@cratis/scene.components 4.2.1 → 4.4.0

package/bindings/resolveElementBinding.ts

@@ -17,6 +17,22 @@ const bindingPropertyNames: Record<BindingKind, string> = {
     [BindingKind.Command]: 'command',
 };
 
+/**
+ * Reads a binding name from a property that holds either the name itself or a `QueryBinding`, which is what an
+ * editor stores when a query is bound to a host-supplied candidate. Both resolve through the registry by name.
+ */
+function bindingName(properties: Record<string, unknown>, property: string): string | undefined {
+    const direct = stringProperty(properties, property);
+    if (direct !== undefined) return direct;
+
+    const binding = properties[property];
+    if (binding !== null && typeof binding === 'object' && !Array.isArray(binding)) {
+        return stringProperty(binding as Record<string, unknown>, 'query');
+    }
+
+    return undefined;
+}
+
 /**
  * Reads the binding name an element carries for the given kind and looks it up in the binding registry.
  *
@@ -26,7 +42,7 @@ const bindingPropertyNames: Record<BindingKind, string> = {
  * turns into a visible placeholder.
  */
 export function resolveElementBinding(element: ExternalComponent, kind: BindingKind): ElementBinding {
-    const name = stringProperty(element.properties, bindingPropertyNames[kind]);
+    const name = bindingName(element.properties, bindingPropertyNames[kind]);
     if (name === undefined) return {};
 
     return { name, target: kind === BindingKind.Query ? resolveQuery(name) : resolveCommand(name) };

package/cratisComponentsDescriptors.ts

@@ -0,0 +1,48 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ComponentDescriptor, PropertyDescriptor, PropertyValueType, QueryResultShape } from '@cratis/scene.model';
+import { componentRegistryKey } from '@cratis/scene.react';
+
+// The package name, spelled out so describing components does not pull every adapter (and its UI dependencies) in
+// with it; the bundle's validation checks each key against the manifest.
+const key = (name: string) => componentRegistryKey('Cratis.Components', name);
+
+/**
+ * The properties every query-bound data table shares: which query feeds it, and the few settings that shape how
+ * it shows the result.
+ *
+ * `query` is a `QueryReference`, so an editor binds it to a host-supplied query candidate and validates the
+ * arguments against it. What is stored is a `QueryBinding`; a plain query name - what screens carried before
+ * bindings existed - is still read, as a binding with no explicit connections. The columns are not properties:
+ * they are the `content` slot's children, edited as nodes.
+ */
+const dataTableProperties: PropertyDescriptor[] = [
+    {
+        path: 'query', label: 'Query', group: 'Data', valueType: PropertyValueType.QueryReference, editorKind: 'queryBinding',
+        description: 'The collection query that feeds the table.',
+        constraints: { required: true, resultShapes: [QueryResultShape.Collection] },
+    },
+    { path: 'emptyMessage', label: 'Empty message', group: 'Content', valueType: PropertyValueType.String, default: '' },
+    {
+        path: 'dataKey', label: 'Row identity', group: 'Data', valueType: PropertyValueType.String, editorKind: 'resultField',
+        description: 'The result field that identifies a row.',
+    },
+    {
+        path: 'globalFilterFields', label: 'Searchable fields', group: 'Data', valueType: PropertyValueType.Object, editorKind: 'resultFieldList',
+        description: 'The result fields the table\'s search box looks in.',
+    },
+];
+
+/**
+ * What can be edited on the `Cratis.Components` package's components.
+ *
+ * Only the query-bound tables are described so far; the form, dialog and editor composites carry
+ * Arc proxy classes by name and are configured through their own tooling. A package adds a descriptor here the
+ * same way it adds a component to the manifest.
+ */
+export const cratisComponentsDescriptors: ComponentDescriptor[] = [
+    { component: key('dataTable'), displayName: 'Data table', properties: dataTableProperties },
+    { component: key('table'), displayName: 'Table', properties: dataTableProperties },
+    { component: key('observableDataTable'), displayName: 'Live data table', properties: dataTableProperties },
+];

package/cratisComponentsPackage.ts

@@ -4,6 +4,7 @@
 import { PackageKind, ScenePackage } from '@cratis/scene.model';
 import { ScenePackageBundle } from '@cratis/scene.react';
 import { cratisComponents, cratisComponentsPackageName } from './cratisComponents';
