@cratis/scene.primereact 4.5.0 → 4.7.0

package/dist/esm/data/isSerializedLegacyElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSerializedLegacyElement.d.ts","sourceRoot":"","sources":["../../../data/isSerializedLegacyElement.ts"],"names":[],"mappings":"AAaA,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEjE;AASD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAK/G"}

package/dist/esm/data/isSerializedLegacyElement.js

@@ -0,0 +1,27 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Whether an entry is a serialized legacy UI element - an object that names its type in `_derivedTypeId`.
+ *
+ * The original `ItemsControl.Items` and `TreeTable.Columns` held UI elements, not data. Scene does not
+ * read those shapes and has no runtime adapter for them: the controls recognize them only to refuse them
+ * visibly, instead of listing the element's fields as if they were rows. Converting them is the migration
+ * tool's job, which maps each element to a canonical slot (see the package documentation).
+ *
+ * @param entry An entry of `items` or `columns`.
+ */ function isSerializedLegacyElement(entry) {
+    return typeof entry === 'object' && entry !== null && !Array.isArray(entry) && typeof entry._derivedTypeId === 'string';
+}
+/**
+ * The message for entries that were refused, or `undefined` when there were none.
+ *
+ * @param entries The authored entries.
+ * @param property The property they came from.
+ * @param guidance What the author should do instead, finishing the sentence "Author them ..." or similar.
+ */ function legacyElementMessage(entries, property, guidance) {
+    const refused = entries.filter(isSerializedLegacyElement).length;
+    return refused === 0 ? undefined : `${refused} entr${refused === 1 ? 'y' : 'ies'} of ${property} ${refused === 1 ? 'is a' : 'are'} serialized legacy UI element${refused === 1 ? '' : 's'}, which this control does not read. ${guidance}`;
+}
+
+export { isSerializedLegacyElement, legacyElementMessage };
+//# sourceMappingURL=isSerializedLegacyElement.js.map

package/dist/esm/data/isSerializedLegacyElement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSerializedLegacyElement.js","sources":["../../../data/isSerializedLegacyElement.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/**\n * Whether an entry is a serialized legacy UI element - an object that names its type in `_derivedTypeId`.\n *\n * The original `ItemsControl.Items` and `TreeTable.Columns` held UI elements, not data. Scene does not\n * read those shapes and has no runtime adapter for them: the controls recognize them only to refuse them\n * visibly, instead of listing the element's fields as if they were rows. Converting them is the migration\n * tool's job, which maps each element to a canonical slot (see the package documentation).\n *\n * @param entry An entry of `items` or `columns`.\n */\nexport function isSerializedLegacyElement(entry: unknown): boolean {\n    return typeof entry === 'object' && entry !== null && !Array.isArray(entry) && typeof (entry as { _derivedTypeId?: unknown })._derivedTypeId === 'string';\n}\n\n/**\n * The message for entries that were refused, or `undefined` when there were none.\n *\n * @param entries The authored entries.\n * @param property The property they came from.\n * @param guidance What the author should do instead, finishing the sentence \"Author them ...\" or similar.\n */\nexport function legacyElementMessage(entries: unknown[], property: string, guidance: string): string | undefined {\n    const refused = entries.filter(isSerializedLegacyElement).length;\n    return refused === 0\n        ? undefined\n        : `${refused} entr${refused === 1 ? 'y' : 'ies'} of ${property} ${refused === 1 ? 'is a' : 'are'} serialized legacy UI element${refused === 1 ? '' : 's'}, which this control does not read. ${guidance}`;\n}\n"],"names":["isSerializedLegacyElement","entry","Array","isArray","_derivedTypeId","legacyElementMessage","entries","property","guidance","refused","filter","length","undefined"],"mappings":"AAAA;AACA;AAEA;;;;;;;;;IAUO,SAASA,yBAAAA,CAA0BC,KAAc,EAAA;AACpD,IAAA,OAAO,OAAOA,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAU,QAAQ,CAACC,KAAAA,CAAMC,OAAO,CAACF,KAAAA,CAAAA,IAAU,OAAO,KAACA,CAAuCG,cAAc,KAAK,QAAA;AACrJ;AAEA;;;;;;AAMC,IACM,SAASC,oBAAAA,CAAqBC,OAAkB,EAAEC,QAAgB,EAAEC,QAAgB,EAAA;AACvF,IAAA,MAAMC,OAAAA,GAAUH,OAAAA,CAAQI,MAAM,CAACV,2BAA2BW,MAAM;AAChE,IAAA,OAAOF,OAAAA,KAAY,CAAA,GACbG,SAAAA,GACA,CAAA,EAAGH,OAAAA,CAAQ,KAAK,EAAEA,OAAAA,KAAY,CAAA,GAAI,GAAA,GAAM,KAAA,CAAM,IAAI,EAAEF,QAAAA,CAAS,CAAC,EAAEE,OAAAA,KAAY,CAAA,GAAI,MAAA,GAAS,KAAA,CAAM,6BAA6B,EAAEA,OAAAA,KAAY,CAAA,GAAI,EAAA,GAAK,GAAA,CAAI,oCAAoC,EAAED,QAAAA,CAAAA,CAAU;AACjN;;"}

package/dist/esm/data/readableValue.d.ts

@@ -0,0 +1,2 @@
+export declare function readableValue(value: unknown, depth?: number): string;
+//# sourceMappingURL=readableValue.d.ts.map

package/dist/esm/data/readableValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readableValue.d.ts","sourceRoot":"","sources":["../../../data/readableValue.ts"],"names":[],"mappings":"AAgBA,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,MAAM,CAe/D"}

package/dist/esm/data/readableValue.js

@@ -0,0 +1,29 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/** Nested deeper than this is shown as an ellipsis, so a cyclic or enormous value cannot flood the page. */ const maximumDepth = 3;
+/**
+ * Writes any authored value as text a person can read.
+ *
+ * Scalars are shown as they are. An array is its readable entries joined by commas, and an object is
+ * `name: value` pairs joined by semicolons - never `[object Object]`, and never a raw JSON document. `null`
+ * and `undefined` are empty.
+ *
+ * @param value The authored value.
+ * @param depth How deep the value is nested already; callers leave it out.
+ */ function readableValue(value, depth = 0) {
+    if (value === undefined || value === null) return '';
+    if (typeof value === 'string') return value;
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') return String(value);
+    if (depth >= maximumDepth) return '…';
+    if (Array.isArray(value)) return value.map((entry)=>readableValue(entry, depth + 1)).filter((text)=>text !== '').join(', ');
+    if (typeof value === 'object') {
+        return Object.entries(value).map(([name, entry])=>[
+                name,
+                readableValue(entry, depth + 1)
+            ]).filter(([, text])=>text !== '').map(([name, text])=>`${name}: ${text}`).join('; ');
+    }
+    return '';
+}
+
+export { readableValue };
+//# sourceMappingURL=readableValue.js.map

