@cratis/scene.components 0.1.0

package/dist/cjs/data/SceneObservableDataTable.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var BindingKind = require('../bindings/BindingKind.js');
+var resolveElementBinding = require('../bindings/resolveElementBinding.js');
+var MissingBinding = require('../bindings/MissingBinding.js');
+var ArcRuntimeBoundary = require('../bindings/ArcRuntimeBoundary.js');
+var properties = require('../properties.js');
+
+const DataTableForObservableQuery = /*#__PURE__*/ react.lazy(async ()=>({
+        default: (await import('@cratis/components/DataTables')).DataTableForObservableQuery
+    }));
+/**
+ * The `Cratis.Components:observableDataTable` component - `DataTableForObservableQuery` from
+ * `@cratis/components/DataTables`.
+ *
+ * A separate name rather than a flag on `dataTable`, because the distinction is in the *proxy* a host
+ * registers, not in how the table is configured: an observable query opens a WebSocket subscription and
+ * re-renders when the server's read model changes, and a plain query does not. A screen that names an
+ * observable query here is stating that its data is live, which is a design decision worth being able to
+ * read off the screen.
+ */ function SceneObservableDataTable({ element, slots }) {
+    const { name, target } = resolveElementBinding.resolveElementBinding(element, BindingKind.BindingKind.Query);
+    if (!target) return /*#__PURE__*/ jsxRuntime.jsx(MissingBinding.MissingBinding, {
+        element: element,
+        kind: BindingKind.BindingKind.Query,
+        name: name
+    });
+    return /*#__PURE__*/ jsxRuntime.jsx(ArcRuntimeBoundary.ArcRuntimeBoundary, {
+        children: /*#__PURE__*/ jsxRuntime.jsx(DataTableForObservableQuery, {
+            query: target,
+            emptyMessage: properties.stringProperty(element.properties, 'emptyMessage') ?? '',
+            dataKey: properties.stringProperty(element.properties, 'dataKey'),
+            globalFilterFields: properties.stringArrayProperty(element.properties, 'globalFilterFields'),
+            clientFiltering: properties.booleanProperty(element.properties, 'clientFiltering'),
+            className: properties.stringProperty(element.properties, 'className'),
+            children: slots.content
+        })
+    });
+}
+
+exports.SceneObservableDataTable = SceneObservableDataTable;
+//# sourceMappingURL=SceneObservableDataTable.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SceneObservableDataTable.js","sources":["../../../data/SceneObservableDataTable.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 { lazy } from 'react';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { ArcRuntimeBoundary, BindingKind, MissingBinding, resolveElementBinding } from '../bindings';\nimport { booleanProperty, stringArrayProperty, stringProperty } from '../properties';\n\nconst DataTableForObservableQuery = lazy(async () => ({\n    default: (await import('@cratis/components/DataTables')).DataTableForObservableQuery,\n}));\n\n/**\n * The `Cratis.Components:observableDataTable` component - `DataTableForObservableQuery` from\n * `@cratis/components/DataTables`.\n *\n * A separate name rather than a flag on `dataTable`, because the distinction is in the *proxy* a host\n * registers, not in how the table is configured: an observable query opens a WebSocket subscription and\n * re-renders when the server's read model changes, and a plain query does not. A screen that names an\n * observable query here is stating that its data is live, which is a design decision worth being able to\n * read off the screen.\n */\nexport function SceneObservableDataTable({ element, slots }: RegisteredComponentProps) {\n    const { name, target } = resolveElementBinding(element, BindingKind.Query);\n    if (!target) return <MissingBinding element={element} kind={BindingKind.Query} name={name} />;\n\n    return (\n        <ArcRuntimeBoundary>\n            <DataTableForObservableQuery\n                query={target}\n                emptyMessage={stringProperty(element.properties, 'emptyMessage') ?? ''}\n                dataKey={stringProperty(element.properties, 'dataKey')}\n                globalFilterFields={stringArrayProperty(element.properties, 'globalFilterFields')}\n                clientFiltering={booleanProperty(element.properties, 'clientFiltering')}\n                className={stringProperty(element.properties, 'className')}\n            >\n                {slots.content}\n            </DataTableForObservableQuery>\n        </ArcRuntimeBoundary>\n    );\n}\n"],"names":["DataTableForObservableQuery","lazy","default","SceneObservableDataTable","element","slots","name","target","resolveElementBinding","BindingKind","Query","_jsx","MissingBinding","kind","ArcRuntimeBoundary","query","emptyMessage","stringProperty","properties","dataKey","globalFilterFields","stringArrayProperty","clientFiltering","booleanProperty","className","content"],"mappings":";;;;;;;;;;AAQA,MAAMA,2BAAAA,iBAA8BC,UAAAA,CAAK,WAAa;AAClDC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,+BAAA,CAA+B,EAAGF;KAC7D,CAAA,CAAA;AAEA;;;;;;;;;AASC,IACM,SAASG,wBAAAA,CAAyB,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;IACjF,MAAM,EAAEC,IAAI,EAAEC,MAAM,EAAE,GAAGC,2CAAAA,CAAsBJ,OAAAA,EAASK,uBAAAA,CAAYC,KAAK,CAAA;IACzE,IAAI,CAACH,MAAAA,EAAQ,qBAAOI,cAAA,CAACC,6BAAAA,EAAAA;QAAeR,OAAAA,EAASA,OAAAA;AAASS,QAAAA,IAAAA,EAAMJ,wBAAYC,KAAK;QAAEJ,IAAAA,EAAMA;;AAErF,IAAA,qBACIK,cAAA,CAACG,qCAAAA,EAAAA;AACG,QAAA,QAAA,gBAAAH,cAAA,CAACX,2BAAAA,EAAAA;YACGe,KAAAA,EAAOR,MAAAA;AACPS,YAAAA,YAAAA,EAAcC,yBAAAA,CAAeb,OAAAA,CAAQc,UAAU,EAAE,cAAA,CAAA,IAAmB,EAAA;YACpEC,OAAAA,EAASF,yBAAAA,CAAeb,OAAAA,CAAQc,UAAU,EAAE,SAAA,CAAA;YAC5CE,kBAAAA,EAAoBC,8BAAAA,CAAoBjB,OAAAA,CAAQc,UAAU,EAAE,oBAAA,CAAA;YAC5DI,eAAAA,EAAiBC,0BAAAA,CAAgBnB,OAAAA,CAAQc,UAAU,EAAE,iBAAA,CAAA;YACrDM,SAAAA,EAAWP,yBAAAA,CAAeb,OAAAA,CAAQc,UAAU,EAAE,WAAA,CAAA;AAE7Cb,YAAAA,QAAAA,EAAAA,KAAAA,CAAMoB;;;AAIvB;;;;"}

package/dist/cjs/dialogs/SceneBusyIndicatorDialog.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+require('../bindings/resolveElementBinding.js');
+var ArcRuntimeBoundary = require('../bindings/ArcRuntimeBoundary.js');
+var properties = require('../properties.js');
+
+const BusyIndicatorDialog = /*#__PURE__*/ react.lazy(async ()=>({
+        default: (await import('@cratis/components/Dialogs')).BusyIndicatorDialog
+    }));
+/**
+ * The `Cratis.Components:busyIndicatorDialog` component - `BusyIndicatorDialog` from
+ * `@cratis/components/Dialogs`.
+ *
+ * The blocking spinner shown while a long-running command is in flight. In a running application it is
+ * the Arc dialog host that renders it, threading its own `title` and `message` through; exposing it as a
+ * Scene component is what lets a screen show the same chrome at design time, so its wording and
+ * placement can be designed rather than discovered the first time an operation takes a while.
+ */ function SceneBusyIndicatorDialog({ element }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(ArcRuntimeBoundary.ArcRuntimeBoundary, {
+        children: /*#__PURE__*/ jsxRuntime.jsx(BusyIndicatorDialog, {
+            title: properties.stringProperty(element.properties, 'title') ?? '',
+            message: properties.stringProperty(element.properties, 'message') ?? ''
+        })
+    });
+}
+
+exports.SceneBusyIndicatorDialog = SceneBusyIndicatorDialog;
+//# sourceMappingURL=SceneBusyIndicatorDialog.js.map

