@cratis/scene.components 0.1.0

package/dist/cjs/bindings/bindingRegistry.js

@@ -0,0 +1,101 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+const queries = new Map();
+const commands = new Map();
+/**
+ * Registers an Arc query proxy under the name screens refer to it by.
+ *
+ * This is the seam that makes the Arc-bound half of `@cratis/components` usable from Scene at all. A
+ * screen says `data Invoices via query AllInvoices`, and by the time that reaches a renderer it is an
+ * `ExternalComponent` whose `properties` bag holds the *string* `'AllInvoices'` - a property bag carries
+ * plain values and named slots, and there is no way to put a TypeScript class into one. `DataTableForQuery`
+ * needs the class. The name is the only thing that survives the trip, so the name is what the lookup has
+ * to be keyed on, and a host that owns the generated proxies is the only party that can supply the class
+ * behind it.
+ *
+ * A host - Stage's generated application, or Studio's preview when it is wired to a real backend -
+ * registers every proxy a screen can name, once, during startup. Registering the same name twice
+ * replaces the earlier registration, so a host can re-register on hot reload without having to unwind
+ * the previous run.
+ */ function registerQuery(name, queryClass) {
+    queries.set(name, queryClass);
+}
+/**
+ * Registers several query proxies at once, keyed by the name screens refer to each by.
+ *
+ * Stage generates a module that exports every proxy it produced; handing that module's exports straight
+ * to this is the whole of a generated host's registration step, and it stays correct as proxies are
+ * added and removed without anyone editing a list.
+ */ function registerQueries(bindings) {
+    for (const [name, queryClass] of Object.entries(bindings)){
+        registerQuery(name, queryClass);
+    }
+}
+/**
+ * The query proxy registered under a name, or `undefined` when nothing is registered under it.
+ *
+ * `undefined` rather than a throw: design-time preview in Studio normally has nothing registered at all,
+ * and a screen still has to render so its layout can be worked on. Every adapter turns `undefined` into
+ * a visible placeholder naming the binding it wanted.
+ */ function resolveQuery(name) {
+    return queries.get(name);
+}
+/**
+ * Registers an Arc command proxy under the name screens refer to it by. The command half of
+ * {@link registerQuery}, with the same contract.
+ */ function registerCommand(name, commandClass) {
+    commands.set(name, commandClass);
+}
+/**
+ * Registers several command proxies at once, keyed by the name screens refer to each by.
+ */ function registerCommands(bindings) {
+    for (const [name, commandClass] of Object.entries(bindings)){
+        registerCommand(name, commandClass);
+    }
+}
+/**
+ * The command proxy registered under a name, or `undefined` when nothing is registered under it.
+ */ function resolveCommand(name) {
+    return commands.get(name);
+}
+/**
+ * Every registered query name, sorted.
+ *
+ * A design-time tool uses this to offer the names a screen can actually bind to, and a diagnostics
+ * surface uses it to explain a placeholder - "this screen wants `AllInvoices`, and here is what is
+ * registered" is a far more useful message than the placeholder alone.
+ */ function registeredQueryNames() {
+    return [
+        ...queries.keys()
+    ].sort();
+}
+/**
+ * Every registered command name, sorted.
+ */ function registeredCommandNames() {
+    return [
+        ...commands.keys()
+    ].sort();
+}
+/**
+ * Forgets every registered query and command.
+ *
+ * The registry is module-level state, which is right for a host that registers once at startup but wrong
+ * for anything that switches between applications - Studio previewing a different project, or a spec
+ * that must not inherit what the previous one registered. Both need a way back to empty.
+ */ function clearBindings() {
+    queries.clear();
+    commands.clear();
+}
+
+exports.clearBindings = clearBindings;
+exports.registerCommand = registerCommand;
+exports.registerCommands = registerCommands;
+exports.registerQueries = registerQueries;
+exports.registerQuery = registerQuery;
+exports.registeredCommandNames = registeredCommandNames;
+exports.registeredQueryNames = registeredQueryNames;
+exports.resolveCommand = resolveCommand;
+exports.resolveQuery = resolveQuery;
+//# sourceMappingURL=bindingRegistry.js.map

package/dist/cjs/bindings/bindingRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bindingRegistry.js","sources":["../../../bindings/bindingRegistry.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 { BoundConstructor } from './BoundConstructor';\n\nconst queries = new Map<string, BoundConstructor>();\nconst commands = new Map<string, BoundConstructor>();\n\n/**\n * Registers an Arc query proxy under the name screens refer to it by.\n *\n * This is the seam that makes the Arc-bound half of `@cratis/components` usable from Scene at all. A\n * screen says `data Invoices via query AllInvoices`, and by the time that reaches a renderer it is an\n * `ExternalComponent` whose `properties` bag holds the *string* `'AllInvoices'` - a property bag carries\n * plain values and named slots, and there is no way to put a TypeScript class into one. `DataTableForQuery`\n * needs the class. The name is the only thing that survives the trip, so the name is what the lookup has\n * to be keyed on, and a host that owns the generated proxies is the only party that can supply the class\n * behind it.\n *\n * A host - Stage's generated application, or Studio's preview when it is wired to a real backend -\n * registers every proxy a screen can name, once, during startup. Registering the same name twice\n * replaces the earlier registration, so a host can re-register on hot reload without having to unwind\n * the previous run.\n */\nexport function registerQuery(name: string, queryClass: BoundConstructor): void {\n    queries.set(name, queryClass);\n}\n\n/**\n * Registers several query proxies at once, keyed by the name screens refer to each by.\n *\n * Stage generates a module that exports every proxy it produced; handing that module's exports straight\n * to this is the whole of a generated host's registration step, and it stays correct as proxies are\n * added and removed without anyone editing a list.\n */\nexport function registerQueries(bindings: Record<string, BoundConstructor>): void {\n    for (const [name, queryClass] of Object.entries(bindings)) {\n        registerQuery(name, queryClass);\n    }\n}\n\n/**\n * The query proxy registered under a name, or `undefined` when nothing is registered under it.\n *\n * `undefined` rather than a throw: design-time preview in Studio normally has nothing registered at all,\n * and a screen still has to render so its layout can be worked on. Every adapter turns `undefined` into\n * a visible placeholder naming the binding it wanted.\n */\nexport function resolveQuery(name: string): BoundConstructor | undefined {\n    return queries.get(name);\n}\n\n/**\n * Registers an Arc command proxy under the name screens refer to it by. The command half of\n * {@link registerQuery}, with the same contract.\n */\nexport function registerCommand(name: string, commandClass: BoundConstructor): void {\n    commands.set(name, commandClass);\n}\n\n/**\n * Registers several command proxies at once, keyed by the name screens refer to each by.\n */\nexport function registerCommands(bindings: Record<string, BoundConstructor>): void {\n    for (const [name, commandClass] of Object.entries(bindings)) {\n        registerCommand(name, commandClass);\n    }\n}\n\n/**\n * The command proxy registered under a name, or `undefined` when nothing is registered under it.\n */\nexport function resolveCommand(name: string): BoundConstructor | undefined {\n    return commands.get(name);\n}\n\n/**\n * Every registered query name, sorted.\n *\n * A design-time tool uses this to offer the names a screen can actually bind to, and a diagnostics\n * surface uses it to explain a placeholder - \"this screen wants `AllInvoices`, and here is what is\n * registered\" is a far more useful message than the placeholder alone.\n */\nexport function registeredQueryNames(): string[] {\n    return [...queries.keys()].sort();\n}\n\n/**\n * Every registered command name, sorted.\n */\nexport function registeredCommandNames(): string[] {\n    return [...commands.keys()].sort();\n}\n\n/**\n * Forgets every registered query and command.\n *\n * The registry is module-level state, which is right for a host that registers once at startup but wrong\n * for anything that switches between applications - Studio previewing a different project, or a spec\n * that must not inherit what the previous one registered. Both need a way back to empty.\n */\nexport function clearBindings(): void {\n    queries.clear();\n    commands.clear();\n}\n"],"names":["queries","Map","commands","registerQuery","name","queryClass","set","registerQueries","bindings","Object","entries","resolveQuery","get","registerCommand","commandClass","registerCommands","resolveCommand","registeredQueryNames","keys","sort","registeredCommandNames","clearBindings","clear"],"mappings":";;AAAA;AACA;AAIA,MAAMA,UAAU,IAAIC,GAAAA,EAAAA;AACpB,MAAMC,WAAW,IAAID,GAAAA,EAAAA;AAErB;;;;;;;;;;;;;;;AAeC,IACM,SAASE,aAAAA,CAAcC,IAAY,EAAEC,UAA4B,EAAA;IACpEL,OAAAA,CAAQM,GAAG,CAACF,IAAAA,EAAMC,UAAAA,CAAAA;AACtB;AAEA;;;;;;IAOO,SAASE,eAAAA,CAAgBC,QAA0C,EAAA;IACtE,KAAK,MAAM,CAACJ,IAAAA,EAAMC,UAAAA,CAAW,IAAII,MAAAA,CAAOC,OAAO,CAACF,QAAAA,CAAAA,CAAW;AACvDL,QAAAA,aAAAA,CAAcC,IAAAA,EAAMC,UAAAA,CAAAA;AACxB,IAAA;AACJ;AAEA;;;;;;IAOO,SAASM,YAAAA,CAAaP,IAAY,EAAA;IACrC,OAAOJ,OAAAA,CAAQY,GAAG,CAACR,IAAAA,CAAAA;AACvB;AAEA;;;AAGC,IACM,SAASS,eAAAA,CAAgBT,IAAY,EAAEU,YAA8B,EAAA;IACxEZ,QAAAA,CAASI,GAAG,CAACF,IAAAA,EAAMU,YAAAA,CAAAA;AACvB;AAEA;;IAGO,SAASC,gBAAAA,CAAiBP,QAA0C,EAAA;IACvE,KAAK,MAAM,CAACJ,IAAAA,EAAMU,YAAAA,CAAa,IAAIL,MAAAA,CAAOC,OAAO,CAACF,QAAAA,CAAAA,CAAW;AACzDK,QAAAA,eAAAA,CAAgBT,IAAAA,EAAMU,YAAAA,CAAAA;AAC1B,IAAA;AACJ;AAEA;;IAGO,SAASE,cAAAA,CAAeZ,IAAY,EAAA;IACvC,OAAOF,QAAAA,CAASU,GAAG,CAACR,IAAAA,CAAAA;AACxB;AAEA;;;;;;AAMC,IACM,SAASa,oBAAAA,GAAAA;IACZ,OAAO;AAAIjB,QAAAA,GAAAA,OAAAA,CAAQkB,IAAI;AAAG,KAAA,CAACC,IAAI,EAAA;AACnC;AAEA;;AAEC,IACM,SAASC,sBAAAA,GAAAA;IACZ,OAAO;AAAIlB,QAAAA,GAAAA,QAAAA,CAASgB,IAAI;AAAG,KAAA,CAACC,IAAI,EAAA;AACpC;AAEA;;;;;;AAMC,IACM,SAASE,aAAAA,GAAAA;AACZrB,IAAAA,OAAAA,CAAQsB,KAAK,EAAA;AACbpB,IAAAA,QAAAA,CAASoB,KAAK,EAAA;AAClB;;;;;;;;;;;;"}

