@cratis/scene.components 0.1.0

package/dist/cjs/forms/fields/SceneRadioButtonField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneRadioButtonField.js","sources":["../../../../forms/fields/SceneRadioButtonField.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 { numberProperty, stringProperty } from '../../properties';\nimport { CommandFormField } from './CommandFormField';\n\nconst RadioButtonField = lazy(async () => ({ default: (await import('@cratis/components/CommandForm')).RadioButtonField }));\n\n/**\n * The `Cratis.Components:radioButtonField` component - `RadioButtonField` from\n * `@cratis/components/CommandForm`.\n *\n * One button of a mutually exclusive set, for a screen that needs the choices placed individually rather\n * than as a block. `buttonValue` is the value this particular button writes to the bound property, and\n * the whole set is tied together by every button naming the same `property`.\n *\n * `buttonValue` is read as a string first and a number second, since a choice is usually a string but a\n * numeric code is common enough that forcing it through as `'1'` would bind the wrong value.\n */\nexport function SceneRadioButtonField({ element }: RegisteredComponentProps) {\n    const buttonValue = stringProperty(element.properties, 'buttonValue') ?? numberProperty(element.properties, 'buttonValue') ?? '';\n\n    return (\n        <CommandFormField element={element}>\n            {binding => (\n                <RadioButtonField\n                    {...binding}\n                    buttonValue={buttonValue}\n                    label={stringProperty(element.properties, 'label')}\n                    className={stringProperty(element.properties, 'className')}\n                />\n            )}\n        </CommandFormField>\n    );\n}\n"],"names":["RadioButtonField","lazy","default","SceneRadioButtonField","element","buttonValue","stringProperty","properties","numberProperty","_jsx","CommandFormField","binding","label","className"],"mappings":";;;;;;;AAQA,MAAMA,gBAAAA,iBAAmBC,UAAAA,CAAK,WAAa;AAAEC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,gCAAA,CAAgC,EAAGF;KAAiB,CAAA,CAAA;AAExH;;;;;;;;;;AAUC,IACM,SAASG,qBAAAA,CAAsB,EAAEC,OAAO,EAA4B,EAAA;IACvE,MAAMC,WAAAA,GAAcC,yBAAAA,CAAeF,OAAAA,CAAQG,UAAU,EAAE,kBAAkBC,yBAAAA,CAAeJ,OAAAA,CAAQG,UAAU,EAAE,aAAA,CAAA,IAAkB,EAAA;AAE9H,IAAA,qBACIE,cAAA,CAACC,iCAAAA,EAAAA;QAAiBN,OAAAA,EAASA,OAAAA;AACtBO,QAAAA,QAAAA,EAAAA,CAAAA,wBACGF,cAAA,CAACT,gBAAAA,EAAAA;AACI,gBAAA,GAAGW,OAAO;gBACXN,WAAAA,EAAaA,WAAAA;gBACbO,KAAAA,EAAON,yBAAAA,CAAeF,OAAAA,CAAQG,UAAU,EAAE,OAAA,CAAA;gBAC1CM,SAAAA,EAAWP,yBAAAA,CAAeF,OAAAA,CAAQG,UAAU,EAAE,WAAA;;;AAKlE;;;;"}

package/dist/cjs/forms/fields/SceneRadioGroupField.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var properties = require('../../properties.js');
+var CommandFormField = require('./CommandFormField.js');
+
+const RadioGroupField = /*#__PURE__*/ react.lazy(async ()=>({
+        default: (await import('@cratis/components/CommandForm')).RadioGroupField
+    }));
+/** Whether the group's buttons stack or sit in a row. */ const layouts = [
+    'horizontal',
+    'vertical'
+];
+/**
+ * The `Cratis.Components:radioGroupField` component - `RadioGroupField` from
+ * `@cratis/components/CommandForm`.
+ *
+ * A whole mutually exclusive choice from one options list, which is what a screen almost always wants.
+ * Use `radioButtonField` only when the individual buttons have to be placed apart from one another.
+ */ function SceneRadioGroupField({ element }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(CommandFormField.CommandFormField, {
+        element: element,
+        children: (binding)=>/*#__PURE__*/ jsxRuntime.jsx(RadioGroupField, {
+                ...binding,
+                options: properties.objectArrayProperty(element.properties, 'options') ?? [],
+                optionLabel: properties.stringProperty(element.properties, 'optionLabel') ?? 'label',
+                optionValue: properties.stringProperty(element.properties, 'optionValue') ?? 'value',
+                layout: properties.unionProperty(element.properties, 'layout', layouts),
+                className: properties.stringProperty(element.properties, 'className')
+            })
+    });
+}
+
+exports.SceneRadioGroupField = SceneRadioGroupField;
+//# sourceMappingURL=SceneRadioGroupField.js.map

package/dist/cjs/forms/fields/SceneRadioGroupField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneRadioGroupField.js","sources":["../../../../forms/fields/SceneRadioGroupField.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 { objectArrayProperty, stringProperty, unionProperty } from '../../properties';\nimport { CommandFormField } from './CommandFormField';\n\nconst RadioGroupField = lazy(async () => ({ default: (await import('@cratis/components/CommandForm')).RadioGroupField }));\n\n/** Whether the group's buttons stack or sit in a row. */\nconst layouts = ['horizontal', 'vertical'] as const;\n\n/**\n * The `Cratis.Components:radioGroupField` component - `RadioGroupField` from\n * `@cratis/components/CommandForm`.\n *\n * A whole mutually exclusive choice from one options list, which is what a screen almost always wants.\n * Use `radioButtonField` only when the individual buttons have to be placed apart from one another.\n */\nexport function SceneRadioGroupField({ element }: RegisteredComponentProps) {\n    return (\n        <CommandFormField element={element}>\n            {binding => (\n                <RadioGroupField\n                    {...binding}\n                    options={objectArrayProperty(element.properties, 'options') ?? []}\n                    optionLabel={stringProperty(element.properties, 'optionLabel') ?? 'label'}\n                    optionValue={stringProperty(element.properties, 'optionValue') ?? 'value'}\n                    layout={unionProperty(element.properties, 'layout', layouts)}\n                    className={stringProperty(element.properties, 'className')}\n                />\n            )}\n        </CommandFormField>\n    );\n}\n"],"names":["RadioGroupField","lazy","default","layouts","SceneRadioGroupField","element","_jsx","CommandFormField","binding","options","objectArrayProperty","properties","optionLabel","stringProperty","optionValue","layout","unionProperty","className"],"mappings":";;;;;;;AAQA,MAAMA,eAAAA,iBAAkBC,UAAAA,CAAK,WAAa;AAAEC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,gCAAA,CAAgC,EAAGF;KAAgB,CAAA,CAAA;AAEtH,0DACA,MAAMG,OAAAA,GAAU;AAAC,IAAA,YAAA;AAAc,IAAA;AAAW,CAAA;AAE1C;;;;;;AAMC,IACM,SAASC,oBAAAA,CAAqB,EAAEC,OAAO,EAA4B,EAAA;AACtE,IAAA,qBACIC,cAAA,CAACC,iCAAAA,EAAAA;QAAiBF,OAAAA,EAASA,OAAAA;AACtBG,QAAAA,QAAAA,EAAAA,CAAAA,wBACGF,cAAA,CAACN,eAAAA,EAAAA;AACI,gBAAA,GAAGQ,OAAO;AACXC,gBAAAA,OAAAA,EAASC,8BAAAA,CAAoBL,OAAAA,CAAQM,UAAU,EAAE,cAAc,EAAE;AACjEC,gBAAAA,WAAAA,EAAaC,yBAAAA,CAAeR,OAAAA,CAAQM,UAAU,EAAE,aAAA,CAAA,IAAkB,OAAA;AAClEG,gBAAAA,WAAAA,EAAaD,yBAAAA,CAAeR,OAAAA,CAAQM,UAAU,EAAE,aAAA,CAAA,IAAkB,OAAA;AAClEI,gBAAAA,MAAAA,EAAQC,wBAAAA,CAAcX,OAAAA,CAAQM,UAAU,EAAE,QAAA,EAAUR,OAAAA,CAAAA;gBACpDc,SAAAA,EAAWJ,yBAAAA,CAAeR,OAAAA,CAAQM,UAAU,EAAE,WAAA;;;AAKlE;;;;"}

