@cratis/scene.components 0.1.0

package/dist/esm/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,IAAAA,CAAK,WAAa;AAAEC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,4BAAA,CAA4B,EAAGF;KAAmB,CAAA,CAAA;AAExH;;;;;;;AAOC,IACM,SAASG,uBAAAA,GAAAA;AACZ,IAAA,qBACIC,GAAA,CAACC,kBAAAA,EAAAA;AACG,QAAA,QAAA,gBAAAD,GAAA,CAACJ,kBAAAA,EAAAA,EAAAA;;AAGb;;;;"}

package/dist/esm/dialogs/SceneDialog.d.ts

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

package/dist/esm/dialogs/SceneDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneDialog.d.ts","sourceRoot":"","sources":["../../../dialogs/SceneDialog.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAkB/D,wBAAgB,WAAW,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,wBAAwB,+BAkBvE"}

package/dist/esm/dialogs/SceneDialog.js

@@ -0,0 +1,39 @@
+import { jsx } from 'react/jsx-runtime';
+import { lazy } from 'react';
+import '../bindings/resolveElementBinding.js';
+import { ArcRuntimeBoundary } from '../bindings/ArcRuntimeBoundary.js';
+import { stringProperty, booleanProperty } from '../properties.js';
+
+const Dialog = /*#__PURE__*/ 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__*/ jsx(ArcRuntimeBoundary, {
+        children: /*#__PURE__*/ jsx(Dialog, {
+            title: stringProperty(element.properties, 'title') ?? '',
+            visible: booleanProperty(element.properties, 'visible') ?? true,
+            width: stringProperty(element.properties, 'width'),
+            resizable: booleanProperty(element.properties, 'resizable'),
+            isValid: booleanProperty(element.properties, 'isValid'),
+            isBusy: booleanProperty(element.properties, 'isBusy'),
+            okLabel: stringProperty(element.properties, 'okLabel'),
+            cancelLabel: stringProperty(element.properties, 'cancelLabel'),
+            className: stringProperty(element.properties, 'className'),
+            children: slots.content
+        })
+    });
+}
+
+export { SceneDialog };
+//# sourceMappingURL=SceneDialog.js.map

package/dist/esm/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,IAAAA,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,GAAA,CAACC,kBAAAA,EAAAA;AACG,QAAA,QAAA,gBAAAD,GAAA,CAACN,MAAAA,EAAAA;AACGQ,YAAAA,KAAAA,EAAOC,cAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,OAAA,CAAA,IAAY,EAAA;AACtDC,YAAAA,OAAAA,EAASC,eAAAA,CAAgBR,OAAAA,CAAQM,UAAU,EAAE,SAAA,CAAA,IAAc,IAAA;YAC3DG,KAAAA,EAAOJ,cAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,OAAA,CAAA;YAC1CI,SAAAA,EAAWF,eAAAA,CAAgBR,OAAAA,CAAQM,UAAU,EAAE,WAAA,CAAA;YAC/CK,OAAAA,EAASH,eAAAA,CAAgBR,OAAAA,CAAQM,UAAU,EAAE,SAAA,CAAA;YAC7CM,MAAAA,EAAQJ,eAAAA,CAAgBR,OAAAA,CAAQM,UAAU,EAAE,QAAA,CAAA;YAC5CO,OAAAA,EAASR,cAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,SAAA,CAAA;YAC5CQ,WAAAA,EAAaT,cAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,aAAA,CAAA;YAChDS,SAAAA,EAAWV,cAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,WAAA,CAAA;AAE7CL,YAAAA,QAAAA,EAAAA,KAAAA,CAAMe;;;AAIvB;;;;"}

package/dist/esm/dialogs/SceneStepperCommandDialog.d.ts

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

package/dist/esm/dialogs/SceneStepperCommandDialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneStepperCommandDialog.d.ts","sourceRoot":"","sources":["../../../dialogs/SceneStepperCommandDialog.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAsB/D,wBAAgB,yBAAyB,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,wBAAwB,+BAuBrF"}

package/dist/esm/dialogs/SceneStepperCommandDialog.js

