@spearwolf/shadow-objects 0.33.0 → 0.34.0

package/src/elements/ShaeElement.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/elements/ShaeElement.ts"],
-  "sourcesContent": ["import {createSignal, Signal} from '@spearwolf/signalize';\nimport {GlobalNS} from '../constants.js';\nimport type {NamespaceType} from '../types.ts';\nimport {readNamespaceAttribute} from '../utils/attr-utils.js';\nimport {toNamespace} from '../utils/toNamespace.js';\nimport {ShadowEnv} from '../view/ShadowEnv.js';\nimport {ATTR_NS} from './constants.js';\n\nconst updateNamespace = (el: HTMLElement, ns: Signal<NamespaceType>) => {\n  ns.set(readNamespaceAttribute(el));\n};\n\nconst SyncNamespaces = new Set<NamespaceType>();\nlet nextSyncIsScheduled = false;\n\nconst syncShadowObjects = (ns: NamespaceType) => {\n  SyncNamespaces.add(ns);\n  if (!nextSyncIsScheduled) {\n    nextSyncIsScheduled = true;\n    queueMicrotask(() => {\n      nextSyncIsScheduled = false;\n      for (const ns of SyncNamespaces) {\n        ShadowEnv.get(ns)?.sync();\n      }\n      SyncNamespaces.clear();\n    });\n  }\n};\n\nexport class ShaeElement extends HTMLElement {\n  static observedAttributes = [ATTR_NS];\n\n  readonly isShaeElement = true;\n\n  readonly ns$ = createSignal<NamespaceType>(GlobalNS);\n\n  get ns(): NamespaceType {\n    return this.ns$.value;\n  }\n\n  set ns(ns: NamespaceType) {\n    if (typeof ns === 'symbol') {\n      this.ns$.set(ns);\n    } else {\n      this.ns$.set(toNamespace(ns));\n    }\n  }\n\n  constructor() {\n    super();\n\n    this.ns$.onChange((ns) => {\n      if (typeof ns === 'string' && ns.length > 0) {\n        if (this.getAttribute(ATTR_NS) !== ns) {\n          this.setAttribute(ATTR_NS, ns);\n        }\n      } else {\n        this.removeAttribute(ATTR_NS);\n      }\n    });\n\n    updateNamespace(this, this.ns$);\n  }\n\n  attributeChangedCallback(name: string) {\n    if (name === ATTR_NS) {\n      updateNamespace(this, this.ns$);\n    }\n  }\n\n  syncShadowObjects() {\n    syncShadowObjects(this.ns);\n  }\n}"],
-  "mappings": "AAAA,SAAQ,cAAc,cAAa;AACnC,SAAQ,gBAAe;AAEvB,SAAQ,8BAA6B;AACrC,SAAQ,mBAAkB;AAC1B,SAAQ,iBAAgB;AACxB,SAAQ,eAAc;AAEtB,MAAM,kBAAkB,CAAC,IAAiB,OAA8B;AACtE,KAAG,IAAI,uBAAuB,EAAE,CAAC;AACnC;AAEA,MAAM,iBAAiB,oBAAI,IAAmB;AAC9C,IAAI,sBAAsB;AAE1B,MAAM,oBAAoB,CAAC,OAAsB;AAC/C,iBAAe,IAAI,EAAE;AACrB,MAAI,CAAC,qBAAqB;AACxB,0BAAsB;AACtB,mBAAe,MAAM;AACnB,4BAAsB;AACtB,iBAAWA,OAAM,gBAAgB;AAC/B,kBAAU,IAAIA,GAAE,GAAG,KAAK;AAAA,MAC1B;AACA,qBAAe,MAAM;AAAA,IACvB,CAAC;AAAA,EACH;AACF;AAEO,MAAM,oBAAoB,YAAY;AAAA,EAmB3C,cAAc;AACZ,UAAM;AAjBR,SAAS,gBAAgB;AAEzB,SAAS,MAAM,aAA4B,QAAQ;AAiBjD,SAAK,IAAI,SAAS,CAAC,OAAO;AACxB,UAAI,OAAO,OAAO,YAAY,GAAG,SAAS,GAAG;AAC3C,YAAI,KAAK,aAAa,OAAO,MAAM,IAAI;AACrC,eAAK,aAAa,SAAS,EAAE;AAAA,QAC/B;AAAA,MACF,OAAO;AACL,aAAK,gBAAgB,OAAO;AAAA,MAC9B;AAAA,IACF,CAAC;AAED,oBAAgB,MAAM,KAAK,GAAG;AAAA,EAChC;AAAA,EAhCA;AAAA,SAAO,qBAAqB,CAAC,OAAO;AAAA;AAAA,EAMpC,IAAI,KAAoB;AACtB,WAAO,KAAK,IAAI;AAAA,EAClB;AAAA,EAEA,IAAI,GAAG,IAAmB;AACxB,QAAI,OAAO,OAAO,UAAU;AAC1B,WAAK,IAAI,IAAI,EAAE;AAAA,IACjB,OAAO;AACL,WAAK,IAAI,IAAI,YAAY,EAAE,CAAC;AAAA,IAC9B;AAAA,EACF;AAAA,EAkBA,yBAAyB,MAAc;AACrC,QAAI,SAAS,SAAS;AACpB,sBAAgB,MAAM,KAAK,GAAG;AAAA,IAChC;AAAA,EACF;AAAA,EAEA,oBAAoB;AAClB,sBAAkB,KAAK,EAAE;AAAA,EAC3B;AACF;",
-  "names": ["ns"]
+  "sourcesContent": ["import {createSignal, hibernate, Signal} from '@spearwolf/signalize';\nimport {GlobalNS} from '../constants.js';\nimport type {NamespaceType} from '../types.js';\nimport {readNamespaceAttribute} from '../utils/attr-utils.js';\nimport {ConsoleLogger} from '../utils/ConsoleLogger.js';\nimport {MicrotaskCollector} from '../utils/MicrotaskCollector.js';\nimport {runGuarded} from '../utils/runGuarded.js';\nimport {toNamespace} from '../utils/toNamespace.js';\nimport {ShadowEnv} from '../view/ShadowEnv.js';\nimport {ATTR_NS} from './constants.js';\nimport {ShaeLifecycleElement} from './ShaeLifecycleElement.js';\n\nconst updateNamespace = (el: HTMLElement, ns: Signal<NamespaceType>) => {\n  ns.set(readNamespaceAttribute(el));\n};\n\nconst logger = new ConsoleLogger('ShaeElement');\n\n// Module-wide, and one collector for every element in the realm: the key *is* the namespace and\n// `ShadowEnv.get(ns)` resolves it realm-wide, so two environments of one realm can take nothing\n// from each other here.\n//\n// One hand-over is one namespace: the call for each of them stands on its own, so none can take\n// the rest of the round with it, and what comes up while handing one over is reported instead of\n// carried out of the loop. What becomes of the trail is settled inside the environment, a\n// microtask later, and does not travel back through here.\nconst syncCollector = new MicrotaskCollector<NamespaceType>((namespaces) => {\n  for (const ns of namespaces.keys()) {\n    runGuarded(logger, () => ShadowEnv.get(ns)?.sync(), 'a namespace could not be synced:', ns);\n  }\n});\n\nconst collectForSync = (ns: NamespaceType) => {\n  syncCollector.add(ns);\n};\n\n/**\n * The base of the custom elements that pick an environment through their `ns` attribute.\n *\n * What it adds to {@link ShaeLifecycleElement} is the namespace: the `ns` attribute, the signal\n * behind it, the reflection back onto the attribute, and the two ways to hand an environment on to\n * the next sync. When such an element starts listening and when it lets go is the base's answer,\n * and it is the same answer `<shae-prop>` gets, which shares that base without this layer.\n */\nexport class ShaeElement extends ShaeLifecycleElement {\n  static observedAttributes = [ATTR_NS];\n\n  readonly isShaeElement = true;\n\n  readonly ns$ = createSignal<NamespaceType>(GlobalNS);\n\n  get ns(): NamespaceType {\n    return this.ns$.value;\n  }\n\n  set ns(ns: NamespaceType) {\n    if (typeof ns === 'symbol') {\n      this.ns$.set(ns);\n    } else {\n      this.ns$.set(toNamespace(ns));\n    }\n  }\n\n  /** Whether this element has been in a tree at least once. */\n  #wasConnected = false;\n\n  /** Attribute writes that came in before the first connect, the latest one per attribute. */\n  #pendingReflections?: Map<string, () => void> | undefined;\n\n  /** Takes the namespace reflection off again. */\n  #nsReflection?: (() => void) | undefined;\n\n  constructor() {\n    super();\n\n    // Nothing is listening at this point, and the read does not need anything to: it puts into the\n    // signal what the attribute spells, normalised \u2014 `ns=\"  local  \"` becomes `local`. The\n    // normalised value reaches the attribute at the first connect, where `restore()` writes every\n    // reflecting signal back out.\n    updateNamespace(this, this.ns$);\n  }\n\n  /**\n   * Take up everything this element listens to.\n   *\n   * Private rather than overridable, and called from {@link ShaeElement.restore} alone: a subclass\n   * extends the pair `restore()`/`teardown()`, which is where its own signals are there to be\n   * subscribed to.\n   */\n  #subscribe(): void {\n    this.#nsReflection = this.ns$.onChange((ns) => this.#reflectNamespace(ns));\n  }\n\n  #reflectNamespace(ns: NamespaceType): void {\n    this.reflectAttribute(ATTR_NS, () => {\n      if (typeof ns === 'string' && ns.length > 0) {\n        if (this.getAttribute(ATTR_NS) !== ns) {\n          this.setAttribute(ATTR_NS, ns);\n        }\n      } else {\n        this.removeAttribute(ATTR_NS);\n      }\n    });\n  }\n\n  /**\n   * Take the namespace subscription up, and catch up on what changed while nothing was listening.\n   * The namespace half of {@link ShaeLifecycleElement.restore}.\n   *\n   * The catch-up is the half that is easy to leave out and expensive to miss. A released element\n   * still takes writes \u2014 the signals are alive \u2014 but nothing carries them onto the attributes, so\n   * the two drift apart. Writing the signal's value back here settles that before anything reads an\n   * attribute again: without it, the attribute read on the way in would push the *old* value back\n   * into the signal and the write would be lost without a word. At the first connect the same\n   * write is what carries the normalisation of the constructor's attribute read onto the attribute.\n   */\n  protected override restore(): void {\n    super.restore();\n\n    this.#subscribe();\n    this.#reflectNamespace(this.ns$.value);\n  }\n\n  /**\n   * Writes an attribute back from a signal, or holds the write until the element first connects.\n   *\n   * A write is parked whenever it happens before the element has connected once \u2014 `restore()`'s\n   * own writes on the very first connect are one source, carrying every reflecting signal out to\n   * its attribute, including whatever the constructor's attribute read normalised; any other\n   * write that lands ahead of that first connect is parked the same way. `restore()`'s call sits\n   * in front of the gate on purpose: a `setAttribute` from inside it would re-enter\n   * `attributeChangedCallback` while the subscriptions are still being set up, and running the\n   * writes a few lines further on, once the element is whole, is cheaper than making every\n   * subscription survive being read halfway through. A later write for the same attribute\n   * replaces the parked one \u2014 only the value the signal ends up with is worth writing.\n   *\n   * What is written back on connect is what the signals already carry, so the\n   * `attributeChangedCallback` it triggers sets each signal to the value it is already on. For a\n   * signal holding a scalar that is no change and reaches no handler at all; for one holding a\n   * fresh object on every read \u2014 `forward-custom-events` builds a new `Set` per read \u2014 the write\n   * counts as a change by identity and the reflecting handler runs once more, where the guard on\n   * the attribute value it already wrote stops the second write. Either way the attribute ends up\n   * on the value the signal carries.\n   */\n  protected reflectAttribute(name: string, write: () => void): void {\n    if (this.#wasConnected) {\n      write();\n    } else {\n      this.#pendingReflections ??= new Map();\n      this.#pendingReflections.set(name, write);\n    }\n  }\n\n  override connectedCallback() {\n    // the whole body outside whatever reactive context the caller is in, for the reason spelled out\n    // in `ShaeLifecycleElement.connectedCallback`. Nesting is fine: `super.connectedCallback()`\n    // opens a frame of its own inside this one\n    hibernate(() => {\n      super.connectedCallback();\n\n      // the gate is \"has been connected once\", not \"is connected now\": what is held back is only\n      // what accrues before the very first connect \u2014 the reflections `restore()` just wrote among\n      // them, which is why the flag falls behind that call. An element between its teardown and its\n      // return reflects nothing for a different reason \u2014 it has no reflecting handler at that\n      // point, and `restore()` settles the difference on the way back in. And the flag is set\n      // before the parked writes run, so a write that triggers another one goes straight through\n      // instead of landing in a map nobody reads again\n      this.#wasConnected = true;\n\n      const pending = this.#pendingReflections;\n      this.#pendingReflections = undefined;\n      if (pending) {\n        for (const write of pending.values()) {\n          write();\n        }\n      }\n    });\n  }\n\n  /**\n   * Release the namespace reflection. The namespace half of {@link ShaeLifecycleElement.teardown}.\n   *\n   * `#pendingReflections` is left alone on purpose: it holds every write parked before the\n   * element's first connect, and that connect is what drains it \u2014 a `destroy()` reached first\n   * leaves the map standing for whichever connect comes next.\n   */\n  protected override teardown(): void {\n    this.#nsReflection?.();\n    this.#nsReflection = undefined;\n\n    super.teardown();\n  }\n\n  attributeChangedCallback(name: string) {\n    if (name === ATTR_NS) {\n      updateNamespace(this, this.ns$);\n    }\n  }\n\n  /**\n   * Hand the environment of this element's namespace on to the next `sync()` \u2014 the unconfirmed\n   * path.\n   *\n   * Over a worker it learns nothing of a confirmation the Shadow Environment refused, and no\n   * `syncfailed` event follows. Whoever needs to know switches `auto-sync` off and runs\n   * `syncWait()` from their own loop.\n   */\n  syncShadowObjects() {\n    collectForSync(this.ns);\n  }\n\n  /**\n   * Sync the environment of `ns` instead of the one this element sits in right now.\n   *\n   * For the moment an element changes namespaces: the environment it leaves has a change trail\n   * waiting for it, and `this.ns` no longer points at it.\n   */\n  protected syncShadowObjectsOf(ns: NamespaceType) {\n    collectForSync(ns);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
 }