package/dist/cjs/forms/fields/SceneSliderField.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var properties = require('../../properties.js');
+var CommandFormField = require('./CommandFormField.js');
+
+const SliderField = /*#__PURE__*/ react.lazy(async ()=>({
+        default: (await import('@cratis/components/CommandForm')).SliderField
+    }));
+/**
+ * The `Cratis.Components:sliderField` component - `SliderField` from `@cratis/components/CommandForm`.
+ *
+ * A numeric field where the range itself is the point - a percentage, a threshold, a weighting. Prefer
+ * `numberField` whenever the exact value matters more than its position in a range; a slider trades
+ * precision for a sense of scale, and that is only ever a deliberate choice.
+ */ function SceneSliderField({ element }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(CommandFormField.CommandFormField, {
+        element: element,
+        children: (binding)=>/*#__PURE__*/ jsxRuntime.jsx(SliderField, {
+                ...binding,
+                min: properties.numberProperty(element.properties, 'min'),
+                max: properties.numberProperty(element.properties, 'max'),
+                step: properties.numberProperty(element.properties, 'step'),
+                className: properties.stringProperty(element.properties, 'className')
+            })
+    });
+}
+
+exports.SceneSliderField = SceneSliderField;
+//# sourceMappingURL=SceneSliderField.js.map

package/dist/cjs/forms/fields/SceneSliderField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneSliderField.js","sources":["../../../../forms/fields/SceneSliderField.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 { numberProperty, stringProperty } from '../../properties';\nimport { CommandFormField } from './CommandFormField';\n\nconst SliderField = lazy(async () => ({ default: (await import('@cratis/components/CommandForm')).SliderField }));\n\n/**\n * The `Cratis.Components:sliderField` component - `SliderField` from `@cratis/components/CommandForm`.\n *\n * A numeric field where the range itself is the point - a percentage, a threshold, a weighting. Prefer\n * `numberField` whenever the exact value matters more than its position in a range; a slider trades\n * precision for a sense of scale, and that is only ever a deliberate choice.\n */\nexport function SceneSliderField({ element }: RegisteredComponentProps) {\n    return (\n        <CommandFormField element={element}>\n            {binding => (\n                <SliderField\n                    {...binding}\n                    min={numberProperty(element.properties, 'min')}\n                    max={numberProperty(element.properties, 'max')}\n                    step={numberProperty(element.properties, 'step')}\n                    className={stringProperty(element.properties, 'className')}\n                />\n            )}\n        </CommandFormField>\n    );\n}\n"],"names":["SliderField","lazy","default","SceneSliderField","element","_jsx","CommandFormField","binding","min","numberProperty","properties","max","step","className","stringProperty"],"mappings":";;;;;;;AAQA,MAAMA,WAAAA,iBAAcC,UAAAA,CAAK,WAAa;AAAEC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,gCAAA,CAAgC,EAAGF;KAAY,CAAA,CAAA;AAE9G;;;;;;AAMC,IACM,SAASG,gBAAAA,CAAiB,EAAEC,OAAO,EAA4B,EAAA;AAClE,IAAA,qBACIC,cAAA,CAACC,iCAAAA,EAAAA;QAAiBF,OAAAA,EAASA,OAAAA;AACtBG,QAAAA,QAAAA,EAAAA,CAAAA,wBACGF,cAAA,CAACL,WAAAA,EAAAA;AACI,gBAAA,GAAGO,OAAO;gBACXC,GAAAA,EAAKC,yBAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,KAAA,CAAA;gBACxCC,GAAAA,EAAKF,yBAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,KAAA,CAAA;gBACxCE,IAAAA,EAAMH,yBAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,MAAA,CAAA;gBACzCG,SAAAA,EAAWC,yBAAAA,CAAeV,OAAAA,CAAQM,UAAU,EAAE,WAAA;;;AAKlE;;;;"}

package/dist/cjs/forms/fields/SceneTextAreaField.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var properties = require('../../properties.js');
+var CommandFormField = require('./CommandFormField.js');
+
+const TextAreaField = /*#__PURE__*/ react.lazy(async ()=>({
+        default: (await import('@cratis/components/CommandForm')).TextAreaField
+    }));
+/**
+ * The `Cratis.Components:textAreaField` component - `TextAreaField` from `@cratis/components/CommandForm`.
+ *
+ * The multi-line counterpart to `inputTextField`. A separate name rather than a `multiline` flag on that
+ * one, because the two wrap different PrimeReact inputs and take different sizing props - collapsing
+ * them would mean a `rows` property that is meaningless half the time.
+ */ function SceneTextAreaField({ element }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(CommandFormField.CommandFormField, {
+        element: element,
+        children: (binding)=>/*#__PURE__*/ jsxRuntime.jsx(TextAreaField, {
+                ...binding,
+                placeholder: properties.stringProperty(element.properties, 'placeholder'),
+                rows: properties.numberProperty(element.properties, 'rows'),
+                cols: properties.numberProperty(element.properties, 'cols'),
+                className: properties.stringProperty(element.properties, 'className')
+            })
+    });
+}
+
+exports.SceneTextAreaField = SceneTextAreaField;
+//# sourceMappingURL=SceneTextAreaField.js.map