@@ -0,0 +1,52 @@
+import { jsx } from 'react/jsx-runtime';
+import { lazy } from 'react';
+import { BindingKind } from '../bindings/BindingKind.js';
+import { resolveElementBinding } from '../bindings/resolveElementBinding.js';
+import { MissingBinding } from '../bindings/MissingBinding.js';
+import { ArcRuntimeBoundary } from '../bindings/ArcRuntimeBoundary.js';
+import { stringProperty, booleanProperty, unionProperty } from '../properties.js';
+
+const StepperCommandDialog = /*#__PURE__*/ 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(element, BindingKind.Command);
+    if (!target) return /*#__PURE__*/ jsx(MissingBinding, {
+        element: element,
+        kind: BindingKind.Command,
+        name: name
+    });
+    return /*#__PURE__*/ jsx(ArcRuntimeBoundary, {
+        children: /*#__PURE__*/ jsx(StepperCommandDialog, {
+            title: stringProperty(element.properties, 'title') ?? '',
+            command: target,
+            visible: booleanProperty(element.properties, 'visible') ?? true,
+            width: stringProperty(element.properties, 'width'),
+            linear: booleanProperty(element.properties, 'linear'),
+            orientation: unionProperty(element.properties, 'orientation', orientations),
+            okLabel: stringProperty(element.properties, 'okLabel'),
+            nextLabel: stringProperty(element.properties, 'nextLabel'),
+            previousLabel: stringProperty(element.properties, 'previousLabel'),
+            showCancel: booleanProperty(element.properties, 'showCancel'),
+            cancelLabel: stringProperty(element.properties, 'cancelLabel'),
+            children: slots.content
+        })
+    });
+}
+
+export { SceneStepperCommandDialog };
+//# sourceMappingURL=SceneStepperCommandDialog.js.map

package/dist/esm/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,IAAAA,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,qBAAAA,CAAsBJ,OAAAA,EAASK,WAAAA,CAAYC,OAAO,CAAA;IAC3E,IAAI,CAACH,MAAAA,EAAQ,qBAAOI,GAAA,CAACC,cAAAA,EAAAA;QAAeR,OAAAA,EAASA,OAAAA;AAASS,QAAAA,IAAAA,EAAMJ,YAAYC,OAAO;QAAEJ,IAAAA,EAAMA;;AAEvF,IAAA,qBACIK,GAAA,CAACG,kBAAAA,EAAAA;AACG,QAAA,QAAA,gBAAAH,GAAA,CAACZ,oBAAAA,EAAAA;AACGgB,YAAAA,KAAAA,EAAOC,cAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,OAAA,CAAA,IAAY,EAAA;YACtDC,OAAAA,EAASX,MAAAA;AACTY,YAAAA,OAAAA,EAASC,eAAAA,CAAgBhB,OAAAA,CAAQa,UAAU,EAAE,SAAA,CAAA,IAAc,IAAA;YAC3DI,KAAAA,EAAOL,cAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,OAAA,CAAA;YAC1CK,MAAAA,EAAQF,eAAAA,CAAgBhB,OAAAA,CAAQa,UAAU,EAAE,QAAA,CAAA;AAC5CM,YAAAA,WAAAA,EAAaC,aAAAA,CAAcpB,OAAAA,CAAQa,UAAU,EAAE,aAAA,EAAef,YAAAA,CAAAA;YAC9DuB,OAAAA,EAAST,cAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,SAAA,CAAA;YAC5CS,SAAAA,EAAWV,cAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,WAAA,CAAA;YAC9CU,aAAAA,EAAeX,cAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,eAAA,CAAA;YAClDW,UAAAA,EAAYR,eAAAA,CAAgBhB,OAAAA,CAAQa,UAAU,EAAE,YAAA,CAAA;YAChDY,WAAAA,EAAab,cAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,aAAA,CAAA;AAE/CZ,YAAAA,QAAAA,EAAAA,KAAAA,CAAMyB;;;AAIvB;;;;"}

package/dist/esm/dialogs/index.d.ts

