@loadbare/app 0.14.0 → 0.15.0

package/dist/hub/lb-lifecycle.js

@@ -0,0 +1,140 @@
+/// <reference lib="dom" />
+/**
+ * The hub's lifecycle — see docs/reference/custom-elements.md, When its code
+ * runs.
+ *
+ * A custom element hears what the hub did to it, in the hub's terms, rather
+ * than the browser's insertions. The hub knows every moment it places an
+ * element and every moment it removes one, so it says so: `lbAttached` once
+ * the element is placed and filled, `lbDetached` once it is gone. A move, or
+ * `lb-show` parking an element and bringing it back, is neither, and the
+ * element hears nothing.
+ *
+ * Placing is noted as it happens and told at the end of the landing that
+ * follows, so an element is filled before it hears it, and an outer element
+ * hears it before the ones inside it.
+ *
+ * Every custom element the hub places has upgraded before it is filled: a
+ * live row and a group are imported into the document, and an absent branch
+ * is imported again as it arrives — see upgradeAbsent().
+ */
+import { ATTR_GROUP_LEAVING, ATTR_ROW_LEAVING, ATTR_SHOW, } from "../core/lb-constants.js";
+/** The template holding an absent branch — see ATTR_SHOW. */
+export const PARKED = `template[${ATTR_SHOW}]`;
+/** A row or a group on its way out. */
+export const LEAVING = `[${ATTR_ROW_LEAVING}], [${ATTR_GROUP_LEAVING}]`;
+/** An Element's nodeType. Tier 3 has no `Node` global to read it from. */
+const ELEMENT_NODE = 1;
+/** Every custom element the hub has attached and not yet detached. */
+const attached = new WeakSet();
+/** What the hub has placed since the last landing ended. */
+let placedSince = [];
+/** A custom element whose class has run on it. */
+function upgraded(el) {
+    if (!el.localName.includes("-"))
+        return false;
+    const registry = globalThis
+        .customElements;
+    const defined = registry?.get(el.localName);
+    return defined !== undefined && el instanceof defined;
+}
+/**
+ * Every upgraded custom element at and under `root`, in tree order, outer
+ * before inner. An absent branch is searched where its template stands.
+ */
+function customIn(root, found) {
+    if (root.nodeType === ELEMENT_NODE && upgraded(root)) {
+        found.push(root);
+    }
+    for (const child of root.children) {
+        customIn(child.matches(PARKED) ? child.content : child, found);
+    }
+}
+/** Call one of the hub's methods, if the element has it. */
+function tell(el, method, ...args) {
+    const fn = el[method];
+    try {
+        fn?.apply(el, args);
+    }
+    catch (err) {
+        console.error(`lb-hub: <${el.localName}> ${method} threw`, err);
+    }
+}
+/**
+ * Make every absent branch under `root` from elements that have upgraded.
+ *
+ * The builder ships each `lb-show` element inside its template, and a
+ * template's content belongs to a document with no definitions, so nothing
+ * shipped there has upgraded. Importing the branch into `doc` upgrades it as
+ * it is made, and it goes back into its template already the class it will
+ * be when it shows: the hub sets a control's `value` while it is away, and
+ * calls its methods, as on any other.
+ *
+ * Called on what the hub places before anything lands on it, while every
+ * branch is as the builder shipped it.
+ */
+export function upgradeAbsent(root, doc) {
+    for (const parked of root.querySelectorAll(PARKED)) {
+        const content = parked.content;
+        const branch = content.firstElementChild;
+        if (!branch)
+            continue;
+        const made = doc.importNode(branch, true);
+        branch.replaceWith(made);
+        upgradeAbsent(made, doc);
+    }
+}
+/** Note that the hub has placed `root`, to attach at the end of landing. */
+export function placed(root) {
+    placedSince.push(root);
+}
+/**
+ * Attach every custom element in what the hub has placed since the last
+ * landing ended. A root inside another is reached from the outer one, so an
+ * outer element is attached before the ones inside it. An element on its way
+ * out is passed over.
+ */
+export function attachPlaced() {
+    const roots = placedSince;
+    placedSince = [];
+    const outer = roots.filter((root) => !roots.some((other) => other !== root && other.contains(root)));
+    for (const root of outer) {
+        if (root.closest(LEAVING))
+            continue;
+        const found = [];
+        customIn(root, found);
+        for (const el of found) {
+            if (attached.has(el) || el.closest(LEAVING))
+                continue;
+            attached.add(el);
+            tell(el, "lbAttached");
+        }
+    }
+}
+/**
+ * Detach every attached custom element in nodes the hub has removed, inner
+ * before outer. An element the hub never attached, such as the copy a moved
+ * row leaves behind, hears nothing.
+ */
+export function detachRemoved(nodes) {
+    const found = [];
+    for (const node of nodes) {
+        if (node.nodeType === ELEMENT_NODE)
+            customIn(node, found);
+    }
+    for (const el of found.reverse()) {
+        if (attached.delete(el))
+            tell(el, "lbDetached");
+    }
+}
+/**
+ * Tell the attached custom elements from `origin` outward how its request
+ * turned out, innermost first.
+ */
+export function requestDone(origin, detail) {
+    for (let el = origin; el; el = el.parentElement) {
+        if (attached.has(el))
+            tell(el, "lbRequestDone", detail, origin);
+    }
+}
+//# sourceMappingURL=lb-lifecycle.js.map

