Merge pull request #129 from switch-to-gitlab/main

Include SharedWorker in WebWorkerAPI

Author: nojaf

.gitignore

@@ -4,4 +4,5 @@
 .astro
 dist/
 tmp/
-docs/public/llm.txt
+docs/public/llm.txt
+*~

src/WebWorkersAPI.res

@@ -1,4 +1,5 @@
 open EventAPI
+open FetchAPI
 
 /**
 Provides a storage mechanism for Request / Response object pairs that are cached, for example as part of the ServiceWorker life cycle. Note that the Cache interface is exposed to windowed scopes as well as workers. You don't have to use it in conjunction with service workers, even though it is defined in the service worker spec.
@@ -25,6 +26,8 @@ type multiCacheQueryOptions = {
   mutable cacheName?: string,
 }
 
+type sharedWorker
+
 /**
 The WorkerGlobalScope interface of the Web Workers API is an interface representing the scope of any worker.
 Workers have no browsing context; this scope contains the information usually conveyed by Window objects —
@@ -44,3 +47,29 @@ type workerGlobalScope = {
     */
   crossOriginIsolated: bool,
 }
+
+type workerType =
+  | @as("classic") Classic
+  | @as("module") Module
+
+
+/** An object containing option properties that can set when creating the
+object instance. */
+type workerOptions = {
+  @as("type") mutable type_?: workerType,
+  mutable credentials?: requestCredentials,
+  mutable name?: string,
+}
+
+/**
+The `SharedWorkerGlobalScope` object (the `SharedWorker` global scope) is 
+accessible through the self keyword. Some additional global functions, 
+namespaces objects, and constructors, not typically associated with the worker 
+global scope, but available on it, are listed in the JavaScript Reference. See 
+the complete list of functions available to workers.
+*/
+@editor.completeFrom(SharedWorkerGlobalScope)
+type sharedWorkerGlobalScope = {
+  ...workerGlobalScope,
+  name: option<string>
+}

src/WebWorkersAPI/SharedWorker.js

@@ -0,0 +1,69 @@
+open ChannelMessagingAPI
+open WebWorkersAPI
+
+include EventTarget.Impl({
+  type t = sharedWorker
+})
+
+/**
+`make(string)`
+
+The SharedWorker() constructor creates a SharedWorker object that executes the 
+script at the specified URL. This script must obey the same-origin policy.
+
+```res
+let shared: sharedWorker = SharedWorker.make("sharedworker.js")
+```
+
+[Read more on MDN](https://developer.mozilla.org/en-US/docs/Web/API/SharedWorker/)
+*/
+@new
+external make: string => sharedWorker = "SharedWorker"
+
+/**
+`makeWithName(string, string)`
+
+The SharedWorker() constructor creates a SharedWorker object that executes the 
+script at the specified URL. This script must obey the same-origin policy.
+
+```res
+let shared: sharedWorker = SharedWorker.make("sharedworker.js", "name")
+```
+
+[Read more on MDN](https://developer.mozilla.org/en-US/docs/Web/API/SharedWorker/)
+*/
+@new
+external makeWithName: (string, string) => sharedWorker = "SharedWorker"
+
+/**
+`makeWithOptions(string, workerOptions)`
+
+The SharedWorker() constructor creates a SharedWorker object that executes the 
+script at the specified URL. This script must obey the same-origin policy.
+
+```res
+let shared: sharedWorker = SharedWorker.makeWithOptions("sharedworker.js", {
+  name: "workerName",
+  type_: Module
+})
+```
+
+[Read more on MDN](https://developer.mozilla.org/en-US/docs/Web/API/SharedWorker/)
+*/
+@new
+external makeWithOptions: (string, workerOptions) => sharedWorker = "SharedWorker"
+
+/**
+`port(sharedWorker)`
+
+The port property of the SharedWorker interface returns a MessagePort object 
+used to communicate and control the shared worker.
+
+```res
+let port: WebAPI.ChannelMessagingAPI.messagePort = SharedWorker.port(myWorker)
+```
+
+[Read more on MDN](https://developer.mozilla.org/en-US/docs/Web/API/SharedWorker/port)
+*/
+@get
+external port: sharedWorker => messagePort = "port"

src/WebWorkersAPI/SharedWorker.res

@@ -0,0 +1,32 @@
+open WebWorkersAPI
+
+module Impl = (
+  T: {
+    type t
+  },
+) => {
+  include WorkerGlobalScope.Impl({
+    type t = T.t
+  })
+
+  /**
+`close(sharedWorkerGlobalScope)`
+
+The close() method of the SharedWorkerGlobalScope interface discards any tasks 
+queued in the SharedWorkerGlobalScope's event loop, effectively closing this 
+particular scope.
+
+```res
+self -> SharedWorkerGlobalScope.close
+```
+
+[Read more on MDN](https://developer.mozilla.org/en-US/docs/Web/API/SharedWorkerGlobalScope/close)
+*/
+  @send
+  external close: T.t => unit = "close"
+}
+
+include Impl({
+  type t = sharedWorkerGlobalScope
+})
+

src/WebWorkersAPI/SharedWorkerGlobalScope.js

@@ -0,0 +1,7 @@
+open WebAPI.WebWorkersAPI
+
+external getSelf: () => sharedWorkerGlobalScope = "self"
+
+let self = getSelf()
+
+self -> SharedWorkerGlobalScope.close

src/WebWorkersAPI/SharedWorkerGlobalScope.res

@@ -0,0 +1,18 @@
+open WebAPI.WebWorkersAPI
+
+let shared1: sharedWorker = SharedWorker.make("sharedworker.js")
+
+let shared2: sharedWorker = SharedWorker.makeWithName("sharedworker.js", "name")
+
+let shared3: sharedWorker = SharedWorker.makeWithOptions("sharedworker.js", {
+  name: "workerName",
+  type_: Module
+})
+
+let port: WebAPI.ChannelMessagingAPI.messagePort = SharedWorker.port(shared1)
+
+external getSelf: () => sharedWorkerGlobalScope = "self"
+
+let self = getSelf()
+
+self -> SharedWorkerGlobalScope.close