@spearwolf/shadow-objects 0.32.0 → 0.34.0

package/src/view/ComponentContext.d.ts

@@ -1,7 +1,24 @@
 import type { ChangeTrailType, NamespaceType } from '../types.js';
+import { type ComponentState } from './ComponentMemory.js';
 import type { ViewComponent } from './ViewComponent.js';
 declare global {
-    var __shadowEntsContexts: Map<string | symbol, ComponentContext> | undefined;
+    var __shadowObjectsContexts: Map<string | symbol, ComponentContext> | undefined;
+}
+/**
+ * Thrown when a {@link ViewComponent} tries to join a {@link ComponentContext} that has
+ * already been disposed.
+ */
+export declare class ComponentContextDisposedError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Thrown when a {@link ViewComponent} tries to join a {@link ComponentContext} under a uuid
+ * another component of that {@link ComponentContext} is holding. A uuid names one component at a
+ * time; it becomes free again once its holder has left.
+ */
+export declare class ComponentUuidInUseError extends Error {
+    readonly uuid: string;
+    constructor(uuid: string);
 }
 /**
  * The {@link ComponentContext} represents the current real-time state of the _view components_.
@@ -19,29 +36,127 @@ declare global {
  *
  * A context is always associated with a namespace.
  * If no namespace is specified when creating a {@link ComponentContext}, the global namespace is used.
- * There is only one {@link ComponentContext} (a singleton) for each namespace.
+ * There is only one {@link ComponentContext} instance per namespace: the constructor returns the
+ * existing instance for an already-occupied namespace rather than building a second one, so
+ * {@link ComponentContext.get} is the way consumers are meant to reach it.
  */
 export declare class ComponentContext {
     #private;
     static readonly ReRequestParentRoots = "re-request-parent-roots";
+    static readonly ReRequestParent = "re-request-parent";
+    /**
+     * Ask the element behind a component to let the properties hanging on it look for their host
+     * again.
+     *
+     * A context knows nothing about `<shae-prop>` — a property has no view component and cannot be
+     * addressed here. The signal still belongs next to the two above: it travels the same broadcast
+     * channel to the same receivers, and the element on the other end is the one that can reach the
+     * properties below it.
+     */
+    static readonly ReRequestEntHost = "re-request-ent-host";
     static getContextsMap(): Map<NamespaceType, ComponentContext>;
     static get(namespace?: NamespaceType): ComponentContext;
     ns?: NamespaceType;
     constructor(namespace?: NamespaceType);
+    /**
+     * Whether this context has been torn down by {@link ComponentContext.dispose}.
+     *
+     * A disposed context holds no components, produces empty change trails and no longer
+     * occupies its namespace. It cannot be revived; use {@link ComponentContext.get} to
+     * obtain a fresh context for the same namespace.
+     */
+    get isDisposed(): boolean;
+    /**
+     * Take a component in: it becomes a member of this {@link ComponentContext} and a
+     * `CreateEntities` change is written for its uuid.
+     *
+     * Called by the {@link ViewComponent#context} setter, and by nothing else.
+     *
+     * @throws {ComponentContextDisposedError} if this {@link ComponentContext} has been disposed
+     * @throws {ComponentUuidInUseError} if another member of this {@link ComponentContext} holds
+     *   `component.uuid`
+     */
     addComponent(component: ViewComponent): void;
+    /**
+     * Whether `component` is a member of this {@link ComponentContext} right now.
+     *
+     * This is the question about the instance, and the only one this class answers about
+     * membership. A component that has left gets `false`, even while its entry is still standing —
+     * {@link ComponentContext.hasComponents} is what counts entries.
+     */
     hasComponent(component: ViewComponent): boolean;
     hasComponents(): boolean;
     isRootComponent(component: ViewComponent): boolean;
     destroyComponent(component: ViewComponent): void;
+    /**
+     * The children of `component`, in sort order — a fresh array each call, and an empty one for
+     * an instance that does not own its entry.
+     *
+     * Uuids without a matching view instance are skipped instead of dereferenced: `addToChildren()`
+     * writes a uuid into a children list without the parent link of the child following along, so
+     * `#deleteComponent()` has no list to take that uuid out of and the entry behind it goes while
+     * the list keeps naming it. `#appendToOrdered()` and `#traverseLevelOrderBFS()` read a children
+     * list the same way.
+     */
     getChildren(component: ViewComponent): ViewComponent[];
-    removeFromParent(childUuid: string, parent: ViewComponent): void;
-    moveToRoot(childUuid: string): void;
+    removeFromParent(component: ViewComponent, parent: ViewComponent): void;
+    moveToRoot(component: ViewComponent): void;
     changeToken(component: ViewComponent, token?: string): void;
     isChildOf(child: ViewComponent, parent: ViewComponent): boolean;
     addToChildren(parent: ViewComponent, child: ViewComponent): void;
+    /**
+     * Destroy a component and all its descendants without writing anything to a change trail.
+     * Each of them is detached from this context and reports {@link ViewComponent#isDestroyed}.
+     *
+     * @see {@link ComponentContext.clear}
+     */
     removeSubTree(uuid: string): void;
-    setProperty<T = unknown>(component: ViewComponent, propKey: string, value: T, isEqual?: (a: T, b: T) => boolean): false | void;
+    /**
+     * @returns `true` if the value differs from the last value written to a change trail
+     */
+    setProperty<T = unknown>(component: ViewComponent, propKey: string, value: T, isEqual?: (a: T, b: T) => boolean): boolean;
+    /**
+     * Mark `propKey` on `component` as set without giving it a value: the change trail carries
+     * an entry that names only the key, and the entity behind it reads the property as
+     * `undefined` with the key in place. {@link ComponentContext.setProperty} with `undefined`
+     * is the other thing — a removal.
+     *
+     * An equality rule registered for the key is forgotten, the way it is for a
+     * {@link ComponentContext.setProperty} that comes without one: there is no value here for a
+     * rule to compare.
+     *
+     * @returns `true` when this differs from the last value written to a change trail, and
+     *   `false` for an instance that does not own its entry
+     */
+    setPropertyWithoutValue(component: ViewComponent, propKey: string): boolean;
     removeProperty(component: ViewComponent, propKey: string): void;
+    /**
+     * Hand the properties of `component` over to the context it has just joined.
+     *
+     * Called by the {@link ViewComponent#context} setter, and by nothing else. It reads the state
+     * this context still holds for the component: leaving a context destroys it, but the entry
+     * survives until the next {@link ComponentContext.buildChangeTrails}, so the properties are
+     * still there to be read once the join has happened.
+     *
+     * The equality function travels with each property, because it is a rule about the key and not
+     * about the value — the same key means the same notion of "unchanged" wherever it lives. It does
+     * not get to decide about the arrival, though: the target holds nothing for the key yet, so it
+     * would be asked whether the value equals `undefined`, and a function that says yes would drop
+     * the property instead of carrying it over. The value is therefore written first and the rule
+     * registered after it — the other way round, the write would delete the entry it just made,
+     * because {@link ComponentContext.setProperty} keeps only what its caller passes.
+     *
+     * What the registered rule is for: {@link ComponentContext.reCreateChanges} is its one reader,
+     * and it compares with it when it rebuilds a component from the memory. A later
+     * {@link ComponentContext.setProperty} does not consult it — it uses its own argument, or none.
+     *
+     * A property that is set without a value goes over as one: handing it on as the value
+     * `undefined` would have the target read it as a removal, and the key would not arrive.
+     *
+     * Built like {@link ComponentChanges.transferEventsTo}, with one difference: the properties are
+     * copied, not moved. What stays behind goes down with the entity in this context.
+     */
+    transferPropertiesTo(component: ViewComponent, target: ComponentContext): void;
     changeOrder(component: ViewComponent): void;
     /**
      * @returns all view-components in breadth-first order
@@ -60,23 +175,140 @@ export declare class ComponentContext {
      */
     dispatchMessage(uuid: string, type: string, data?: unknown, traverseChildren?: boolean): void;
     /**
-     * Inform all root components that they should re-request their parents
+     * Inform all root components that they should re-request their parents.
+     *
+     * Every root is asked, because there is nothing here to ask about: the message carries no
+     * sender, so this side cannot narrow the set down at all. The receiver is the one that can:
+     * it re-asks the element tree, and whoever answers first wins.
+     *
+     * Delivery is immediate: the round is over by the time the call returns. Two paths inside the
+     * library end here — {@link ComponentContext.dispatchReRequestParentSiblings} for a component
+     * without a parent, whose candidate set is the roots, and the delivery of a collected round for
+     * that same set. What does not come this way is an entity that has just arrived: it hands its
+     * round to the collector below. The method is public because running a round at a moment of
+     * one's own choosing is what it is for.
      */
     dispatchReRequestParentRoots(): void;
+    /**
+     * Inform the children of `component` that they should re-request their parents.
+     *
+     * The receivers are the components hanging on `component` right now, and every one of them has
+     * to let go: the message carries no sender and needs no filter, because there is nothing here to
+     * decide. {@link ComponentContext.ReRequestParentRoots} is the signal for it — it means "drop
+     * your parent and ask again", which is what the roots happen to be asked for most often, not
+     * what it says.
+     */
+    dispatchReRequestParentChildren(component: ViewComponent): void;
+    /**
+     * Inform the siblings of `component` that they should re-request their parents.
+     *
+     * This narrows the candidate set for one specific question: which components could have bound
+     * to an ancestor further away than they should have, because `component` was not yet answering
+     * when they asked? Such a component sits below `component` in the element tree and shares its
+     * parent — any entity in between would have answered first. As long as `component` has no
+     * parent of its own, the roots are that same set.
+     *
+     * The signal alone does not decide anything: the receiver re-asks, and whoever answers first
+     * wins. Which components exist as candidates is what this method knows; whether one of them
+     * really sits below `component` is settled on the receiving side, which is where the element
+     * tree is visible — `data` is what carries the sender's identity there.
+     *
+     * The two signals differ in the order they work in, and that decides more than it looks like:
+     * {@link ComponentContext.ReRequestParentRoots} releases the parent before asking, so a
+     * component that gets the same answer back re-joins its parent's children at the end;
+     * {@link ComponentContext.ReRequestParent} asks first and releases only where nobody answers,
+     * which leaves every component that is already bound where it stands, order included.
+     *
+     * Delivery is immediate, and nothing inside the library calls it: like
+     * {@link ComponentContext.dispatchReRequestParentRoots} it is public so that a round can be run
+     * at a moment of one's own choosing.
+     */
+    dispatchReRequestParentSiblings(component: ViewComponent, data?: unknown): void;
     /**
      * Create the component change trails at this point in time.
      * The next call will only return the differences from the previous call.
      *
+     * @param commit whether the trail counts as applied the moment it is built. Pass `false` when
+     *   the trail still has to travel to a Shadow Environment that may refuse it, and settle it
+     *   afterwards with {@link ComponentContext.commitChangeTrail}.
+     *
+     * @see {@link ComponentContext.commitChangeTrail}
      * @see {@link ComponentContext.reCreateChanges}
      */
-    buildChangeTrails(clearChanges?: boolean): ChangeTrailType;
+    buildChangeTrails(commit?: boolean): ChangeTrailType;
+    /**
+     * Fold the first `appliedCount` entries of the change trail this context built last into the
+     * state the next trail is diffed against, and write them to the Component Memory. Every entry
+     * behind that line stays pending and goes out again with the next trail.
+     *
+     * A component is retired -- its entry dropped -- only where the build read it as spent and every
+     * entry it contributed is settled. One component can hold a creation and an event in the same
+     * trail, and a creation sent twice is refused by the Shadow Environment, which already holds an
+     * entity behind that uuid.
+     *
+     * @param appliedCount how many entries the Shadow Environment applied, counted from the front.
+     *   Clamped to the length of the trail.
+     * @param changeTrail the trail this call settles. Given, the call is ignored unless it is the
+     *   very trail this context built last -- a cycle that lost its trail to a later build must not
+     *   draw a line through that later trail.
+     */
+    commitChangeTrail(appliedCount: number, changeTrail?: ChangeTrailType): void;
+    /**
+     * Whether the Component Memory holds a state for `uuid` — the state
+     * {@link ComponentContext.reCreateChanges} would rebuild that component from.
+     */
+    hasComponentState(uuid: string): boolean;
+    /**
+     * The state the Component Memory holds for `uuid`, or `undefined` where it holds none.
+     *
+     * A snapshot, not the record: the property list of the record is rewritten in place as
+     * trails come in, so a caller holding on to it would be reading a moving value — or
+     * writing one. What it is a snapshot of is the memory at the moment of the call, and the
+     * memory moves under several hands: {@link ComponentContext.commitChangeTrail} folds a
+     * settled trail into it, {@link ComponentContext.buildChangeTrails} does the same for the
+     * trail it builds unless it is told not to commit, {@link ComponentContext.reCreateChanges}
+     * writes the trail it builds and empties the memory afterwards, and
+     * {@link ComponentContext.clear} empties it outright. A snapshot taken before any of those
+     * describes a state that is over; take it again to see the current one.
+     *
+     * This is the window a test or a diagnosis needs, and the one that leaves the context as it
+     * found it — reading the same thing out of {@link ComponentContext.reCreateChanges} costs a
+     * rebuild of every component in the namespace.
+     */
+    getComponentState(uuid: string): ComponentState | undefined;
     /**
      * Resets the internal component change states so that all view components are regenerated with the next change trail.
      * The outstanding events are taken over.
      *
+     * The trail this produces belongs to a Shadow Environment that holds none of these uuids -- a
+     * fresh proxy. One whose Kernel still holds them refuses the first re-created creation it reads,
+     * and every cycle that follows, because a uuid names one entity at a time.
+     *
      * @see {@link ComponentContext.buildChangeTrails}
      */
     reCreateChanges(): void;
+    /**
+     * Remove all components without writing anything to a change trail. Every
+     * {@link ViewComponent} this context holds is destroyed, so each of them reports
+     * {@link ViewComponent#isDestroyed} and holds no context afterwards. The context itself stays
+     * registered under its namespace and can be used again — assigning it to a component takes
+     * that component back in under the same uuid.
+     *
+     * @see {@link ComponentContext.dispose} for the final teardown
+     */
     clear(): void;
+    /**
+     * Tear the context down for good: every {@link ViewComponent} it holds is destroyed, the
+     * component memory is dropped, and the namespace is released so that
+     * {@link ComponentContext.get} creates a fresh context for it.
+     *
+     * Unlike {@link ComponentContext.clear} this is final. The context holds no components,
+     * produces empty change trails, and rejects any component that tries to join it. Calling
+     * it more than once is a no-op.
+     *
+     * A `ShadowEnv` bound to this context keeps its reference; destroy the environment
+     * first if you want the namespace released on both sides.
+     */
+    dispose(): void;
 }
 //# sourceMappingURL=ComponentContext.d.ts.map

