@aglyn/plugins-data 1.0.0-beta.143

package/src/lib/model/dataset-record-view.js

@@ -0,0 +1,293 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { formatDatasetValue } from "@aglyn/aglyn/app-utils/dataset-models";
+import { humanizeDatasetFieldId } from "@aglyn/aglyn/app-utils/datasets";
+const NO_TEXT = {
+    text: '',
+    block: false
+};
+/** Firestore `Bytes`, `Uint8Array`, `Buffer` — anything holding raw octets. */ function byteLength(value) {
+    if (value instanceof Uint8Array) return value.byteLength;
+    if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
+        return value.byteLength;
+    }
+    // Firestore's `Bytes` wrapper exposes its octets only through a method.
+    const asBytes = value;
+    if (typeof (asBytes == null ? void 0 : asBytes.toUint8Array) === 'function') {
+        try {
+            return asBytes.toUint8Array().byteLength;
+        } catch (unused) {
+            return null;
+        }
+    }
+    return null;
+}
+function describeBytes(value) {
+    const length = byteLength(value);
+    return {
+        kind: 'opaque',
+        text: length == null ? 'Binary value' : `Binary value · ${length} bytes`,
+        block: false
+    };
+}
+/**
+ * Nested structures, pretty-printed.
+ *
+ * A one-line `JSON.stringify` is what the table shows; a record view has the
+ * height to indent it, and an indented object is the difference between
+ * reading a nested value and squinting at one. A structure that will not
+ * serialize is reported as such rather than falling through to
+ * `String(value)`.
+ */ function describeStructure(value) {
+    try {
+        const text = JSON.stringify(value, null, 2);
+        // `undefined` in, `undefined` out — `JSON.stringify` answers that for a
+        // function or a symbol without throwing.
+        if (typeof text !== 'string') {
+            return {
+                kind: 'opaque',
+                text: 'Value cannot be displayed',
+                block: false
+            };
+        }
+        return {
+            kind: 'value',
+            text,
+            block: text.includes('\n')
+        };
+    } catch (unused) {
+        // A cycle, or a `toJSON` that throws.
+        return {
+            kind: 'opaque',
+            text: 'Value cannot be displayed',
+            block: false
+        };
+    }
+}
+/**
+ * A list's items, kept apart instead of joined.
+ *
+ * The join `formatDatasetValue` performs is lossy: `['a, b']` and
+ * `['a', 'b']` render to the identical string, so a reader cannot tell a
+ * one-item list holding a comma from a two-item list. One line per item
+ * removes the ambiguity, and `text` keeps the joined form for a flattened
+ * context such as a copy to the clipboard.
+ *
+ * An item that is itself a structure is serialized on its own; a list of
+ * objects reads as a list of objects rather than as `[object Object]`
+ * repeated.
+ */ function describeList(field, value) {
+    const items = value.map((item)=>{
+        if (typeof item === 'string') return item;
+        if (item === null) return 'null';
+        if (typeof item === 'object') {
+            const described = describeStructure(item);
+            return described.kind === 'value' ? described.text : described.text;
+        }
+        return String(item);
+    });
+    return {
+        kind: 'value',
+        text: field ? formatDatasetValue(field, value) : items.join(', '),
+        block: false,
+        items
+    };
+}
+/**
+ * The reference field's targets, each carrying whether it resolved.
+ *
+ * Both storage shapes flatten to the same list — a single ID string, or the
+ * `sorted` array a `multiple` reference holds — because the question asked of
+ * each entry is the same one.
+ */ function describeReference(fieldId, value, resolve) {
+    const raw = Array.isArray(value) ? value : [
+        value
+    ];
+    const references = raw.map((entry)=>typeof entry === 'string' ? entry.trim() : '').filter((id)=>id.length > 0).map((id)=>{
+        var _ref;
+        return {
+            id,
+            label: (_ref = resolve == null ? void 0 : resolve(fieldId, id)) != null ? _ref : null
+        };
+    });
+    if (!references.length) {
+        // An array that held nothing but blanks is an empty list, not a value;
+        // a non-string entry never was a reference and is reported by
+        // `validateDocument`, which the record view runs alongside this.
+        return _extends({
+            kind: Array.isArray(value) ? 'empty-list' : 'null'
+        }, NO_TEXT);
+    }
+    return {
+        kind: 'value',
+        // The label where there is one, the bare ID where there is not. The
+        // renderer marks the unresolved entries; this text is the fallback for
+        // anywhere the structure is flattened, such as a copy to the clipboard.
+        text: references.map((reference)=>{
+            var _reference_label;
+            return (_reference_label = reference.label) != null ? _reference_label : reference.id;
+        }).join(', '),
+        block: false,
+        references
+    };
+}
+/**
+ * What one field of one record holds, as a descriptor the renderer can be
+ * honest with.
+ *
+ * `values` and `fieldId` are taken separately rather than as one already-read
+ * value because "the key is missing" and "the key is present and empty" are
+ * two of the states being distinguished, and a read value cannot tell them
+ * apart.
+ *
+ * `field` may be undefined — a stored value the model does not declare. The
+ * value is then described from its own runtime shape, since there is no
+ * declared type to describe it by.
+ */ export function describeDatasetValue(field, values, fieldId, resolve) {
+    const present = values != null && Object.prototype.hasOwnProperty.call(values, fieldId) && values[fieldId] !== undefined;
+    if (!present) return _extends({
+        kind: 'absent'
+    }, NO_TEXT);
+    const value = values[fieldId];
+    if (value === null) return _extends({
+        kind: 'null'
+    }, NO_TEXT);
+    if (value === '') return _extends({
+        kind: 'empty-text'
+    }, NO_TEXT);
+    if (Array.isArray(value) && value.length === 0) {
+        return _extends({
+            kind: 'empty-list'
+        }, NO_TEXT);
+    }
+    if ((field == null ? void 0 : field.type) === 'reference') {
+        return describeReference(fieldId, value, resolve);
+    }
+    if ((field == null ? void 0 : field.type) === 'bytes') return describeBytes(value);
+    // An object with no keys is an empty map whether or not the model says
+    // `map` — an undeclared field has no declared type to consult.
+    const plainObject = typeof value === 'object' && !Array.isArray(value) && byteLength(value) == null;
+    if (plainObject && Object.keys(value).length === 0) {
+        return _extends({
+            kind: 'empty-map'
+        }, NO_TEXT);
+    }
+    // Raw octets stored against a field the model does not declare as `bytes`.
+    if (typeof value === 'object' && byteLength(value) != null) {
+        return describeBytes(value);
+    }
+    // A list is rendered per item rather than joined. An array stored against a
+    // field declared `map` is not one — `validateDocument` reports the mismatch
+    // and the value is pretty-printed as the structure it is.
+    if (Array.isArray(value) && (!field || field.type === 'sorted')) {
+        return describeList(field, value);
+    }
+    if (field) {
+        // `map` is the only declared type `formatDatasetValue` serializes, and it
+        // serializes to one line. Everything else it formats is already the short
+        // form a record view wants.
+        if (field.type === 'map') return describeStructure(value);
+        const text = formatDatasetValue(field, value);
+        // A non-empty value that formats to nothing would print as a blank line
+        // and read as an empty string. `formatDatasetValue` returns `''` only for
+        // the states already handled above, so this is a guard against a future
+        // formatter, not a state reachable today.
+        if (text === '') return {
+            kind: 'opaque',
+            text: 'Value cannot be displayed',
+            block: false
+        };
+        return {
+            kind: 'value',
+            text,
+            block: false
+        };
+    }
+    // Undeclared: describe the runtime shape rather than guessing a type.
+    if (typeof value === 'object') return describeStructure(value);
+    if (typeof value === 'boolean') {
+        return {
+            kind: 'value',
+            text: value ? 'true' : 'false',
+            block: false
+        };
+    }
+    if (typeof value === 'number' || typeof value === 'string') {
+        return {
+            kind: 'value',
+            text: String(value),
+            block: false
+        };
+    }
+    return {
+        kind: 'opaque',
+        text: 'Value cannot be displayed',
+        block: false
+    };
+}
+/**
+ * Every field of a record, in reading order: the model's declared order
+ * first, then anything the model declares but does not display, then every
+ * stored value the model does not declare at all.
+ *
+ * The union is the point. `model.order` is what the table's columns are built
+ * from, so a view built from `order` alone would be a wider row rather than
+ * the record — it would silently omit a reference field declared without a
+ * display slot, and every value left behind by a field the model no longer
+ * has. Both are real states of a stored document, and a viewer that drops
+ * them tells the reader the record is smaller than it is.
+ */ export function datasetRecordFields(model, values, resolve) {
+    var _model_order, _model_fields;
+    const order = (_model_order = model.order) != null ? _model_order : [];
+    const declared = (_model_fields = model.fields) != null ? _model_fields : {};
+    const seen = new Set();
+    const fields = [];
+    const pushDeclared = (fieldId)=>{
+        var _field_validation;
+        if (seen.has(fieldId)) return;
+        const field = declared[fieldId];
+        if (!field) return;
+        seen.add(fieldId);
+        fields.push(_extends({
+            fieldId,
+            label: field.name || humanizeDatasetFieldId(fieldId),
+            type: field.type
+        }, field.description ? {
+            description: field.description
+        } : {}, field.required || ((_field_validation = field.validation) == null ? void 0 : _field_validation.required) ? {
+            required: true
+        } : {}, {
+            source: 'model',
+            value: describeDatasetValue(field, values, fieldId, resolve)
+        }));
+    };
+    for (const fieldId of order)pushDeclared(fieldId);
+    for (const fieldId of Object.keys(declared))pushDeclared(fieldId);
+    for (const fieldId of Object.keys(values != null ? values : {})){
+        if (seen.has(fieldId)) continue;
+        seen.add(fieldId);
+        fields.push({
+            fieldId,
+            label: humanizeDatasetFieldId(fieldId),
+            source: 'extra',
+            value: describeDatasetValue(undefined, values, fieldId, resolve)
+        });
+    }
+    return fields;
+}
+
+//# sourceMappingURL=dataset-record-view.js.map

