@effectionx/worker 0.1.1

package/esm/worker.js

@@ -0,0 +1,237 @@
+import { assert } from "./deps/jsr.io/@std/assert/1.0.12/mod.js";
+import { createSignal, each, Err, main, Ok, on, once, resource, scoped, spawn, withResolvers, } from "effection";
+/**
+ * Entrypoint used in the worker that estaliblishes communication
+ * with the main thread. It can be used to return a value,
+ * respond to messages or both.
+ *
+ * @example Returning a value
+ * ```ts
+ * import { workerMain } from "../worker.ts";
+ *
+ * await workerMain(function* ({ data }) {
+ *  return data;
+ * });
+ * ```
+ *
+ * @example Responding to messages
+ * ```ts
+ * import { workerMain } from "../worker.ts";
+ *
+ * await workerMain(function* ({ messages }) {
+ *  yield* messages.forEach(function* (message) {
+ *    return message;
+ *  });
+ * });
+ * ```
+ *
+ * @example Responding to messages and return a value
+ * ```ts
+ * import { workerMain } from "../worker.ts";
+ *
+ * await workerMain<number, number, number, number>(
+ *   function* ({ messages, data: initial }) {
+ *     let counter = initial;
+ *
+ *     yield* messages.forEach(function* (message) {
+ *       counter += message;
+ *       return counter; // returns a value after each message
+ *     });
+ *
+ *     return counter; // returns the final value
+ *   },
+ * );
+ * ```
+ *
+ * @template TSend - value main thread will send to the worker
+ * @template TRecv - value main thread will receive from the worker
+ * @template TReturn - worker operation return value
+ * @template TData - data passed from the main thread to the worker during initialization
+ * @param {(options: WorkerMainOptions<TSend, TRecv, TData>) => Operation<TReturn>} body
+ * @returns {Promise<void>}
+ */
+export async function workerMain(body) {
+    await main(function* () {
+        let sent = createSignal();
+        let controls = yield* on(self, "message");
+        let outcome = withResolvers();
+        self.postMessage({ type: "open" });
+        let result = yield* scoped(function* () {
+            yield* spawn(function* () {
+                let next = yield* controls.next();
+                while (true) {
+                    let control = next.value.data;
+                    if (control.type === "init") {
+                        yield* spawn(function* () {
+                            try {
+                                let value = yield* body({
+                                    data: control.data,
+                                    messages: {
+                                        *forEach(fn) {
+                                            for (let { value, response } of yield* each(sent)) {
+                                                yield* spawn(function* () {
+                                                    try {
+                                                        let result = yield* fn(value);
+                                                        response.postMessage(Ok(result));
+                                                    }
+                                                    catch (error) {
+                                                        response.postMessage(Err(error));
+                                                    }
+                                                });
+                                                yield* each.next();
+                                            }
+                                        },
+                                    },
+                                });
+                                outcome.resolve(Ok(value));
+                            }
+                            catch (error) {
+                                outcome.resolve(Err(error));
+                            }
+                        });
+                    }
+                    else if (control.type === "send") {
+                        let { value, response } = control;
+                        sent.send({ value, response });
+                    }
+                    else if (control.type === "close") {
+                        outcome.resolve(Err(new Error(`worker terminated`)));
+                    }
+                    next = yield* controls.next();
+                }
+            });
+            return yield* outcome.operation;
+        });
+        self.postMessage({ type: "close", result });
+    });
+}
+/**
+ * Use on the main thread to create and exeecute a well behaved web worker.
+ *
+ * @example Compute a single value
+ * ```ts
+ * import { run } from "effection";
+ * import { useWorker } from "@effectionx/worker"
+ *
+ * await run(function*() {
+ *    const worker = yield* useWorker("script.ts", { type: "module" });
+ *
+ *    try {
+ *      const result = yield* worker;
+ *    } catch (e) {
+ *      console.error(e);
+ *    }
+ * });
+ * ```
+ *
+ * @example Compute multipe values
+ * ```ts
+ * import { run } from "effection";
+ * import { useWorker } from "@effectionx/worker"
+ *
+ * await run(function*() {
+ *    const worker = yield* useWorker("script.ts", { type: "module" });
+ *
+ *    try {
+ *      const result1 = yield* worker.send("Tom");
+ *      const result2 = yield* worker.send("Dick");
+ *      const result2 = yield* worker.send("Harry");
+ *
+ *      // get the last result
+ *      const finalResult = yield* worker;
+ *    } catch (e) {
+ *      console.error(e);
+ *    }
+ * });
+ * ```
+ *
+ * @param url URL or string of script
+ * @param options WorkerOptions
+ * @template TSend - value main thread will send to the worker
+ * @template TRecv - value main thread will receive from the worker
+ * @template TReturn - worker operation return value
+ * @template TData - data passed from the main thread to the worker during initialization
+ * @returns {Operation<WorkerResource<TSend, TRecv>>}
+ */
+export function useWorker(url, options) {
+    return resource(function* (provide) {
+        let outcome = withResolvers();
+        let worker = new Worker(url, options);
+        let subscription = yield* on(worker, "message");
+        let onclose = (event) => {
+            if (event.data.type === "close") {
+                let { result } = event.data;
+                if (result.ok) {
+                    outcome.resolve(result.value);
+                }
+                else {
+                    outcome.reject(result.error);
+                }
+            }
+        };
+        worker.addEventListener("message", onclose);
+        let first = yield* subscription.next();
+        assert(first.value.data.type === "open", `expected first message to arrive from worker to be of type "open", but was: ${first.value.data.type}`);
+        yield* spawn(function* () {
+            let event = yield* once(worker, "error");
+            event.preventDefault();
+            throw event.error;
+        });
+        try {
+            worker.postMessage({
+                type: "init",
+                data: options?.data,
+            });
+            yield* provide({
+                *send(value) {
+                    let channel = yield* useMessageChannel();
+                    worker.postMessage({
+                        type: "send",
+                        value,
+                        response: channel.port2,
+                    }, [channel.port2]);
+                    channel.port1.start();
+                    let event = yield* once(channel.port1, "message");
+                    let result = event.data;
+                    if (result.ok) {
+                        return result.value;
+                    }
+                    else {
+                        throw result.error;
+                    }
+                },
+                [Symbol.iterator]: outcome.operation[Symbol.iterator],
+            });
+        }
+        finally {
+            worker.postMessage({ type: "close" });
+            yield* settled(outcome.operation);
+            worker.removeEventListener("message", onclose);
+        }
+    });
+}
+function useMessageChannel() {
+    return resource(function* (provide) {
+        let channel = new MessageChannel();
+        try {
+            yield* provide(channel);
+        }
+        finally {
+            channel.port1.close();
+            channel.port2.close();
+        }
+    });
+}
+function settled(operation) {
+    return {
+        *[Symbol.iterator]() {
+            try {
+                yield* operation;
+                return Ok();
+            }
+            catch (error) {
+                return Err(error);
+            }
+        },
+    };
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@effectionx/worker",
+  "version": "0.1.1",
+  "author": "engineering@frontside.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thefrontside/effectionx.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/thefrontside/effectionx/issues"
+  },
+  "main": "./script/mod.js",
+  "module": "./esm/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/mod.js",
+      "require": "./script/mod.js"
+    }
+  },
+  "engines": {
+    "node": ">= 16"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "effection": "4.0.0-alpha.4"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/_dnt.shims.d.ts

@@ -0,0 +1,2 @@
+export declare const dntGlobalThis: Omit<typeof globalThis, never>;
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/script/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gCAA2C,CAAC"}

package/script/_dnt.shims.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = void 0;
+const dntGlobals = {};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/deps/jsr.io/@std/assert/1.0.12/almost_equals.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Make an assertion that `actual` and `expected` are almost equal numbers
+ * through a given tolerance. It can be used to take into account IEEE-754
+ * double-precision floating-point representation limitations. If the values
+ * are not almost equal then throw.
+ *
+ * The default tolerance is one hundred thousandth of a percent of the
+ * expected value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertAlmostEquals } from "@std/assert";
+ *
+ * assertAlmostEquals(0.01, 0.02); // Throws
+ * assertAlmostEquals(1e-8, 1e-9); // Throws
+ * assertAlmostEquals(1.000000001e-8, 1.000000002e-8); // Doesn't throw
+ * assertAlmostEquals(0.01, 0.02, 0.1); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17); // Throws
+ * ```
+ *
+ * @param actual The actual value to compare.
+ * @param expected The expected value to compare.
+ * @param tolerance The tolerance to consider the values almost equal. The
+ * default is one hundred thousandth of a percent of the expected value.
+ * @param msg The optional message to include in the error.
+ */
+export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;
+//# sourceMappingURL=almost_equals.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.12/almost_equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"almost_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.12/almost_equals.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,EAClB,GAAG,CAAC,EAAE,MAAM,QAmBb"}

package/script/deps/jsr.io/@std/assert/1.0.12/almost_equals.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertAlmostEquals = assertAlmostEquals;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion that `actual` and `expected` are almost equal numbers
+ * through a given tolerance. It can be used to take into account IEEE-754
+ * double-precision floating-point representation limitations. If the values
+ * are not almost equal then throw.
+ *
+ * The default tolerance is one hundred thousandth of a percent of the
+ * expected value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertAlmostEquals } from "@std/assert";
+ *
+ * assertAlmostEquals(0.01, 0.02); // Throws
+ * assertAlmostEquals(1e-8, 1e-9); // Throws
+ * assertAlmostEquals(1.000000001e-8, 1.000000002e-8); // Doesn't throw
+ * assertAlmostEquals(0.01, 0.02, 0.1); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17); // Throws
+ * ```
+ *
+ * @param actual The actual value to compare.
+ * @param expected The expected value to compare.
+ * @param tolerance The tolerance to consider the values almost equal. The
+ * default is one hundred thousandth of a percent of the expected value.
+ * @param msg The optional message to include in the error.
+ */
+function assertAlmostEquals(actual, expected, tolerance, msg) {
+    if (Object.is(actual, expected)) {
+        return;
+    }
+    const delta = Math.abs(expected - actual);
+    if (tolerance === undefined) {
+        tolerance = isFinite(expected) ? Math.abs(expected * 1e-7) : 1e-7;
+    }
+    if (delta <= tolerance) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    const f = (n) => Number.isInteger(n) ? n : n.toExponential();
+    throw new assertion_error_js_1.AssertionError(`Expected actual: "${f(actual)}" to be close to "${f(expected)}": \
+delta "${f(delta)}" is greater than "${f(tolerance)}"${msgSuffix}`);
+}