package/src/view/ComponentContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComponentContext.d.ts","sourceRoot":"","sources":["../../../src/view/ComponentContext.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAwB,aAAa,EAAC,MAAM,aAAa,CAAC;AAKtF,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAStD,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,oBAAoB,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,gBAAgB,CAAC,GAAG,SAAS,CAAC;CAC9E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,gBAAgB;;IAC3B,MAAM,CAAC,QAAQ,CAAC,oBAAoB,6BAA6B;IAEjE,MAAM,CAAC,cAAc,IAAI,GAAG,CAAC,aAAa,EAAE,gBAAgB,CAAC;IAO7D,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,aAAa,GAAG,gBAAgB;IASvD,EAAE,CAAC,EAAE,aAAa,CAAC;gBAOP,SAAS,GAAE,aAAwB;IAU/C,YAAY,CAAC,SAAS,EAAE,aAAa;IAkCrC,YAAY,CAAC,SAAS,EAAE,aAAa;IAIrC,aAAa;IAIb,eAAe,CAAC,SAAS,EAAE,aAAa;IAIxC,gBAAgB,CAAC,SAAS,EAAE,aAAa;IASzC,WAAW,CAAC,SAAS,EAAE,aAAa,GAAG,aAAa,EAAE;IAItD,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa;IAczD,UAAU,CAAC,SAAS,EAAE,MAAM;IAS5B,WAAW,CAAC,SAAS,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE,MAAM;IAIpD,SAAS,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa;IAQrD,aAAa,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa;IAYzD,aAAa,CAAC,IAAI,EAAE,MAAM;IAS1B,WAAW,CAAC,CAAC,GAAG,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO;IAc/G,cAAc,CAAC,SAAS,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM;IAIxD,WAAW,CAAC,SAAS,EAAE,aAAa;IAapC;;OAEG;IACH,qBAAqB,IAAI,aAAa,EAAE;IAIxC;;OAEG;IACH,0BAA0B,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,aAAa,CAAC,EAAE,YAAY,EAAE;IAIhH;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,OAAmB;IAMtD;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,OAAmB,EAAE,gBAAgB,UAAQ;IAI/F;;OAEG;IACH,4BAA4B;IAM5B;;;;;OAKG;IACH,iBAAiB,CAAC,YAAY,UAAO,GAAG,eAAe;IAmCvD;;;;;OAKG;IACH,eAAe;IA6Bf,KAAK;CA2GN"}
+{"version":3,"file":"ComponentContext.d.ts","sourceRoot":"","sources":["../../../src/view/ComponentContext.ts"],"names":[],"mappings":"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"}