package/dist/cjs/bindings/resolveElementBinding.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var properties = require('../properties.js');
+var BindingKind = require('./BindingKind.js');
+var bindingRegistry = require('./bindingRegistry.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The property an element carries its binding name in, per kind. Queries and commands use different
+ * property names so a single element could in principle carry both - a command dialog launched from a
+ * data page, say - without the two names colliding.
+ */ const bindingPropertyNames = {
+    [BindingKind.BindingKind.Query]: 'query',
+    [BindingKind.BindingKind.Command]: 'command'
+};
+/**
+ * Reads the binding name an element carries for the given kind and looks it up in the binding registry.
+ *
+ * Every Arc-bound adapter starts here, so the "name in, class out" step happens in exactly one place and
+ * every adapter reports a missing binding the same way. Nothing throws: an absent property and an
+ * unregistered name both come back as an {@link ElementBinding} with no `target`, which the adapter
+ * turns into a visible placeholder.
+ */ function resolveElementBinding(element, kind) {
+    const name = properties.stringProperty(element.properties, bindingPropertyNames[kind]);
+    if (name === undefined) return {};
+    return {
+        name,
+        target: kind === BindingKind.BindingKind.Query ? bindingRegistry.resolveQuery(name) : bindingRegistry.resolveCommand(name)
+    };
+}
+
+exports.resolveElementBinding = resolveElementBinding;
+//# sourceMappingURL=resolveElementBinding.js.map

package/dist/cjs/bindings/resolveElementBinding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveElementBinding.js","sources":["../../../bindings/resolveElementBinding.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 { BindingKind } from './BindingKind';\nimport { ElementBinding } from './ElementBinding';\nimport { resolveCommand, resolveQuery } from './bindingRegistry';\n\n/**\n * The property an element carries its binding name in, per kind. Queries and commands use different\n * property names so a single element could in principle carry both - a command dialog launched from a\n * data page, say - without the two names colliding.\n */\nconst bindingPropertyNames: Record<BindingKind, string> = {\n    [BindingKind.Query]: 'query',\n    [BindingKind.Command]: 'command',\n};\n\n/**\n * Reads the binding name an element carries for the given kind and looks it up in the binding registry.\n *\n * Every Arc-bound adapter starts here, so the \"name in, class out\" step happens in exactly one place and\n * every adapter reports a missing binding the same way. Nothing throws: an absent property and an\n * unregistered name both come back as an {@link ElementBinding} with no `target`, which the adapter\n * turns into a visible placeholder.\n */\nexport function resolveElementBinding(element: ExternalComponent, kind: BindingKind): ElementBinding {\n    const name = stringProperty(element.properties, bindingPropertyNames[kind]);\n    if (name === undefined) return {};\n\n    return { name, target: kind === BindingKind.Query ? resolveQuery(name) : resolveCommand(name) };\n}\n"],"names":["bindingPropertyNames","BindingKind","Query","Command","resolveElementBinding","element","kind","name","stringProperty","properties","undefined","target","resolveQuery","resolveCommand"],"mappings":";;;;;;AAAA;AACA;AAQA;;;;AAIC,IACD,MAAMA,oBAAAA,GAAoD;IACtD,CAACC,uBAAAA,CAAYC,KAAK,GAAG,OAAA;IACrB,CAACD,uBAAAA,CAAYE,OAAO,GAAG;AAC3B,CAAA;AAEA;;;;;;;AAOC,IACM,SAASC,qBAAAA,CAAsBC,OAA0B,EAAEC,IAAiB,EAAA;AAC/E,IAAA,MAAMC,OAAOC,yBAAAA,CAAeH,OAAAA,CAAQI,UAAU,EAAET,oBAAoB,CAACM,IAAAA,CAAK,CAAA;IAC1E,IAAIC,IAAAA,KAASG,SAAAA,EAAW,OAAO,EAAC;IAEhC,OAAO;AAAEH,QAAAA,IAAAA;AAAMI,QAAAA,MAAAA,EAAQL,SAASL,uBAAAA,CAAYC,KAAK,GAAGU,4BAAAA,CAAaL,QAAQM,8BAAAA,CAAeN,IAAAA;AAAM,KAAA;AAClG;;;;"}

package/dist/cjs/common/SceneDropdown.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var Dropdown = require('@cratis/components/Dropdown');
+var properties = require('../properties.js');
+
+/**
+ * The `Cratis.Components:dropdown` component - `Dropdown` from `@cratis/components/Dropdown`.
+ *
+ * The library's own `Dropdown` rather than PrimeReact's, because it carries the overlay z-index fix the
+ * library applies across every overlay it owns - a dropdown inside a dialog renders above the dialog
+ * instead of behind it, which is the single most common overlay bug in a PrimeReact application.
+ *
+ * This is the standalone dropdown, not the command-form one: it takes its options from the screen and is
+ * not bound to a command property. Use `dropdownField` inside a `commandForm`.
+ */ function SceneDropdown({ element }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(Dropdown.Dropdown, {
+        options: properties.objectArrayProperty(element.properties, 'options') ?? [],
+        optionLabel: properties.stringProperty(element.properties, 'optionLabel') ?? 'label',
+        optionValue: properties.stringProperty(element.properties, 'optionValue') ?? 'value',
+        placeholder: properties.stringProperty(element.properties, 'placeholder'),
+        disabled: properties.booleanProperty(element.properties, 'disabled'),
+        showClear: properties.booleanProperty(element.properties, 'showClear'),
+        filter: properties.booleanProperty(element.properties, 'filter'),
+        className: properties.stringProperty(element.properties, 'className')
+    });
+}
+
+exports.SceneDropdown = SceneDropdown;
+//# sourceMappingURL=SceneDropdown.js.map

package/dist/cjs/common/SceneDropdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneDropdown.js","sources":["../../../common/SceneDropdown.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 { Dropdown } from '@cratis/components/Dropdown';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, objectArrayProperty, stringProperty } from '../properties';\n\n/**\n * The `Cratis.Components:dropdown` component - `Dropdown` from `@cratis/components/Dropdown`.\n *\n * The library's own `Dropdown` rather than PrimeReact's, because it carries the overlay z-index fix the\n * library applies across every overlay it owns - a dropdown inside a dialog renders above the dialog\n * instead of behind it, which is the single most common overlay bug in a PrimeReact application.\n *\n * This is the standalone dropdown, not the command-form one: it takes its options from the screen and is\n * not bound to a command property. Use `dropdownField` inside a `commandForm`.\n */\nexport function SceneDropdown({ element }: RegisteredComponentProps) {\n    return (\n        <Dropdown\n            options={objectArrayProperty(element.properties, 'options') ?? []}\n            optionLabel={stringProperty(element.properties, 'optionLabel') ?? 'label'}\n            optionValue={stringProperty(element.properties, 'optionValue') ?? 'value'}\n            placeholder={stringProperty(element.properties, 'placeholder')}\n            disabled={booleanProperty(element.properties, 'disabled')}\n            showClear={booleanProperty(element.properties, 'showClear')}\n            filter={booleanProperty(element.properties, 'filter')}\n            className={stringProperty(element.properties, 'className')}\n        />\n    );\n}\n"],"names":["SceneDropdown","element","_jsx","Dropdown","options","objectArrayProperty","properties","optionLabel","stringProperty","optionValue","placeholder","disabled","booleanProperty","showClear","filter","className"],"mappings":";;;;;;AAOA;;;;;;;;;AASC,IACM,SAASA,aAAAA,CAAc,EAAEC,OAAO,EAA4B,EAAA;AAC/D,IAAA,qBACIC,cAAA,CAACC,iBAAAA,EAAAA;AACGC,QAAAA,OAAAA,EAASC,8BAAAA,CAAoBJ,OAAAA,CAAQK,UAAU,EAAE,cAAc,EAAE;AACjEC,QAAAA,WAAAA,EAAaC,yBAAAA,CAAeP,OAAAA,CAAQK,UAAU,EAAE,aAAA,CAAA,IAAkB,OAAA;AAClEG,QAAAA,WAAAA,EAAaD,yBAAAA,CAAeP,OAAAA,CAAQK,UAAU,EAAE,aAAA,CAAA,IAAkB,OAAA;QAClEI,WAAAA,EAAaF,yBAAAA,CAAeP,OAAAA,CAAQK,UAAU,EAAE,aAAA,CAAA;QAChDK,QAAAA,EAAUC,0BAAAA,CAAgBX,OAAAA,CAAQK,UAAU,EAAE,UAAA,CAAA;QAC9CO,SAAAA,EAAWD,0BAAAA,CAAgBX,OAAAA,CAAQK,UAAU,EAAE,WAAA,CAAA;QAC/CQ,MAAAA,EAAQF,0BAAAA,CAAgBX,OAAAA,CAAQK,UAAU,EAAE,QAAA,CAAA;QAC5CS,SAAAA,EAAWP,yBAAAA,CAAeP,OAAAA,CAAQK,UAAU,EAAE,WAAA;;AAG1D;;;;"}

