@cratis/scene.primereact 0.1.0

package/dist/cjs/data/PrimeOrderList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeOrderList.js","sources":["../../../data/PrimeOrderList.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 { useState } from 'react';\nimport { OrderList } from 'primereact/orderlist';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { optionsProperty, stringProperty } from '../properties';\nimport { SelectOption } from '../SelectOption';\n\n/**\n * The `PrimeReact:orderList` component - a list the user reorders with the supplied controls.\n *\n * Reordering is the component's entire purpose, so the order has to live somewhere that survives a\n * re-render; the adapter keeps it locally, seeded from `items`.\n *\n * In PrimeReact 11 this component becomes a hook rather than a component.\n */\nexport function PrimeOrderList({ element }: RegisteredComponentProps) {\n    const [items, setItems] = useState<SelectOption[]>(optionsProperty(element, 'items'));\n    return (\n        <OrderList\n            data-scene-id={element.id}\n            value={items}\n            onChange={(event) => setItems(event.value)}\n            dataKey='value'\n            header={stringProperty(element, 'header')}\n            itemTemplate={(item: SelectOption) => <span>{item.label}</span>}\n        />\n    );\n}\n"],"names":["PrimeOrderList","element","items","setItems","useState","optionsProperty","_jsx","OrderList","data-scene-id","id","value","onChange","event","dataKey","header","stringProperty","itemTemplate","item","span","label"],"mappings":";;;;;;;AASA;;;;;;;AAOC,IACM,SAASA,cAAAA,CAAe,EAAEC,OAAO,EAA4B,EAAA;AAChE,IAAA,MAAM,CAACC,KAAAA,EAAOC,QAAAA,CAAS,GAAGC,cAAAA,CAAyBC,2BAAgBJ,OAAAA,EAAS,OAAA,CAAA,CAAA;AAC5E,IAAA,qBACIK,cAAA,CAACC,mBAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeP,QAAQQ,EAAE;QACzBC,KAAAA,EAAOR,KAAAA;AACPS,QAAAA,QAAAA,EAAU,CAACC,KAAAA,GAAUT,QAAAA,CAASS,KAAAA,CAAMF,KAAK,CAAA;QACzCG,OAAAA,EAAQ,OAAA;AACRC,QAAAA,MAAAA,EAAQC,0BAAed,OAAAA,EAAS,QAAA,CAAA;QAChCe,YAAAA,EAAc,CAACC,qBAAuBX,cAAA,CAACY,MAAAA,EAAAA;AAAMD,gBAAAA,QAAAA,EAAAA,IAAAA,CAAKE;;;AAG9D;;;;"}

package/dist/cjs/data/PrimeOrganizationChart.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var organizationchart = require('primereact/organizationchart');
+var treeNodes = require('../treeNodes.js');
+
+/**
+ * The `PrimeReact:organizationChart` component - a hierarchy drawn top-down as connected boxes.
+ *
+ * Takes the same node model as `tree` and `treeSelect`, so one authored hierarchy can be shown three
+ * different ways without being restructured.
+ *
+ * The empty case is guarded because PrimeReact's OrganizationChart reads the root node's `expanded` flag
+ * without checking there is a root, and throws on an empty `value`. An element whose nodes have not been
+ * authored yet is an ordinary state on a screen under construction; taking the whole screen down for it
+ * would be the wrong failure.
+ */ function PrimeOrganizationChart({ element }) {
+    const nodes = treeNodes.treeNodesProperty(element, 'nodes');
+    if (nodes.length === 0) return /*#__PURE__*/ jsxRuntime.jsx("div", {
+        "data-scene-id": element.id
+    });
+    return /*#__PURE__*/ jsxRuntime.jsx(organizationchart.OrganizationChart, {
+        "data-scene-id": element.id,
+        value: nodes
+    });
+}
+
+exports.PrimeOrganizationChart = PrimeOrganizationChart;
+//# sourceMappingURL=PrimeOrganizationChart.js.map

package/dist/cjs/data/PrimeOrganizationChart.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeOrganizationChart.js","sources":["../../../data/PrimeOrganizationChart.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 { OrganizationChart } from 'primereact/organizationchart';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { treeNodesProperty } from '../treeNodes';\n\n/**\n * The `PrimeReact:organizationChart` component - a hierarchy drawn top-down as connected boxes.\n *\n * Takes the same node model as `tree` and `treeSelect`, so one authored hierarchy can be shown three\n * different ways without being restructured.\n *\n * The empty case is guarded because PrimeReact's OrganizationChart reads the root node's `expanded` flag\n * without checking there is a root, and throws on an empty `value`. An element whose nodes have not been\n * authored yet is an ordinary state on a screen under construction; taking the whole screen down for it\n * would be the wrong failure.\n */\nexport function PrimeOrganizationChart({ element }: RegisteredComponentProps) {\n    const nodes = treeNodesProperty(element, 'nodes');\n    if (nodes.length === 0) return <div data-scene-id={element.id} />;\n    return <OrganizationChart data-scene-id={element.id} value={nodes} />;\n}\n"],"names":["PrimeOrganizationChart","element","nodes","treeNodesProperty","length","_jsx","div","data-scene-id","id","OrganizationChart","value"],"mappings":";;;;;;AAOA;;;;;;;;;;AAUC,IACM,SAASA,sBAAAA,CAAuB,EAAEC,OAAO,EAA4B,EAAA;IACxE,MAAMC,KAAAA,GAAQC,4BAAkBF,OAAAA,EAAS,OAAA,CAAA;AACzC,IAAA,IAAIC,KAAAA,CAAME,MAAM,KAAK,CAAA,EAAG,qBAAOC,cAAA,CAACC,KAAAA,EAAAA;AAAIC,QAAAA,eAAAA,EAAeN,QAAQO;;AAC3D,IAAA,qBAAOH,cAAA,CAACI,mCAAAA,EAAAA;AAAkBF,QAAAA,eAAAA,EAAeN,QAAQO,EAAE;QAAEE,KAAAA,EAAOR;;AAChE;;;;"}

package/dist/cjs/data/PrimePaginator.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var paginator = require('primereact/paginator');
+var properties = require('../properties.js');
+
+/**
+ * The `PrimeReact:paginator` component - page navigation for a list a screen paginates itself.
+ *
+ * Owns the current page locally so the control is operable in a preview; a Scene element has no place to
+ * record which page the user is on.
+ */ function PrimePaginator({ element }) {
+    const pageSize = properties.numberProperty(element, 'pageSize', 10);
+    const [first, setFirst] = react.useState(properties.numberProperty(element, 'first', 0));
+    const [rows, setRows] = react.useState(pageSize);
+    return /*#__PURE__*/ jsxRuntime.jsx(paginator.Paginator, {
+        "data-scene-id": element.id,
+        first: first,
+        rows: rows,
+        totalRecords: properties.numberProperty(element, 'totalRecords', 0),
+        rowsPerPageOptions: [
+            pageSize,
+            pageSize * 2,
+            pageSize * 5
+        ],
+        onPageChange: (event)=>{
+            setFirst(event.first);
+            setRows(event.rows);
+        }
+    });
+}
+
+exports.PrimePaginator = PrimePaginator;
+//# sourceMappingURL=PrimePaginator.js.map

