@cratis/scene.primereact 4.5.0 → 4.7.0

package/dist/cjs/resolveEnumeration.js

@@ -0,0 +1,55 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Resolves an authored value to a member of one of this package's string enums.
+ *
+ * Three forms are accepted, and the stored value is never rewritten:
+ * - the canonical string value the enum declares (`'checkbox'`), which new documents use;
+ * - the ordinal of the original .NET enum (`3`), which migrated documents carry. The ordinal is the member's
+ *   position in declaration order, so that order is part of the stored-data contract and must not change;
+ * - the .NET member name in its original Pascal case (`'Checkbox'`), which a JSON serialization of that enum
+ *   produces.
+ *
+ * An absent value is the one default. Anything else - an out-of-range or fractional ordinal, a numeric
+ * string, a differently cased name, `null` - resolves to a finding with a message, because the intended
+ * behavior cannot be known and a silent fallback hides a mistyped document.
+ *
+ * @param property The property name, used in the message.
+ * @param value The authored value.
+ * @param members The enum object.
+ * @param fallback The member an absent value means.
+ * @returns The resolved member, or the finding.
+ */ function resolveEnumeration(property, value, members, fallback) {
+    if (value === undefined) return {
+        isValid: true,
+        value: fallback
+    };
+    const canonical = Object.values(members);
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 0 && value < canonical.length) {
+        return {
+            isValid: true,
+            value: canonical[value]
+        };
+    }
+    if (typeof value === 'string') {
+        if (canonical.includes(value)) return {
+            isValid: true,
+            value: value
+        };
+        if (Object.hasOwn(members, value)) return {
+            isValid: true,
+            value: members[value]
+        };
+    }
+    const shown = typeof value === 'string' ? `'${value}'` : JSON.stringify(value) ?? String(value);
+    return {
+        isValid: false,
+        value,
+        message: `Unsupported ${property} ${shown}. Use one of ${canonical.join(', ')}, or a legacy ordinal from 0 to ${canonical.length - 1}.`
+    };
+}
+
+exports.resolveEnumeration = resolveEnumeration;
+//# sourceMappingURL=resolveEnumeration.js.map

package/dist/cjs/resolveEnumeration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveEnumeration.js","sources":["../../resolveEnumeration.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 { EnumerationResolution } from './EnumerationResolution';\n\n/**\n * Resolves an authored value to a member of one of this package's string enums.\n *\n * Three forms are accepted, and the stored value is never rewritten:\n * - the canonical string value the enum declares (`'checkbox'`), which new documents use;\n * - the ordinal of the original .NET enum (`3`), which migrated documents carry. The ordinal is the member's\n *   position in declaration order, so that order is part of the stored-data contract and must not change;\n * - the .NET member name in its original Pascal case (`'Checkbox'`), which a JSON serialization of that enum\n *   produces.\n *\n * An absent value is the one default. Anything else - an out-of-range or fractional ordinal, a numeric\n * string, a differently cased name, `null` - resolves to a finding with a message, because the intended\n * behavior cannot be known and a silent fallback hides a mistyped document.\n *\n * @param property The property name, used in the message.\n * @param value The authored value.\n * @param members The enum object.\n * @param fallback The member an absent value means.\n * @returns The resolved member, or the finding.\n */\nexport function resolveEnumeration<TMember extends string>(\n    property: string,\n    value: unknown,\n    members: Record<string, TMember>,\n    fallback: TMember\n): EnumerationResolution<TMember> {\n    if (value === undefined) return { isValid: true, value: fallback };\n\n    const canonical = Object.values(members);\n    if (typeof value === 'number' && Number.isInteger(value) && value >= 0 && value < canonical.length) {\n        return { isValid: true, value: canonical[value] };\n    }\n\n    if (typeof value === 'string') {\n        if (canonical.includes(value as TMember)) return { isValid: true, value: value as TMember };\n        if (Object.hasOwn(members, value)) return { isValid: true, value: members[value] };\n    }\n\n    const shown = typeof value === 'string' ? `'${value}'` : JSON.stringify(value) ?? String(value);\n    return {\n        isValid: false,\n        value,\n        message: `Unsupported ${property} ${shown}. Use one of ${canonical.join(', ')}, or a legacy ordinal from 0 to ${canonical.length - 1}.`,\n    };\n}\n"],"names":["resolveEnumeration","property","value","members","fallback","undefined","isValid","canonical","Object","values","Number","isInteger","length","includes","hasOwn","shown","JSON","stringify","String","message","join"],"mappings":";;AAAA;AACA;AAIA;;;;;;;;;;;;;;;;;;;IAoBO,SAASA,kBAAAA,CACZC,QAAgB,EAChBC,KAAc,EACdC,OAAgC,EAChCC,QAAiB,EAAA;IAEjB,IAAIF,KAAAA,KAAUG,WAAW,OAAO;QAAEC,OAAAA,EAAS,IAAA;QAAMJ,KAAAA,EAAOE;AAAS,KAAA;IAEjE,MAAMG,SAAAA,GAAYC,MAAAA,CAAOC,MAAM,CAACN,OAAAA,CAAAA;AAChC,IAAA,IAAI,OAAOD,KAAAA,KAAU,QAAA,IAAYQ,MAAAA,CAAOC,SAAS,CAACT,KAAAA,CAAAA,IAAUA,KAAAA,IAAS,CAAA,IAAKA,KAAAA,GAAQK,SAAAA,CAAUK,MAAM,EAAE;QAChG,OAAO;YAAEN,OAAAA,EAAS,IAAA;YAAMJ,KAAAA,EAAOK,SAAS,CAACL,KAAAA;AAAO,SAAA;AACpD,IAAA;IAEA,IAAI,OAAOA,UAAU,QAAA,EAAU;AAC3B,QAAA,IAAIK,SAAAA,CAAUM,QAAQ,CAACX,KAAAA,CAAAA,EAAmB,OAAO;YAAEI,OAAAA,EAAS,IAAA;YAAMJ,KAAAA,EAAOA;AAAiB,SAAA;AAC1F,QAAA,IAAIM,MAAAA,CAAOM,MAAM,CAACX,OAAAA,EAASD,QAAQ,OAAO;YAAEI,OAAAA,EAAS,IAAA;YAAMJ,KAAAA,EAAOC,OAAO,CAACD,KAAAA;AAAO,SAAA;AACrF,IAAA;AAEA,IAAA,MAAMa,KAAAA,GAAQ,OAAOb,KAAAA,KAAU,QAAA,GAAW,CAAC,CAAC,EAAEA,KAAAA,CAAM,CAAC,CAAC,GAAGc,IAAAA,CAAKC,SAAS,CAACf,UAAUgB,MAAAA,CAAOhB,KAAAA,CAAAA;IACzF,OAAO;QACHI,OAAAA,EAAS,KAAA;AACTJ,QAAAA,KAAAA;QACAiB,OAAAA,EAAS,CAAC,YAAY,EAAElB,QAAAA,CAAS,CAAC,EAAEc,KAAAA,CAAM,aAAa,EAAER,SAAAA,CAAUa,IAAI,CAAC,IAAA,CAAA,CAAM,gCAAgC,EAAEb,SAAAA,CAAUK,MAAM,GAAG,CAAA,CAAE,CAAC;AAC1I,KAAA;AACJ;;"}

package/dist/cjs/structurallyEqual.js