package/dist/cjs/forms/fields/SceneTextAreaField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneTextAreaField.js","sources":["../../../../forms/fields/SceneTextAreaField.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 { numberProperty, stringProperty } from '../../properties';\nimport { CommandFormField } from './CommandFormField';\n\nconst TextAreaField = lazy(async () => ({ default: (await import('@cratis/components/CommandForm')).TextAreaField }));\n\n/**\n * The `Cratis.Components:textAreaField` component - `TextAreaField` from `@cratis/components/CommandForm`.\n *\n * The multi-line counterpart to `inputTextField`. A separate name rather than a `multiline` flag on that\n * one, because the two wrap different PrimeReact inputs and take different sizing props - collapsing\n * them would mean a `rows` property that is meaningless half the time.\n */\nexport function SceneTextAreaField({ element }: RegisteredComponentProps) {\n    return (\n        <CommandFormField element={element}>\n            {binding => (\n                <TextAreaField\n                    {...binding}\n                    placeholder={stringProperty(element.properties, 'placeholder')}\n                    rows={numberProperty(element.properties, 'rows')}\n                    cols={numberProperty(element.properties, 'cols')}\n                    className={stringProperty(element.properties, 'className')}\n                />\n            )}\n        </CommandFormField>\n    );\n}\n"],"names":["TextAreaField","lazy","default","SceneTextAreaField","element","_jsx","CommandFormField","binding","placeholder","stringProperty","properties","rows","numberProperty","cols","className"],"mappings":";;;;;;;AAQA,MAAMA,aAAAA,iBAAgBC,UAAAA,CAAK,WAAa;AAAEC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,gCAAA,CAAgC,EAAGF;KAAc,CAAA,CAAA;AAElH;;;;;;AAMC,IACM,SAASG,kBAAAA,CAAmB,EAAEC,OAAO,EAA4B,EAAA;AACpE,IAAA,qBACIC,cAAA,CAACC,iCAAAA,EAAAA;QAAiBF,OAAAA,EAASA,OAAAA;AACtBG,QAAAA,QAAAA,EAAAA,CAAAA,wBACGF,cAAA,CAACL,aAAAA,EAAAA;AACI,gBAAA,GAAGO,OAAO;gBACXC,WAAAA,EAAaC,yBAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,aAAA,CAAA;gBAChDC,IAAAA,EAAMC,yBAAAA,CAAeR,OAAAA,CAAQM,UAAU,EAAE,MAAA,CAAA;gBACzCG,IAAAA,EAAMD,yBAAAA,CAAeR,OAAAA,CAAQM,UAAU,EAAE,MAAA,CAAA;gBACzCI,SAAAA,EAAWL,yBAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,WAAA;;;AAKlE;;;;"}

package/dist/cjs/forms/fields/resolveFieldBinding.js

@@ -0,0 +1,27 @@
+'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.
+/**
+ * Turns an element's `property` name into the {@link FieldBinding} a `@cratis/components` field takes,
+ * or `undefined` when the screen never named a property.
+ *
+ * `undefined` rather than a default accessor, because a field bound to nothing is not a field with an
+ * empty value - it is a field that would silently never read or write anything, and the screen author
+ * needs to see that. The caller renders a placeholder instead.
+ *
+ * The label falls back to the property name, so a field is legible before anyone has written a `title`.
+ */ function resolveFieldBinding(element) {
+    const property = properties.stringProperty(element.properties, 'property');
+    if (property === undefined) return undefined;
+    return {
+        value: (instance)=>instance[property],
+        title: properties.stringProperty(element.properties, 'title') ?? property,
+        description: properties.stringProperty(element.properties, 'description')
+    };
+}
+
+exports.resolveFieldBinding = resolveFieldBinding;
+//# sourceMappingURL=resolveFieldBinding.js.map

package/dist/cjs/forms/fields/resolveFieldBinding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveFieldBinding.js","sources":["../../../../forms/fields/resolveFieldBinding.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { ExternalComponent } from '@cratis/scene.model';\nimport { stringProperty } from '../../properties';\nimport { FieldBinding } from './FieldBinding';\n\n/**\n * Turns an element's `property` name into the {@link FieldBinding} a `@cratis/components` field takes,\n * or `undefined` when the screen never named a property.\n *\n * `undefined` rather than a default accessor, because a field bound to nothing is not a field with an\n * empty value - it is a field that would silently never read or write anything, and the screen author\n * needs to see that. The caller renders a placeholder instead.\n *\n * The label falls back to the property name, so a field is legible before anyone has written a `title`.\n */\nexport function resolveFieldBinding(element: ExternalComponent): FieldBinding | undefined {\n    const property = stringProperty(element.properties, 'property');\n    if (property === undefined) return undefined;\n\n    return {\n        value: (instance: Record<string, unknown>) => instance[property],\n        title: stringProperty(element.properties, 'title') ?? property,\n        description: stringProperty(element.properties, 'description'),\n    };\n}\n"],"names":["resolveFieldBinding","element","property","stringProperty","properties","undefined","value","instance","title","description"],"mappings":";;;;AAAA;AACA;AAMA;;;;;;;;;IAUO,SAASA,mBAAAA,CAAoBC,OAA0B,EAAA;AAC1D,IAAA,MAAMC,QAAAA,GAAWC,yBAAAA,CAAeF,OAAAA,CAAQG,UAAU,EAAE,UAAA,CAAA;IACpD,IAAIF,QAAAA,KAAaG,WAAW,OAAOA,SAAAA;IAEnC,OAAO;AACHC,QAAAA,KAAAA,EAAO,CAACC,QAAAA,GAAsCA,QAAQ,CAACL,QAAAA,CAAS;AAChEM,QAAAA,KAAAA,EAAOL,yBAAAA,CAAeF,OAAAA,CAAQG,UAAU,EAAE,OAAA,CAAA,IAAYF,QAAAA;QACtDO,WAAAA,EAAaN,yBAAAA,CAAeF,OAAAA,CAAQG,UAAU,EAAE,aAAA;AACpD,KAAA;AACJ;;;;"}

package/dist/cjs/index.js

