@xmachines/play-actor 3.0.0 → 4.0.0

package/dist/failure-latch.d.ts

@@ -1,157 +0,0 @@
-/**
- * The report rules of a provider, in one place.
- *
- * A provider resolves the store from three inputs — the actor, the view, and the store of
- * the caller — and it reports a failure of that resolution to `onError`. This module holds
- * the three rules that every renderer had written for itself, beside
- * {@link createViewStoreLifecycle}, which already receives the same three inputs on every
- * resolve:
- *
- * - {@link sameViewInputs} answers whether two attempts carry the SAME three inputs.
- * - {@link createFailureLatch} reports ONE time for one set of those three. The render
- *   path of a provider runs again for every tracked change, and a parent that renders
- *   hands the props over again, so a report on each attempt gives the host one failure
- *   many times.
- * - {@link createReportGuard} keeps the host from defeating the containment: a reset that
- *   the host starts from INSIDE the report does nothing, a reset after the provider is
- *   gone does nothing, and a handler that THROWS is contained where the renderer needs it.
- *
- * The copies disagreed. play-vue held a boolean and cleared it at four sites, play-svelte
- * held the three inputs and kept them across a null emission, and play-solid held nothing
- * at all while the comment of play-vue said that it did.
- *
- * @packageDocumentation
- */
-/**
- * The three inputs that a provider resolves a store from.
- *
- * `ViewStoreLifecycle.resolve` takes exactly these, and every provider names all three in
- * its reset rule. The type gives the rule one name, so the comparison below stands one
- * time instead of once for each renderer that needs it.
- */
-export interface ViewInputs {
-    actor: unknown;
-    view: unknown;
-    store: unknown;
-}
-/**
- * Answers whether two sets of inputs are the SAME attempt.
- *
- * Identity, and not a deep compare: a provider holds the references that it rendered, and
- * a new spec object is a new attempt even when it holds equal fields.
- */
-export declare function sameViewInputs(a: ViewInputs, b: ViewInputs): boolean;
-/**
- * A report guard of one provider.
- *
- * The rule it holds: a provider reports a contained failure to the host, and it must do
- * that without letting the host defeat the containment. Two things follow — a reset that
- * the host calls from INSIDE the report does nothing, because no input changed between
- * the two attempts; and every callback that the provider handed out does nothing once the
- * provider is gone, because a host can keep a reset (a "Retry" button of a toast outlives
- * the route that opened it).
- */
-export interface ReportGuard {
-    /** True when a reset that the host starts must do nothing. */
-    blocked(): boolean;
-    /**
-     * True once {@link ReportGuard.dispose} ran, and never for a report that runs.
-     *
-     * {@link ReportGuard.blocked} answers a different question: it is true for the
-     * re-entry of a report as well, and it goes back to false when that report ends. A
-     * caller that asks whether the guard is SPENT — play-react builds one again after the
-     * cleanup of `<StrictMode>` disposed it — must read this one: `blocked()` there would
-     * replace a live guard that is reporting, and the `finally` of that report would then
-     * clear the re-entry flag of a guard that nobody holds.
-     */
-    disposed(): boolean;
-    /** The provider is gone. */
-    dispose(): void;
-    /**
-     * Delivers one report, with the re-entry flag held for the call.
-     *
-     * @param error - The contained failure.
-     * @param deliver - The call of the handler of the host, or `undefined` when the host
-     *   gave none. Without a handler the guard writes {@link ReportGuardMessages.noHandler}
-     *   to `console.error`: a contained failure that reaches no handler and no caller is
-     *   the one result that nobody can debug. A handler that THROWS is contained where the
-     *   guard carries {@link ReportGuardMessages.handlerThrew}, and it reaches the caller
-     *   where it does not.
-     */
-    report(error: unknown, deliver: (() => void) | undefined): void;
-}
-/**
- * What a {@link ReportGuard} writes to `console.error`, and what it therefore contains.
- *
- * Each message is optional, and each one is a DECISION of the renderer that builds the
- * guard. The rule that both serve is one rule: a contained failure is never silent, and
- * a handler of the host never defeats the containment.
- */
-export interface ReportGuardMessages {
-    /**
-     * What `console.error` says when the host gave no handler.
-     *
-     * Omit it where the framework writes such a failure itself: React logs an error that
-     * a boundary caught, so play-react would report the same failure two times.
-     */
-    noHandler?: string;
-    /**
-     * What `console.error` says when the handler of the host THROWS.
-     *
-     * A guard that carries this message CONTAINS such a throw. All five renderers carry it,
-     * so a host learns one rule: a handler of the host never defeats the containment, and a
-     * host that must escalate raises the failure from a task of its own —
-     * `queueMicrotask(() => { throw error; })`. Omit it only where a throw must reach the
-     * caller, which no renderer of this workspace asks for today.
-     *
-     * A renderer needs the containment when a throw that leaves the report also stops the
-     * screen of the fallback: the flag of play-vue schedules a render, the fallback of
-     * play-solid is the RETURN of the callback that reports, `componentDidCatch` of
-     * play-react can take the complete React root down, and a throw that leaves the
-     * `onerror` of Svelte leaves its own `calling_on_error` flag raised, which makes every
-     * later reset of the host raise `svelte_boundary_reset_onerror`.
-     */
-    handlerThrew?: string;
-}
-/**
- * Makes a {@link ReportGuard}.
- *
- * The flag SAVES and restores, and it is no plain `false` at the end: a handler of the
- * host can start a second contained failure inside the first — a fallback that throws, a
- * write of the store that drives another emission — and a bare reset in the inner
- * `finally` would clear the guard while the outer report still runs.
- *
- * @param messages - See {@link ReportGuardMessages}. The two messages say what the guard
- *   writes to `console.error`, and the absence of one says what it lets through.
- */
-export declare function createReportGuard(messages: ReportGuardMessages): ReportGuard;
-/** The record of what a provider reported. See {@link createFailureLatch}. */
-export interface FailureLatch {
-    /**
-     * Answers whether a failure of these three inputs is new, and records it.
-     *
-     * @returns `true` the first time for one set of inputs, and `false` for every repeat
-     *   of the same set. A caller reports only when it returns `true`.
-     */
-    shouldReport(actor: unknown, view: unknown, store: unknown): boolean;
-    /**
-     * Forgets the record, so the next failure reports again.
-     *
-     * A caller clears it on EVERY emission of a view, the null emission included: a view,
-     * then null, then the same view is a real sequence of an actor, and the second failure
-     * of that view is a second attempt that the host must hear about. It also clears it on
-     * a resolution that works, and on a retry that the host starts — the host asked for
-     * that attempt, so it must hear the result.
-     */
-    clear(): void;
-}
-/**
- * Makes a {@link FailureLatch}.
- *
- * The latch holds the three inputs BESIDE the flag. Clearing on each emission would be
- * enough for a provider that can hook every emission, and the identity check covers the
- * one that cannot: a render that runs again with nothing changed reports nothing, whether
- * or not the provider noticed that it ran.
- */
-export declare function createFailureLatch(): FailureLatch;
-//# sourceMappingURL=failure-latch.d.ts.map