@@ -0,0 +1,27 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Compares values that can survive a Scene document serialization round trip.
+ *
+ * Authored data (chart datasets, option values, current values) arrives as plain JSON. Every edit to a
+ * Scene document clones the whole document, so the same data gets a new object identity with no change in
+ * content; reference equality would treat each unrelated edit as a change. Primitives compare with
+ * `Object.is`, so `0` and `-0`, or `NaN` and `NaN`, are told apart exactly as `Object.is` does.
+ */ function structurallyEqual(left, right) {
+    if (Object.is(left, right)) return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index)=>structurallyEqual(value, right[index]));
+    }
+    if (!isRecord(left) || !isRecord(right)) return false;
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    return leftKeys.length === rightKeys.length && leftKeys.every((key, index)=>key === rightKeys[index] && structurallyEqual(left[key], right[key]));
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object';
+}
+
+exports.structurallyEqual = structurallyEqual;
+//# sourceMappingURL=structurallyEqual.js.map

package/dist/cjs/structurallyEqual.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structurallyEqual.js","sources":["../../structurallyEqual.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 * Compares values that can survive a Scene document serialization round trip.\n *\n * Authored data (chart datasets, option values, current values) arrives as plain JSON. Every edit to a\n * Scene document clones the whole document, so the same data gets a new object identity with no change in\n * content; reference equality would treat each unrelated edit as a change. Primitives compare with\n * `Object.is`, so `0` and `-0`, or `NaN` and `NaN`, are told apart exactly as `Object.is` does.\n */\nexport function structurallyEqual(left: unknown, right: unknown): boolean {\n    if (Object.is(left, right)) return true;\n    if (Array.isArray(left) || Array.isArray(right)) {\n        return Array.isArray(left) && Array.isArray(right)\n            && left.length === right.length\n            && left.every((value, index) => structurallyEqual(value, right[index]));\n    }\n\n    if (!isRecord(left) || !isRecord(right)) return false;\n    const leftKeys = Object.keys(left).sort();\n    const rightKeys = Object.keys(right).sort();\n    return leftKeys.length === rightKeys.length\n        && leftKeys.every((key, index) => key === rightKeys[index] && structurallyEqual(left[key], right[key]));\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n    return value !== null && typeof value === 'object';\n}\n"],"names":["structurallyEqual","left","right","Object","is","Array","isArray","length","every","value","index","isRecord","leftKeys","keys","sort","rightKeys","key"],"mappings":";;AAAA;AACA;AAEA;;;;;;;AAOC,IACM,SAASA,iBAAAA,CAAkBC,IAAa,EAAEC,KAAc,EAAA;AAC3D,IAAA,IAAIC,MAAAA,CAAOC,EAAE,CAACH,IAAAA,EAAMC,QAAQ,OAAO,IAAA;AACnC,IAAA,IAAIG,MAAMC,OAAO,CAACL,SAASI,KAAAA,CAAMC,OAAO,CAACJ,KAAAA,CAAAA,EAAQ;QAC7C,OAAOG,KAAAA,CAAMC,OAAO,CAACL,IAAAA,CAAAA,IAASI,KAAAA,CAAMC,OAAO,CAACJ,KAAAA,CAAAA,IACrCD,IAAAA,CAAKM,MAAM,KAAKL,KAAAA,CAAMK,MAAM,IAC5BN,IAAAA,CAAKO,KAAK,CAAC,CAACC,KAAAA,EAAOC,QAAUV,iBAAAA,CAAkBS,KAAAA,EAAOP,KAAK,CAACQ,KAAAA,CAAM,CAAA,CAAA;AAC7E,IAAA;AAEA,IAAA,IAAI,CAACC,QAAAA,CAASV,IAAAA,CAAAA,IAAS,CAACU,QAAAA,CAAST,QAAQ,OAAO,KAAA;AAChD,IAAA,MAAMU,QAAAA,GAAWT,MAAAA,CAAOU,IAAI,CAACZ,MAAMa,IAAI,EAAA;AACvC,IAAA,MAAMC,SAAAA,GAAYZ,MAAAA,CAAOU,IAAI,CAACX,OAAOY,IAAI,EAAA;IACzC,OAAOF,QAAAA,CAASL,MAAM,KAAKQ,SAAAA,CAAUR,MAAM,IACpCK,QAAAA,CAASJ,KAAK,CAAC,CAACQ,GAAAA,EAAKN,KAAAA,GAAUM,QAAQD,SAAS,CAACL,KAAAA,CAAM,IAAIV,iBAAAA,CAAkBC,IAAI,CAACe,GAAAA,CAAI,EAAEd,KAAK,CAACc,GAAAA,CAAI,CAAA,CAAA;AAC7G;AAEA,SAASL,SAASF,KAAc,EAAA;IAC5B,OAAOA,KAAAA,KAAU,IAAA,IAAQ,OAAOA,KAAAA,KAAU,QAAA;AAC9C;;"}

package/dist/cjs/treeNodes.js

@@ -13,35 +13,69 @@ var properties = require('./properties.js');
  * expands the wrong rows the moment two siblings share a label. Deriving the key from the path makes it
  * unique and stable across re-renders without asking the author for anything.
  *
+ * An authored key may be a string or a number (a numeric id is a natural key); it is kept as a string. Keys
+ * are unique across the whole tree: a node whose authored key was already taken by an earlier node falls back
+ * to its path key, so two nodes can never share expansion or selection.
+ *
+ * An entry that is a string, number or boolean is a leaf labeled with it. Anything else that is not a record
+ * (`null`, a nested array) cannot be a node and is skipped; see {@link countUnreadableEntries}.
+ *
  * @param entries The raw entries to convert.
  * @param parentKey The key of the node these entries belong to, used to build stable child keys.
+ * @param usedKeys The keys already given out in this tree, shared down the recursion.
  * @returns The converted nodes, in order.