package/script/deps/jsr.io/@std/assert/1.0.12/array_includes.d.ts

@@ -0,0 +1,24 @@
+/** An array-like object (`Array`, `Uint8Array`, `NodeList`, etc.) that is not a string */
+export type ArrayLikeArg<T> = ArrayLike<T> & object;
+/**
+ * Make an assertion that `actual` includes the `expected` values. If not then
+ * an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the
+ * same type.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertArrayIncludes } from "@std/assert";
+ *
+ * assertArrayIncludes([1, 2], [2]); // Doesn't throw
+ * assertArrayIncludes([1, 2], [3]); // Throws
+ * ```
+ *
+ * @typeParam T The type of the elements in the array to compare.
+ * @param actual The array-like object to check for.
+ * @param expected The array-like object to check for.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assertArrayIncludes<T>(actual: ArrayLikeArg<T>, expected: ArrayLikeArg<T>, msg?: string): void;
+//# sourceMappingURL=array_includes.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.12/array_includes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_includes.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.12/array_includes.ts"],"names":[],"mappings":"AAMA,0FAA0F;AAC1F,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EACvB,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,EACzB,GAAG,CAAC,EAAE,MAAM,QAwBb"}

package/script/deps/jsr.io/@std/assert/1.0.12/array_includes.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertArrayIncludes = assertArrayIncludes;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const equal_js_1 = require("./equal.js");
+const format_js_1 = require("../../internal/1.0.6/format.js");
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion that `actual` includes the `expected` values. If not then
+ * an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the
+ * same type.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertArrayIncludes } from "@std/assert";
+ *
+ * assertArrayIncludes([1, 2], [2]); // Doesn't throw
+ * assertArrayIncludes([1, 2], [3]); // Throws
+ * ```
+ *
+ * @typeParam T The type of the elements in the array to compare.
+ * @param actual The array-like object to check for.
+ * @param expected The array-like object to check for.
+ * @param msg The optional message to display if the assertion fails.
+ */
+function assertArrayIncludes(actual, expected, msg) {
+    const missing = [];
+    for (let i = 0; i < expected.length; i++) {
+        let found = false;
+        for (let j = 0; j < actual.length; j++) {
+            if ((0, equal_js_1.equal)(expected[i], actual[j])) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            missing.push(expected[i]);
+        }
+    }
+    if (missing.length === 0) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg = `Expected actual: "${(0, format_js_1.format)(actual)}" to include: "${(0, format_js_1.format)(expected)}"${msgSuffix}\nmissing: ${(0, format_js_1.format)(missing)}`;
+    throw new assertion_error_js_1.AssertionError(msg);
+}