package/dist/cjs/common/SceneErrorBoundary.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var Common = require('@cratis/components/Common');
+
+/**
+ * The `Cratis.Components:errorBoundary` component - `ErrorBoundary` from `@cratis/components/Common`.
+ *
+ * Lets a screen decide where a failure stops. React's default is that a throw anywhere unmounts the
+ * whole tree, which for a composed screen means one broken region takes the navigation with it; placing
+ * a boundary around a region scopes that to the region. Which regions deserve one is a design decision
+ * about the screen, which is precisely why it belongs in the screen rather than in the renderer.
+ */ function SceneErrorBoundary({ slots }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(Common.ErrorBoundary, {
+        children: slots.content
+    });
+}
+
+exports.SceneErrorBoundary = SceneErrorBoundary;
+//# sourceMappingURL=SceneErrorBoundary.js.map

package/dist/cjs/common/SceneErrorBoundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneErrorBoundary.js","sources":["../../../common/SceneErrorBoundary.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 { ErrorBoundary } from '@cratis/components/Common';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\n\n/**\n * The `Cratis.Components:errorBoundary` component - `ErrorBoundary` from `@cratis/components/Common`.\n *\n * Lets a screen decide where a failure stops. React's default is that a throw anywhere unmounts the\n * whole tree, which for a composed screen means one broken region takes the navigation with it; placing\n * a boundary around a region scopes that to the region. Which regions deserve one is a design decision\n * about the screen, which is precisely why it belongs in the screen rather than in the renderer.\n */\nexport function SceneErrorBoundary({ slots }: RegisteredComponentProps) {\n    return <ErrorBoundary>{slots.content}</ErrorBoundary>;\n}\n"],"names":["SceneErrorBoundary","slots","_jsx","ErrorBoundary","content"],"mappings":";;;;;AAMA;;;;;;;AAOC,IACM,SAASA,kBAAAA,CAAmB,EAAEC,KAAK,EAA4B,EAAA;AAClE,IAAA,qBAAOC,cAAA,CAACC,oBAAAA,EAAAA;AAAeF,QAAAA,QAAAA,EAAAA,KAAAA,CAAMG;;AACjC;;;;"}

package/dist/cjs/common/SceneIcon.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var Common = require('@cratis/components/Common');
+var properties = require('../properties.js');
+
+/**
+ * The `Cratis.Components:icon` component - `IconDisplay` from `@cratis/components/Common`.
+ *
+ * Takes an icon class name (`pi pi-check`) rather than an image, and normalizes the shorthand forms
+ * people actually write - `pi-check` on its own, or a bare name - into the class PrimeIcons expects.
+ * That normalization is the whole reason to route a screen's icons through this rather than emitting an
+ * `<i>`: a screen author writes what they remember and it still renders.
+ */ function SceneIcon({ element }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(Common.IconDisplay, {
+        icon: properties.stringProperty(element.properties, 'icon') ?? '',
+        className: properties.stringProperty(element.properties, 'className')
+    });
+}
+
+exports.SceneIcon = SceneIcon;
+//# sourceMappingURL=SceneIcon.js.map