package/dist/hub/lb-lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lb-lifecycle.js","sourceRoot":"","sources":["../../hub/lb-lifecycle.ts"],"names":[],"mappings":"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","sourcesContent":["/// <reference lib=\"dom\" />\n\n/**\n * The hub's lifecycle — see docs/reference/custom-elements.md, When its code\n * runs.\n *\n * A custom element hears what the hub did to it, in the hub's terms, rather\n * than the browser's insertions. The hub knows every moment it places an\n * element and every moment it removes one, so it says so: `lbAttached` once\n * the element is placed and filled, `lbDetached` once it is gone. A move, or\n * `lb-show` parking an element and bringing it back, is neither, and the\n * element hears nothing.\n *\n * Placing is noted as it happens and told at the end of the landing that\n * follows, so an element is filled before it hears it, and an outer element\n * hears it before the ones inside it.\n *\n * Every custom element the hub places has upgraded before it is filled: a\n * live row and a group are imported into the document, and an absent branch\n * is imported again as it arrives — see upgradeAbsent().\n */\n\nimport {\n  ATTR_GROUP_LEAVING,\n  ATTR_ROW_LEAVING,\n  ATTR_SHOW,\n} from \"../core/lb-constants.js\";\nimport type { HubLifecycle, HubRequestDone } from \"../core/lb-types.js\";\n\n/** The template holding an absent branch — see ATTR_SHOW. */\nexport const PARKED = `template[${ATTR_SHOW}]`;\n\n/** A row or a group on its way out. */\nexport const LEAVING = `[${ATTR_ROW_LEAVING}], [${ATTR_GROUP_LEAVING}]`;\n\n/** An Element's nodeType. Tier 3 has no `Node` global to read it from. */\nconst ELEMENT_NODE = 1;\n\n/** Every custom element the hub has attached and not yet detached. */\nconst attached = new WeakSet<Element>();\n\n/** What the hub has placed since the last landing ended. */\nlet placedSince: Element[] = [];\n\n/** A custom element whose class has run on it. */\nfunction upgraded(el: Element): boolean {\n  if (!el.localName.includes(\"-\")) return false;\n  const registry = (globalThis as { customElements?: CustomElementRegistry })\n    .customElements;\n  const defined = registry?.get(el.localName);\n  return defined !== undefined && el instanceof defined;\n}\n\n/**\n * Every upgraded custom element at and under `root`, in tree order, outer\n * before inner. An absent branch is searched where its template stands.\n */\nfunction customIn(root: Element | DocumentFragment, found: Element[]): void {\n  if (root.nodeType === ELEMENT_NODE && upgraded(root as Element)) {\n    found.push(root as Element);\n  }\n  for (const child of root.children) {\n    customIn(\n      child.matches(PARKED) ? (child as HTMLTemplateElement).content : child,\n      found,\n    );\n  }\n}\n\n/** Call one of the hub's methods, if the element has it. */\nfunction tell<K extends keyof HubLifecycle>(\n  el: Element,\n  method: K,\n  ...args: Parameters<NonNullable<HubLifecycle[K]>>\n): void {\n  const fn = (el as Element & HubLifecycle)[method] as\n    ((...a: typeof args) => void) | undefined;\n  try {\n    fn?.apply(el, args);\n  } catch (err) {\n    console.error(`lb-hub: <${el.localName}> ${method} threw`, err);\n  }\n}\n\n/**\n * Make every absent branch under `root` from elements that have upgraded.\n *\n * The builder ships each `lb-show` element inside its template, and a\n * template's content belongs to a document with no definitions, so nothing\n * shipped there has upgraded. Importing the branch into `doc` upgrades it as\n * it is made, and it goes back into its template already the class it will\n * be when it shows: the hub sets a control's `value` while it is away, and\n * calls its methods, as on any other.\n *\n * Called on what the hub places before anything lands on it, while every\n * branch is as the builder shipped it.\n */\nexport function upgradeAbsent(\n  root: Element | DocumentFragment,\n  doc: Document,\n): void {\n  for (const parked of root.querySelectorAll(PARKED)) {\n    const content = (parked as HTMLTemplateElement).content;\n    const branch = content.firstElementChild;\n    if (!branch) continue;\n    const made = doc.importNode(branch, true);\n    branch.replaceWith(made);\n    upgradeAbsent(made, doc);\n  }\n}\n\n/** Note that the hub has placed `root`, to attach at the end of landing. */\nexport function placed(root: Element): void {\n  placedSince.push(root);\n}\n\n/**\n * Attach every custom element in what the hub has placed since the last\n * landing ended. A root inside another is reached from the outer one, so an\n * outer element is attached before the ones inside it. An element on its way\n * out is passed over.\n */\nexport function attachPlaced(): void {\n  const roots = placedSince;\n  placedSince = [];\n  const outer = roots.filter(\n    (root) => !roots.some((other) => other !== root && other.contains(root)),\n  );\n  for (const root of outer) {\n    if (root.closest(LEAVING)) continue;\n    const found: Element[] = [];\n    customIn(root, found);\n    for (const el of found) {\n      if (attached.has(el) || el.closest(LEAVING)) continue;\n      attached.add(el);\n      tell(el, \"lbAttached\");\n    }\n  }\n}\n\n/**\n * Detach every attached custom element in nodes the hub has removed, inner\n * before outer. An element the hub never attached, such as the copy a moved\n * row leaves behind, hears nothing.\n */\nexport function detachRemoved(nodes: Iterable<ChildNode>): void {\n  const found: Element[] = [];\n  for (const node of nodes) {\n    if (node.nodeType === ELEMENT_NODE) customIn(node as Element, found);\n  }\n  for (const el of found.reverse()) {\n    if (attached.delete(el)) tell(el, \"lbDetached\");\n  }\n}\n\n/**\n * Tell the attached custom elements from `origin` outward how its request\n * turned out, innermost first.\n */\nexport function requestDone(origin: Element, detail: HubRequestDone): void {\n  for (let el: Element | null = origin; el; el = el.parentElement) {\n    if (attached.has(el)) tell(el, \"lbRequestDone\", detail, origin);\n  }\n}\n"]}