package/dist/failure-latch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"failure-latch.d.ts","sourceRoot":"","sources":["../src/failure-latch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAEpE;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC3B,8DAA8D;IAC9D,OAAO,IAAI,OAAO,CAAC;IACnB;;;;;;;;;OASG;IACH,QAAQ,IAAI,OAAO,CAAC;IACpB,4BAA4B;IAC5B,OAAO,IAAI,IAAI,CAAC;IAChB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC;CAChE;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IACnC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;;;;;;;;OAeG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,WAAW,CAqC5E;AAED,8EAA8E;AAC9E,MAAM,WAAW,YAAY;IAC5B;;;;;OAKG;IACH,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IACrE;;;;;;;;OAQG;IACH,KAAK,IAAI,IAAI,CAAC;CACd;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,CAgBjD"}

package/dist/failure-latch.js

@@ -1,110 +0,0 @@
-/**
- * The report rules of a provider, in one place.
- *
- * A provider resolves the store from three inputs — the actor, the view, and the store of
- * the caller — and it reports a failure of that resolution to `onError`. This module holds
- * the three rules that every renderer had written for itself, beside
- * {@link createViewStoreLifecycle}, which already receives the same three inputs on every
- * resolve:
- *
- * - {@link sameViewInputs} answers whether two attempts carry the SAME three inputs.
- * - {@link createFailureLatch} reports ONE time for one set of those three. The render
- *   path of a provider runs again for every tracked change, and a parent that renders
- *   hands the props over again, so a report on each attempt gives the host one failure
- *   many times.
- * - {@link createReportGuard} keeps the host from defeating the containment: a reset that
- *   the host starts from INSIDE the report does nothing, a reset after the provider is
- *   gone does nothing, and a handler that THROWS is contained where the renderer needs it.
- *
- * The copies disagreed. play-vue held a boolean and cleared it at four sites, play-svelte
- * held the three inputs and kept them across a null emission, and play-solid held nothing
- * at all while the comment of play-vue said that it did.
- *
- * @packageDocumentation
- */
-/**
- * Answers whether two sets of inputs are the SAME attempt.
- *
- * Identity, and not a deep compare: a provider holds the references that it rendered, and
- * a new spec object is a new attempt even when it holds equal fields.
- */
-export function sameViewInputs(a, b) {
-    return a.actor === b.actor && a.view === b.view && a.store === b.store;
-}
-/**
- * Makes a {@link ReportGuard}.
- *
- * The flag SAVES and restores, and it is no plain `false` at the end: a handler of the
- * host can start a second contained failure inside the first — a fallback that throws, a
- * write of the store that drives another emission — and a bare reset in the inner
- * `finally` would clear the guard while the outer report still runs.
- *
- * @param messages - See {@link ReportGuardMessages}. The two messages say what the guard
- *   writes to `console.error`, and the absence of one says what it lets through.
- */
-export function createReportGuard(messages) {
-    const { noHandler, handlerThrew } = messages;
-    let disposed = false;
-    let reporting = false;
-    return {
-        blocked: () => disposed || reporting,
-        disposed: () => disposed,
-        dispose() {
-            disposed = true;
-        },
-        report(error, deliver) {
-            const wasReporting = reporting;
-            reporting = true;
-            try {
-                if (!deliver) {
-                    if (noHandler !== undefined)
-                        console.error(noHandler, error);
-                    return;
-                }
-                if (handlerThrew === undefined) {
-                    deliver();
-                    return;
-                }
-                // The containment of a handler that throws. The failure belongs to the host,
-                // and it stops here: a throw that leaves this call reaches the framework of
-                // the caller, which is the path that the boundary of the renderer closes.
-                // Write it where a caller can find it.
-                try {
-                    deliver();
-                }
-                catch (handlerFailure) {
-                    console.error(handlerThrew, handlerFailure);
-                }
-            }
-            finally {
-                reporting = wasReporting;
-            }
-        },
-    };
-}
-/**
- * Makes a {@link FailureLatch}.
- *
- * The latch holds the three inputs BESIDE the flag. Clearing on each emission would be
- * enough for a provider that can hook every emission, and the identity check covers the
- * one that cannot: a render that runs again with nothing changed reports nothing, whether
- * or not the provider noticed that it ran.
- */
-export function createFailureLatch() {
-    // ONE record of the three inputs, and `null` for "nothing reported yet". A flag beside
-    // three loose fields says the same thing two times, and the two can disagree.
-    let last = null;
-    return {
-        shouldReport(actor, view, store) {
-            const next = { actor, view, store };
-            if (last !== null && sameViewInputs(last, next))
-                return false;
-            last = next;
-            return true;
-        },
-        clear() {
-            last = null;
-        },
-    };
-}
-//# sourceMappingURL=failure-latch.js.map