package/src/lib/model/dataset-record-view.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/data/src/lib/model/dataset-record-view.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  type DatasetFieldDefinition,\n  type DatasetFieldType,\n  type DatasetModel,\n  formatDatasetValue,\n} from '@aglyn/aglyn/app-utils/dataset-models'\nimport { humanizeDatasetFieldId } from '@aglyn/aglyn/app-utils/datasets'\n\n/**\n * Reading a whole record, as opposed to skimming a row of it.\n *\n * `formatDatasetValue` is the GRID formatter and is right for a grid: it\n * answers one short string per cell, and every state that has no short string\n * collapses to `''`, which the table then prints as `--`. A cell is one line\n * tall and one column wide, so that collapse is the only affordable answer.\n *\n * A record view has room to be exact, and the difference matters as soon as\n * anybody acts on what they read:\n *\n *  * A field the record does not carry AT ALL, a field storing `null`, and a\n *    field storing a real empty string are three different facts. They all\n *    format to `''` and print as `--`. \"The address is blank\" and \"this\n *    record predates the address field\" are not the same finding, and a CSV\n *    export makes the difference visible where the table did not.\n *  * A reference whose target cannot be resolved formats as the raw target\n *    ID, which is indistinguishable from a resolved reference whose label\n *    happens to look like an ID. One is a working link, the other is a\n *    dangling one — a `setNull` that never ran, a target outside the picker's\n *    window, or a record pointing at a deleted document.\n *  * `bytes` reaches `String(value)`. A `Uint8Array` prints as its comma-\n *    joined byte values and a Firestore `Bytes` prints `[object Object]`.\n *    Neither is the value; both look like one.\n *  * A `map` whose value cannot be serialized (a cycle) falls through\n *    `JSON.stringify`'s throw to `String(value)`, which is `[object Object]`\n *    again — a placeholder wearing the costume of data.\n *\n * So this module answers with a DESCRIPTOR rather than a string, and the\n * renderer decides how each state should look. Nothing here formats a value\n * a second time: a real value's text still comes from `formatDatasetValue`,\n * so the record view and the table can never disagree about one.\n */\n\n/** What a field slot actually holds — the four \"no value\" states are distinct. */\nexport type DatasetDisplayKind =\n  /** The record has no such key. */\n  | 'absent'\n  /** The key is present and stores `null`. */\n  | 'null'\n  /** A real, stored empty string. */\n  | 'empty-text'\n  /** A real, stored empty array. */\n  | 'empty-list'\n  /** A real, stored empty object. */\n  | 'empty-map'\n  /** A value, rendered in `text`. */\n  | 'value'\n  /**\n   * A value that exists and cannot be shown honestly as text — binary, or a\n   * structure that will not serialize. `text` says which, and says so as a\n   * description of the value rather than as the value.\n   */\n  | 'opaque'\n\n/** One target of a reference field, and whether it could be resolved. */\nexport interface DatasetDisplayReference {\n  id: string\n  /**\n   * The target's display label, or `null` when this ID resolved to nothing.\n   * An unresolved reference is not an error to hide: the ID is still shown,\n   * marked as unresolved, because the ID is the only fact available.\n   */\n  label: string | null\n}\n\nexport interface DatasetDisplayValue {\n  kind: DatasetDisplayKind\n  /**\n   * The rendered value for `value`, and the reason for `opaque`. Empty for\n   * every other kind — those carry no text of their own, and the renderer\n   * supplies the placeholder so a placeholder can never be mistaken for\n   * stored content.\n   */\n  text: string\n  /**\n   * Pre-formatted across several lines. Nested JSON is pretty-printed, which\n   * is only readable in a block that preserves its whitespace.\n   */\n  block: boolean\n  /** Present only for a `reference` field, one entry per target ID. */\n  references?: DatasetDisplayReference[]\n  /**\n   * A list field's items, one entry each.\n   *\n   * `formatDatasetValue` joins a `sorted` array with `\", \"`, which is the only\n   * thing a cell has room for and is ambiguous in both directions: the\n   * one-item list `['a, b']` and the two-item list `['a', 'b']` produce the\n   * same string, and nothing in it says which was stored. A record view has a\n   * line per item, so it renders the items rather than the join. `text` keeps\n   * the joined form for anywhere the structure is flattened.\n   */\n  items?: string[]\n}\n\n/** A field slot in a record view: what it is called, and what it holds. */\nexport interface DatasetRecordField {\n  fieldId: string\n  /** Display label — the model's name, or a humanized ID for an extra. */\n  label: string\n  /** The declared type; absent for a stored value the model does not declare. */\n  type?: DatasetFieldType\n  description?: string\n  required?: boolean\n  /**\n   * `extra` marks a stored value with no field in the model. It is not\n   * corruption and not rare: a type or field removed from a model never\n   * rewrites documents (the record editor strips orphans lazily, on the next\n   * save), and the import and API legs accept any key the model names at the\n   * time of the write. The table cannot show these — its columns come from\n   * the model — which is exactly why a record view must.\n   */\n  source: 'model' | 'extra'\n  value: DatasetDisplayValue\n}\n\n/** Resolves one reference target to its label, or `null` when unresolved. */\nexport type DatasetReferenceResolver = (\n  fieldId: string,\n  id: string,\n) => string | null\n\nconst NO_TEXT = { text: '', block: false } as const\n\n/** Firestore `Bytes`, `Uint8Array`, `Buffer` — anything holding raw octets. */\nfunction byteLength(value: unknown): number | null {\n  if (value instanceof Uint8Array) return value.byteLength\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return value.byteLength\n  }\n  // Firestore's `Bytes` wrapper exposes its octets only through a method.\n  const asBytes = value as { toUint8Array?: () => Uint8Array }\n  if (typeof asBytes?.toUint8Array === 'function') {\n    try {\n      return asBytes.toUint8Array().byteLength\n    } catch {\n      return null\n    }\n  }\n  return null\n}\n\nfunction describeBytes(value: unknown): DatasetDisplayValue {\n  const length = byteLength(value)\n  return {\n    kind: 'opaque',\n    text: length == null ? 'Binary value' : `Binary value · ${length} bytes`,\n    block: false,\n  }\n}\n\n/**\n * Nested structures, pretty-printed.\n *\n * A one-line `JSON.stringify` is what the table shows; a record view has the\n * height to indent it, and an indented object is the difference between\n * reading a nested value and squinting at one. A structure that will not\n * serialize is reported as such rather than falling through to\n * `String(value)`.\n */\nfunction describeStructure(value: unknown): DatasetDisplayValue {\n  try {\n    const text = JSON.stringify(value, null, 2)\n    // `undefined` in, `undefined` out — `JSON.stringify` answers that for a\n    // function or a symbol without throwing.\n    if (typeof text !== 'string') {\n      return { kind: 'opaque', text: 'Value cannot be displayed', block: false }\n    }\n    return { kind: 'value', text, block: text.includes('\\n') }\n  } catch {\n    // A cycle, or a `toJSON` that throws.\n    return { kind: 'opaque', text: 'Value cannot be displayed', block: false }\n  }\n}\n\n/**\n * A list's items, kept apart instead of joined.\n *\n * The join `formatDatasetValue` performs is lossy: `['a, b']` and\n * `['a', 'b']` render to the identical string, so a reader cannot tell a\n * one-item list holding a comma from a two-item list. One line per item\n * removes the ambiguity, and `text` keeps the joined form for a flattened\n * context such as a copy to the clipboard.\n *\n * An item that is itself a structure is serialized on its own; a list of\n * objects reads as a list of objects rather than as `[object Object]`\n * repeated.\n */\nfunction describeList(\n  field: DatasetFieldDefinition | undefined,\n  value: unknown[],\n): DatasetDisplayValue {\n  const items = value.map((item) => {\n    if (typeof item === 'string') return item\n    if (item === null) return 'null'\n    if (typeof item === 'object') {\n      const described = describeStructure(item)\n      return described.kind === 'value' ? described.text : described.text\n    }\n    return String(item)\n  })\n  return {\n    kind: 'value',\n    text: field ? formatDatasetValue(field, value) : items.join(', '),\n    block: false,\n    items,\n  }\n}\n\n/**\n * The reference field's targets, each carrying whether it resolved.\n *\n * Both storage shapes flatten to the same list — a single ID string, or the\n * `sorted` array a `multiple` reference holds — because the question asked of\n * each entry is the same one.\n */\nfunction describeReference(\n  fieldId: string,\n  value: unknown,\n  resolve: DatasetReferenceResolver | undefined,\n): DatasetDisplayValue {\n  const raw = Array.isArray(value) ? value : [value]\n  const references: DatasetDisplayReference[] = raw\n    .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))\n    .filter((id) => id.length > 0)\n    .map((id) => ({ id, label: resolve?.(fieldId, id) ?? null }))\n  if (!references.length) {\n    // An array that held nothing but blanks is an empty list, not a value;\n    // a non-string entry never was a reference and is reported by\n    // `validateDocument`, which the record view runs alongside this.\n    return { kind: Array.isArray(value) ? 'empty-list' : 'null', ...NO_TEXT }\n  }\n  return {\n    kind: 'value',\n    // The label where there is one, the bare ID where there is not. The\n    // renderer marks the unresolved entries; this text is the fallback for\n    // anywhere the structure is flattened, such as a copy to the clipboard.\n    text: references\n      .map((reference) => reference.label ?? reference.id)\n      .join(', '),\n    block: false,\n    references,\n  }\n}\n\n/**\n * What one field of one record holds, as a descriptor the renderer can be\n * honest with.\n *\n * `values` and `fieldId` are taken separately rather than as one already-read\n * value because \"the key is missing\" and \"the key is present and empty\" are\n * two of the states being distinguished, and a read value cannot tell them\n * apart.\n *\n * `field` may be undefined — a stored value the model does not declare. The\n * value is then described from its own runtime shape, since there is no\n * declared type to describe it by.\n */\nexport function describeDatasetValue(\n  field: DatasetFieldDefinition | undefined,\n  values: Record<string, unknown> | undefined,\n  fieldId: string,\n  resolve?: DatasetReferenceResolver,\n): DatasetDisplayValue {\n  const present =\n    values != null &&\n    Object.prototype.hasOwnProperty.call(values, fieldId) &&\n    values[fieldId] !== undefined\n  if (!present) return { kind: 'absent', ...NO_TEXT }\n  const value = values[fieldId]\n  if (value === null) return { kind: 'null', ...NO_TEXT }\n  if (value === '') return { kind: 'empty-text', ...NO_TEXT }\n  if (Array.isArray(value) && value.length === 0) {\n    return { kind: 'empty-list', ...NO_TEXT }\n  }\n\n  if (field?.type === 'reference') {\n    return describeReference(fieldId, value, resolve)\n  }\n  if (field?.type === 'bytes') return describeBytes(value)\n\n  // An object with no keys is an empty map whether or not the model says\n  // `map` — an undeclared field has no declared type to consult.\n  const plainObject =\n    typeof value === 'object' &&\n    !Array.isArray(value) &&\n    byteLength(value) == null\n  if (plainObject && Object.keys(value as object).length === 0) {\n    return { kind: 'empty-map', ...NO_TEXT }\n  }\n  // Raw octets stored against a field the model does not declare as `bytes`.\n  if (typeof value === 'object' && byteLength(value) != null) {\n    return describeBytes(value)\n  }\n  // A list is rendered per item rather than joined. An array stored against a\n  // field declared `map` is not one — `validateDocument` reports the mismatch\n  // and the value is pretty-printed as the structure it is.\n  if (Array.isArray(value) && (!field || field.type === 'sorted')) {\n    return describeList(field, value)\n  }\n\n  if (field) {\n    // `map` is the only declared type `formatDatasetValue` serializes, and it\n    // serializes to one line. Everything else it formats is already the short\n    // form a record view wants.\n    if (field.type === 'map') return describeStructure(value)\n    const text = formatDatasetValue(field, value)\n    // A non-empty value that formats to nothing would print as a blank line\n    // and read as an empty string. `formatDatasetValue` returns `''` only for\n    // the states already handled above, so this is a guard against a future\n    // formatter, not a state reachable today.\n    if (text === '')\n      return { kind: 'opaque', text: 'Value cannot be displayed', block: false }\n    return { kind: 'value', text, block: false }\n  }\n\n  // Undeclared: describe the runtime shape rather than guessing a type.\n  if (typeof value === 'object') return describeStructure(value)\n  if (typeof value === 'boolean') {\n    return { kind: 'value', text: value ? 'true' : 'false', block: false }\n  }\n  if (typeof value === 'number' || typeof value === 'string') {\n    return { kind: 'value', text: String(value), block: false }\n  }\n  return { kind: 'opaque', text: 'Value cannot be displayed', block: false }\n}\n\n/**\n * Every field of a record, in reading order: the model's declared order\n * first, then anything the model declares but does not display, then every\n * stored value the model does not declare at all.\n *\n * The union is the point. `model.order` is what the table's columns are built\n * from, so a view built from `order` alone would be a wider row rather than\n * the record — it would silently omit a reference field declared without a\n * display slot, and every value left behind by a field the model no longer\n * has. Both are real states of a stored document, and a viewer that drops\n * them tells the reader the record is smaller than it is.\n */\nexport function datasetRecordFields(\n  model: DatasetModel,\n  values: Record<string, unknown> | undefined,\n  resolve?: DatasetReferenceResolver,\n): DatasetRecordField[] {\n  const order = model.order ?? []\n  const declared = model.fields ?? {}\n  const seen = new Set<string>()\n  const fields: DatasetRecordField[] = []\n\n  const pushDeclared = (fieldId: string) => {\n    if (seen.has(fieldId)) return\n    const field = declared[fieldId]\n    if (!field) return\n    seen.add(fieldId)\n    fields.push({\n      fieldId,\n      label: field.name || humanizeDatasetFieldId(fieldId),\n      type: field.type,\n      ...(field.description ? { description: field.description } : {}),\n      ...(field.required || field.validation?.required\n        ? { required: true }\n        : {}),\n      source: 'model',\n      value: describeDatasetValue(field, values, fieldId, resolve),\n    })\n  }\n\n  for (const fieldId of order) pushDeclared(fieldId)\n  for (const fieldId of Object.keys(declared)) pushDeclared(fieldId)\n\n  for (const fieldId of Object.keys(values ?? {})) {\n    if (seen.has(fieldId)) continue\n    seen.add(fieldId)\n    fields.push({\n      fieldId,\n      label: humanizeDatasetFieldId(fieldId),\n      source: 'extra',\n      value: describeDatasetValue(undefined, values, fieldId, resolve),\n    })\n  }\n  return fields\n}\n"],"names":["formatDatasetValue","humanizeDatasetFieldId","NO_TEXT","text","block","byteLength","value","Uint8Array","ArrayBuffer","asBytes","toUint8Array","describeBytes","length","kind","describeStructure","JSON","stringify","includes","describeList","field","items","map","item","described","String","join","describeReference","fieldId","resolve","raw","Array","isArray","references","entry","trim","filter","id","label","reference","describeDatasetValue","values","present","Object","prototype","hasOwnProperty","call","undefined","type","plainObject","keys","datasetRecordFields","model","order","declared","fields","seen","Set","pushDeclared","has","add","push","name","description","required","validation","source"],"mappings":"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"}

