j-templates 9.0.1 → 10.0.0

package/Store/Diff/diffTreeWriter.js

@@ -1,137 +0,0 @@
-import { DiffTree } from "./diffTree";
-import { DIFF_TREE_ERROR, DIFF_TREE_EVENT } from "./diffTree.types";
-/**
- * A `DiffTree` that pushes its changes to a `PushStore` instead of answering a store's
- * requests. Use it inside a worker that produces data itself (for example, the result of a
- * computation it runs): write with the usual `DiffTree` methods, then call `Commit()` to run
- * projections and post everything since the last commit as one message.
- *
- * - Push only: don't pass a `DiffTreeWriter` to `ConnectWorkerToDiffTree`, which commits
- *   every batch itself and would post it to the wrong place.
- * - After a change fails, every later change before `Commit()` throws that same error. The
- *   changes made before the failure are already in the tree, so `Commit()` still sends them,
- *   followed by a `DIFF_TREE_ERROR` message. Projections aren't run for that batch; the next
- *   `Commit()` brings them up to date.
- * - A `PushStore` only receives the changes committed after it starts listening, so
- *   create it before the writer's first `Commit()`.
- *
- * @example
- * // engine-worker.ts
- * const tree = new DiffTreeWriter(self, undefined, { "/": { projections } });
- * tree.WritePath("results", computeResults());
- * tree.Commit();
- *
- * // main thread
- * const store = new PushStore(worker);
- *
- * @see PushStore
- */
-export class DiffTreeWriter extends DiffTree {
-    /**
-     * Creates a DiffTreeWriter.
-     * @param worker Where `Commit()` posts its messages: the worker's `self`, or a `MessagePort`.
-     *   On the same thread as the store, anything whose `postMessage` dispatches a `"message"`
-     *   event on the store's `EventTarget`. The store clones every value it applies, so it never
-     *   shares objects with the writer's tree.
-     * @param keyFunc Optional function to extract a key from objects. Pass the same key logic to
-     *   the `PushStore` that receives the changes.
-     * @param routes Optional route definitions. Projections run once per `Commit()`, after the
-     *   batch's changes.
-     */
-    constructor(worker, keyFunc, routes) {
-        super(keyFunc, routes);
-        this.worker = worker;
-        this.uncommittedError = null;
-    }
-    /**
-     * Not available on a DiffTreeWriter: `Commit()` runs projections once per batch, after its
-     * changes. Running them earlier would push a projection result computed from part of a batch.
-     * @throws Always.
-     */
-    RunProjections() {
-        throw new Error("RunProjections is called during Commit()");
-    }
-    /**
-     * Writes a value at a path.
-     * @throws The change's error, or an earlier uncommitted change's error.
-     */
-    WritePath(path, value) {
-        this.Guard(() => super.WritePath(path, value));
-    }
-    /**
-     * Merges a patch into the current value at a path.
-     * @throws The change's error, or an earlier uncommitted change's error.
-     */
-    PatchPath(path, patch) {
-        this.Guard(() => super.PatchPath(path, patch));
-    }
-    /**
-     * Appends items to the array at a path.
-     * @throws The change's error, or an earlier uncommitted change's error.
-     */
-    PushPath(path, items) {
-        this.Guard(() => super.PushPath(path, items));
-    }
-    /**
-     * Splices the array at a path.
-     * @throws The change's error, or an earlier uncommitted change's error.
-     */
-    SplicePath(path, start, deleteCount, items) {
-        this.Guard(() => super.SplicePath(path, start, deleteCount, items));
-    }
-    /**
-     * Deletes a route, its child routes and its route instances.
-     * @throws The change's error, or an earlier uncommitted change's error.
-     */
-    DeleteRoute(routePath) {
-        this.Guard(() => super.DeleteRoute(routePath));
-    }
-    /**
-     * Runs projections and posts every change since the last commit as one `DIFF_TREE_EVENT`
-     * message, which a `PushStore` applies as a unit. Posts nothing when nothing changed.
-     *
-     * If a change in the batch failed, projections are skipped, the applied changes are still
-     * posted, and a `DIFF_TREE_ERROR` message follows with the error; `Commit()` itself doesn't
-     * throw, since the failed change already did. If a projection throws, the batch's changes
-     * and the error are posted the same way, then `Commit()` rethrows. Either way the next batch
-     * starts clean.
-     * @returns The diff that was posted.
-     * @throws A projection's error.
-     */
-    Commit() {
-        let diff = [];
-        try {
-            !this.uncommittedError && super.RunProjections();
-        }
-        catch (err) {
-            this.uncommittedError = err;
-            throw err;
-        }
-        finally {
-            diff = super.Commit();
-            diff.length > 0 && this.worker.postMessage({
-                type: DIFF_TREE_EVENT,
-                data: diff
-            });
-            if (this.uncommittedError) {
-                this.worker.postMessage({
-                    type: DIFF_TREE_ERROR,
-                    data: this.uncommittedError
-                });
-            }
-            this.uncommittedError = null;
-        }
-        return diff;
-    }
-    Guard(change) {
-        if (this.uncommittedError)
-            throw this.uncommittedError;
-        try {
-            change();
-        }
-        catch (err) {
-            this.uncommittedError = err;
-            throw err;
-        }
-    }
-}