@@ -0,0 +1,6 @@
+export * from './SceneDialog';
+export * from './SceneConfirmationDialog';
+export * from './SceneBusyIndicatorDialog';
+export * from './SceneCommandDialog';
+export * from './SceneStepperCommandDialog';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/dialogs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../dialogs/index.ts"],"names":[],"mappings":"AAGA,cAAc,eAAe,CAAC;AAC9B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC"}

package/dist/esm/dialogs/index.js

@@ -0,0 +1,6 @@
+export * from './SceneDialog';
+export * from './SceneConfirmationDialog';
+export * from './SceneBusyIndicatorDialog';
+export * from './SceneCommandDialog';
+export * from './SceneStepperCommandDialog';
+//# sourceMappingURL=index.js.map

package/dist/esm/dialogs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../dialogs/index.ts"],"names":[],"mappings":"AAGA,cAAc,eAAe,CAAC;AAC9B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC"}

package/dist/esm/editors/SceneFilterPanel.d.ts

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

package/dist/esm/editors/SceneFilterPanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneFilterPanel.d.ts","sourceRoot":"","sources":["../../../editors/SceneFilterPanel.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAe/D,wBAAgB,gBAAgB,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,wBAAwB,+BA+B5E"}

package/dist/esm/editors/SceneFilterPanel.js

@@ -0,0 +1,55 @@
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+import { useMemo, useRef, useState } from 'react';
+import { useFilterState, FilterPanel } from '@cratis/components/Filter';
+import { stringProperty } from '../properties.js';
+import { filterDefinitions } from './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 = useMemo(()=>filterDefinitions(element.properties), [
+        element.properties
+    ]);
+    const anchorRef = useRef(null);
+    const [isOpen, setIsOpen] = useState(false);
+    const state = useFilterState(filters);
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            /*#__PURE__*/ jsx("button", {
+                type: "button",
+                ref: anchorRef,
+                "data-scene-id": element.id,
+                onClick: ()=>setIsOpen((open)=>!open),
+                children: stringProperty(element.properties, 'label') ?? 'Filters'
+            }),
+            /*#__PURE__*/ jsx(FilterPanel, {
+                isOpen: isOpen,
+                filters: filters,
+                filterValues: state.filterValues,
+                rangeValues: state.rangeValues,
+                customValues: state.customValues,
+                searchPlaceholder: 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
+            })
+        ]
+    });
+}
+
+export { SceneFilterPanel };
+//# sourceMappingURL=SceneFilterPanel.js.map

package/dist/esm/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,OAAAA,CAAQ,IAAMC,iBAAAA,CAAkBJ,OAAAA,CAAQK,UAAU,CAAA,EAAG;AAACL,QAAAA,OAAAA,CAAQK;AAAW,KAAA,CAAA;AACzF,IAAA,MAAMC,YAAYC,MAAAA,CAA0B,IAAA,CAAA;AAC5C,IAAA,MAAM,CAACC,MAAAA,EAAQC,SAAAA,CAAU,GAAGC,QAAAA,CAAS,KAAA,CAAA;AACrC,IAAA,MAAMC,QAAQC,cAAAA,CAAeV,OAAAA,CAAAA;IAE7B,qBACIW,IAAA,CAAAC,QAAA,EAAA;;0BACIC,GAAA,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,cAAAA,CAAevB,OAAAA,CAAQK,UAAU,EAAE,OAAA,CAAA,IAAY;;0BAEpDU,GAAA,CAACS,WAAAA,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,cAAAA,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/esm/editors/SceneObjectContentEditor.d.ts

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

package/dist/esm/editors/SceneObjectContentEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneObjectContentEditor.d.ts","sourceRoot":"","sources":["../../../editors/SceneObjectContentEditor.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAe/D,wBAAgB,wBAAwB,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAc7E"}

package/dist/esm/editors/SceneObjectContentEditor.js

