@loadbare/app 0.9.0 → 0.10.0

package/dist/core/lb-types.d.ts

@@ -1,4 +1,4 @@
-import { ACTION_ROW_DELETE, ACTION_ROW_INSERT, ACTION_ROW_UPDATE } from "./lb-constants.js";
+import { KIND_ROW, KIND_ROWS } from "./lb-constants.js";
 /**
  * One row: its columns, by name.
  *
@@ -9,9 +9,9 @@ import { ACTION_ROW_DELETE, ACTION_ROW_INSERT, ACTION_ROW_UPDATE } from "./lb-co
  */
 export type Row = Record<string, unknown>;
 /**
- * Part of a list — see docs/reference/server.md, "Queries".
+ * Part of a `rows` query's answer — see docs/reference/server.md, "Queries".
  *
- * Rows named here arrive or are updated, keys in `drop` are gone, and
+ * Rows named here are added or updated, keys in `drop` are removed, and
  * anything unnamed is left alone: its contents, and its place in whatever
  * order the widget is keeping. Add and remove are one result rather than two
  * because the interesting cases are both at once — a row whose sort key
@@ -22,77 +22,51 @@ export interface Patch {
     rows?: Row[];
     drop?: unknown[];
 }
+/** A query's kind, declared by the server and carried by every answer. */
+export type Kind = typeof KIND_ROW | typeof KIND_ROWS;
 /**
- * What a list answers with.
- *
- * An array is the entire set and therefore also the order: a row whose key
- * is not in it is gone. A Patch disturbs only what it names.
- *
- * `Array.isArray` tells the two apart, which is why no column name has to be
- * reserved to carry a discriminant. A list answering with an object is a
- * patch, because the declaration already said this name answers with rows.
- */
-export type ListResult = Row[] | Patch;
-export declare function isPatch(result: ListResult): result is Patch;
-/**
- * What any one name answers with. Which of the two it is comes from the
- * query's own declaration, never from inspecting the value.
+ * What a `rows` query answers with: all rows, which is also their order, or
+ * a patch. `Array.isArray` tells the two apart.
  */
-export type HubResult = Row | ListResult;
+export type RowsResult = Row[] | Patch;
+export declare function isPatch(result: RowsResult): result is Patch;
+/** What any one query answers with, as the application writes it. */
+export type HubResult = Row | RowsResult;
 /**
- * Every response on the data channel is the same shape, whether it is a cold
- * start or the narrowest refresh. The hub does not know which case it is in.
- *
- * A name rides as an object key and is labelled by nothing, which is why the
- * response direction never needed a noun for the addressable thing.
+ * What application code hands the engine: answers by query name. The engine
+ * turns each into a response item, adding the kind and key the query
+ * declared.
  */
 export type HubData = Record<string, HubResult>;
 /**
- * The three operations — docs/reference/data-binding.md. The set is closed.
- *
- * `action` carries the value of `lb-action` verbatim, so the attribute, the
- * wire field and the CRUD key are one vocabulary with no translation step.
- * The scope field is `list` here because all three are list operations: each
- * needs a key, and a key exists only on a live row inside a list.
+ * One query's answer on the wire: its name, its kind, its key's column name,
+ * and exactly one of a row, all rows, or a patch. A patch answers a `rows`
+ * query only.
  */
-export type LbOperation = {
-    action: typeof ACTION_ROW_INSERT;
-    list: string;
-    values: Record<string, string>;
-} | {
-    action: typeof ACTION_ROW_DELETE;
-    list: string;
+export interface ResponseItem {
+    query: string;
+    kind: Kind;
     key: string;
-} | {
-    action: typeof ACTION_ROW_UPDATE;
-    list: string;
-    key: string;
-    values: Record<string, string>;
-};
+    row?: Row;
+    rows?: Row[];
+    patch?: Patch;
+}
+/** Every response the server sends: a page load and a request alike. */
+export type HubResponse = ResponseItem[];
 /**
- * Everything that is not one of the three.
- *
- * The name is the application's and is looked up in the page's declared
- * actions. What keeps this from being an RPC endpoint is that the name must
- * already appear in the page's requests: the browser cannot reach anything the
- * page has not published, and there is no argument list — only where the
- * interaction happened and, where a control has one, its value.
- *
- * The scope field is `list` or `row`, whichever attribute scoped the element
- * the interaction came from, so an action fired from a single-row scope says
- * so. A button carries no value, so the server computes the whole of the new
- * state and the browser never displays a number it has not confirmed. A
- * `<select>` carries one, because the choice is the interaction.
+ * Every request has one shape. The name picks the handler; the rest is
+ * present when the hub found it.
  */