package/dist/failure-latch.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"failure-latch.js","sourceRoot":"","sources":["../src/failure-latch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAeH;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,CAAa,EAAE,CAAa;IAC1D,OAAO,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,KAAK,CAAC;AACxE,CAAC;AA4ED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAA6B;IAC9D,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,GAAG,QAAQ,CAAC;IAC7C,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,IAAI,SAAS,GAAG,KAAK,CAAC;IAEtB,OAAO;QACN,OAAO,EAAE,GAAY,EAAE,CAAC,QAAQ,IAAI,SAAS;QAC7C,QAAQ,EAAE,GAAY,EAAE,CAAC,QAAQ;QACjC,OAAO;YACN,QAAQ,GAAG,IAAI,CAAC;QACjB,CAAC;QACD,MAAM,CAAC,KAAc,EAAE,OAAiC;YACvD,MAAM,YAAY,GAAG,SAAS,CAAC;YAC/B,SAAS,GAAG,IAAI,CAAC;YACjB,IAAI,CAAC;gBACJ,IAAI,CAAC,OAAO,EAAE,CAAC;oBACd,IAAI,SAAS,KAAK,SAAS;wBAAE,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;oBAC7D,OAAO;gBACR,CAAC;gBACD,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;oBAChC,OAAO,EAAE,CAAC;oBACV,OAAO;gBACR,CAAC;gBACD,6EAA6E;gBAC7E,4EAA4E;gBAC5E,0EAA0E;gBAC1E,uCAAuC;gBACvC,IAAI,CAAC;oBACJ,OAAO,EAAE,CAAC;gBACX,CAAC;gBAAC,OAAO,cAAc,EAAE,CAAC;oBACzB,OAAO,CAAC,KAAK,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;gBAC7C,CAAC;YACF,CAAC;oBAAS,CAAC;gBACV,SAAS,GAAG,YAAY,CAAC;YAC1B,CAAC;QACF,CAAC;KACD,CAAC;AACH,CAAC;AAuBD;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB;IACjC,uFAAuF;IACvF,8EAA8E;IAC9E,IAAI,IAAI,GAAsB,IAAI,CAAC;IAEnC,OAAO;QACN,YAAY,CAAC,KAAc,EAAE,IAAa,EAAE,KAAc;YACzD,MAAM,IAAI,GAAe,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;YAChD,IAAI,IAAI,KAAK,IAAI,IAAI,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC;gBAAE,OAAO,KAAK,CAAC;YAC9D,IAAI,GAAG,IAAI,CAAC;YACZ,OAAO,IAAI,CAAC;QACb,CAAC;QACD,KAAK;YACJ,IAAI,GAAG,IAAI,CAAC;QACb,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/provider-guards.d.ts

@@ -1,58 +0,0 @@
-/**
- * The shared provider guards of the ActorProvider implementation of each framework.
- *
- * Every framework integration (React, Vue, Solid, Svelte, and DOM) does the same
- * two steps when it connects the view of an actor to a json-render tree:
- *
- * 1. It cleans `spec.state` before it seeds a new `@xstate/store` atom
- *    ({@link toAtomState}).
- * 2. It puts an `onRenderError` handler of the component level into the component
- *    registry, and it does not change the registry of the caller
- *    ({@link attachRenderErrorHandler}).
- *
- * Both functions are here. Therefore the semantics of the guards are identical in
- * every framework.
- *
- * @packageDocumentation
- */
-import type { RenderErrorHandler } from "@xmachines/json-render-core";
-/**
- * Converts the `state` field of a spec into a plain object for `createAtom`, in a safe way.
- *
- * `spec.state` has the type `unknown` in `PlaySpec`. At run time it is `null`,
- * `undefined`, a primitive, or a plain object, and this depends on the value that
- * the author of the machine put in the view spec. `createAtom` requires a plain
- * object as its first value, because every other value makes a broken store at run
- * time.
- *
- * The function accepts a plain object only, which means that its prototype is
- * `Object.prototype` or `null`, and it returns that object without a change. Every
- * other value becomes a new `{}`: `null`, `undefined`, a primitive, an array, an
- * instance of a class, and a built-in object such as a Date, a Map, or a Set. A
- * broken store therefore never appears at run time.
- *
- * @param state - The raw `spec.state` value of a `PlaySpec`.
- * @returns `state` itself when it is a plain object. In every other case, a new empty object.
- */
-export declare function toAtomState(state: unknown): Record<string, unknown>;
-/**
- * Copies a component registry, and puts an `onRenderError` handler into the copy.
- *
- * The function defines the handler as an own property of the copy. That property is
- * not enumerable, and it is configurable (D-19 gives one convention of the
- * injection for every framework renderer). The handler therefore replaces each
- * handler of the `defineRegistry` level, and it does not appear in an enumeration of
- * the component entries of the registry.
- *
- * The function never changes the registry of the caller: it returns a shallow copy.
- * Therefore a caller that needs a handler for each instance, such as an
- * `onRenderError` prop of `ActorProvider`, can share one result of `defineRegistry`
- * between the providers in a safe way.
- *
- * @typeParam TRegistry - The component registry type of the framework.
- * @param registry - The component registry from `defineRegistry().registry`.
- * @param handler - The renderer calls it with `(error, componentName)` when a catalog component throws during a render.
- * @returns A shallow copy of `registry`, with `onRenderError` on it.
- */
-export declare function attachRenderErrorHandler<TRegistry extends object>(registry: TRegistry, handler: RenderErrorHandler): TRegistry;
-//# sourceMappingURL=provider-guards.d.ts.map

package/dist/provider-guards.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"provider-guards.d.ts","sourceRoot":"","sources":["../src/provider-guards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEtE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQnE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,SAAS,MAAM,EAChE,QAAQ,EAAE,SAAS,EACnB,OAAO,EAAE,kBAAkB,GACzB,SAAS,CAQX"}

package/dist/provider-guards.js

@@ -1,73 +0,0 @@
-/**
- * The shared provider guards of the ActorProvider implementation of each framework.
- *
- * Every framework integration (React, Vue, Solid, Svelte, and DOM) does the same
- * two steps when it connects the view of an actor to a json-render tree:
- *
- * 1. It cleans `spec.state` before it seeds a new `@xstate/store` atom
- *    ({@link toAtomState}).
- * 2. It puts an `onRenderError` handler of the component level into the component
- *    registry, and it does not change the registry of the caller
- *    ({@link attachRenderErrorHandler}).
- *
- * Both functions are here. Therefore the semantics of the guards are identical in
- * every framework.
- *
- * @packageDocumentation
- */
-/**
- * Converts the `state` field of a spec into a plain object for `createAtom`, in a safe way.
- *
- * `spec.state` has the type `unknown` in `PlaySpec`. At run time it is `null`,
- * `undefined`, a primitive, or a plain object, and this depends on the value that
- * the author of the machine put in the view spec. `createAtom` requires a plain
- * object as its first value, because every other value makes a broken store at run
- * time.
- *
- * The function accepts a plain object only, which means that its prototype is
- * `Object.prototype` or `null`, and it returns that object without a change. Every
- * other value becomes a new `{}`: `null`, `undefined`, a primitive, an array, an
- * instance of a class, and a built-in object such as a Date, a Map, or a Set. A
- * broken store therefore never appears at run time.
- *
- * @param state - The raw `spec.state` value of a `PlaySpec`.
- * @returns `state` itself when it is a plain object. In every other case, a new empty object.
- */
-export function toAtomState(state) {
-    if (state !== null && typeof state === "object" && !Array.isArray(state)) {
-        const proto = Object.getPrototypeOf(state);
-        if (proto === Object.prototype || proto === null) {
-            return state;
-        }
-    }
-    return {};
-}
-/**
- * Copies a component registry, and puts an `onRenderError` handler into the copy.
- *
- * The function defines the handler as an own property of the copy. That property is
- * not enumerable, and it is configurable (D-19 gives one convention of the
- * injection for every framework renderer). The handler therefore replaces each
- * handler of the `defineRegistry` level, and it does not appear in an enumeration of
- * the component entries of the registry.
- *
- * The function never changes the registry of the caller: it returns a shallow copy.
- * Therefore a caller that needs a handler for each instance, such as an
- * `onRenderError` prop of `ActorProvider`, can share one result of `defineRegistry`
- * between the providers in a safe way.
- *
- * @typeParam TRegistry - The component registry type of the framework.
- * @param registry - The component registry from `defineRegistry().registry`.
- * @param handler - The renderer calls it with `(error, componentName)` when a catalog component throws during a render.
- * @returns A shallow copy of `registry`, with `onRenderError` on it.
- */
-export function attachRenderErrorHandler(registry, handler) {
-    const clone = { ...registry };
-    Object.defineProperty(clone, "onRenderError", {
-        value: handler,
-        enumerable: false,
-        configurable: true,
-    });
-    return clone;
-}
-//# sourceMappingURL=provider-guards.js.map

package/dist/provider-guards.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"provider-guards.js","sourceRoot":"","sources":["../src/provider-guards.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,WAAW,CAAC,KAAc;IACzC,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1E,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAY,CAAC;QACtD,IAAI,KAAK,KAAK,MAAM,CAAC,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YAClD,OAAO,KAAgC,CAAC;QACzC,CAAC;IACF,CAAC;IACD,OAAO,EAAE,CAAC;AACX,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,wBAAwB,CACvC,QAAmB,EACnB,OAA2B;IAE3B,MAAM,KAAK,GAAG,EAAE,GAAG,QAAQ,EAAE,CAAC;IAC9B,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,eAAe,EAAE;QAC7C,KAAK,EAAE,OAAO;QACd,UAAU,EAAE,KAAK;QACjB,YAAY,EAAE,IAAI;KAClB,CAAC,CAAC;IACH,OAAO,KAAK,CAAC;AACd,CAAC"}

package/dist/view-store-lifecycle.d.ts

@@ -1,82 +0,0 @@
-/**
- * The lifecycle of the view store — the framework-agnostic decision between a new
- * seed and a refresh. Each provider connects it to its own reactivity.
- *
- * The policy is in one place now. Each renderer held a copy of it before, and those
- * copies moved apart into real faults:
- *
- * - The `viewKey` changed, or this is the first resolve, or the tree provides a
- *   different actor → NEW SEED: a new store, from the composed state of the view.
- * - The `viewKey` did not change → REFRESH: only the /context projection moved.
- *   Therefore the code replaces the `/context` subtree in place, and the ephemeral
- *   state at the root level, such as a draft or a toggle, stays.
- * - No `viewKey`, from a Viewable that a person built and that stamps no key → a new
- *   seed for each EMISSION, which is the safe behavior from the time before the
- *   viewKey.
- * - A different actor → the store that stays alive dies with its actor. This is the
- *   rule of the lifetime.
- * - The controlled mode, where the caller gives the store → the caller owns the seed
- *   and the lifecycle. The machinery owns /context in both modes, and this file
- *   refreshes it. The caller can move that refresh to a later moment
- *   ({@link ResolveViewStoreOptions}), and the render path of React needs this,
- *   because a store must notify no subscriber during a render. The effects of React
- *   then do the refresh.
- *
- * Each provider therefore holds the wiring of its reactivity only: the moment of
- * the resolve, and the path of the result to the children.
- *
- * @packageDocumentation
- */
-import type { StateStore } from "@xmachines/json-render-core";
-import type { PlaySpec } from "./abstract-actor.js";
-/** The result of a resolve — see {@link ViewStoreLifecycle.resolve}. */
-export interface ViewStoreResolution {
-    /** The store WITHOUT the guard — the reference of the machinery for its own refresh. */
-    store: StateStore;
-    /**
-     * The store to give to the children ($bindState, setState, and a chained set): a
-     * write under /context throws. There is one wrapper for each store below it, and
-     * the code caches the identity. Therefore a consumer in the style of
-     * `useSyncExternalStore` stays stable.
-     */
-    guardedStore: StateStore;
-    /**
-     * It is true when this resolve made a new store: at the first resolve, on a change
-     * of the viewKey, in the fallback for each emission, and on a change of the actor. A
-     * provider that mounts a subtree again for each store, such as the storeKey of Vue,
-     * uses this field as its key.
-     */
-    reseeded: boolean;
-}
-export interface ResolveViewStoreOptions {
-    /**
-     * The controlled mode only: refresh the /context subtree of the external store
-     * during this resolve. The default is true. Give false where the call site permits
-     * no notification of the store subscribers, which is the render path of React, and
-     * refresh from an effect instead.
-     */
-    refreshExternalStore?: boolean;
-}
-export interface ViewStoreLifecycle {
-    /**
-     * Brings the store in line with an emission, and returns it with its guard.
-     *
-     * @param actor - The actor of the emission. A different actor drops the store that the code kept.
-     * @param view - The derived view. It is not null: a null emission is a GAP, and not
-     *   a new view. A caller resolves nothing on a null value, and it keeps the store.
-     * @param externalStore - The controlled mode: the store of the caller.
-     * @param options - See {@link ResolveViewStoreOptions}.
-     */
-    resolve(actor: unknown, view: PlaySpec, externalStore?: StateStore | undefined, options?: ResolveViewStoreOptions): ViewStoreResolution;
-    /** Drops everything, on an unmount or a disconnect. The next resolve makes a new seed. */
-    reset(): void;
-}
-/**
- * Creates a coordinator of the lifecycle.
- *
- * @param createStore - The store factory of the framework. It receives the seed
- *   that is safe for the prototype (`toAtomState(view.state)`), and the composed
- *   state carries /context already.
- */
-export declare function createViewStoreLifecycle(createStore: (seed: Record<string, unknown>) => StateStore): ViewStoreLifecycle;
-//# sourceMappingURL=view-store-lifecycle.d.ts.map

package/dist/view-store-lifecycle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"view-store-lifecycle.d.ts","sourceRoot":"","sources":["../src/view-store-lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD,wEAAwE;AACxE,MAAM,WAAW,mBAAmB;IACnC,wFAAwF;IACxF,KAAK,EAAE,UAAU,CAAC;IAClB;;;;;OAKG;IACH,YAAY,EAAE,UAAU,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACvC;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,WAAW,kBAAkB;IAClC;;;;;;;;OAQG;IACH,OAAO,CACN,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,QAAQ,EACd,aAAa,CAAC,EAAE,UAAU,GAAG,SAAS,EACtC,OAAO,CAAC,EAAE,uBAAuB,GAC/B,mBAAmB,CAAC;IACvB,0FAA0F;IAC1F,KAAK,IAAI,IAAI,CAAC;CACd;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACvC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,UAAU,GACxD,kBAAkB,CA4DpB"}

package/dist/view-store-lifecycle.js

@@ -1,97 +0,0 @@
-/**
- * The lifecycle of the view store — the framework-agnostic decision between a new
- * seed and a refresh. Each provider connects it to its own reactivity.
- *
- * The policy is in one place now. Each renderer held a copy of it before, and those
- * copies moved apart into real faults:
- *
- * - The `viewKey` changed, or this is the first resolve, or the tree provides a
- *   different actor → NEW SEED: a new store, from the composed state of the view.
- * - The `viewKey` did not change → REFRESH: only the /context projection moved.
- *   Therefore the code replaces the `/context` subtree in place, and the ephemeral
- *   state at the root level, such as a draft or a toggle, stays.
- * - No `viewKey`, from a Viewable that a person built and that stamps no key → a new
- *   seed for each EMISSION, which is the safe behavior from the time before the
- *   viewKey.
- * - A different actor → the store that stays alive dies with its actor. This is the
- *   rule of the lifetime.
- * - The controlled mode, where the caller gives the store → the caller owns the seed
- *   and the lifecycle. The machinery owns /context in both modes, and this file
- *   refreshes it. The caller can move that refresh to a later moment
- *   ({@link ResolveViewStoreOptions}), and the render path of React needs this,
- *   because a store must notify no subscriber during a render. The effects of React
- *   then do the refresh.
- *
- * Each provider therefore holds the wiring of its reactivity only: the moment of
- * the resolve, and the path of the result to the children.
- *
- * @packageDocumentation
- */
-import { guardContextWrites, refreshContextSubtree } from "./context-projection.js";
-import { toAtomState } from "./provider-guards.js";
-/**
- * Creates a coordinator of the lifecycle.
- *
- * @param createStore - The store factory of the framework. It receives the seed
- *   that is safe for the prototype (`toAtomState(view.state)`), and the composed
- *   state carries /context already.
- */
-export function createViewStoreLifecycle(createStore) {
-    let internalStore = null;
-    let lastViewKey = undefined;
-    let lastView = null;
-    let lastActor = null;
-    // The identity cache of the guard: one wrapper for each store below it.
-    let guardedSource = null;
-    let guardedStore = null;
-    const reset = () => {
-        internalStore = null;
-        lastViewKey = undefined;
-        lastView = null;
-        lastActor = null;
-        guardedSource = null;
-        guardedStore = null;
-    };
-    return {
-        reset,
-        resolve(actor, view, externalStore, options) {
-            // The rule of the lifetime: a store that stays alive must not outlive its actor.
-            if (lastActor !== actor) {
-                const firstResolve = lastActor === null && internalStore === null;
-                if (!firstResolve)
-                    reset();
-                lastActor = actor;
-            }
-            let resolved;
-            let reseeded = false;
-            if (externalStore) {
-                resolved = externalStore;
-                if (options?.refreshExternalStore !== false) {
-                    refreshContextSubtree(resolved, view);
-                }
-            }
-            else {
-                const viewKey = view.viewKey;
-                let nextStore = internalStore;
-                if (nextStore === null ||
-                    (viewKey !== undefined ? lastViewKey !== viewKey : lastView !== view)) {
-                    nextStore = createStore(toAtomState(view.state));
-                    internalStore = nextStore;
-                    lastViewKey = viewKey;
-                    reseeded = true;
-                }
-                else if (viewKey !== undefined) {
-                    refreshContextSubtree(nextStore, view);
-                }
-                lastView = view;
-                resolved = nextStore;
-            }
-            if (guardedSource !== resolved) {
-                guardedSource = resolved;
-                guardedStore = guardContextWrites(resolved);
-            }
-            return { store: resolved, guardedStore: guardedStore, reseeded };
-        },
-    };
-}
-//# sourceMappingURL=view-store-lifecycle.js.map

package/dist/view-store-lifecycle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"view-store-lifecycle.js","sourceRoot":"","sources":["../src/view-store-lifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAKH,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACpF,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAoDnD;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CACvC,WAA0D;IAE1D,IAAI,aAAa,GAAsB,IAAI,CAAC;IAC5C,IAAI,WAAW,GAAuB,SAAS,CAAC;IAChD,IAAI,QAAQ,GAAoB,IAAI,CAAC;IACrC,IAAI,SAAS,GAAY,IAAI,CAAC;IAC9B,wEAAwE;IACxE,IAAI,aAAa,GAAsB,IAAI,CAAC;IAC5C,IAAI,YAAY,GAAsB,IAAI,CAAC;IAE3C,MAAM,KAAK,GAAG,GAAS,EAAE;QACxB,aAAa,GAAG,IAAI,CAAC;QACrB,WAAW,GAAG,SAAS,CAAC;QACxB,QAAQ,GAAG,IAAI,CAAC;QAChB,SAAS,GAAG,IAAI,CAAC;QACjB,aAAa,GAAG,IAAI,CAAC;QACrB,YAAY,GAAG,IAAI,CAAC;IACrB,CAAC,CAAC;IAEF,OAAO;QACN,KAAK;QACL,OAAO,CAAC,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO;YAC1C,iFAAiF;YACjF,IAAI,SAAS,KAAK,KAAK,EAAE,CAAC;gBACzB,MAAM,YAAY,GAAG,SAAS,KAAK,IAAI,IAAI,aAAa,KAAK,IAAI,CAAC;gBAClE,IAAI,CAAC,YAAY;oBAAE,KAAK,EAAE,CAAC;gBAC3B,SAAS,GAAG,KAAK,CAAC;YACnB,CAAC;YAED,IAAI,QAAoB,CAAC;YACzB,IAAI,QAAQ,GAAG,KAAK,CAAC;YACrB,IAAI,aAAa,EAAE,CAAC;gBACnB,QAAQ,GAAG,aAAa,CAAC;gBACzB,IAAI,OAAO,EAAE,oBAAoB,KAAK,KAAK,EAAE,CAAC;oBAC7C,qBAAqB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;gBACvC,CAAC;YACF,CAAC;iBAAM,CAAC;gBACP,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;gBAC7B,IAAI,SAAS,GAAsB,aAAa,CAAC;gBACjD,IACC,SAAS,KAAK,IAAI;oBAClB,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,QAAQ,KAAK,IAAI,CAAC,EACpE,CAAC;oBACF,SAAS,GAAG,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;oBACjD,aAAa,GAAG,SAAS,CAAC;oBAC1B,WAAW,GAAG,OAAO,CAAC;oBACtB,QAAQ,GAAG,IAAI,CAAC;gBACjB,CAAC;qBAAM,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;oBAClC,qBAAqB,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;gBACxC,CAAC;gBACD,QAAQ,GAAG,IAAI,CAAC;gBAChB,QAAQ,GAAG,SAAS,CAAC;YACtB,CAAC;YAED,IAAI,aAAa,KAAK,QAAQ,EAAE,CAAC;gBAChC,aAAa,GAAG,QAAQ,CAAC;gBACzB,YAAY,GAAG,kBAAkB,CAAC,QAAQ,CAAC,CAAC;YAC7C,CAAC;YACD,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,YAA0B,EAAE,QAAQ,EAAE,CAAC;QAChF,CAAC;KACD,CAAC;AACH,CAAC"}