@@ -0,0 +1,123 @@
+'use strict';
+
+var properties = require('./properties.js');
+var BindingKind = require('./bindings/BindingKind.js');
+var bindingRegistry = require('./bindings/bindingRegistry.js');
+var resolveElementBinding = require('./bindings/resolveElementBinding.js');
+var Placeholder = require('./bindings/Placeholder.js');
+var MissingBinding = require('./bindings/MissingBinding.js');
+var ArcRuntimeBoundary = require('./bindings/ArcRuntimeBoundary.js');
+var ScenePage = require('./pages/ScenePage.js');
+var SceneDataPage = require('./pages/SceneDataPage.js');
+var SceneFormElement = require('./pages/SceneFormElement.js');
+var SceneDataTable = require('./data/SceneDataTable.js');
+var SceneObservableDataTable = require('./data/SceneObservableDataTable.js');
+var SceneCommandForm = require('./forms/SceneCommandForm.js');
+var resolveFieldBinding = require('./forms/fields/resolveFieldBinding.js');
+var CommandFormField = require('./forms/fields/CommandFormField.js');
+var SceneInputTextField = require('./forms/fields/SceneInputTextField.js');
+var SceneNumberField = require('./forms/fields/SceneNumberField.js');
+var SceneCheckboxField = require('./forms/fields/SceneCheckboxField.js');
+var SceneTextAreaField = require('./forms/fields/SceneTextAreaField.js');
+var SceneDropdownField = require('./forms/fields/SceneDropdownField.js');
+var SceneSliderField = require('./forms/fields/SceneSliderField.js');
+var SceneCalendarField = require('./forms/fields/SceneCalendarField.js');
+var SceneColorPickerField = require('./forms/fields/SceneColorPickerField.js');
+var SceneMultiSelectField = require('./forms/fields/SceneMultiSelectField.js');
+var SceneChipsField = require('./forms/fields/SceneChipsField.js');
+var SceneRadioButtonField = require('./forms/fields/SceneRadioButtonField.js');
+var SceneRadioGroupField = require('./forms/fields/SceneRadioGroupField.js');
+var SceneDialog = require('./dialogs/SceneDialog.js');
+var SceneConfirmationDialog = require('./dialogs/SceneConfirmationDialog.js');
+var SceneBusyIndicatorDialog = require('./dialogs/SceneBusyIndicatorDialog.js');
+var SceneCommandDialog = require('./dialogs/SceneCommandDialog.js');
+var SceneStepperCommandDialog = require('./dialogs/SceneStepperCommandDialog.js');
+var SceneIcon = require('./common/SceneIcon.js');
+var SceneTooltip = require('./common/SceneTooltip.js');
+var SceneErrorBoundary = require('./common/SceneErrorBoundary.js');
+var SceneDropdown = require('./common/SceneDropdown.js');
+var useEditableCopy = require('./editors/useEditableCopy.js');
+var timeMachineVersions = require('./editors/timeMachineVersions.js');
+var filterDefinitions = require('./editors/filterDefinitions.js');
+var SceneObjectContentEditor = require('./editors/SceneObjectContentEditor.js');
+var SceneObjectNavigationalBar = require('./editors/SceneObjectNavigationalBar.js');
+var SceneSchemaEditor = require('./editors/SceneSchemaEditor.js');
+var SceneTimeMachine = require('./editors/SceneTimeMachine.js');
+var SceneFilterPanel = require('./editors/SceneFilterPanel.js');
+var SceneToolbar = require('./toolbar/SceneToolbar.js');
+var SceneToolbarButton = require('./toolbar/SceneToolbarButton.js');
+var SceneToolbarGroup = require('./toolbar/SceneToolbarGroup.js');
+var SceneToolbarSeparator = require('./toolbar/SceneToolbarSeparator.js');
+var cratisComponents = require('./cratisComponents.js');
+var cratisComponentsPackage = require('./cratisComponentsPackage.js');
+
+
+
+exports.arrayProperty = properties.arrayProperty;
+exports.booleanProperty = properties.booleanProperty;
+exports.numberProperty = properties.numberProperty;
+exports.objectArrayProperty = properties.objectArrayProperty;
+exports.objectProperty = properties.objectProperty;
+exports.stringArrayProperty = properties.stringArrayProperty;
+exports.stringProperty = properties.stringProperty;
+exports.unionProperty = properties.unionProperty;
+exports.BindingKind = BindingKind.BindingKind;
+exports.clearBindings = bindingRegistry.clearBindings;
+exports.registerCommand = bindingRegistry.registerCommand;
+exports.registerCommands = bindingRegistry.registerCommands;
+exports.registerQueries = bindingRegistry.registerQueries;
+exports.registerQuery = bindingRegistry.registerQuery;
+exports.registeredCommandNames = bindingRegistry.registeredCommandNames;
+exports.registeredQueryNames = bindingRegistry.registeredQueryNames;
+exports.resolveCommand = bindingRegistry.resolveCommand;
+exports.resolveQuery = bindingRegistry.resolveQuery;
+exports.resolveElementBinding = resolveElementBinding.resolveElementBinding;
+exports.Placeholder = Placeholder.Placeholder;
+exports.MissingBinding = MissingBinding.MissingBinding;
+exports.ArcRuntimeBoundary = ArcRuntimeBoundary.ArcRuntimeBoundary;
+exports.ScenePage = ScenePage.ScenePage;
+exports.SceneDataPage = SceneDataPage.SceneDataPage;
+exports.SceneFormElement = SceneFormElement.SceneFormElement;
+exports.SceneDataTable = SceneDataTable.SceneDataTable;
+exports.SceneObservableDataTable = SceneObservableDataTable.SceneObservableDataTable;
+exports.SceneCommandForm = SceneCommandForm.SceneCommandForm;
+exports.resolveFieldBinding = resolveFieldBinding.resolveFieldBinding;
+exports.CommandFormField = CommandFormField.CommandFormField;
+exports.SceneInputTextField = SceneInputTextField.SceneInputTextField;
+exports.SceneNumberField = SceneNumberField.SceneNumberField;
+exports.SceneCheckboxField = SceneCheckboxField.SceneCheckboxField;
+exports.SceneTextAreaField = SceneTextAreaField.SceneTextAreaField;
+exports.SceneDropdownField = SceneDropdownField.SceneDropdownField;
+exports.SceneSliderField = SceneSliderField.SceneSliderField;
+exports.SceneCalendarField = SceneCalendarField.SceneCalendarField;
+exports.SceneColorPickerField = SceneColorPickerField.SceneColorPickerField;
+exports.SceneMultiSelectField = SceneMultiSelectField.SceneMultiSelectField;
+exports.SceneChipsField = SceneChipsField.SceneChipsField;
+exports.SceneRadioButtonField = SceneRadioButtonField.SceneRadioButtonField;
+exports.SceneRadioGroupField = SceneRadioGroupField.SceneRadioGroupField;
+exports.SceneDialog = SceneDialog.SceneDialog;
+exports.SceneConfirmationDialog = SceneConfirmationDialog.SceneConfirmationDialog;
+exports.SceneBusyIndicatorDialog = SceneBusyIndicatorDialog.SceneBusyIndicatorDialog;
+exports.SceneCommandDialog = SceneCommandDialog.SceneCommandDialog;
+exports.SceneStepperCommandDialog = SceneStepperCommandDialog.SceneStepperCommandDialog;
+exports.SceneIcon = SceneIcon.SceneIcon;
+exports.SceneTooltip = SceneTooltip.SceneTooltip;
+exports.SceneErrorBoundary = SceneErrorBoundary.SceneErrorBoundary;
+exports.SceneDropdown = SceneDropdown.SceneDropdown;
+exports.useEditableCopy = useEditableCopy.useEditableCopy;
+exports.timeMachineVersions = timeMachineVersions.timeMachineVersions;
+exports.filterDefinitions = filterDefinitions.filterDefinitions;
+exports.SceneObjectContentEditor = SceneObjectContentEditor.SceneObjectContentEditor;
+exports.SceneObjectNavigationalBar = SceneObjectNavigationalBar.SceneObjectNavigationalBar;
+exports.SceneSchemaEditor = SceneSchemaEditor.SceneSchemaEditor;
+exports.SceneTimeMachine = SceneTimeMachine.SceneTimeMachine;
+exports.SceneFilterPanel = SceneFilterPanel.SceneFilterPanel;
+exports.SceneToolbar = SceneToolbar.SceneToolbar;
+exports.SceneToolbarButton = SceneToolbarButton.SceneToolbarButton;
+exports.SceneToolbarGroup = SceneToolbarGroup.SceneToolbarGroup;
+exports.SceneToolbarSeparator = SceneToolbarSeparator.SceneToolbarSeparator;
+exports.cratisComponents = cratisComponents.cratisComponents;
+exports.cratisComponentsPackageName = cratisComponents.cratisComponentsPackageName;
+exports.cratisComponentsPackage = cratisComponentsPackage.cratisComponentsPackage;
+exports.cratisComponentsPackageManifest = cratisComponentsPackage.cratisComponentsPackageManifest;
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/pages/SceneDataPage.js