package/dist/cjs/dialogs/SceneBusyIndicatorDialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneBusyIndicatorDialog.js","sources":["../../../dialogs/SceneBusyIndicatorDialog.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 { lazy } from 'react';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { ArcRuntimeBoundary } from '../bindings';\nimport { stringProperty } from '../properties';\n\nconst BusyIndicatorDialog = lazy(async () => ({ default: (await import('@cratis/components/Dialogs')).BusyIndicatorDialog }));\n\n/**\n * The `Cratis.Components:busyIndicatorDialog` component - `BusyIndicatorDialog` from\n * `@cratis/components/Dialogs`.\n *\n * The blocking spinner shown while a long-running command is in flight. In a running application it is\n * the Arc dialog host that renders it, threading its own `title` and `message` through; exposing it as a\n * Scene component is what lets a screen show the same chrome at design time, so its wording and\n * placement can be designed rather than discovered the first time an operation takes a while.\n */\nexport function SceneBusyIndicatorDialog({ element }: RegisteredComponentProps) {\n    return (\n        <ArcRuntimeBoundary>\n            <BusyIndicatorDialog\n                title={stringProperty(element.properties, 'title') ?? ''}\n                message={stringProperty(element.properties, 'message') ?? ''}\n            />\n        </ArcRuntimeBoundary>\n    );\n}\n"],"names":["BusyIndicatorDialog","lazy","default","SceneBusyIndicatorDialog","element","_jsx","ArcRuntimeBoundary","title","stringProperty","properties","message"],"mappings":";;;;;;;;AAQA,MAAMA,mBAAAA,iBAAsBC,UAAAA,CAAK,WAAa;AAAEC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,4BAAA,CAA4B,EAAGF;KAAoB,CAAA,CAAA;AAE1H;;;;;;;;AAQC,IACM,SAASG,wBAAAA,CAAyB,EAAEC,OAAO,EAA4B,EAAA;AAC1E,IAAA,qBACIC,cAAA,CAACC,qCAAAA,EAAAA;AACG,QAAA,QAAA,gBAAAD,cAAA,CAACL,mBAAAA,EAAAA;AACGO,YAAAA,KAAAA,EAAOC,yBAAAA,CAAeJ,OAAAA,CAAQK,UAAU,EAAE,OAAA,CAAA,IAAY,EAAA;AACtDC,YAAAA,OAAAA,EAASF,yBAAAA,CAAeJ,OAAAA,CAAQK,UAAU,EAAE,SAAA,CAAA,IAAc;;;AAI1E;;;;"}

package/dist/cjs/dialogs/SceneCommandDialog.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var BindingKind = require('../bindings/BindingKind.js');
+var resolveElementBinding = require('../bindings/resolveElementBinding.js');
+var MissingBinding = require('../bindings/MissingBinding.js');
+var ArcRuntimeBoundary = require('../bindings/ArcRuntimeBoundary.js');
+var properties = require('../properties.js');
+
+const CommandDialog = /*#__PURE__*/ react.lazy(async ()=>({
+        default: (await import('@cratis/components/CommandDialog')).CommandDialog
+    }));
+/**
+ * The `Cratis.Components:commandDialog` component - `CommandDialog` from `@cratis/components/CommandDialog`.
+ *
+ * A dialog whose confirm button *is* the command's execution: it binds the form to the command, submits
+ * on confirm, feeds the backend's validation results back onto the fields, and only closes when the
+ * command succeeded. That last part is the reason to use it rather than composing `dialog` with
+ * `commandForm` - a hand-composed pair has no way to keep the dialog open on a rejected command without
+ * reimplementing the protocol.
+ *
+ * The `command` property names an Arc command proxy; the fields go in the `content` slot.
+ */ function SceneCommandDialog({ element, slots }) {
+    const { name, target } = resolveElementBinding.resolveElementBinding(element, BindingKind.BindingKind.Command);
+    if (!target) return /*#__PURE__*/ jsxRuntime.jsx(MissingBinding.MissingBinding, {
+        element: element,
+        kind: BindingKind.BindingKind.Command,
+        name: name
+    });
+    return /*#__PURE__*/ jsxRuntime.jsx(ArcRuntimeBoundary.ArcRuntimeBoundary, {
+        children: /*#__PURE__*/ jsxRuntime.jsx(CommandDialog, {
+            title: properties.stringProperty(element.properties, 'title') ?? '',
+            command: target,
+            visible: properties.booleanProperty(element.properties, 'visible') ?? true,
+            width: properties.stringProperty(element.properties, 'width'),
+            resizable: properties.booleanProperty(element.properties, 'resizable'),
+            okLabel: properties.stringProperty(element.properties, 'okLabel'),
+            cancelLabel: properties.stringProperty(element.properties, 'cancelLabel'),
+            className: properties.stringProperty(element.properties, 'className'),
+            children: slots.content
+        })
+    });
+}
+
+exports.SceneCommandDialog = SceneCommandDialog;
+//# sourceMappingURL=SceneCommandDialog.js.map

package/dist/cjs/dialogs/SceneCommandDialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneCommandDialog.js","sources":["../../../dialogs/SceneCommandDialog.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 { lazy } from 'react';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { ArcRuntimeBoundary, BindingKind, MissingBinding, resolveElementBinding } from '../bindings';\nimport { booleanProperty, stringProperty } from '../properties';\n\nconst CommandDialog = lazy(async () => ({ default: (await import('@cratis/components/CommandDialog')).CommandDialog }));\n\n/**\n * The `Cratis.Components:commandDialog` component - `CommandDialog` from `@cratis/components/CommandDialog`.\n *\n * A dialog whose confirm button *is* the command's execution: it binds the form to the command, submits\n * on confirm, feeds the backend's validation results back onto the fields, and only closes when the\n * command succeeded. That last part is the reason to use it rather than composing `dialog` with\n * `commandForm` - a hand-composed pair has no way to keep the dialog open on a rejected command without\n * reimplementing the protocol.\n *\n * The `command` property names an Arc command proxy; the fields go in the `content` slot.\n */\nexport function SceneCommandDialog({ element, slots }: RegisteredComponentProps) {\n    const { name, target } = resolveElementBinding(element, BindingKind.Command);\n    if (!target) return <MissingBinding element={element} kind={BindingKind.Command} name={name} />;\n\n    return (\n        <ArcRuntimeBoundary>\n            <CommandDialog\n                title={stringProperty(element.properties, 'title') ?? ''}\n                command={target}\n                visible={booleanProperty(element.properties, 'visible') ?? true}\n                width={stringProperty(element.properties, 'width')}\n                resizable={booleanProperty(element.properties, 'resizable')}\n                okLabel={stringProperty(element.properties, 'okLabel')}\n                cancelLabel={stringProperty(element.properties, 'cancelLabel')}\n                className={stringProperty(element.properties, 'className')}\n            >\n                {slots.content}\n            </CommandDialog>\n        </ArcRuntimeBoundary>\n    );\n}\n"],"names":["CommandDialog","lazy","default","SceneCommandDialog","element","slots","name","target","resolveElementBinding","BindingKind","Command","_jsx","MissingBinding","kind","ArcRuntimeBoundary","title","stringProperty","properties","command","visible","booleanProperty","width","resizable","okLabel","cancelLabel","className","content"],"mappings":";;;;;;;;;;AAQA,MAAMA,aAAAA,iBAAgBC,UAAAA,CAAK,WAAa;AAAEC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,kCAAA,CAAkC,EAAGF;KAAc,CAAA,CAAA;AAEpH;;;;;;;;;;AAUC,IACM,SAASG,kBAAAA,CAAmB,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;IAC3E,MAAM,EAAEC,IAAI,EAAEC,MAAM,EAAE,GAAGC,2CAAAA,CAAsBJ,OAAAA,EAASK,uBAAAA,CAAYC,OAAO,CAAA;IAC3E,IAAI,CAACH,MAAAA,EAAQ,qBAAOI,cAAA,CAACC,6BAAAA,EAAAA;QAAeR,OAAAA,EAASA,OAAAA;AAASS,QAAAA,IAAAA,EAAMJ,wBAAYC,OAAO;QAAEJ,IAAAA,EAAMA;;AAEvF,IAAA,qBACIK,cAAA,CAACG,qCAAAA,EAAAA;AACG,QAAA,QAAA,gBAAAH,cAAA,CAACX,aAAAA,EAAAA;AACGe,YAAAA,KAAAA,EAAOC,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,OAAA,CAAA,IAAY,EAAA;YACtDC,OAAAA,EAASX,MAAAA;AACTY,YAAAA,OAAAA,EAASC,0BAAAA,CAAgBhB,OAAAA,CAAQa,UAAU,EAAE,SAAA,CAAA,IAAc,IAAA;YAC3DI,KAAAA,EAAOL,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,OAAA,CAAA;YAC1CK,SAAAA,EAAWF,0BAAAA,CAAgBhB,OAAAA,CAAQa,UAAU,EAAE,WAAA,CAAA;YAC/CM,OAAAA,EAASP,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,SAAA,CAAA;YAC5CO,WAAAA,EAAaR,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,aAAA,CAAA;YAChDQ,SAAAA,EAAWT,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,WAAA,CAAA;AAE7CZ,YAAAA,QAAAA,EAAAA,KAAAA,CAAMqB;;;AAIvB;;;;"}