package/Store/Diff/workerQueue.d.ts

@@ -1,7 +0,0 @@
-export declare class WorkerQueue<S, R> {
-    private callbacks;
-    private worker;
-    constructor(worker: Worker);
-    Push(message: S): Promise<R>;
-    Destroy(): void;
-}

package/Store/Diff/workerQueue.js

@@ -1,29 +0,0 @@
-import { List } from "../../Utils/list";
-export class WorkerQueue {
-    constructor(worker) {
-        this.worker = worker;
-        this.callbacks = List.Create();
-        this.worker.onerror = (err) => {
-            const cb = List.Pop(this.callbacks);
-            cb && cb(null, err);
-        };
-        this.worker.onmessage = (message) => {
-            const cb = List.Pop(this.callbacks);
-            cb && cb(message.data);
-        };
-    }
-    Push(message) {
-        return new Promise((resolve, reject) => {
-            List.Add(this.callbacks, function (data, err) {
-                if (err)
-                    reject(err);
-                else
-                    resolve(data);
-            });
-            this.worker.postMessage(message);
-        });
-    }
-    Destroy() {
-        this.worker.terminate();
-    }
-}

package/Store/Store/pushStore.d.ts

@@ -1,53 +0,0 @@
-import { ReadStore } from "./store";
-/**
- * A read-only store whose changes are pushed to it by a `DiffTreeWriter`. The writer decides
- * when data changes and pushes it with `Commit()`; this store applies each pushed batch as it
- * arrives, and readers update the same way they do for any other store.
- *
- * The source is any `EventTarget` that delivers the writer's messages as `"message"` events:
- * usually a `Worker` or a `MessagePort`, or a plain `EventTarget` when the writer runs on the
- * same thread. The store ignores any message that isn't a `DIFF_TREE_EVENT` or
- * `DIFF_TREE_ERROR`, so the source can carry other traffic too. It never takes over the
- * source's `onmessage` or terminates a worker; that stays with the source's owner. It doesn't
- * listen for the source's `"error"` events either: the writer's errors arrive as
- * `DIFF_TREE_ERROR` messages (see `Error`).
- *
- * Changes are diffs against the writer's tree, so create the store before the writer's
- * first `Commit()`. A store created later misses the earlier changes.
- *
- * @example
- * const worker = new Worker(new URL("./engine-worker.ts", import.meta.url), { type: "module" });
- * const store = new PushStore(worker);
- * store.Get<Results>("results");   // reactive; undefined until the first commit
- * store.Destroy();                 // stops listening; doesn't terminate the worker
- *
- * @see DiffTreeWriter
- * @see StoreAsync
- */
-export declare class PushStore extends ReadStore {
-    private eventTarget;
-    private error;
-    private errorScope;
-    /**
-     * The error the writer reported with its last commit, or null. Reactive. It's cleared when
-     * a later commit's changes arrive, so it reflects the most recent push, not a stopped store:
-     * the writer's later changes are still applied after an error.
-     */
-    get Error(): any;
-    private messageHandler;
-    /**
-     * Creates a PushStore and starts listening to the source. A `MessagePort` is started for
-     * you, since `addEventListener` doesn't start a port the way assigning `onmessage` does.
-     * @param eventTarget The source of the `DiffTreeWriter`'s messages: a `Worker`, a
-     *   `MessagePort`, or any `EventTarget` that dispatches them as `"message"` events.
-     * @param keyFunc Optional function to generate a key for a given data value, used to
-     *   resolve root objects. Pass the same key logic the `DiffTreeWriter` was constructed
-     *   with, if any.
-     */
-    constructor(eventTarget: EventTarget, keyFunc?: (value: any) => string | undefined);
-    /**
-     * Stops listening to the source and destroys the error scope. The source stays open (a
-     * worker keeps running); closing or terminating it is up to its owner.
-     */
-    Destroy(): void;
-}

