@cratis/scene.components 1.0.0 → 2.0.0

package/.storybook/main.ts

@@ -39,12 +39,6 @@ const config: StorybookConfig = {
             ...(config.build.rollupOptions ?? {}),
             external: [/^@cratis\/arc/, '@cratis/fundamentals'],
         };
-        // Vite 8 minifies CSS with lightningcss, which rejects the whole bundle over one invalid file:
-        // `@cratis/components@2.9.0` ships `dist/esm/TimeMachine/Properties.css` with `//` line comments,
-        // which are not CSS. esbuild's minifier tolerates them. This is an upstream defect and the
-        // workaround belongs here, in preview tooling, rather than anywhere it could hide the problem -
-        // remove this line once the Components package ships that file with `/* */` comments.
-        config.build.cssMinify = 'esbuild';
         return config;
     },
 };

package/.storybook/preview.tsx

@@ -4,26 +4,51 @@
 import type { Preview } from '@storybook/react';
 import { CratisComponentsProvider } from '@cratis/components/Common';
 
-// The three layers a `@cratis/components` component needs to look like itself, in the order they
-// resolve. PrimeReact 10 ships every widget's *structural* CSS inside the theme file - there is no
-// separate primitives stylesheet - so without a theme the wrapped widgets render as bare HTML. The
-// library's own sheet adds its Tailwind utilities and the `--cratis-*` token layer on top, and this
-// package's bridge puts Scene's `--scene-*` tokens in front of that wherever a Scene theme is applied.
-import 'primereact/resources/themes/lara-light-blue/theme.css';
-import 'primeicons/primeicons.css';
+// The stylesheet stack a `@cratis/components` component needs, in the order the layers resolve.
+//
+// PrimeReact 11 ships no CSS whatsoever - `primereact/resources/` does not exist, so the compiled theme
+// this file used to import has nothing left to resolve to. A look is no longer a stylesheet at all: it is
+// either a `@primeuix/themes` preset handed to the provider, which `@primeuix/styled` turns into `--p-*`
+// custom properties at runtime, or a sheet that assigns the library's own `--cratis-*` tokens directly.
+// This preview takes the second path - see the decorator below for why.
+//
+// `tokens` declares the `--cratis-*` layer every component stylesheet reads, `styles` is that component
+// CSS plus the compiled Tailwind utilities and the vendored Allotment sheet `DataPage`'s split view needs,
+// `theme` fills the tokens in, and this package's bridge puts Scene's `--scene-*` tokens in front of all
+// of it wherever a Scene theme is applied. Each layer consumes the one before it, so the order is not
+// cosmetic.
+import '@cratis/components/tokens';
 import '@cratis/components/styles';
+import '@cratis/components/theme';
+import 'primeicons/primeicons.css';
 import '../theme/sceneTokenBridge.css';
 