+import { cratisComponentsDescriptors } from './cratisComponentsDescriptors';
 
 /**
  * The `Cratis.Components` package's declaration - what a profile gets when it lists this package.
@@ -106,4 +107,5 @@ export const cratisComponentsPackageManifest: ScenePackage = {
 export const cratisComponentsPackage: ScenePackageBundle = {
     manifest: cratisComponentsPackageManifest,
     components: cratisComponents,
+    descriptors: cratisComponentsDescriptors,
 };

package/dist/cjs/bindings/resolveElementBinding.js

@@ -14,6 +14,18 @@ var bindingRegistry = require('./bindingRegistry.js');
     [BindingKind.BindingKind.Query]: 'query',
     [BindingKind.BindingKind.Command]: 'command'
 };
+/**
+ * Reads a binding name from a property that holds either the name itself or a `QueryBinding`, which is what an
+ * editor stores when a query is bound to a host-supplied candidate. Both resolve through the registry by name.
+ */ function bindingName(properties$1, property) {
+    const direct = properties.stringProperty(properties$1, property);
+    if (direct !== undefined) return direct;
+    const binding = properties$1[property];
+    if (binding !== null && typeof binding === 'object' && !Array.isArray(binding)) {
+        return properties.stringProperty(binding, 'query');
+    }
+    return undefined;
+}
 /**
  * Reads the binding name an element carries for the given kind and looks it up in the binding registry.
  *
@@ -22,7 +34,7 @@ var bindingRegistry = require('./bindingRegistry.js');
  * 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]);
+    const name = bindingName(element.properties, bindingPropertyNames[kind]);
     if (name === undefined) return {};
     return {
         name,

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

@@ -1 +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;;"}
+{"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 a binding name from a property that holds either the name itself or a `QueryBinding`, which is what an\n * editor stores when a query is bound to a host-supplied candidate. Both resolve through the registry by name.\n */\nfunction bindingName(properties: Record<string, unknown>, property: string): string | undefined {\n    const direct = stringProperty(properties, property);\n    if (direct !== undefined) return direct;\n\n    const binding = properties[property];\n    if (binding !== null && typeof binding === 'object' && !Array.isArray(binding)) {\n        return stringProperty(binding as Record<string, unknown>, 'query');\n    }\n\n    return undefined;\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 = bindingName(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","bindingName","properties","property","direct","stringProperty","undefined","binding","Array","isArray","resolveElementBinding","element","kind","name","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;;;AAGC,IACD,SAASC,WAAAA,CAAYC,YAAmC,EAAEC,QAAgB,EAAA;IACtE,MAAMC,MAAAA,GAASC,0BAAeH,YAAAA,EAAYC,QAAAA,CAAAA;IAC1C,IAAIC,MAAAA,KAAWE,WAAW,OAAOF,MAAAA;IAEjC,MAAMG,OAAAA,GAAUL,YAAU,CAACC,QAAAA,CAAS;IACpC,IAAII,OAAAA,KAAY,QAAQ,OAAOA,OAAAA,KAAY,YAAY,CAACC,KAAAA,CAAMC,OAAO,CAACF,OAAAA,CAAAA,EAAU;AAC5E,QAAA,OAAOF,0BAAeE,OAAAA,EAAoC,OAAA,CAAA;AAC9D,IAAA;IAEA,OAAOD,SAAAA;AACX;AAEA;;;;;;;AAOC,IACM,SAASI,qBAAAA,CAAsBC,OAA0B,EAAEC,IAAiB,EAAA;AAC/E,IAAA,MAAMC,OAAOZ,WAAAA,CAAYU,OAAAA,CAAQT,UAAU,EAAEL,oBAAoB,CAACe,IAAAA,CAAK,CAAA;IACvE,IAAIC,IAAAA,KAASP,SAAAA,EAAW,OAAO,EAAC;IAEhC,OAAO;AAAEO,QAAAA,IAAAA;AAAMC,QAAAA,MAAAA,EAAQF,SAASd,uBAAAA,CAAYC,KAAK,GAAGgB,4BAAAA,CAAaF,QAAQG,8BAAAA,CAAeH,IAAAA;AAAM,KAAA;AAClG;;"}

package/dist/cjs/cratisComponentsDescriptors.js

@@ -0,0 +1,83 @@
+'use strict';
+
+var scene_model = require('@cratis/scene.model');
+var scene_react = require('@cratis/scene.react');
+
+// 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, spelled out so describing components does not pull every adapter (and its UI dependencies) in
+// with it; the bundle's validation checks each key against the manifest.
+const key = (name)=>scene_react.componentRegistryKey('Cratis.Components', name);
+/**
+ * The properties every query-bound data table shares: which query feeds it, and the few settings that shape how
+ * it shows the result.
+ *
+ * `query` is a `QueryReference`, so an editor binds it to a host-supplied query candidate and validates the
+ * arguments against it. What is stored is a `QueryBinding`; a plain query name - what screens carried before
+ * bindings existed - is still read, as a binding with no explicit connections. The columns are not properties:
+ * they are the `content` slot's children, edited as nodes.
+ */ const dataTableProperties = [
+    {
+        path: 'query',
+        label: 'Query',
+        group: 'Data',
+        valueType: scene_model.PropertyValueType.QueryReference,
+        editorKind: 'queryBinding',
+        description: 'The collection query that feeds the table.',
+        constraints: {
+            required: true,
+            resultShapes: [
+                scene_model.QueryResultShape.Collection
+            ]
+        }
+    },
+    {
+        path: 'emptyMessage',
+        label: 'Empty message',
+        group: 'Content',
+        valueType: scene_model.PropertyValueType.String,
+        default: ''
+    },
+    {
+        path: 'dataKey',
+        label: 'Row identity',
+        group: 'Data',
+        valueType: scene_model.PropertyValueType.String,
+        editorKind: 'resultField',
+        description: 'The result field that identifies a row.'
+    },
+    {
+        path: 'globalFilterFields',
+        label: 'Searchable fields',
+        group: 'Data',
+        valueType: scene_model.PropertyValueType.Object,
+        editorKind: 'resultFieldList',
+        description: 'The result fields the table\'s search box looks in.'
+    }
+];
+/**
+ * What can be edited on the `Cratis.Components` package's components.
+ *
+ * Only the query-bound tables are described so far; the form, dialog and editor composites carry
+ * Arc proxy classes by name and are configured through their own tooling. A package adds a descriptor here the
+ * same way it adds a component to the manifest.
+ */ const cratisComponentsDescriptors = [
+    {
+        component: key('dataTable'),
+        displayName: 'Data table',
+        properties: dataTableProperties
+    },
+    {
+        component: key('table'),
+        displayName: 'Table',
+        properties: dataTableProperties
+    },
+    {
+        component: key('observableDataTable'),
+        displayName: 'Live data table',
+        properties: dataTableProperties
+    }
+];
+
+exports.cratisComponentsDescriptors = cratisComponentsDescriptors;
+//# sourceMappingURL=cratisComponentsDescriptors.js.map

package/dist/cjs/cratisComponentsDescriptors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cratisComponentsDescriptors.js","sources":["../../cratisComponentsDescriptors.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 { ComponentDescriptor, PropertyDescriptor, PropertyValueType, QueryResultShape } from '@cratis/scene.model';\nimport { componentRegistryKey } from '@cratis/scene.react';\n\n// The package name, spelled out so describing components does not pull every adapter (and its UI dependencies) in\n// with it; the bundle's validation checks each key against the manifest.\nconst key = (name: string) => componentRegistryKey('Cratis.Components', name);\n\n/**\n * The properties every query-bound data table shares: which query feeds it, and the few settings that shape how\n * it shows the result.\n *\n * `query` is a `QueryReference`, so an editor binds it to a host-supplied query candidate and validates the\n * arguments against it. What is stored is a `QueryBinding`; a plain query name - what screens carried before\n * bindings existed - is still read, as a binding with no explicit connections. The columns are not properties:\n * they are the `content` slot's children, edited as nodes.\n */\nconst dataTableProperties: PropertyDescriptor[] = [\n    {\n        path: 'query', label: 'Query', group: 'Data', valueType: PropertyValueType.QueryReference, editorKind: 'queryBinding',\n        description: 'The collection query that feeds the table.',\n        constraints: { required: true, resultShapes: [QueryResultShape.Collection] },\n    },\n    { path: 'emptyMessage', label: 'Empty message', group: 'Content', valueType: PropertyValueType.String, default: '' },\n    {\n        path: 'dataKey', label: 'Row identity', group: 'Data', valueType: PropertyValueType.String, editorKind: 'resultField',\n        description: 'The result field that identifies a row.',\n    },\n    {\n        path: 'globalFilterFields', label: 'Searchable fields', group: 'Data', valueType: PropertyValueType.Object, editorKind: 'resultFieldList',\n        description: 'The result fields the table\\'s search box looks in.',\n    },\n];\n\n/**\n * What can be edited on the `Cratis.Components` package's components.\n *\n * Only the query-bound tables are described so far; the form, dialog and editor composites carry\n * Arc proxy classes by name and are configured through their own tooling. A package adds a descriptor here the\n * same way it adds a component to the manifest.\n */\nexport const cratisComponentsDescriptors: ComponentDescriptor[] = [\n    { component: key('dataTable'), displayName: 'Data table', properties: dataTableProperties },\n    { component: key('table'), displayName: 'Table', properties: dataTableProperties },\n    { component: key('observableDataTable'), displayName: 'Live data table', properties: dataTableProperties },\n];\n"],"names":["key","name","componentRegistryKey","dataTableProperties","path","label","group","valueType","PropertyValueType","QueryReference","editorKind","description","constraints","required","resultShapes","QueryResultShape","Collection","String","default","Object","cratisComponentsDescriptors","component","displayName","properties"],"mappings":";;;;;AAAA;AACA;AAKA;AACA;AACA,MAAMA,GAAAA,GAAM,CAACC,IAAAA,GAAiBC,gCAAAA,CAAqB,mBAAA,EAAqBD,IAAAA,CAAAA;AAExE;;;;;;;;AAQC,IACD,MAAME,mBAAAA,GAA4C;AAC9C,IAAA;QACIC,IAAAA,EAAM,OAAA;QAASC,KAAAA,EAAO,OAAA;QAASC,KAAAA,EAAO,MAAA;AAAQC,QAAAA,SAAAA,EAAWC,8BAAkBC,cAAc;QAAEC,UAAAA,EAAY,cAAA;QACvGC,WAAAA,EAAa,4CAAA;QACbC,WAAAA,EAAa;YAAEC,QAAAA,EAAU,IAAA;YAAMC,YAAAA,EAAc;AAACC,gBAAAA,4BAAAA,CAAiBC;AAAW;AAAC;AAC/E,KAAA;AACA,IAAA;QAAEZ,IAAAA,EAAM,cAAA;QAAgBC,KAAAA,EAAO,eAAA;QAAiBC,KAAAA,EAAO,SAAA;AAAWC,QAAAA,SAAAA,EAAWC,8BAAkBS,MAAM;QAAEC,OAAAA,EAAS;AAAG,KAAA;AACnH,IAAA;QACId,IAAAA,EAAM,SAAA;QAAWC,KAAAA,EAAO,cAAA;QAAgBC,KAAAA,EAAO,MAAA;AAAQC,QAAAA,SAAAA,EAAWC,8BAAkBS,MAAM;QAAEP,UAAAA,EAAY,aAAA;QACxGC,WAAAA,EAAa;AACjB,KAAA;AACA,IAAA;QACIP,IAAAA,EAAM,oBAAA;QAAsBC,KAAAA,EAAO,mBAAA;QAAqBC,KAAAA,EAAO,MAAA;AAAQC,QAAAA,SAAAA,EAAWC,8BAAkBW,MAAM;QAAET,UAAAA,EAAY,iBAAA;QACxHC,WAAAA,EAAa;AACjB;AACH,CAAA;AAED;;;;;;UAOaS,2BAAAA,GAAqD;AAC9D,IAAA;AAAEC,QAAAA,SAAAA,EAAWrB,GAAAA,CAAI,WAAA,CAAA;QAAcsB,WAAAA,EAAa,YAAA;QAAcC,UAAAA,EAAYpB;AAAoB,KAAA;AAC1F,IAAA;AAAEkB,QAAAA,SAAAA,EAAWrB,GAAAA,CAAI,OAAA,CAAA;QAAUsB,WAAAA,EAAa,OAAA;QAASC,UAAAA,EAAYpB;AAAoB,KAAA;AACjF,IAAA;AAAEkB,QAAAA,SAAAA,EAAWrB,GAAAA,CAAI,qBAAA,CAAA;QAAwBsB,WAAAA,EAAa,iBAAA;QAAmBC,UAAAA,EAAYpB;AAAoB;;;"}

package/dist/cjs/cratisComponentsPackage.js

@@ -2,6 +2,7 @@
 
 var scene_model = require('@cratis/scene.model');
 var cratisComponents = require('./cratisComponents.js');
+var cratisComponentsDescriptors = require('./cratisComponentsDescriptors.js');
 
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
@@ -105,7 +106,8 @@ var cratisComponents = require('./cratisComponents.js');
  * declares none of them; `validatePackageBundle` is what proves the two halves agree.
  */ const cratisComponentsPackage = {
     manifest: cratisComponentsPackageManifest,
-    components: cratisComponents.cratisComponents
+    components: cratisComponents.cratisComponents,
+    descriptors: cratisComponentsDescriptors.cratisComponentsDescriptors
 };
 
 exports.cratisComponentsPackage = cratisComponentsPackage;

package/dist/cjs/cratisComponentsPackage.js.map

@@ -1 +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 own\n * styling is a `--cratis-*` token layer (`@cratis/components/tokens`) plus the component stylesheets and\n * compiled Tailwind utilities in `@cratis/components/styles`. Activate it in a profile without PrimeReact\n * and nothing renders; activate it without Tailwind and everything renders unstyled. Both are stated as\n * dependencies so a package picker can say so while the profile is being configured, instead of leaving\n * it to be discovered when the page opens.\n *\n * The version ranges are the real ones the library carries. `>=11.0.0` for PrimeReact: version 3.0.0\n * declares `primereact@^11` as a peer dependency and is built against version 11's component set, so the\n * span across the major boundary that the previous `>=10.9.0` range described is over. The `--cratis-*`\n * tokens still resolve a version 10 theme variable as their last fallback, but that is an upgrade-window\n * courtesy for an application with a compiled version 10 stylesheet still on the page - not a version of\n * PrimeReact this package can be activated against. `^4.0.0` for Tailwind, because the utility sheet is\n * compiled against Tailwind 4.\n */\nexport const cratisComponentsPackageManifest: ScenePackage = {\n    name: cratisComponentsPackageName,\n    version: '3.0.0',\n    kind: PackageKind.ComponentLibrary,\n    dependencies: [\n        { name: 'PrimeReact', versionRange: '>=11.0.0' },\n        { name: 'Tailwind', versionRange: '^4.0.0' },\n    ],\n    components: [\n        'page',\n        'dataPage',\n        'formElement',\n        'singleResult',\n        'queryInputForm',\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 is in front of it - the `--p-*` properties a\n    // PrimeReact 11 preset emits at runtime, or a Scene theme through this package's token bridge.\n    // Shipping a theme here would be this library 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. dataTable and table accept optional object-valued queryArguments for collection queries. singleResult displays one read-only scalar own resultField of an optional model using an explicit query, object queryArguments and enabled: true. queryInputForm commits explicit string inputs on submit to the same optional-single runtime; drafts never execute a query.\",\n    module: '@cratis/scene.components',\n    license: 'MIT',\n    licenseUrl: 'https://github.com/Cratis/Scene/blob/main/LICENSE',\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","license","licenseUrl","cratisComponentsPackage","manifest","cratisComponents"],"mappings":";;;;;AAAA;AACA;AAMA;;;;;;;;;;;;;;;;;;UAmBaA,+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,cAAA;AACA,QAAA,gBAAA;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,6bAAA;IACbC,MAAAA,EAAQ,0BAAA;IACRC,OAAAA,EAAS,KAAA;IACTC,UAAAA,EAAY;AAChB;AAEA;;;;;;UAOaC,uBAAAA,GAA8C;IACvDC,QAAAA,EAAUpB,+BAAAA;IACVS,UAAAA,EAAYY;AAChB;;;"}
+{"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';\nimport { cratisComponentsDescriptors } from './cratisComponentsDescriptors';\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 own\n * styling is a `--cratis-*` token layer (`@cratis/components/tokens`) plus the component stylesheets and\n * compiled Tailwind utilities in `@cratis/components/styles`. Activate it in a profile without PrimeReact\n * and nothing renders; activate it without Tailwind and everything renders unstyled. Both are stated as\n * dependencies so a package picker can say so while the profile is being configured, instead of leaving\n * it to be discovered when the page opens.\n *\n * The version ranges are the real ones the library carries. `>=11.0.0` for PrimeReact: version 3.0.0\n * declares `primereact@^11` as a peer dependency and is built against version 11's component set, so the\n * span across the major boundary that the previous `>=10.9.0` range described is over. The `--cratis-*`\n * tokens still resolve a version 10 theme variable as their last fallback, but that is an upgrade-window\n * courtesy for an application with a compiled version 10 stylesheet still on the page - not a version of\n * PrimeReact this package can be activated against. `^4.0.0` for Tailwind, because the utility sheet is\n * compiled against Tailwind 4.\n */\nexport const cratisComponentsPackageManifest: ScenePackage = {\n    name: cratisComponentsPackageName,\n    version: '3.0.0',\n    kind: PackageKind.ComponentLibrary,\n    dependencies: [\n        { name: 'PrimeReact', versionRange: '>=11.0.0' },\n        { name: 'Tailwind', versionRange: '^4.0.0' },\n    ],\n    components: [\n        'page',\n        'dataPage',\n        'formElement',\n        'singleResult',\n        'queryInputForm',\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 is in front of it - the `--p-*` properties a\n    // PrimeReact 11 preset emits at runtime, or a Scene theme through this package's token bridge.\n    // Shipping a theme here would be this library 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. dataTable and table accept optional object-valued queryArguments for collection queries. singleResult displays one read-only scalar own resultField of an optional model using an explicit query, object queryArguments and enabled: true. queryInputForm commits explicit string inputs on submit to the same optional-single runtime; drafts never execute a query.\",\n    module: '@cratis/scene.components',\n    license: 'MIT',\n    licenseUrl: 'https://github.com/Cratis/Scene/blob/main/LICENSE',\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    descriptors: cratisComponentsDescriptors,\n};\n"],"names":["cratisComponentsPackageManifest","name","cratisComponentsPackageName","version","kind","PackageKind","ComponentLibrary","dependencies","versionRange","components","layouts","screenTemplates","dialogTemplates","themes","displayName","description","module","license","licenseUrl","cratisComponentsPackage","manifest","cratisComponents","descriptors","cratisComponentsDescriptors"],"mappings":";;;;;;AAAA;AACA;AAOA;;;;;;;;;;;;;;;;;;UAmBaA,+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,cAAA;AACA,QAAA,gBAAA;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,6bAAA;IACbC,MAAAA,EAAQ,0BAAA;IACRC,OAAAA,EAAS,KAAA;IACTC,UAAAA,EAAY;AAChB;AAEA;;;;;;UAOaC,uBAAAA,GAA8C;IACvDC,QAAAA,EAAUpB,+BAAAA;IACVS,UAAAA,EAAYY,iCAAAA;IACZC,WAAAA,EAAaC;AACjB;;;"}

package/dist/cjs/index.js

@@ -51,6 +51,7 @@ var SceneToolbarButton = require('./toolbar/SceneToolbarButton.js');
 var SceneToolbarGroup = require('./toolbar/SceneToolbarGroup.js');
 var SceneToolbarSeparator = require('./toolbar/SceneToolbarSeparator.js');
 var cratisComponents = require('./cratisComponents.js');
+var cratisComponentsDescriptors = require('./cratisComponentsDescriptors.js');
 var cratisComponentsPackage = require('./cratisComponentsPackage.js');
 
 
@@ -126,6 +127,7 @@ exports.SceneToolbarGroup = SceneToolbarGroup.SceneToolbarGroup;
 exports.SceneToolbarSeparator = SceneToolbarSeparator.SceneToolbarSeparator;
 exports.cratisComponents = cratisComponents.cratisComponents;
 exports.cratisComponentsPackageName = cratisComponents.cratisComponentsPackageName;
+exports.cratisComponentsDescriptors = cratisComponentsDescriptors.cratisComponentsDescriptors;
 exports.cratisComponentsPackage = cratisComponentsPackage.cratisComponentsPackage;
 exports.cratisComponentsPackageManifest = cratisComponentsPackage.cratisComponentsPackageManifest;
 //# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

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

package/dist/esm/bindings/resolveElementBinding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveElementBinding.d.ts","sourceRoot":"","sources":["../../../bindings/resolveElementBinding.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAqBlD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,WAAW,GAAG,cAAc,CAKnG"}
+{"version":3,"file":"resolveElementBinding.d.ts","sourceRoot":"","sources":["../../../bindings/resolveElementBinding.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAqClD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,WAAW,GAAG,cAAc,CAKnG"}

package/dist/esm/bindings/resolveElementBinding.js

@@ -12,6 +12,18 @@ import { resolveQuery, resolveCommand } from './bindingRegistry.js';
     [BindingKind.Query]: 'query',
     [BindingKind.Command]: 'command'
 };
+/**
+ * Reads a binding name from a property that holds either the name itself or a `QueryBinding`, which is what an
+ * editor stores when a query is bound to a host-supplied candidate. Both resolve through the registry by name.
+ */ function bindingName(properties, property) {
+    const direct = stringProperty(properties, property);
+    if (direct !== undefined) return direct;
+    const binding = properties[property];
+    if (binding !== null && typeof binding === 'object' && !Array.isArray(binding)) {
+        return stringProperty(binding, 'query');
+    }
+    return undefined;
+}
 /**
  * Reads the binding name an element carries for the given kind and looks it up in the binding registry.
  *
@@ -20,7 +32,7 @@ import { resolveQuery, resolveCommand } from './bindingRegistry.js';
  * 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 = stringProperty(element.properties, bindingPropertyNames[kind]);
+    const name = bindingName(element.properties, bindingPropertyNames[kind]);
     if (name === undefined) return {};
     return {
         name,

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

@@ -1 +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,WAAAA,CAAYC,KAAK,GAAG,OAAA;IACrB,CAACD,WAAAA,CAAYE,OAAO,GAAG;AAC3B,CAAA;AAEA;;;;;;;AAOC,IACM,SAASC,qBAAAA,CAAsBC,OAA0B,EAAEC,IAAiB,EAAA;AAC/E,IAAA,MAAMC,OAAOC,cAAAA,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,WAAAA,CAAYC,KAAK,GAAGU,YAAAA,CAAaL,QAAQM,cAAAA,CAAeN,IAAAA;AAAM,KAAA;AAClG;;"}
+{"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 a binding name from a property that holds either the name itself or a `QueryBinding`, which is what an\n * editor stores when a query is bound to a host-supplied candidate. Both resolve through the registry by name.\n */\nfunction bindingName(properties: Record<string, unknown>, property: string): string | undefined {\n    const direct = stringProperty(properties, property);\n    if (direct !== undefined) return direct;\n\n    const binding = properties[property];\n    if (binding !== null && typeof binding === 'object' && !Array.isArray(binding)) {\n        return stringProperty(binding as Record<string, unknown>, 'query');\n    }\n\n    return undefined;\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 = bindingName(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","bindingName","properties","property","direct","stringProperty","undefined","binding","Array","isArray","resolveElementBinding","element","kind","name","target","resolveQuery","resolveCommand"],"mappings":";;;;AAAA;AACA;AAQA;;;;AAIC,IACD,MAAMA,oBAAAA,GAAoD;IACtD,CAACC,WAAAA,CAAYC,KAAK,GAAG,OAAA;IACrB,CAACD,WAAAA,CAAYE,OAAO,GAAG;AAC3B,CAAA;AAEA;;;AAGC,IACD,SAASC,WAAAA,CAAYC,UAAmC,EAAEC,QAAgB,EAAA;IACtE,MAAMC,MAAAA,GAASC,eAAeH,UAAAA,EAAYC,QAAAA,CAAAA;IAC1C,IAAIC,MAAAA,KAAWE,WAAW,OAAOF,MAAAA;IAEjC,MAAMG,OAAAA,GAAUL,UAAU,CAACC,QAAAA,CAAS;IACpC,IAAII,OAAAA,KAAY,QAAQ,OAAOA,OAAAA,KAAY,YAAY,CAACC,KAAAA,CAAMC,OAAO,CAACF,OAAAA,CAAAA,EAAU;AAC5E,QAAA,OAAOF,eAAeE,OAAAA,EAAoC,OAAA,CAAA;AAC9D,IAAA;IAEA,OAAOD,SAAAA;AACX;AAEA;;;;;;;AAOC,IACM,SAASI,qBAAAA,CAAsBC,OAA0B,EAAEC,IAAiB,EAAA;AAC/E,IAAA,MAAMC,OAAOZ,WAAAA,CAAYU,OAAAA,CAAQT,UAAU,EAAEL,oBAAoB,CAACe,IAAAA,CAAK,CAAA;IACvE,IAAIC,IAAAA,KAASP,SAAAA,EAAW,OAAO,EAAC;IAEhC,OAAO;AAAEO,QAAAA,IAAAA;AAAMC,QAAAA,MAAAA,EAAQF,SAASd,WAAAA,CAAYC,KAAK,GAAGgB,YAAAA,CAAaF,QAAQG,cAAAA,CAAeH,IAAAA;AAAM,KAAA;AAClG;;"}

package/dist/esm/cratisComponentsDescriptors.d.ts

@@ -0,0 +1,3 @@
+import { ComponentDescriptor } from '@cratis/scene.model';
+export declare const cratisComponentsDescriptors: ComponentDescriptor[];
+//# sourceMappingURL=cratisComponentsDescriptors.d.ts.map

package/dist/esm/cratisComponentsDescriptors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cratisComponentsDescriptors.d.ts","sourceRoot":"","sources":["../../cratisComponentsDescriptors.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAA2D,MAAM,qBAAqB,CAAC;AAwCnH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,EAI5D,CAAC"}

package/dist/esm/cratisComponentsDescriptors.js

@@ -0,0 +1,81 @@
+import { QueryResultShape, PropertyValueType } from '@cratis/scene.model';
+import { componentRegistryKey } from '@cratis/scene.react';
+
+// 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, spelled out so describing components does not pull every adapter (and its UI dependencies) in
+// with it; the bundle's validation checks each key against the manifest.
+const key = (name)=>componentRegistryKey('Cratis.Components', name);
+/**
+ * The properties every query-bound data table shares: which query feeds it, and the few settings that shape how
+ * it shows the result.
+ *
+ * `query` is a `QueryReference`, so an editor binds it to a host-supplied query candidate and validates the
+ * arguments against it. What is stored is a `QueryBinding`; a plain query name - what screens carried before
+ * bindings existed - is still read, as a binding with no explicit connections. The columns are not properties:
+ * they are the `content` slot's children, edited as nodes.
+ */ const dataTableProperties = [
+    {
+        path: 'query',
+        label: 'Query',
+        group: 'Data',
+        valueType: PropertyValueType.QueryReference,
+        editorKind: 'queryBinding',
+        description: 'The collection query that feeds the table.',
+        constraints: {
+            required: true,
+            resultShapes: [
+                QueryResultShape.Collection
+            ]
+        }
+    },
+    {
+        path: 'emptyMessage',
+        label: 'Empty message',
+        group: 'Content',
+        valueType: PropertyValueType.String,
+        default: ''
+    },
+    {
+        path: 'dataKey',
+        label: 'Row identity',
+        group: 'Data',
+        valueType: PropertyValueType.String,
+        editorKind: 'resultField',
+        description: 'The result field that identifies a row.'
+    },
+    {
+        path: 'globalFilterFields',
+        label: 'Searchable fields',
+        group: 'Data',
+        valueType: PropertyValueType.Object,
+        editorKind: 'resultFieldList',
+        description: 'The result fields the table\'s search box looks in.'
+    }
+];
+/**
+ * What can be edited on the `Cratis.Components` package's components.
+ *
+ * Only the query-bound tables are described so far; the form, dialog and editor composites carry
+ * Arc proxy classes by name and are configured through their own tooling. A package adds a descriptor here the
+ * same way it adds a component to the manifest.
+ */ const cratisComponentsDescriptors = [
+    {
+        component: key('dataTable'),
+        displayName: 'Data table',
+        properties: dataTableProperties
+    },
+    {
+        component: key('table'),
+        displayName: 'Table',
+        properties: dataTableProperties
+    },
+    {
+        component: key('observableDataTable'),
+        displayName: 'Live data table',
+        properties: dataTableProperties
+    }
+];
+
+export { cratisComponentsDescriptors };
+//# sourceMappingURL=cratisComponentsDescriptors.js.map

package/dist/esm/cratisComponentsDescriptors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cratisComponentsDescriptors.js","sources":["../../cratisComponentsDescriptors.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 { ComponentDescriptor, PropertyDescriptor, PropertyValueType, QueryResultShape } from '@cratis/scene.model';\nimport { componentRegistryKey } from '@cratis/scene.react';\n\n// The package name, spelled out so describing components does not pull every adapter (and its UI dependencies) in\n// with it; the bundle's validation checks each key against the manifest.\nconst key = (name: string) => componentRegistryKey('Cratis.Components', name);\n\n/**\n * The properties every query-bound data table shares: which query feeds it, and the few settings that shape how\n * it shows the result.\n *\n * `query` is a `QueryReference`, so an editor binds it to a host-supplied query candidate and validates the\n * arguments against it. What is stored is a `QueryBinding`; a plain query name - what screens carried before\n * bindings existed - is still read, as a binding with no explicit connections. The columns are not properties:\n * they are the `content` slot's children, edited as nodes.\n */\nconst dataTableProperties: PropertyDescriptor[] = [\n    {\n        path: 'query', label: 'Query', group: 'Data', valueType: PropertyValueType.QueryReference, editorKind: 'queryBinding',\n        description: 'The collection query that feeds the table.',\n        constraints: { required: true, resultShapes: [QueryResultShape.Collection] },\n    },\n    { path: 'emptyMessage', label: 'Empty message', group: 'Content', valueType: PropertyValueType.String, default: '' },\n    {\n        path: 'dataKey', label: 'Row identity', group: 'Data', valueType: PropertyValueType.String, editorKind: 'resultField',\n        description: 'The result field that identifies a row.',\n    },\n    {\n        path: 'globalFilterFields', label: 'Searchable fields', group: 'Data', valueType: PropertyValueType.Object, editorKind: 'resultFieldList',\n        description: 'The result fields the table\\'s search box looks in.',\n    },\n];\n\n/**\n * What can be edited on the `Cratis.Components` package's components.\n *\n * Only the query-bound tables are described so far; the form, dialog and editor composites carry\n * Arc proxy classes by name and are configured through their own tooling. A package adds a descriptor here the\n * same way it adds a component to the manifest.\n */\nexport const cratisComponentsDescriptors: ComponentDescriptor[] = [\n    { component: key('dataTable'), displayName: 'Data table', properties: dataTableProperties },\n    { component: key('table'), displayName: 'Table', properties: dataTableProperties },\n    { component: key('observableDataTable'), displayName: 'Live data table', properties: dataTableProperties },\n];\n"],"names":["key","name","componentRegistryKey","dataTableProperties","path","label","group","valueType","PropertyValueType","QueryReference","editorKind","description","constraints","required","resultShapes","QueryResultShape","Collection","String","default","Object","cratisComponentsDescriptors","component","displayName","properties"],"mappings":";;;AAAA;AACA;AAKA;AACA;AACA,MAAMA,GAAAA,GAAM,CAACC,IAAAA,GAAiBC,oBAAAA,CAAqB,mBAAA,EAAqBD,IAAAA,CAAAA;AAExE;;;;;;;;AAQC,IACD,MAAME,mBAAAA,GAA4C;AAC9C,IAAA;QACIC,IAAAA,EAAM,OAAA;QAASC,KAAAA,EAAO,OAAA;QAASC,KAAAA,EAAO,MAAA;AAAQC,QAAAA,SAAAA,EAAWC,kBAAkBC,cAAc;QAAEC,UAAAA,EAAY,cAAA;QACvGC,WAAAA,EAAa,4CAAA;QACbC,WAAAA,EAAa;YAAEC,QAAAA,EAAU,IAAA;YAAMC,YAAAA,EAAc;AAACC,gBAAAA,gBAAAA,CAAiBC;AAAW;AAAC;AAC/E,KAAA;AACA,IAAA;QAAEZ,IAAAA,EAAM,cAAA;QAAgBC,KAAAA,EAAO,eAAA;QAAiBC,KAAAA,EAAO,SAAA;AAAWC,QAAAA,SAAAA,EAAWC,kBAAkBS,MAAM;QAAEC,OAAAA,EAAS;AAAG,KAAA;AACnH,IAAA;QACId,IAAAA,EAAM,SAAA;QAAWC,KAAAA,EAAO,cAAA;QAAgBC,KAAAA,EAAO,MAAA;AAAQC,QAAAA,SAAAA,EAAWC,kBAAkBS,MAAM;QAAEP,UAAAA,EAAY,aAAA;QACxGC,WAAAA,EAAa;AACjB,KAAA;AACA,IAAA;QACIP,IAAAA,EAAM,oBAAA;QAAsBC,KAAAA,EAAO,mBAAA;QAAqBC,KAAAA,EAAO,MAAA;AAAQC,QAAAA,SAAAA,EAAWC,kBAAkBW,MAAM;QAAET,UAAAA,EAAY,iBAAA;QACxHC,WAAAA,EAAa;AACjB;AACH,CAAA;AAED;;;;;;UAOaS,2BAAAA,GAAqD;AAC9D,IAAA;AAAEC,QAAAA,SAAAA,EAAWrB,GAAAA,CAAI,WAAA,CAAA;QAAcsB,WAAAA,EAAa,YAAA;QAAcC,UAAAA,EAAYpB;AAAoB,KAAA;AAC1F,IAAA;AAAEkB,QAAAA,SAAAA,EAAWrB,GAAAA,CAAI,OAAA,CAAA;QAAUsB,WAAAA,EAAa,OAAA;QAASC,UAAAA,EAAYpB;AAAoB,KAAA;AACjF,IAAA;AAAEkB,QAAAA,SAAAA,EAAWrB,GAAAA,CAAI,qBAAA,CAAA;QAAwBsB,WAAAA,EAAa,iBAAA;QAAmBC,UAAAA,EAAYpB;AAAoB;;;"}

package/dist/esm/cratisComponentsPackage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cratisComponentsPackage.d.ts","sourceRoot":"","sources":["../../cratisComponentsPackage.ts"],"names":[],"mappings":"AAGA,OAAO,EAAe,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAsBzD,eAAO,MAAM,+BAA+B,EAAE,YAsE7C,CAAC;AASF,eAAO,MAAM,uBAAuB,EAAE,kBAGrC,CAAC"}
+{"version":3,"file":"cratisComponentsPackage.d.ts","sourceRoot":"","sources":["../../cratisComponentsPackage.ts"],"names":[],"mappings":"AAGA,OAAO,EAAe,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAuBzD,eAAO,MAAM,+BAA+B,EAAE,YAsE7C,CAAC;AASF,eAAO,MAAM,uBAAuB,EAAE,kBAIrC,CAAC"}

package/dist/esm/cratisComponentsPackage.js

@@ -1,5 +1,6 @@
 import { PackageKind } from '@cratis/scene.model';
 import { cratisComponents, cratisComponentsPackageName } from './cratisComponents.js';
+import { cratisComponentsDescriptors } from './cratisComponentsDescriptors.js';
 
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
@@ -103,7 +104,8 @@ import { cratisComponents, cratisComponentsPackageName } from './cratisComponent
  * declares none of them; `validatePackageBundle` is what proves the two halves agree.
  */ const cratisComponentsPackage = {
     manifest: cratisComponentsPackageManifest,
-    components: cratisComponents
+    components: cratisComponents,
+    descriptors: cratisComponentsDescriptors
 };
 
 export { cratisComponentsPackage, cratisComponentsPackageManifest };

package/dist/esm/cratisComponentsPackage.js.map

@@ -1 +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 own\n * styling is a `--cratis-*` token layer (`@cratis/components/tokens`) plus the component stylesheets and\n * compiled Tailwind utilities in `@cratis/components/styles`. Activate it in a profile without PrimeReact\n * and nothing renders; activate it without Tailwind and everything renders unstyled. Both are stated as\n * dependencies so a package picker can say so while the profile is being configured, instead of leaving\n * it to be discovered when the page opens.\n *\n * The version ranges are the real ones the library carries. `>=11.0.0` for PrimeReact: version 3.0.0\n * declares `primereact@^11` as a peer dependency and is built against version 11's component set, so the\n * span across the major boundary that the previous `>=10.9.0` range described is over. The `--cratis-*`\n * tokens still resolve a version 10 theme variable as their last fallback, but that is an upgrade-window\n * courtesy for an application with a compiled version 10 stylesheet still on the page - not a version of\n * PrimeReact this package can be activated against. `^4.0.0` for Tailwind, because the utility sheet is\n * compiled against Tailwind 4.\n */\nexport const cratisComponentsPackageManifest: ScenePackage = {\n    name: cratisComponentsPackageName,\n    version: '3.0.0',\n    kind: PackageKind.ComponentLibrary,\n    dependencies: [\n        { name: 'PrimeReact', versionRange: '>=11.0.0' },\n        { name: 'Tailwind', versionRange: '^4.0.0' },\n    ],\n    components: [\n        'page',\n        'dataPage',\n        'formElement',\n        'singleResult',\n        'queryInputForm',\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 is in front of it - the `--p-*` properties a\n    // PrimeReact 11 preset emits at runtime, or a Scene theme through this package's token bridge.\n    // Shipping a theme here would be this library 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. dataTable and table accept optional object-valued queryArguments for collection queries. singleResult displays one read-only scalar own resultField of an optional model using an explicit query, object queryArguments and enabled: true. queryInputForm commits explicit string inputs on submit to the same optional-single runtime; drafts never execute a query.\",\n    module: '@cratis/scene.components',\n    license: 'MIT',\n    licenseUrl: 'https://github.com/Cratis/Scene/blob/main/LICENSE',\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","license","licenseUrl","cratisComponentsPackage","manifest","cratisComponents"],"mappings":";;;AAAA;AACA;AAMA;;;;;;;;;;;;;;;;;;UAmBaA,+BAAAA,GAAgD;IACzDC,IAAAA,EAAMC,2BAAAA;IACNC,OAAAA,EAAS,OAAA;AACTC,IAAAA,IAAAA,EAAMC,YAAYC,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,cAAA;AACA,QAAA,gBAAA;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,6bAAA;IACbC,MAAAA,EAAQ,0BAAA;IACRC,OAAAA,EAAS,KAAA;IACTC,UAAAA,EAAY;AAChB;AAEA;;;;;;UAOaC,uBAAAA,GAA8C;IACvDC,QAAAA,EAAUpB,+BAAAA;IACVS,UAAAA,EAAYY;AAChB;;"}
+{"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';\nimport { cratisComponentsDescriptors } from './cratisComponentsDescriptors';\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 own\n * styling is a `--cratis-*` token layer (`@cratis/components/tokens`) plus the component stylesheets and\n * compiled Tailwind utilities in `@cratis/components/styles`. Activate it in a profile without PrimeReact\n * and nothing renders; activate it without Tailwind and everything renders unstyled. Both are stated as\n * dependencies so a package picker can say so while the profile is being configured, instead of leaving\n * it to be discovered when the page opens.\n *\n * The version ranges are the real ones the library carries. `>=11.0.0` for PrimeReact: version 3.0.0\n * declares `primereact@^11` as a peer dependency and is built against version 11's component set, so the\n * span across the major boundary that the previous `>=10.9.0` range described is over. The `--cratis-*`\n * tokens still resolve a version 10 theme variable as their last fallback, but that is an upgrade-window\n * courtesy for an application with a compiled version 10 stylesheet still on the page - not a version of\n * PrimeReact this package can be activated against. `^4.0.0` for Tailwind, because the utility sheet is\n * compiled against Tailwind 4.\n */\nexport const cratisComponentsPackageManifest: ScenePackage = {\n    name: cratisComponentsPackageName,\n    version: '3.0.0',\n    kind: PackageKind.ComponentLibrary,\n    dependencies: [\n        { name: 'PrimeReact', versionRange: '>=11.0.0' },\n        { name: 'Tailwind', versionRange: '^4.0.0' },\n    ],\n    components: [\n        'page',\n        'dataPage',\n        'formElement',\n        'singleResult',\n        'queryInputForm',\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 is in front of it - the `--p-*` properties a\n    // PrimeReact 11 preset emits at runtime, or a Scene theme through this package's token bridge.\n    // Shipping a theme here would be this library 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. dataTable and table accept optional object-valued queryArguments for collection queries. singleResult displays one read-only scalar own resultField of an optional model using an explicit query, object queryArguments and enabled: true. queryInputForm commits explicit string inputs on submit to the same optional-single runtime; drafts never execute a query.\",\n    module: '@cratis/scene.components',\n    license: 'MIT',\n    licenseUrl: 'https://github.com/Cratis/Scene/blob/main/LICENSE',\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    descriptors: cratisComponentsDescriptors,\n};\n"],"names":["cratisComponentsPackageManifest","name","cratisComponentsPackageName","version","kind","PackageKind","ComponentLibrary","dependencies","versionRange","components","layouts","screenTemplates","dialogTemplates","themes","displayName","description","module","license","licenseUrl","cratisComponentsPackage","manifest","cratisComponents","descriptors","cratisComponentsDescriptors"],"mappings":";;;;AAAA;AACA;AAOA;;;;;;;;;;;;;;;;;;UAmBaA,+BAAAA,GAAgD;IACzDC,IAAAA,EAAMC,2BAAAA;IACNC,OAAAA,EAAS,OAAA;AACTC,IAAAA,IAAAA,EAAMC,YAAYC,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,cAAA;AACA,QAAA,gBAAA;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,6bAAA;IACbC,MAAAA,EAAQ,0BAAA;IACRC,OAAAA,EAAS,KAAA;IACTC,UAAAA,EAAY;AAChB;AAEA;;;;;;UAOaC,uBAAAA,GAA8C;IACvDC,QAAAA,EAAUpB,+BAAAA;IACVS,UAAAA,EAAYY,gBAAAA;IACZC,WAAAA,EAAaC;AACjB;;"}

package/dist/esm/index.d.ts

@@ -8,5 +8,6 @@ export * from './common';
 export * from './editors';
 export * from './toolbar';
 export * from './cratisComponents';
+export * from './cratisComponentsDescriptors';
 export * from './cratisComponentsPackage';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAGA,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAGA,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC"}

package/dist/esm/index.js

@@ -49,5 +49,6 @@ export { SceneToolbarButton } from './toolbar/SceneToolbarButton.js';
 export { SceneToolbarGroup } from './toolbar/SceneToolbarGroup.js';
 export { SceneToolbarSeparator } from './toolbar/SceneToolbarSeparator.js';
 export { cratisComponents, cratisComponentsPackageName } from './cratisComponents.js';
+export { cratisComponentsDescriptors } from './cratisComponentsDescriptors.js';
 export { cratisComponentsPackage, cratisComponentsPackageManifest } from './cratisComponentsPackage.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

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