package/Store/Store/pushStore.js

@@ -1,77 +0,0 @@
-import { DIFF_TREE_ERROR, DIFF_TREE_EVENT } from "../Diff/diffTree.types";
-import { ObservableScope } from "../Tree/observableScope";
-import { ReadStore } from "./store";
-/**
- * A read-only store whose changes are pushed to it by a `DiffTreeWriter`. The writer decides
- * when data changes and pushes it with `Commit()`; this store applies each pushed batch as it
- * arrives, and readers update the same way they do for any other store.
- *
- * The source is any `EventTarget` that delivers the writer's messages as `"message"` events:
- * usually a `Worker` or a `MessagePort`, or a plain `EventTarget` when the writer runs on the
- * same thread. The store ignores any message that isn't a `DIFF_TREE_EVENT` or
- * `DIFF_TREE_ERROR`, so the source can carry other traffic too. It never takes over the
- * source's `onmessage` or terminates a worker; that stays with the source's owner. It doesn't
- * listen for the source's `"error"` events either: the writer's errors arrive as
- * `DIFF_TREE_ERROR` messages (see `Error`).
- *
- * Changes are diffs against the writer's tree, so create the store before the writer's
- * first `Commit()`. A store created later misses the earlier changes.
- *
- * @example
- * const worker = new Worker(new URL("./engine-worker.ts", import.meta.url), { type: "module" });
- * const store = new PushStore(worker);
- * store.Get<Results>("results");   // reactive; undefined until the first commit
- * store.Destroy();                 // stops listening; doesn't terminate the worker
- *
- * @see DiffTreeWriter
- * @see StoreAsync
- */
-export class PushStore extends ReadStore {
-    /**
-     * The error the writer reported with its last commit, or null. Reactive. It's cleared when
-     * a later commit's changes arrive, so it reflects the most recent push, not a stopped store:
-     * the writer's later changes are still applied after an error.
-     */
-    get Error() {
-        return ObservableScope.Value(this.errorScope);
-    }
-    /**
-     * Creates a PushStore and starts listening to the source. A `MessagePort` is started for
-     * you, since `addEventListener` doesn't start a port the way assigning `onmessage` does.
-     * @param eventTarget The source of the `DiffTreeWriter`'s messages: a `Worker`, a
-     *   `MessagePort`, or any `EventTarget` that dispatches them as `"message"` events.
-     * @param keyFunc Optional function to generate a key for a given data value, used to
-     *   resolve root objects. Pass the same key logic the `DiffTreeWriter` was constructed
-     *   with, if any.
-     */
-    constructor(eventTarget, keyFunc) {
-        super(keyFunc);
-        this.eventTarget = eventTarget;
-        this.error = null;
-        this.errorScope = ObservableScope.Basic(() => this.error);
-        this.messageHandler = (event) => {
-            const messageData = event.data;
-            if (messageData && messageData.type === DIFF_TREE_EVENT) {
-                this.UpdateRootMap(messageData.data);
-                if (this.error !== null) {
-                    this.error = null;
-                    ObservableScope.Update(this.errorScope);
-                }
-            }
-            else if (messageData && messageData.type === DIFF_TREE_ERROR) {
-                this.error = messageData.data;
-                ObservableScope.Update(this.errorScope);
-            }
-        };
-        eventTarget.addEventListener("message", this.messageHandler);
-        eventTarget.start?.();
-    }
-    /**
-     * Stops listening to the source and destroys the error scope. The source stays open (a
-     * worker keeps running); closing or terminating it is up to its owner.
-     */
-    Destroy() {
-        this.eventTarget.removeEventListener("message", this.messageHandler);
-        ObservableScope.Destroy(this.errorScope);
-    }
-}