package/docs/TECHREF-1.0.md

@@ -715,10 +715,9 @@ standing where it stood, and moved back out when the column turns on.  It is
 not rendered, focused, clicked, announced or gathered.  It is moved and
 never rebuilt, so a custom element keeps its instance and a control keeps
 what was typed into it.  Landing reaches into that template, so the element
-and everything inside it return current.  A custom element sees
-`disconnectedCallback` then `adoptedCallback` going in, and
-`adoptedCallback` then `connectedCallback` coming out, and still receives
-`lb-column-value` while it is away.
+and everything inside it return current.  A custom element hears nothing
+going in or coming out, and still receives `lb-column-value` while it is
+away.
 
 The builder ships every `lb-show` element already inside its template, so
 nothing conditional shows until its row lands.  An absent element's template
@@ -1098,8 +1097,10 @@ makes a confirmation wrapper possible without the wrapped element knowing
 about it.
 
 Once what the request brought back has landed, or its round trip has failed,
-the hub dispatches the bubbling `lb-request-done` event from the same
-element.  Its `detail`, `HubRequestDone` in `@loadbare/app/types`, holds
+the hub calls `lbRequestDone(detail, origin)` on the committing element and
+every custom element around it, innermost first (see
+[Lifecycle](#lifecycle)), then dispatches the bubbling `lb-request-done`
+event from the same element.  Its `detail`, `HubRequestDone` in `@loadbare/app/types`, holds
 the request as the hub sent it and `items`, every response item that landed
 because of it, in order.  An answer that moved the URL contributes its
 `lb-url` item and the page load.  `error` is set instead when the round trip
@@ -1884,14 +1885,12 @@ Each direction has one mechanism for each kind of message:
 | -------------- | ------------------------------------------- | ---------------------------- | ------------------------------------------------ |
 | Hub to element | State that lasts                            | An attribute the hub stamps  | `lb-column-value`, `lb-key-value`, `lb-query-row-count`, `lb-group-*`, `lb-row-*`, `lb-request-pending`, `lb-request-error` |
 | Hub to element | State the platform already names           | A property                   | A control's `value`                              |
-| Hub to element | Work the hub needs done now, while landing  | An optional `lb` method      | `lbRowsLanded`                                   |
+| Hub to element | What the hub did                            | An optional `lb` method      | `lbAttached`, `lbRowsLanded`, `lbRequestDone`, `lbDetached` |
 | Hub to element | A moment an element started                 | A bubbling event             | `lb-request-done`                                |
 | Element to hub | A moment                                    | A bubbling event             | `lb-request`, and `change`, `click` and `submit` |
 
-State is an attribute, because a stylesheet can select on it and an element
-that upgrades late still finds it.  A method is for work the hub cannot go
-on without, since it acts on one element at one point in landing and nothing
-else can do it.  A moment is an event, because the element that cares is
+State is an attribute, because a stylesheet can select on it.  A method is
+how the hub tells one element what it just did to that element.  A moment is an event, because the element that cares is
 often an ancestor of the one it concerns, and an event reaches it with no
 knowledge of either.
 
@@ -1910,45 +1909,47 @@ class NoteField extends HTMLElement {
 }
 ```
 
-A control that is not yet upgraded when its column lands receives
-`lb-column-value` alone, since the hub sets `value` only on a control.  That
-happens to an element the builder shipped absent, and to one whose
-definition loads after the hub lands.  A control takes the stamp up the
-first time it connects, and never again.
-
 A custom element that is not a control receives `lb-column-value` and
 renders it; its content is never replaced.
 
 ### Lifecycle
 
-| The hub                                  | A custom element sees                        |
-| ---------------------------------------- | -------------------------------------------- |
-| Shows a page                             | `constructor`, `connectedCallback`           |
-| Creates a live row, before placing it    | `constructor`                                |
-| Places a live row the first time         | `connectedCallback`                          |
-| Moves a live row the order put elsewhere | `connectedMoveCallback` where the browser moves in place, otherwise `disconnectedCallback`, `connectedCallback` |
-| Leaves a copy of a moved row behind      | The copy's `constructor`, `connectedCallback`, and later `disconnectedCallback` |
-| Removes a live row                       | `disconnectedCallback`, once its animations end |
-| Turns `lb-show` off                      | `disconnectedCallback`, `adoptedCallback`    |
-| Turns `lb-show` on                       | `adoptedCallback`, `connectedCallback`       |
-| Turns on an element shipped absent       | `constructor`, `connectedCallback`           |
+A custom element hears the hub's lifecycle, never the browser's.  The hub
+calls four optional methods, which the `HubLifecycle` interface in
+`@loadbare/app/types` declares:
+
+| The hub                                          | A custom element hears          |
+| ------------------------------------------------ | ------------------------------- |
+| Places it: chrome at startup, a page, a new live row, a new group | `lbAttached()`, once, after every column has landed on it |
+| Lands rows on it                                 | `lbRowsLanded()`                |
+| Finishes a request committed by it or inside it  | `lbRequestDone(detail, origin)` |
+| Removes it: a row or group done leaving, the page replaced | `lbDetached()`, once  |
+| Moves a live row the order put elsewhere         | Nothing                         |
+| Turns `lb-show` off or on                        | Nothing                         |
+| Leaves a copy of a moved row behind              | Nothing, on the copy            |
+
+The chrome and a page are placed as the page's first answer lands, or once
+that round trip fails.  An element under an `lb-show` that is off is placed
+inside its template, so `lbAttached` runs whether it shows or not.  `lbAttached` reaches an outer
+custom element before the ones inside it, and `lbDetached` the inner ones
+first.  `lbRequestDone` reaches the committing element and every custom
+element around it, innermost first, before the `lb-request-done` event.
+An element a script creates hears none of them.
 
 A listener on the element itself goes in the constructor, which reads no
-attribute and no child.  A child is looked up when it is needed.
-`connectedCallback` runs on every move and is written to run again; work
-done once per instance goes behind a flag.
+attribute and no child.  A child is looked up when it is needed.  Work done
+once per instance goes in `lbAttached`, and its undoing in `lbDetached`.
 
-### Row hooks
+The build refuses a script that declares `connectedCallback`,
+`disconnectedCallback`, `adoptedCallback` or `connectedMoveCallback`.
 
-| Method           | Implemented By | The hub calls it                                       |
-| ---------------- | -------------- | ------------------------------------------------------ |
-| `lbRowsLanded()` | Developer      | After the rows land, with every row placed and stamped |
+### Row hooks
 
-The hub calls it on a custom element with `lb-query` and a row template.
-It is optional.  The `RowsHost` interface in `@loadbare/app/types` declares
-it.  The hub places every row and builds every group itself, so a custom
-element reacts to rows and never places them.  Scrolling to the row the
-page's request created is the case:
+The hub calls `lbRowsLanded()` on a custom element with `lb-query` and a row
+template, after the rows land, with every row placed and stamped.  The hub
+places every row and builds every group itself, so a custom element reacts
+to rows and never places them.  Scrolling to the row the page's request
+created is the case:
 
 ```ts
 lbRowsLanded() {
@@ -1957,10 +1958,8 @@ lbRowsLanded() {
 }
 ```
 
-A custom element the builder shipped absent under `lb-show` has not
-upgraded while its column is off.  When the column first turns on and it
-upgrades, the hub lands the query's last answer on it again, as all rows,
-so the hook runs.
+A custom element under an `lb-show` that is off holds its rows all the
+same, and the hook runs as they land.
 
 `applyRow(root, row)`, exported by `@loadbare/app`, fills `root` from one
 row, the same operation that fills a live row.
@@ -2136,9 +2135,12 @@ Loadbare/app owns every DOM event in this table, both the name and what its
 
 ### Reserved methods
 
-| Method         | On                                                 | Defined in              |
-| -------------- | -------------------------------------------------- | ----------------------- |
-| `lbRowsLanded` | A custom element with `lb-query` and a row template | [Row hooks](#row-hooks) |
+| Method          | On                                                  | Defined in              |
+| --------------- | --------------------------------------------------- | ----------------------- |
+| `lbAttached`    | Any custom element the hub places                   | [Lifecycle](#lifecycle) |
+| `lbRowsLanded`  | A custom element with `lb-query` and a row template | [Row hooks](#row-hooks) |
+| `lbRequestDone` | A custom element that committed, or holds one that did | [Lifecycle](#lifecycle) |
+| `lbDetached`    | Any custom element the hub removes                  | [Lifecycle](#lifecycle) |
 
 ### Constants
 

package/docs/comparison.md

@@ -319,10 +319,11 @@ without `.browser` is not bundled, and the build error names it.
 - A widget may send a request by dispatching a bubbling `lb-request`
   `CustomEvent`.  The hub completes it with `query`, `key` and `values` from
   where the element sits.  An ancestor may stop the event.
-- A custom element carrying `lb-query` and a row template may implement
-  `lbRowsLanded()` to act on the rows once they land, such as scrolling to
-  the one a request created.  The hub does the cloning, matching, ordering,
-  grouping, removal and counting.
+- A custom element hears the hub's lifecycle rather than the browser's:
+  `lbAttached()` and `lbDetached()` once each, when the hub places and
+  removes it, `lbRowsLanded()` once rows land on it, and `lbRequestDone()`
+  when a request from inside it finishes.  The hub does the cloning,
+  matching, ordering, grouping, removal and counting.
 - Method names beginning with `lb` on a custom element are reserved.
 
 Widget libraries are npm packages listed in `imports.ts`.  The builder scans
@@ -791,7 +792,7 @@ TECHREF-1.0 lists every name Loadbare/app owns in one cross-reference.
 | `lb-*` stamps                       | 17    | `lb-column-value`, `lb-key-value`, `lb-row-live`, `lb-query-row-count`, `lb-group-live`, `lb-group-column`, `lb-group-value`, `lb-row-created`, `lb-row-changed`, `lb-row-moved`, `lb-row-requested`, `lb-row-leaving`, `lb-group-leaving`, `lb-request-pending`, `lb-request-error`, `lb-page`, `lb-page-title` |
 | `lb-*` build-time attributes        | 2     | `lb-exp-slot`, `lb-exp-template`                              |
 | Requests Loadbare provides          | 3     | `lb-row-insert`, `lb-row-update`, `lb-row-delete`             |
-| `lb*` methods on custom elements    | 1     | `lbRowsLanded`                                                |
+| `lb*` methods on custom elements    | 4     | `lbAttached`, `lbRowsLanded`, `lbRequestDone`, `lbDetached`   |
 | Query parms Loadbare reads          | 1     | `lb-order-<query>`                                            |
 | Attribute namespace for expansion   | 1     | `exp-*`                                                       |
 | Reserved tags                       | 1     | `<lb-hub>`                                                    |
@@ -1185,6 +1186,7 @@ Each equivalent is approximate.
 | `exp-` parameter              | A prop fixed at build time                                                       |
 | `lb-exp-slot`, `lb-exp-template` | Default slot and named slots; `ng-content` with `select`                         |
 | `lbRowsLanded`                | An effect after a list renders                                                   |
+| `lbAttached`, `lbDetached`    | Mount and unmount; `onMounted` and `onUnmounted` (Vue); `onMount` and `onDestroy` (Svelte) |
 | `order`, `lb-group`           | `ORDER BY` with report-writer control breaks (`BREAK ON`, group bands)          |
 | `ctx` / `HubContext`          | `event.locals` (SvelteKit); loader `context` (React Router 7); request-scoped dependency injection |
 | `imports.ts`                  | Installing and registering a component library                                   |

package/docs/possible-ideas.md

@@ -4,6 +4,12 @@
 > 2026-10-02 against `@loadbare/app` 0.12.0, from a session in ef.  Nothing
 > here is decided or planned.
 
+> **Status, 2026-10-04.**  The lifecycle in the hub's terms was adopted, on
+> custom elements rather than on behaviors: see
+> [When its code runs](./reference/custom-elements.md#when-its-code-runs).
+> Behavior by attribute, and expansion that replaces the tag, were set aside.
+> What follows is kept as the record of how the decision was reached.
+
 ## Why these are being considered
 
 A custom element is the platform's one way to attach code to markup, and