-export interface DeclaredAction {
-    action: string;
-    list?: string;
-    row?: string;
+export interface HubRequest {
+    name: string;
+    query?: string;
     key?: string;
-    cell?: string;
-    value?: string;
+    values?: Record<string, string>;
 }
-export type HubRequest = LbOperation | DeclaredAction;
+/** The fields a handler receives: the request, less its name. */
+export type RequestFields = Omit<HubRequest, "name">;
+/** Whether a name is one of the requests Loadbare provides. */
+export declare function isRowRequest(name: string): boolean;
 /**
  * A query string with some parms set, and the rest as they were. An empty
  * value takes its parm out, since empty is every parm's default and a
@@ -100,30 +74,43 @@ export type HubRequest = LbOperation | DeclaredAction;
  *
  * One rule on both sides of the wire: the hub applies it to the address bar,
  * and the server to the query string it loads the page at after a request
- * returned `QUERY_PARMS_ROW`. The two must agree, or what the page shows
- * would differ from what the address bar says.
+ * returned `lb-url`. The two must agree, or what the page shows would differ
+ * from what the address bar says.
  */
 export declare function withQueryParms(search: URLSearchParams, parms: Record<string, string>): URLSearchParams;
 /**
- * The reserved prefix is the whole of the discriminant. Nothing else tells
- * an operation from a declared action, on the wire or anywhere else.
+ * A path names a page by its stub, and nothing finer. The bare path resolves
+ * to `index`, the same convention a static file server follows.
  */
-export declare function isOperation(request: HubRequest): request is LbOperation;
+export declare function pageNameFor(path: string): string;
 /**
- * The two hooks a list widget may implement, both optional.
+ * Where a row for `lb-url` leads, from a page and its query parms.
  *
- * The hub reconciles every list scope itself, so a widget supplies placement
- * and scaffolding and nothing else. A scope that implements neither is a
- * plain element with a row template inside it, which is why there is no
- * repeater widget.
+ * A column whose name begins with `lb-` is Loadbare's, and never a query
+ * parm; every other column is one. An `lb-path` naming another page enters
+ * it with only the parms the row names. Otherwise the named parms are set,
+ * or taken out when empty, and the rest are kept.
+ *
+ * One rule on both sides of the wire: the server loads the page it names,
+ * and the hub writes the URL it names. The two must agree, or what the page
+ * shows would differ from what the address bar says.
+ */
+export declare function nextLocation(page: string, parms: URLSearchParams, row: Row): {
+    page: string;
+    parms: URLSearchParams;
+    moved: boolean;
+};
+/**
+ * The two hooks a custom element holding rows may implement, both optional.
  *
- * They are methods on an element the hub does not own, so they carry the
- * `lb` prefix that Loadbare reserves for exactly that — see
- * docs/reference/custom-elements.md.
+ * The hub reconciles every row template itself, so a custom element supplies
+ * placement and scaffolding and nothing else. They are methods on an element
+ * the hub does not own, so they carry the `lb` prefix Loadbare reserves for
+ * exactly that — see docs/reference/custom-elements.md.
  */
-export interface ListHost {
+export interface RowsHost {
     /**
-     * Where a row belongs, called with the row detached on its first
+     * Where a live row belongs, called with the row detached on its first
      * appearance. Without it a row lands immediately before the template, so
      * rows accumulate in the order they arrive.
      */

package/dist/core/lb-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lb-types.d.ts","sourceRoot":"","sources":["../../core/lb-types.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EAElB,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;GAOG;AACH,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1C;;;;;;;;;GASG;AACH,MAAM,WAAW,KAAK;IACpB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACb,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG,GAAG,EAAE,GAAG,KAAK,CAAC;AAEvC,wBAAgB,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,IAAI,KAAK,CAE3D;AAED;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,GAAG,GAAG,UAAU,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GACnB;IACE,MAAM,EAAE,OAAO,iBAAiB,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC,GACD;IAAE,MAAM,EAAE,OAAO,iBAAiB,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC/D;IACE,MAAM,EAAE,OAAO,iBAAiB,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC,CAAC;AAEN;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,cAAc,CAAC;AAEtD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5B,eAAe,CAOjB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,IAAI,WAAW,CAEvE;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;OAIG;IACH,UAAU,CAAC,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAExE,4EAA4E;IAC5E,YAAY,CAAC,IAAI,IAAI,CAAC;CACvB"}
+{"version":3,"file":"lb-types.d.ts","sourceRoot":"","sources":["../../core/lb-types.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,QAAQ,EACR,SAAS,EAIV,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;GAOG;AACH,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1C;;;;;;;;;GASG;AACH,MAAM,WAAW,KAAK;IACpB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACb,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;CAClB;AAED,0EAA0E;AAC1E,MAAM,MAAM,IAAI,GAAG,OAAO,QAAQ,GAAG,OAAO,SAAS,CAAC;AAEtD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,GAAG,EAAE,GAAG,KAAK,CAAC;AAEvC,wBAAgB,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,IAAI,KAAK,CAE3D;AAED,qEAAqE;AACrE,MAAM,MAAM,SAAS,GAAG,GAAG,GAAG,UAAU,CAAC;AAEzC;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAEhD;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,IAAI,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACb,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,wEAAwE;AACxE,MAAM,MAAM,WAAW,GAAG,YAAY,EAAE,CAAC;AAEzC;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,iEAAiE;AACjE,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;AAErD,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5B,eAAe,CAOjB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,GAAG,GACP;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAc1D;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;OAIG;IACH,UAAU,CAAC,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAExE,4EAA4E;IAC5E,YAAY,CAAC,IAAI,IAAI,CAAC;CACvB"}

package/dist/core/lb-types.js

@@ -1,9 +1,13 @@
 /// <reference lib="dom" />
 // The wire vocabulary. Shared by browser and server.
-import { LB_RESERVED_PREFIX, } from "./lb-constants.js";
+import { LB_RESERVED_PREFIX, LB_ROW_REQUESTS, URL_COLUMN_PATH, } from "./lb-constants.js";
 export function isPatch(result) {
     return !Array.isArray(result);
 }
+/** Whether a name is one of the requests Loadbare provides. */
+export function isRowRequest(name) {
+    return LB_ROW_REQUESTS.includes(name);
+}
 /**
  * A query string with some parms set, and the rest as they were. An empty
  * value takes its parm out, since empty is every parm's default and a
@@ -11,8 +15,8 @@ export function isPatch(result) {
  *
  * One rule on both sides of the wire: the hub applies it to the address bar,
  * and the server to the query string it loads the page at after a request
- * returned `QUERY_PARMS_ROW`. The two must agree, or what the page shows
- * would differ from what the address bar says.
+ * returned `lb-url`. The two must agree, or what the page shows would differ
+ * from what the address bar says.
  */
 export function withQueryParms(search, parms) {
     const next = new URLSearchParams(search);
@@ -25,10 +29,39 @@ export function withQueryParms(search, parms) {
     return next;
 }
 /**
- * The reserved prefix is the whole of the discriminant. Nothing else tells
- * an operation from a declared action, on the wire or anywhere else.
+ * A path names a page by its stub, and nothing finer. The bare path resolves
+ * to `index`, the same convention a static file server follows.
  */
-export function isOperation(request) {
-    return request.action.startsWith(LB_RESERVED_PREFIX);
+export function pageNameFor(path) {
+    const name = path.replace(/^\/+|\/+$/g, "");
+    return name === "" ? "index" : name;
+}
+/**
+ * Where a row for `lb-url` leads, from a page and its query parms.
+ *
+ * A column whose name begins with `lb-` is Loadbare's, and never a query
+ * parm; every other column is one. An `lb-path` naming another page enters
+ * it with only the parms the row names. Otherwise the named parms are set,
+ * or taken out when empty, and the rest are kept.
+ *
+ * One rule on both sides of the wire: the server loads the page it names,
+ * and the hub writes the URL it names. The two must agree, or what the page
+ * shows would differ from what the address bar says.
+ */
+export function nextLocation(page, parms, row) {
+    const named = {};
+    for (const [name, value] of Object.entries(row)) {
+        if (name.startsWith(LB_RESERVED_PREFIX))
+            continue;
+        named[name] = value === null || value === undefined ? "" : String(value);
+    }
+    const path = row[URL_COLUMN_PATH];
+    const next = typeof path === "string" ? pageNameFor(path) : page;
+    const moved = next !== page;
+    return {
+        page: next,
+        parms: withQueryParms(moved ? new URLSearchParams() : parms, named),
+        moved,
+    };
 }
 //# sourceMappingURL=lb-types.js.map

package/dist/core/lb-types.js.map

@@ -1 +1 @@
-{"version":3,"file":"lb-types.js","sourceRoot":"","sources":["../../core/lb-types.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAE3B,qDAAqD;AAErD,OAAO,EAIL,kBAAkB,GACnB,MAAM,mBAAmB,CAAC;AAuC3B,MAAM,UAAU,OAAO,CAAC,MAAkB;IACxC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;AAChC,CAAC;AAiED;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAC5B,MAAuB,EACvB,KAA6B;IAE7B,MAAM,IAAI,GAAG,IAAI,eAAe,CAAC,MAAM,CAAC,CAAC;IACzC,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAClD,IAAI,KAAK,KAAK,EAAE;YAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;;YAC/B,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC7B,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,OAAmB;IAC7C,OAAO,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,kBAAkB,CAAC,CAAC;AACvD,CAAC","sourcesContent":["/// <reference lib=\"dom\" />\n\n// The wire vocabulary. Shared by browser and server.\n\nimport {\n  ACTION_ROW_DELETE,\n  ACTION_ROW_INSERT,\n  ACTION_ROW_UPDATE,\n  LB_RESERVED_PREFIX,\n} from \"./lb-constants.js\";\n\n/**\n * One row: its columns, by name.\n *\n * A value is whatever the server serialized. The hub knows nothing about its\n * type and enforces nothing: it hands each value to the browser untouched,\n * and the browser renders it as it sees fit. What a number, a date or a null\n * should look like is the application's decision, made in the query.\n */\nexport type Row = Record<string, unknown>;\n\n/**\n * Part of a list — see docs/reference/server.md, \"Queries\".\n *\n * Rows named here arrive or are updated, keys in `drop` are gone, and\n * anything unnamed is left alone: its contents, and its place in whatever\n * order the widget is keeping. Add and remove are one result rather than two\n * because the interesting cases are both at once — a row whose sort key\n * changed has to move, a swap is one out and one in — and two messages would\n * paint the intermediate state.\n */\nexport interface Patch {\n  rows?: Row[];\n  drop?: unknown[];\n}\n\n/**\n * What a list answers with.\n *\n * An array is the entire set and therefore also the order: a row whose key\n * is not in it is gone. A Patch disturbs only what it names.\n *\n * `Array.isArray` tells the two apart, which is why no column name has to be\n * reserved to carry a discriminant. A list answering with an object is a\n * patch, because the declaration already said this name answers with rows.\n */\nexport type ListResult = Row[] | Patch;\n\nexport function isPatch(result: ListResult): result is Patch {\n  return !Array.isArray(result);\n}\n\n/**\n * What any one name answers with. Which of the two it is comes from the\n * query's own declaration, never from inspecting the value.\n */\nexport type HubResult = Row | ListResult;\n\n/**\n * Every response on the data channel is the same shape, whether it is a cold\n * start or the narrowest refresh. The hub does not know which case it is in.\n *\n * A name rides as an object key and is labelled by nothing, which is why the\n * response direction never needed a noun for the addressable thing.\n */\nexport type HubData = Record<string, HubResult>;\n\n/**\n * The three operations — docs/reference/data-binding.md. The set is closed.\n *\n * `action` carries the value of `lb-action` verbatim, so the attribute, the\n * wire field and the CRUD key are one vocabulary with no translation step.\n * The scope field is `list` here because all three are list operations: each\n * needs a key, and a key exists only on a live row inside a list.\n */\nexport type LbOperation =\n  | {\n      action: typeof ACTION_ROW_INSERT;\n      list: string;\n      values: Record<string, string>;\n    }\n  | { action: typeof ACTION_ROW_DELETE; list: string; key: string }\n  | {\n      action: typeof ACTION_ROW_UPDATE;\n      list: string;\n      key: string;\n      values: Record<string, string>;\n    };\n\n/**\n * Everything that is not one of the three.\n *\n * The name is the application's and is looked up in the page's declared\n * actions. What keeps this from being an RPC endpoint is that the name must\n * already appear in the page's requests: the browser cannot reach anything the\n * page has not published, and there is no argument list — only where the\n * interaction happened and, where a control has one, its value.\n *\n * The scope field is `list` or `row`, whichever attribute scoped the element\n * the interaction came from, so an action fired from a single-row scope says\n * so. A button carries no value, so the server computes the whole of the new\n * state and the browser never displays a number it has not confirmed. A\n * `<select>` carries one, because the choice is the interaction.\n */\nexport interface DeclaredAction {\n  action: string;\n  list?: string;\n  row?: string;\n  key?: string;\n  cell?: string;\n  value?: string;\n}\n\nexport type HubRequest = LbOperation | DeclaredAction;\n\n/**\n * A query string with some parms set, and the rest as they were. An empty\n * value takes its parm out, since empty is every parm's default and a\n * default is left out of the URL.\n *\n * One rule on both sides of the wire: the hub applies it to the address bar,\n * and the server to the query string it loads the page at after a request\n * returned `QUERY_PARMS_ROW`. The two must agree, or what the page shows\n * would differ from what the address bar says.\n */\nexport function withQueryParms(\n  search: URLSearchParams,\n  parms: Record<string, string>,\n): URLSearchParams {\n  const next = new URLSearchParams(search);\n  for (const [name, value] of Object.entries(parms)) {\n    if (value === \"\") next.delete(name);\n    else next.set(name, value);\n  }\n  return next;\n}\n\n/**\n * The reserved prefix is the whole of the discriminant. Nothing else tells\n * an operation from a declared action, on the wire or anywhere else.\n */\nexport function isOperation(request: HubRequest): request is LbOperation {\n  return request.action.startsWith(LB_RESERVED_PREFIX);\n}\n\n/**\n * The two hooks a list widget may implement, both optional.\n *\n * The hub reconciles every list scope itself, so a widget supplies placement\n * and scaffolding and nothing else. A scope that implements neither is a\n * plain element with a row template inside it, which is why there is no\n * repeater widget.\n *\n * They are methods on an element the hub does not own, so they carry the\n * `lb` prefix that Loadbare reserves for exactly that — see\n * docs/reference/custom-elements.md.\n */\nexport interface ListHost {\n  /**\n   * Where a row belongs, called with the row detached on its first\n   * appearance. Without it a row lands immediately before the template, so\n   * rows accumulate in the order they arrive.\n   */\n  lbPlaceRow?(el: Element, row: Row, template: HTMLTemplateElement): void;\n\n  /** Called once after a whole result has landed, for derived scaffolding. */\n  lbRowsLanded?(): void;\n}\n"]}
+{"version":3,"file":"lb-types.js","sourceRoot":"","sources":["../../core/lb-types.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAE3B,qDAAqD;AAErD,OAAO,EAGL,kBAAkB,EAClB,eAAe,EACf,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAoC3B,MAAM,UAAU,OAAO,CAAC,MAAkB;IACxC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;AAChC,CAAC;AA2CD,+DAA+D;AAC/D,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,OAAQ,eAAqC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAC5B,MAAuB,EACvB,KAA6B;IAE7B,MAAM,IAAI,GAAG,IAAI,eAAe,CAAC,MAAM,CAAC,CAAC;IACzC,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAClD,IAAI,KAAK,KAAK,EAAE;YAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;;YAC/B,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC7B,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;IAC5C,OAAO,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY,CAC1B,IAAY,EACZ,KAAsB,EACtB,GAAQ;IAER,MAAM,KAAK,GAA2B,EAAE,CAAC;IACzC,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QAChD,IAAI,IAAI,CAAC,UAAU,CAAC,kBAAkB,CAAC;YAAE,SAAS;QAClD,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC3E,CAAC;IACD,MAAM,IAAI,GAAG,GAAG,CAAC,eAAe,CAAC,CAAC;IAClC,MAAM,IAAI,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACjE,MAAM,KAAK,GAAG,IAAI,KAAK,IAAI,CAAC;IAC5B,OAAO;QACL,IAAI,EAAE,IAAI;QACV,KAAK,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,eAAe,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC;QACnE,KAAK;KACN,CAAC;AACJ,CAAC","sourcesContent":["/// <reference lib=\"dom\" />\n\n// The wire vocabulary. Shared by browser and server.\n\nimport {\n  KIND_ROW,\n  KIND_ROWS,\n  LB_RESERVED_PREFIX,\n  LB_ROW_REQUESTS,\n  URL_COLUMN_PATH,\n} from \"./lb-constants.js\";\n\n/**\n * One row: its columns, by name.\n *\n * A value is whatever the server serialized. The hub knows nothing about its\n * type and enforces nothing: it hands each value to the browser untouched,\n * and the browser renders it as it sees fit. What a number, a date or a null\n * should look like is the application's decision, made in the query.\n */\nexport type Row = Record<string, unknown>;\n\n/**\n * Part of a `rows` query's answer — see docs/reference/server.md, \"Queries\".\n *\n * Rows named here are added or updated, keys in `drop` are removed, and\n * anything unnamed is left alone: its contents, and its place in whatever\n * order the widget is keeping. Add and remove are one result rather than two\n * because the interesting cases are both at once — a row whose sort key\n * changed has to move, a swap is one out and one in — and two messages would\n * paint the intermediate state.\n */\nexport interface Patch {\n  rows?: Row[];\n  drop?: unknown[];\n}\n\n/** A query's kind, declared by the server and carried by every answer. */\nexport type Kind = typeof KIND_ROW | typeof KIND_ROWS;\n\n/**\n * What a `rows` query answers with: all rows, which is also their order, or\n * a patch. `Array.isArray` tells the two apart.\n */\nexport type RowsResult = Row[] | Patch;\n\nexport function isPatch(result: RowsResult): result is Patch {\n  return !Array.isArray(result);\n}\n\n/** What any one query answers with, as the application writes it. */\nexport type HubResult = Row | RowsResult;\n\n/**\n * What application code hands the engine: answers by query name. The engine\n * turns each into a response item, adding the kind and key the query\n * declared.\n */\nexport type HubData = Record<string, HubResult>;\n\n/**\n * One query's answer on the wire: its name, its kind, its key's column name,\n * and exactly one of a row, all rows, or a patch. A patch answers a `rows`\n * query only.\n */\nexport interface ResponseItem {\n  query: string;\n  kind: Kind;\n  key: string;\n  row?: Row;\n  rows?: Row[];\n  patch?: Patch;\n}\n\n/** Every response the server sends: a page load and a request alike. */\nexport type HubResponse = ResponseItem[];\n\n/**\n * Every request has one shape. The name picks the handler; the rest is\n * present when the hub found it.\n */\nexport interface HubRequest {\n  name: string;\n  query?: string;\n  key?: string;\n  values?: Record<string, string>;\n}\n\n/** The fields a handler receives: the request, less its name. */\nexport type RequestFields = Omit<HubRequest, \"name\">;\n\n/** Whether a name is one of the requests Loadbare provides. */\nexport function isRowRequest(name: string): boolean {\n  return (LB_ROW_REQUESTS as readonly string[]).includes(name);\n}\n\n/**\n * A query string with some parms set, and the rest as they were. An empty\n * value takes its parm out, since empty is every parm's default and a\n * default is left out of the URL.\n *\n * One rule on both sides of the wire: the hub applies it to the address bar,\n * and the server to the query string it loads the page at after a request\n * returned `lb-url`. The two must agree, or what the page shows would differ\n * from what the address bar says.\n */\nexport function withQueryParms(\n  search: URLSearchParams,\n  parms: Record<string, string>,\n): URLSearchParams {\n  const next = new URLSearchParams(search);\n  for (const [name, value] of Object.entries(parms)) {\n    if (value === \"\") next.delete(name);\n    else next.set(name, value);\n  }\n  return next;\n}\n\n/**\n * A path names a page by its stub, and nothing finer. The bare path resolves\n * to `index`, the same convention a static file server follows.\n */\nexport function pageNameFor(path: string): string {\n  const name = path.replace(/^\\/+|\\/+$/g, \"\");\n  return name === \"\" ? \"index\" : name;\n}\n\n/**\n * Where a row for `lb-url` leads, from a page and its query parms.\n *\n * A column whose name begins with `lb-` is Loadbare's, and never a query\n * parm; every other column is one. An `lb-path` naming another page enters\n * it with only the parms the row names. Otherwise the named parms are set,\n * or taken out when empty, and the rest are kept.\n *\n * One rule on both sides of the wire: the server loads the page it names,\n * and the hub writes the URL it names. The two must agree, or what the page\n * shows would differ from what the address bar says.\n */\nexport function nextLocation(\n  page: string,\n  parms: URLSearchParams,\n  row: Row,\n): { page: string; parms: URLSearchParams; moved: boolean } {\n  const named: Record<string, string> = {};\n  for (const [name, value] of Object.entries(row)) {\n    if (name.startsWith(LB_RESERVED_PREFIX)) continue;\n    named[name] = value === null || value === undefined ? \"\" : String(value);\n  }\n  const path = row[URL_COLUMN_PATH];\n  const next = typeof path === \"string\" ? pageNameFor(path) : page;\n  const moved = next !== page;\n  return {\n    page: next,\n    parms: withQueryParms(moved ? new URLSearchParams() : parms, named),\n    moved,\n  };\n}\n\n/**\n * The two hooks a custom element holding rows may implement, both optional.\n *\n * The hub reconciles every row template itself, so a custom element supplies\n * placement and scaffolding and nothing else. They are methods on an element\n * the hub does not own, so they carry the `lb` prefix Loadbare reserves for\n * exactly that — see docs/reference/custom-elements.md.\n */\nexport interface RowsHost {\n  /**\n   * Where a live row belongs, called with the row detached on its first\n   * appearance. Without it a row lands immediately before the template, so\n   * rows accumulate in the order they arrive.\n   */\n  lbPlaceRow?(el: Element, row: Row, template: HTMLTemplateElement): void;\n\n  /** Called once after a whole result has landed, for derived scaffolding. */\n  lbRowsLanded?(): void;\n}\n"]}

package/dist/hub/lb-apply.d.ts

@@ -1,53 +1,63 @@
-import { type HubData, type ListResult, type Row } from "../core/lb-types.js";
+import { type ResponseItem, type Row, type RowsResult } from "../core/lb-types.js";
+/** A control's value, whether it is native or a custom element. */
+export interface Control extends Element {
+    value: string;
+}
 /**
- * A form control whose state is its `value`: a `<select>`, a `<textarea>`,
- * or an `<input>` of any type but checkbox, radio and file. Landing and
- * gathering draw the same line, so a value read back from a form is the one
- * that landed there.
- *
- * Told apart by tag name and type rather than by class, so it holds for an
- * element from any document.
+ * A form-associated custom element with a `value` property. HTML marks one
+ * with `static formAssociated = true` on its class, and a control has a value.
+ */
+export declare function isFormAssociated(el: Element): boolean;
+/**
+ * A control: an `<input>`, `<select>` or `<textarea>`, or a form-associated
+ * custom element with a `value` property. Landing and gathering draw the
+ * same line, so a value read back is the one that landed there.
  */
-export declare function isValueControl(el: Element): el is HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
+export declare function isControl(el: Element): el is Control;
 /**
- * Root if it matches, then every descendant in root's scope that does.
- * Gathering finds cells through here. It does not reach into an absent
- * branch, so a form reads back from the places a row lands that are showing.
+ * Root if it matches, then every descendant in root's query that does.
+ * Gathering finds columns through here. It does not reach into an absent
+ * branch, so a live row is read back from the places a row lands that are
+ * showing.
  */
 export declare function within(root: Element, selector: string): Element[];
 /**
- * Fill one scope from one row.
+ * Fill from one row: every `lb-column` and `lb-show` in root's query.
  *
- * The root counts as a cell if it carries one. A `<tr>` holds its cells in
- * `<td>` children, but `<option>`'s content model is text, so an option row
- * has to be the cell it displays. Requiring a wrapper there would require an
- * element HTML does not allow.
+ * A live row is its own row, so its root counts when it carries
+ * `lb-column`: `<option>`'s content model is text, so an option row has to
+ * be the column it displays. An element a `row` lands on is not its own
+ * ancestor, so its own `lb-column` reads from the row around it and is left
+ * alone here.
+ */
+export declare function applyRow(root: Element, row: Row, liveRow?: boolean): void;
+/**
+ * The row template: the first `<template>` among the element's descendants,
+ * outside any nested `lb-query`. A template holding an absent branch is not a
+ * row template: rows land before the row template, so one inside the first
+ * live row comes first in document order.
  */
-export declare function applyRow(root: Element, row: Row): void;
+export declare function templateIn(el: Element): HTMLTemplateElement | null;
 /**
- * Land a list result in a list scope.
+ * Land rows through a row template.
  *
- * An array is the whole set, so it decides membership and order: every row is
- * placed in the order given, and a row whose key did not arrive is gone. A
- * patch disturbs only what it names — a row it did not mention keeps its
- * contents and its position.
+ * All rows decide membership and order: every row is placed in the order
+ * given, and a row whose key did not arrive is gone. A patch disturbs only
+ * what it names — a row it did not mention keeps its contents and its
+ * position.
  *
- * A widget that carries `lbPlaceRow` decides where a row goes, because only
- * it knows whether it sorts or groups. Without it a row lands immediately
- * before the template, so rows accumulate in the order they arrive and the
- * template stays put as the insertion marker.
+ * A custom element that carries `lbPlaceRow` decides where a row goes,
+ * because only it knows whether it sorts or groups. Without it a row lands
+ * immediately before the template, so rows accumulate in the order they
+ * arrive and the template stays put as the insertion marker.
  */
-export declare function applyList(scope: Element, result: ListResult): void;
-/** Land a whole response. Every result arrives through here. */
-export declare function applyData(root: ParentNode, data: HubData): void;
+export declare function applyRows(el: Element, template: HTMLTemplateElement, keyColumn: string, result: RowsResult): void;
 /**
- * Land the query string on every control that writes one of its parms, the
- * way a cell lands a column. A parm the URL does not carry lands empty, so a
- * control shows what the address bar says after Back as well as after a
- * reload: the URL is what is on screen, and nothing else is.
+ * Land response items. Every answer arrives through here.
  *
- * Landed after the page's data, so a picker already has the options its
- * value selects.
+ * `quiet` names queries that may have nowhere to land without a warning: the
+ * hub's own `lb-url` lands wherever a chrome or page names it, and nowhere
+ * otherwise.
  */
-export declare function applyQueryParms(root: ParentNode, parms: URLSearchParams): void;
+export declare function applyResponse(root: ParentNode, items: ResponseItem[], quiet?: readonly string[]): void;
 //# sourceMappingURL=lb-apply.d.ts.map

package/dist/hub/lb-apply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lb-apply.d.ts","sourceRoot":"","sources":["../../hub/lb-apply.ts"],"names":[],"mappings":"AAmCA,OAAO,EAEL,KAAK,OAAO,EAEZ,KAAK,UAAU,EACf,KAAK,GAAG,EACT,MAAM,qBAAqB,CAAC;AAW7B;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,OAAO,GACV,EAAE,IAAI,gBAAgB,GAAG,iBAAiB,GAAG,mBAAmB,CAMlE;AA8DD;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,EAAE,CAMjE;AAqED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAetD;AA6CD;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAgElE;AAED,gEAAgE;AAChE,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAkC/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,eAAe,GACrB,IAAI,CAIN"}
+{"version":3,"file":"lb-apply.d.ts","sourceRoot":"","sources":["../../hub/lb-apply.ts"],"names":[],"mappings":"AAkCA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,GAAG,EAER,KAAK,UAAU,EAChB,MAAM,qBAAqB,CAAC;AAW7B,mEAAmE;AACnE,MAAM,WAAW,OAAQ,SAAQ,OAAO;IACtC,KAAK,EAAE,MAAM,CAAC;CACf;AAiBD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAGrD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAEpD;AAuDD;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,EAAE,CAMjE;AA8DD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,UAAQ,GAAG,IAAI,CAgBvE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,OAAO,GAAG,mBAAmB,GAAG,IAAI,CAKlE;AAcD;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CACvB,EAAE,EAAE,OAAO,EACX,QAAQ,EAAE,mBAAmB,EAC7B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,UAAU,GACjB,IAAI,CA+DN;AAyBD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,YAAY,EAAE,EACrB,KAAK,GAAE,SAAS,MAAM,EAAO,GAC5B,IAAI,CAWN"}