package/dist/cjs/dialogs/SceneConfirmationDialog.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+require('../bindings/resolveElementBinding.js');
+var ArcRuntimeBoundary = require('../bindings/ArcRuntimeBoundary.js');
+
+const ConfirmationDialog = /*#__PURE__*/ react.lazy(async ()=>({
+        default: (await import('@cratis/components/Dialogs')).ConfirmationDialog
+    }));
+/**
+ * The `Cratis.Components:confirmationDialog` component - `ConfirmationDialog` from
+ * `@cratis/components/Dialogs`.
+ *
+ * Takes no properties by design: it is not a dialog a screen configures, it is the host that renders
+ * whatever confirmation the running application has asked for through Arc's dialog service. A screen
+ * places it once, near the root, and every `Are you sure?` in the application appears there.
+ */ function SceneConfirmationDialog() {
+    return /*#__PURE__*/ jsxRuntime.jsx(ArcRuntimeBoundary.ArcRuntimeBoundary, {
+        children: /*#__PURE__*/ jsxRuntime.jsx(ConfirmationDialog, {})
+    });
+}
+
+exports.SceneConfirmationDialog = SceneConfirmationDialog;
+//# sourceMappingURL=SceneConfirmationDialog.js.map

package/dist/cjs/dialogs/SceneConfirmationDialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneConfirmationDialog.js","sources":["../../../dialogs/SceneConfirmationDialog.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 { lazy } from 'react';\nimport { ArcRuntimeBoundary } from '../bindings';\n\nconst ConfirmationDialog = lazy(async () => ({ default: (await import('@cratis/components/Dialogs')).ConfirmationDialog }));\n\n/**\n * The `Cratis.Components:confirmationDialog` component - `ConfirmationDialog` from\n * `@cratis/components/Dialogs`.\n *\n * Takes no properties by design: it is not a dialog a screen configures, it is the host that renders\n * whatever confirmation the running application has asked for through Arc's dialog service. A screen\n * places it once, near the root, and every `Are you sure?` in the application appears there.\n */\nexport function SceneConfirmationDialog() {\n    return (\n        <ArcRuntimeBoundary>\n            <ConfirmationDialog />\n        </ArcRuntimeBoundary>\n    );\n}\n"],"names":["ConfirmationDialog","lazy","default","SceneConfirmationDialog","_jsx","ArcRuntimeBoundary"],"mappings":";;;;;;;AAMA,MAAMA,kBAAAA,iBAAqBC,UAAAA,CAAK,WAAa;AAAEC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,4BAAA,CAA4B,EAAGF;KAAmB,CAAA,CAAA;AAExH;;;;;;;AAOC,IACM,SAASG,uBAAAA,GAAAA;AACZ,IAAA,qBACIC,cAAA,CAACC,qCAAAA,EAAAA;AACG,QAAA,QAAA,gBAAAD,cAAA,CAACJ,kBAAAA,EAAAA,EAAAA;;AAGb;;;;"}

package/dist/cjs/dialogs/SceneDialog.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+require('../bindings/resolveElementBinding.js');
+var ArcRuntimeBoundary = require('../bindings/ArcRuntimeBoundary.js');
+var properties = require('../properties.js');
+
+const Dialog = /*#__PURE__*/ react.lazy(async ()=>({
+        default: (await import('@cratis/components/Dialogs')).Dialog
+    }));
+/**
+ * The `Cratis.Components:dialog` component, registered under the bare name `dialog` - `Dialog` from
+ * `@cratis/components/Dialogs`.
+ *
+ * Shadowing PrimeReact's `dialog` deliberately. PrimeReact's is a modal frame and nothing more; this one
+ * resolves its result through Arc's dialog context, so a screen's dialog participates in the same
+ * request/response protocol as the rest of the application - a caller awaits a `DialogResult` instead of
+ * threading `visible` state and callbacks by hand.
+ *
+ * `visible` defaults to `true` because a dialog placed on a screen is being placed to be seen; a host
+ * that controls visibility sets the property explicitly.
+ */ function SceneDialog({ element, slots }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(ArcRuntimeBoundary.ArcRuntimeBoundary, {
+        children: /*#__PURE__*/ jsxRuntime.jsx(Dialog, {
+            title: properties.stringProperty(element.properties, 'title') ?? '',
+            visible: properties.booleanProperty(element.properties, 'visible') ?? true,
+            width: properties.stringProperty(element.properties, 'width'),
+            resizable: properties.booleanProperty(element.properties, 'resizable'),
+            isValid: properties.booleanProperty(element.properties, 'isValid'),
+            isBusy: properties.booleanProperty(element.properties, 'isBusy'),
+            okLabel: properties.stringProperty(element.properties, 'okLabel'),
+            cancelLabel: properties.stringProperty(element.properties, 'cancelLabel'),
+            className: properties.stringProperty(element.properties, 'className'),
+            children: slots.content
+        })
+    });
+}
+
+exports.SceneDialog = SceneDialog;
+//# sourceMappingURL=SceneDialog.js.map

package/dist/cjs/dialogs/SceneDialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneDialog.js","sources":["../../../dialogs/SceneDialog.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 { lazy } from 'react';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { ArcRuntimeBoundary } from '../bindings';\nimport { booleanProperty, stringProperty } from '../properties';\n\nconst Dialog = lazy(async () => ({ default: (await import('@cratis/components/Dialogs')).Dialog }));\n\n/**\n * The `Cratis.Components:dialog` component, registered under the bare name `dialog` - `Dialog` from\n * `@cratis/components/Dialogs`.\n *\n * Shadowing PrimeReact's `dialog` deliberately. PrimeReact's is a modal frame and nothing more; this one\n * resolves its result through Arc's dialog context, so a screen's dialog participates in the same\n * request/response protocol as the rest of the application - a caller awaits a `DialogResult` instead of\n * threading `visible` state and callbacks by hand.\n *\n * `visible` defaults to `true` because a dialog placed on a screen is being placed to be seen; a host\n * that controls visibility sets the property explicitly.\n */\nexport function SceneDialog({ element, slots }: RegisteredComponentProps) {\n    return (\n        <ArcRuntimeBoundary>\n            <Dialog\n                title={stringProperty(element.properties, 'title') ?? ''}\n                visible={booleanProperty(element.properties, 'visible') ?? true}\n                width={stringProperty(element.properties, 'width')}\n                resizable={booleanProperty(element.properties, 'resizable')}\n                isValid={booleanProperty(element.properties, 'isValid')}\n                isBusy={booleanProperty(element.properties, 'isBusy')}\n                okLabel={stringProperty(element.properties, 'okLabel')}\n                cancelLabel={stringProperty(element.properties, 'cancelLabel')}\n                className={stringProperty(element.properties, 'className')}\n            >\n                {slots.content}\n            </Dialog>\n        </ArcRuntimeBoundary>\n    );\n}\n"],"names":["Dialog","lazy","default","SceneDialog","element","slots","_jsx","ArcRuntimeBoundary","title","stringProperty","properties","visible","booleanProperty","width","resizable","isValid","isBusy","okLabel","cancelLabel","className","content"],"mappings":";;;;;;;;AAQA,MAAMA,MAAAA,iBAASC,UAAAA,CAAK,WAAa;AAAEC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,4BAAA,CAA4B,EAAGF;KAAO,CAAA,CAAA;AAEhG;;;;;;;;;;;AAWC,IACM,SAASG,WAAAA,CAAY,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;AACpE,IAAA,qBACIC,cAAA,CAACC,qCAAAA,EAAAA;AACG,QAAA,QAAA,gBAAAD,cAAA,CAACN,MAAAA,EAAAA;AACGQ,YAAAA,KAAAA,EAAOC,yBAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,OAAA,CAAA,IAAY,EAAA;AACtDC,YAAAA,OAAAA,EAASC,0BAAAA,CAAgBR,OAAAA,CAAQM,UAAU,EAAE,SAAA,CAAA,IAAc,IAAA;YAC3DG,KAAAA,EAAOJ,yBAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,OAAA,CAAA;YAC1CI,SAAAA,EAAWF,0BAAAA,CAAgBR,OAAAA,CAAQM,UAAU,EAAE,WAAA,CAAA;YAC/CK,OAAAA,EAASH,0BAAAA,CAAgBR,OAAAA,CAAQM,UAAU,EAAE,SAAA,CAAA;YAC7CM,MAAAA,EAAQJ,0BAAAA,CAAgBR,OAAAA,CAAQM,UAAU,EAAE,QAAA,CAAA;YAC5CO,OAAAA,EAASR,yBAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,SAAA,CAAA;YAC5CQ,WAAAA,EAAaT,yBAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,aAAA,CAAA;YAChDS,SAAAA,EAAWV,yBAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,WAAA,CAAA;AAE7CL,YAAAA,QAAAA,EAAAA,KAAAA,CAAMe;;;AAIvB;;;;"}