package/dist/cjs/data/PrimePaginator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimePaginator.js","sources":["../../../data/PrimePaginator.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 { useState } from 'react';\nimport { Paginator } from 'primereact/paginator';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { numberProperty } from '../properties';\n\n/**\n * The `PrimeReact:paginator` component - page navigation for a list a screen paginates itself.\n *\n * Owns the current page locally so the control is operable in a preview; a Scene element has no place to\n * record which page the user is on.\n */\nexport function PrimePaginator({ element }: RegisteredComponentProps) {\n    const pageSize = numberProperty(element, 'pageSize', 10);\n    const [first, setFirst] = useState(numberProperty(element, 'first', 0));\n    const [rows, setRows] = useState(pageSize);\n    return (\n        <Paginator\n            data-scene-id={element.id}\n            first={first}\n            rows={rows}\n            totalRecords={numberProperty(element, 'totalRecords', 0)}\n            rowsPerPageOptions={[pageSize, pageSize * 2, pageSize * 5]}\n            onPageChange={(event) => {\n                setFirst(event.first);\n                setRows(event.rows);\n            }}\n        />\n    );\n}\n"],"names":["PrimePaginator","element","pageSize","numberProperty","first","setFirst","useState","rows","setRows","_jsx","Paginator","data-scene-id","id","totalRecords","rowsPerPageOptions","onPageChange","event"],"mappings":";;;;;;;AAQA;;;;;AAKC,IACM,SAASA,cAAAA,CAAe,EAAEC,OAAO,EAA4B,EAAA;IAChE,MAAMC,QAAAA,GAAWC,yBAAAA,CAAeF,OAAAA,EAAS,UAAA,EAAY,EAAA,CAAA;AACrD,IAAA,MAAM,CAACG,KAAAA,EAAOC,QAAAA,CAAS,GAAGC,cAAAA,CAASH,yBAAAA,CAAeF,SAAS,OAAA,EAAS,CAAA,CAAA,CAAA;AACpE,IAAA,MAAM,CAACM,IAAAA,EAAMC,OAAAA,CAAQ,GAAGF,cAAAA,CAASJ,QAAAA,CAAAA;AACjC,IAAA,qBACIO,cAAA,CAACC,mBAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeV,QAAQW,EAAE;QACzBR,KAAAA,EAAOA,KAAAA;QACPG,IAAAA,EAAMA,IAAAA;QACNM,YAAAA,EAAcV,yBAAAA,CAAeF,SAAS,cAAA,EAAgB,CAAA,CAAA;QACtDa,kBAAAA,EAAoB;AAACZ,YAAAA,QAAAA;YAAUA,QAAAA,GAAW,CAAA;YAAGA,QAAAA,GAAW;AAAE,SAAA;AAC1Da,QAAAA,YAAAA,EAAc,CAACC,KAAAA,GAAAA;AACXX,YAAAA,QAAAA,CAASW,MAAMZ,KAAK,CAAA;AACpBI,YAAAA,OAAAA,CAAQQ,MAAMT,IAAI,CAAA;AACtB,QAAA;;AAGZ;;;;"}

package/dist/cjs/data/PrimePickList.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var picklist = require('primereact/picklist');
+var properties = require('../properties.js');
+
+/**
+ * The `PrimeReact:pickList` component - two lists with items moved between them.
+ *
+ * Both sides are held locally for the same reason {@link PrimeOrderList} holds its order: moving items is
+ * what the component does, and a Scene element cannot record the result.
+ *
+ * In PrimeReact 11 this component becomes a hook rather than a component.
+ */ function PrimePickList({ element }) {
+    const [source, setSource] = react.useState(properties.optionsProperty(element, 'source'));
+    const [target, setTarget] = react.useState(properties.optionsProperty(element, 'target'));
+    return /*#__PURE__*/ jsxRuntime.jsx(picklist.PickList, {
+        "data-scene-id": element.id,
+        source: source,
+        target: target,
+        onChange: (event)=>{
+            setSource(event.source);
+            setTarget(event.target);
+        },
+        dataKey: "value",
+        sourceHeader: properties.stringProperty(element, 'sourceHeader', 'Available'),
+        targetHeader: properties.stringProperty(element, 'targetHeader', 'Selected'),
+        itemTemplate: (item)=>/*#__PURE__*/ jsxRuntime.jsx("span", {
+                children: item.label
+            })
+    });
+}
+
+exports.PrimePickList = PrimePickList;
+//# sourceMappingURL=PrimePickList.js.map

package/dist/cjs/data/PrimePickList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimePickList.js","sources":["../../../data/PrimePickList.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 { useState } from 'react';\nimport { PickList } from 'primereact/picklist';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { optionsProperty, stringProperty } from '../properties';\nimport { SelectOption } from '../SelectOption';\n\n/**\n * The `PrimeReact:pickList` component - two lists with items moved between them.\n *\n * Both sides are held locally for the same reason {@link PrimeOrderList} holds its order: moving items is\n * what the component does, and a Scene element cannot record the result.\n *\n * In PrimeReact 11 this component becomes a hook rather than a component.\n */\nexport function PrimePickList({ element }: RegisteredComponentProps) {\n    const [source, setSource] = useState<SelectOption[]>(optionsProperty(element, 'source'));\n    const [target, setTarget] = useState<SelectOption[]>(optionsProperty(element, 'target'));\n    return (\n        <PickList\n            data-scene-id={element.id}\n            source={source}\n            target={target}\n            onChange={(event) => {\n                setSource(event.source);\n                setTarget(event.target);\n            }}\n            dataKey='value'\n            sourceHeader={stringProperty(element, 'sourceHeader', 'Available')}\n            targetHeader={stringProperty(element, 'targetHeader', 'Selected')}\n            itemTemplate={(item: SelectOption) => <span>{item.label}</span>}\n        />\n    );\n}\n"],"names":["PrimePickList","element","source","setSource","useState","optionsProperty","target","setTarget","_jsx","PickList","data-scene-id","id","onChange","event","dataKey","sourceHeader","stringProperty","targetHeader","itemTemplate","item","span","label"],"mappings":";;;;;;;AASA;;;;;;;AAOC,IACM,SAASA,aAAAA,CAAc,EAAEC,OAAO,EAA4B,EAAA;AAC/D,IAAA,MAAM,CAACC,MAAAA,EAAQC,SAAAA,CAAU,GAAGC,cAAAA,CAAyBC,2BAAgBJ,OAAAA,EAAS,QAAA,CAAA,CAAA;AAC9E,IAAA,MAAM,CAACK,MAAAA,EAAQC,SAAAA,CAAU,GAAGH,cAAAA,CAAyBC,2BAAgBJ,OAAAA,EAAS,QAAA,CAAA,CAAA;AAC9E,IAAA,qBACIO,cAAA,CAACC,iBAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeT,QAAQU,EAAE;QACzBT,MAAAA,EAAQA,MAAAA;QACRI,MAAAA,EAAQA,MAAAA;AACRM,QAAAA,QAAAA,EAAU,CAACC,KAAAA,GAAAA;AACPV,YAAAA,SAAAA,CAAUU,MAAMX,MAAM,CAAA;AACtBK,YAAAA,SAAAA,CAAUM,MAAMP,MAAM,CAAA;AAC1B,QAAA,CAAA;QACAQ,OAAAA,EAAQ,OAAA;QACRC,YAAAA,EAAcC,yBAAAA,CAAef,SAAS,cAAA,EAAgB,WAAA,CAAA;QACtDgB,YAAAA,EAAcD,yBAAAA,CAAef,SAAS,cAAA,EAAgB,UAAA,CAAA;QACtDiB,YAAAA,EAAc,CAACC,qBAAuBX,cAAA,CAACY,MAAAA,EAAAA;AAAMD,gBAAAA,QAAAA,EAAAA,IAAAA,CAAKE;;;AAG9D;;;;"}

package/dist/cjs/data/PrimeTimeline.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var timeline = require('primereact/timeline');
+var properties = require('../properties.js');
+
+/**
+ * The `PrimeReact:timeline` component - events laid out along an axis.
+ *
+ * Supplies its own content and opposite templates from the `titleField`, `descriptionField` and
+ * `dateField` properties, because Timeline renders only the connector line without them.
+ */ function PrimeTimeline({ element }) {
+    const titleField = properties.stringProperty(element, 'titleField', 'title');
+    const descriptionField = properties.stringProperty(element, 'descriptionField', 'description');
+    const dateField = properties.stringProperty(element, 'dateField', 'date');
+    return /*#__PURE__*/ jsxRuntime.jsx(timeline.Timeline, {
+        "data-scene-id": element.id,
+        value: properties.recordArrayProperty(element, 'events'),
+        align: properties.stringProperty(element, 'align', 'left'),
+        layout: properties.stringProperty(element, 'layout', 'vertical'),
+        opposite: (event)=>/*#__PURE__*/ jsxRuntime.jsx("span", {
+                className: "text-sm opacity-75",
+                children: String(event[dateField] ?? '')
+            }),
+        content: (event)=>/*#__PURE__*/ jsxRuntime.jsxs("div", {
+                className: "flex flex-col",
+                children: [
+                    /*#__PURE__*/ jsxRuntime.jsx("span", {
+                        className: "font-semibold",
+                        children: String(event[titleField] ?? '')
+                    }),
+                    /*#__PURE__*/ jsxRuntime.jsx("span", {
+                        className: "text-sm opacity-75",
+                        children: String(event[descriptionField] ?? '')
+                    })
+                ]
+            })
+    });
+}
+
+exports.PrimeTimeline = PrimeTimeline;
+//# sourceMappingURL=PrimeTimeline.js.map