- */ function toTreeNodes(entries, parentKey = '') {
+ */ function toTreeNodes(entries, parentKey = '', usedKeys = new Set()) {
     const nodes = [];
     entries.forEach((entry, index)=>{
         const path = parentKey === '' ? `${index}` : `${parentKey}-${index}`;
-        if (typeof entry === 'string') {
+        if (typeof entry === 'string' || typeof entry === 'number' || typeof entry === 'boolean') {
             nodes.push({
-                key: path,
-                label: entry
+                key: uniqueKey(undefined, path, usedKeys),
+                label: String(entry)
             });
             return;
         }
         if (typeof entry !== 'object' || entry === undefined || entry === null || Array.isArray(entry)) return;
         const record = entry;
         const node = {
-            key: typeof record.key === 'string' ? record.key : path
+            key: uniqueKey(authoredKey(record.key), path, usedKeys)
         };
         if (typeof record.label === 'string') node.label = record.label;
         if (typeof record.icon === 'string') node.icon = record.icon;
         if (typeof record.className === 'string') node.className = record.className;
         if (typeof record.leaf === 'boolean') node.leaf = record.leaf;
-        if (typeof record.data === 'object' && record.data !== null) node.data = record.data;
-        if (Array.isArray(record.children)) node.children = toTreeNodes(record.children, node.key);
+        if (typeof record.expanded === 'boolean') node.expanded = record.expanded;
+        if (typeof record.selectable === 'boolean') node.selectable = record.selectable;
+        if (record.data !== undefined && record.data !== null) node.data = record.data;
+        if (Array.isArray(record.children)) node.children = toTreeNodes(record.children, node.key, usedKeys);
         nodes.push(node);
     });
     return nodes;
 }
+/**
+ * Counts the entries `toTreeNodes` skips, so a control can say that some of its data was not shown instead
+ * of silently showing less.
+ *
+ * @param entries The raw entries.
+ * @returns How many entries, at any depth, were neither a scalar nor a record.
+ */ function countUnreadableEntries(entries) {
+    return entries.reduce((count, entry)=>{
+        if (typeof entry === 'string' || typeof entry === 'number' || typeof entry === 'boolean') return count;
+        if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) return count + 1;
+        const children = entry.children;
+        return count + (Array.isArray(children) ? countUnreadableEntries(children) : 0);
+    }, 0);
+}
+function authoredKey(value) {
+    if (typeof value === 'string' && value !== '') return value;
+    return typeof value === 'number' && Number.isFinite(value) ? String(value) : undefined;
+}
+function uniqueKey(authored, path, usedKeys) {
+    let key = authored !== undefined && !usedKeys.has(authored) ? authored : path;
+    while(usedKeys.has(key))key = `${key}~`;
+    usedKeys.add(key);
+    return key;
+}
 /**
  * Reads a tree model off a Scene element's properties.
  *
@@ -52,6 +86,7 @@ var properties = require('./properties.js');
     return toTreeNodes(properties.arrayProperty(element, name));
 }
 
+exports.countUnreadableEntries = countUnreadableEntries;
 exports.toTreeNodes = toTreeNodes;
 exports.treeNodesProperty = treeNodesProperty;
 //# sourceMappingURL=treeNodes.js.map

package/dist/cjs/treeNodes.js.map

@@ -1 +1 @@
-{"version":3,"file":"treeNodes.js","sources":["../../treeNodes.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 { SceneElement } from '@cratis/scene.model';\nimport { arrayProperty } from './properties';\n\n/**\n * Turns raw authored entries into the `TreeNode` model PrimeReact's tree, tree table, tree select and\n * organization chart all share.\n *\n * A `key` is synthesized from the node's path when an author did not supply one. That is not cosmetic:\n * PrimeReact keys expansion, selection and virtual scrolling off `key`, so a tree of unkeyed nodes\n * expands the wrong rows the moment two siblings share a label. Deriving the key from the path makes it\n * unique and stable across re-renders without asking the author for anything.\n *\n * @param entries The raw entries to convert.\n * @param parentKey The key of the node these entries belong to, used to build stable child keys.\n * @returns The converted nodes, in order.\n */\nexport function toTreeNodes(entries: unknown[], parentKey = ''): TreeNode[] {\n    const nodes: TreeNode[] = [];\n    entries.forEach((entry, index) => {\n        const path = parentKey === '' ? `${index}` : `${parentKey}-${index}`;\n        if (typeof entry === 'string') {\n            nodes.push({ key: path, label: entry });\n            return;\n        }\n\n        if (typeof entry !== 'object' || entry === undefined || entry === null || Array.isArray(entry)) return;\n\n        const record = entry as Record<string, unknown>;\n        const node: TreeNode = { key: typeof record.key === 'string' ? record.key : path };\n        if (typeof record.label === 'string') node.label = record.label;\n        if (typeof record.icon === 'string') node.icon = record.icon;\n        if (typeof record.className === 'string') node.className = record.className;\n        if (typeof record.leaf === 'boolean') node.leaf = record.leaf;\n        if (typeof record.data === 'object' && record.data !== null) node.data = record.data;\n        if (Array.isArray(record.children)) node.children = toTreeNodes(record.children, node.key as string);\n        nodes.push(node);\n    });\n\n    return nodes;\n}\n\n/**\n * Reads a tree model off a Scene element's properties.\n *\n * @param element The element whose properties to read.\n * @param name The property name holding the entries.\n * @returns The converted nodes, empty when the property is missing or is not an array.\n */\nexport function treeNodesProperty(element: SceneElement, name: string): TreeNode[] {\n    return toTreeNodes(arrayProperty(element, name));\n}\n"],"names":["toTreeNodes","entries","parentKey","nodes","forEach","entry","index","path","push","key","label","undefined","Array","isArray","record","node","icon","className","leaf","data","children","treeNodesProperty","element","name","arrayProperty"],"mappings":";;;;AAAA;AACA;AAMA;;;;;;;;;;;;AAYC,IACM,SAASA,WAAAA,CAAYC,OAAkB,EAAEC,YAAY,EAAE,EAAA;AAC1D,IAAA,MAAMC,QAAoB,EAAE;IAC5BF,OAAAA,CAAQG,OAAO,CAAC,CAACC,KAAAA,EAAOC,KAAAA,GAAAA;QACpB,MAAMC,IAAAA,GAAOL,SAAAA,KAAc,EAAA,GAAK,CAAA,EAAGI,KAAAA,CAAAA,CAAO,GAAG,CAAA,EAAGJ,SAAAA,CAAU,CAAC,EAAEI,KAAAA,CAAAA,CAAO;QACpE,IAAI,OAAOD,UAAU,QAAA,EAAU;AAC3BF,YAAAA,KAAAA,CAAMK,IAAI,CAAC;gBAAEC,GAAAA,EAAKF,IAAAA;gBAAMG,KAAAA,EAAOL;AAAM,aAAA,CAAA;AACrC,YAAA;AACJ,QAAA;QAEA,IAAI,OAAOA,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAUM,SAAAA,IAAaN,UAAU,IAAA,IAAQO,KAAAA,CAAMC,OAAO,CAACR,KAAAA,CAAAA,EAAQ;AAEhG,QAAA,MAAMS,MAAAA,GAAST,KAAAA;AACf,QAAA,MAAMU,IAAAA,GAAiB;AAAEN,YAAAA,GAAAA,EAAK,OAAOK,MAAAA,CAAOL,GAAG,KAAK,QAAA,GAAWK,MAAAA,CAAOL,GAAG,GAAGF;AAAK,SAAA;QACjF,IAAI,OAAOO,OAAOJ,KAAK,KAAK,UAAUK,IAAAA,CAAKL,KAAK,GAAGI,MAAAA,CAAOJ,KAAK;QAC/D,IAAI,OAAOI,OAAOE,IAAI,KAAK,UAAUD,IAAAA,CAAKC,IAAI,GAAGF,MAAAA,CAAOE,IAAI;QAC5D,IAAI,OAAOF,OAAOG,SAAS,KAAK,UAAUF,IAAAA,CAAKE,SAAS,GAAGH,MAAAA,CAAOG,SAAS;QAC3E,IAAI,OAAOH,OAAOI,IAAI,KAAK,WAAWH,IAAAA,CAAKG,IAAI,GAAGJ,MAAAA,CAAOI,IAAI;AAC7D,QAAA,IAAI,OAAOJ,MAAAA,CAAOK,IAAI,KAAK,QAAA,IAAYL,MAAAA,CAAOK,IAAI,KAAK,IAAA,EAAMJ,IAAAA,CAAKI,IAAI,GAAGL,OAAOK,IAAI;AACpF,QAAA,IAAIP,KAAAA,CAAMC,OAAO,CAACC,MAAAA,CAAOM,QAAQ,CAAA,EAAGL,IAAAA,CAAKK,QAAQ,GAAGpB,WAAAA,CAAYc,MAAAA,CAAOM,QAAQ,EAAEL,KAAKN,GAAG,CAAA;AACzFN,QAAAA,KAAAA,CAAMK,IAAI,CAACO,IAAAA,CAAAA;AACf,IAAA,CAAA,CAAA;IAEA,OAAOZ,KAAAA;AACX;AAEA;;;;;;AAMC,IACM,SAASkB,iBAAAA,CAAkBC,OAAqB,EAAEC,IAAY,EAAA;IACjE,OAAOvB,WAAAA,CAAYwB,yBAAcF,OAAAA,EAASC,IAAAA,CAAAA,CAAAA;AAC9C;;;"}
+{"version":3,"file":"treeNodes.js","sources":["../../treeNodes.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 { SceneElement } from '@cratis/scene.model';\nimport { arrayProperty } from './properties';\n\n/**\n * Turns raw authored entries into the `TreeNode` model PrimeReact's tree, tree table, tree select and\n * organization chart all share.\n *\n * A `key` is synthesized from the node's path when an author did not supply one. That is not cosmetic:\n * PrimeReact keys expansion, selection and virtual scrolling off `key`, so a tree of unkeyed nodes\n * expands the wrong rows the moment two siblings share a label. Deriving the key from the path makes it\n * unique and stable across re-renders without asking the author for anything.\n *\n * An authored key may be a string or a number (a numeric id is a natural key); it is kept as a string. Keys\n * are unique across the whole tree: a node whose authored key was already taken by an earlier node falls back\n * to its path key, so two nodes can never share expansion or selection.\n *\n * An entry that is a string, number or boolean is a leaf labeled with it. Anything else that is not a record\n * (`null`, a nested array) cannot be a node and is skipped; see {@link countUnreadableEntries}.\n *\n * @param entries The raw entries to convert.\n * @param parentKey The key of the node these entries belong to, used to build stable child keys.\n * @param usedKeys The keys already given out in this tree, shared down the recursion.\n * @returns The converted nodes, in order.\n */\nexport function toTreeNodes(entries: unknown[], parentKey = '', usedKeys: Set<string> = new Set()): TreeNode[] {\n    const nodes: TreeNode[] = [];\n    entries.forEach((entry, index) => {\n        const path = parentKey === '' ? `${index}` : `${parentKey}-${index}`;\n        if (typeof entry === 'string' || typeof entry === 'number' || typeof entry === 'boolean') {\n            nodes.push({ key: uniqueKey(undefined, path, usedKeys), label: String(entry) });\n            return;\n        }\n\n        if (typeof entry !== 'object' || entry === undefined || entry === null || Array.isArray(entry)) return;\n\n        const record = entry as Record<string, unknown>;\n        const node: TreeNode = { key: uniqueKey(authoredKey(record.key), path, usedKeys) };\n        if (typeof record.label === 'string') node.label = record.label;\n        if (typeof record.icon === 'string') node.icon = record.icon;\n        if (typeof record.className === 'string') node.className = record.className;\n        if (typeof record.leaf === 'boolean') node.leaf = record.leaf;\n        if (typeof record.expanded === 'boolean') node.expanded = record.expanded;\n        if (typeof record.selectable === 'boolean') node.selectable = record.selectable;\n        if (record.data !== undefined && record.data !== null) node.data = record.data;\n        if (Array.isArray(record.children)) node.children = toTreeNodes(record.children, node.key as string, usedKeys);\n        nodes.push(node);\n    });\n\n    return nodes;\n}\n\n/**\n * Counts the entries `toTreeNodes` skips, so a control can say that some of its data was not shown instead\n * of silently showing less.\n *\n * @param entries The raw entries.\n * @returns How many entries, at any depth, were neither a scalar nor a record.\n */\nexport function countUnreadableEntries(entries: unknown[]): number {\n    return entries.reduce<number>((count, entry) => {\n        if (typeof entry === 'string' || typeof entry === 'number' || typeof entry === 'boolean') return count;\n        if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) return count + 1;\n        const children = (entry as { children?: unknown }).children;\n        return count + (Array.isArray(children) ? countUnreadableEntries(children) : 0);\n    }, 0);\n}\n\nfunction authoredKey(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 uniqueKey(authored: string | undefined, path: string, usedKeys: Set<string>): string {\n    let key = authored !== undefined && !usedKeys.has(authored) ? authored : path;\n    while (usedKeys.has(key)) key = `${key}~`;\n    usedKeys.add(key);\n    return key;\n}\n\n/**\n * Reads a tree model off a Scene element's properties.\n *\n * @param element The element whose properties to read.\n * @param name The property name holding the entries.\n * @returns The converted nodes, empty when the property is missing or is not an array.\n */\nexport function treeNodesProperty(element: SceneElement, name: string): TreeNode[] {\n    return toTreeNodes(arrayProperty(element, name));\n}\n"],"names":["toTreeNodes","entries","parentKey","usedKeys","Set","nodes","forEach","entry","index","path","push","key","uniqueKey","undefined","label","String","Array","isArray","record","node","authoredKey","icon","className","leaf","expanded","selectable","data","children","countUnreadableEntries","reduce","count","value","Number","isFinite","authored","has","add","treeNodesProperty","element","name","arrayProperty"],"mappings":";;;;AAAA;AACA;AAMA;;;;;;;;;;;;;;;;;;;;IAqBO,SAASA,WAAAA,CAAYC,OAAkB,EAAEC,YAAY,EAAE,EAAEC,QAAAA,GAAwB,IAAIC,GAAAA,EAAK,EAAA;AAC7F,IAAA,MAAMC,QAAoB,EAAE;IAC5BJ,OAAAA,CAAQK,OAAO,CAAC,CAACC,KAAAA,EAAOC,KAAAA,GAAAA;QACpB,MAAMC,IAAAA,GAAOP,SAAAA,KAAc,EAAA,GAAK,CAAA,EAAGM,KAAAA,CAAAA,CAAO,GAAG,CAAA,EAAGN,SAAAA,CAAU,CAAC,EAAEM,KAAAA,CAAAA,CAAO;QACpE,IAAI,OAAOD,UAAU,QAAA,IAAY,OAAOA,UAAU,QAAA,IAAY,OAAOA,UAAU,SAAA,EAAW;AACtFF,YAAAA,KAAAA,CAAMK,IAAI,CAAC;gBAAEC,GAAAA,EAAKC,SAAAA,CAAUC,WAAWJ,IAAAA,EAAMN,QAAAA,CAAAA;AAAWW,gBAAAA,KAAAA,EAAOC,MAAAA,CAAOR,KAAAA;AAAO,aAAA,CAAA;AAC7E,YAAA;AACJ,QAAA;QAEA,IAAI,OAAOA,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAUM,SAAAA,IAAaN,UAAU,IAAA,IAAQS,KAAAA,CAAMC,OAAO,CAACV,KAAAA,CAAAA,EAAQ;AAEhG,QAAA,MAAMW,MAAAA,GAASX,KAAAA;AACf,QAAA,MAAMY,IAAAA,GAAiB;AAAER,YAAAA,GAAAA,EAAKC,SAAAA,CAAUQ,WAAAA,CAAYF,MAAAA,CAAOP,GAAG,GAAGF,IAAAA,EAAMN,QAAAA;AAAU,SAAA;QACjF,IAAI,OAAOe,OAAOJ,KAAK,KAAK,UAAUK,IAAAA,CAAKL,KAAK,GAAGI,MAAAA,CAAOJ,KAAK;QAC/D,IAAI,OAAOI,OAAOG,IAAI,KAAK,UAAUF,IAAAA,CAAKE,IAAI,GAAGH,MAAAA,CAAOG,IAAI;QAC5D,IAAI,OAAOH,OAAOI,SAAS,KAAK,UAAUH,IAAAA,CAAKG,SAAS,GAAGJ,MAAAA,CAAOI,SAAS;QAC3E,IAAI,OAAOJ,OAAOK,IAAI,KAAK,WAAWJ,IAAAA,CAAKI,IAAI,GAAGL,MAAAA,CAAOK,IAAI;QAC7D,IAAI,OAAOL,OAAOM,QAAQ,KAAK,WAAWL,IAAAA,CAAKK,QAAQ,GAAGN,MAAAA,CAAOM,QAAQ;QACzE,IAAI,OAAON,OAAOO,UAAU,KAAK,WAAWN,IAAAA,CAAKM,UAAU,GAAGP,MAAAA,CAAOO,UAAU;AAC/E,QAAA,IAAIP,MAAAA,CAAOQ,IAAI,KAAKb,SAAAA,IAAaK,MAAAA,CAAOQ,IAAI,KAAK,IAAA,EAAMP,IAAAA,CAAKO,IAAI,GAAGR,MAAAA,CAAOQ,IAAI;AAC9E,QAAA,IAAIV,KAAAA,CAAMC,OAAO,CAACC,MAAAA,CAAOS,QAAQ,CAAA,EAAGR,IAAAA,CAAKQ,QAAQ,GAAG3B,YAAYkB,MAAAA,CAAOS,QAAQ,EAAER,IAAAA,CAAKR,GAAG,EAAYR,QAAAA,CAAAA;AACrGE,QAAAA,KAAAA,CAAMK,IAAI,CAACS,IAAAA,CAAAA;AACf,IAAA,CAAA,CAAA;IAEA,OAAOd,KAAAA;AACX;AAEA;;;;;;IAOO,SAASuB,sBAAAA,CAAuB3B,OAAkB,EAAA;AACrD,IAAA,OAAOA,OAAAA,CAAQ4B,MAAM,CAAS,CAACC,KAAAA,EAAOvB,KAAAA,GAAAA;QAClC,IAAI,OAAOA,UAAU,QAAA,IAAY,OAAOA,UAAU,QAAA,IAAY,OAAOA,KAAAA,KAAU,SAAA,EAAW,OAAOuB,KAAAA;QACjG,IAAI,OAAOvB,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAU,IAAA,IAAQS,MAAMC,OAAO,CAACV,KAAAA,CAAAA,EAAQ,OAAOuB,KAAAA,GAAQ,CAAA;QACxF,MAAMH,QAAAA,GAAW,KAACpB,CAAiCoB,QAAQ;QAC3D,OAAOG,KAAAA,IAASd,KAAAA,CAAMC,OAAO,CAACU,QAAAA,CAAAA,GAAYC,sBAAAA,CAAuBD,YAAY,CAAA,CAAA;IACjF,CAAA,EAAG,CAAA,CAAA;AACP;AAEA,SAASP,YAAYW,KAAc,EAAA;AAC/B,IAAA,IAAI,OAAOA,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAU,IAAI,OAAOA,KAAAA;IACtD,OAAO,OAAOA,UAAU,QAAA,IAAYC,MAAAA,CAAOC,QAAQ,CAACF,KAAAA,CAAAA,GAAShB,OAAOgB,KAAAA,CAAAA,GAASlB,SAAAA;AACjF;AAEA,SAASD,SAAAA,CAAUsB,QAA4B,EAAEzB,IAAY,EAAEN,QAAqB,EAAA;IAChF,IAAIQ,GAAAA,GAAMuB,aAAarB,SAAAA,IAAa,CAACV,SAASgC,GAAG,CAACD,YAAYA,QAAAA,GAAWzB,IAAAA;IACzE,MAAON,QAAAA,CAASgC,GAAG,CAACxB,GAAAA,CAAAA,CAAMA,MAAM,CAAA,EAAGA,GAAAA,CAAI,CAAC,CAAC;AACzCR,IAAAA,QAAAA,CAASiC,GAAG,CAACzB,GAAAA,CAAAA;IACb,OAAOA,GAAAA;AACX;AAEA;;;;;;AAMC,IACM,SAAS0B,iBAAAA,CAAkBC,OAAqB,EAAEC,IAAY,EAAA;IACjE,OAAOvC,WAAAA,CAAYwC,yBAAcF,OAAAA,EAASC,IAAAA,CAAAA,CAAAA;AAC9C;;;;"}

package/dist/cjs/useResettingState.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var react = require('react');
+var useStructuralValue = require('./useStructuralValue.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * State that starts from authored data and starts over when that data really changes.
+ *
+ * A control's selection or expansion is runtime state the user changes, yet it is also authored on the
+ * element. Reading the authored value once (`useState(() => authored)`) ignores a later edit of the document;
+ * resetting on every render discards what the user did. This does neither: the state follows `source` when
+ * its content changes, compared structurally because every document edit clones the data, and is otherwise
+ * left alone - so an unrelated property edit does not undo the user's choice.
+ *
+ * @param source The authored data the state derives from.
+ * @param initial Derives the starting state from the authored data.
+ * @returns The state and its setter, like `useState`.
+ */ function useResettingState(source, initial) {
+    const stable = useStructuralValue.useStructuralValue(source);
+    const [held, setHeld] = react.useState(()=>({
+            source: stable,
+            value: initial()
+        }));
+    let current = held;
+    if (held.source !== stable) {
+        current = {
+            source: stable,
+            value: initial()
+        };
+        setHeld(current);
+    }
+    const update = react.useCallback((action)=>{
+        setHeld((previous)=>({
+                source: previous.source,
+                value: typeof action === 'function' ? action(previous.value) : action
+            }));
+    }, []);
+    return [
+        current.value,
+        update
+    ];
+}
+
+exports.useResettingState = useResettingState;
+//# sourceMappingURL=useResettingState.js.map

package/dist/cjs/useResettingState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResettingState.js","sources":["../../useResettingState.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 { Dispatch, SetStateAction, useCallback, useState } from 'react';\nimport { useStructuralValue } from './useStructuralValue';\n\n/**\n * State that starts from authored data and starts over when that data really changes.\n *\n * A control's selection or expansion is runtime state the user changes, yet it is also authored on the\n * element. Reading the authored value once (`useState(() => authored)`) ignores a later edit of the document;\n * resetting on every render discards what the user did. This does neither: the state follows `source` when\n * its content changes, compared structurally because every document edit clones the data, and is otherwise\n * left alone - so an unrelated property edit does not undo the user's choice.\n *\n * @param source The authored data the state derives from.\n * @param initial Derives the starting state from the authored data.\n * @returns The state and its setter, like `useState`.\n */\nexport function useResettingState<TState>(source: unknown, initial: () => TState): [TState, Dispatch<SetStateAction<TState>>] {\n    const stable = useStructuralValue(source);\n    const [held, setHeld] = useState(() => ({ source: stable, value: initial() }));\n    let current = held;\n    if (held.source !== stable) {\n        current = { source: stable, value: initial() };\n        setHeld(current);\n    }\n\n    const update = useCallback((action: SetStateAction<TState>) => {\n        setHeld(previous => ({ source: previous.source, value: typeof action === 'function' ? (action as (state: TState) => TState)(previous.value) : action }));\n    }, []);\n\n    return [current.value, update];\n}\n"],"names":["useResettingState","source","initial","stable","useStructuralValue","held","setHeld","useState","value","current","update","useCallback","action","previous"],"mappings":";;;;;AAAA;AACA;AAKA;;;;;;;;;;;;AAYC,IACM,SAASA,iBAAAA,CAA0BC,MAAe,EAAEC,OAAqB,EAAA;AAC5E,IAAA,MAAMC,SAASC,qCAAAA,CAAmBH,MAAAA,CAAAA;AAClC,IAAA,MAAM,CAACI,IAAAA,EAAMC,OAAAA,CAAQ,GAAGC,cAAAA,CAAS,KAAO;YAAEN,MAAAA,EAAQE,MAAAA;YAAQK,KAAAA,EAAON,OAAAA;SAAU,CAAA,CAAA;AAC3E,IAAA,IAAIO,OAAAA,GAAUJ,IAAAA;IACd,IAAIA,IAAAA,CAAKJ,MAAM,KAAKE,MAAAA,EAAQ;QACxBM,OAAAA,GAAU;YAAER,MAAAA,EAAQE,MAAAA;YAAQK,KAAAA,EAAON,OAAAA;AAAU,SAAA;QAC7CI,OAAAA,CAAQG,OAAAA,CAAAA;AACZ,IAAA;IAEA,MAAMC,MAAAA,GAASC,kBAAY,CAACC,MAAAA,GAAAA;QACxBN,OAAAA,CAAQO,CAAAA,YAAa;AAAEZ,gBAAAA,MAAAA,EAAQY,SAASZ,MAAM;AAAEO,gBAAAA,KAAAA,EAAO,OAAOI,MAAAA,KAAW,UAAA,GAAa,MAACA,CAAqCC,QAAAA,CAASL,KAAK,CAAA,GAAII;aAAO,CAAA,CAAA;AACzJ,IAAA,CAAA,EAAG,EAAE,CAAA;IAEL,OAAO;AAACH,QAAAA,OAAAA,CAAQD,KAAK;AAAEE,QAAAA;AAAO,KAAA;AAClC;;"}

package/dist/cjs/useStructuralValue.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var react = require('react');
+var structurallyEqual = require('./structurallyEqual.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Returns the same reference for as long as the content of `value` is unchanged.
+ *
+ * Use it for authored data that feeds an effect dependency list: a cloned document gives that data a new
+ * identity on every unrelated edit, which would otherwise rerun the effect and rebuild whatever it owns.
+ */ function useStructuralValue(value) {
+    const stable = react.useRef(value);
+    if (!structurallyEqual.structurallyEqual(stable.current, value)) stable.current = value;
+    return stable.current;
+}
+
+exports.useStructuralValue = useStructuralValue;
+//# sourceMappingURL=useStructuralValue.js.map

package/dist/cjs/useStructuralValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStructuralValue.js","sources":["../../useStructuralValue.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 { useRef } from 'react';\nimport { structurallyEqual } from './structurallyEqual';\n\n/**\n * Returns the same reference for as long as the content of `value` is unchanged.\n *\n * Use it for authored data that feeds an effect dependency list: a cloned document gives that data a new\n * identity on every unrelated edit, which would otherwise rerun the effect and rebuild whatever it owns.\n */\nexport function useStructuralValue<TValue>(value: TValue): TValue {\n    const stable = useRef(value);\n    if (!structurallyEqual(stable.current, value)) stable.current = value;\n    return stable.current;\n}\n"],"names":["useStructuralValue","value","stable","useRef","structurallyEqual","current"],"mappings":";;;;;AAAA;AACA;AAKA;;;;;IAMO,SAASA,kBAAAA,CAA2BC,KAAa,EAAA;AACpD,IAAA,MAAMC,SAASC,YAAAA,CAAOF,KAAAA,CAAAA;IACtB,IAAI,CAACG,oCAAkBF,MAAAA,CAAOG,OAAO,EAAEJ,KAAAA,CAAAA,EAAQC,MAAAA,CAAOG,OAAO,GAAGJ,KAAAA;AAChE,IAAA,OAAOC,OAAOG,OAAO;AACzB;;"}

package/dist/esm/EnumerationResolution.d.ts

@@ -0,0 +1,9 @@
+export type EnumerationResolution<TMember extends string> = {
+    isValid: true;
+    value: TMember;
+} | {
+    isValid: false;
+    value: unknown;
+    message: string;
+};
+//# sourceMappingURL=EnumerationResolution.d.ts.map

package/dist/esm/EnumerationResolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnumerationResolution.d.ts","sourceRoot":"","sources":["../../EnumerationResolution.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,qBAAqB,CAAC,OAAO,SAAS,MAAM,IAClD;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACjC;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/esm/EnumerationResolution.js

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

package/dist/esm/EnumerationResolution.js.map

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

package/dist/esm/chart/ChartGallery.stories.d.ts

@@ -0,0 +1,14 @@
+import type { StoryObj } from '@storybook/react';
+import { SceneElementView } from '@cratis/scene.react';
+declare const meta: {
+    title: string;
+    component: typeof SceneElementView;
+    tags: string[];
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Bar: Story;
+export declare const MigratedWithoutData: Story;
+export declare const UnsupportedType: Story;
+export declare const MigratedLegacyBar: Story;
+//# sourceMappingURL=ChartGallery.stories.d.ts.map

package/dist/esm/chart/ChartGallery.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChartGallery.stories.d.ts","sourceRoot":"","sources":["../../../chart/ChartGallery.stories.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAIvD,QAAA,MAAM,IAAI;;;;CAI+B,CAAC;eAE3B,IAAI;AAEnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAC;AAQnC,eAAO,MAAM,GAAG,EAAE,KAQjB,CAAC;AAGF,eAAO,MAAM,mBAAmB,EAAE,KAMjC,CAAC;AAGF,eAAO,MAAM,eAAe,EAAE,KAM7B,CAAC;AAGF,eAAO,MAAM,iBAAiB,EAAE,KAS/B,CAAC"}

package/dist/esm/chart/ChartGallery.stories.js

@@ -0,0 +1,47 @@
+import { SceneElementView } from '@cratis/scene.react';
+import { primeReactComponents } from '../primeReactComponents';
+import { sceneComponent } from '../storyElements';
+const meta = {
+    title: 'PrimeReact/Chart',
+    component: SceneElementView,
+    tags: ['autodocs'],
+};
+export default meta;
+const salesData = {
+    labels: ['January', 'February', 'March'],
+    datasets: [{ label: 'Sales', data: [12, 19, 8], backgroundColor: '#6366f1' }],
+};
+export const Bar = {
+    args: {
+        element: sceneComponent('sales', 'chart', {
+            type: 'bar', data: salesData, options: { maintainAspectRatio: false }, style: { height: 240 }, ariaLabel: 'Monthly sales',
+        }),
+        registry: primeReactComponents,
+        resolveBinding: () => undefined,
+    },
+};
+export const MigratedWithoutData = {
+    args: {
+        element: sceneComponent('legacy-empty', 'chart', { type: 0, style: { height: 72 }, ariaLabel: 'Migrated chart without data', legacyType: 'PrimeReact.Chart' }),
+        registry: primeReactComponents,
+        resolveBinding: () => undefined,
+    },
+};
+export const UnsupportedType = {
+    args: {
+        element: sceneComponent('unsupported', 'chart', { type: 8, data: salesData }),
+        registry: primeReactComponents,
+        resolveBinding: () => undefined,
+    },
+};
+export const MigratedLegacyBar = {
+    args: {
+        element: sceneComponent('legacy-sales', 'chart', {
+            type: 0, data: salesData, options: { maintainAspectRatio: false }, style: { height: 240 }, ariaLabel: 'Migrated monthly sales',
+            legacyType: 'PrimeReact.Chart', legacyExtras: { canvas: { x: 256, y: 184 } },
+        }),
+        registry: primeReactComponents,
+        resolveBinding: () => undefined,
+    },
+};
+//# sourceMappingURL=ChartGallery.stories.js.map

package/dist/esm/chart/ChartGallery.stories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChartGallery.stories.js","sourceRoot":"","sources":["../../../chart/ChartGallery.stories.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,MAAM,IAAI,GAAG;IACT,KAAK,EAAE,kBAAkB;IACzB,SAAS,EAAE,gBAAgB;IAC3B,IAAI,EAAE,CAAC,UAAU,CAAC;CACmB,CAAC;AAE1C,eAAe,IAAI,CAAC;AAKpB,MAAM,SAAS,GAAG;IACd,MAAM,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,CAAC;IACxC,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC;CAChF,CAAC;AAEF,MAAM,CAAC,MAAM,GAAG,GAAU;IACtB,IAAI,EAAE;QACF,OAAO,EAAE,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE;YACtC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,eAAe;SAC5H,CAAC;QACF,QAAQ,EAAE,oBAAoB;QAC9B,cAAc,EAAE,GAAG,EAAE,CAAC,SAAS;KAClC;CACJ,CAAC;AAGF,MAAM,CAAC,MAAM,mBAAmB,GAAU;IACtC,IAAI,EAAE;QACF,OAAO,EAAE,cAAc,CAAC,cAAc,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,6BAA6B,EAAE,UAAU,EAAE,kBAAkB,EAAE,CAAC;QAC9J,QAAQ,EAAE,oBAAoB;QAC9B,cAAc,EAAE,GAAG,EAAE,CAAC,SAAS;KAClC;CACJ,CAAC;AAGF,MAAM,CAAC,MAAM,eAAe,GAAU;IAClC,IAAI,EAAE;QACF,OAAO,EAAE,cAAc,CAAC,aAAa,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;QAC7E,QAAQ,EAAE,oBAAoB;QAC9B,cAAc,EAAE,GAAG,EAAE,CAAC,SAAS;KAClC;CACJ,CAAC;AAGF,MAAM,CAAC,MAAM,iBAAiB,GAAU;IACpC,IAAI,EAAE;QACF,OAAO,EAAE,cAAc,CAAC,cAAc,EAAE,OAAO,EAAE;YAC7C,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,wBAAwB;YAC9H,UAAU,EAAE,kBAAkB,EAAE,YAAY,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE;SAC/E,CAAC;QACF,QAAQ,EAAE,oBAAoB;QAC9B,cAAc,EAAE,GAAG,EAAE,CAAC,SAAS;KAClC;CACJ,CAAC"}

package/dist/esm/chart/ChartType.d.ts

@@ -0,0 +1,11 @@
+export declare enum ChartType {
+    Bar = "bar",
+    Line = "line",
+    Pie = "pie",
+    Doughnut = "doughnut",
+    PolarArea = "polarArea",
+    Radar = "radar",
+    Bubble = "bubble",
+    Scatter = "scatter"
+}
+//# sourceMappingURL=ChartType.d.ts.map

package/dist/esm/chart/ChartType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChartType.d.ts","sourceRoot":"","sources":["../../../chart/ChartType.ts"],"names":[],"mappings":"AAIA,oBAAY,SAAS;IACjB,GAAG,QAAQ;IACX,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,QAAQ,aAAa;IACrB,SAAS,cAAc;IACvB,KAAK,UAAU;IACf,MAAM,WAAW;IACjB,OAAO,YAAY;CACtB"}

package/dist/esm/chart/ChartType.js

@@ -0,0 +1,16 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/** The canonical names of the Chart.js chart types Scene's `chart` component supports. */ var ChartType = /*#__PURE__*/ function(ChartType) {
+    ChartType["Bar"] = "bar";
+    ChartType["Line"] = "line";
+    ChartType["Pie"] = "pie";
+    ChartType["Doughnut"] = "doughnut";
+    ChartType["PolarArea"] = "polarArea";
+    ChartType["Radar"] = "radar";
+    ChartType["Bubble"] = "bubble";
+    ChartType["Scatter"] = "scatter";
+    return ChartType;
+}({});
+
+export { ChartType };
+//# sourceMappingURL=ChartType.js.map

package/dist/esm/chart/ChartType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChartType.js","sources":["../../../chart/ChartType.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 canonical names of the Chart.js chart types Scene's `chart` component supports. */\nexport enum ChartType {\n    Bar = 'bar',\n    Line = 'line',\n    Pie = 'pie',\n    Doughnut = 'doughnut',\n    PolarArea = 'polarArea',\n    Radar = 'radar',\n    Bubble = 'bubble',\n    Scatter = 'scatter',\n}\n"],"names":["ChartType"],"mappings":"AAAA;AACA;AAEA,2FACO,IAAKA,SAAAA,iBAAAA,SAAAA,SAAAA,EAAAA;;;;;;;;;AAAAA,IAAAA,OAAAA,SAAAA;AASX,CAAA,CAAA,EAAA;;"}

package/dist/esm/chart/ChartTypeResolution.d.ts

@@ -0,0 +1,10 @@
+import { ChartType } from './ChartType';
+export type ChartTypeResolution = {
+    isValid: true;
+    type: ChartType;
+} | {
+    isValid: false;
+    value: unknown;
+    message: string;
+};
+//# sourceMappingURL=ChartTypeResolution.d.ts.map

package/dist/esm/chart/ChartTypeResolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChartTypeResolution.d.ts","sourceRoot":"","sources":["../../../chart/ChartTypeResolution.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAQxC,MAAM,MAAM,mBAAmB,GACzB;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAClC;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/esm/chart/ChartTypeResolution.js

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

package/dist/esm/chart/ChartTypeResolution.js.map

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

package/dist/esm/chart/PrimeChart.d.ts

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

package/dist/esm/chart/PrimeChart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeChart.d.ts","sourceRoot":"","sources":["../../../chart/PrimeChart.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAuB/D,wBAAgB,UAAU,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,wBAAwB,+BAiC7E"}

package/dist/esm/chart/PrimeChart.js

@@ -0,0 +1,90 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useRef, useMemo } from 'react';
+import { recordProperty, booleanProperty, stringProperty } from '../properties.js';
+import { useStructuralValue } from '../useStructuralValue.js';
+import { chartHasData } from './chartHasData.js';
+import { resolveChartType } from './resolveChartType.js';
+import { useChart } from './useChart.js';
+
+/**
+ * The `PrimeReact:chart` component, rendered by Chart.js because PrimeReact 11 no longer ships its
+ * former Chart.js wrapper.
+ *
+ * Three states are explicit rather than a blank canvas: an unsupported `type` is reported (the right chart
+ * cannot be guessed), a chart with no data points shows its `emptyLabel` (data is never invented), and a
+ * chart Chart.js could not draw says why. Only a chart with data and a supported type reaches Chart.js.
+ *
+ * Chart.js is an optional peer dependency of this package: a host that renders charts must install
+ * `chart.js` itself. The chart rebuilds only when its resolved type, data or options change in content -
+ * every edit to a Scene document clones the whole document, and a clone with equal content is not a change.
+ *
+ * The chart fills the authored size: `maintainAspectRatio` defaults to `false` here (Chart.js defaults to
+ * `true`, which shrinks the chart inside its box) and an authored `options.maintainAspectRatio` wins. The
+ * `responsive` property is authoritative over `options.responsive` when both are set.
+ */ function PrimeChart({ element, interactions }) {
+    const canvas = useRef(null);
+    const resolution = resolveChartType(element);
+    const data = useStructuralValue(recordProperty(element, 'data'));
+    const options = useStructuralValue(recordProperty(element, 'options'));
+    const style = recordProperty(element, 'style');
+    const responsive = booleanProperty(element, 'responsive', options?.responsive ?? true);
+    const ariaLabel = stringProperty(element, 'ariaLabel', element.name || 'Chart');
+    const emptyLabel = stringProperty(element, 'emptyLabel', 'No chart data');
+    const hasData = chartHasData(data);
+    const type = resolution.isValid ? resolution.type : undefined;
+    const enabled = type !== undefined && hasData;
+    const configuration = useMemo(()=>({
+            type,
+            data: data ?? {
+                datasets: []
+            },
+            options: {
+                maintainAspectRatio: false,
+                ...options,
+                responsive
+            }
+        }), [
+        type,
+        data,
+        options,
+        responsive
+    ]);
+    const failure = useChart(canvas, configuration, enabled);
+    return /*#__PURE__*/ jsxs("div", {
+        "data-scene-id": element.id,
+        "data-scene-component": "chart",
+        style: {
+            position: 'relative',
+            width: element.size.width ?? '100%',
+            height: element.size.height ?? '100%',
+            ...style
+        },
+        ...interactions,
+        children: [
+            !resolution.isValid && /*#__PURE__*/ jsx("div", {
+                role: "alert",
+                "data-scene-state": "unsupported-type",
+                children: resolution.message
+            }),
+            resolution.isValid && !hasData && /*#__PURE__*/ jsx("div", {
+                role: "status",
+                "data-scene-state": "empty",
+                children: emptyLabel
+            }),
+            failure !== undefined && /*#__PURE__*/ jsx("div", {
+                role: "alert",
+                "data-scene-state": "unavailable",
+                children: `The chart could not be drawn: ${failure}`
+            }),
+            enabled && /*#__PURE__*/ jsx("canvas", {
+                ref: canvas,
+                role: "img",
+                "aria-label": ariaLabel,
+                hidden: failure !== undefined
+            })
+        ]
+    });
+}
+
+export { PrimeChart };
+//# sourceMappingURL=PrimeChart.js.map

package/dist/esm/chart/PrimeChart.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeChart.js","sources":["../../../chart/PrimeChart.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 { CSSProperties, useMemo, useRef } from 'react';\nimport type { ChartConfiguration, ChartData, ChartOptions } from 'chart.js';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, recordProperty, stringProperty } from '../properties';\nimport { useStructuralValue } from '../useStructuralValue';\nimport { chartHasData } from './chartHasData';\nimport { resolveChartType } from './resolveChartType';\nimport { useChart } from './useChart';\n\n/**\n * The `PrimeReact:chart` component, rendered by Chart.js because PrimeReact 11 no longer ships its\n * former Chart.js wrapper.\n *\n * Three states are explicit rather than a blank canvas: an unsupported `type` is reported (the right chart\n * cannot be guessed), a chart with no data points shows its `emptyLabel` (data is never invented), and a\n * chart Chart.js could not draw says why. Only a chart with data and a supported type reaches Chart.js.\n *\n * Chart.js is an optional peer dependency of this package: a host that renders charts must install\n * `chart.js` itself. The chart rebuilds only when its resolved type, data or options change in content -\n * every edit to a Scene document clones the whole document, and a clone with equal content is not a change.\n *\n * The chart fills the authored size: `maintainAspectRatio` defaults to `false` here (Chart.js defaults to\n * `true`, which shrinks the chart inside its box) and an authored `options.maintainAspectRatio` wins. The\n * `responsive` property is authoritative over `options.responsive` when both are set.\n */\nexport function PrimeChart({ element, interactions }: RegisteredComponentProps) {\n    const canvas = useRef<HTMLCanvasElement>(null);\n    const resolution = resolveChartType(element);\n    const data = useStructuralValue(recordProperty(element, 'data') as ChartData | undefined);\n    const options = useStructuralValue(recordProperty(element, 'options') as ChartOptions | undefined);\n    const style = recordProperty(element, 'style') as CSSProperties | undefined;\n    const responsive = booleanProperty(element, 'responsive', options?.responsive ?? true);\n    const ariaLabel = stringProperty(element, 'ariaLabel', element.name || 'Chart');\n    const emptyLabel = stringProperty(element, 'emptyLabel', 'No chart data');\n    const hasData = chartHasData(data);\n    const type = resolution.isValid ? resolution.type : undefined;\n    const enabled = type !== undefined && hasData;\n\n    const configuration = useMemo(() => ({\n        type,\n        data: data ?? { datasets: [] },\n        options: { maintainAspectRatio: false, ...options, responsive },\n    }) as unknown as ChartConfiguration, [type, data, options, responsive]);\n\n    const failure = useChart(canvas, configuration, enabled);\n\n    return (\n        <div\n            data-scene-id={element.id}\n            data-scene-component='chart'\n            style={{ position: 'relative', width: element.size.width ?? '100%', height: element.size.height ?? '100%', ...style }}\n            {...interactions}>\n            {!resolution.isValid && <div role='alert' data-scene-state='unsupported-type'>{resolution.message}</div>}\n            {resolution.isValid && !hasData && <div role='status' data-scene-state='empty'>{emptyLabel}</div>}\n            {failure !== undefined && <div role='alert' data-scene-state='unavailable'>{`The chart could not be drawn: ${failure}`}</div>}\n            {enabled && <canvas ref={canvas} role='img' aria-label={ariaLabel} hidden={failure !== undefined} />}\n        </div>\n    );\n}\n"],"names":["PrimeChart","element","interactions","canvas","useRef","resolution","resolveChartType","data","useStructuralValue","recordProperty","options","style","responsive","booleanProperty","ariaLabel","stringProperty","name","emptyLabel","hasData","chartHasData","type","isValid","undefined","enabled","configuration","useMemo","datasets","maintainAspectRatio","failure","useChart","_jsxs","div","data-scene-id","id","data-scene-component","position","width","size","height","_jsx","role","data-scene-state","message","ref","aria-label","hidden"],"mappings":"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"}

package/dist/esm/chart/chartHasData.d.ts

@@ -0,0 +1,2 @@
+export declare function chartHasData(data: unknown): boolean;
+//# sourceMappingURL=chartHasData.d.ts.map

package/dist/esm/chart/chartHasData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chartHasData.d.ts","sourceRoot":"","sources":["../../../chart/chartHasData.ts"],"names":[],"mappings":"AAUA,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAWnD"}

package/dist/esm/chart/chartHasData.js

@@ -0,0 +1,22 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Whether chart data holds at least one data point to draw.
+ *
+ * Datasets whose `data` is empty (or absent) draw nothing but axes, so the chart reports it instead.
+ * A dataset may also give its points as keyed records (Chart.js `parsing` over an object), which counts
+ * when it has any keys.
+ */ function chartHasData(data) {
+    if (data === null || typeof data !== 'object') return false;
+    const datasets = data.datasets;
+    if (!Array.isArray(datasets)) return false;
+    return datasets.some((dataset)=>{
+        if (dataset === null || typeof dataset !== 'object') return false;
+        const points = dataset.data;
+        if (Array.isArray(points)) return points.length > 0;
+        return points !== null && typeof points === 'object' && Object.keys(points).length > 0;
+    });
+}
+
+export { chartHasData };
+//# sourceMappingURL=chartHasData.js.map