package/dist/cjs/dialogs/SceneStepperCommandDialog.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var BindingKind = require('../bindings/BindingKind.js');
+var resolveElementBinding = require('../bindings/resolveElementBinding.js');
+var MissingBinding = require('../bindings/MissingBinding.js');
+var ArcRuntimeBoundary = require('../bindings/ArcRuntimeBoundary.js');
+var properties = require('../properties.js');
+
+const StepperCommandDialog = /*#__PURE__*/ react.lazy(async ()=>({
+        default: (await import('@cratis/components/CommandDialog')).StepperCommandDialog
+    }));
+/** Whether the step headers run across the top or down the side. */ const orientations = [
+    'horizontal',
+    'vertical'
+];
+/**
+ * The `Cratis.Components:stepperCommandDialog` component - `StepperCommandDialog` from
+ * `@cratis/components/CommandDialog`.
+ *
+ * `commandDialog` split across steps, for a command with more fields than fit one screen. It stays a
+ * single command: the steps partition the *fields*, not the intent, and nothing is submitted until the
+ * last step - so a half-finished wizard leaves no trace, which is exactly what a command should do.
+ *
+ * `linear` decides whether a step can be skipped ahead of the one before it. The step panels go in the
+ * `content` slot.
+ */ function SceneStepperCommandDialog({ element, slots }) {
+    const { name, target } = resolveElementBinding.resolveElementBinding(element, BindingKind.BindingKind.Command);
+    if (!target) return /*#__PURE__*/ jsxRuntime.jsx(MissingBinding.MissingBinding, {
+        element: element,
+        kind: BindingKind.BindingKind.Command,
+        name: name
+    });
+    return /*#__PURE__*/ jsxRuntime.jsx(ArcRuntimeBoundary.ArcRuntimeBoundary, {
+        children: /*#__PURE__*/ jsxRuntime.jsx(StepperCommandDialog, {
+            title: properties.stringProperty(element.properties, 'title') ?? '',
+            command: target,
+            visible: properties.booleanProperty(element.properties, 'visible') ?? true,
+            width: properties.stringProperty(element.properties, 'width'),
+            linear: properties.booleanProperty(element.properties, 'linear'),
+            orientation: properties.unionProperty(element.properties, 'orientation', orientations),
+            okLabel: properties.stringProperty(element.properties, 'okLabel'),
+            nextLabel: properties.stringProperty(element.properties, 'nextLabel'),
+            previousLabel: properties.stringProperty(element.properties, 'previousLabel'),
+            showCancel: properties.booleanProperty(element.properties, 'showCancel'),
+            cancelLabel: properties.stringProperty(element.properties, 'cancelLabel'),
+            children: slots.content
+        })
+    });
+}
+
+exports.SceneStepperCommandDialog = SceneStepperCommandDialog;
+//# sourceMappingURL=SceneStepperCommandDialog.js.map

package/dist/cjs/dialogs/SceneStepperCommandDialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneStepperCommandDialog.js","sources":["../../../dialogs/SceneStepperCommandDialog.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 { lazy } from 'react';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { ArcRuntimeBoundary, BindingKind, MissingBinding, resolveElementBinding } from '../bindings';\nimport { booleanProperty, stringProperty, unionProperty } from '../properties';\n\nconst StepperCommandDialog = lazy(async () => ({\n    default: (await import('@cratis/components/CommandDialog')).StepperCommandDialog,\n}));\n\n/** Whether the step headers run across the top or down the side. */\nconst orientations = ['horizontal', 'vertical'] as const;\n\n/**\n * The `Cratis.Components:stepperCommandDialog` component - `StepperCommandDialog` from\n * `@cratis/components/CommandDialog`.\n *\n * `commandDialog` split across steps, for a command with more fields than fit one screen. It stays a\n * single command: the steps partition the *fields*, not the intent, and nothing is submitted until the\n * last step - so a half-finished wizard leaves no trace, which is exactly what a command should do.\n *\n * `linear` decides whether a step can be skipped ahead of the one before it. The step panels go in the\n * `content` slot.\n */\nexport function SceneStepperCommandDialog({ element, slots }: RegisteredComponentProps) {\n    const { name, target } = resolveElementBinding(element, BindingKind.Command);\n    if (!target) return <MissingBinding element={element} kind={BindingKind.Command} name={name} />;\n\n    return (\n        <ArcRuntimeBoundary>\n            <StepperCommandDialog\n                title={stringProperty(element.properties, 'title') ?? ''}\n                command={target}\n                visible={booleanProperty(element.properties, 'visible') ?? true}\n                width={stringProperty(element.properties, 'width')}\n                linear={booleanProperty(element.properties, 'linear')}\n                orientation={unionProperty(element.properties, 'orientation', orientations)}\n                okLabel={stringProperty(element.properties, 'okLabel')}\n                nextLabel={stringProperty(element.properties, 'nextLabel')}\n                previousLabel={stringProperty(element.properties, 'previousLabel')}\n                showCancel={booleanProperty(element.properties, 'showCancel')}\n                cancelLabel={stringProperty(element.properties, 'cancelLabel')}\n            >\n                {slots.content}\n            </StepperCommandDialog>\n        </ArcRuntimeBoundary>\n    );\n}\n"],"names":["StepperCommandDialog","lazy","default","orientations","SceneStepperCommandDialog","element","slots","name","target","resolveElementBinding","BindingKind","Command","_jsx","MissingBinding","kind","ArcRuntimeBoundary","title","stringProperty","properties","command","visible","booleanProperty","width","linear","orientation","unionProperty","okLabel","nextLabel","previousLabel","showCancel","cancelLabel","content"],"mappings":";;;;;;;;;;AAQA,MAAMA,oBAAAA,iBAAuBC,UAAAA,CAAK,WAAa;AAC3CC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,kCAAA,CAAkC,EAAGF;KAChE,CAAA,CAAA;AAEA,qEACA,MAAMG,YAAAA,GAAe;AAAC,IAAA,YAAA;AAAc,IAAA;AAAW,CAAA;AAE/C;;;;;;;;;;AAUC,IACM,SAASC,yBAAAA,CAA0B,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;IAClF,MAAM,EAAEC,IAAI,EAAEC,MAAM,EAAE,GAAGC,2CAAAA,CAAsBJ,OAAAA,EAASK,uBAAAA,CAAYC,OAAO,CAAA;IAC3E,IAAI,CAACH,MAAAA,EAAQ,qBAAOI,cAAA,CAACC,6BAAAA,EAAAA;QAAeR,OAAAA,EAASA,OAAAA;AAASS,QAAAA,IAAAA,EAAMJ,wBAAYC,OAAO;QAAEJ,IAAAA,EAAMA;;AAEvF,IAAA,qBACIK,cAAA,CAACG,qCAAAA,EAAAA;AACG,QAAA,QAAA,gBAAAH,cAAA,CAACZ,oBAAAA,EAAAA;AACGgB,YAAAA,KAAAA,EAAOC,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,OAAA,CAAA,IAAY,EAAA;YACtDC,OAAAA,EAASX,MAAAA;AACTY,YAAAA,OAAAA,EAASC,0BAAAA,CAAgBhB,OAAAA,CAAQa,UAAU,EAAE,SAAA,CAAA,IAAc,IAAA;YAC3DI,KAAAA,EAAOL,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,OAAA,CAAA;YAC1CK,MAAAA,EAAQF,0BAAAA,CAAgBhB,OAAAA,CAAQa,UAAU,EAAE,QAAA,CAAA;AAC5CM,YAAAA,WAAAA,EAAaC,wBAAAA,CAAcpB,OAAAA,CAAQa,UAAU,EAAE,aAAA,EAAef,YAAAA,CAAAA;YAC9DuB,OAAAA,EAAST,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,SAAA,CAAA;YAC5CS,SAAAA,EAAWV,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,WAAA,CAAA;YAC9CU,aAAAA,EAAeX,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,eAAA,CAAA;YAClDW,UAAAA,EAAYR,0BAAAA,CAAgBhB,OAAAA,CAAQa,UAAU,EAAE,YAAA,CAAA;YAChDY,WAAAA,EAAab,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,aAAA,CAAA;AAE/CZ,YAAAA,QAAAA,EAAAA,KAAAA,CAAMyB;;;AAIvB;;;;"}