package/dist/cjs/data/PrimeTimeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeTimeline.js","sources":["../../../data/PrimeTimeline.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 { Timeline } from 'primereact/timeline';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { recordArrayProperty, stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:timeline` component - events laid out along an axis.\n *\n * Supplies its own content and opposite templates from the `titleField`, `descriptionField` and\n * `dateField` properties, because Timeline renders only the connector line without them.\n */\nexport function PrimeTimeline({ element }: RegisteredComponentProps) {\n    const titleField = stringProperty(element, 'titleField', 'title');\n    const descriptionField = stringProperty(element, 'descriptionField', 'description');\n    const dateField = stringProperty(element, 'dateField', 'date');\n    return (\n        <Timeline\n            data-scene-id={element.id}\n            value={recordArrayProperty(element, 'events')}\n            align={stringProperty(element, 'align', 'left') as 'left' | 'right' | 'alternate' | 'top' | 'bottom'}\n            layout={stringProperty(element, 'layout', 'vertical') as 'vertical' | 'horizontal'}\n            opposite={(event: Record<string, unknown>) => <span className='text-sm opacity-75'>{String(event[dateField] ?? '')}</span>}\n            content={(event: Record<string, unknown>) => (\n                <div className='flex flex-col'>\n                    <span className='font-semibold'>{String(event[titleField] ?? '')}</span>\n                    <span className='text-sm opacity-75'>{String(event[descriptionField] ?? '')}</span>\n                </div>\n            )}\n        />\n    );\n}\n"],"names":["PrimeTimeline","element","titleField","stringProperty","descriptionField","dateField","_jsx","Timeline","data-scene-id","id","value","recordArrayProperty","align","layout","opposite","event","span","className","String","content","_jsxs","div"],"mappings":";;;;;;AAOA;;;;;AAKC,IACM,SAASA,aAAAA,CAAc,EAAEC,OAAO,EAA4B,EAAA;IAC/D,MAAMC,UAAAA,GAAaC,yBAAAA,CAAeF,OAAAA,EAAS,YAAA,EAAc,OAAA,CAAA;IACzD,MAAMG,gBAAAA,GAAmBD,yBAAAA,CAAeF,OAAAA,EAAS,kBAAA,EAAoB,aAAA,CAAA;IACrE,MAAMI,SAAAA,GAAYF,yBAAAA,CAAeF,OAAAA,EAAS,WAAA,EAAa,MAAA,CAAA;AACvD,IAAA,qBACIK,cAAA,CAACC,iBAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeP,QAAQQ,EAAE;AACzBC,QAAAA,KAAAA,EAAOC,+BAAoBV,OAAAA,EAAS,QAAA,CAAA;QACpCW,KAAAA,EAAOT,yBAAAA,CAAeF,SAAS,OAAA,EAAS,MAAA,CAAA;QACxCY,MAAAA,EAAQV,yBAAAA,CAAeF,SAAS,QAAA,EAAU,UAAA,CAAA;QAC1Ca,QAAAA,EAAU,CAACC,sBAAmCT,cAAA,CAACU,MAAAA,EAAAA;gBAAKC,SAAAA,EAAU,oBAAA;0BAAsBC,MAAAA,CAAOH,KAAK,CAACV,SAAAA,CAAU,IAAI,EAAA;;QAC/Gc,OAAAA,EAAS,CAACJ,sBACNK,eAAA,CAACC,KAAAA,EAAAA;gBAAIJ,SAAAA,EAAU,eAAA;;kCACXX,cAAA,CAACU,MAAAA,EAAAA;wBAAKC,SAAAA,EAAU,eAAA;kCAAiBC,MAAAA,CAAOH,KAAK,CAACb,UAAAA,CAAW,IAAI,EAAA;;kCAC7DI,cAAA,CAACU,MAAAA,EAAAA;wBAAKC,SAAAA,EAAU,oBAAA;kCAAsBC,MAAAA,CAAOH,KAAK,CAACX,gBAAAA,CAAiB,IAAI,EAAA;;;;;AAK5F;;;;"}

package/dist/cjs/data/PrimeTree.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var tree = require('primereact/tree');
+var properties = require('../properties.js');
+var treeNodes = require('../treeNodes.js');
+
+/**
+ * The `PrimeReact:tree` component - a hierarchy the user can expand and collapse.
+ */ function PrimeTree({ element }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(tree.Tree, {
+        "data-scene-id": element.id,
+        value: treeNodes.treeNodesProperty(element, 'nodes'),
+        filter: properties.booleanProperty(element, 'filter', false),
+        selectionMode: properties.booleanProperty(element, 'selectable', false) ? 'single' : undefined
+    });
+}
+
+exports.PrimeTree = PrimeTree;
+//# sourceMappingURL=PrimeTree.js.map

package/dist/cjs/data/PrimeTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeTree.js","sources":["../../../data/PrimeTree.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 { Tree } from 'primereact/tree';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty } from '../properties';\nimport { treeNodesProperty } from '../treeNodes';\n\n/**\n * The `PrimeReact:tree` component - a hierarchy the user can expand and collapse.\n */\nexport function PrimeTree({ element }: RegisteredComponentProps) {\n    return (\n        <Tree\n            data-scene-id={element.id}\n            value={treeNodesProperty(element, 'nodes')}\n            filter={booleanProperty(element, 'filter', false)}\n            selectionMode={booleanProperty(element, 'selectable', false) ? 'single' : undefined}\n        />\n    );\n}\n"],"names":["PrimeTree","element","_jsx","Tree","data-scene-id","id","value","treeNodesProperty","filter","booleanProperty","selectionMode","undefined"],"mappings":";;;;;;;AAQA;;AAEC,IACM,SAASA,SAAAA,CAAU,EAAEC,OAAO,EAA4B,EAAA;AAC3D,IAAA,qBACIC,cAAA,CAACC,SAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeH,QAAQI,EAAE;AACzBC,QAAAA,KAAAA,EAAOC,4BAAkBN,OAAAA,EAAS,OAAA,CAAA;QAClCO,MAAAA,EAAQC,0BAAAA,CAAgBR,SAAS,QAAA,EAAU,KAAA,CAAA;AAC3CS,QAAAA,aAAAA,EAAeD,0BAAAA,CAAgBR,OAAAA,EAAS,YAAA,EAAc,KAAA,CAAA,GAAS,QAAA,GAAWU;;AAGtF;;;;"}

package/dist/cjs/data/PrimeTreeTable.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var column = require('primereact/column');
+var treetable = require('primereact/treetable');
+var properties = require('../properties.js');
+var treeNodes = require('../treeNodes.js');
+
+/**
+ * The `PrimeReact:treeTable` component - a table whose rows nest.
+ *
+ * Columns address the node's `data` object, so they are read from a `columns` property here rather than
+ * inferred: a tree node's own shape (key, label, children) is structure, not data, and inferring columns
+ * from it would produce a table of the tree's plumbing.
+ */ function PrimeTreeTable({ element }) {
+    const nodes = treeNodes.treeNodesProperty(element, 'nodes');
+    const named = properties.recordArrayProperty(element, 'columns').map((column)=>({
+            field: column.field,
+            header: column.header ?? column.field
+        })).filter((column)=>typeof column.field === 'string').map((column)=>({
+            field: column.field,
+            header: typeof column.header === 'string' ? column.header : column.field
+        }));
+    const columns = named.length > 0 ? named : properties.stringArrayProperty(element, 'columns').map((field)=>({
+            field,
+            header: field
+        }));
+    return /*#__PURE__*/ jsxRuntime.jsx(treetable.TreeTable, {
+        "data-scene-id": element.id,
+        value: nodes,
+        children: columns.map((column$1, index)=>/*#__PURE__*/ jsxRuntime.jsx(column.Column, {
+                field: column$1.field,
+                header: column$1.header,
+                expander: index === 0
+            }, column$1.field))
+    });
+}
+
+exports.PrimeTreeTable = PrimeTreeTable;
+//# sourceMappingURL=PrimeTreeTable.js.map

package/dist/cjs/data/PrimeTreeTable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeTreeTable.js","sources":["../../../data/PrimeTreeTable.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 { Column } from 'primereact/column';\nimport { TreeTable } from 'primereact/treetable';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { recordArrayProperty, stringArrayProperty } from '../properties';\nimport { treeNodesProperty } from '../treeNodes';\n\n/**\n * The `PrimeReact:treeTable` component - a table whose rows nest.\n *\n * Columns address the node's `data` object, so they are read from a `columns` property here rather than\n * inferred: a tree node's own shape (key, label, children) is structure, not data, and inferring columns\n * from it would produce a table of the tree's plumbing.\n */\nexport function PrimeTreeTable({ element }: RegisteredComponentProps) {\n    const nodes = treeNodesProperty(element, 'nodes');\n    const named = recordArrayProperty(element, 'columns')\n        .map((column) => ({ field: column.field, header: column.header ?? column.field }))\n        .filter((column): column is { field: string; header: unknown } => typeof column.field === 'string')\n        .map((column) => ({ field: column.field, header: typeof column.header === 'string' ? column.header : column.field }));\n    const columns = named.length > 0 ? named : stringArrayProperty(element, 'columns').map((field) => ({ field, header: field }));\n\n    return (\n        <TreeTable data-scene-id={element.id} value={nodes}>\n            {columns.map((column, index) => (\n                <Column key={column.field} field={column.field} header={column.header} expander={index === 0} />\n            ))}\n        </TreeTable>\n    );\n}\n"],"names":["PrimeTreeTable","element","nodes","treeNodesProperty","named","recordArrayProperty","map","column","field","header","filter","columns","length","stringArrayProperty","_jsx","TreeTable","data-scene-id","id","value","index","Column","expander"],"mappings":";;;;;;;;AASA;;;;;;AAMC,IACM,SAASA,cAAAA,CAAe,EAAEC,OAAO,EAA4B,EAAA;IAChE,MAAMC,KAAAA,GAAQC,4BAAkBF,OAAAA,EAAS,OAAA,CAAA;IACzC,MAAMG,KAAAA,GAAQC,+BAAoBJ,OAAAA,EAAS,SAAA,CAAA,CACtCK,GAAG,CAAC,CAACC,UAAY;AAAEC,YAAAA,KAAAA,EAAOD,OAAOC,KAAK;AAAEC,YAAAA,MAAAA,EAAQF,MAAAA,CAAOE,MAAM,IAAIF,MAAAA,CAAOC;AAAM,SAAA,CAAA,CAAA,CAC9EE,MAAM,CAAC,CAACH,SAAyD,OAAOA,MAAAA,CAAOC,KAAK,KAAK,QAAA,CAAA,CACzFF,GAAG,CAAC,CAACC,UAAY;AAAEC,YAAAA,KAAAA,EAAOD,OAAOC,KAAK;YAAEC,MAAAA,EAAQ,OAAOF,OAAOE,MAAM,KAAK,WAAWF,MAAAA,CAAOE,MAAM,GAAGF,MAAAA,CAAOC;SAAM,CAAA,CAAA;AACtH,IAAA,MAAMG,OAAAA,GAAUP,KAAAA,CAAMQ,MAAM,GAAG,CAAA,GAAIR,KAAAA,GAAQS,8BAAAA,CAAoBZ,OAAAA,EAAS,SAAA,CAAA,CAAWK,GAAG,CAAC,CAACE,SAAW;AAAEA,YAAAA,KAAAA;YAAOC,MAAAA,EAAQD;SAAM,CAAA,CAAA;AAE1H,IAAA,qBACIM,cAAA,CAACC,mBAAAA,EAAAA;AAAUC,QAAAA,eAAAA,EAAef,QAAQgB,EAAE;QAAEC,KAAAA,EAAOhB,KAAAA;AACxCS,QAAAA,QAAAA,EAAAA,OAAAA,CAAQL,GAAG,CAAC,CAACC,QAAAA,EAAQY,sBAClBL,cAAA,CAACM,aAAAA,EAAAA;AAA0BZ,gBAAAA,KAAAA,EAAOD,SAAOC,KAAK;AAAEC,gBAAAA,MAAAA,EAAQF,SAAOE,MAAM;AAAEY,gBAAAA,QAAAA,EAAUF,KAAAA,KAAU;AAA9EZ,aAAAA,EAAAA,QAAAA,CAAOC,KAAK,CAAA;;AAIzC;;;;"}

package/dist/cjs/data/PrimeVirtualScroller.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var virtualscroller = require('primereact/virtualscroller');
+var properties = require('../properties.js');
+
+/**
+ * The `PrimeReact:virtualScroller` component - a long list that renders only the visible window.
+ *
+ * VirtualScroller needs a fixed `itemSize` and an explicitly sized viewport to know what to render; both
+ * are supplied with defaults so an element authored with only `items` still scrolls rather than
+ * collapsing to zero height.
+ */ function PrimeVirtualScroller({ element }) {
+    const itemSize = properties.numberProperty(element, 'itemSize', 40);
+    return /*#__PURE__*/ jsxRuntime.jsx(virtualscroller.VirtualScroller, {
+        "data-scene-id": element.id,
+        items: properties.stringArrayProperty(element, 'items'),
+        itemSize: itemSize,
+        className: "w-64 border",
+        style: {
+            height: `${properties.numberProperty(element, 'height', 200)}px`
+        },
+        itemTemplate: (item)=>/*#__PURE__*/ jsxRuntime.jsx("div", {
+                className: "flex items-center px-3",
+                style: {
+                    height: `${itemSize}px`
+                },
+                children: item
+            })
+    });
+}
+
+exports.PrimeVirtualScroller = PrimeVirtualScroller;
+//# sourceMappingURL=PrimeVirtualScroller.js.map

package/dist/cjs/data/PrimeVirtualScroller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeVirtualScroller.js","sources":["../../../data/PrimeVirtualScroller.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 { VirtualScroller } from 'primereact/virtualscroller';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { numberProperty, stringArrayProperty } from '../properties';\n\n/**\n * The `PrimeReact:virtualScroller` component - a long list that renders only the visible window.\n *\n * VirtualScroller needs a fixed `itemSize` and an explicitly sized viewport to know what to render; both\n * are supplied with defaults so an element authored with only `items` still scrolls rather than\n * collapsing to zero height.\n */\nexport function PrimeVirtualScroller({ element }: RegisteredComponentProps) {\n    const itemSize = numberProperty(element, 'itemSize', 40);\n    return (\n        <VirtualScroller\n            data-scene-id={element.id}\n            items={stringArrayProperty(element, 'items')}\n            itemSize={itemSize}\n            className='w-64 border'\n            style={{ height: `${numberProperty(element, 'height', 200)}px` }}\n            itemTemplate={(item: string) => (\n                <div className='flex items-center px-3' style={{ height: `${itemSize}px` }}>\n                    {item}\n                </div>\n            )}\n        />\n    );\n}\n"],"names":["PrimeVirtualScroller","element","itemSize","numberProperty","_jsx","VirtualScroller","data-scene-id","id","items","stringArrayProperty","className","style","height","itemTemplate","item","div"],"mappings":";;;;;;AAOA;;;;;;AAMC,IACM,SAASA,oBAAAA,CAAqB,EAAEC,OAAO,EAA4B,EAAA;IACtE,MAAMC,QAAAA,GAAWC,yBAAAA,CAAeF,OAAAA,EAAS,UAAA,EAAY,EAAA,CAAA;AACrD,IAAA,qBACIG,cAAA,CAACC,+BAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeL,QAAQM,EAAE;AACzBC,QAAAA,KAAAA,EAAOC,+BAAoBR,OAAAA,EAAS,OAAA,CAAA;QACpCC,QAAAA,EAAUA,QAAAA;QACVQ,SAAAA,EAAU,aAAA;QACVC,KAAAA,EAAO;AAAEC,YAAAA,MAAAA,EAAQ,GAAGT,yBAAAA,CAAeF,OAAAA,EAAS,QAAA,EAAU,GAAA,CAAA,CAAK,EAAE;AAAE,SAAA;QAC/DY,YAAAA,EAAc,CAACC,qBACXV,cAAA,CAACW,KAAAA,EAAAA;gBAAIL,SAAAA,EAAU,wBAAA;gBAAyBC,KAAAA,EAAO;oBAAEC,MAAAA,EAAQ,CAAA,EAAGV,QAAAA,CAAS,EAAE;AAAE,iBAAA;AACpEY,gBAAAA,QAAAA,EAAAA;;;AAKrB;;;;"}

package/dist/cjs/data/columnDefinitions.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var properties = require('../properties.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Works out a table's columns, preferring what the screen said most explicitly.
+ *
+ * There are three ways a screen can express columns, and this walks them in order of intent:
+ *
+ * 1. Nested `column` children. Screenplay's screen vocabulary produces these, so they come first.
+ * 2. A `columns` property, for a screen that would rather configure the table than nest elements.
+ * 3. Nothing at all - in which case the keys of the first row are used.
+ *
+ * The third step matters more than it looks: a table given rows and no column configuration is the most
+ * common thing an author writes first, and inferring the columns means it renders their data instead of
+ * an empty grid they have to debug.
+ *
+ * Note that the children are read from `element.slots` - the *model* - and not from the rendered React
+ * nodes the adapter is handed. PrimeReact's DataTable identifies its columns by React element type, so a
+ * Scene adapter wrapping `Column` would not be recognized as one; reading the definitions off the model
+ * and constructing real `Column` elements is what makes nested `column` children work at all.
+ *
+ * @param element The table element.
+ * @param rows The rows the table will show, used for the inference step.
+ * @returns The column definitions, in order.
+ */ function columnDefinitions(element, rows) {
+    const children = [
+        ...element.slots.columns ?? [],
+        ...element.slots.content ?? []
+    ];
+    const fromChildren = children.map(toColumnDefinition).filter((column)=>column !== undefined);
+    if (fromChildren.length > 0) return fromChildren;
+    const fromProperty = properties.recordArrayProperty(element, 'columns').map((column)=>toColumnDefinition({
+            properties: column
+        })).filter((column)=>column !== undefined);
+    if (fromProperty.length > 0) return fromProperty;
+    const fromNames = properties.stringArrayProperty(element, 'columns').map((field)=>({
+            field,
+            header: field,
+            sortable: false
+        }));
+    if (fromNames.length > 0) return fromNames;
+    return Object.keys(rows[0] ?? {}).map((field)=>({
+            field,
+            header: field,
+            sortable: false
+        }));
+}
+function toColumnDefinition(element) {
+    const field = element.properties.field;
+    const header = element.properties.header ?? element.properties.label;
+    if (typeof field !== 'string') return undefined;
+    return {
+        field,
+        header: typeof header === 'string' ? header : field,
+        sortable: element.properties.sortable === true
+    };
+}
+
+exports.columnDefinitions = columnDefinitions;
+//# sourceMappingURL=columnDefinitions.js.map

package/dist/cjs/data/columnDefinitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnDefinitions.js","sources":["../../../data/columnDefinitions.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 { ExternalComponent, SceneElement } from '@cratis/scene.model';\nimport { recordArrayProperty, stringArrayProperty } from '../properties';\nimport { ColumnDefinition } from './ColumnDefinition';\n\n/**\n * Works out a table's columns, preferring what the screen said most explicitly.\n *\n * There are three ways a screen can express columns, and this walks them in order of intent:\n *\n * 1. Nested `column` children. Screenplay's screen vocabulary produces these, so they come first.\n * 2. A `columns` property, for a screen that would rather configure the table than nest elements.\n * 3. Nothing at all - in which case the keys of the first row are used.\n *\n * The third step matters more than it looks: a table given rows and no column configuration is the most\n * common thing an author writes first, and inferring the columns means it renders their data instead of\n * an empty grid they have to debug.\n *\n * Note that the children are read from `element.slots` - the *model* - and not from the rendered React\n * nodes the adapter is handed. PrimeReact's DataTable identifies its columns by React element type, so a\n * Scene adapter wrapping `Column` would not be recognized as one; reading the definitions off the model\n * and constructing real `Column` elements is what makes nested `column` children work at all.\n *\n * @param element The table element.\n * @param rows The rows the table will show, used for the inference step.\n * @returns The column definitions, in order.\n */\nexport function columnDefinitions(element: ExternalComponent, rows: Record<string, unknown>[]): ColumnDefinition[] {\n    const children = [...(element.slots.columns ?? []), ...(element.slots.content ?? [])];\n    const fromChildren = children.map(toColumnDefinition).filter((column): column is ColumnDefinition => column !== undefined);\n    if (fromChildren.length > 0) return fromChildren;\n\n    const fromProperty = recordArrayProperty(element, 'columns')\n        .map((column) => toColumnDefinition({ id: '', properties: column }))\n        .filter((column): column is ColumnDefinition => column !== undefined);\n    if (fromProperty.length > 0) return fromProperty;\n\n    const fromNames = stringArrayProperty(element, 'columns').map((field) => ({ field, header: field, sortable: false }));\n    if (fromNames.length > 0) return fromNames;\n\n    return Object.keys(rows[0] ?? {}).map((field) => ({ field, header: field, sortable: false }));\n}\n\nfunction toColumnDefinition(element: SceneElement): ColumnDefinition | undefined {\n    const field = element.properties.field;\n    const header = element.properties.header ?? element.properties.label;\n    if (typeof field !== 'string') return undefined;\n    return {\n        field,\n        header: typeof header === 'string' ? header : field,\n        sortable: element.properties.sortable === true,\n    };\n}\n"],"names":["columnDefinitions","element","rows","children","slots","columns","content","fromChildren","map","toColumnDefinition","filter","column","undefined","length","fromProperty","recordArrayProperty","properties","fromNames","stringArrayProperty","field","header","sortable","Object","keys","label"],"mappings":";;;;AAAA;AACA;AAMA;;;;;;;;;;;;;;;;;;;;;AAqBC,IACM,SAASA,iBAAAA,CAAkBC,OAA0B,EAAEC,IAA+B,EAAA;AACzF,IAAA,MAAMC,QAAAA,GAAW;AAAKF,QAAAA,GAAAA,OAAAA,CAAQG,KAAK,CAACC,OAAO,IAAI,EAAE;AAAOJ,QAAAA,GAAAA,OAAAA,CAAQG,KAAK,CAACE,OAAO,IAAI;AAAI,KAAA;IACrF,MAAMC,YAAAA,GAAeJ,SAASK,GAAG,CAACC,oBAAoBC,MAAM,CAAC,CAACC,MAAAA,GAAuCA,MAAAA,KAAWC,SAAAA,CAAAA;AAChH,IAAA,IAAIL,YAAAA,CAAaM,MAAM,GAAG,CAAA,EAAG,OAAON,YAAAA;IAEpC,MAAMO,YAAAA,GAAeC,+BAAoBd,OAAAA,EAAS,SAAA,CAAA,CAC7CO,GAAG,CAAC,CAACG,SAAWF,kBAAAA,CAAmB;YAAUO,UAAAA,EAAYL;AAAO,SAAA,CAAA,CAAA,CAChED,MAAM,CAAC,CAACC,MAAAA,GAAuCA,MAAAA,KAAWC,SAAAA,CAAAA;AAC/D,IAAA,IAAIE,YAAAA,CAAaD,MAAM,GAAG,CAAA,EAAG,OAAOC,YAAAA;IAEpC,MAAMG,SAAAA,GAAYC,+BAAoBjB,OAAAA,EAAS,SAAA,CAAA,CAAWO,GAAG,CAAC,CAACW,SAAW;AAAEA,YAAAA,KAAAA;YAAOC,MAAAA,EAAQD,KAAAA;YAAOE,QAAAA,EAAU;SAAM,CAAA,CAAA;AAClH,IAAA,IAAIJ,SAAAA,CAAUJ,MAAM,GAAG,CAAA,EAAG,OAAOI,SAAAA;AAEjC,IAAA,OAAOK,MAAAA,CAAOC,IAAI,CAACrB,IAAI,CAAC,CAAA,CAAE,IAAI,EAAC,CAAA,CAAGM,GAAG,CAAC,CAACW,SAAW;AAAEA,YAAAA,KAAAA;YAAOC,MAAAA,EAAQD,KAAAA;YAAOE,QAAAA,EAAU;SAAM,CAAA,CAAA;AAC9F;AAEA,SAASZ,mBAAmBR,OAAqB,EAAA;AAC7C,IAAA,MAAMkB,KAAAA,GAAQlB,OAAAA,CAAQe,UAAU,CAACG,KAAK;IACtC,MAAMC,MAAAA,GAASnB,QAAQe,UAAU,CAACI,MAAM,IAAInB,OAAAA,CAAQe,UAAU,CAACQ,KAAK;IACpE,IAAI,OAAOL,KAAAA,KAAU,QAAA,EAAU,OAAOP,SAAAA;IACtC,OAAO;AACHO,QAAAA,KAAAA;QACAC,MAAAA,EAAQ,OAAOA,MAAAA,KAAW,QAAA,GAAWA,MAAAA,GAASD,KAAAA;AAC9CE,QAAAA,QAAAA,EAAUpB,OAAAA,CAAQe,UAAU,CAACK,QAAQ,KAAK;AAC9C,KAAA;AACJ;;;;"}

package/dist/cjs/form/PrimeAutoComplete.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var autocomplete = require('primereact/autocomplete');
+var properties = require('../properties.js');
+
+/**
+ * The `PrimeReact:autoComplete` component - a text field that suggests from a known set as you type.
+ *
+ * AutoComplete has no built-in filtering: it asks the host to produce suggestions through
+ * `completeMethod`, because in a real application that is a server call. A Scene element cannot express
+ * a server call, so the adapter filters the authored `options` case-insensitively instead - enough for
+ * the component to behave like itself in a preview, and honest about where the data came from.
+ */ function PrimeAutoComplete({ element }) {
+    const options = properties.optionsProperty(element, 'options');
+    const [value, setValue] = react.useState(properties.stringProperty(element, 'value', ''));
+    const [suggestions, setSuggestions] = react.useState([]);
+    return /*#__PURE__*/ jsxRuntime.jsx(autocomplete.AutoComplete, {
+        "data-scene-id": element.id,
+        value: value,
+        onChange: (event)=>setValue(typeof event.value === 'string' ? event.value : ''),
+        suggestions: suggestions,
+        completeMethod: (event)=>setSuggestions(options.filter((option)=>option.label.toLowerCase().includes(event.query.toLowerCase())).map((option)=>option.label)),
+        dropdown: properties.booleanProperty(element, 'dropdown', false),
+        placeholder: properties.stringProperty(element, 'placeholder'),
+        disabled: properties.booleanProperty(element, 'disabled', false)
+    });
+}
+
+exports.PrimeAutoComplete = PrimeAutoComplete;
+//# sourceMappingURL=PrimeAutoComplete.js.map

package/dist/cjs/form/PrimeAutoComplete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeAutoComplete.js","sources":["../../../form/PrimeAutoComplete.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 { useState } from 'react';\nimport { AutoComplete } from 'primereact/autocomplete';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, optionsProperty, stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:autoComplete` component - a text field that suggests from a known set as you type.\n *\n * AutoComplete has no built-in filtering: it asks the host to produce suggestions through\n * `completeMethod`, because in a real application that is a server call. A Scene element cannot express\n * a server call, so the adapter filters the authored `options` case-insensitively instead - enough for\n * the component to behave like itself in a preview, and honest about where the data came from.\n */\nexport function PrimeAutoComplete({ element }: RegisteredComponentProps) {\n    const options = optionsProperty(element, 'options');\n    const [value, setValue] = useState(stringProperty(element, 'value', ''));\n    const [suggestions, setSuggestions] = useState<string[]>([]);\n\n    return (\n        <AutoComplete\n            data-scene-id={element.id}\n            value={value}\n            onChange={(event) => setValue(typeof event.value === 'string' ? event.value : '')}\n            suggestions={suggestions}\n            completeMethod={(event) =>\n                setSuggestions(options.filter((option) => option.label.toLowerCase().includes(event.query.toLowerCase())).map((option) => option.label))\n            }\n            dropdown={booleanProperty(element, 'dropdown', false)}\n            placeholder={stringProperty(element, 'placeholder')}\n            disabled={booleanProperty(element, 'disabled', false)}\n        />\n    );\n}\n"],"names":["PrimeAutoComplete","element","options","optionsProperty","value","setValue","useState","stringProperty","suggestions","setSuggestions","_jsx","AutoComplete","data-scene-id","id","onChange","event","completeMethod","filter","option","label","toLowerCase","includes","query","map","dropdown","booleanProperty","placeholder","disabled"],"mappings":";;;;;;;AAQA;;;;;;;AAOC,IACM,SAASA,iBAAAA,CAAkB,EAAEC,OAAO,EAA4B,EAAA;IACnE,MAAMC,OAAAA,GAAUC,2BAAgBF,OAAAA,EAAS,SAAA,CAAA;AACzC,IAAA,MAAM,CAACG,KAAAA,EAAOC,QAAAA,CAAS,GAAGC,cAAAA,CAASC,yBAAAA,CAAeN,SAAS,OAAA,EAAS,EAAA,CAAA,CAAA;AACpE,IAAA,MAAM,CAACO,WAAAA,EAAaC,cAAAA,CAAe,GAAGH,eAAmB,EAAE,CAAA;AAE3D,IAAA,qBACII,cAAA,CAACC,yBAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeX,QAAQY,EAAE;QACzBT,KAAAA,EAAOA,KAAAA;QACPU,QAAAA,EAAU,CAACC,KAAAA,GAAUV,QAAAA,CAAS,OAAOU,KAAAA,CAAMX,KAAK,KAAK,QAAA,GAAWW,KAAAA,CAAMX,KAAK,GAAG,EAAA,CAAA;QAC9EI,WAAAA,EAAaA,WAAAA;QACbQ,cAAAA,EAAgB,CAACD,KAAAA,GACbN,cAAAA,CAAeP,OAAAA,CAAQe,MAAM,CAAC,CAACC,MAAAA,GAAWA,MAAAA,CAAOC,KAAK,CAACC,WAAW,GAAGC,QAAQ,CAACN,KAAAA,CAAMO,KAAK,CAACF,WAAW,EAAA,CAAA,CAAA,CAAKG,GAAG,CAAC,CAACL,MAAAA,GAAWA,MAAAA,CAAOC,KAAK,CAAA,CAAA;QAE1IK,QAAAA,EAAUC,0BAAAA,CAAgBxB,SAAS,UAAA,EAAY,KAAA,CAAA;AAC/CyB,QAAAA,WAAAA,EAAanB,0BAAeN,OAAAA,EAAS,aAAA,CAAA;QACrC0B,QAAAA,EAAUF,0BAAAA,CAAgBxB,SAAS,UAAA,EAAY,KAAA;;AAG3D;;;;"}

package/dist/cjs/form/PrimeCalendar.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var calendar = require('primereact/calendar');
+var properties = require('../properties.js');
+
+/**
+ * The `PrimeReact:calendar` component - a date picker.
+ *
+ * The seed value is parsed from an ISO date string because that is what survives a round trip through a
+ * Scene model's JSON properties; an unparseable one leaves the field empty rather than showing
+ * "Invalid Date".
+ *
+ * In PrimeReact 11 this component is renamed `DatePicker`.
+ */ function PrimeCalendar({ element }) {
+    const [value, setValue] = react.useState(()=>{
+        const seed = properties.stringProperty(element, 'value');
+        if (seed === undefined) return undefined;
+        const parsed = new Date(seed);
+        return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+    });
+    return /*#__PURE__*/ jsxRuntime.jsx(calendar.Calendar, {
+        "data-scene-id": element.id,
+        value: value,
+        onChange: (event)=>setValue(event.value instanceof Date ? event.value : undefined),
+        dateFormat: properties.stringProperty(element, 'dateFormat'),
+        showIcon: properties.booleanProperty(element, 'showIcon', true),
+        showTime: properties.booleanProperty(element, 'showTime', false),
+        inline: properties.booleanProperty(element, 'inline', false),
+        placeholder: properties.stringProperty(element, 'placeholder'),
+        disabled: properties.booleanProperty(element, 'disabled', false)
+    });
+}
+
+exports.PrimeCalendar = PrimeCalendar;
+//# sourceMappingURL=PrimeCalendar.js.map

package/dist/cjs/form/PrimeCalendar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeCalendar.js","sources":["../../../form/PrimeCalendar.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 { useState } from 'react';\nimport { Calendar } from 'primereact/calendar';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:calendar` component - a date picker.\n *\n * The seed value is parsed from an ISO date string because that is what survives a round trip through a\n * Scene model's JSON properties; an unparseable one leaves the field empty rather than showing\n * \"Invalid Date\".\n *\n * In PrimeReact 11 this component is renamed `DatePicker`.\n */\nexport function PrimeCalendar({ element }: RegisteredComponentProps) {\n    const [value, setValue] = useState<Date | undefined>(() => {\n        const seed = stringProperty(element, 'value');\n        if (seed === undefined) return undefined;\n        const parsed = new Date(seed);\n        return Number.isNaN(parsed.getTime()) ? undefined : parsed;\n    });\n\n    return (\n        <Calendar\n            data-scene-id={element.id}\n            value={value}\n            onChange={(event) => setValue(event.value instanceof Date ? event.value : undefined)}\n            dateFormat={stringProperty(element, 'dateFormat')}\n            showIcon={booleanProperty(element, 'showIcon', true)}\n            showTime={booleanProperty(element, 'showTime', false)}\n            inline={booleanProperty(element, 'inline', false)}\n            placeholder={stringProperty(element, 'placeholder')}\n            disabled={booleanProperty(element, 'disabled', false)}\n        />\n    );\n}\n"],"names":["PrimeCalendar","element","value","setValue","useState","seed","stringProperty","undefined","parsed","Date","Number","isNaN","getTime","_jsx","Calendar","data-scene-id","id","onChange","event","dateFormat","showIcon","booleanProperty","showTime","inline","placeholder","disabled"],"mappings":";;;;;;;AAQA;;;;;;;;AAQC,IACM,SAASA,aAAAA,CAAc,EAAEC,OAAO,EAA4B,EAAA;AAC/D,IAAA,MAAM,CAACC,KAAAA,EAAOC,QAAAA,CAAS,GAAGC,cAAAA,CAA2B,IAAA;QACjD,MAAMC,IAAAA,GAAOC,0BAAeL,OAAAA,EAAS,OAAA,CAAA;QACrC,IAAII,IAAAA,KAASE,WAAW,OAAOA,SAAAA;QAC/B,MAAMC,MAAAA,GAAS,IAAIC,IAAAA,CAAKJ,IAAAA,CAAAA;AACxB,QAAA,OAAOK,OAAOC,KAAK,CAACH,MAAAA,CAAOI,OAAO,MAAML,SAAAA,GAAYC,MAAAA;AACxD,IAAA,CAAA,CAAA;AAEA,IAAA,qBACIK,cAAA,CAACC,iBAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAed,QAAQe,EAAE;QACzBd,KAAAA,EAAOA,KAAAA;QACPe,QAAAA,EAAU,CAACC,QAAUf,QAAAA,CAASe,KAAAA,CAAMhB,KAAK,YAAYO,IAAAA,GAAOS,KAAAA,CAAMhB,KAAK,GAAGK,SAAAA,CAAAA;AAC1EY,QAAAA,UAAAA,EAAYb,0BAAeL,OAAAA,EAAS,YAAA,CAAA;QACpCmB,QAAAA,EAAUC,0BAAAA,CAAgBpB,SAAS,UAAA,EAAY,IAAA,CAAA;QAC/CqB,QAAAA,EAAUD,0BAAAA,CAAgBpB,SAAS,UAAA,EAAY,KAAA,CAAA;QAC/CsB,MAAAA,EAAQF,0BAAAA,CAAgBpB,SAAS,QAAA,EAAU,KAAA,CAAA;AAC3CuB,QAAAA,WAAAA,EAAalB,0BAAeL,OAAAA,EAAS,aAAA,CAAA;QACrCwB,QAAAA,EAAUJ,0BAAAA,CAAgBpB,SAAS,UAAA,EAAY,KAAA;;AAG3D;;;;"}

package/dist/cjs/form/PrimeCascadeSelect.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var cascadeselect = require('primereact/cascadeselect');
+var properties = require('../properties.js');
+
+/**
+ * The `PrimeReact:cascadeSelect` component - nested groups revealed one level at a time.
+ *
+ * Options are read as raw records rather than normalized to `SelectOption`, because a cascade is defined
+ * by the nesting itself: `optionGroupChildren` names the property each level recurses into, and
+ * flattening the records would destroy exactly the structure the component exists to show.
+ */ function PrimeCascadeSelect({ element }) {
+    const [value, setValue] = react.useState(properties.stringProperty(element, 'value'));
+    return /*#__PURE__*/ jsxRuntime.jsx(cascadeselect.CascadeSelect, {
+        "data-scene-id": element.id,
+        value: value,
+        onChange: (event)=>setValue(event.value),
+        options: properties.recordArrayProperty(element, 'options'),
+        optionLabel: properties.stringProperty(element, 'optionLabel', 'label'),
+        optionGroupLabel: properties.stringProperty(element, 'optionGroupLabel', 'label'),
+        optionGroupChildren: [
+            properties.stringProperty(element, 'optionGroupChildren', 'items')
+        ],
+        placeholder: properties.stringProperty(element, 'placeholder', 'Select'),
+        disabled: properties.booleanProperty(element, 'disabled', false)
+    });
+}
+
+exports.PrimeCascadeSelect = PrimeCascadeSelect;
+//# sourceMappingURL=PrimeCascadeSelect.js.map

package/dist/cjs/form/PrimeCascadeSelect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeCascadeSelect.js","sources":["../../../form/PrimeCascadeSelect.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 { useState } from 'react';\nimport { CascadeSelect } from 'primereact/cascadeselect';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, recordArrayProperty, stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:cascadeSelect` component - nested groups revealed one level at a time.\n *\n * Options are read as raw records rather than normalized to `SelectOption`, because a cascade is defined\n * by the nesting itself: `optionGroupChildren` names the property each level recurses into, and\n * flattening the records would destroy exactly the structure the component exists to show.\n */\nexport function PrimeCascadeSelect({ element }: RegisteredComponentProps) {\n    const [value, setValue] = useState<unknown>(stringProperty(element, 'value'));\n    return (\n        <CascadeSelect\n            data-scene-id={element.id}\n            value={value}\n            onChange={(event) => setValue(event.value)}\n            options={recordArrayProperty(element, 'options')}\n            optionLabel={stringProperty(element, 'optionLabel', 'label')}\n            optionGroupLabel={stringProperty(element, 'optionGroupLabel', 'label')}\n            optionGroupChildren={[stringProperty(element, 'optionGroupChildren', 'items')]}\n            placeholder={stringProperty(element, 'placeholder', 'Select')}\n            disabled={booleanProperty(element, 'disabled', false)}\n        />\n    );\n}\n"],"names":["PrimeCascadeSelect","element","value","setValue","useState","stringProperty","_jsx","CascadeSelect","data-scene-id","id","onChange","event","options","recordArrayProperty","optionLabel","optionGroupLabel","optionGroupChildren","placeholder","disabled","booleanProperty"],"mappings":";;;;;;;AAQA;;;;;;AAMC,IACM,SAASA,kBAAAA,CAAmB,EAAEC,OAAO,EAA4B,EAAA;AACpE,IAAA,MAAM,CAACC,KAAAA,EAAOC,QAAAA,CAAS,GAAGC,cAAAA,CAAkBC,0BAAeJ,OAAAA,EAAS,OAAA,CAAA,CAAA;AACpE,IAAA,qBACIK,cAAA,CAACC,2BAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeP,QAAQQ,EAAE;QACzBP,KAAAA,EAAOA,KAAAA;AACPQ,QAAAA,QAAAA,EAAU,CAACC,KAAAA,GAAUR,QAAAA,CAASQ,KAAAA,CAAMT,KAAK,CAAA;AACzCU,QAAAA,OAAAA,EAASC,+BAAoBZ,OAAAA,EAAS,SAAA,CAAA;QACtCa,WAAAA,EAAaT,yBAAAA,CAAeJ,SAAS,aAAA,EAAe,OAAA,CAAA;QACpDc,gBAAAA,EAAkBV,yBAAAA,CAAeJ,SAAS,kBAAA,EAAoB,OAAA,CAAA;QAC9De,mBAAAA,EAAqB;AAACX,YAAAA,yBAAAA,CAAeJ,SAAS,qBAAA,EAAuB,OAAA;AAAS,SAAA;QAC9EgB,WAAAA,EAAaZ,yBAAAA,CAAeJ,SAAS,aAAA,EAAe,QAAA,CAAA;QACpDiB,QAAAA,EAAUC,0BAAAA,CAAgBlB,SAAS,UAAA,EAAY,KAAA;;AAG3D;;;;"}

package/dist/cjs/form/PrimeCheckbox.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var checkbox = require('primereact/checkbox');
+var properties = require('../properties.js');
+
+/**
+ * The `PrimeReact:checkbox` component.
+ *
+ * Rendered with its label rather than bare: an unlabeled checkbox has no accessible name and nothing to
+ * click but a 20-pixel box, which is a defect in every screen that would ever use one.
+ */ function PrimeCheckbox({ element }) {
+    const [checked, setChecked] = react.useState(properties.booleanProperty(element, 'checked', false));
+    const label = properties.stringProperty(element, 'label');
+    return /*#__PURE__*/ jsxRuntime.jsxs("div", {
+        "data-scene-id": element.id,
+        className: "flex items-center gap-2",
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsx(checkbox.Checkbox, {
+                inputId: element.id,
+                checked: checked,
+                onChange: (event)=>setChecked(event.checked === true),
+                disabled: properties.booleanProperty(element, 'disabled', false)
+            }),
+            label !== undefined && /*#__PURE__*/ jsxRuntime.jsx("label", {
+                htmlFor: element.id,
+                children: label
+            })
+        ]
+    });
+}
+
+exports.PrimeCheckbox = PrimeCheckbox;
+//# sourceMappingURL=PrimeCheckbox.js.map