package/src/lib/model/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Dataset io model (AGL-413): CSV serialize/parse for dataset records relocated from core app-utils.
+ * Context-free — importable by client components, /server handlers, and
+ * other plugins/apps via `@aglyn/plugins-data/model`.
+ */
+export * from './dataset-io';

package/src/lib/model/index.js

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * Dataset io model (AGL-413): CSV serialize/parse for dataset records relocated from core app-utils.
+ * Context-free — importable by client components, /server handlers, and
+ * other plugins/apps via `@aglyn/plugins-data/model`.
+ */ export * from "./dataset-io.js";
+
+//# sourceMappingURL=index.js.map

package/src/lib/model/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/data/src/lib/model/index.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Dataset io model (AGL-413): CSV serialize/parse for dataset records relocated from core app-utils.\n * Context-free — importable by client components, /server handlers, and\n * other plugins/apps via `@aglyn/plugins-data/model`.\n */\nexport * from './dataset-io'\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;CAIC,GACD,cAAc,kBAAc"}

package/src/lib/plugin.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Data feature plugin (AGL-395). Console-only — datasets are org-shared
+ * document collections consumed by repeatable components at render time
+ * through binding resolution, not a canvas element of their own, so there
+ * is no UI bundle. The console half declares the host Data nav + page
+ * through the ConsoleExtension registry, gated by the `dataStore`
+ * entitlement. The org Data page (`Route.ORG_DATA`) is an org-scoped app route
+ * that imports {@link HostDatasetsCard} directly.
+ *
+ * It also registers datasets as a repeat source (AGL-3111), which is what puts
+ * "Repeat over dataset" on every element's Attributes panel and draws a
+ * repeat's copies from the real rows on the besigner canvas. Registered here,
+ * inside the function the loader calls by name, and never by a module's own
+ * load: this package declares no side effects, so a bundler deletes a module
+ * imported only to run one (AGL-3025).
+ */
+export declare function registerDataConsole(): void;
+export { default as HostDatasetsCard } from './components/host-datasets-card.component';
+export type { HostDatasetsCardProps } from './components/host-datasets-card.component';