package/dist/esm/data/readableValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readableValue.js","sources":["../../../data/readableValue.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/** Nested deeper than this is shown as an ellipsis, so a cyclic or enormous value cannot flood the page. */\nconst maximumDepth = 3;\n\n/**\n * Writes any authored value as text a person can read.\n *\n * Scalars are shown as they are. An array is its readable entries joined by commas, and an object is\n * `name: value` pairs joined by semicolons - never `[object Object]`, and never a raw JSON document. `null`\n * and `undefined` are empty.\n *\n * @param value The authored value.\n * @param depth How deep the value is nested already; callers leave it out.\n */\nexport function readableValue(value: unknown, depth = 0): string {\n    if (value === undefined || value === null) return '';\n    if (typeof value === 'string') return value;\n    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') return String(value);\n    if (depth >= maximumDepth) return '…';\n    if (Array.isArray(value)) return value.map(entry => readableValue(entry, depth + 1)).filter(text => text !== '').join(', ');\n    if (typeof value === 'object') {\n        return Object.entries(value)\n            .map(([name, entry]) => [name, readableValue(entry, depth + 1)])\n            .filter(([, text]) => text !== '')\n            .map(([name, text]) => `${name}: ${text}`)\n            .join('; ');\n    }\n\n    return '';\n}\n"],"names":["maximumDepth","readableValue","value","depth","undefined","String","Array","isArray","map","entry","filter","text","join","Object","entries","name"],"mappings":"AAAA;AACA;AAEA,6GACA,MAAMA,YAAAA,GAAe,CAAA;AAErB;;;;;;;;;AASC,IACM,SAASC,aAAAA,CAAcC,KAAc,EAAEC,QAAQ,CAAC,EAAA;AACnD,IAAA,IAAID,KAAAA,KAAUE,SAAAA,IAAaF,KAAAA,KAAU,IAAA,EAAM,OAAO,EAAA;IAClD,IAAI,OAAOA,KAAAA,KAAU,QAAA,EAAU,OAAOA,KAAAA;IACtC,IAAI,OAAOA,KAAAA,KAAU,QAAA,IAAY,OAAOA,KAAAA,KAAU,aAAa,OAAOA,KAAAA,KAAU,QAAA,EAAU,OAAOG,MAAAA,CAAOH,KAAAA,CAAAA;IACxG,IAAIC,KAAAA,IAASH,cAAc,OAAO,GAAA;IAClC,IAAIM,KAAAA,CAAMC,OAAO,CAACL,KAAAA,CAAAA,EAAQ,OAAOA,KAAAA,CAAMM,GAAG,CAACC,CAAAA,KAAAA,GAASR,cAAcQ,KAAAA,EAAON,KAAAA,GAAQ,IAAIO,MAAM,CAACC,CAAAA,IAAAA,GAAQA,IAAAA,KAAS,EAAA,CAAA,CAAIC,IAAI,CAAC,IAAA,CAAA;IACtH,IAAI,OAAOV,UAAU,QAAA,EAAU;QAC3B,OAAOW,MAAAA,CAAOC,OAAO,CAACZ,KAAAA,CAAAA,CACjBM,GAAG,CAAC,CAAC,CAACO,IAAAA,EAAMN,KAAAA,CAAM,GAAK;AAACM,gBAAAA,IAAAA;AAAMd,gBAAAA,aAAAA,CAAcQ,OAAON,KAAAA,GAAQ,CAAA;aAAG,CAAA,CAC9DO,MAAM,CAAC,CAAC,GAAGC,KAAK,GAAKA,IAAAA,KAAS,EAAA,CAAA,CAC9BH,GAAG,CAAC,CAAC,CAACO,IAAAA,EAAMJ,IAAAA,CAAK,GAAK,CAAA,EAAGI,IAAAA,CAAK,EAAE,EAAEJ,IAAAA,CAAAA,CAAM,CAAA,CACxCC,IAAI,CAAC,IAAA,CAAA;AACd,IAAA;IAEA,OAAO,EAAA;AACX;;"}

package/dist/esm/data/selectionKeysOf.d.ts

@@ -0,0 +1,2 @@
+export declare function selectionKeysOf(value: unknown): Set<string>;
+//# sourceMappingURL=selectionKeysOf.d.ts.map

package/dist/esm/data/selectionKeysOf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionKeysOf.d.ts","sourceRoot":"","sources":["../../../data/selectionKeysOf.ts"],"names":[],"mappings":"AA6BA,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,CAU3D"}

package/dist/esm/data/selectionKeysOf.js

@@ -0,0 +1,38 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/** The keys of one node, whichever of the shapes a selection may use. */ function keyOf(value) {
+    if (typeof value === 'string' && value !== '') return value;
+    return typeof value === 'number' && Number.isFinite(value) ? String(value) : undefined;
+}
+function nodeKeyOf(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) return keyOf(value);
+    return keyOf(value.key);
+}
+/**
+ * Reads the keys an authored `selection` selects.
+ *
+ * Every shape a legacy document may hold is accepted, and none is rewritten:
+ * - one key, string or number (`'b'`, `6`);
+ * - an array mixing keys and `{ key }` objects (`['a', 6, { key: 'c' }]`);
+ * - one `{ key }` object;
+ * - PrimeReact's key map (`{ b: { checked: true, partialChecked: false } }`), whose `checked` entries are
+ *   selected. A `partialChecked` entry is derived state, not a selection, so it is ignored: the control
+ *   computes it from the selected descendants.
+ *
+ * Numeric keys are matched as the strings the tree builds from them.
+ *
+ * @param value The authored selection.
+ */ function selectionKeysOf(value) {
+    if (Array.isArray(value)) return new Set(value.flatMap((entry)=>nodeKeyOf(entry) ?? []));
+    const single = nodeKeyOf(value);
+    if (single !== undefined) return new Set([
+        single
+    ]);
+    if (typeof value === 'object' && value !== null && keyOf(value.key) === undefined) {
+        return new Set(Object.entries(value).filter(([, state])=>state?.checked === true).map(([key])=>key));
+    }
+    return new Set();
+}
+
+export { selectionKeysOf };
+//# sourceMappingURL=selectionKeysOf.js.map