@@ -0,0 +1,35 @@
+import { jsx } from 'react/jsx-runtime';
+import { useMemo } from 'react';
+import { ObjectContentEditor } from '@cratis/components/ObjectContentEditor';
+import { objectProperty, stringProperty, booleanProperty } from '../properties.js';
+import { useEditableCopy } from './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 = useMemo(()=>objectProperty(element.properties, 'object') ?? {}, [
+        element.properties
+    ]);
+    const schema = useMemo(()=>objectProperty(element.properties, 'schema') ?? {}, [
+        element.properties
+    ]);
+    const [object, setObject] = useEditableCopy(declared);
+    return /*#__PURE__*/ jsx(ObjectContentEditor, {
+        object: object,
+        schema: schema,
+        editMode: booleanProperty(element.properties, 'editMode'),
+        onChange: setObject,
+        className: stringProperty(element.properties, 'className')
+    });
+}
+
+export { SceneObjectContentEditor };
+//# sourceMappingURL=SceneObjectContentEditor.js.map

package/dist/esm/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,QAAQ,IAAOC,cAAAA,CAAeH,QAAQI,UAAU,EAAE,QAAA,CAAA,IAAa,EAAC,EAAuB;AAACJ,QAAAA,OAAAA,CAAQI;AAAW,KAAA,CAAA;IAC5H,MAAMC,MAAAA,GAASH,QAAQ,IAAOC,cAAAA,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,eAAAA,CAAgBP,QAAAA,CAAAA;AAE5C,IAAA,qBACIQ,GAAA,CAACC,mBAAAA,EAAAA;QACGJ,MAAAA,EAAQA,MAAAA;QACRD,MAAAA,EAAQA,MAAAA;QACRM,QAAAA,EAAUC,eAAAA,CAAgBZ,OAAAA,CAAQI,UAAU,EAAE,UAAA,CAAA;QAC9CS,QAAAA,EAAUN,SAAAA;QACVO,SAAAA,EAAWC,cAAAA,CAAef,OAAAA,CAAQI,UAAU,EAAE,WAAA;;AAG1D;;;;"}

package/dist/esm/editors/SceneObjectNavigationalBar.d.ts

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

package/dist/esm/editors/SceneObjectNavigationalBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneObjectNavigationalBar.d.ts","sourceRoot":"","sources":["../../../editors/SceneObjectNavigationalBar.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAiB/D,wBAAgB,0BAA0B,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAW/E"}

package/dist/esm/editors/SceneObjectNavigationalBar.js

@@ -0,0 +1,32 @@
+import { jsx } from 'react/jsx-runtime';
+import { useMemo } from 'react';
+import { ObjectNavigationalBar } from '@cratis/components/ObjectNavigationalBar';
+import { stringArrayProperty, stringProperty } from '../properties.js';
+import { useEditableCopy } from './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 = useMemo(()=>stringArrayProperty(element.properties, 'navigationPath') ?? [], [
+        element.properties
+    ]);
+    const [navigationPath, setNavigationPath] = useEditableCopy(declared);
+    return /*#__PURE__*/ jsx(ObjectNavigationalBar, {
+        navigationPath: navigationPath,
+        onNavigate: (index)=>setNavigationPath(navigationPath.slice(0, index)),
+        className: stringProperty(element.properties, 'className')
+    });
+}
+
+export { SceneObjectNavigationalBar };
+//# sourceMappingURL=SceneObjectNavigationalBar.js.map

package/dist/esm/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,QAAQ,IAAMC,mBAAAA,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,eAAAA,CAAgBN,QAAAA,CAAAA;AAE5D,IAAA,qBACIO,GAAA,CAACC,qBAAAA,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,cAAAA,CAAed,OAAAA,CAAQI,UAAU,EAAE,WAAA;;AAG1D;;;;"}

package/dist/esm/editors/SceneSchemaEditor.d.ts

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

package/dist/esm/editors/SceneSchemaEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneSchemaEditor.d.ts","sourceRoot":"","sources":["../../../editors/SceneSchemaEditor.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAY/D,wBAAgB,iBAAiB,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAetE"}

package/dist/esm/editors/SceneSchemaEditor.js