package/dist/cjs/editors/SceneFilterPanel.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var Filter = require('@cratis/components/Filter');
+var properties = require('../properties.js');
+var filterDefinitions = require('./filterDefinitions.js');
+
+/**
+ * The `Cratis.Components:filterPanel` component - `FilterPanel` from `@cratis/components/Filter`.
+ *
+ * `FilterPanel` is a portal anchored to a button: it renders next to whatever opened it, which means it
+ * cannot be placed on a screen on its own. So this adapter is the whole control - the toggle button and
+ * the panel it anchors - and a screen places one element instead of having to model an anchor
+ * relationship the element tree has no way to express.
+ *
+ * Selection state comes from the library's own `useFilterState`, so the toggling, clearing and range
+ * behavior is the library's rather than a second implementation of it here.
+ */ function SceneFilterPanel({ element, slots }) {
+    const filters = react.useMemo(()=>filterDefinitions.filterDefinitions(element.properties), [
+        element.properties
+    ]);
+    const anchorRef = react.useRef(null);
+    const [isOpen, setIsOpen] = react.useState(false);
+    const state = Filter.useFilterState(filters);
+    return /*#__PURE__*/ jsxRuntime.jsxs(jsxRuntime.Fragment, {
+        children: [
+            /*#__PURE__*/ jsxRuntime.jsx("button", {
+                type: "button",
+                ref: anchorRef,
+                "data-scene-id": element.id,
+                onClick: ()=>setIsOpen((open)=>!open),
+                children: properties.stringProperty(element.properties, 'label') ?? 'Filters'
+            }),
+            /*#__PURE__*/ jsxRuntime.jsx(Filter.FilterPanel, {
+                isOpen: isOpen,
+                filters: filters,
+                filterValues: state.filterValues,
+                rangeValues: state.rangeValues,
+                customValues: state.customValues,
+                searchPlaceholder: properties.stringProperty(element.properties, 'searchPlaceholder'),
+                expandedFilterKey: state.expandedFilterKey,
+                anchorRef: anchorRef,
+                onClose: ()=>setIsOpen(false),
+                onFilterToggle: state.handleToggleFilter,
+                onFilterClear: state.handleClearFilter,
+                onRangeChange: state.handleRangeChange,
+                onExpandedFilterChange: state.setExpandedFilterKey,
+                onCustomValueChange: state.handleCustomValueChange,
+                children: slots.content
+            })
+        ]
+    });
+}
+
+exports.SceneFilterPanel = SceneFilterPanel;
+//# sourceMappingURL=SceneFilterPanel.js.map

package/dist/cjs/editors/SceneFilterPanel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneFilterPanel.js","sources":["../../../editors/SceneFilterPanel.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 { useMemo, useRef, useState } from 'react';\nimport { FilterPanel, useFilterState } from '@cratis/components/Filter';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { stringProperty } from '../properties';\nimport { filterDefinitions } from './filterDefinitions';\n\n/**\n * The `Cratis.Components:filterPanel` component - `FilterPanel` from `@cratis/components/Filter`.\n *\n * `FilterPanel` is a portal anchored to a button: it renders next to whatever opened it, which means it\n * cannot be placed on a screen on its own. So this adapter is the whole control - the toggle button and\n * the panel it anchors - and a screen places one element instead of having to model an anchor\n * relationship the element tree has no way to express.\n *\n * Selection state comes from the library's own `useFilterState`, so the toggling, clearing and range\n * behavior is the library's rather than a second implementation of it here.\n */\nexport function SceneFilterPanel({ element, slots }: RegisteredComponentProps) {\n    const filters = useMemo(() => filterDefinitions(element.properties), [element.properties]);\n    const anchorRef = useRef<HTMLButtonElement>(null);\n    const [isOpen, setIsOpen] = useState(false);\n    const state = useFilterState(filters);\n\n    return (\n        <>\n            <button type='button' ref={anchorRef} data-scene-id={element.id} onClick={() => setIsOpen(open => !open)}>\n                {stringProperty(element.properties, 'label') ?? 'Filters'}\n            </button>\n            <FilterPanel\n                isOpen={isOpen}\n                filters={filters}\n                filterValues={state.filterValues}\n                rangeValues={state.rangeValues}\n                customValues={state.customValues}\n                searchPlaceholder={stringProperty(element.properties, 'searchPlaceholder')}\n                expandedFilterKey={state.expandedFilterKey}\n                anchorRef={anchorRef}\n                onClose={() => setIsOpen(false)}\n                onFilterToggle={state.handleToggleFilter}\n                onFilterClear={state.handleClearFilter}\n                onRangeChange={state.handleRangeChange}\n                onExpandedFilterChange={state.setExpandedFilterKey}\n                onCustomValueChange={state.handleCustomValueChange}\n            >\n                {slots.content}\n            </FilterPanel>\n        </>\n    );\n}\n"],"names":["SceneFilterPanel","element","slots","filters","useMemo","filterDefinitions","properties","anchorRef","useRef","isOpen","setIsOpen","useState","state","useFilterState","_jsxs","_Fragment","_jsx","button","type","ref","data-scene-id","id","onClick","open","stringProperty","FilterPanel","filterValues","rangeValues","customValues","searchPlaceholder","expandedFilterKey","onClose","onFilterToggle","handleToggleFilter","onFilterClear","handleClearFilter","onRangeChange","handleRangeChange","onExpandedFilterChange","setExpandedFilterKey","onCustomValueChange","handleCustomValueChange","content"],"mappings":";;;;;;;;AASA;;;;;;;;;;AAUC,IACM,SAASA,gBAAAA,CAAiB,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;AACzE,IAAA,MAAMC,UAAUC,aAAAA,CAAQ,IAAMC,mCAAAA,CAAkBJ,OAAAA,CAAQK,UAAU,CAAA,EAAG;AAACL,QAAAA,OAAAA,CAAQK;AAAW,KAAA,CAAA;AACzF,IAAA,MAAMC,YAAYC,YAAAA,CAA0B,IAAA,CAAA;AAC5C,IAAA,MAAM,CAACC,MAAAA,EAAQC,SAAAA,CAAU,GAAGC,cAAAA,CAAS,KAAA,CAAA;AACrC,IAAA,MAAMC,QAAQC,qBAAAA,CAAeV,OAAAA,CAAAA;IAE7B,qBACIW,eAAA,CAAAC,mBAAA,EAAA;;0BACIC,cAAA,CAACC,QAAAA,EAAAA;gBAAOC,IAAAA,EAAK,QAAA;gBAASC,GAAAA,EAAKZ,SAAAA;AAAWa,gBAAAA,eAAAA,EAAenB,QAAQoB,EAAE;AAAEC,gBAAAA,OAAAA,EAAS,IAAMZ,SAAAA,CAAUa,CAAAA,IAAAA,GAAQ,CAACA,IAAAA,CAAAA;0BAC9FC,yBAAAA,CAAevB,OAAAA,CAAQK,UAAU,EAAE,OAAA,CAAA,IAAY;;0BAEpDU,cAAA,CAACS,kBAAAA,EAAAA;gBACGhB,MAAAA,EAAQA,MAAAA;gBACRN,OAAAA,EAASA,OAAAA;AACTuB,gBAAAA,YAAAA,EAAcd,MAAMc,YAAY;AAChCC,gBAAAA,WAAAA,EAAaf,MAAMe,WAAW;AAC9BC,gBAAAA,YAAAA,EAAchB,MAAMgB,YAAY;gBAChCC,iBAAAA,EAAmBL,yBAAAA,CAAevB,OAAAA,CAAQK,UAAU,EAAE,mBAAA,CAAA;AACtDwB,gBAAAA,iBAAAA,EAAmBlB,MAAMkB,iBAAiB;gBAC1CvB,SAAAA,EAAWA,SAAAA;AACXwB,gBAAAA,OAAAA,EAAS,IAAMrB,SAAAA,CAAU,KAAA,CAAA;AACzBsB,gBAAAA,cAAAA,EAAgBpB,MAAMqB,kBAAkB;AACxCC,gBAAAA,aAAAA,EAAetB,MAAMuB,iBAAiB;AACtCC,gBAAAA,aAAAA,EAAexB,MAAMyB,iBAAiB;AACtCC,gBAAAA,sBAAAA,EAAwB1B,MAAM2B,oBAAoB;AAClDC,gBAAAA,mBAAAA,EAAqB5B,MAAM6B,uBAAuB;AAEjDvC,gBAAAA,QAAAA,EAAAA,KAAAA,CAAMwC;;;;AAIvB;;;;"}