package/dist/esm/data/selectionKeysOf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionKeysOf.js","sources":["../../../data/selectionKeysOf.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/** The keys of one node, whichever of the shapes a selection may use. */\nfunction keyOf(value: unknown): string | undefined {\n    if (typeof value === 'string' && value !== '') return value;\n    return typeof value === 'number' && Number.isFinite(value) ? String(value) : undefined;\n}\n\nfunction nodeKeyOf(value: unknown): string | undefined {\n    if (typeof value !== 'object' || value === null || Array.isArray(value)) return keyOf(value);\n    return keyOf((value as { key?: unknown }).key);\n}\n\n/**\n * Reads the keys an authored `selection` selects.\n *\n * Every shape a legacy document may hold is accepted, and none is rewritten:\n * - one key, string or number (`'b'`, `6`);\n * - an array mixing keys and `{ key }` objects (`['a', 6, { key: 'c' }]`);\n * - one `{ key }` object;\n * - PrimeReact's key map (`{ b: { checked: true, partialChecked: false } }`), whose `checked` entries are\n *   selected. A `partialChecked` entry is derived state, not a selection, so it is ignored: the control\n *   computes it from the selected descendants.\n *\n * Numeric keys are matched as the strings the tree builds from them.\n *\n * @param value The authored selection.\n */\nexport function selectionKeysOf(value: unknown): Set<string> {\n    if (Array.isArray(value)) return new Set(value.flatMap(entry => nodeKeyOf(entry) ?? []));\n    const single = nodeKeyOf(value);\n    if (single !== undefined) return new Set([single]);\n\n    if (typeof value === 'object' && value !== null && keyOf((value as { key?: unknown }).key) === undefined) {\n        return new Set(Object.entries(value).filter(([, state]) => (state as { checked?: unknown } | null)?.checked === true).map(([key]) => key));\n    }\n\n    return new Set();\n}\n"],"names":["keyOf","value","Number","isFinite","String","undefined","nodeKeyOf","Array","isArray","key","selectionKeysOf","Set","flatMap","entry","single","Object","entries","filter","state","checked","map"],"mappings":"AAAA;AACA;AAEA,0EACA,SAASA,KAAAA,CAAMC,KAAc,EAAA;AACzB,IAAA,IAAI,OAAOA,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAU,IAAI,OAAOA,KAAAA;IACtD,OAAO,OAAOA,UAAU,QAAA,IAAYC,MAAAA,CAAOC,QAAQ,CAACF,KAAAA,CAAAA,GAASG,OAAOH,KAAAA,CAAAA,GAASI,SAAAA;AACjF;AAEA,SAASC,UAAUL,KAAc,EAAA;IAC7B,IAAI,OAAOA,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAU,IAAA,IAAQM,MAAMC,OAAO,CAACP,KAAAA,CAAAA,EAAQ,OAAOD,KAAAA,CAAMC,KAAAA,CAAAA;IACtF,OAAOD,KAAAA,CAAM,KAACC,CAA4BQ,GAAG,CAAA;AACjD;AAEA;;;;;;;;;;;;;;IAeO,SAASC,eAAAA,CAAgBT,KAAc,EAAA;AAC1C,IAAA,IAAIM,KAAAA,CAAMC,OAAO,CAACP,KAAAA,CAAAA,EAAQ,OAAO,IAAIU,GAAAA,CAAIV,KAAAA,CAAMW,OAAO,CAACC,CAAAA,KAAAA,GAASP,SAAAA,CAAUO,UAAU,EAAE,CAAA,CAAA;AACtF,IAAA,MAAMC,SAASR,SAAAA,CAAUL,KAAAA,CAAAA;AACzB,IAAA,IAAIa,MAAAA,KAAWT,SAAAA,EAAW,OAAO,IAAIM,GAAAA,CAAI;AAACG,QAAAA;AAAO,KAAA,CAAA;IAEjD,IAAI,OAAOb,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAU,IAAA,IAAQD,MAAM,KAACC,CAA4BQ,GAAG,CAAA,KAAMJ,SAAAA,EAAW;QACtG,OAAO,IAAIM,IAAII,MAAAA,CAAOC,OAAO,CAACf,KAAAA,CAAAA,CAAOgB,MAAM,CAAC,CAAC,GAAGC,MAAM,GAAMA,OAAwCC,OAAAA,KAAY,IAAA,CAAA,CAAMC,GAAG,CAAC,CAAC,CAACX,GAAAA,CAAI,GAAKA,GAAAA,CAAAA,CAAAA;AACzI,IAAA;AAEA,IAAA,OAAO,IAAIE,GAAAA,EAAAA;AACf;;"}

package/dist/esm/data/treeTableRows.d.ts

@@ -0,0 +1,6 @@
+import { TreeNode } from '../TreeNode';
+import { TreeTableRow } from './TreeTableRow';
+export declare function visibleRows(nodes: TreeNode[], expanded: ReadonlySet<string>, depth?: number, parentKey?: string): TreeTableRow[];
+export declare function expandedKeysOf(nodes: TreeNode[]): string[];
+export declare function nodeLabel(node: TreeNode): string;
+//# sourceMappingURL=treeTableRows.d.ts.map

package/dist/esm/data/treeTableRows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeTableRows.d.ts","sourceRoot":"","sources":["../../../data/treeTableRows.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAQ9C,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,KAAK,SAAI,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,YAAY,EAAE,CAM3H;AAGD,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,EAAE,CAK1D;AAGD,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAEhD"}

package/dist/esm/data/treeTableRows.js

@@ -0,0 +1,38 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Flattens the nodes into the rows that are visible: a node's children follow it only while it is expanded.
+ *
+ * @param nodes The sibling nodes to flatten.
+ * @param expanded The keys of the expanded nodes.
+ */ function visibleRows(nodes, expanded, depth = 0, parentKey) {
+    return nodes.flatMap((node, index)=>{
+        const key = node.key ?? '';
+        const row = {
+            node,
+            key,
+            depth,
+            parentKey,
+            position: index + 1,
+            siblings: nodes.length
+        };
+        return [
+            row,
+            ...node.children !== undefined && expanded.has(key) ? visibleRows(node.children, expanded, depth + 1, key) : []
+        ];
+    });
+}
+/** The keys of the nodes authored as expanded, at any depth, in tree order. */ function expandedKeysOf(nodes) {
+    return nodes.flatMap((node)=>[
+            ...node.expanded === true && node.key !== undefined ? [
+                node.key
+            ] : [],
+            ...expandedKeysOf(node.children ?? [])
+        ]);
+}
+/** A node's own text for naming it: its label, else its key. */ function nodeLabel(node) {
+    return node.label ?? node.key ?? '';
+}
+
+export { expandedKeysOf, nodeLabel, visibleRows };
+//# sourceMappingURL=treeTableRows.js.map