package/src/elements/ShaeEntElement.d.ts

@@ -1,3 +1,4 @@
+import { ConsoleLogger } from '../utils/ConsoleLogger.js';
 import { ComponentContext } from '../view/ComponentContext.js';
 import { ViewComponent } from '../view/ViewComponent.js';
 import { ShaeElement } from './ShaeElement.js';
@@ -9,18 +10,55 @@ export declare class ShaeEntElement extends ShaeElement {
     readonly viewComponent$: import("@spearwolf/signalize").Signal<ViewComponent | undefined>;
     readonly token$: import("@spearwolf/signalize").Signal<string | undefined>;
     readonly forwardCustomEvents$: import("@spearwolf/signalize").Signal<boolean | Set<string>>;
+    /** The logger this element reports through: a subclass reads it and does not replace it. */
+    protected get logger(): ConsoleLogger;
     get componentContext(): ComponentContext | undefined;
     get viewComponent(): ViewComponent | undefined;
     get uuid(): string | undefined;
     get token(): string | undefined;
     set token(token: string | undefined);
-    entParentNode?: ShaeEntElement;
+    entParentNode?: ShaeEntElement | undefined;
     constructor();
+    /**
+     * Take the subscriptions up and settle what drifted while none of them were listening.
+     *
+     * Runs on the first connect, where this element has never listened to anything, and again for one
+     * that comes back after a teardown.
+     *
+     * The three catch-up calls are not decoration. A released element still takes writes, so `token`,
+     * `ns` and `forward-custom-events` can each stand on a value its attribute never heard about —
+     * and `connectedCallback` reads exactly those attributes back into exactly those signals a few
+     * lines further on. Without the catch-up that read would overwrite the newer value with the older
+     * one, and the entity would go on carrying a token nobody wrote.
+     *
+     * `super.restore()` runs first and takes `ns` with it. That it writes the `ns` attribute before
+     * this class has re-subscribed to `ns$` costs nothing: the write puts the value the signal
+     * already holds onto the attribute, so the read it triggers changes no signal and reaches no
+     * handler.
+     */
+    protected restore(): void;
     findShadowRootHost(): HTMLElement | undefined;
     protected getParentNodeForObserver(): Node | undefined;
     connectedCallback(): void;
     onParentChanged(_newParent: Node | undefined, _oldParent: Node): void;
     attributeChangedCallback(name: string): void;
     disconnectedCallback(): void;
+    /**
+     * Let go of everything this element listens to, and leave what it is made of standing.
+     *
+     * The signals are not destroyed — they are what carries this element's state across a teardown,
+     * and {@link ShaeEntElement.restore} subscribes to them again on the way back in.
+     *
+     * The `ViewComponent` stays too. `disconnectedCallback` has already taken it out of its
+     * `ComponentContext`, which is what unbinds it from this element's position; ending it on top of
+     * that would write a destroy entry into the change trail and take the entity down in the worker
+     * — a decision about the entity, not about this element. It is also what lets an element that
+     * comes back carry the same entity and the same uuid it left with.
+     *
+     * Both effects run their cleanup on `destroy()`, which is what this depends on: the one on the
+     * `dispatchEvent` patch has to, or the patched function would go on holding the component and
+     * everything reachable from it.
+     */
+    protected teardown(): void;
 }
 //# sourceMappingURL=ShaeEntElement.d.ts.map