package/dist/cjs/editors/SceneObjectContentEditor.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var ObjectContentEditor = require('@cratis/components/ObjectContentEditor');
+var properties = require('../properties.js');
+var useEditableCopy = require('./useEditableCopy.js');
+
+/**
+ * The `Cratis.Components:objectContentEditor` component - `ObjectContentEditor` from
+ * `@cratis/components/ObjectContentEditor`.
+ *
+ * Renders an arbitrary JSON document against its schema, so nested objects and arrays are navigable and
+ * each value is edited with a control that matches its declared type. That is what makes it worth
+ * exposing to a screen at all: the alternative is a textarea full of JSON, which is not an editor.
+ *
+ * `object` and `schema` come through the property bag as plain JSON, which is exactly what they are at
+ * runtime - the conversions state that, since the property bag is typed as unknown values by definition.
+ */ function SceneObjectContentEditor({ element }) {
+    const declared = react.useMemo(()=>properties.objectProperty(element.properties, 'object') ?? {}, [
+        element.properties
+    ]);
+    const schema = react.useMemo(()=>properties.objectProperty(element.properties, 'schema') ?? {}, [
+        element.properties
+    ]);
+    const [object, setObject] = useEditableCopy.useEditableCopy(declared);
+    return /*#__PURE__*/ jsxRuntime.jsx(ObjectContentEditor.ObjectContentEditor, {
+        object: object,
+        schema: schema,
+        editMode: properties.booleanProperty(element.properties, 'editMode'),
+        onChange: setObject,
+        className: properties.stringProperty(element.properties, 'className')
+    });
+}
+
+exports.SceneObjectContentEditor = SceneObjectContentEditor;
+//# sourceMappingURL=SceneObjectContentEditor.js.map

package/dist/cjs/editors/SceneObjectContentEditor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneObjectContentEditor.js","sources":["../../../editors/SceneObjectContentEditor.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 { useMemo } from 'react';\nimport { ObjectContentEditor } from '@cratis/components/ObjectContentEditor';\nimport { Json, JsonSchema } from '@cratis/components/types';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, objectProperty, stringProperty } from '../properties';\nimport { useEditableCopy } from './useEditableCopy';\n\n/**\n * The `Cratis.Components:objectContentEditor` component - `ObjectContentEditor` from\n * `@cratis/components/ObjectContentEditor`.\n *\n * Renders an arbitrary JSON document against its schema, so nested objects and arrays are navigable and\n * each value is edited with a control that matches its declared type. That is what makes it worth\n * exposing to a screen at all: the alternative is a textarea full of JSON, which is not an editor.\n *\n * `object` and `schema` come through the property bag as plain JSON, which is exactly what they are at\n * runtime - the conversions state that, since the property bag is typed as unknown values by definition.\n */\nexport function SceneObjectContentEditor({ element }: RegisteredComponentProps) {\n    const declared = useMemo(() => (objectProperty(element.properties, 'object') ?? {}) as unknown as Json, [element.properties]);\n    const schema = useMemo(() => (objectProperty(element.properties, 'schema') ?? {}) as unknown as JsonSchema, [element.properties]);\n    const [object, setObject] = useEditableCopy(declared);\n\n    return (\n        <ObjectContentEditor\n            object={object}\n            schema={schema}\n            editMode={booleanProperty(element.properties, 'editMode')}\n            onChange={setObject}\n            className={stringProperty(element.properties, 'className')}\n        />\n    );\n}\n"],"names":["SceneObjectContentEditor","element","declared","useMemo","objectProperty","properties","schema","object","setObject","useEditableCopy","_jsx","ObjectContentEditor","editMode","booleanProperty","onChange","className","stringProperty"],"mappings":";;;;;;;;AAUA;;;;;;;;;;AAUC,IACM,SAASA,wBAAAA,CAAyB,EAAEC,OAAO,EAA4B,EAAA;IAC1E,MAAMC,QAAAA,GAAWC,cAAQ,IAAOC,yBAAAA,CAAeH,QAAQI,UAAU,EAAE,QAAA,CAAA,IAAa,EAAC,EAAuB;AAACJ,QAAAA,OAAAA,CAAQI;AAAW,KAAA,CAAA;IAC5H,MAAMC,MAAAA,GAASH,cAAQ,IAAOC,yBAAAA,CAAeH,QAAQI,UAAU,EAAE,QAAA,CAAA,IAAa,EAAC,EAA6B;AAACJ,QAAAA,OAAAA,CAAQI;AAAW,KAAA,CAAA;AAChI,IAAA,MAAM,CAACE,MAAAA,EAAQC,SAAAA,CAAU,GAAGC,+BAAAA,CAAgBP,QAAAA,CAAAA;AAE5C,IAAA,qBACIQ,cAAA,CAACC,uCAAAA,EAAAA;QACGJ,MAAAA,EAAQA,MAAAA;QACRD,MAAAA,EAAQA,MAAAA;QACRM,QAAAA,EAAUC,0BAAAA,CAAgBZ,OAAAA,CAAQI,UAAU,EAAE,UAAA,CAAA;QAC9CS,QAAAA,EAAUN,SAAAA;QACVO,SAAAA,EAAWC,yBAAAA,CAAef,OAAAA,CAAQI,UAAU,EAAE,WAAA;;AAG1D;;;;"}

package/dist/cjs/editors/SceneObjectNavigationalBar.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var ObjectNavigationalBar = require('@cratis/components/ObjectNavigationalBar');
+var properties = require('../properties.js');
+var useEditableCopy = require('./useEditableCopy.js');
+
+/**
+ * The `Cratis.Components:objectNavigationalBar` component - `ObjectNavigationalBar` from
+ * `@cratis/components/ObjectNavigationalBar`.
+ *
+ * The breadcrumb trail that says where you are inside a nested document, and lets you climb back out.
+ * Clicking a crumb truncates the trail to it, which is behavior the component reports rather than
+ * performs - so this adapter holds the trail and applies the truncation, and the bar is a working
+ * breadcrumb on a screen instead of a row of inert labels.
+ *
+ * The reported index is how many segments to *keep*, not the position of the crumb clicked: the bar
+ * prepends a `Root` crumb at index 0, so clicking the first real segment reports 1. `slice(0, index)` is
+ * what that means, and it is also exactly what the back arrow asks for when it reports `length - 1`.
+ */ function SceneObjectNavigationalBar({ element }) {
+    const declared = react.useMemo(()=>properties.stringArrayProperty(element.properties, 'navigationPath') ?? [], [
+        element.properties
+    ]);
+    const [navigationPath, setNavigationPath] = useEditableCopy.useEditableCopy(declared);
+    return /*#__PURE__*/ jsxRuntime.jsx(ObjectNavigationalBar.ObjectNavigationalBar, {
+        navigationPath: navigationPath,
+        onNavigate: (index)=>setNavigationPath(navigationPath.slice(0, index)),
+        className: properties.stringProperty(element.properties, 'className')
+    });
+}
+
+exports.SceneObjectNavigationalBar = SceneObjectNavigationalBar;
+//# sourceMappingURL=SceneObjectNavigationalBar.js.map