package/dist/esm/data/treeTableRows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeTableRows.js","sources":["../../../data/treeTableRows.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { TreeNode } from '../TreeNode';\nimport { TreeTableRow } from './TreeTableRow';\n\n/**\n * Flattens the nodes into the rows that are visible: a node's children follow it only while it is expanded.\n *\n * @param nodes The sibling nodes to flatten.\n * @param expanded The keys of the expanded nodes.\n */\nexport function visibleRows(nodes: TreeNode[], expanded: ReadonlySet<string>, depth = 0, parentKey?: string): TreeTableRow[] {\n    return nodes.flatMap((node, index) => {\n        const key = node.key ?? '';\n        const row: TreeTableRow = { node, key, depth, parentKey, position: index + 1, siblings: nodes.length };\n        return [row, ...(node.children !== undefined && expanded.has(key) ? visibleRows(node.children, expanded, depth + 1, key) : [])];\n    });\n}\n\n/** The keys of the nodes authored as expanded, at any depth, in tree order. */\nexport function expandedKeysOf(nodes: TreeNode[]): string[] {\n    return nodes.flatMap(node => [\n        ...(node.expanded === true && node.key !== undefined ? [node.key] : []),\n        ...expandedKeysOf(node.children ?? []),\n    ]);\n}\n\n/** A node's own text for naming it: its label, else its key. */\nexport function nodeLabel(node: TreeNode): string {\n    return node.label ?? node.key ?? '';\n}\n"],"names":["visibleRows","nodes","expanded","depth","parentKey","flatMap","node","index","key","row","position","siblings","length","children","undefined","has","expandedKeysOf","nodeLabel","label"],"mappings":"AAAA;AACA;AAKA;;;;;IAMO,SAASA,WAAAA,CAAYC,KAAiB,EAAEC,QAA6B,EAAEC,KAAAA,GAAQ,CAAC,EAAEC,SAAkB,EAAA;AACvG,IAAA,OAAOH,KAAAA,CAAMI,OAAO,CAAC,CAACC,IAAAA,EAAMC,KAAAA,GAAAA;QACxB,MAAMC,GAAAA,GAAMF,IAAAA,CAAKE,GAAG,IAAI,EAAA;AACxB,QAAA,MAAMC,GAAAA,GAAoB;AAAEH,YAAAA,IAAAA;AAAME,YAAAA,GAAAA;AAAKL,YAAAA,KAAAA;AAAOC,YAAAA,SAAAA;AAAWM,YAAAA,QAAAA,EAAUH,KAAAA,GAAQ,CAAA;AAAGI,YAAAA,QAAAA,EAAUV,MAAMW;AAAO,SAAA;QACrG,OAAO;AAACH,YAAAA,GAAAA;AAASH,YAAAA,GAAAA,IAAAA,CAAKO,QAAQ,KAAKC,SAAAA,IAAaZ,QAAAA,CAASa,GAAG,CAACP,GAAAA,CAAAA,GAAOR,WAAAA,CAAYM,IAAAA,CAAKO,QAAQ,EAAEX,QAAAA,EAAUC,KAAAA,GAAQ,CAAA,EAAGK,OAAO;AAAI,SAAA;AACnI,IAAA,CAAA,CAAA;AACJ;AAEA,gFACO,SAASQ,cAAAA,CAAef,KAAiB,EAAA;AAC5C,IAAA,OAAOA,KAAAA,CAAMI,OAAO,CAACC,CAAAA,IAAAA,GAAQ;AACrBA,YAAAA,GAAAA,IAAAA,CAAKJ,QAAQ,KAAK,IAAA,IAAQI,IAAAA,CAAKE,GAAG,KAAKM,SAAAA,GAAY;AAACR,gBAAAA,IAAAA,CAAKE;AAAI,aAAA,GAAG,EAAE;eACnEQ,cAAAA,CAAeV,IAAAA,CAAKO,QAAQ,IAAI,EAAE;AACxC,SAAA,CAAA;AACL;AAEA,iEACO,SAASI,SAAAA,CAAUX,IAAc,EAAA;AACpC,IAAA,OAAOA,IAAAA,CAAKY,KAAK,IAAIZ,IAAAA,CAAKE,GAAG,IAAI,EAAA;AACrC;;"}

package/dist/esm/data/useIncrementalLoad.d.ts

@@ -0,0 +1,6 @@
+export interface IncrementalLoad {
+    loaded: number;
+    loadMore(): void;
+}
+export declare function useIncrementalLoad(total: number, chunk: number, resetKey: unknown): IncrementalLoad;
+//# sourceMappingURL=useIncrementalLoad.d.ts.map

package/dist/esm/data/useIncrementalLoad.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIncrementalLoad.d.ts","sourceRoot":"","sources":["../../../data/useIncrementalLoad.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,eAAe;IAE5B,MAAM,EAAE,MAAM,CAAC;IAGf,QAAQ,IAAI,IAAI,CAAC;CACpB;AAaD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,eAAe,CAUnG"}

package/dist/esm/data/useIncrementalLoad.js

@@ -0,0 +1,44 @@
+import { useState, useCallback } from 'react';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Tracks how many entries of a list are loaded, a chunk at a time.
+ *
+ * The count follows the authored properties: it starts over at one chunk when the chunk size changes or when
+ * `resetKey` does, so a document edit that replaces the items does not leave the old count behind. Pass a
+ * structurally stable `resetKey` (see `useStructuralValue`), or every render would reset it.
+ *
+ * @param total The number of entries there are.
+ * @param chunk The number of entries per load.
+ * @param resetKey Changes when the entries are replaced.
+ */ function useIncrementalLoad(total, chunk, resetKey) {
+    const [state, setState] = useState({
+        resetKey,
+        chunk,
+        loaded: chunk
+    });
+    let loaded = state.loaded;
+    if (state.resetKey !== resetKey || state.chunk !== chunk) {
+        setState({
+            resetKey,
+            chunk,
+            loaded: chunk
+        });
+        loaded = chunk;
+    }
+    const loadMore = useCallback(()=>setState((current)=>({
+                ...current,
+                loaded: Math.min(current.loaded + chunk, total)
+            })), [
+        chunk,
+        total
+    ]);
+    return {
+        loaded: Math.min(loaded, total),
+        loadMore
+    };
+}
+
+export { useIncrementalLoad };
+//# sourceMappingURL=useIncrementalLoad.js.map