@@ -0,0 +1,45 @@
+'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 DataPage = /*#__PURE__*/ react.lazy(async ()=>({
+        default: (await import('@cratis/components/DataPage')).DataPage
+    }));
+/**
+ * The `Cratis.Components:dataPage` component - `DataPage` from `@cratis/components/DataPage`.
+ *
+ * The library's whole list-screen composite in one name: title bar, menubar, filterable table and
+ * optional details pane, all driven from a single query. It is the single highest-leverage thing this
+ * package exposes, because reproducing it out of `table` and `toolbar` in a screen would be pages of
+ * modeling for a worse result.
+ *
+ * The `query` property names an Arc query proxy; the columns and menu items come from the `content`
+ * slot as `DataPage.Columns` / `DataPage.MenuItems` children.
+ */ function SceneDataPage({ 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(DataPage, {
+            title: properties.stringProperty(element.properties, 'title') ?? '',
+            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'),
+            children: slots.content
+        })
+    });
+}
+
+exports.SceneDataPage = SceneDataPage;
+//# sourceMappingURL=SceneDataPage.js.map

package/dist/cjs/pages/SceneDataPage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneDataPage.js","sources":["../../../pages/SceneDataPage.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 DataPage = lazy(async () => ({ default: (await import('@cratis/components/DataPage')).DataPage }));\n\n/**\n * The `Cratis.Components:dataPage` component - `DataPage` from `@cratis/components/DataPage`.\n *\n * The library's whole list-screen composite in one name: title bar, menubar, filterable table and\n * optional details pane, all driven from a single query. It is the single highest-leverage thing this\n * package exposes, because reproducing it out of `table` and `toolbar` in a screen would be pages of\n * modeling for a worse result.\n *\n * The `query` property names an Arc query proxy; the columns and menu items come from the `content`\n * slot as `DataPage.Columns` / `DataPage.MenuItems` children.\n */\nexport function SceneDataPage({ 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            <DataPage\n                title={stringProperty(element.properties, 'title') ?? ''}\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            >\n                {slots.content}\n            </DataPage>\n        </ArcRuntimeBoundary>\n    );\n}\n"],"names":["DataPage","lazy","default","SceneDataPage","element","slots","name","target","resolveElementBinding","BindingKind","Query","_jsx","MissingBinding","kind","ArcRuntimeBoundary","title","stringProperty","properties","query","emptyMessage","dataKey","globalFilterFields","stringArrayProperty","clientFiltering","booleanProperty","content"],"mappings":";;;;;;;;;;AAQA,MAAMA,QAAAA,iBAAWC,UAAAA,CAAK,WAAa;AAAEC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,6BAAA,CAA6B,EAAGF;KAAS,CAAA,CAAA;AAErG;;;;;;;;;;AAUC,IACM,SAASG,aAAAA,CAAc,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;IACtE,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,QAAAA,EAAAA;AACGe,YAAAA,KAAAA,EAAOC,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,OAAA,CAAA,IAAY,EAAA;YACtDC,KAAAA,EAAOX,MAAAA;AACPY,YAAAA,YAAAA,EAAcH,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,cAAA,CAAA,IAAmB,EAAA;YACpEG,OAAAA,EAASJ,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,SAAA,CAAA;YAC5CI,kBAAAA,EAAoBC,8BAAAA,CAAoBlB,OAAAA,CAAQa,UAAU,EAAE,oBAAA,CAAA;YAC5DM,eAAAA,EAAiBC,0BAAAA,CAAgBpB,OAAAA,CAAQa,UAAU,EAAE,iBAAA,CAAA;AAEpDZ,YAAAA,QAAAA,EAAAA,KAAAA,CAAMoB;;;AAIvB;;;;"}

package/dist/cjs/pages/SceneFormElement.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var Common = require('@cratis/components/Common');
+var properties = require('../properties.js');
+
+/**
+ * The `Cratis.Components:formElement` component - `FormElement` from `@cratis/components/Common`.
+ *
+ * Pairs an input with a leading icon addon so a row of unrelated inputs still lines up. The icon can be
+ * given two ways, and both are worth supporting: the `icon` property for the common case of a PrimeIcons
+ * class name, and an `icon` slot for a screen that wants a real component there. The slot wins when both
+ * are present, since a slot is the more specific statement.
+ */ function SceneFormElement({ element, slots }) {
+    const icon = properties.stringProperty(element.properties, 'icon');
+    const iconContent = slots.icon?.length ? slots.icon : icon === undefined ? undefined : /*#__PURE__*/ jsxRuntime.jsx(Common.IconDisplay, {
+        icon: icon
+    });
+    return /*#__PURE__*/ jsxRuntime.jsx(Common.FormElement, {
+        icon: iconContent,
+        children: slots.content
+    });
+}
+
+exports.SceneFormElement = SceneFormElement;
+//# sourceMappingURL=SceneFormElement.js.map

package/dist/cjs/pages/SceneFormElement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneFormElement.js","sources":["../../../pages/SceneFormElement.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 { FormElement, IconDisplay } from '@cratis/components/Common';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { stringProperty } from '../properties';\n\n/**\n * The `Cratis.Components:formElement` component - `FormElement` from `@cratis/components/Common`.\n *\n * Pairs an input with a leading icon addon so a row of unrelated inputs still lines up. The icon can be\n * given two ways, and both are worth supporting: the `icon` property for the common case of a PrimeIcons\n * class name, and an `icon` slot for a screen that wants a real component there. The slot wins when both\n * are present, since a slot is the more specific statement.\n */\nexport function SceneFormElement({ element, slots }: RegisteredComponentProps) {\n    const icon = stringProperty(element.properties, 'icon');\n    const iconContent = slots.icon?.length ? slots.icon : icon === undefined ? undefined : <IconDisplay icon={icon} />;\n\n    return <FormElement icon={iconContent}>{slots.content}</FormElement>;\n}\n"],"names":["SceneFormElement","element","slots","icon","stringProperty","properties","iconContent","length","undefined","_jsx","IconDisplay","FormElement","content"],"mappings":";;;;;;AAOA;;;;;;;AAOC,IACM,SAASA,gBAAAA,CAAiB,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;AACzE,IAAA,MAAMC,IAAAA,GAAOC,yBAAAA,CAAeH,OAAAA,CAAQI,UAAU,EAAE,MAAA,CAAA;IAChD,MAAMC,WAAAA,GAAcJ,KAAAA,CAAMC,IAAI,EAAEI,MAAAA,GAASL,KAAAA,CAAMC,IAAI,GAAGA,IAAAA,KAASK,SAAAA,GAAYA,SAAAA,iBAAYC,cAAA,CAACC,kBAAAA,EAAAA;QAAYP,IAAAA,EAAMA;;AAE1G,IAAA,qBAAOM,cAAA,CAACE,kBAAAA,EAAAA;QAAYR,IAAAA,EAAMG,WAAAA;AAAcJ,QAAAA,QAAAA,EAAAA,KAAAA,CAAMU;;AAClD;;;;"}