package/dist/cjs/common/SceneIcon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneIcon.js","sources":["../../../common/SceneIcon.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 { IconDisplay } from '@cratis/components/Common';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { stringProperty } from '../properties';\n\n/**\n * The `Cratis.Components:icon` component - `IconDisplay` from `@cratis/components/Common`.\n *\n * Takes an icon class name (`pi pi-check`) rather than an image, and normalizes the shorthand forms\n * people actually write - `pi-check` on its own, or a bare name - into the class PrimeIcons expects.\n * That normalization is the whole reason to route a screen's icons through this rather than emitting an\n * `<i>`: a screen author writes what they remember and it still renders.\n */\nexport function SceneIcon({ element }: RegisteredComponentProps) {\n    return <IconDisplay icon={stringProperty(element.properties, 'icon') ?? ''} className={stringProperty(element.properties, 'className')} />;\n}\n"],"names":["SceneIcon","element","_jsx","IconDisplay","icon","stringProperty","properties","className"],"mappings":";;;;;;AAOA;;;;;;;AAOC,IACM,SAASA,SAAAA,CAAU,EAAEC,OAAO,EAA4B,EAAA;AAC3D,IAAA,qBAAOC,cAAA,CAACC,kBAAAA,EAAAA;AAAYC,QAAAA,IAAAA,EAAMC,yBAAAA,CAAeJ,OAAAA,CAAQK,UAAU,EAAE,MAAA,CAAA,IAAW,EAAA;QAAIC,SAAAA,EAAWF,yBAAAA,CAAeJ,OAAAA,CAAQK,UAAU,EAAE,WAAA;;AAC9H;;;;"}

package/dist/cjs/common/SceneTooltip.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var Common = require('@cratis/components/Common');
+var properties = require('../properties.js');
+
+/** Which side of the wrapped content the tooltip appears on. */ const positions = [
+    'top',
+    'right',
+    'bottom',
+    'left'
+];
+/**
+ * The `Cratis.Components:tooltip` component - `Tooltip` from `@cratis/components/Common`.
+ *
+ * Wraps whatever is in its `content` slot and explains it on hover. `disabled` exists so a screen can
+ * keep the wrapper in place while turning the hint off, rather than restructuring the element tree to
+ * remove it - the tree is authored, and a conditional wrapper would be a worse thing to model.
+ */ function SceneTooltip({ element, slots }) {
+    return /*#__PURE__*/ jsxRuntime.jsx(Common.Tooltip, {
+        content: properties.stringProperty(element.properties, 'content') ?? '',
+        position: properties.unionProperty(element.properties, 'position', positions),
+        disabled: properties.booleanProperty(element.properties, 'disabled'),
+        children: slots.content
+    });
+}
+
+exports.SceneTooltip = SceneTooltip;
+//# sourceMappingURL=SceneTooltip.js.map

package/dist/cjs/common/SceneTooltip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneTooltip.js","sources":["../../../common/SceneTooltip.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 { Tooltip } from '@cratis/components/Common';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, stringProperty, unionProperty } from '../properties';\n\n/** Which side of the wrapped content the tooltip appears on. */\nconst positions = ['top', 'right', 'bottom', 'left'] as const;\n\n/**\n * The `Cratis.Components:tooltip` component - `Tooltip` from `@cratis/components/Common`.\n *\n * Wraps whatever is in its `content` slot and explains it on hover. `disabled` exists so a screen can\n * keep the wrapper in place while turning the hint off, rather than restructuring the element tree to\n * remove it - the tree is authored, and a conditional wrapper would be a worse thing to model.\n */\nexport function SceneTooltip({ element, slots }: RegisteredComponentProps) {\n    return (\n        <Tooltip\n            content={stringProperty(element.properties, 'content') ?? ''}\n            position={unionProperty(element.properties, 'position', positions)}\n            disabled={booleanProperty(element.properties, 'disabled')}\n        >\n            {slots.content}\n        </Tooltip>\n    );\n}\n"],"names":["positions","SceneTooltip","element","slots","_jsx","Tooltip","content","stringProperty","properties","position","unionProperty","disabled","booleanProperty"],"mappings":";;;;;;AAOA,iEACA,MAAMA,SAAAA,GAAY;AAAC,IAAA,KAAA;AAAO,IAAA,OAAA;AAAS,IAAA,QAAA;AAAU,IAAA;AAAO,CAAA;AAEpD;;;;;;AAMC,IACM,SAASC,YAAAA,CAAa,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;AACrE,IAAA,qBACIC,cAAA,CAACC,cAAAA,EAAAA;AACGC,QAAAA,OAAAA,EAASC,yBAAAA,CAAeL,OAAAA,CAAQM,UAAU,EAAE,SAAA,CAAA,IAAc,EAAA;AAC1DC,QAAAA,QAAAA,EAAUC,wBAAAA,CAAcR,OAAAA,CAAQM,UAAU,EAAE,UAAA,EAAYR,SAAAA,CAAAA;QACxDW,QAAAA,EAAUC,0BAAAA,CAAgBV,OAAAA,CAAQM,UAAU,EAAE,UAAA,CAAA;AAE7CL,QAAAA,QAAAA,EAAAA,KAAAA,CAAMG;;AAGnB;;;;"}

package/dist/cjs/cratisComponents.js

@@ -0,0 +1,106 @@
+'use strict';
+
+var scene_react = require('@cratis/scene.react');
+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');
+require('react/jsx-runtime');
+require('./bindings/resolveElementBinding.js');
+require('react');
+require('@cratis/components/Common');
+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 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');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The package name every component here is registered under, and the one a screen writes when it
+ * qualifies a name explicitly (`Cratis.Components.table`).
+ */ const cratisComponentsPackageName = 'Cratis.Components';
+/**
+ * The `Cratis.Components` package's component registry - the abstract names a screen can resolve to a
+ * real `@cratis/components` component.
+ *
+ * Names are `lowerCamelCase` and deliberately *abstract*: a screen names `dataTable`, not
+ * `DataTableForQuery`, so the same screen resolves against whichever package a profile ranks highest.
+ * Two of them - `table` and `dialog` - are names `core` and `PrimeReact` also declare, and that overlap
+ * is the point: a profile listing `core`, `PrimeReact`, `Cratis.Components` in that order resolves both
+ * here and records the others as shadowed, which is override priority doing exactly what it exists for.
+ *
+ * `table` and `dataTable` are the same component under two names. `dataTable` says what it is; `table`
+ * is what a screen written against the base vocabulary already says, and both should land on the
+ * query-aware implementation.
+ */ const cratisComponents = {
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'page')]: ScenePage.ScenePage,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'dataPage')]: SceneDataPage.SceneDataPage,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'formElement')]: SceneFormElement.SceneFormElement,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'dataTable')]: SceneDataTable.SceneDataTable,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'table')]: SceneDataTable.SceneDataTable,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'observableDataTable')]: SceneObservableDataTable.SceneObservableDataTable,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'commandForm')]: SceneCommandForm.SceneCommandForm,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'inputTextField')]: SceneInputTextField.SceneInputTextField,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'numberField')]: SceneNumberField.SceneNumberField,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'checkboxField')]: SceneCheckboxField.SceneCheckboxField,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'textAreaField')]: SceneTextAreaField.SceneTextAreaField,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'dropdownField')]: SceneDropdownField.SceneDropdownField,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'sliderField')]: SceneSliderField.SceneSliderField,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'calendarField')]: SceneCalendarField.SceneCalendarField,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'colorPickerField')]: SceneColorPickerField.SceneColorPickerField,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'multiSelectField')]: SceneMultiSelectField.SceneMultiSelectField,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'chipsField')]: SceneChipsField.SceneChipsField,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'radioButtonField')]: SceneRadioButtonField.SceneRadioButtonField,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'radioGroupField')]: SceneRadioGroupField.SceneRadioGroupField,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'dialog')]: SceneDialog.SceneDialog,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'confirmationDialog')]: SceneConfirmationDialog.SceneConfirmationDialog,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'busyIndicatorDialog')]: SceneBusyIndicatorDialog.SceneBusyIndicatorDialog,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'commandDialog')]: SceneCommandDialog.SceneCommandDialog,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'stepperCommandDialog')]: SceneStepperCommandDialog.SceneStepperCommandDialog,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'icon')]: SceneIcon.SceneIcon,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'tooltip')]: SceneTooltip.SceneTooltip,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'dropdown')]: SceneDropdown.SceneDropdown,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'errorBoundary')]: SceneErrorBoundary.SceneErrorBoundary,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'objectContentEditor')]: SceneObjectContentEditor.SceneObjectContentEditor,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'objectNavigationalBar')]: SceneObjectNavigationalBar.SceneObjectNavigationalBar,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'schemaEditor')]: SceneSchemaEditor.SceneSchemaEditor,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'timeMachine')]: SceneTimeMachine.SceneTimeMachine,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'filterPanel')]: SceneFilterPanel.SceneFilterPanel,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'toolbar')]: SceneToolbar.SceneToolbar,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'toolbarButton')]: SceneToolbarButton.SceneToolbarButton,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'toolbarGroup')]: SceneToolbarGroup.SceneToolbarGroup,
+    [scene_react.componentRegistryKey(cratisComponentsPackageName, 'toolbarSeparator')]: SceneToolbarSeparator.SceneToolbarSeparator
+};
+
+exports.cratisComponents = cratisComponents;
+exports.cratisComponentsPackageName = cratisComponentsPackageName;
+//# sourceMappingURL=cratisComponents.js.map