package/dist/esm/data/useIncrementalLoad.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIncrementalLoad.js","sources":["../../../data/useIncrementalLoad.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { useCallback, useState } from 'react';\n\n/** How much of a list is loaded and how to load more. */\nexport interface IncrementalLoad {\n    /** The number of entries loaded, never more than the total. */\n    loaded: number;\n\n    /** Loads the next chunk. */\n    loadMore(): void;\n}\n\n/**\n * Tracks how many entries of a list are loaded, a chunk at a time.\n *\n * The count follows the authored properties: it starts over at one chunk when the chunk size changes or when\n * `resetKey` does, so a document edit that replaces the items does not leave the old count behind. Pass a\n * structurally stable `resetKey` (see `useStructuralValue`), or every render would reset it.\n *\n * @param total The number of entries there are.\n * @param chunk The number of entries per load.\n * @param resetKey Changes when the entries are replaced.\n */\nexport function useIncrementalLoad(total: number, chunk: number, resetKey: unknown): IncrementalLoad {\n    const [state, setState] = useState({ resetKey, chunk, loaded: chunk });\n    let loaded = state.loaded;\n    if (state.resetKey !== resetKey || state.chunk !== chunk) {\n        setState({ resetKey, chunk, loaded: chunk });\n        loaded = chunk;\n    }\n\n    const loadMore = useCallback(() => setState(current => ({ ...current, loaded: Math.min(current.loaded + chunk, total) })), [chunk, total]);\n    return { loaded: Math.min(loaded, total), loadMore };\n}\n"],"names":["useIncrementalLoad","total","chunk","resetKey","state","setState","useState","loaded","loadMore","useCallback","current","Math","min"],"mappings":";;AAAA;AACA;AAaA;;;;;;;;;;AAUC,IACM,SAASA,kBAAAA,CAAmBC,KAAa,EAAEC,KAAa,EAAEC,QAAiB,EAAA;AAC9E,IAAA,MAAM,CAACC,KAAAA,EAAOC,QAAAA,CAAS,GAAGC,QAAAA,CAAS;AAAEH,QAAAA,QAAAA;AAAUD,QAAAA,KAAAA;QAAOK,MAAAA,EAAQL;AAAM,KAAA,CAAA;IACpE,IAAIK,MAAAA,GAASH,MAAMG,MAAM;AACzB,IAAA,IAAIH,MAAMD,QAAQ,KAAKA,YAAYC,KAAAA,CAAMF,KAAK,KAAKA,KAAAA,EAAO;QACtDG,QAAAA,CAAS;AAAEF,YAAAA,QAAAA;AAAUD,YAAAA,KAAAA;YAAOK,MAAAA,EAAQL;AAAM,SAAA,CAAA;QAC1CK,MAAAA,GAASL,KAAAA;AACb,IAAA;AAEA,IAAA,MAAMM,WAAWC,WAAAA,CAAY,IAAMJ,QAAAA,CAASK,CAAAA,WAAY;AAAE,gBAAA,GAAGA,OAAO;AAAEH,gBAAAA,MAAAA,EAAQI,KAAKC,GAAG,CAACF,OAAAA,CAAQH,MAAM,GAAGL,KAAAA,EAAOD,KAAAA;AAAO,aAAA,CAAA,CAAA,EAAK;AAACC,QAAAA,KAAAA;AAAOD,QAAAA;AAAM,KAAA,CAAA;IACzI,OAAO;QAAEM,MAAAA,EAAQI,IAAAA,CAAKC,GAAG,CAACL,MAAAA,EAAQN,KAAAA,CAAAA;AAAQO,QAAAA;AAAS,KAAA;AACvD;;"}

package/dist/esm/data/useLoadOnReach.d.ts

@@ -0,0 +1,3 @@
+import { RefObject } from 'react';
+export declare function useLoadOnReach(sentinel: RefObject<HTMLElement | null>, root: RefObject<HTMLElement | null> | null, active: boolean, revision: unknown, onReach: () => void): void;
+//# sourceMappingURL=useLoadOnReach.d.ts.map

package/dist/esm/data/useLoadOnReach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLoadOnReach.d.ts","sourceRoot":"","sources":["../../../data/useLoadOnReach.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAa,MAAM,OAAO,CAAC;AAgB7C,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI,CAWjL"}

package/dist/esm/data/useLoadOnReach.js

@@ -0,0 +1,40 @@
+import { useEffect } from 'react';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Calls `onReach` while the sentinel is visible, which is what scrolling to the end of a list means.
+ *
+ * The observer is rebuilt whenever `revision` changes, so a sentinel that is still visible after a chunk was
+ * loaded loads the next one, until the viewport is filled or the list ends. `root` is the element that
+ * scrolls for an inline list; `null` observes the page's own viewport. Where there is no
+ * `IntersectionObserver` nothing is observed and the list's own button remains the way to load more.
+ *
+ * @param sentinel The element placed after the last loaded entry.
+ * @param root The scrolling container, or `null` for the page.
+ * @param active Whether reaching the end should load anything.
+ * @param revision A value that changes each time the list changed.
+ * @param onReach Loads the next chunk.
+ */ function useLoadOnReach(sentinel, root, active, revision, onReach) {
+    useEffect(()=>{
+        const target = sentinel.current;
+        if (!active || target === null || typeof IntersectionObserver === 'undefined') return undefined;
+        const observer = new IntersectionObserver((entries)=>{
+            if (entries.some((entry)=>entry.isIntersecting)) onReach();
+        }, {
+            root: root?.current ?? null,
+            rootMargin: '0px 0px 48px 0px'
+        });
+        observer.observe(target);
+        return ()=>observer.disconnect();
+    }, [
+        sentinel,
+        root,
+        active,
+        revision,
+        onReach
+    ]);
+}
+
+export { useLoadOnReach };
+//# sourceMappingURL=useLoadOnReach.js.map

package/dist/esm/data/useLoadOnReach.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLoadOnReach.js","sources":["../../../data/useLoadOnReach.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { RefObject, useEffect } from 'react';\n\n/**\n * Calls `onReach` while the sentinel is visible, which is what scrolling to the end of a list means.\n *\n * The observer is rebuilt whenever `revision` changes, so a sentinel that is still visible after a chunk was\n * loaded loads the next one, until the viewport is filled or the list ends. `root` is the element that\n * scrolls for an inline list; `null` observes the page's own viewport. Where there is no\n * `IntersectionObserver` nothing is observed and the list's own button remains the way to load more.\n *\n * @param sentinel The element placed after the last loaded entry.\n * @param root The scrolling container, or `null` for the page.\n * @param active Whether reaching the end should load anything.\n * @param revision A value that changes each time the list changed.\n * @param onReach Loads the next chunk.\n */\nexport function useLoadOnReach(sentinel: RefObject<HTMLElement | null>, root: RefObject<HTMLElement | null> | null, active: boolean, revision: unknown, onReach: () => void): void {\n    useEffect(() => {\n        const target = sentinel.current;\n        if (!active || target === null || typeof IntersectionObserver === 'undefined') return undefined;\n\n        const observer = new IntersectionObserver(entries => {\n            if (entries.some(entry => entry.isIntersecting)) onReach();\n        }, { root: root?.current ?? null, rootMargin: '0px 0px 48px 0px' });\n        observer.observe(target);\n        return () => observer.disconnect();\n    }, [sentinel, root, active, revision, onReach]);\n}\n"],"names":["useLoadOnReach","sentinel","root","active","revision","onReach","useEffect","target","current","IntersectionObserver","undefined","observer","entries","some","entry","isIntersecting","rootMargin","observe","disconnect"],"mappings":";;AAAA;AACA;AAIA;;;;;;;;;;;;;IAcO,SAASA,cAAAA,CAAeC,QAAuC,EAAEC,IAA0C,EAAEC,MAAe,EAAEC,QAAiB,EAAEC,OAAmB,EAAA;IACvKC,SAAAA,CAAU,IAAA;QACN,MAAMC,MAAAA,GAASN,SAASO,OAAO;AAC/B,QAAA,IAAI,CAACL,MAAAA,IAAUI,MAAAA,KAAW,QAAQ,OAAOE,oBAAAA,KAAyB,aAAa,OAAOC,SAAAA;QAEtF,MAAMC,QAAAA,GAAW,IAAIF,oBAAAA,CAAqBG,CAAAA,OAAAA,GAAAA;AACtC,YAAA,IAAIA,QAAQC,IAAI,CAACC,CAAAA,KAAAA,GAASA,KAAAA,CAAMC,cAAc,CAAA,EAAGV,OAAAA,EAAAA;QACrD,CAAA,EAAG;AAAEH,YAAAA,IAAAA,EAAMA,MAAMM,OAAAA,IAAW,IAAA;YAAMQ,UAAAA,EAAY;AAAmB,SAAA,CAAA;AACjEL,QAAAA,QAAAA,CAASM,OAAO,CAACV,MAAAA,CAAAA;QACjB,OAAO,IAAMI,SAASO,UAAU,EAAA;IACpC,CAAA,EAAG;AAACjB,QAAAA,QAAAA;AAAUC,QAAAA,IAAAA;AAAMC,QAAAA,MAAAA;AAAQC,QAAAA,QAAAA;AAAUC,QAAAA;AAAQ,KAAA,CAAA;AAClD;;"}