@@ -0,0 +1,31 @@
+import { jsx } from 'react/jsx-runtime';
+import { useMemo } from 'react';
+import { SchemaEditor } from '@cratis/components/SchemaEditor';
+import { objectProperty, stringProperty, booleanProperty } from '../properties.js';
+import { useEditableCopy } from './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 = useMemo(()=>objectProperty(element.properties, 'schema') ?? {}, [
+        element.properties
+    ]);
+    const [schema, setSchema] = useEditableCopy(declared);
+    return /*#__PURE__*/ jsx(SchemaEditor, {
+        schema: schema,
+        eventTypeName: stringProperty(element.properties, 'eventTypeName'),
+        canEdit: booleanProperty(element.properties, 'canEdit'),
+        canNotEditReason: stringProperty(element.properties, 'canNotEditReason'),
+        editMode: booleanProperty(element.properties, 'editMode'),
+        onChange: setSchema,
+        className: stringProperty(element.properties, 'className')
+    });
+}
+
+export { SceneSchemaEditor };
+//# sourceMappingURL=SceneSchemaEditor.js.map

package/dist/esm/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,QAAQ,IAAOC,cAAAA,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,eAAAA,CAAgBN,QAAAA,CAAAA;AAE5C,IAAA,qBACIO,GAAA,CAACC,YAAAA,EAAAA;QACGJ,MAAAA,EAAQA,MAAAA;QACRK,aAAAA,EAAeC,cAAAA,CAAeX,OAAAA,CAAQI,UAAU,EAAE,eAAA,CAAA;QAClDQ,OAAAA,EAASC,eAAAA,CAAgBb,OAAAA,CAAQI,UAAU,EAAE,SAAA,CAAA;QAC7CU,gBAAAA,EAAkBH,cAAAA,CAAeX,OAAAA,CAAQI,UAAU,EAAE,kBAAA,CAAA;QACrDW,QAAAA,EAAUF,eAAAA,CAAgBb,OAAAA,CAAQI,UAAU,EAAE,UAAA,CAAA;QAC9CY,QAAAA,EAAUV,SAAAA;QACVW,SAAAA,EAAWN,cAAAA,CAAeX,OAAAA,CAAQI,UAAU,EAAE,WAAA;;AAG1D;;;;"}

package/dist/esm/editors/SceneTimeMachine.d.ts

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

package/dist/esm/editors/SceneTimeMachine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneTimeMachine.d.ts","sourceRoot":"","sources":["../../../editors/SceneTimeMachine.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAa/D,wBAAgB,gBAAgB,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAarE"}

package/dist/esm/editors/SceneTimeMachine.js

@@ -0,0 +1,30 @@
+import { jsx } from 'react/jsx-runtime';
+import { useMemo } from 'react';
+import { TimeMachine } from '@cratis/components/TimeMachine';
+import { numberProperty } from '../properties.js';
+import { timeMachineVersions } from './timeMachineVersions.js';
+import { useEditableCopy } from './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 = useMemo(()=>timeMachineVersions(element.properties), [
+        element.properties
+    ]);
+    const declaredIndex = numberProperty(element.properties, 'currentVersionIndex') ?? 0;
+    const [currentVersionIndex, setCurrentVersionIndex] = useEditableCopy(declaredIndex);
+    return /*#__PURE__*/ jsx(TimeMachine, {
+        versions: versions,
+        currentVersionIndex: currentVersionIndex,
+        onVersionChange: setCurrentVersionIndex,
+        scrollSensitivity: numberProperty(element.properties, 'scrollSensitivity')
+    });
+}
+
+export { SceneTimeMachine };
+//# sourceMappingURL=SceneTimeMachine.js.map

package/dist/esm/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,OAAAA,CAAQ,IAAMC,mBAAAA,CAAoBH,OAAAA,CAAQI,UAAU,CAAA,EAAG;AAACJ,QAAAA,OAAAA,CAAQI;AAAW,KAAA,CAAA;AAC5F,IAAA,MAAMC,aAAAA,GAAgBC,cAAAA,CAAeN,OAAAA,CAAQI,UAAU,EAAE,qBAAA,CAAA,IAA0B,CAAA;AACnF,IAAA,MAAM,CAACG,mBAAAA,EAAqBC,sBAAAA,CAAuB,GAAGC,eAAAA,CAAgBJ,aAAAA,CAAAA;AAEtE,IAAA,qBACIK,GAAA,CAACC,WAAAA,EAAAA;QACGV,QAAAA,EAAUA,QAAAA;QACVM,mBAAAA,EAAqBA,mBAAAA;QACrBK,eAAAA,EAAiBJ,sBAAAA;QACjBK,iBAAAA,EAAmBP,cAAAA,CAAeN,OAAAA,CAAQI,UAAU,EAAE,mBAAA;;AAGlE;;;;"}