package/src/lib/plugin.js

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import HostDatasetsCard from "./components/host-datasets-card.component.js";
+import * as Aglyn from "@aglyn/aglyn";
+import { registerRepeatSource } from "@aglyn/aglyn/app-utils/repeat-sources";
+import { mdiDatabaseOutline } from "@aglyn/shared-data-mdi";
+import { lazy } from "react";
+import { BUNDLE_ID } from "./constants/bundle-common.js";
+import { DATASET_REPEAT_SOURCE } from "./repeat/dataset-repeat-source.js";
+/** Code-split: the Data console page only loads when opened. */ const DataConsolePage = lazy(()=>import("./components/data-console-page.js"));
+/**
+ * Data feature plugin (AGL-395). Console-only — datasets are org-shared
+ * document collections consumed by repeatable components at render time
+ * through binding resolution, not a canvas element of their own, so there
+ * is no UI bundle. The console half declares the host Data nav + page
+ * through the ConsoleExtension registry, gated by the `dataStore`
+ * entitlement. The org Data page (`Route.ORG_DATA`) is an org-scoped app route
+ * that imports {@link HostDatasetsCard} directly.
+ *
+ * It also registers datasets as a repeat source (AGL-3111), which is what puts
+ * "Repeat over dataset" on every element's Attributes panel and draws a
+ * repeat's copies from the real rows on the besigner canvas. Registered here,
+ * inside the function the loader calls by name, and never by a module's own
+ * load: this package declares no side effects, so a bundler deletes a module
+ * imported only to run one (AGL-3025).
+ */ export function registerDataConsole() {
+    registerRepeatSource(DATASET_REPEAT_SOURCE);
+    Aglyn.registerConsoleExtension({
+        // Org datasets card (AGL-419): org/data renders it through the
+        // 'orgData' widget slot.
+        widgets: [
+            {
+                slot: 'orgData',
+                widgetId: 'data-org-datasets',
+                Component: HostDatasetsCard
+            }
+        ],
+        pluginId: BUNDLE_ID,
+        displayName: 'Data',
+        featureFlag: 'dataStore',
+        navItems: [
+            {
+                label: 'Data',
+                href: '/data',
+                // Reuse the existing release-flag nav-tab so staff-preview gating is
+                // unchanged now that the tab comes from the plugin (AGL-395).
+                navTabId: 'nav-tab-data',
+                icon: {
+                    path: mdiDatabaseOutline.path
+                },
+                header: {
+                    title: 'Data',
+                    icon: {
+                        path: mdiDatabaseOutline.path
+                    },
+                    docsTopic: 'datasets'
+                },
+                Component: DataConsolePage
+            }
+        ]
+    });
+}
+export { default as HostDatasetsCard } from "./components/host-datasets-card.component.js";
+
+//# sourceMappingURL=plugin.js.map