package/dist/esm/data/useTreeGridNavigation.d.ts

@@ -0,0 +1,17 @@
+import { KeyboardEvent } from 'react';
+import { TreeTableRow } from './TreeTableRow';
+export interface TreeGridNavigationOptions {
+    rows: TreeTableRow[];
+    expanded: ReadonlySet<string>;
+    enabled: boolean;
+    toggle(key: string): void;
+    select(row: TreeTableRow): void;
+}
+export interface TreeGridNavigation {
+    tabStopKey: string | undefined;
+    register(key: string, element: HTMLElement | null): void;
+    activate(key: string): void;
+    onKeyDown(row: TreeTableRow, event: KeyboardEvent<HTMLElement>): void;
+}
+export declare function useTreeGridNavigation({ rows, expanded, enabled, toggle, select }: TreeGridNavigationOptions): TreeGridNavigation;
+//# sourceMappingURL=useTreeGridNavigation.d.ts.map

package/dist/esm/data/useTreeGridNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTreeGridNavigation.d.ts","sourceRoot":"","sources":["../../../data/useTreeGridNavigation.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAiC,MAAM,OAAO,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,MAAM,WAAW,yBAAyB;IACtC,IAAI,EAAE,YAAY,EAAE,CAAC;IACrB,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,MAAM,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI,CAAC;CACnC;AAGD,MAAM,WAAW,kBAAkB;IAE/B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAG/B,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI,CAAC;IAGzD,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAG5B,SAAS,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;CACzE;AASD,wBAAgB,qBAAqB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,yBAAyB,GAAG,kBAAkB,CA2ChI"}

package/dist/esm/data/useTreeGridNavigation.js

@@ -0,0 +1,73 @@
+import { useState, useRef, useCallback } from 'react';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The keyboard model of an ARIA tree grid, with a roving tab index.
+ *
+ * Up and Down move between visible rows, Home and End to the first and last, Right expands a collapsed row or
+ * enters its first child, Left collapses an expanded row or goes to its parent, and Space or Enter selects.
+ * Keys pressed on a control inside the row (its expand button or checkbox) are left to that control.
+ */ function useTreeGridNavigation({ rows, expanded, enabled, toggle, select }) {
+    const [activeKey, setActiveKey] = useState(undefined);
+    const elements = useRef(new Map());
+    const tabStopKey = rows.some((row)=>row.key === activeKey) ? activeKey : rows[0]?.key;
+    const register = useCallback((key, element)=>{
+        if (element === null) elements.current.delete(key);
+        else elements.current.set(key, element);
+    }, []);
+    const moveTo = (row)=>{
+        if (row === undefined) return;
+        setActiveKey(row.key);
+        elements.current.get(row.key)?.focus();
+    };
+    const onKeyDown = (row, event)=>{
+        if (event.target !== event.currentTarget) return;
+        const index = rows.indexOf(row);
+        const hasChildren = (row.node.children?.length ?? 0) > 0;
+        const handled = (action)=>{
+            event.preventDefault();
+            action();
+        };
+        switch(event.key){
+            case 'ArrowDown':
+                handled(()=>moveTo(rows[index + 1]));
+                break;
+            case 'ArrowUp':
+                handled(()=>moveTo(rows[index - 1]));
+                break;
+            case 'Home':
+                handled(()=>moveTo(rows[0]));
+                break;
+            case 'End':
+                handled(()=>moveTo(rows[rows.length - 1]));
+                break;
+            case 'ArrowRight':
+                if (hasChildren) handled(()=>{
+                    if (!expanded.has(row.key)) {
+                        if (enabled) toggle(row.key);
+                    } else moveTo(rows[index + 1]);
+                });
+                break;
+            case 'ArrowLeft':
+                if (hasChildren && expanded.has(row.key)) handled(()=>{
+                    if (enabled) toggle(row.key);
+                });
+                else if (row.parentKey !== undefined) handled(()=>moveTo(rows.find((candidate)=>candidate.key === row.parentKey)));
+                break;
+            case ' ':
+            case 'Enter':
+                handled(()=>select(row));
+                break;
+        }
+    };
+    return {
+        tabStopKey,
+        register,
+        activate: setActiveKey,
+        onKeyDown
+    };
+}
+
+export { useTreeGridNavigation };
+//# sourceMappingURL=useTreeGridNavigation.js.map