package/dist/cjs/editors/SceneObjectNavigationalBar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneObjectNavigationalBar.js","sources":["../../../editors/SceneObjectNavigationalBar.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 { useMemo } from 'react';\nimport { ObjectNavigationalBar } from '@cratis/components/ObjectNavigationalBar';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { stringArrayProperty, stringProperty } from '../properties';\nimport { useEditableCopy } from './useEditableCopy';\n\n/**\n * The `Cratis.Components:objectNavigationalBar` component - `ObjectNavigationalBar` from\n * `@cratis/components/ObjectNavigationalBar`.\n *\n * The breadcrumb trail that says where you are inside a nested document, and lets you climb back out.\n * Clicking a crumb truncates the trail to it, which is behavior the component reports rather than\n * performs - so this adapter holds the trail and applies the truncation, and the bar is a working\n * breadcrumb on a screen instead of a row of inert labels.\n *\n * The reported index is how many segments to *keep*, not the position of the crumb clicked: the bar\n * prepends a `Root` crumb at index 0, so clicking the first real segment reports 1. `slice(0, index)` is\n * what that means, and it is also exactly what the back arrow asks for when it reports `length - 1`.\n */\nexport function SceneObjectNavigationalBar({ element }: RegisteredComponentProps) {\n    const declared = useMemo(() => stringArrayProperty(element.properties, 'navigationPath') ?? [], [element.properties]);\n    const [navigationPath, setNavigationPath] = useEditableCopy(declared);\n\n    return (\n        <ObjectNavigationalBar\n            navigationPath={navigationPath}\n            onNavigate={index => setNavigationPath(navigationPath.slice(0, index))}\n            className={stringProperty(element.properties, 'className')}\n        />\n    );\n}\n"],"names":["SceneObjectNavigationalBar","element","declared","useMemo","stringArrayProperty","properties","navigationPath","setNavigationPath","useEditableCopy","_jsx","ObjectNavigationalBar","onNavigate","index","slice","className","stringProperty"],"mappings":";;;;;;;;AASA;;;;;;;;;;;;AAYC,IACM,SAASA,0BAAAA,CAA2B,EAAEC,OAAO,EAA4B,EAAA;IAC5E,MAAMC,QAAAA,GAAWC,cAAQ,IAAMC,8BAAAA,CAAoBH,QAAQI,UAAU,EAAE,gBAAA,CAAA,IAAqB,EAAE,EAAE;AAACJ,QAAAA,OAAAA,CAAQI;AAAW,KAAA,CAAA;AACpH,IAAA,MAAM,CAACC,cAAAA,EAAgBC,iBAAAA,CAAkB,GAAGC,+BAAAA,CAAgBN,QAAAA,CAAAA;AAE5D,IAAA,qBACIO,cAAA,CAACC,2CAAAA,EAAAA;QACGJ,cAAAA,EAAgBA,cAAAA;AAChBK,QAAAA,UAAAA,EAAYC,CAAAA,KAAAA,GAASL,iBAAAA,CAAkBD,cAAAA,CAAeO,KAAK,CAAC,CAAA,EAAGD,KAAAA,CAAAA,CAAAA;QAC/DE,SAAAA,EAAWC,yBAAAA,CAAed,OAAAA,CAAQI,UAAU,EAAE,WAAA;;AAG1D;;;;"}

package/dist/cjs/editors/SceneSchemaEditor.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var SchemaEditor = require('@cratis/components/SchemaEditor');
+var properties = require('../properties.js');
+var useEditableCopy = require('./useEditableCopy.js');
+
+/**
+ * The `Cratis.Components:schemaEditor` component - `SchemaEditor` from `@cratis/components/SchemaEditor`.
+ *
+ * Edits a JSON schema as a typed property tree rather than as text. In a Cratis application this is how
+ * an event type's shape is inspected and evolved, so `canEdit` and `canNotEditReason` are a pair worth
+ * setting together - a schema is often deliberately read-only, and saying *why* in the same place is
+ * what keeps that from looking like a bug.
+ */ function SceneSchemaEditor({ element }) {
+    const declared = react.useMemo(()=>properties.objectProperty(element.properties, 'schema') ?? {}, [
+        element.properties
+    ]);
+    const [schema, setSchema] = useEditableCopy.useEditableCopy(declared);
+    return /*#__PURE__*/ jsxRuntime.jsx(SchemaEditor.SchemaEditor, {
+        schema: schema,
+        eventTypeName: properties.stringProperty(element.properties, 'eventTypeName'),
+        canEdit: properties.booleanProperty(element.properties, 'canEdit'),
+        canNotEditReason: properties.stringProperty(element.properties, 'canNotEditReason'),
+        editMode: properties.booleanProperty(element.properties, 'editMode'),
+        onChange: setSchema,
+        className: properties.stringProperty(element.properties, 'className')
+    });
+}
+
+exports.SceneSchemaEditor = SceneSchemaEditor;
+//# sourceMappingURL=SceneSchemaEditor.js.map

package/dist/cjs/editors/SceneSchemaEditor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneSchemaEditor.js","sources":["../../../editors/SceneSchemaEditor.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 { useMemo } from 'react';\nimport { SchemaEditor } from '@cratis/components/SchemaEditor';\nimport { JsonSchema } from '@cratis/components/types';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, objectProperty, stringProperty } from '../properties';\nimport { useEditableCopy } from './useEditableCopy';\n\n/**\n * The `Cratis.Components:schemaEditor` component - `SchemaEditor` from `@cratis/components/SchemaEditor`.\n *\n * Edits a JSON schema as a typed property tree rather than as text. In a Cratis application this is how\n * an event type's shape is inspected and evolved, so `canEdit` and `canNotEditReason` are a pair worth\n * setting together - a schema is often deliberately read-only, and saying *why* in the same place is\n * what keeps that from looking like a bug.\n */\nexport function SceneSchemaEditor({ element }: RegisteredComponentProps) {\n    const declared = useMemo(() => (objectProperty(element.properties, 'schema') ?? {}) as unknown as JsonSchema, [element.properties]);\n    const [schema, setSchema] = useEditableCopy(declared);\n\n    return (\n        <SchemaEditor\n            schema={schema}\n            eventTypeName={stringProperty(element.properties, 'eventTypeName')}\n            canEdit={booleanProperty(element.properties, 'canEdit')}\n            canNotEditReason={stringProperty(element.properties, 'canNotEditReason')}\n            editMode={booleanProperty(element.properties, 'editMode')}\n            onChange={setSchema}\n            className={stringProperty(element.properties, 'className')}\n        />\n    );\n}\n"],"names":["SceneSchemaEditor","element","declared","useMemo","objectProperty","properties","schema","setSchema","useEditableCopy","_jsx","SchemaEditor","eventTypeName","stringProperty","canEdit","booleanProperty","canNotEditReason","editMode","onChange","className"],"mappings":";;;;;;;;AAUA;;;;;;;AAOC,IACM,SAASA,iBAAAA,CAAkB,EAAEC,OAAO,EAA4B,EAAA;IACnE,MAAMC,QAAAA,GAAWC,cAAQ,IAAOC,yBAAAA,CAAeH,QAAQI,UAAU,EAAE,QAAA,CAAA,IAAa,EAAC,EAA6B;AAACJ,QAAAA,OAAAA,CAAQI;AAAW,KAAA,CAAA;AAClI,IAAA,MAAM,CAACC,MAAAA,EAAQC,SAAAA,CAAU,GAAGC,+BAAAA,CAAgBN,QAAAA,CAAAA;AAE5C,IAAA,qBACIO,cAAA,CAACC,yBAAAA,EAAAA;QACGJ,MAAAA,EAAQA,MAAAA;QACRK,aAAAA,EAAeC,yBAAAA,CAAeX,OAAAA,CAAQI,UAAU,EAAE,eAAA,CAAA;QAClDQ,OAAAA,EAASC,0BAAAA,CAAgBb,OAAAA,CAAQI,UAAU,EAAE,SAAA,CAAA;QAC7CU,gBAAAA,EAAkBH,yBAAAA,CAAeX,OAAAA,CAAQI,UAAU,EAAE,kBAAA,CAAA;QACrDW,QAAAA,EAAUF,0BAAAA,CAAgBb,OAAAA,CAAQI,UAAU,EAAE,UAAA,CAAA;QAC9CY,QAAAA,EAAUV,SAAAA;QACVW,SAAAA,EAAWN,yBAAAA,CAAeX,OAAAA,CAAQI,UAAU,EAAE,WAAA;;AAG1D;;;;"}