package/dist/cjs/cratisComponents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cratisComponents.js","sources":["../../cratisComponents.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 { ComponentRegistry, componentRegistryKey } from '@cratis/scene.react';\nimport { SceneDataPage, SceneFormElement, ScenePage } from './pages';\nimport { SceneDataTable, SceneObservableDataTable } from './data';\nimport {\n    SceneCalendarField,\n    SceneCheckboxField,\n    SceneChipsField,\n    SceneColorPickerField,\n    SceneCommandForm,\n    SceneDropdownField,\n    SceneInputTextField,\n    SceneMultiSelectField,\n    SceneNumberField,\n    SceneRadioButtonField,\n    SceneRadioGroupField,\n    SceneSliderField,\n    SceneTextAreaField,\n} from './forms';\nimport { SceneBusyIndicatorDialog, SceneCommandDialog, SceneConfirmationDialog, SceneDialog, SceneStepperCommandDialog } from './dialogs';\nimport { SceneDropdown, SceneErrorBoundary, SceneIcon, SceneTooltip } from './common';\nimport { SceneFilterPanel, SceneObjectContentEditor, SceneObjectNavigationalBar, SceneSchemaEditor, SceneTimeMachine } from './editors';\nimport { SceneToolbar, SceneToolbarButton, SceneToolbarGroup, SceneToolbarSeparator } from './toolbar';\n\n/**\n * The package name every component here is registered under, and the one a screen writes when it\n * qualifies a name explicitly (`Cratis.Components.table`).\n */\nexport const cratisComponentsPackageName = 'Cratis.Components';\n\n/**\n * The `Cratis.Components` package's component registry - the abstract names a screen can resolve to a\n * real `@cratis/components` component.\n *\n * Names are `lowerCamelCase` and deliberately *abstract*: a screen names `dataTable`, not\n * `DataTableForQuery`, so the same screen resolves against whichever package a profile ranks highest.\n * Two of them - `table` and `dialog` - are names `core` and `PrimeReact` also declare, and that overlap\n * is the point: a profile listing `core`, `PrimeReact`, `Cratis.Components` in that order resolves both\n * here and records the others as shadowed, which is override priority doing exactly what it exists for.\n *\n * `table` and `dataTable` are the same component under two names. `dataTable` says what it is; `table`\n * is what a screen written against the base vocabulary already says, and both should land on the\n * query-aware implementation.\n */\nexport const cratisComponents: ComponentRegistry = {\n    [componentRegistryKey(cratisComponentsPackageName, 'page')]: ScenePage,\n    [componentRegistryKey(cratisComponentsPackageName, 'dataPage')]: SceneDataPage,\n    [componentRegistryKey(cratisComponentsPackageName, 'formElement')]: SceneFormElement,\n\n    [componentRegistryKey(cratisComponentsPackageName, 'dataTable')]: SceneDataTable,\n    [componentRegistryKey(cratisComponentsPackageName, 'table')]: SceneDataTable,\n    [componentRegistryKey(cratisComponentsPackageName, 'observableDataTable')]: SceneObservableDataTable,\n\n    [componentRegistryKey(cratisComponentsPackageName, 'commandForm')]: SceneCommandForm,\n    [componentRegistryKey(cratisComponentsPackageName, 'inputTextField')]: SceneInputTextField,\n    [componentRegistryKey(cratisComponentsPackageName, 'numberField')]: SceneNumberField,\n    [componentRegistryKey(cratisComponentsPackageName, 'checkboxField')]: SceneCheckboxField,\n    [componentRegistryKey(cratisComponentsPackageName, 'textAreaField')]: SceneTextAreaField,\n    [componentRegistryKey(cratisComponentsPackageName, 'dropdownField')]: SceneDropdownField,\n    [componentRegistryKey(cratisComponentsPackageName, 'sliderField')]: SceneSliderField,\n    [componentRegistryKey(cratisComponentsPackageName, 'calendarField')]: SceneCalendarField,\n    [componentRegistryKey(cratisComponentsPackageName, 'colorPickerField')]: SceneColorPickerField,\n    [componentRegistryKey(cratisComponentsPackageName, 'multiSelectField')]: SceneMultiSelectField,\n    [componentRegistryKey(cratisComponentsPackageName, 'chipsField')]: SceneChipsField,\n    [componentRegistryKey(cratisComponentsPackageName, 'radioButtonField')]: SceneRadioButtonField,\n    [componentRegistryKey(cratisComponentsPackageName, 'radioGroupField')]: SceneRadioGroupField,\n\n    [componentRegistryKey(cratisComponentsPackageName, 'dialog')]: SceneDialog,\n    [componentRegistryKey(cratisComponentsPackageName, 'confirmationDialog')]: SceneConfirmationDialog,\n    [componentRegistryKey(cratisComponentsPackageName, 'busyIndicatorDialog')]: SceneBusyIndicatorDialog,\n    [componentRegistryKey(cratisComponentsPackageName, 'commandDialog')]: SceneCommandDialog,\n    [componentRegistryKey(cratisComponentsPackageName, 'stepperCommandDialog')]: SceneStepperCommandDialog,\n\n    [componentRegistryKey(cratisComponentsPackageName, 'icon')]: SceneIcon,\n    [componentRegistryKey(cratisComponentsPackageName, 'tooltip')]: SceneTooltip,\n    [componentRegistryKey(cratisComponentsPackageName, 'dropdown')]: SceneDropdown,\n    [componentRegistryKey(cratisComponentsPackageName, 'errorBoundary')]: SceneErrorBoundary,\n\n    [componentRegistryKey(cratisComponentsPackageName, 'objectContentEditor')]: SceneObjectContentEditor,\n    [componentRegistryKey(cratisComponentsPackageName, 'objectNavigationalBar')]: SceneObjectNavigationalBar,\n    [componentRegistryKey(cratisComponentsPackageName, 'schemaEditor')]: SceneSchemaEditor,\n    [componentRegistryKey(cratisComponentsPackageName, 'timeMachine')]: SceneTimeMachine,\n    [componentRegistryKey(cratisComponentsPackageName, 'filterPanel')]: SceneFilterPanel,\n\n    [componentRegistryKey(cratisComponentsPackageName, 'toolbar')]: SceneToolbar,\n    [componentRegistryKey(cratisComponentsPackageName, 'toolbarButton')]: SceneToolbarButton,\n    [componentRegistryKey(cratisComponentsPackageName, 'toolbarGroup')]: SceneToolbarGroup,\n    [componentRegistryKey(cratisComponentsPackageName, 'toolbarSeparator')]: SceneToolbarSeparator,\n};\n"],"names":["cratisComponentsPackageName","cratisComponents","componentRegistryKey","ScenePage","SceneDataPage","SceneFormElement","SceneDataTable","SceneObservableDataTable","SceneCommandForm","SceneInputTextField","SceneNumberField","SceneCheckboxField","SceneTextAreaField","SceneDropdownField","SceneSliderField","SceneCalendarField","SceneColorPickerField","SceneMultiSelectField","SceneChipsField","SceneRadioButtonField","SceneRadioGroupField","SceneDialog","SceneConfirmationDialog","SceneBusyIndicatorDialog","SceneCommandDialog","SceneStepperCommandDialog","SceneIcon","SceneTooltip","SceneDropdown","SceneErrorBoundary","SceneObjectContentEditor","SceneObjectNavigationalBar","SceneSchemaEditor","SceneTimeMachine","SceneFilterPanel","SceneToolbar","SceneToolbarButton","SceneToolbarGroup","SceneToolbarSeparator"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AACA;AAyBA;;;IAIO,MAAMA,2BAAAA,GAA8B;AAE3C;;;;;;;;;;;;;UAcaC,gBAAAA,GAAsC;IAC/C,CAACC,gCAAAA,CAAqBF,2BAAAA,EAA6B,MAAA,CAAA,GAAUG,mBAAAA;IAC7D,CAACD,gCAAAA,CAAqBF,2BAAAA,EAA6B,UAAA,CAAA,GAAcI,2BAAAA;IACjE,CAACF,gCAAAA,CAAqBF,2BAAAA,EAA6B,aAAA,CAAA,GAAiBK,iCAAAA;IAEpE,CAACH,gCAAAA,CAAqBF,2BAAAA,EAA6B,WAAA,CAAA,GAAeM,6BAAAA;IAClE,CAACJ,gCAAAA,CAAqBF,2BAAAA,EAA6B,OAAA,CAAA,GAAWM,6BAAAA;IAC9D,CAACJ,gCAAAA,CAAqBF,2BAAAA,EAA6B,qBAAA,CAAA,GAAyBO,iDAAAA;IAE5E,CAACL,gCAAAA,CAAqBF,2BAAAA,EAA6B,aAAA,CAAA,GAAiBQ,iCAAAA;IACpE,CAACN,gCAAAA,CAAqBF,2BAAAA,EAA6B,gBAAA,CAAA,GAAoBS,uCAAAA;IACvE,CAACP,gCAAAA,CAAqBF,2BAAAA,EAA6B,aAAA,CAAA,GAAiBU,iCAAAA;IACpE,CAACR,gCAAAA,CAAqBF,2BAAAA,EAA6B,eAAA,CAAA,GAAmBW,qCAAAA;IACtE,CAACT,gCAAAA,CAAqBF,2BAAAA,EAA6B,eAAA,CAAA,GAAmBY,qCAAAA;IACtE,CAACV,gCAAAA,CAAqBF,2BAAAA,EAA6B,eAAA,CAAA,GAAmBa,qCAAAA;IACtE,CAACX,gCAAAA,CAAqBF,2BAAAA,EAA6B,aAAA,CAAA,GAAiBc,iCAAAA;IACpE,CAACZ,gCAAAA,CAAqBF,2BAAAA,EAA6B,eAAA,CAAA,GAAmBe,qCAAAA;IACtE,CAACb,gCAAAA,CAAqBF,2BAAAA,EAA6B,kBAAA,CAAA,GAAsBgB,2CAAAA;IACzE,CAACd,gCAAAA,CAAqBF,2BAAAA,EAA6B,kBAAA,CAAA,GAAsBiB,2CAAAA;IACzE,CAACf,gCAAAA,CAAqBF,2BAAAA,EAA6B,YAAA,CAAA,GAAgBkB,+BAAAA;IACnE,CAAChB,gCAAAA,CAAqBF,2BAAAA,EAA6B,kBAAA,CAAA,GAAsBmB,2CAAAA;IACzE,CAACjB,gCAAAA,CAAqBF,2BAAAA,EAA6B,iBAAA,CAAA,GAAqBoB,yCAAAA;IAExE,CAAClB,gCAAAA,CAAqBF,2BAAAA,EAA6B,QAAA,CAAA,GAAYqB,uBAAAA;IAC/D,CAACnB,gCAAAA,CAAqBF,2BAAAA,EAA6B,oBAAA,CAAA,GAAwBsB,+CAAAA;IAC3E,CAACpB,gCAAAA,CAAqBF,2BAAAA,EAA6B,qBAAA,CAAA,GAAyBuB,iDAAAA;IAC5E,CAACrB,gCAAAA,CAAqBF,2BAAAA,EAA6B,eAAA,CAAA,GAAmBwB,qCAAAA;IACtE,CAACtB,gCAAAA,CAAqBF,2BAAAA,EAA6B,sBAAA,CAAA,GAA0ByB,mDAAAA;IAE7E,CAACvB,gCAAAA,CAAqBF,2BAAAA,EAA6B,MAAA,CAAA,GAAU0B,mBAAAA;IAC7D,CAACxB,gCAAAA,CAAqBF,2BAAAA,EAA6B,SAAA,CAAA,GAAa2B,yBAAAA;IAChE,CAACzB,gCAAAA,CAAqBF,2BAAAA,EAA6B,UAAA,CAAA,GAAc4B,2BAAAA;IACjE,CAAC1B,gCAAAA,CAAqBF,2BAAAA,EAA6B,eAAA,CAAA,GAAmB6B,qCAAAA;IAEtE,CAAC3B,gCAAAA,CAAqBF,2BAAAA,EAA6B,qBAAA,CAAA,GAAyB8B,iDAAAA;IAC5E,CAAC5B,gCAAAA,CAAqBF,2BAAAA,EAA6B,uBAAA,CAAA,GAA2B+B,qDAAAA;IAC9E,CAAC7B,gCAAAA,CAAqBF,2BAAAA,EAA6B,cAAA,CAAA,GAAkBgC,mCAAAA;IACrE,CAAC9B,gCAAAA,CAAqBF,2BAAAA,EAA6B,aAAA,CAAA,GAAiBiC,iCAAAA;IACpE,CAAC/B,gCAAAA,CAAqBF,2BAAAA,EAA6B,aAAA,CAAA,GAAiBkC,iCAAAA;IAEpE,CAAChC,gCAAAA,CAAqBF,2BAAAA,EAA6B,SAAA,CAAA,GAAamC,yBAAAA;IAChE,CAACjC,gCAAAA,CAAqBF,2BAAAA,EAA6B,eAAA,CAAA,GAAmBoC,qCAAAA;IACtE,CAAClC,gCAAAA,CAAqBF,2BAAAA,EAA6B,cAAA,CAAA,GAAkBqC,mCAAAA;IACrE,CAACnC,gCAAAA,CAAqBF,2BAAAA,EAA6B,kBAAA,CAAA,GAAsBsC;AAC7E;;;;;"}