package/dist/esm/data/useTreeGridNavigation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTreeGridNavigation.js","sources":["../../../data/useTreeGridNavigation.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { KeyboardEvent, useCallback, useRef, useState } from 'react';\nimport { TreeTableRow } from './TreeTableRow';\n\n/** What the keyboard navigation of a tree grid needs from the control. */\nexport interface TreeGridNavigationOptions {\n    rows: TreeTableRow[];\n    expanded: ReadonlySet<string>;\n    enabled: boolean;\n    toggle(key: string): void;\n    select(row: TreeTableRow): void;\n}\n\n/** The wiring a tree grid applies to its rows. */\nexport interface TreeGridNavigation {\n    /** The one row that is in the tab order (roving tabindex). */\n    tabStopKey: string | undefined;\n\n    /** Gives the navigation the element of a row, so it can move focus there. */\n    register(key: string, element: HTMLElement | null): void;\n\n    /** Makes a row the tab stop, as a click does. */\n    activate(key: string): void;\n\n    /** The key handler of a row. */\n    onKeyDown(row: TreeTableRow, event: KeyboardEvent<HTMLElement>): void;\n}\n\n/**\n * The keyboard model of an ARIA tree grid, with a roving tab index.\n *\n * Up and Down move between visible rows, Home and End to the first and last, Right expands a collapsed row or\n * enters its first child, Left collapses an expanded row or goes to its parent, and Space or Enter selects.\n * Keys pressed on a control inside the row (its expand button or checkbox) are left to that control.\n */\nexport function useTreeGridNavigation({ rows, expanded, enabled, toggle, select }: TreeGridNavigationOptions): TreeGridNavigation {\n    const [activeKey, setActiveKey] = useState<string | undefined>(undefined);\n    const elements = useRef(new Map<string, HTMLElement>());\n    const tabStopKey = rows.some(row => row.key === activeKey) ? activeKey : rows[0]?.key;\n\n    const register = useCallback((key: string, element: HTMLElement | null) => {\n        if (element === null) elements.current.delete(key); else elements.current.set(key, element);\n    }, []);\n\n    const moveTo = (row: TreeTableRow | undefined) => {\n        if (row === undefined) return;\n        setActiveKey(row.key);\n        elements.current.get(row.key)?.focus();\n    };\n\n    const onKeyDown = (row: TreeTableRow, event: KeyboardEvent<HTMLElement>) => {\n        if (event.target !== event.currentTarget) return;\n        const index = rows.indexOf(row);\n        const hasChildren = (row.node.children?.length ?? 0) > 0;\n        const handled = (action: () => void) => { event.preventDefault(); action(); };\n\n        switch (event.key) {\n            case 'ArrowDown': handled(() => moveTo(rows[index + 1])); break;\n            case 'ArrowUp': handled(() => moveTo(rows[index - 1])); break;\n            case 'Home': handled(() => moveTo(rows[0])); break;\n            case 'End': handled(() => moveTo(rows[rows.length - 1])); break;\n            case 'ArrowRight':\n                if (hasChildren) handled(() => { if (!expanded.has(row.key)) { if (enabled) toggle(row.key); } else moveTo(rows[index + 1]); });\n                break;\n            case 'ArrowLeft':\n                if (hasChildren && expanded.has(row.key)) handled(() => { if (enabled) toggle(row.key); });\n                else if (row.parentKey !== undefined) handled(() => moveTo(rows.find(candidate => candidate.key === row.parentKey)));\n                break;\n            case ' ':\n            case 'Enter':\n                handled(() => select(row));\n                break;\n            default:\n                break;\n        }\n    };\n\n    return { tabStopKey, register, activate: setActiveKey, onKeyDown };\n}\n"],"names":["useTreeGridNavigation","rows","expanded","enabled","toggle","select","activeKey","setActiveKey","useState","undefined","elements","useRef","Map","tabStopKey","some","row","key","register","useCallback","element","current","delete","set","moveTo","get","focus","onKeyDown","event","target","currentTarget","index","indexOf","hasChildren","node","children","length","handled","action","preventDefault","has","parentKey","find","candidate","activate"],"mappings":"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"}

package/dist/esm/editor/PrimeEditor.d.ts

@@ -0,0 +1,3 @@
+import { RegisteredComponentProps } from '@cratis/scene.react';
+export declare function PrimeEditor({ element, interactions }: RegisteredComponentProps): import("react").JSX.Element;
+//# sourceMappingURL=PrimeEditor.d.ts.map

package/dist/esm/editor/PrimeEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeEditor.d.ts","sourceRoot":"","sources":["../../../editor/PrimeEditor.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAwB/D,wBAAgB,WAAW,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,wBAAwB,+BAsD9E"}

package/dist/esm/editor/PrimeEditor.js

@@ -0,0 +1,94 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useContext, useRef, useState, useEffect, useMemo } from 'react';
+import { stringProperty, booleanProperty } from '../properties.js';
+import { QuillLoaderContext } from './QuillLoaderContext.js';
+import { htmlToPlainText } from './htmlToPlainText.js';
+import { renderSafeNodes } from './renderSafeNodes.js';
+import { sanitizeHtml } from './sanitizeHtml.js';
+import { useQuillEditor } from './useQuillEditor.js';
+
+/**
+ * The `PrimeReact:editor` rich-text control.
+ *
+ * Authored HTML is untrusted data and is never injected as markup. Everywhere it is shown it first goes
+ * through an allowlist (see {@link sanitizeHtml}): into Quill as a Delta, or into the read-only view as React
+ * elements. Where there is no DOM - server rendering, and the first client render so hydration matches - it is
+ * shown as plain text. `element.properties.value` itself is never changed.
+ *
+ * Editing needs Quill, which this package does not import. A host provides it with `QuillLoaderProvider`
+ * (the loader `loadQuill` lives in the `@cratis/scene.primereact/quill` entry point). Without a loader, or if
+ * loading fails, the content stays visible read-only and a status says why; the control never pretends to be
+ * editable.
+ *
+ * `readOnly: true` and `isEnabled: false` both stop editing. Edits are runtime state: `interactions.onChange`
+ * is called when the user edits, but the new HTML is not written back to the document or a binding.
+ */ function PrimeEditor({ element, interactions }) {
+    const loader = useContext(QuillLoaderContext);
+    const host = useRef(null);
+    const interactionReference = useRef(interactions);
+    interactionReference.current = interactions;
+    const [mounted, setMounted] = useState(false);
+    const html = stringProperty(element, 'value', '');
+    const readOnly = booleanProperty(element, 'readOnly', false);
+    const editable = !readOnly && element.isEnabled;
+    const ariaLabel = stringProperty(element, 'ariaLabel', 'Rich text editor');
+    useEffect(()=>setMounted(true), []);
+    const editor = useQuillEditor({
+        loader,
+        host,
+        html,
+        showHeader: booleanProperty(element, 'showHeader', true),
+        editable,
+        placeholder: stringProperty(element, 'placeholder'),
+        ariaLabel,
+        onUserChange: ()=>interactionReference.current?.onChange?.()
+    });
+    const readOnlyView = useMemo(()=>{
+        if (!mounted || typeof DOMParser === 'undefined') return htmlToPlainText(html);
+        return renderSafeNodes(sanitizeHtml(html));
+    }, [
+        mounted,
+        html
+    ]);
+    const status = !editor.ready ? undefined : editable ? `${editor.characters} characters` : readOnly ? 'Read only' : 'Disabled';
+    return /*#__PURE__*/ jsxs("section", {
+        "data-scene-id": element.id,
+        "data-scene-component": "editor",
+        onClick: interactions?.onClick,
+        onDoubleClick: interactions?.onDoubleClick,
+        children: [
+            /*#__PURE__*/ jsx("div", {
+                ref: host
+            }),
+            !editor.ready && /*#__PURE__*/ jsx("div", {
+                role: "textbox",
+                tabIndex: 0,
+                "aria-multiline": "true",
+                "aria-readonly": "true",
+                "aria-label": ariaLabel,
+                "data-scene-part": "read-only-content",
+                style: typeof readOnlyView === 'string' ? {
+                    whiteSpace: 'pre-wrap'
+                } : undefined,
+                children: readOnlyView
+            }, typeof readOnlyView),
+            editor.failure !== undefined && /*#__PURE__*/ jsx("p", {
+                role: "alert",
+                "data-scene-state": "unavailable",
+                children: `Rich-text editing could not be loaded: ${editor.failure}`
+            }),
+            !editor.ready && editor.failure === undefined && loader === undefined && /*#__PURE__*/ jsx("p", {
+                role: "status",
+                "data-scene-state": "read-only",
+                children: "Rich-text editing is not available in this application. The content is shown read-only."
+            }),
+            status !== undefined && /*#__PURE__*/ jsx("output", {
+                "aria-live": "polite",
+                children: status
+            })
+        ]
+    });
+}
+
+export { PrimeEditor };
+//# sourceMappingURL=PrimeEditor.js.map