package/dist/cjs/form/PrimeCheckbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeCheckbox.js","sources":["../../../form/PrimeCheckbox.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 { useState } from 'react';\nimport { Checkbox } from 'primereact/checkbox';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:checkbox` component.\n *\n * Rendered with its label rather than bare: an unlabeled checkbox has no accessible name and nothing to\n * click but a 20-pixel box, which is a defect in every screen that would ever use one.\n */\nexport function PrimeCheckbox({ element }: RegisteredComponentProps) {\n    const [checked, setChecked] = useState(booleanProperty(element, 'checked', false));\n    const label = stringProperty(element, 'label');\n    return (\n        <div data-scene-id={element.id} className='flex items-center gap-2'>\n            <Checkbox\n                inputId={element.id}\n                checked={checked}\n                onChange={(event) => setChecked(event.checked === true)}\n                disabled={booleanProperty(element, 'disabled', false)}\n            />\n            {label !== undefined && <label htmlFor={element.id}>{label}</label>}\n        </div>\n    );\n}\n"],"names":["PrimeCheckbox","element","checked","setChecked","useState","booleanProperty","label","stringProperty","_jsxs","div","data-scene-id","id","className","_jsx","Checkbox","inputId","onChange","event","disabled","undefined","htmlFor"],"mappings":";;;;;;;AAQA;;;;;AAKC,IACM,SAASA,aAAAA,CAAc,EAAEC,OAAO,EAA4B,EAAA;AAC/D,IAAA,MAAM,CAACC,OAAAA,EAASC,UAAAA,CAAW,GAAGC,cAAAA,CAASC,0BAAAA,CAAgBJ,SAAS,SAAA,EAAW,KAAA,CAAA,CAAA;IAC3E,MAAMK,KAAAA,GAAQC,0BAAeN,OAAAA,EAAS,OAAA,CAAA;AACtC,IAAA,qBACIO,eAAA,CAACC,KAAAA,EAAAA;AAAIC,QAAAA,eAAAA,EAAeT,QAAQU,EAAE;QAAEC,SAAAA,EAAU,yBAAA;;0BACtCC,cAAA,CAACC,iBAAAA,EAAAA;AACGC,gBAAAA,OAAAA,EAASd,QAAQU,EAAE;gBACnBT,OAAAA,EAASA,OAAAA;AACTc,gBAAAA,QAAAA,EAAU,CAACC,KAAAA,GAAUd,UAAAA,CAAWc,KAAAA,CAAMf,OAAO,KAAK,IAAA,CAAA;gBAClDgB,QAAAA,EAAUb,0BAAAA,CAAgBJ,SAAS,UAAA,EAAY,KAAA;;AAElDK,YAAAA,KAAAA,KAAUa,2BAAaN,cAAA,CAACP,OAAAA,EAAAA;AAAMc,gBAAAA,OAAAA,EAASnB,QAAQU,EAAE;AAAGL,gBAAAA,QAAAA,EAAAA;;;;AAGjE;;;;"}

package/dist/cjs/form/PrimeChips.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var chips = require('primereact/chips');
+var properties = require('../properties.js');
+
+/**
+ * The `PrimeReact:chips` component - free-form entry of a list of short values, each shown as a chip.
+ *
+ * In PrimeReact 11 this component is renamed `InputTags`.
+ */ function PrimeChips({ element }) {
+    const [value, setValue] = react.useState(properties.stringArrayProperty(element, 'value'));
+    return /*#__PURE__*/ jsxRuntime.jsx(chips.Chips, {
+        "data-scene-id": element.id,
+        value: value,
+        onChange: (event)=>setValue(event.value ?? []),
+        max: undefined,
+        placeholder: properties.stringProperty(element, 'placeholder'),
+        disabled: properties.booleanProperty(element, 'disabled', false)
+    });
+}
+
+exports.PrimeChips = PrimeChips;
+//# sourceMappingURL=PrimeChips.js.map

package/dist/cjs/form/PrimeChips.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeChips.js","sources":["../../../form/PrimeChips.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 { useState } from 'react';\nimport { Chips } from 'primereact/chips';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, stringArrayProperty, stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:chips` component - free-form entry of a list of short values, each shown as a chip.\n *\n * In PrimeReact 11 this component is renamed `InputTags`.\n */\nexport function PrimeChips({ element }: RegisteredComponentProps) {\n    const [value, setValue] = useState<string[]>(stringArrayProperty(element, 'value'));\n    return (\n        <Chips\n            data-scene-id={element.id}\n            value={value}\n            onChange={(event) => setValue(event.value ?? [])}\n            max={undefined}\n            placeholder={stringProperty(element, 'placeholder')}\n            disabled={booleanProperty(element, 'disabled', false)}\n        />\n    );\n}\n"],"names":["PrimeChips","element","value","setValue","useState","stringArrayProperty","_jsx","Chips","data-scene-id","id","onChange","event","max","undefined","placeholder","stringProperty","disabled","booleanProperty"],"mappings":";;;;;;;AAQA;;;;AAIC,IACM,SAASA,UAAAA,CAAW,EAAEC,OAAO,EAA4B,EAAA;AAC5D,IAAA,MAAM,CAACC,KAAAA,EAAOC,QAAAA,CAAS,GAAGC,cAAAA,CAAmBC,+BAAoBJ,OAAAA,EAAS,OAAA,CAAA,CAAA;AAC1E,IAAA,qBACIK,cAAA,CAACC,WAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeP,QAAQQ,EAAE;QACzBP,KAAAA,EAAOA,KAAAA;AACPQ,QAAAA,QAAAA,EAAU,CAACC,KAAAA,GAAUR,QAAAA,CAASQ,KAAAA,CAAMT,KAAK,IAAI,EAAE,CAAA;QAC/CU,GAAAA,EAAKC,SAAAA;AACLC,QAAAA,WAAAA,EAAaC,0BAAed,OAAAA,EAAS,aAAA,CAAA;QACrCe,QAAAA,EAAUC,0BAAAA,CAAgBhB,SAAS,UAAA,EAAY,KAAA;;AAG3D;;;;"}