package/dist/esm/editors/filterDefinitions.d.ts

@@ -0,0 +1,3 @@
+import { FilterDefinition } from '@cratis/components/Filter';
+export declare function filterDefinitions(properties: Record<string, unknown>): FilterDefinition[];
+//# sourceMappingURL=filterDefinitions.d.ts.map

package/dist/esm/editors/filterDefinitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterDefinitions.d.ts","sourceRoot":"","sources":["../../../editors/filterDefinitions.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAA6B,MAAM,2BAA2B,CAAC;AAaxF,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAAE,CAqBzF"}

package/dist/esm/editors/filterDefinitions.js

@@ -0,0 +1,57 @@
+import { objectArrayProperty, stringProperty, numberProperty, booleanProperty, unionProperty } from '../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) {
+    const entries = objectArrayProperty(properties, 'filters') ?? [];
+    return entries.map((entry)=>{
+        const key = stringProperty(entry, 'key');
+        const label = stringProperty(entry, 'label');
+        if (key === undefined || label === undefined) return undefined;
+        return {
+            key,
+            label,
+            type: unionProperty(entry, 'type', filterTypes),
+            multi: booleanProperty(entry, 'multi'),
+            options: filterOptions(entry),
+            searchable: booleanProperty(entry, 'searchable'),
+            searchPlaceholder: stringProperty(entry, 'searchPlaceholder'),
+            buckets: 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 = objectArrayProperty(entry, 'options');
+    if (options === undefined) return undefined;
+    return options.map((option)=>{
+        const key = stringProperty(option, 'key');
+        const label = stringProperty(option, 'label');
+        if (key === undefined || label === undefined) return undefined;
+        const value = stringProperty(option, 'value') ?? numberProperty(option, 'value') ?? booleanProperty(option, 'value') ?? key;
+        return {
+            key,
+            label,
+            value,
+            count: numberProperty(option, 'count')
+        };
+    }).filter((option)=>option !== undefined);
+}
+
+export { filterDefinitions };
+//# sourceMappingURL=filterDefinitions.js.map

package/dist/esm/editors/filterDefinitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterDefinitions.js","sources":["../../../editors/filterDefinitions.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 { FilterDefinition, FilterOption, FilterValue } from '@cratis/components/Filter';\nimport { booleanProperty, numberProperty, objectArrayProperty, stringProperty, unionProperty } from '../properties';\n\n/** The value kinds a filter can be declared over. */\nconst filterTypes = ['string', 'number', 'date', 'custom'] as const;\n\n/**\n * Reads a `filters` property into the `FilterDefinition` list `FilterPanel` renders.\n *\n * A definition needs a `key` and a `label`; an entry without both is dropped, since a filter with no key\n * has nothing to filter on and one with no label cannot be shown. Everything else is optional and falls\n * through to the panel's own defaults.\n */\nexport function filterDefinitions(properties: Record<string, unknown>): FilterDefinition[] {\n    const entries = objectArrayProperty(properties, 'filters') ?? [];\n\n    return entries\n        .map((entry): FilterDefinition | undefined => {\n            const key = stringProperty(entry, 'key');\n            const label = stringProperty(entry, 'label');\n            if (key === undefined || label === undefined) return undefined;\n\n            return {\n                key,\n                label,\n                type: unionProperty(entry, 'type', filterTypes),\n                multi: booleanProperty(entry, 'multi'),\n                options: filterOptions(entry),\n                searchable: booleanProperty(entry, 'searchable'),\n                searchPlaceholder: stringProperty(entry, 'searchPlaceholder'),\n                buckets: numberProperty(entry, 'buckets'),\n            };\n        })\n        .filter((definition): definition is FilterDefinition => definition !== undefined);\n}\n\n/**\n * Reads one filter's selectable options. An option's `value` is what gets applied and its `key` is what\n * the panel tracks selection by; `value` falls back to the key so the common case of a plain string\n * choice needs only `key` and `label`.\n */\nfunction filterOptions(entry: Record<string, unknown>): FilterOption[] | undefined {\n    const options = objectArrayProperty(entry, 'options');\n    if (options === undefined) return undefined;\n\n    return options\n        .map((option): FilterOption | undefined => {\n            const key = stringProperty(option, 'key');\n            const label = stringProperty(option, 'label');\n            if (key === undefined || label === undefined) return undefined;\n\n            const value: FilterValue = stringProperty(option, 'value') ?? numberProperty(option, 'value') ?? booleanProperty(option, 'value') ?? key;\n            return { key, label, value, count: numberProperty(option, 'count') };\n        })\n        .filter((option): option is FilterOption => option !== undefined);\n}\n"],"names":["filterTypes","filterDefinitions","properties","entries","objectArrayProperty","map","entry","key","stringProperty","label","undefined","type","unionProperty","multi","booleanProperty","options","filterOptions","searchable","searchPlaceholder","buckets","numberProperty","filter","definition","option","value","count"],"mappings":";;AAAA;AACA;AAKA,sDACA,MAAMA,WAAAA,GAAc;AAAC,IAAA,QAAA;AAAU,IAAA,QAAA;AAAU,IAAA,MAAA;AAAQ,IAAA;AAAS,CAAA;AAE1D;;;;;;IAOO,SAASC,iBAAAA,CAAkBC,UAAmC,EAAA;AACjE,IAAA,MAAMC,OAAAA,GAAUC,mBAAAA,CAAoBF,UAAAA,EAAY,SAAA,CAAA,IAAc,EAAE;IAEhE,OAAOC,OAAAA,CACFE,GAAG,CAAC,CAACC,KAAAA,GAAAA;QACF,MAAMC,GAAAA,GAAMC,eAAeF,KAAAA,EAAO,KAAA,CAAA;QAClC,MAAMG,KAAAA,GAAQD,eAAeF,KAAAA,EAAO,OAAA,CAAA;AACpC,QAAA,IAAIC,GAAAA,KAAQG,SAAAA,IAAaD,KAAAA,KAAUC,SAAAA,EAAW,OAAOA,SAAAA;QAErD,OAAO;AACHH,YAAAA,GAAAA;AACAE,YAAAA,KAAAA;YACAE,IAAAA,EAAMC,aAAAA,CAAcN,OAAO,MAAA,EAAQN,WAAAA,CAAAA;AACnCa,YAAAA,KAAAA,EAAOC,gBAAgBR,KAAAA,EAAO,OAAA,CAAA;AAC9BS,YAAAA,OAAAA,EAASC,aAAAA,CAAcV,KAAAA,CAAAA;AACvBW,YAAAA,UAAAA,EAAYH,gBAAgBR,KAAAA,EAAO,YAAA,CAAA;AACnCY,YAAAA,iBAAAA,EAAmBV,eAAeF,KAAAA,EAAO,mBAAA,CAAA;AACzCa,YAAAA,OAAAA,EAASC,eAAed,KAAAA,EAAO,SAAA;AACnC,SAAA;AACJ,IAAA,CAAA,CAAA,CACCe,MAAM,CAAC,CAACC,UAAAA,GAA+CA,UAAAA,KAAeZ,SAAAA,CAAAA;AAC/E;AAEA;;;;IAKA,SAASM,cAAcV,KAA8B,EAAA;IACjD,MAAMS,OAAAA,GAAUX,oBAAoBE,KAAAA,EAAO,SAAA,CAAA;IAC3C,IAAIS,OAAAA,KAAYL,WAAW,OAAOA,SAAAA;IAElC,OAAOK,OAAAA,CACFV,GAAG,CAAC,CAACkB,MAAAA,GAAAA;QACF,MAAMhB,GAAAA,GAAMC,eAAee,MAAAA,EAAQ,KAAA,CAAA;QACnC,MAAMd,KAAAA,GAAQD,eAAee,MAAAA,EAAQ,OAAA,CAAA;AACrC,QAAA,IAAIhB,GAAAA,KAAQG,SAAAA,IAAaD,KAAAA,KAAUC,SAAAA,EAAW,OAAOA,SAAAA;QAErD,MAAMc,KAAAA,GAAqBhB,eAAee,MAAAA,EAAQ,OAAA,CAAA,IAAYH,eAAeG,MAAAA,EAAQ,OAAA,CAAA,IAAYT,eAAAA,CAAgBS,MAAAA,EAAQ,OAAA,CAAA,IAAYhB,GAAAA;QACrI,OAAO;AAAEA,YAAAA,GAAAA;AAAKE,YAAAA,KAAAA;AAAOe,YAAAA,KAAAA;AAAOC,YAAAA,KAAAA,EAAOL,eAAeG,MAAAA,EAAQ,OAAA;AAAS,SAAA;AACvE,IAAA,CAAA,CAAA,CACCF,MAAM,CAAC,CAACE,MAAAA,GAAmCA,MAAAA,KAAWb,SAAAA,CAAAA;AAC/D;;;;"}

package/dist/esm/editors/for_SceneObjectNavigationalBar/when_navigating_back_up_the_trail.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=when_navigating_back_up_the_trail.d.ts.map

package/dist/esm/editors/for_SceneObjectNavigationalBar/when_navigating_back_up_the_trail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"when_navigating_back_up_the_trail.d.ts","sourceRoot":"","sources":["../../../../editors/for_SceneObjectNavigationalBar/when_navigating_back_up_the_trail.tsx"],"names":[],"mappings":""}

package/dist/esm/editors/for_SceneObjectNavigationalBar/when_navigating_back_up_the_trail.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen } from '@testing-library/react';
+import { externalComponent } from '../../given';
+import { SceneObjectNavigationalBar } from '../SceneObjectNavigationalBar';
+describe('when navigating back up the trail', () => {
+    beforeEach(() => {
+        const element = externalComponent('Cratis.Components:objectNavigationalBar', { navigationPath: ['shipping', 'address', 'street'] });
+        render(_jsx(SceneObjectNavigationalBar, { element: element, slots: {} }));
+        fireEvent.click(screen.getByText('address'));
+    });
+    it('should keep the crumb that was clicked', () => screen.getByText('address').textContent.should.equal('address'));
+    it('should keep everything above it', () => screen.getByText('shipping').textContent.should.equal('shipping'));
+    it('should drop everything below it', () => (screen.queryByText('street') === null).should.be.true);
+});
+//# sourceMappingURL=when_navigating_back_up_the_trail.js.map