package/script/deps/jsr.io/@std/assert/1.0.12/assert.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assert } from "@std/assert";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assert(expr: unknown, msg?: string): asserts expr;
+//# sourceMappingURL=assert.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.12/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.12/assert.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAI5D"}

package/script/deps/jsr.io/@std/assert/1.0.12/assert.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = assert;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assert } from "@std/assert";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ *
+ * @param expr The expression to test.
+ * @param msg The optional message to display if the assertion fails.
+ */
+function assert(expr, msg = "") {
+    if (!expr) {
+        throw new assertion_error_js_1.AssertionError(msg);
+    }
+}

package/script/deps/jsr.io/@std/assert/1.0.12/assertion_error.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+export declare class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=assertion_error.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.12/assertion_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion_error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.12/assertion_error.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD"}

package/script/deps/jsr.io/@std/assert/1.0.12/assertion_error.js

@@ -0,0 +1,34 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertionError = void 0;
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message, options) {
+        super(message, options);
+        this.name = "AssertionError";
+    }
+}
+exports.AssertionError = AssertionError;

package/script/deps/jsr.io/@std/assert/1.0.12/equal.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Deep equality comparison used in assertions.
+ *
+ * @param a The actual value
+ * @param b The expected value
+ * @returns `true` if the values are deeply equal, `false` otherwise
+ *
+ * @example Usage
+ * ```ts
+ * import { equal } from "@std/assert/equal";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false`
+ * ```
+ */
+export declare function equal(a: unknown, b: unknown): boolean;
+//# sourceMappingURL=equal.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.12/equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.12/equal.ts"],"names":[],"mappings":"AA2FA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAuGrD"}