package/dist/cjs/pages/ScenePage.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var Common = require('@cratis/components/Common');
+var properties = require('../properties.js');
+
+/**
+ * The `Cratis.Components:page` component - `Page` from `@cratis/components/Common`.
+ *
+ * The library's page primitive rather than a plain `div`, because it is what every other component in
+ * the library is laid out inside: a full-height flex column whose optional `panel` chrome is drawn from
+ * the same `--cratis-*` tokens as the tables and dialogs it contains. A screen that wraps its content in
+ * this gets that consistency for free; one that wraps it in a `div` has to reinvent it and will drift.
+ *
+ * Imported statically - `Page` is one of the library's Arc-free components, so it costs a screen nothing
+ * to use it without an Arc runtime present.
+ */ function ScenePage({ element, slots }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(Common.Page, {
+        "data-scene-id": element.id,
+        title: properties.stringProperty(element.properties, 'title') ?? '',
+        showTitle: properties.booleanProperty(element.properties, 'showTitle'),
+        panel: properties.booleanProperty(element.properties, 'panel'),
+        children: slots.content
+    });
+}
+
+exports.ScenePage = ScenePage;
+//# sourceMappingURL=ScenePage.js.map

package/dist/cjs/pages/ScenePage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScenePage.js","sources":["../../../pages/ScenePage.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 { Page } from '@cratis/components/Common';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, stringProperty } from '../properties';\n\n/**\n * The `Cratis.Components:page` component - `Page` from `@cratis/components/Common`.\n *\n * The library's page primitive rather than a plain `div`, because it is what every other component in\n * the library is laid out inside: a full-height flex column whose optional `panel` chrome is drawn from\n * the same `--cratis-*` tokens as the tables and dialogs it contains. A screen that wraps its content in\n * this gets that consistency for free; one that wraps it in a `div` has to reinvent it and will drift.\n *\n * Imported statically - `Page` is one of the library's Arc-free components, so it costs a screen nothing\n * to use it without an Arc runtime present.\n */\nexport function ScenePage({ element, slots }: RegisteredComponentProps) {\n    return (\n        <Page\n            data-scene-id={element.id}\n            title={stringProperty(element.properties, 'title') ?? ''}\n            showTitle={booleanProperty(element.properties, 'showTitle')}\n            panel={booleanProperty(element.properties, 'panel')}\n        >\n            {slots.content}\n        </Page>\n    );\n}\n"],"names":["ScenePage","element","slots","_jsx","Page","data-scene-id","id","title","stringProperty","properties","showTitle","booleanProperty","panel","content"],"mappings":";;;;;;AAOA;;;;;;;;;;AAUC,IACM,SAASA,SAAAA,CAAU,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;AAClE,IAAA,qBACIC,cAAA,CAACC,WAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeJ,QAAQK,EAAE;AACzBC,QAAAA,KAAAA,EAAOC,yBAAAA,CAAeP,OAAAA,CAAQQ,UAAU,EAAE,OAAA,CAAA,IAAY,EAAA;QACtDC,SAAAA,EAAWC,0BAAAA,CAAgBV,OAAAA,CAAQQ,UAAU,EAAE,WAAA,CAAA;QAC/CG,KAAAA,EAAOD,0BAAAA,CAAgBV,OAAAA,CAAQQ,UAAU,EAAE,OAAA,CAAA;AAE1CP,QAAAA,QAAAA,EAAAA,KAAAA,CAAMW;;AAGnB;;;;"}

package/dist/cjs/properties.js