package/dist/esm/editor/PrimeEditor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeEditor.js","sources":["../../../editor/PrimeEditor.tsx"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { useContext, useEffect, useMemo, useRef, useState } from 'react';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, stringProperty } from '../properties';\nimport { QuillLoaderContext } from './QuillLoaderContext';\nimport { htmlToPlainText } from './htmlToPlainText';\nimport { renderSafeNodes } from './renderSafeNodes';\nimport { sanitizeHtml } from './sanitizeHtml';\nimport { useQuillEditor } from './useQuillEditor';\n\n/**\n * The `PrimeReact:editor` rich-text control.\n *\n * Authored HTML is untrusted data and is never injected as markup. Everywhere it is shown it first goes\n * through an allowlist (see {@link sanitizeHtml}): into Quill as a Delta, or into the read-only view as React\n * elements. Where there is no DOM - server rendering, and the first client render so hydration matches - it is\n * shown as plain text. `element.properties.value` itself is never changed.\n *\n * Editing needs Quill, which this package does not import. A host provides it with `QuillLoaderProvider`\n * (the loader `loadQuill` lives in the `@cratis/scene.primereact/quill` entry point). Without a loader, or if\n * loading fails, the content stays visible read-only and a status says why; the control never pretends to be\n * editable.\n *\n * `readOnly: true` and `isEnabled: false` both stop editing. Edits are runtime state: `interactions.onChange`\n * is called when the user edits, but the new HTML is not written back to the document or a binding.\n */\nexport function PrimeEditor({ element, interactions }: RegisteredComponentProps) {\n    const loader = useContext(QuillLoaderContext);\n    const host = useRef<HTMLDivElement>(null);\n    const interactionReference = useRef(interactions);\n    interactionReference.current = interactions;\n    const [mounted, setMounted] = useState(false);\n    const html = stringProperty(element, 'value', '');\n    const readOnly = booleanProperty(element, 'readOnly', false);\n    const editable = !readOnly && element.isEnabled;\n    const ariaLabel = stringProperty(element, 'ariaLabel', 'Rich text editor');\n\n    useEffect(() => setMounted(true), []);\n\n    const editor = useQuillEditor({\n        loader,\n        host,\n        html,\n        showHeader: booleanProperty(element, 'showHeader', true),\n        editable,\n        placeholder: stringProperty(element, 'placeholder'),\n        ariaLabel,\n        onUserChange: () => interactionReference.current?.onChange?.(),\n    });\n\n    const readOnlyView = useMemo(() => {\n        if (!mounted || typeof DOMParser === 'undefined') return htmlToPlainText(html);\n        return renderSafeNodes(sanitizeHtml(html));\n    }, [mounted, html]);\n\n    const status = !editor.ready ? undefined : editable ? `${editor.characters} characters` : readOnly ? 'Read only' : 'Disabled';\n\n    return (\n        <section data-scene-id={element.id} data-scene-component='editor' onClick={interactions?.onClick} onDoubleClick={interactions?.onDoubleClick}>\n            <div ref={host} />\n            {!editor.ready && (\n                <div\n                    key={typeof readOnlyView}\n                    role='textbox'\n                    tabIndex={0}\n                    aria-multiline='true'\n                    aria-readonly='true'\n                    aria-label={ariaLabel}\n                    data-scene-part='read-only-content'\n                    style={typeof readOnlyView === 'string' ? { whiteSpace: 'pre-wrap' } : undefined}>\n                    {readOnlyView}\n                </div>\n            )}\n            {editor.failure !== undefined && <p role='alert' data-scene-state='unavailable'>{`Rich-text editing could not be loaded: ${editor.failure}`}</p>}\n            {!editor.ready && editor.failure === undefined && loader === undefined && (\n                <p role='status' data-scene-state='read-only'>Rich-text editing is not available in this application. The content is shown read-only.</p>\n            )}\n            {status !== undefined && <output aria-live='polite'>{status}</output>}\n        </section>\n    );\n}\n"],"names":["PrimeEditor","element","interactions","loader","useContext","QuillLoaderContext","host","useRef","interactionReference","current","mounted","setMounted","useState","html","stringProperty","readOnly","booleanProperty","editable","isEnabled","ariaLabel","useEffect","editor","useQuillEditor","showHeader","placeholder","onUserChange","onChange","readOnlyView","useMemo","DOMParser","htmlToPlainText","renderSafeNodes","sanitizeHtml","status","ready","undefined","characters","_jsxs","section","data-scene-id","id","data-scene-component","onClick","onDoubleClick","_jsx","div","ref","role","tabIndex","aria-multiline","aria-readonly","aria-label","data-scene-part","style","whiteSpace","failure","p","data-scene-state","output","aria-live"],"mappings":"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"}

package/dist/esm/editor/QuillConstructor.d.ts

@@ -0,0 +1,4 @@
+import { QuillInstance } from './QuillInstance';
+import { QuillOptions } from './QuillOptions';
+export type QuillConstructor = new (container: HTMLElement, options: QuillOptions) => QuillInstance;
+//# sourceMappingURL=QuillConstructor.d.ts.map

package/dist/esm/editor/QuillConstructor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuillConstructor.d.ts","sourceRoot":"","sources":["../../../editor/QuillConstructor.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C,MAAM,MAAM,gBAAgB,GAAG,KAAK,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,KAAK,aAAa,CAAC"}

package/dist/esm/editor/QuillConstructor.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=QuillConstructor.js.map

package/dist/esm/editor/QuillConstructor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuillConstructor.js","sourceRoot":"","sources":["../../../editor/QuillConstructor.ts"],"names":[],"mappings":""}

package/dist/esm/editor/QuillEditorOptions.d.ts

@@ -0,0 +1,13 @@
+import { RefObject } from 'react';
+import { QuillLoader } from './QuillLoader';
+export interface QuillEditorOptions {
+    loader: QuillLoader | undefined;
+    host: RefObject<HTMLElement | null>;
+    html: string;
+    showHeader: boolean;
+    editable: boolean;
+    placeholder: string | undefined;
+    ariaLabel: string;
+    onUserChange(): void;
+}
+//# sourceMappingURL=QuillEditorOptions.d.ts.map

package/dist/esm/editor/QuillEditorOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuillEditorOptions.d.ts","sourceRoot":"","sources":["../../../editor/QuillEditorOptions.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAClC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,MAAM,WAAW,kBAAkB;IAE/B,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;IAGhC,IAAI,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IAGpC,IAAI,EAAE,MAAM,CAAC;IAGb,UAAU,EAAE,OAAO,CAAC;IAGpB,QAAQ,EAAE,OAAO,CAAC;IAElB,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAGlB,YAAY,IAAI,IAAI,CAAC;CACxB"}

package/dist/esm/editor/QuillEditorOptions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=QuillEditorOptions.js.map

package/dist/esm/editor/QuillEditorOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuillEditorOptions.js","sourceRoot":"","sources":["../../../editor/QuillEditorOptions.ts"],"names":[],"mappings":""}