package/dist/esm/editors/for_SceneObjectNavigationalBar/when_navigating_back_up_the_trail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"when_navigating_back_up_the_trail.js","sourceRoot":"","sources":["../../../../editors/for_SceneObjectNavigationalBar/when_navigating_back_up_the_trail.tsx"],"names":[],"mappings":";AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAE3E,QAAQ,CAAC,mCAAmC,EAAE,GAAG,EAAE;IAC/C,UAAU,CAAC,GAAG,EAAE;QACZ,MAAM,OAAO,GAAG,iBAAiB,CAAC,yCAAyC,EAAE,EAAE,cAAc,EAAE,CAAC,UAAU,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;QACpI,MAAM,CAAC,KAAC,0BAA0B,IAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,GAAI,CAAC,CAAC;QACpE,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC;IACjD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,WAAY,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;IACrH,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,WAAY,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;IAChH,EAAE,CAAC,iCAAiC,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;AACxG,CAAC,CAAC,CAAC"}

package/dist/esm/editors/for_filterDefinitions/when_reading_filter_definitions.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=when_reading_filter_definitions.d.ts.map

package/dist/esm/editors/for_filterDefinitions/when_reading_filter_definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"when_reading_filter_definitions.d.ts","sourceRoot":"","sources":["../../../../editors/for_filterDefinitions/when_reading_filter_definitions.ts"],"names":[],"mappings":""}