@@ -0,0 +1,104 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Narrow readers for an {@link ExternalComponent}'s `properties` bag.
+ *
+ * The bag is `Record<string, unknown>` because it survives a round trip through JSON - a `.play` screen
+ * is authored as text, compiled by Stage, and re-read by Studio, and none of those steps carry a
+ * TypeScript type with it. An adapter therefore has to narrow every value it reads, and the tempting
+ * shortcut (`element.properties.title as string`) is a lie the compiler will happily believe: a screen
+ * that writes `title: 42` then reaches the wrapped component as a number and fails somewhere far away.
+ *
+ * These helpers all answer the same way - the value when it really is of the asked-for type, `undefined`
+ * otherwise - so an adapter reads a property and applies its own default in one expression, and a
+ * mistyped property degrades to the default instead of corrupting the render.
+ */ /**
+ * Reads a string property, or `undefined` when it is absent or not a string.
+ */ function stringProperty(properties, name) {
+    const value = properties[name];
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * Reads a boolean property, or `undefined` when it is absent or not a boolean.
+ *
+ * Deliberately not truthiness: a screen that sets `showTitle: 0` means something different from one that
+ * leaves it out, and only the second should fall back to the adapter's default.
+ */ function booleanProperty(properties, name) {
+    const value = properties[name];
+    return typeof value === 'boolean' ? value : undefined;
+}
+/**
+ * Reads a numeric property, or `undefined` when it is absent, not a number, or `NaN`.
+ *
+ * `NaN` is excluded because it is the one number that makes every downstream comparison silently false -
+ * a slider with `min: NaN` renders without complaint and behaves as if it had no minimum at all.
+ */ function numberProperty(properties, name) {
+    const value = properties[name];
+    return typeof value === 'number' && !Number.isNaN(value) ? value : undefined;
+}
+/**
+ * Reads an array property, or `undefined` when it is absent or not an array.
+ *
+ * The element type is deliberately left as `unknown` - narrowing the elements is the caller's job,
+ * through {@link stringArrayProperty} or its own mapping - so this helper never has to guess what a
+ * heterogeneous list was supposed to be.
+ */ function arrayProperty(properties, name) {
+    const value = properties[name];
+    return Array.isArray(value) ? value : undefined;
+}
+/**
+ * Reads an array property and keeps only its string elements, or `undefined` when the property is absent
+ * or not an array.
+ *
+ * Non-string elements are dropped rather than rejecting the whole list, because these lists are
+ * column names, filter fields and the like: one bad entry should cost that one entry, not the entire
+ * table's filtering.
+ */ function stringArrayProperty(properties, name) {
+    return arrayProperty(properties, name)?.filter((value)=>typeof value === 'string');
+}
+/**
+ * Reads an object property as a plain record, or `undefined` when it is absent, `null`, or an array.
+ *
+ * Arrays are excluded even though `typeof [] === 'object'`, because every caller here wants a keyed
+ * object - a JSON schema, a document being edited - and an array reaching one of those would be a
+ * different bug entirely.
+ */ function objectProperty(properties, name) {
+    const value = properties[name];
+    return typeof value === 'object' && value !== null && !Array.isArray(value) ? value : undefined;
+}
+/**
+ * Reads an array property and keeps only its plain-object elements, or `undefined` when the property is
+ * absent or not an array.
+ *
+ * This is what an authored `options` list arrives as - `[{ label: 'Draft', value: 'draft' }, ...]` - and
+ * the same forgiving rule as {@link stringArrayProperty} applies: one malformed entry costs that entry,
+ * not the whole dropdown.
+ */ function objectArrayProperty(properties, name) {
+    return arrayProperty(properties, name)?.filter((value)=>typeof value === 'object' && value !== null && !Array.isArray(value));
+}
+/**
+ * Reads a string property that has to be one of a fixed set of values, or `undefined` when it is absent
+ * or outside the set.
+ *
+ * Several of the wrapped `@cratis/components` props are string literal unions (`'horizontal' | 'vertical'`,
+ * `'top' | 'right' | 'bottom' | 'left'`). This is what turns an arbitrary authored string into one of
+ * them without an assertion: an unrecognized value falls back to the component's own default rather than
+ * being forced through as a value the component never expects to see.
+ *
+ * @param allowed The permitted values, most usefully written as a `const` tuple so `T` infers as the union.
+ */ function unionProperty(properties, name, allowed) {
+    const value = stringProperty(properties, name);
+    return value !== undefined && allowed.includes(value) ? value : undefined;
+}
+
+exports.arrayProperty = arrayProperty;
+exports.booleanProperty = booleanProperty;
+exports.numberProperty = numberProperty;
+exports.objectArrayProperty = objectArrayProperty;
+exports.objectProperty = objectProperty;
+exports.stringArrayProperty = stringArrayProperty;
+exports.stringProperty = stringProperty;
+exports.unionProperty = unionProperty;
+//# sourceMappingURL=properties.js.map

package/dist/cjs/properties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties.js","sources":["../../properties.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/**\n * Narrow readers for an {@link ExternalComponent}'s `properties` bag.\n *\n * The bag is `Record<string, unknown>` because it survives a round trip through JSON - a `.play` screen\n * is authored as text, compiled by Stage, and re-read by Studio, and none of those steps carry a\n * TypeScript type with it. An adapter therefore has to narrow every value it reads, and the tempting\n * shortcut (`element.properties.title as string`) is a lie the compiler will happily believe: a screen\n * that writes `title: 42` then reaches the wrapped component as a number and fails somewhere far away.\n *\n * These helpers all answer the same way - the value when it really is of the asked-for type, `undefined`\n * otherwise - so an adapter reads a property and applies its own default in one expression, and a\n * mistyped property degrades to the default instead of corrupting the render.\n */\n\n/**\n * Reads a string property, or `undefined` when it is absent or not a string.\n */\nexport function stringProperty(properties: Record<string, unknown>, name: string): string | undefined {\n    const value = properties[name];\n    return typeof value === 'string' ? value : undefined;\n}\n\n/**\n * Reads a boolean property, or `undefined` when it is absent or not a boolean.\n *\n * Deliberately not truthiness: a screen that sets `showTitle: 0` means something different from one that\n * leaves it out, and only the second should fall back to the adapter's default.\n */\nexport function booleanProperty(properties: Record<string, unknown>, name: string): boolean | undefined {\n    const value = properties[name];\n    return typeof value === 'boolean' ? value : undefined;\n}\n\n/**\n * Reads a numeric property, or `undefined` when it is absent, not a number, or `NaN`.\n *\n * `NaN` is excluded because it is the one number that makes every downstream comparison silently false -\n * a slider with `min: NaN` renders without complaint and behaves as if it had no minimum at all.\n */\nexport function numberProperty(properties: Record<string, unknown>, name: string): number | undefined {\n    const value = properties[name];\n    return typeof value === 'number' && !Number.isNaN(value) ? value : undefined;\n}\n\n/**\n * Reads an array property, or `undefined` when it is absent or not an array.\n *\n * The element type is deliberately left as `unknown` - narrowing the elements is the caller's job,\n * through {@link stringArrayProperty} or its own mapping - so this helper never has to guess what a\n * heterogeneous list was supposed to be.\n */\nexport function arrayProperty(properties: Record<string, unknown>, name: string): unknown[] | undefined {\n    const value = properties[name];\n    return Array.isArray(value) ? value : undefined;\n}\n\n/**\n * Reads an array property and keeps only its string elements, or `undefined` when the property is absent\n * or not an array.\n *\n * Non-string elements are dropped rather than rejecting the whole list, because these lists are\n * column names, filter fields and the like: one bad entry should cost that one entry, not the entire\n * table's filtering.\n */\nexport function stringArrayProperty(properties: Record<string, unknown>, name: string): string[] | undefined {\n    return arrayProperty(properties, name)?.filter((value): value is string => typeof value === 'string');\n}\n\n/**\n * Reads an object property as a plain record, or `undefined` when it is absent, `null`, or an array.\n *\n * Arrays are excluded even though `typeof [] === 'object'`, because every caller here wants a keyed\n * object - a JSON schema, a document being edited - and an array reaching one of those would be a\n * different bug entirely.\n */\nexport function objectProperty(properties: Record<string, unknown>, name: string): Record<string, unknown> | undefined {\n    const value = properties[name];\n    return typeof value === 'object' && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;\n}\n\n/**\n * Reads an array property and keeps only its plain-object elements, or `undefined` when the property is\n * absent or not an array.\n *\n * This is what an authored `options` list arrives as - `[{ label: 'Draft', value: 'draft' }, ...]` - and\n * the same forgiving rule as {@link stringArrayProperty} applies: one malformed entry costs that entry,\n * not the whole dropdown.\n */\nexport function objectArrayProperty(properties: Record<string, unknown>, name: string): Record<string, unknown>[] | undefined {\n    return arrayProperty(properties, name)?.filter(\n        (value): value is Record<string, unknown> => typeof value === 'object' && value !== null && !Array.isArray(value)\n    );\n}\n\n/**\n * Reads a string property that has to be one of a fixed set of values, or `undefined` when it is absent\n * or outside the set.\n *\n * Several of the wrapped `@cratis/components` props are string literal unions (`'horizontal' | 'vertical'`,\n * `'top' | 'right' | 'bottom' | 'left'`). This is what turns an arbitrary authored string into one of\n * them without an assertion: an unrecognized value falls back to the component's own default rather than\n * being forced through as a value the component never expects to see.\n *\n * @param allowed The permitted values, most usefully written as a `const` tuple so `T` infers as the union.\n */\nexport function unionProperty<T extends string>(properties: Record<string, unknown>, name: string, allowed: readonly T[]): T | undefined {\n    const value = stringProperty(properties, name);\n    return value !== undefined && (allowed as readonly string[]).includes(value) ? (value as T) : undefined;\n}\n"],"names":["stringProperty","properties","name","value","undefined","booleanProperty","numberProperty","Number","isNaN","arrayProperty","Array","isArray","stringArrayProperty","filter","objectProperty","objectArrayProperty","unionProperty","allowed","includes"],"mappings":";;AAAA;AACA;AAEA;;;;;;;;;;;;;;AAgBC,IACM,SAASA,cAAAA,CAAeC,UAAmC,EAAEC,IAAY,EAAA;IAC5E,MAAMC,KAAAA,GAAQF,UAAU,CAACC,IAAAA,CAAK;IAC9B,OAAO,OAAOC,KAAAA,KAAU,QAAA,GAAWA,KAAAA,GAAQC,SAAAA;AAC/C;AAEA;;;;;AAKC,IACM,SAASC,eAAAA,CAAgBJ,UAAmC,EAAEC,IAAY,EAAA;IAC7E,MAAMC,KAAAA,GAAQF,UAAU,CAACC,IAAAA,CAAK;IAC9B,OAAO,OAAOC,KAAAA,KAAU,SAAA,GAAYA,KAAAA,GAAQC,SAAAA;AAChD;AAEA;;;;;AAKC,IACM,SAASE,cAAAA,CAAeL,UAAmC,EAAEC,IAAY,EAAA;IAC5E,MAAMC,KAAAA,GAAQF,UAAU,CAACC,IAAAA,CAAK;IAC9B,OAAO,OAAOC,UAAU,QAAA,IAAY,CAACI,OAAOC,KAAK,CAACL,SAASA,KAAAA,GAAQC,SAAAA;AACvE;AAEA;;;;;;AAMC,IACM,SAASK,aAAAA,CAAcR,UAAmC,EAAEC,IAAY,EAAA;IAC3E,MAAMC,KAAAA,GAAQF,UAAU,CAACC,IAAAA,CAAK;AAC9B,IAAA,OAAOQ,KAAAA,CAAMC,OAAO,CAACR,KAAAA,CAAAA,GAASA,KAAAA,GAAQC,SAAAA;AAC1C;AAEA;;;;;;;AAOC,IACM,SAASQ,mBAAAA,CAAoBX,UAAmC,EAAEC,IAAY,EAAA;AACjF,IAAA,OAAOO,cAAcR,UAAAA,EAAYC,IAAAA,CAAAA,EAAOW,OAAO,CAACV,KAAAA,GAA2B,OAAOA,KAAAA,KAAU,QAAA,CAAA;AAChG;AAEA;;;;;;AAMC,IACM,SAASW,cAAAA,CAAeb,UAAmC,EAAEC,IAAY,EAAA;IAC5E,MAAMC,KAAAA,GAAQF,UAAU,CAACC,IAAAA,CAAK;IAC9B,OAAO,OAAOC,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAU,IAAA,IAAQ,CAACO,KAAAA,CAAMC,OAAO,CAACR,KAAAA,CAAAA,GAAUA,KAAAA,GAAoCC,SAAAA;AACvH;AAEA;;;;;;;AAOC,IACM,SAASW,mBAAAA,CAAoBd,UAAmC,EAAEC,IAAY,EAAA;AACjF,IAAA,OAAOO,aAAAA,CAAcR,UAAAA,EAAYC,IAAAA,CAAAA,EAAOW,MAAAA,CACpC,CAACV,KAAAA,GAA4C,OAAOA,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAU,IAAA,IAAQ,CAACO,KAAAA,CAAMC,OAAO,CAACR,KAAAA,CAAAA,CAAAA;AAEnH;AAEA;;;;;;;;;;AAUC,IACM,SAASa,aAAAA,CAAgCf,UAAmC,EAAEC,IAAY,EAAEe,OAAqB,EAAA;IACpH,MAAMd,KAAAA,GAAQH,eAAeC,UAAAA,EAAYC,IAAAA,CAAAA;AACzC,IAAA,OAAOC,UAAUC,SAAAA,IAAca,QAA8BC,QAAQ,CAACf,SAAUA,KAAAA,GAAcC,SAAAA;AAClG;;;;;;;;;;;"}

package/dist/cjs/toolbar/SceneToolbar.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var Toolbar = require('@cratis/components/Toolbar');
+var properties = require('../properties.js');
+
+/** Whether the toolbar runs down the side or across the top. */ const orientations = [
+    'vertical',
+    'horizontal'
+];
+/**
+ * The `Cratis.Components:toolbar` component - `Toolbar` from `@cratis/components/Toolbar`.
+ *
+ * The container for a tool palette: it draws the rounded chrome and, more importantly, establishes the
+ * drag context every `toolbarButton` inside it reads. `draggable` therefore belongs here rather than on
+ * each button - it is a property of the palette, and setting it per button is how you end up with a
+ * palette that is half draggable.
+ */ function SceneToolbar({ element, slots }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(Toolbar.Toolbar, {
+        orientation: properties.unionProperty(element.properties, 'orientation', orientations),
+        draggable: properties.booleanProperty(element.properties, 'draggable'),
+        children: slots.content
+    });
+}
+
+exports.SceneToolbar = SceneToolbar;
+//# sourceMappingURL=SceneToolbar.js.map

package/dist/cjs/toolbar/SceneToolbar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneToolbar.js","sources":["../../../toolbar/SceneToolbar.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 { Toolbar } from '@cratis/components/Toolbar';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, unionProperty } from '../properties';\n\n/** Whether the toolbar runs down the side or across the top. */\nconst orientations = ['vertical', 'horizontal'] as const;\n\n/**\n * The `Cratis.Components:toolbar` component - `Toolbar` from `@cratis/components/Toolbar`.\n *\n * The container for a tool palette: it draws the rounded chrome and, more importantly, establishes the\n * drag context every `toolbarButton` inside it reads. `draggable` therefore belongs here rather than on\n * each button - it is a property of the palette, and setting it per button is how you end up with a\n * palette that is half draggable.\n */\nexport function SceneToolbar({ element, slots }: RegisteredComponentProps) {\n    return (\n        <Toolbar\n            orientation={unionProperty(element.properties, 'orientation', orientations)}\n            draggable={booleanProperty(element.properties, 'draggable')}\n        >\n            {slots.content}\n        </Toolbar>\n    );\n}\n"],"names":["orientations","SceneToolbar","element","slots","_jsx","Toolbar","orientation","unionProperty","properties","draggable","booleanProperty","content"],"mappings":";;;;;;AAOA,iEACA,MAAMA,YAAAA,GAAe;AAAC,IAAA,UAAA;AAAY,IAAA;AAAa,CAAA;AAE/C;;;;;;;AAOC,IACM,SAASC,YAAAA,CAAa,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;AACrE,IAAA,qBACIC,cAAA,CAACC,eAAAA,EAAAA;AACGC,QAAAA,WAAAA,EAAaC,wBAAAA,CAAcL,OAAAA,CAAQM,UAAU,EAAE,aAAA,EAAeR,YAAAA,CAAAA;QAC9DS,SAAAA,EAAWC,0BAAAA,CAAgBR,OAAAA,CAAQM,UAAU,EAAE,WAAA,CAAA;AAE9CL,QAAAA,QAAAA,EAAAA,KAAAA,CAAMQ;;AAGnB;;;;"}