+// The baseline theme is scoped to a `cratis-theme` ancestor rather than to `:root`, so something has to
+// carry the class. `<body>` rather than a wrapper inside each story, because PrimeReact 11 portals its
+// overlays - dialogs, select panels, the filter panel - straight to `document.body`; a wrapper would
+// leave every one of them outside the themed subtree and rendering unstyled.
+document.body.classList.add('cratis-theme');
+
 /**
  * Every story renders inside `CratisComponentsProvider`, the library's own configuration provider over
  * PrimeReact's. Without it the wrapped components fall back to PrimeReact's defaults rather than
  * Cratis', so a story would be showing something subtly different from what an application renders -
  * which defeats the point of having stories at all.
+ *
+ * `unstyled` is the posture the imported `@cratis/components/theme` is written for: it is Cratis-authored
+ * MIT CSS that assigns the `--cratis-*` tokens outright, so it needs neither a `@primeuix/themes` preset
+ * nor the PrimeUI license key a styled preset is gated behind. Choosing it over a preset also keeps this
+ * package's dependency surface honest - `@primeuix/themes` is not one of its dependencies, and a preview
+ * is the wrong place to start relying on a package nobody declared.
+ *
+ * It is the right choice for these stories on its own terms too. The `--cratis-*` token layer is exactly
+ * what `theme/sceneTokenBridge.css` overrides, so a Scene theme visibly takes over from the baseline in
+ * the `Themed` story rather than from a preset's `--p-*` values one level further down the chain.
  */
 const preview: Preview = {
     decorators: [
         Story => (
-            <CratisComponentsProvider>
+            <CratisComponentsProvider value={{ unstyled: true }}>
                 <Story />
             </CratisComponentsProvider>
         ),

package/README.md

@@ -130,8 +130,13 @@ both packages write themes in one language: `primary.color`, `primary.contrastCo
   for a faceted browser that has nothing to show at design time. An application that wants it imports it
   directly.
 - **`card`** — see above.
-- **`column`** — PrimeReact's `Column` is a configuration element and belongs to the PrimeReact package;
-  a duplicate here would be a shadow with nothing behind it. Columns come through the `content` slot.
+- **`column`** — a column is a configuration element, not a rendered component: it declares `field`,
+  `header`, `sortable` and `filter`, and the table reads those off its children. Columns therefore come
+  through the `content` slot, and declaring a name here would add a registry entry for something no
+  screen resolves on its own. Note that the *ownership* of `Column` moved in PrimeReact 11 — `primereact/column`
+  was removed and `@cratis/components` now ships its own (`@cratis/components/DataTables`, re-exported from
+  `DataPage`) — so if a `column` name is ever wanted, this is the package that would have the component
+  behind it. The decision not to declare one is unchanged; only the reason for it is different.
 - **Event handlers** — Scene has no action-binding seam yet. Where a callback drives a component's own
   visible state the adapter holds it (`useEditableCopy`), so the breadcrumb, schema editor and time machine
   behave like themselves; where it would reach outside, the adapter exposes nothing rather than a handler
@@ -181,12 +186,17 @@ yarn lint:ci
 yarn build-storybook
 ```
 
-Two notes on the Storybook and Vitest configuration, both worked around in this folder and both upstream
-issues rather than ours:
-
-- `@cratis/components@2.9.0` ships `dist/esm/TimeMachine/Properties.css` with `//` line comments, which are
-  not valid CSS. Vite 8's default lightningcss minifier rejects the whole bundle over it, so
-  `.storybook/main.ts` sets `cssMinify: 'esbuild'`.
-- `@cratis/components` and PrimeReact are published as ESM that still uses directory imports
-  (`primereact/api`), which Node's own resolver rejects. `vite.config.mts` inlines both so Vite resolves them
-  instead.
+Two workarounds used to live in this folder for upstream problems that `@cratis/components` 3.0.0 and
+PrimeReact 11 removed the cause of. Both are gone, and neither should come back without new evidence:
+
+- `.storybook/main.ts` no longer forces `cssMinify: 'esbuild'`. It was there because
+  `@cratis/components@2.9.0` shipped `dist/esm/TimeMachine/Properties.css` with `//` line comments, which
+  are not CSS, and Vite's default lightningcss minifier rejects a whole bundle over one invalid file.
+  3.0.0 takes CSS out of the JavaScript module graph entirely: there are no per-component stylesheets any
+  more, only `styles.css`, `tokens.css` and `theme.css` at the package root, and all three minify cleanly
+  under lightningcss.
+- `vite.config.mts` no longer inlines `@cratis/components` and `primereact` for Vitest. That existed
+  because both were published as ESM using directory imports (`primereact/api`), which Node's own resolver
+  rejects. `primereact/api` does not exist in version 11 at all; PrimeReact's `exports` map now resolves
+  `./*` to a concrete `./*/index.mjs`, and every `@cratis/components` subpath points at a real file, so
+  Node loads them natively and Vitest can externalize them as it does every other dependency.

package/common/SceneDropdown.tsx

@@ -8,9 +8,16 @@ import { booleanProperty, objectArrayProperty, stringProperty } from '../propert
 /**
  * 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.
+ * The library's own `Dropdown` rather than PrimeReact's `Select`, and the reason changed with PrimeReact
+ * 11. It used to be the overlay z-index fix: a version 10 dropdown panel opened inside a dialog rendered
+ * within the dialog's own subtree and could land under its mask, so the library appended every overlay to
+ * the document body and handed out z-indexes itself. Version 11 does both natively - the select panel
+ * portals to the body and the shared z-index registry puts a later overlay above whatever is already
+ * open - and `@cratis/components` 3.0.0 accordingly deleted that workaround. What the wrapper is worth
+ * now is its curated surface: a single/multi select expressed in `options` / `optionLabel` /
+ * `optionValue` terms, where version 11's `Select` is compositional (`Select.Root`, `.Trigger`,
+ * `.Portal`, `.Popup`, `.List`, `.Option`) and would have to be assembled here, in an adapter whose whole
+ * input is a property bag.
  *
  * 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`.

package/cratisComponentsPackage.ts

@@ -9,23 +9,27 @@ import { cratisComponents, cratisComponentsPackageName } from './cratisComponent
  * 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.
+ * not a self-contained library: every component in it is a wrapper over a PrimeReact widget, and its own
+ * styling is a `--cratis-*` token layer (`@cratis/components/tokens`) plus the component stylesheets and
+ * compiled Tailwind utilities in `@cratis/components/styles`. 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.
+ * The version ranges are the real ones the library carries. `>=11.0.0` for PrimeReact: version 3.0.0
+ * declares `primereact@^11` as a peer dependency and is built against version 11's component set, so the
+ * span across the major boundary that the previous `>=10.9.0` range described is over. The `--cratis-*`
+ * tokens still resolve a version 10 theme variable as their last fallback, but that is an upgrade-window
+ * courtesy for an application with a compiled version 10 stylesheet still on the page - not a version of
+ * PrimeReact this package can be activated against. `^4.0.0` for Tailwind, because the utility sheet is
+ * compiled against Tailwind 4.
  */
 export const cratisComponentsPackageManifest: ScenePackage = {
     name: cratisComponentsPackageName,
-    version: '2.8.1',
+    version: '3.0.0',
     kind: PackageKind.ComponentLibrary,
     dependencies: [
-        { name: 'PrimeReact', versionRange: '>=10.9.0' },
+        { name: 'PrimeReact', versionRange: '>=11.0.0' },
         { name: 'Tailwind', versionRange: '^4.0.0' },
     ],
     components: [
@@ -78,9 +82,9 @@ export const cratisComponentsPackageManifest: ScenePackage = {
     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.
+    // a `--cratis-*` variable layer that resolves whatever is in front of it - the `--p-*` properties a
+    // PrimeReact 11 preset emits at runtime, or a Scene theme through this package's token bridge.
+    // Shipping a theme here would be this library asserting a look it was specifically built not to have.
     themes: [],
 
     displayName: 'Cratis Components',

package/data/SceneDataTable.tsx

@@ -4,7 +4,7 @@
 import { lazy } from 'react';
 import { RegisteredComponentProps } from '@cratis/scene.react';
 import { ArcRuntimeBoundary, BindingKind, MissingBinding, resolveElementBinding } from '../bindings';
-import { booleanProperty, stringArrayProperty, stringProperty } from '../properties';
+import { stringArrayProperty, stringProperty } from '../properties';
 
 const DataTableForQuery = lazy(async () => ({ default: (await import('@cratis/components/DataTables')).DataTableForQuery }));
 
@@ -19,6 +19,12 @@ const DataTableForQuery = lazy(async () => ({ default: (await import('@cratis/co
  * 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.
+ *
+ * There is deliberately no `clientFiltering` property. `@cratis/components` 3.0.0 still accepts the prop
+ * so existing call sites compile, but it no longer does anything - filtering is always applied to the
+ * loaded page. Exposing a screen property that reads as a choice and silently is not would be worse than
+ * not offering it, so a screen that set it now gets a property-not-recognized signal rather than a
+ * setting that quietly stopped mattering.
  */
 export function SceneDataTable({ element, slots }: RegisteredComponentProps) {
     const { name, target } = resolveElementBinding(element, BindingKind.Query);
@@ -31,7 +37,6 @@ export function SceneDataTable({ element, slots }: RegisteredComponentProps) {
                 emptyMessage={stringProperty(element.properties, 'emptyMessage') ?? ''}
                 dataKey={stringProperty(element.properties, 'dataKey')}
                 globalFilterFields={stringArrayProperty(element.properties, 'globalFilterFields')}
-                clientFiltering={booleanProperty(element.properties, 'clientFiltering')}
                 className={stringProperty(element.properties, 'className')}
             >
                 {slots.content}

package/data/SceneObservableDataTable.tsx

@@ -4,7 +4,7 @@
 import { lazy } from 'react';
 import { RegisteredComponentProps } from '@cratis/scene.react';
 import { ArcRuntimeBoundary, BindingKind, MissingBinding, resolveElementBinding } from '../bindings';
-import { booleanProperty, stringArrayProperty, stringProperty } from '../properties';
+import { stringArrayProperty, stringProperty } from '../properties';
 
 const DataTableForObservableQuery = lazy(async () => ({
     default: (await import('@cratis/components/DataTables')).DataTableForObservableQuery,
@@ -19,6 +19,10 @@ const DataTableForObservableQuery = lazy(async () => ({
  * re-renders when the server's read model changes, and a plain query does not. A screen that names an
  * observable query here is stating that its data is live, which is a design decision worth being able to
  * read off the screen.
+ *
+ * As with `dataTable`, no `clientFiltering` property is exposed: `@cratis/components` 3.0.0 keeps the
+ * prop for source compatibility but ignores it, and a screen property that cannot change anything is
+ * worse than an absent one.
  */
 export function SceneObservableDataTable({ element, slots }: RegisteredComponentProps) {
     const { name, target } = resolveElementBinding(element, BindingKind.Query);
@@ -31,7 +35,6 @@ export function SceneObservableDataTable({ element, slots }: RegisteredComponent
                 emptyMessage={stringProperty(element.properties, 'emptyMessage') ?? ''}
                 dataKey={stringProperty(element.properties, 'dataKey')}
                 globalFilterFields={stringArrayProperty(element.properties, 'globalFilterFields')}
-                clientFiltering={booleanProperty(element.properties, 'clientFiltering')}
                 className={stringProperty(element.properties, 'className')}
             >
                 {slots.content}

package/dialogs/SceneCommandDialog.tsx

@@ -18,6 +18,15 @@ const CommandDialog = lazy(async () => ({ default: (await import('@cratis/compon
  * reimplementing the protocol.
  *
  * The `command` property names an Arc command proxy; the fields go in the `content` slot.
+ *
+ * `dismissable` and `closeAriaLabel` are here rather than on `dialog` alone because `CommandDialog`
+ * forwards both to the dialog it wraps, and in `@cratis/components` 3.0.0 that forwarding actually
+ * happens - 2.x accepted the two props and dropped them on the floor. `dismissable` matters more on a
+ * command dialog than anywhere else: it decides whether a half-filled form can be abandoned with
+ * `Escape` or a backdrop click, which is a decision about the command, not about the chrome.
+ *
+ * The `resizable` property this adapter used to carry is gone. It is still declared upstream so call
+ * sites compile, but PrimeReact 11's headless dialog has no resize handle and nothing reads the prop.
  */
 export function SceneCommandDialog({ element, slots }: RegisteredComponentProps) {
     const { name, target } = resolveElementBinding(element, BindingKind.Command);
@@ -30,9 +39,10 @@ export function SceneCommandDialog({ element, slots }: RegisteredComponentProps)
                 command={target}
                 visible={booleanProperty(element.properties, 'visible') ?? true}
                 width={stringProperty(element.properties, 'width')}
-                resizable={booleanProperty(element.properties, 'resizable')}
+                dismissable={booleanProperty(element.properties, 'dismissable')}
                 okLabel={stringProperty(element.properties, 'okLabel')}
                 cancelLabel={stringProperty(element.properties, 'cancelLabel')}
+                closeAriaLabel={stringProperty(element.properties, 'closeAriaLabel')}
                 className={stringProperty(element.properties, 'className')}
             >
                 {slots.content}

package/dialogs/SceneDialog.tsx

@@ -19,6 +19,17 @@ const Dialog = lazy(async () => ({ default: (await import('@cratis/components/Di
  *
  * `visible` defaults to `true` because a dialog placed on a screen is being placed to be seen; a host
  * that controls visibility sets the property explicitly.
+ *
+ * `dismissable` replaces the `resizable` property this adapter used to carry, and the swap is the whole
+ * PrimeReact 11 story in miniature. `resizable` is still declared on `DialogProps` so call sites compile,
+ * but version 11's headless dialog has no resize handle and the library never reads the prop - a screen
+ * setting it got nothing. `dismissable` is the opposite: 3.0.0 added it and honors it, and it decides
+ * whether the header close button, backdrop click and `Escape` are offered at all. Leaving it unset keeps
+ * the library's own default, so a screen opts into a dismiss affordance rather than having one imposed.
+ *
+ * `closeAriaLabel` names that close button. It is separate from every other label here because it is the
+ * only one a screen reader reads and nobody sees, which is exactly why it gets forgotten - offering it
+ * next to `okLabel` and `cancelLabel` is what makes localizing a dialog a complete job.
  */
 export function SceneDialog({ element, slots }: RegisteredComponentProps) {
     return (
@@ -27,11 +38,12 @@ export function SceneDialog({ element, slots }: RegisteredComponentProps) {
                 title={stringProperty(element.properties, 'title') ?? ''}
                 visible={booleanProperty(element.properties, 'visible') ?? true}
                 width={stringProperty(element.properties, 'width')}
-                resizable={booleanProperty(element.properties, 'resizable')}
+                dismissable={booleanProperty(element.properties, 'dismissable')}
                 isValid={booleanProperty(element.properties, 'isValid')}
                 isBusy={booleanProperty(element.properties, 'isBusy')}
                 okLabel={stringProperty(element.properties, 'okLabel')}
                 cancelLabel={stringProperty(element.properties, 'cancelLabel')}
+                closeAriaLabel={stringProperty(element.properties, 'closeAriaLabel')}
                 className={stringProperty(element.properties, 'className')}
             >
                 {slots.content}

package/dist/cjs/common/SceneDropdown.js

@@ -7,9 +7,16 @@ 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.
+ * The library's own `Dropdown` rather than PrimeReact's `Select`, and the reason changed with PrimeReact
+ * 11. It used to be the overlay z-index fix: a version 10 dropdown panel opened inside a dialog rendered
+ * within the dialog's own subtree and could land under its mask, so the library appended every overlay to
+ * the document body and handed out z-indexes itself. Version 11 does both natively - the select panel
+ * portals to the body and the shared z-index registry puts a later overlay above whatever is already
+ * open - and `@cratis/components` 3.0.0 accordingly deleted that workaround. What the wrapper is worth
+ * now is its curated surface: a single/multi select expressed in `options` / `optionLabel` /
+ * `optionValue` terms, where version 11's `Select` is compositional (`Select.Root`, `.Trigger`,
+ * `.Portal`, `.Popup`, `.List`, `.Option`) and would have to be assembled here, in an adapter whose whole
+ * input is a property bag.
  *
  * 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`.

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

@@ -1 +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;;;;"}
+{"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 `Select`, and the reason changed with PrimeReact\n * 11. It used to be the overlay z-index fix: a version 10 dropdown panel opened inside a dialog rendered\n * within the dialog's own subtree and could land under its mask, so the library appended every overlay to\n * the document body and handed out z-indexes itself. Version 11 does both natively - the select panel\n * portals to the body and the shared z-index registry puts a later overlay above whatever is already\n * open - and `@cratis/components` 3.0.0 accordingly deleted that workaround. What the wrapper is worth\n * now is its curated surface: a single/multi select expressed in `options` / `optionLabel` /\n * `optionValue` terms, where version 11's `Select` is compositional (`Select.Root`, `.Trigger`,\n * `.Portal`, `.Popup`, `.List`, `.Option`) and would have to be assembled here, in an adapter whose whole\n * input is a property bag.\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;;;;;;;;;;;;;;;;AAgBC,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/cratisComponentsPackage.js

@@ -9,24 +9,28 @@ var cratisComponents = require('./cratisComponents.js');
  * 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.
+ * not a self-contained library: every component in it is a wrapper over a PrimeReact widget, and its own
+ * styling is a `--cratis-*` token layer (`@cratis/components/tokens`) plus the component stylesheets and
+ * compiled Tailwind utilities in `@cratis/components/styles`. 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.
+ * The version ranges are the real ones the library carries. `>=11.0.0` for PrimeReact: version 3.0.0
+ * declares `primereact@^11` as a peer dependency and is built against version 11's component set, so the
+ * span across the major boundary that the previous `>=10.9.0` range described is over. The `--cratis-*`
+ * tokens still resolve a version 10 theme variable as their last fallback, but that is an upgrade-window
+ * courtesy for an application with a compiled version 10 stylesheet still on the page - not a version of
+ * PrimeReact this package can be activated against. `^4.0.0` for Tailwind, because the utility sheet is
+ * compiled against Tailwind 4.
  */ const cratisComponentsPackageManifest = {
     name: cratisComponents.cratisComponentsPackageName,
-    version: '2.8.1',
+    version: '3.0.0',
     kind: scene_model.PackageKind.ComponentLibrary,
     dependencies: [
         {
             name: 'PrimeReact',
-            versionRange: '>=10.9.0'
+            versionRange: '>=11.0.0'
         },
         {
             name: 'Tailwind',
@@ -81,9 +85,9 @@ var cratisComponents = require('./cratisComponents.js');
     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.
+    // a `--cratis-*` variable layer that resolves whatever is in front of it - the `--p-*` properties a
+    // PrimeReact 11 preset emits at runtime, or a Scene theme through this package's token bridge.
+    // 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.",

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\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;;;;;"}
+{"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        '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.\",\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;;;;;;;;;;;;;;;;;;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,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

@@ -22,6 +22,12 @@ const DataTableForQuery = /*#__PURE__*/ react.lazy(async ()=>({
  * 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.
+ *
+ * There is deliberately no `clientFiltering` property. `@cratis/components` 3.0.0 still accepts the prop
+ * so existing call sites compile, but it no longer does anything - filtering is always applied to the
+ * loaded page. Exposing a screen property that reads as a choice and silently is not would be worse than
+ * not offering it, so a screen that set it now gets a property-not-recognized signal rather than a
+ * setting that quietly stopped mattering.
  */ function SceneDataTable({ element, slots }) {
     const { name, target } = resolveElementBinding.resolveElementBinding(element, BindingKind.BindingKind.Query);
     if (!target) return /*#__PURE__*/ jsxRuntime.jsx(MissingBinding.MissingBinding, {
@@ -35,7 +41,6 @@ const DataTableForQuery = /*#__PURE__*/ react.lazy(async ()=>({
             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
         })

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

@@ -1 +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;;;;"}
+{"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 { 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 *\n * There is deliberately no `clientFiltering` property. `@cratis/components` 3.0.0 still accepts the prop\n * so existing call sites compile, but it no longer does anything - filtering is always applied to the\n * loaded page. Exposing a screen property that reads as a choice and silently is not would be worse than\n * not offering it, so a screen that set it now gets a property-not-recognized signal rather than a\n * setting that quietly stopped mattering.\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                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","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;;;;;;;;;;;;;;;;;AAiBC,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,SAAAA,EAAWL,yBAAAA,CAAeb,OAAAA,CAAQc,UAAU,EAAE,WAAA,CAAA;AAE7Cb,YAAAA,QAAAA,EAAAA,KAAAA,CAAMkB;;;AAIvB;;;;"}

package/dist/cjs/data/SceneObservableDataTable.js

@@ -20,6 +20,10 @@ const DataTableForObservableQuery = /*#__PURE__*/ react.lazy(async ()=>({
  * re-renders when the server's read model changes, and a plain query does not. A screen that names an
  * observable query here is stating that its data is live, which is a design decision worth being able to
  * read off the screen.
+ *
+ * As with `dataTable`, no `clientFiltering` property is exposed: `@cratis/components` 3.0.0 keeps the
+ * prop for source compatibility but ignores it, and a screen property that cannot change anything is
+ * worse than an absent one.
  */ function SceneObservableDataTable({ element, slots }) {
     const { name, target } = resolveElementBinding.resolveElementBinding(element, BindingKind.BindingKind.Query);
     if (!target) return /*#__PURE__*/ jsxRuntime.jsx(MissingBinding.MissingBinding, {
@@ -33,7 +37,6 @@ const DataTableForObservableQuery = /*#__PURE__*/ react.lazy(async ()=>({
             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
         })

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

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

package/dist/cjs/dialogs/SceneCommandDialog.js

@@ -21,6 +21,15 @@ const CommandDialog = /*#__PURE__*/ react.lazy(async ()=>({
  * reimplementing the protocol.
  *
  * The `command` property names an Arc command proxy; the fields go in the `content` slot.
+ *
+ * `dismissable` and `closeAriaLabel` are here rather than on `dialog` alone because `CommandDialog`
+ * forwards both to the dialog it wraps, and in `@cratis/components` 3.0.0 that forwarding actually
+ * happens - 2.x accepted the two props and dropped them on the floor. `dismissable` matters more on a
+ * command dialog than anywhere else: it decides whether a half-filled form can be abandoned with
+ * `Escape` or a backdrop click, which is a decision about the command, not about the chrome.
+ *
+ * The `resizable` property this adapter used to carry is gone. It is still declared upstream so call
+ * sites compile, but PrimeReact 11's headless dialog has no resize handle and nothing reads the prop.
  */ function SceneCommandDialog({ element, slots }) {
     const { name, target } = resolveElementBinding.resolveElementBinding(element, BindingKind.BindingKind.Command);
     if (!target) return /*#__PURE__*/ jsxRuntime.jsx(MissingBinding.MissingBinding, {
@@ -34,9 +43,10 @@ const CommandDialog = /*#__PURE__*/ react.lazy(async ()=>({
             command: target,
             visible: properties.booleanProperty(element.properties, 'visible') ?? true,
             width: properties.stringProperty(element.properties, 'width'),
-            resizable: properties.booleanProperty(element.properties, 'resizable'),
+            dismissable: properties.booleanProperty(element.properties, 'dismissable'),
             okLabel: properties.stringProperty(element.properties, 'okLabel'),
             cancelLabel: properties.stringProperty(element.properties, 'cancelLabel'),
+            closeAriaLabel: properties.stringProperty(element.properties, 'closeAriaLabel'),
             className: properties.stringProperty(element.properties, 'className'),
             children: slots.content
         })

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

@@ -1 +1 @@
-{"version":3,"file":"SceneCommandDialog.js","sources":["../../../dialogs/SceneCommandDialog.tsx"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { lazy } from 'react';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { ArcRuntimeBoundary, BindingKind, MissingBinding, resolveElementBinding } from '../bindings';\nimport { booleanProperty, stringProperty } from '../properties';\n\nconst CommandDialog = lazy(async () => ({ default: (await import('@cratis/components/CommandDialog')).CommandDialog }));\n\n/**\n * The `Cratis.Components:commandDialog` component - `CommandDialog` from `@cratis/components/CommandDialog`.\n *\n * A dialog whose confirm button *is* the command's execution: it binds the form to the command, submits\n * on confirm, feeds the backend's validation results back onto the fields, and only closes when the\n * command succeeded. That last part is the reason to use it rather than composing `dialog` with\n * `commandForm` - a hand-composed pair has no way to keep the dialog open on a rejected command without\n * reimplementing the protocol.\n *\n * The `command` property names an Arc command proxy; the fields go in the `content` slot.\n */\nexport function SceneCommandDialog({ element, slots }: RegisteredComponentProps) {\n    const { name, target } = resolveElementBinding(element, BindingKind.Command);\n    if (!target) return <MissingBinding element={element} kind={BindingKind.Command} name={name} />;\n\n    return (\n        <ArcRuntimeBoundary>\n            <CommandDialog\n                title={stringProperty(element.properties, 'title') ?? ''}\n                command={target}\n                visible={booleanProperty(element.properties, 'visible') ?? true}\n                width={stringProperty(element.properties, 'width')}\n                resizable={booleanProperty(element.properties, 'resizable')}\n                okLabel={stringProperty(element.properties, 'okLabel')}\n                cancelLabel={stringProperty(element.properties, 'cancelLabel')}\n                className={stringProperty(element.properties, 'className')}\n            >\n                {slots.content}\n            </CommandDialog>\n        </ArcRuntimeBoundary>\n    );\n}\n"],"names":["CommandDialog","lazy","default","SceneCommandDialog","element","slots","name","target","resolveElementBinding","BindingKind","Command","_jsx","MissingBinding","kind","ArcRuntimeBoundary","title","stringProperty","properties","command","visible","booleanProperty","width","resizable","okLabel","cancelLabel","className","content"],"mappings":";;;;;;;;;;AAQA,MAAMA,aAAAA,iBAAgBC,UAAAA,CAAK,WAAa;AAAEC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,kCAAA,CAAkC,EAAGF;KAAc,CAAA,CAAA;AAEpH;;;;;;;;;;AAUC,IACM,SAASG,kBAAAA,CAAmB,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;IAC3E,MAAM,EAAEC,IAAI,EAAEC,MAAM,EAAE,GAAGC,2CAAAA,CAAsBJ,OAAAA,EAASK,uBAAAA,CAAYC,OAAO,CAAA;IAC3E,IAAI,CAACH,MAAAA,EAAQ,qBAAOI,cAAA,CAACC,6BAAAA,EAAAA;QAAeR,OAAAA,EAASA,OAAAA;AAASS,QAAAA,IAAAA,EAAMJ,wBAAYC,OAAO;QAAEJ,IAAAA,EAAMA;;AAEvF,IAAA,qBACIK,cAAA,CAACG,qCAAAA,EAAAA;AACG,QAAA,QAAA,gBAAAH,cAAA,CAACX,aAAAA,EAAAA;AACGe,YAAAA,KAAAA,EAAOC,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,OAAA,CAAA,IAAY,EAAA;YACtDC,OAAAA,EAASX,MAAAA;AACTY,YAAAA,OAAAA,EAASC,0BAAAA,CAAgBhB,OAAAA,CAAQa,UAAU,EAAE,SAAA,CAAA,IAAc,IAAA;YAC3DI,KAAAA,EAAOL,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,OAAA,CAAA;YAC1CK,SAAAA,EAAWF,0BAAAA,CAAgBhB,OAAAA,CAAQa,UAAU,EAAE,WAAA,CAAA;YAC/CM,OAAAA,EAASP,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,SAAA,CAAA;YAC5CO,WAAAA,EAAaR,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,aAAA,CAAA;YAChDQ,SAAAA,EAAWT,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,WAAA,CAAA;AAE7CZ,YAAAA,QAAAA,EAAAA,KAAAA,CAAMqB;;;AAIvB;;;;"}
+{"version":3,"file":"SceneCommandDialog.js","sources":["../../../dialogs/SceneCommandDialog.tsx"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { lazy } from 'react';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { ArcRuntimeBoundary, BindingKind, MissingBinding, resolveElementBinding } from '../bindings';\nimport { booleanProperty, stringProperty } from '../properties';\n\nconst CommandDialog = lazy(async () => ({ default: (await import('@cratis/components/CommandDialog')).CommandDialog }));\n\n/**\n * The `Cratis.Components:commandDialog` component - `CommandDialog` from `@cratis/components/CommandDialog`.\n *\n * A dialog whose confirm button *is* the command's execution: it binds the form to the command, submits\n * on confirm, feeds the backend's validation results back onto the fields, and only closes when the\n * command succeeded. That last part is the reason to use it rather than composing `dialog` with\n * `commandForm` - a hand-composed pair has no way to keep the dialog open on a rejected command without\n * reimplementing the protocol.\n *\n * The `command` property names an Arc command proxy; the fields go in the `content` slot.\n *\n * `dismissable` and `closeAriaLabel` are here rather than on `dialog` alone because `CommandDialog`\n * forwards both to the dialog it wraps, and in `@cratis/components` 3.0.0 that forwarding actually\n * happens - 2.x accepted the two props and dropped them on the floor. `dismissable` matters more on a\n * command dialog than anywhere else: it decides whether a half-filled form can be abandoned with\n * `Escape` or a backdrop click, which is a decision about the command, not about the chrome.\n *\n * The `resizable` property this adapter used to carry is gone. It is still declared upstream so call\n * sites compile, but PrimeReact 11's headless dialog has no resize handle and nothing reads the prop.\n */\nexport function SceneCommandDialog({ element, slots }: RegisteredComponentProps) {\n    const { name, target } = resolveElementBinding(element, BindingKind.Command);\n    if (!target) return <MissingBinding element={element} kind={BindingKind.Command} name={name} />;\n\n    return (\n        <ArcRuntimeBoundary>\n            <CommandDialog\n                title={stringProperty(element.properties, 'title') ?? ''}\n                command={target}\n                visible={booleanProperty(element.properties, 'visible') ?? true}\n                width={stringProperty(element.properties, 'width')}\n                dismissable={booleanProperty(element.properties, 'dismissable')}\n                okLabel={stringProperty(element.properties, 'okLabel')}\n                cancelLabel={stringProperty(element.properties, 'cancelLabel')}\n                closeAriaLabel={stringProperty(element.properties, 'closeAriaLabel')}\n                className={stringProperty(element.properties, 'className')}\n            >\n                {slots.content}\n            </CommandDialog>\n        </ArcRuntimeBoundary>\n    );\n}\n"],"names":["CommandDialog","lazy","default","SceneCommandDialog","element","slots","name","target","resolveElementBinding","BindingKind","Command","_jsx","MissingBinding","kind","ArcRuntimeBoundary","title","stringProperty","properties","command","visible","booleanProperty","width","dismissable","okLabel","cancelLabel","closeAriaLabel","className","content"],"mappings":";;;;;;;;;;AAQA,MAAMA,aAAAA,iBAAgBC,UAAAA,CAAK,WAAa;AAAEC,QAAAA,OAAAA,EAAS,CAAC,MAAM,OAAO,kCAAA,CAAkC,EAAGF;KAAc,CAAA,CAAA;AAEpH;;;;;;;;;;;;;;;;;;;AAmBC,IACM,SAASG,kBAAAA,CAAmB,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;IAC3E,MAAM,EAAEC,IAAI,EAAEC,MAAM,EAAE,GAAGC,2CAAAA,CAAsBJ,OAAAA,EAASK,uBAAAA,CAAYC,OAAO,CAAA;IAC3E,IAAI,CAACH,MAAAA,EAAQ,qBAAOI,cAAA,CAACC,6BAAAA,EAAAA;QAAeR,OAAAA,EAASA,OAAAA;AAASS,QAAAA,IAAAA,EAAMJ,wBAAYC,OAAO;QAAEJ,IAAAA,EAAMA;;AAEvF,IAAA,qBACIK,cAAA,CAACG,qCAAAA,EAAAA;AACG,QAAA,QAAA,gBAAAH,cAAA,CAACX,aAAAA,EAAAA;AACGe,YAAAA,KAAAA,EAAOC,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,OAAA,CAAA,IAAY,EAAA;YACtDC,OAAAA,EAASX,MAAAA;AACTY,YAAAA,OAAAA,EAASC,0BAAAA,CAAgBhB,OAAAA,CAAQa,UAAU,EAAE,SAAA,CAAA,IAAc,IAAA;YAC3DI,KAAAA,EAAOL,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,OAAA,CAAA;YAC1CK,WAAAA,EAAaF,0BAAAA,CAAgBhB,OAAAA,CAAQa,UAAU,EAAE,aAAA,CAAA;YACjDM,OAAAA,EAASP,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,SAAA,CAAA;YAC5CO,WAAAA,EAAaR,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,aAAA,CAAA;YAChDQ,cAAAA,EAAgBT,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,gBAAA,CAAA;YACnDS,SAAAA,EAAWV,yBAAAA,CAAeZ,OAAAA,CAAQa,UAAU,EAAE,WAAA,CAAA;AAE7CZ,YAAAA,QAAAA,EAAAA,KAAAA,CAAMsB;;;AAIvB;;;;"}