package/dist/cjs/cratisComponentsPackage.js

@@ -0,0 +1,105 @@
+'use strict';
+
+var scene_model = require('@cratis/scene.model');
+var cratisComponents = require('./cratisComponents.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The `Cratis.Components` package's declaration - what a profile gets when it lists this package.
+ *
+ * This is the concrete case the whole package-dependency mechanism exists for. `@cratis/components` is
+ * not a self-contained library: every component in it is a wrapper over a PrimeReact widget, and its
+ * own styling is a compiled Tailwind utility sheet (`@cratis/components/styles`) plus a `--cratis-*`
+ * token layer. Activate it in a profile without PrimeReact and nothing renders; activate it without
+ * Tailwind and everything renders unstyled. Both are stated as dependencies so a package picker can say
+ * so while the profile is being configured, instead of leaving it to be discovered when the page opens.
+ *
+ * The version ranges are the real ones the library carries: `>=10.9.0` for PrimeReact because its
+ * `--cratis-*` tokens resolve PrimeReact 11's design tokens first and fall back to the version 10 theme
+ * variables, so it spans the upgrade window; `^4.0.0` for Tailwind because the utility sheet is compiled
+ * against Tailwind 4.
+ */ const cratisComponentsPackageManifest = {
+    name: cratisComponents.cratisComponentsPackageName,
+    version: '2.8.1',
+    kind: scene_model.PackageKind.ComponentLibrary,
+    dependencies: [
+        {
+            name: 'PrimeReact',
+            versionRange: '>=10.9.0'
+        },
+        {
+            name: 'Tailwind',
+            versionRange: '^4.0.0'
+        }
+    ],
+    components: [
+        'page',
+        'dataPage',
+        'formElement',
+        'dataTable',
+        'table',
+        'observableDataTable',
+        'commandForm',
+        'inputTextField',
+        'numberField',
+        'checkboxField',
+        'textAreaField',
+        'dropdownField',
+        'sliderField',
+        'calendarField',
+        'colorPickerField',
+        'multiSelectField',
+        'chipsField',
+        'radioButtonField',
+        'radioGroupField',
+        'dialog',
+        'confirmationDialog',
+        'busyIndicatorDialog',
+        'commandDialog',
+        'stepperCommandDialog',
+        'icon',
+        'tooltip',
+        'dropdown',
+        'errorBoundary',
+        'objectContentEditor',
+        'objectNavigationalBar',
+        'schemaEditor',
+        'timeMachine',
+        'filterPanel',
+        'toolbar',
+        'toolbarButton',
+        'toolbarGroup',
+        'toolbarSeparator'
+    ],
+    // A component library ships components, and nothing else. Layouts, screen templates and dialog
+    // templates all belong to a Blueprint: they are decisions about what an application looks like as a
+    // whole, and this package deliberately makes none of them - it provides the Arc-bound composites a
+    // template is *built from*, so that a blueprint can place a `dataPage` in a slot and configure it,
+    // rather than shipping one opinionated data page nobody can rearrange.
+    layouts: [],
+    screenTemplates: [],
+    dialogTemplates: [],
+    // No themes either, for a different reason: `@cratis/components` has no palette of its own. It reads
+    // a `--cratis-*` variable layer that resolves whatever PrimeReact theme - or Scene theme, through
+    // this package's token bridge - happens to be active. Shipping a theme here would be this library
+    // asserting a look it was specifically built not to have.
+    themes: [],
+    displayName: 'Cratis Components',
+    description: "Cratis' Arc-bound data, form and dialog composites, built on PrimeReact and Tailwind.",
+    module: '@cratis/scene.components'
+};
+/**
+ * The `Cratis.Components` package as a loadable bundle - the manifest above, plus the React components
+ * behind the names it declares.
+ *
+ * No `layouts`, `screenTemplates`, `dialogTemplates` or `themes` are provided, matching a manifest that
+ * declares none of them; `validatePackageBundle` is what proves the two halves agree.
+ */ const cratisComponentsPackage = {
+    manifest: cratisComponentsPackageManifest,
+    components: cratisComponents.cratisComponents
+};
+
+exports.cratisComponentsPackage = cratisComponentsPackage;
+exports.cratisComponentsPackageManifest = cratisComponentsPackageManifest;
+//# sourceMappingURL=cratisComponentsPackage.js.map

package/dist/cjs/cratisComponentsPackage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cratisComponentsPackage.js","sources":["../../cratisComponentsPackage.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 { PackageKind, ScenePackage } from '@cratis/scene.model';\nimport { ScenePackageBundle } from '@cratis/scene.react';\nimport { cratisComponents, cratisComponentsPackageName } from './cratisComponents';\n\n/**\n * The `Cratis.Components` package's declaration - what a profile gets when it lists this package.\n *\n * This is the concrete case the whole package-dependency mechanism exists for. `@cratis/components` is\n * not a self-contained library: every component in it is a wrapper over a PrimeReact widget, and its\n * own styling is a compiled Tailwind utility sheet (`@cratis/components/styles`) plus a `--cratis-*`\n * token layer. Activate it in a profile without PrimeReact and nothing renders; activate it without\n * Tailwind and everything renders unstyled. Both are stated as dependencies so a package picker can say\n * so while the profile is being configured, instead of leaving it to be discovered when the page opens.\n *\n * The version ranges are the real ones the library carries: `>=10.9.0` for PrimeReact because its\n * `--cratis-*` tokens resolve PrimeReact 11's design tokens first and fall back to the version 10 theme\n * variables, so it spans the upgrade window; `^4.0.0` for Tailwind because the utility sheet is compiled\n * against Tailwind 4.\n */\nexport const cratisComponentsPackageManifest: ScenePackage = {\n    name: cratisComponentsPackageName,\n    version: '2.8.1',\n    kind: PackageKind.ComponentLibrary,\n    dependencies: [\n        { name: 'PrimeReact', versionRange: '>=10.9.0' },\n        { name: 'Tailwind', versionRange: '^4.0.0' },\n    ],\n    components: [\n        'page',\n        'dataPage',\n        'formElement',\n        'dataTable',\n        'table',\n        'observableDataTable',\n        'commandForm',\n        'inputTextField',\n        'numberField',\n        'checkboxField',\n        'textAreaField',\n        'dropdownField',\n        'sliderField',\n        'calendarField',\n        'colorPickerField',\n        'multiSelectField',\n        'chipsField',\n        'radioButtonField',\n        'radioGroupField',\n        'dialog',\n        'confirmationDialog',\n        'busyIndicatorDialog',\n        'commandDialog',\n        'stepperCommandDialog',\n        'icon',\n        'tooltip',\n        'dropdown',\n        'errorBoundary',\n        'objectContentEditor',\n        'objectNavigationalBar',\n        'schemaEditor',\n        'timeMachine',\n        'filterPanel',\n        'toolbar',\n        'toolbarButton',\n        'toolbarGroup',\n        'toolbarSeparator',\n    ],\n\n    // A component library ships components, and nothing else. Layouts, screen templates and dialog\n    // templates all belong to a Blueprint: they are decisions about what an application looks like as a\n    // whole, and this package deliberately makes none of them - it provides the Arc-bound composites a\n    // template is *built from*, so that a blueprint can place a `dataPage` in a slot and configure it,\n    // rather than shipping one opinionated data page nobody can rearrange.\n    layouts: [],\n    screenTemplates: [],\n    dialogTemplates: [],\n\n    // No themes either, for a different reason: `@cratis/components` has no palette of its own. It reads\n    // a `--cratis-*` variable layer that resolves whatever PrimeReact theme - or Scene theme, through\n    // this package's token bridge - happens to be active. Shipping a theme here would be this library\n    // asserting a look it was specifically built not to have.\n    themes: [],\n\n    displayName: 'Cratis Components',\n    description: \"Cratis' Arc-bound data, form and dialog composites, built on PrimeReact and Tailwind.\",\n    module: '@cratis/scene.components',\n};\n\n/**\n * The `Cratis.Components` package as a loadable bundle - the manifest above, plus the React components\n * behind the names it declares.\n *\n * No `layouts`, `screenTemplates`, `dialogTemplates` or `themes` are provided, matching a manifest that\n * declares none of them; `validatePackageBundle` is what proves the two halves agree.\n */\nexport const cratisComponentsPackage: ScenePackageBundle = {\n    manifest: cratisComponentsPackageManifest,\n    components: cratisComponents,\n};\n"],"names":["cratisComponentsPackageManifest","name","cratisComponentsPackageName","version","kind","PackageKind","ComponentLibrary","dependencies","versionRange","components","layouts","screenTemplates","dialogTemplates","themes","displayName","description","module","cratisComponentsPackage","manifest","cratisComponents"],"mappings":";;;;;AAAA;AACA;AAMA;;;;;;;;;;;;;;UAeaA,+BAAAA,GAAgD;IACzDC,IAAAA,EAAMC,4CAAAA;IACNC,OAAAA,EAAS,OAAA;AACTC,IAAAA,IAAAA,EAAMC,wBAAYC,gBAAgB;IAClCC,YAAAA,EAAc;AACV,QAAA;YAAEN,IAAAA,EAAM,YAAA;YAAcO,YAAAA,EAAc;AAAW,SAAA;AAC/C,QAAA;YAAEP,IAAAA,EAAM,UAAA;YAAYO,YAAAA,EAAc;AAAS;AAC9C,KAAA;IACDC,UAAAA,EAAY;AACR,QAAA,MAAA;AACA,QAAA,UAAA;AACA,QAAA,aAAA;AACA,QAAA,WAAA;AACA,QAAA,OAAA;AACA,QAAA,qBAAA;AACA,QAAA,aAAA;AACA,QAAA,gBAAA;AACA,QAAA,aAAA;AACA,QAAA,eAAA;AACA,QAAA,eAAA;AACA,QAAA,eAAA;AACA,QAAA,aAAA;AACA,QAAA,eAAA;AACA,QAAA,kBAAA;AACA,QAAA,kBAAA;AACA,QAAA,YAAA;AACA,QAAA,kBAAA;AACA,QAAA,iBAAA;AACA,QAAA,QAAA;AACA,QAAA,oBAAA;AACA,QAAA,qBAAA;AACA,QAAA,eAAA;AACA,QAAA,sBAAA;AACA,QAAA,MAAA;AACA,QAAA,SAAA;AACA,QAAA,UAAA;AACA,QAAA,eAAA;AACA,QAAA,qBAAA;AACA,QAAA,uBAAA;AACA,QAAA,cAAA;AACA,QAAA,aAAA;AACA,QAAA,aAAA;AACA,QAAA,SAAA;AACA,QAAA,eAAA;AACA,QAAA,cAAA;AACA,QAAA;AACH,KAAA;;;;;;AAODC,IAAAA,OAAAA,EAAS,EAAE;AACXC,IAAAA,eAAAA,EAAiB,EAAE;AACnBC,IAAAA,eAAAA,EAAiB,EAAE;;;;;AAMnBC,IAAAA,MAAAA,EAAQ,EAAE;IAEVC,WAAAA,EAAa,mBAAA;IACbC,WAAAA,EAAa,uFAAA;IACbC,MAAAA,EAAQ;AACZ;AAEA;;;;;;UAOaC,uBAAAA,GAA8C;IACvDC,QAAAA,EAAUlB,+BAAAA;IACVS,UAAAA,EAAYU;AAChB;;;;;"}

package/dist/cjs/data/SceneDataTable.js

@@ -0,0 +1,46 @@
+'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 DataTableForQuery = /*#__PURE__*/ react.lazy(async ()=>({
+        default: (await import('@cratis/components/DataTables')).DataTableForQuery
+    }));
+/**
+ * The `Cratis.Components:dataTable` component, also registered as `table` - `DataTableForQuery` from
+ * `@cratis/components/DataTables`.
+ *
+ * Registering it under the bare name `table` as well is override priority working as designed: a profile
+ * listing `core`, `PrimeReact` and `Cratis.Components` in that order resolves `table` here and records
+ * the other two as shadowed. That is the right outcome, because this is a strictly better `table` for a
+ * Cratis application - it performs the query, pages against the server, and wires filtering and sorting
+ * back into it, where PrimeReact's `DataTable` is handed rows and knows nothing about where they came from.
+ *
+ * The `query` property names an Arc query proxy; the columns come from the `content` slot.
+ */ function SceneDataTable({ 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(DataTableForQuery, {
+            query: target,
+            emptyMessage: properties.stringProperty(element.properties, 'emptyMessage') ?? '',
+            dataKey: properties.stringProperty(element.properties, 'dataKey'),
+            globalFilterFields: properties.stringArrayProperty(element.properties, 'globalFilterFields'),
+            clientFiltering: properties.booleanProperty(element.properties, 'clientFiltering'),
+            className: properties.stringProperty(element.properties, 'className'),
+            children: slots.content
+        })
+    });
+}
+
+exports.SceneDataTable = SceneDataTable;
+//# sourceMappingURL=SceneDataTable.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SceneDataTable.js","sources":["../../../data/SceneDataTable.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 DataTableForQuery = lazy(async () => ({ default: (await import('@cratis/components/DataTables')).DataTableForQuery }));\n\n/**\n * The `Cratis.Components:dataTable` component, also registered as `table` - `DataTableForQuery` from\n * `@cratis/components/DataTables`.\n *\n * Registering it under the bare name `table` as well is override priority working as designed: a profile\n * listing `core`, `PrimeReact` and `Cratis.Components` in that order resolves `table` here and records\n * the other two as shadowed. That is the right outcome, because this is a strictly better `table` for a\n * Cratis application - it performs the query, pages against the server, and wires filtering and sorting\n * back into it, where PrimeReact's `DataTable` is handed rows and knows nothing about where they came from.\n *\n * The `query` property names an Arc query proxy; the columns come from the `content` slot.\n */\nexport function SceneDataTable({ 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            <DataTableForQuery\n                query={target}\n                emptyMessage={stringProperty(element.properties, 'emptyMessage') ?? ''}\n                dataKey={stringProperty(element.properties, 'dataKey')}\n                globalFilterFields={stringArrayProperty(element.properties, 'globalFilterFields')}\n                clientFiltering={booleanProperty(element.properties, 'clientFiltering')}\n                className={stringProperty(element.properties, 'className')}\n            >\n                {slots.content}\n            </DataTableForQuery>\n        </ArcRuntimeBoundary>\n    );\n}\n"],"names":["DataTableForQuery","lazy","default","SceneDataTable","element","slots","name","target","resolveElementBinding","BindingKind","Query","_jsx","MissingBinding","kind","ArcRuntimeBoundary","query","emptyMessage","stringProperty","properties","dataKey","globalFilterFields","stringArrayProperty","clientFiltering","booleanProperty","className","content"],"mappings":";;;;;;;;;;AAQA,MAAMA,iBAAAA,iBAAoBC,UAAAA,CAAK,WAAa;AAAEC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,+BAAA,CAA+B,EAAGF;KAAkB,CAAA,CAAA;AAEzH;;;;;;;;;;;AAWC,IACM,SAASG,cAAAA,CAAe,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;IACvE,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,iBAAAA,EAAAA;YACGe,KAAAA,EAAOR,MAAAA;AACPS,YAAAA,YAAAA,EAAcC,yBAAAA,CAAeb,OAAAA,CAAQc,UAAU,EAAE,cAAA,CAAA,IAAmB,EAAA;YACpEC,OAAAA,EAASF,yBAAAA,CAAeb,OAAAA,CAAQc,UAAU,EAAE,SAAA,CAAA;YAC5CE,kBAAAA,EAAoBC,8BAAAA,CAAoBjB,OAAAA,CAAQc,UAAU,EAAE,oBAAA,CAAA;YAC5DI,eAAAA,EAAiBC,0BAAAA,CAAgBnB,OAAAA,CAAQc,UAAU,EAAE,iBAAA,CAAA;YACrDM,SAAAA,EAAWP,yBAAAA,CAAeb,OAAAA,CAAQc,UAAU,EAAE,WAAA,CAAA;AAE7Cb,YAAAA,QAAAA,EAAAA,KAAAA,CAAMoB;;;AAIvB;;;;"}