package/src/elements/ShaeEntElement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaeEntElement.d.ts","sourceRoot":"","sources":["../../../src/elements/ShaeEntElement.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,gBAAgB,EAAC,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAEvD,OAAO,EAAC,WAAW,EAAC,MAAM,kBAAkB,CAAC;AAE7C,qBAAa,cAAe,SAAQ,WAAW;;IAC7C,OAAgB,kBAAkB,WAA+E;IAEjH,QAAQ,CAAC,gBAAgB,QAAQ;IAEjC,QAAQ,CAAC,iBAAiB,sEAAgD;IAC1E,QAAQ,CAAC,cAAc,mEAA6C;IACpE,QAAQ,CAAC,MAAM,4DAAsC;IACrD,QAAQ,CAAC,oBAAoB,+DAA8C;IAE3E,IAAI,gBAAgB,IAAI,gBAAgB,GAAG,SAAS,CAEnD;IAED,IAAI,aAAa,IAAI,aAAa,GAAG,SAAS,CAE7C;IAED,IAAI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;IAED,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAE9B;IAED,IAAI,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAElC;IAED,aAAa,CAAC,EAAE,cAAc,CAAC;;IAoJ/B,kBAAkB,IAAI,WAAW,GAAG,SAAS;IAmB7C,SAAS,CAAC,wBAAwB,IAAI,IAAI,GAAG,SAAS;IAOtD,iBAAiB;IAmDjB,eAAe,CAAC,UAAU,EAAE,IAAI,GAAG,SAAS,EAAE,UAAU,EAAE,IAAI;IAUrD,wBAAwB,CAAC,IAAI,EAAE,MAAM;IAS9C,oBAAoB;CAgJrB"}
+{"version":3,"file":"ShaeEntElement.d.ts","sourceRoot":"","sources":["../../../src/elements/ShaeEntElement.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,aAAa,EAAC,MAAM,2BAA2B,CAAC;AAExD,OAAO,EAAC,gBAAgB,EAAC,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAavD,OAAO,EAAC,WAAW,EAAC,MAAM,kBAAkB,CAAC;AAiD7C,qBAAa,cAAe,SAAQ,WAAW;;IAC7C,OAAgB,kBAAkB,WAA+E;IAEjH,QAAQ,CAAC,gBAAgB,QAAQ;IAEjC,QAAQ,CAAC,iBAAiB,sEAAgD;IAC1E,QAAQ,CAAC,cAAc,mEAA6C;IACpE,QAAQ,CAAC,MAAM,4DAAsC;IACrD,QAAQ,CAAC,oBAAoB,+DAA8C;IAI3E,4FAA4F;IAC5F,SAAS,KAAK,MAAM,IAAI,aAAa,CAEpC;IAED,IAAI,gBAAgB,IAAI,gBAAgB,GAAG,SAAS,CAEnD;IAED,IAAI,aAAa,IAAI,aAAa,GAAG,SAAS,CAE7C;IAED,IAAI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;IAED,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAE9B;IAED,IAAI,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAElC;IAED,aAAa,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IAuD3C,cAOC;IAgID;;;;;;;;;;;;;;;;OAgBG;IACH,UAAmB,OAAO,IAAI,IAAI,CAOjC;IAuED,kBAAkB,IAAI,WAAW,GAAG,SAAS,CAM5C;IAED,SAAS,CAAC,wBAAwB,IAAI,IAAI,GAAG,SAAS,CAKrD;IAEQ,iBAAiB,SA0EzB;IA8ED,eAAe,CAAC,UAAU,EAAE,IAAI,GAAG,SAAS,EAAE,UAAU,EAAE,IAAI,QAO7D;IAEQ,wBAAwB,CAAC,IAAI,EAAE,MAAM,QAO7C;IAEQ,oBAAoB,SAwC5B;IAED;;;;;;;;;;;;;;;OAeG;IACH,UAAmB,QAAQ,SA2C1B;CAsOF"}