package/src/lib/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/plugins/data/src/lib/plugin.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport HostDatasetsCard from './components/host-datasets-card.component'\nimport * as Aglyn from '@aglyn/aglyn'\nimport { registerRepeatSource } from '@aglyn/aglyn/app-utils/repeat-sources'\nimport { mdiDatabaseOutline } from '@aglyn/shared-data-mdi'\nimport { lazy } from 'react'\nimport { BUNDLE_ID } from './constants/bundle-common'\nimport { DATASET_REPEAT_SOURCE } from './repeat/dataset-repeat-source'\n\n/** Code-split: the Data console page only loads when opened. */\nconst DataConsolePage = lazy(() => import('./components/data-console-page'))\n\n/**\n * Data feature plugin (AGL-395). Console-only — datasets are org-shared\n * document collections consumed by repeatable components at render time\n * through binding resolution, not a canvas element of their own, so there\n * is no UI bundle. The console half declares the host Data nav + page\n * through the ConsoleExtension registry, gated by the `dataStore`\n * entitlement. The org Data page (`Route.ORG_DATA`) is an org-scoped app route\n * that imports {@link HostDatasetsCard} directly.\n *\n * It also registers datasets as a repeat source (AGL-3111), which is what puts\n * \"Repeat over dataset\" on every element's Attributes panel and draws a\n * repeat's copies from the real rows on the besigner canvas. Registered here,\n * inside the function the loader calls by name, and never by a module's own\n * load: this package declares no side effects, so a bundler deletes a module\n * imported only to run one (AGL-3025).\n */\nexport function registerDataConsole(): void {\n  registerRepeatSource(DATASET_REPEAT_SOURCE)\n  Aglyn.registerConsoleExtension({\n    // Org datasets card (AGL-419): org/data renders it through the\n    // 'orgData' widget slot.\n    widgets: [\n      {\n        slot: 'orgData',\n        widgetId: 'data-org-datasets',\n        Component: HostDatasetsCard,\n      },\n    ],\n    pluginId: BUNDLE_ID,\n    displayName: 'Data',\n    featureFlag: 'dataStore',\n    navItems: [\n      {\n        label: 'Data',\n        href: '/data',\n        // Reuse the existing release-flag nav-tab so staff-preview gating is\n        // unchanged now that the tab comes from the plugin (AGL-395).\n        navTabId: 'nav-tab-data',\n        icon: { path: mdiDatabaseOutline.path },\n        header: {\n          title: 'Data',\n          icon: { path: mdiDatabaseOutline.path },\n          docsTopic: 'datasets',\n        },\n        Component: DataConsolePage,\n      },\n    ],\n  })\n}\n\nexport { default as HostDatasetsCard } from './components/host-datasets-card.component'\nexport type { HostDatasetsCardProps } from './components/host-datasets-card.component'\n"],"names":["HostDatasetsCard","Aglyn","registerRepeatSource","mdiDatabaseOutline","lazy","BUNDLE_ID","DATASET_REPEAT_SOURCE","DataConsolePage","registerDataConsole","registerConsoleExtension","widgets","slot","widgetId","Component","pluginId","displayName","featureFlag","navItems","label","href","navTabId","icon","path","header","title","docsTopic","default"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,OAAOA,sBAAsB,+CAA2C;AACxE,YAAYC,WAAW,eAAc;AACrC,SAASC,oBAAoB,QAAQ,wCAAuC;AAC5E,SAASC,kBAAkB,QAAQ,yBAAwB;AAC3D,SAASC,IAAI,QAAQ,QAAO;AAC5B,SAASC,SAAS,QAAQ,+BAA2B;AACrD,SAASC,qBAAqB,QAAQ,oCAAgC;AAEtE,8DAA8D,GAC9D,MAAMC,kBAAkBH,KAAK,IAAM,MAAM,CAAC;AAE1C;;;;;;;;;;;;;;;CAeC,GACD,OAAO,SAASI;IACdN,qBAAqBI;IACrBL,MAAMQ,wBAAwB,CAAC;QAC7B,+DAA+D;QAC/D,yBAAyB;QACzBC,SAAS;YACP;gBACEC,MAAM;gBACNC,UAAU;gBACVC,WAAWb;YACb;SACD;QACDc,UAAUT;QACVU,aAAa;QACbC,aAAa;QACbC,UAAU;YACR;gBACEC,OAAO;gBACPC,MAAM;gBACN,qEAAqE;gBACrE,8DAA8D;gBAC9DC,UAAU;gBACVC,MAAM;oBAAEC,MAAMnB,mBAAmBmB,IAAI;gBAAC;gBACtCC,QAAQ;oBACNC,OAAO;oBACPH,MAAM;wBAAEC,MAAMnB,mBAAmBmB,IAAI;oBAAC;oBACtCG,WAAW;gBACb;gBACAZ,WAAWN;YACb;SACD;IACH;AACF;AAEA,SAASmB,WAAW1B,gBAAgB,QAAQ,+CAA2C"}

package/src/lib/repeat/dataset-repeat-rows.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { RepeatRowsAnswer } from '@aglyn/aglyn/app-utils/repeat-sources';
+import { type Firestore } from 'firebase/firestore';
+export interface DatasetRepeatRowsRequest {
+    firestore: Firestore;
+    /** `['orgs', orgId]` — where the site's organization keeps its datasets. */
+    scope: readonly [string, string];
+    /** The site the canvas edits. */
+    hostId: string;
+    /** The dataset key exactly as the node stores it: an id or a display name. */
+    key: string;
+}
+/**
+ * A dataset's rows for the besigner's canvas preview, read the way the
+ * published page's composition reads them (`getDatasets` in the tenant
+ * runtime), with the client SDK instead of the Admin one (AGL-3111).
+ *
+ * - The key resolves as the page resolves it: an id first, then a display
+ *   name within what this site may see. An id that exists but that this site
+ *   cannot see does not fall through to the name — that would answer "which
+ *   dataset is called X" for a key that already named a specific one.
+ * - A dataset shared with other sites but not this one, or deleted, answers
+ *   `missing`: the page renders the element once, as written.
+ * - The rows are the two bounded reads and the one ordering rule the page
+ *   uses, {@link repeatRecordsFromPages}, so a canvas copy is a row the page
+ *   renders.
+ * - One reference hop (AGL-180) is loaded as the page loads it, so
+ *   `{{item.author.name}}` previews too.
+ */
+export declare function readDatasetRepeatRows(request: DatasetRepeatRowsRequest): Promise<RepeatRowsAnswer>;