package/dist/cjs/toolbar/SceneToolbarButton.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var Toolbar = require('@cratis/components/Toolbar');
+var properties = require('../properties.js');
+
+/** Which side of the button its tooltip appears on. */ const tooltipPositions = [
+    'top',
+    'right',
+    'bottom',
+    'left'
+];
+/**
+ * The `Cratis.Components:toolbarButton` component - `ToolbarButton` from `@cratis/components/Toolbar`.
+ *
+ * `title` is required by the underlying component and is not decoration: it is both the tooltip text and
+ * the accessible name, so a toolbar of icon-only buttons is still usable by anyone who cannot see the
+ * icons. It defaults to the `text` property rather than to an empty string, so a button that has a
+ * visible label is never left nameless.
+ */ function SceneToolbarButton({ element }) {
+    const text = properties.stringProperty(element.properties, 'text');
+    return /*#__PURE__*/ jsxRuntime.jsx(Toolbar.ToolbarButton, {
+        icon: properties.stringProperty(element.properties, 'icon'),
+        text: text,
+        title: properties.stringProperty(element.properties, 'title') ?? text ?? '',
+        active: properties.booleanProperty(element.properties, 'active'),
+        tooltipPosition: properties.unionProperty(element.properties, 'tooltipPosition', tooltipPositions)
+    });
+}
+
+exports.SceneToolbarButton = SceneToolbarButton;
+//# sourceMappingURL=SceneToolbarButton.js.map