package/dist/cjs/editors/SceneTimeMachine.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var TimeMachine = require('@cratis/components/TimeMachine');
+var properties = require('../properties.js');
+var timeMachineVersions = require('./timeMachineVersions.js');
+var useEditableCopy = require('./useEditableCopy.js');
+
+/**
+ * The `Cratis.Components:timeMachine` component - `TimeMachine` from `@cratis/components/TimeMachine`.
+ *
+ * Scrubs through successive versions of something on a timeline - which in an event-sourced application
+ * is the most natural way to look at anything, since every read model *has* a history rather than only a
+ * current value. The selected version is held here so the timeline scrubs on a screen; a host that wants
+ * to drive the selection renders the component itself.
+ */ function SceneTimeMachine({ element }) {
+    const versions = react.useMemo(()=>timeMachineVersions.timeMachineVersions(element.properties), [
+        element.properties
+    ]);
+    const declaredIndex = properties.numberProperty(element.properties, 'currentVersionIndex') ?? 0;
+    const [currentVersionIndex, setCurrentVersionIndex] = useEditableCopy.useEditableCopy(declaredIndex);
+    return /*#__PURE__*/ jsxRuntime.jsx(TimeMachine.TimeMachine, {
+        versions: versions,
+        currentVersionIndex: currentVersionIndex,
+        onVersionChange: setCurrentVersionIndex,
+        scrollSensitivity: properties.numberProperty(element.properties, 'scrollSensitivity')
+    });
+}
+
+exports.SceneTimeMachine = SceneTimeMachine;
+//# sourceMappingURL=SceneTimeMachine.js.map

package/dist/cjs/editors/SceneTimeMachine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneTimeMachine.js","sources":["../../../editors/SceneTimeMachine.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 { useMemo } from 'react';\nimport { TimeMachine } from '@cratis/components/TimeMachine';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { numberProperty } from '../properties';\nimport { timeMachineVersions } from './timeMachineVersions';\nimport { useEditableCopy } from './useEditableCopy';\n\n/**\n * The `Cratis.Components:timeMachine` component - `TimeMachine` from `@cratis/components/TimeMachine`.\n *\n * Scrubs through successive versions of something on a timeline - which in an event-sourced application\n * is the most natural way to look at anything, since every read model *has* a history rather than only a\n * current value. The selected version is held here so the timeline scrubs on a screen; a host that wants\n * to drive the selection renders the component itself.\n */\nexport function SceneTimeMachine({ element }: RegisteredComponentProps) {\n    const versions = useMemo(() => timeMachineVersions(element.properties), [element.properties]);\n    const declaredIndex = numberProperty(element.properties, 'currentVersionIndex') ?? 0;\n    const [currentVersionIndex, setCurrentVersionIndex] = useEditableCopy(declaredIndex);\n\n    return (\n        <TimeMachine\n            versions={versions}\n            currentVersionIndex={currentVersionIndex}\n            onVersionChange={setCurrentVersionIndex}\n            scrollSensitivity={numberProperty(element.properties, 'scrollSensitivity')}\n        />\n    );\n}\n"],"names":["SceneTimeMachine","element","versions","useMemo","timeMachineVersions","properties","declaredIndex","numberProperty","currentVersionIndex","setCurrentVersionIndex","useEditableCopy","_jsx","TimeMachine","onVersionChange","scrollSensitivity"],"mappings":";;;;;;;;;AAUA;;;;;;;AAOC,IACM,SAASA,gBAAAA,CAAiB,EAAEC,OAAO,EAA4B,EAAA;AAClE,IAAA,MAAMC,WAAWC,aAAAA,CAAQ,IAAMC,uCAAAA,CAAoBH,OAAAA,CAAQI,UAAU,CAAA,EAAG;AAACJ,QAAAA,OAAAA,CAAQI;AAAW,KAAA,CAAA;AAC5F,IAAA,MAAMC,aAAAA,GAAgBC,yBAAAA,CAAeN,OAAAA,CAAQI,UAAU,EAAE,qBAAA,CAAA,IAA0B,CAAA;AACnF,IAAA,MAAM,CAACG,mBAAAA,EAAqBC,sBAAAA,CAAuB,GAAGC,+BAAAA,CAAgBJ,aAAAA,CAAAA;AAEtE,IAAA,qBACIK,cAAA,CAACC,uBAAAA,EAAAA;QACGV,QAAAA,EAAUA,QAAAA;QACVM,mBAAAA,EAAqBA,mBAAAA;QACrBK,eAAAA,EAAiBJ,sBAAAA;QACjBK,iBAAAA,EAAmBP,yBAAAA,CAAeN,OAAAA,CAAQI,UAAU,EAAE,mBAAA;;AAGlE;;;;"}

package/dist/cjs/editors/filterDefinitions.js

@@ -0,0 +1,59 @@
+'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.
+/** The value kinds a filter can be declared over. */ const filterTypes = [
+    'string',
+    'number',
+    'date',
+    'custom'
+];
+/**
+ * Reads a `filters` property into the `FilterDefinition` list `FilterPanel` renders.
+ *
+ * A definition needs a `key` and a `label`; an entry without both is dropped, since a filter with no key
+ * has nothing to filter on and one with no label cannot be shown. Everything else is optional and falls
+ * through to the panel's own defaults.
+ */ function filterDefinitions(properties$1) {
+    const entries = properties.objectArrayProperty(properties$1, 'filters') ?? [];
+    return entries.map((entry)=>{
+        const key = properties.stringProperty(entry, 'key');
+        const label = properties.stringProperty(entry, 'label');
+        if (key === undefined || label === undefined) return undefined;
+        return {
+            key,
+            label,
+            type: properties.unionProperty(entry, 'type', filterTypes),
+            multi: properties.booleanProperty(entry, 'multi'),
+            options: filterOptions(entry),
+            searchable: properties.booleanProperty(entry, 'searchable'),
+            searchPlaceholder: properties.stringProperty(entry, 'searchPlaceholder'),
+            buckets: properties.numberProperty(entry, 'buckets')
+        };
+    }).filter((definition)=>definition !== undefined);
+}
+/**
+ * Reads one filter's selectable options. An option's `value` is what gets applied and its `key` is what
+ * the panel tracks selection by; `value` falls back to the key so the common case of a plain string
+ * choice needs only `key` and `label`.
+ */ function filterOptions(entry) {
+    const options = properties.objectArrayProperty(entry, 'options');
+    if (options === undefined) return undefined;
+    return options.map((option)=>{
+        const key = properties.stringProperty(option, 'key');
+        const label = properties.stringProperty(option, 'label');
+        if (key === undefined || label === undefined) return undefined;
+        const value = properties.stringProperty(option, 'value') ?? properties.numberProperty(option, 'value') ?? properties.booleanProperty(option, 'value') ?? key;
+        return {
+            key,
+            label,
+            value,
+            count: properties.numberProperty(option, 'count')
+        };
+    }).filter((option)=>option !== undefined);
+}
+
+exports.filterDefinitions = filterDefinitions;
+//# sourceMappingURL=filterDefinitions.js.map