@cratis/scene.primereact 0.1.0

package/dist/esm/primeReactPackage.d.ts

@@ -0,0 +1,5 @@
+import { ScenePackage } from '@cratis/scene.model';
+import { ScenePackageBundle } from '@cratis/scene.react';
+export declare const primeReactPackageManifest: ScenePackage;
+export declare const primeReactPackage: ScenePackageBundle;
+//# sourceMappingURL=primeReactPackage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"primeReactPackage.d.ts","sourceRoot":"","sources":["../../primeReactPackage.ts"],"names":[],"mappings":"AAGA,OAAO,EAAe,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAczD,eAAO,MAAM,yBAAyB,EAAE,YAsDvC,CAAC;AAMF,eAAO,MAAM,iBAAiB,EAAE,kBAI/B,CAAC"}

package/dist/esm/primeReactPackage.js

@@ -0,0 +1,153 @@
+import { PackageKind } from '@cratis/scene.model';
+import { primeReactComponents } from './primeReactComponents.js';
+import { primeReactThemes, primeReactThemeNames } from './theme/primeReactThemes.js';
+import 'react';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The `PrimeReact` package's declaration - what a `ui profile` lists by name and what a
+ * `PackageDependency` refers to.
+ *
+ * The component list is written out rather than derived from the registry, on purpose. A manifest is
+ * read by Stage's build and Studio's design-time queries *without loading a single component*, so it has
+ * to stand on its own as the statement of what this package offers. Keeping it as its own list is also
+ * what gives `validatePackageBundle` something real to check: two independently maintained lists that
+ * must agree, rather than one list compared against itself.
+ */ const primeReactPackageManifest = {
+    name: 'PrimeReact',
+    version: '10.9.8',
+    kind: PackageKind.ComponentLibrary,
+    /**
+     * PrimeReact's own components need nothing from Tailwind - they are skinned by a compiled theme
+     * stylesheet. The dependency is here because *this package's wrappers* use Tailwind utility classes
+     * for the layout around them: the row a checkbox and its label sit on, the column a radio group
+     * stacks into, the grid a summary lays its pairs out in. A profile that activates this package
+     * without Tailwind renders those wrappers unstyled, so declaring it is what makes the profile picker
+     * offer Tailwind alongside PrimeReact instead of leaving the gap to be discovered on screen.
+     */ dependencies: [
+        {
+            name: 'Tailwind'
+        }
+    ],
+    components: [
+        'inputText',
+        'inputTextarea',
+        'inputNumber',
+        'password',
+        'inputMask',
+        'floatLabel',
+        'iconField',
+        'dropdown',
+        'multiSelect',
+        'listBox',
+        'selectButton',
+        'checkbox',
+        'radioButton',
+        'toggleSwitch',
+        'slider',
+        'rating',
+        'knob',
+        'calendar',
+        'colorPicker',
+        'chips',
+        'autoComplete',
+        'treeSelect',
+        'cascadeSelect',
+        'button',
+        'splitButton',
+        'speedDial',
+        'buttonGroup',
+        'dataTable',
+        'table',
+        'column',
+        'dataView',
+        'tree',
+        'treeTable',
+        'timeline',
+        'paginator',
+        'orderList',
+        'pickList',
+        'organizationChart',
+        'virtualScroller',
+        'card',
+        'panel',
+        'accordion',
+        'fieldset',
+        'divider',
+        'splitter',
+        'scrollPanel',
+        'tabView',
+        'toolbar',
+        'stepper',
+        'dialog',
+        'confirmDialog',
+        'overlayPanel',
+        'sidebar',
+        'tooltip',
+        'menu',
+        'menubar',
+        'breadcrumb',
+        'tabMenu',
+        'steps',
+        'tieredMenu',
+        'panelMenu',
+        'contextMenu',
+        'megaMenu',
+        'dock',
+        'message',
+        'inlineMessage',
+        'toast',
+        'image',
+        'galleria',
+        'carousel',
+        'avatar',
+        'badge',
+        'chip',
+        'tag',
+        'progressBar',
+        'progressSpinner',
+        'skeleton',
+        'scrollTop',
+        'blockUI',
+        'inplace',
+        'terminal',
+        'text',
+        'title',
+        'field',
+        'section',
+        'summary',
+        'action'
+    ],
+    /**
+     * Empty, and it stays empty. A layout is an application's base navigational look - one per
+     * application - and choosing it is a decision about the product, not about which widgets are
+     * available. A component library supplies the vocabulary a layout is built *from*; a
+     * {@link PackageKind.Blueprint} package supplies the layout itself.
+     */ layouts: [],
+    /**
+     * Empty for the same reason `layouts` is. A screen template is a reusable page shape at module,
+     * feature or slice level - "list with filters and a detail pane" - and it is composed *out of* the
+     * names declared above. Shipping one here would mean this package had opinions about how a screen is
+     * arranged, which is a Blueprint's job and not a component library's.
+     */ screenTemplates: [],
+    /**
+     * Empty, as above: a dialog template is a reusable dialog shape, composed from these components by a
+     * Blueprint package rather than provided by the library the components come from.
+     */ dialogTemplates: [],
+    themes: primeReactThemeNames,
+    displayName: 'PrimeReact',
+    description: 'PrimeReact 10 components and its free PrimeTek themes, mapped onto Scene\'s abstract component names.',
+    module: '@cratis/scene.primereact'
+};
+/**
+ * The `PrimeReact` package as a loadable bundle - the manifest plus the React components and themes
+ * behind the names it declares.
+ */ const primeReactPackage = {
+    manifest: primeReactPackageManifest,
+    components: primeReactComponents,
+    themes: primeReactThemes
+};
+
+export { primeReactPackage, primeReactPackageManifest };
+//# sourceMappingURL=primeReactPackage.js.map

package/dist/esm/primeReactPackage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primeReactPackage.js","sources":["../../primeReactPackage.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 { primeReactComponents } from './primeReactComponents';\nimport { primeReactThemeNames, primeReactThemes } from './theme';\n\n/**\n * The `PrimeReact` package's declaration - what a `ui profile` lists by name and what a\n * `PackageDependency` refers to.\n *\n * The component list is written out rather than derived from the registry, on purpose. A manifest is\n * read by Stage's build and Studio's design-time queries *without loading a single component*, so it has\n * to stand on its own as the statement of what this package offers. Keeping it as its own list is also\n * what gives `validatePackageBundle` something real to check: two independently maintained lists that\n * must agree, rather than one list compared against itself.\n */\nexport const primeReactPackageManifest: ScenePackage = {\n    name: 'PrimeReact',\n    version: '10.9.8',\n    kind: PackageKind.ComponentLibrary,\n\n    /**\n     * PrimeReact's own components need nothing from Tailwind - they are skinned by a compiled theme\n     * stylesheet. The dependency is here because *this package's wrappers* use Tailwind utility classes\n     * for the layout around them: the row a checkbox and its label sit on, the column a radio group\n     * stacks into, the grid a summary lays its pairs out in. A profile that activates this package\n     * without Tailwind renders those wrappers unstyled, so declaring it is what makes the profile picker\n     * offer Tailwind alongside PrimeReact instead of leaving the gap to be discovered on screen.\n     */\n    dependencies: [{ name: 'Tailwind' }],\n\n    components: [\n        'inputText', 'inputTextarea', 'inputNumber', 'password', 'inputMask', 'floatLabel', 'iconField', 'dropdown', 'multiSelect',\n        'listBox', 'selectButton', 'checkbox', 'radioButton', 'toggleSwitch', 'slider', 'rating', 'knob', 'calendar', 'colorPicker',\n        'chips', 'autoComplete', 'treeSelect', 'cascadeSelect', 'button', 'splitButton', 'speedDial', 'buttonGroup', 'dataTable', 'table',\n        'column', 'dataView', 'tree', 'treeTable', 'timeline', 'paginator', 'orderList', 'pickList', 'organizationChart', 'virtualScroller',\n        'card', 'panel', 'accordion', 'fieldset', 'divider', 'splitter', 'scrollPanel', 'tabView', 'toolbar', 'stepper', 'dialog',\n        'confirmDialog', 'overlayPanel', 'sidebar', 'tooltip', 'menu', 'menubar', 'breadcrumb', 'tabMenu', 'steps', 'tieredMenu',\n        'panelMenu', 'contextMenu', 'megaMenu', 'dock', 'message', 'inlineMessage', 'toast', 'image', 'galleria', 'carousel', 'avatar',\n        'badge', 'chip', 'tag', 'progressBar', 'progressSpinner', 'skeleton', 'scrollTop', 'blockUI', 'inplace', 'terminal', 'text',\n        'title', 'field', 'section', 'summary', 'action',\n    ],\n\n    /**\n     * Empty, and it stays empty. A layout is an application's base navigational look - one per\n     * application - and choosing it is a decision about the product, not about which widgets are\n     * available. A component library supplies the vocabulary a layout is built *from*; a\n     * {@link PackageKind.Blueprint} package supplies the layout itself.\n     */\n    layouts: [],\n\n    /**\n     * Empty for the same reason `layouts` is. A screen template is a reusable page shape at module,\n     * feature or slice level - \"list with filters and a detail pane\" - and it is composed *out of* the\n     * names declared above. Shipping one here would mean this package had opinions about how a screen is\n     * arranged, which is a Blueprint's job and not a component library's.\n     */\n    screenTemplates: [],\n\n    /**\n     * Empty, as above: a dialog template is a reusable dialog shape, composed from these components by a\n     * Blueprint package rather than provided by the library the components come from.\n     */\n    dialogTemplates: [],\n\n    themes: primeReactThemeNames,\n\n    displayName: 'PrimeReact',\n    description: 'PrimeReact 10 components and its free PrimeTek themes, mapped onto Scene\\'s abstract component names.',\n    module: '@cratis/scene.primereact',\n};\n\n/**\n * The `PrimeReact` package as a loadable bundle - the manifest plus the React components and themes\n * behind the names it declares.\n */\nexport const primeReactPackage: ScenePackageBundle = {\n    manifest: primeReactPackageManifest,\n    components: primeReactComponents,\n    themes: primeReactThemes,\n};\n"],"names":["primeReactPackageManifest","name","version","kind","PackageKind","ComponentLibrary","dependencies","components","layouts","screenTemplates","dialogTemplates","themes","primeReactThemeNames","displayName","description","module","primeReactPackage","manifest","primeReactComponents","primeReactThemes"],"mappings":";;;;;AAAA;AACA;AAOA;;;;;;;;;UAUaA,yBAAAA,GAA0C;IACnDC,IAAAA,EAAM,YAAA;IACNC,OAAAA,EAAS,QAAA;AACTC,IAAAA,IAAAA,EAAMC,YAAYC,gBAAgB;AAElC;;;;;;;AAOC,QACDC,YAAAA,EAAc;AAAC,QAAA;YAAEL,IAAAA,EAAM;AAAW;AAAE,KAAA;IAEpCM,UAAAA,EAAY;AACR,QAAA,WAAA;AAAa,QAAA,eAAA;AAAiB,QAAA,aAAA;AAAe,QAAA,UAAA;AAAY,QAAA,WAAA;AAAa,QAAA,YAAA;AAAc,QAAA,WAAA;AAAa,QAAA,UAAA;AAAY,QAAA,aAAA;AAC7G,QAAA,SAAA;AAAW,QAAA,cAAA;AAAgB,QAAA,UAAA;AAAY,QAAA,aAAA;AAAe,QAAA,cAAA;AAAgB,QAAA,QAAA;AAAU,QAAA,QAAA;AAAU,QAAA,MAAA;AAAQ,QAAA,UAAA;AAAY,QAAA,aAAA;AAC9G,QAAA,OAAA;AAAS,QAAA,cAAA;AAAgB,QAAA,YAAA;AAAc,QAAA,eAAA;AAAiB,QAAA,QAAA;AAAU,QAAA,aAAA;AAAe,QAAA,WAAA;AAAa,QAAA,aAAA;AAAe,QAAA,WAAA;AAAa,QAAA,OAAA;AAC1H,QAAA,QAAA;AAAU,QAAA,UAAA;AAAY,QAAA,MAAA;AAAQ,QAAA,WAAA;AAAa,QAAA,UAAA;AAAY,QAAA,WAAA;AAAa,QAAA,WAAA;AAAa,QAAA,UAAA;AAAY,QAAA,mBAAA;AAAqB,QAAA,iBAAA;AAClH,QAAA,MAAA;AAAQ,QAAA,OAAA;AAAS,QAAA,WAAA;AAAa,QAAA,UAAA;AAAY,QAAA,SAAA;AAAW,QAAA,UAAA;AAAY,QAAA,aAAA;AAAe,QAAA,SAAA;AAAW,QAAA,SAAA;AAAW,QAAA,SAAA;AAAW,QAAA,QAAA;AACjH,QAAA,eAAA;AAAiB,QAAA,cAAA;AAAgB,QAAA,SAAA;AAAW,QAAA,SAAA;AAAW,QAAA,MAAA;AAAQ,QAAA,SAAA;AAAW,QAAA,YAAA;AAAc,QAAA,SAAA;AAAW,QAAA,OAAA;AAAS,QAAA,YAAA;AAC5G,QAAA,WAAA;AAAa,QAAA,aAAA;AAAe,QAAA,UAAA;AAAY,QAAA,MAAA;AAAQ,QAAA,SAAA;AAAW,QAAA,eAAA;AAAiB,QAAA,OAAA;AAAS,QAAA,OAAA;AAAS,QAAA,UAAA;AAAY,QAAA,UAAA;AAAY,QAAA,QAAA;AACtH,QAAA,OAAA;AAAS,QAAA,MAAA;AAAQ,QAAA,KAAA;AAAO,QAAA,aAAA;AAAe,QAAA,iBAAA;AAAmB,QAAA,UAAA;AAAY,QAAA,WAAA;AAAa,QAAA,SAAA;AAAW,QAAA,SAAA;AAAW,QAAA,UAAA;AAAY,QAAA,MAAA;AACrH,QAAA,OAAA;AAAS,QAAA,OAAA;AAAS,QAAA,SAAA;AAAW,QAAA,SAAA;AAAW,QAAA;AAC3C,KAAA;AAED;;;;;AAKC,QACDC,SAAS,EAAE;AAEX;;;;;AAKC,QACDC,iBAAiB,EAAE;AAEnB;;;AAGC,QACDC,iBAAiB,EAAE;IAEnBC,MAAAA,EAAQC,oBAAAA;IAERC,WAAAA,EAAa,YAAA;IACbC,WAAAA,EAAa,uGAAA;IACbC,MAAAA,EAAQ;AACZ;AAEA;;;UAIaC,iBAAAA,GAAwC;IACjDC,QAAAA,EAAUjB,yBAAAA;IACVO,UAAAA,EAAYW,oBAAAA;IACZP,MAAAA,EAAQQ;AACZ;;;;"}

package/dist/esm/properties.d.ts

@@ -0,0 +1,13 @@
+import { SceneElement } from '@cratis/scene.model';
+import { SelectOption } from './SelectOption';
+export declare function stringProperty(element: SceneElement, name: string): string | undefined;
+export declare function stringProperty(element: SceneElement, name: string, fallback: string): string;
+export declare function booleanProperty(element: SceneElement, name: string): boolean | undefined;
+export declare function booleanProperty(element: SceneElement, name: string, fallback: boolean): boolean;
+export declare function numberProperty(element: SceneElement, name: string): number | undefined;
+export declare function numberProperty(element: SceneElement, name: string, fallback: number): number;
+export declare function arrayProperty(element: SceneElement, name: string): unknown[];
+export declare function stringArrayProperty(element: SceneElement, name: string): string[];
+export declare function recordArrayProperty(element: SceneElement, name: string): Record<string, unknown>[];
+export declare function optionsProperty(element: SceneElement, name: string): SelectOption[];
+//# sourceMappingURL=properties.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"properties.d.ts","sourceRoot":"","sources":["../../properties.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAiB9C,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AACxF,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;AAc9F,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;AAC1F,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC;AAiBjG,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AACxF,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;AAiB9F,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,CAG5E;AASD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEjF;AAYD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAIlG;AAcD,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,CAiBnF"}

package/dist/esm/properties.js

@@ -0,0 +1,84 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+function stringProperty(element, name, fallback) {
+    const value = element.properties[name];
+    return typeof value === 'string' ? value : fallback;
+}
+function booleanProperty(element, name, fallback) {
+    const value = element.properties[name];
+    return typeof value === 'boolean' ? value : fallback;
+}
+function numberProperty(element, name, fallback) {
+    const value = element.properties[name];
+    return typeof value === 'number' && !Number.isNaN(value) ? value : fallback;
+}
+/**
+ * Reads an array configuration value off a Scene element, as raw entries.
+ *
+ * Always returns an array - an absent or wrongly typed property becomes an empty one - because every
+ * caller is about to map over it, and a component rendering nothing is a far better failure than one
+ * throwing on `undefined.map`.
+ *
+ * @param element The element whose properties to read.
+ * @param name The property name.
+ * @returns The entries, or an empty array when the property is missing or is not an array.
+ */ function arrayProperty(element, name) {
+    const value = element.properties[name];
+    return Array.isArray(value) ? value : [];
+}
+/**
+ * Reads an array of strings off a Scene element, dropping any entry that is not one.
+ *
+ * @param element The element whose properties to read.
+ * @param name The property name.
+ * @returns The string entries, in order.
+ */ function stringArrayProperty(element, name) {
+    return arrayProperty(element, name).filter((entry)=>typeof entry === 'string');
+}
+/**
+ * Reads an array of objects off a Scene element, dropping any entry that is not one.
+ *
+ * This is the shape row data, column definitions and menu items all arrive in, so it is the common
+ * bottom step every structured reader in this package builds on.
+ *
+ * @param element The element whose properties to read.
+ * @param name The property name.
+ * @returns The object entries, in order.
+ */ function recordArrayProperty(element, name) {
+    return arrayProperty(element, name).filter((entry)=>typeof entry === 'object' && entry !== undefined && entry !== null && !Array.isArray(entry));
+}
+/**
+ * Reads a selection component's options off a Scene element, normalizing both shapes a screen may use.
+ *
+ * A screen written by hand tends to say `options: ['Draft', 'Published']`; one generated from a model
+ * says `options: [{ label: 'Draft', value: 'draft' }]`. Both are reasonable, so both are accepted and
+ * flattened to {@link SelectOption} - an entry with only a label uses that label as its value, which is
+ * exactly what the shorthand means.
+ *
+ * @param element The element whose properties to read.
+ * @param name The property name.
+ * @returns The normalized options, in order, skipping entries that carry no usable label.
+ */ function optionsProperty(element, name) {
+    const options = [];
+    for (const entry of arrayProperty(element, name)){
+        if (typeof entry === 'string') {
+            options.push({
+                label: entry,
+                value: entry
+            });
+            continue;
+        }
+        if (typeof entry !== 'object' || entry === undefined || entry === null || Array.isArray(entry)) continue;
+        const record = entry;
+        const label = typeof record.label === 'string' ? record.label : undefined;
+        const value = typeof record.value === 'string' ? record.value : label;
+        if (label !== undefined && value !== undefined) options.push({
+            label,
+            value
+        });
+    }
+    return options;
+}
+
+export { arrayProperty, booleanProperty, numberProperty, optionsProperty, recordArrayProperty, stringArrayProperty, stringProperty };
+//# sourceMappingURL=properties.js.map

package/dist/esm/properties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties.js","sources":["../../properties.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { SceneElement } from '@cratis/scene.model';\nimport { SelectOption } from './SelectOption';\n\n/**\n * Reads a string configuration value off a Scene element.\n *\n * `SceneElement.properties` is `Record<string, unknown>` because a screen's properties come from\n * authored model data, not from a compiler that knows this package's expectations. Every adapter\n * therefore has to narrow before it can use a value, and doing that with a cast would defeat the point -\n * a mistyped property would sail through and blow up inside PrimeReact instead of quietly falling back\n * here. These helpers are the single narrowing point, so a wrong type behaves exactly like an absent\n * one everywhere.\n *\n * @param element The element whose properties to read.\n * @param name The property name.\n * @param fallback The value to use when the property is missing or is not a string.\n * @returns The string value, or `fallback` (`undefined` when none was given).\n */\nexport function stringProperty(element: SceneElement, name: string): string | undefined;\nexport function stringProperty(element: SceneElement, name: string, fallback: string): string;\nexport function stringProperty(element: SceneElement, name: string, fallback?: string): string | undefined {\n    const value = element.properties[name];\n    return typeof value === 'string' ? value : fallback;\n}\n\n/**\n * Reads a boolean configuration value off a Scene element.\n *\n * @param element The element whose properties to read.\n * @param name The property name.\n * @param fallback The value to use when the property is missing or is not a boolean.\n * @returns The boolean value, or `fallback` (`undefined` when none was given).\n */\nexport function booleanProperty(element: SceneElement, name: string): boolean | undefined;\nexport function booleanProperty(element: SceneElement, name: string, fallback: boolean): boolean;\nexport function booleanProperty(element: SceneElement, name: string, fallback?: boolean): boolean | undefined {\n    const value = element.properties[name];\n    return typeof value === 'boolean' ? value : fallback;\n}\n\n/**\n * Reads a numeric configuration value off a Scene element.\n *\n * `NaN` is rejected alongside non-numbers: it is a number by `typeof` but never a usable size, count or\n * bound, and letting it through would surface as an unexplained blank component rather than a fallback.\n *\n * @param element The element whose properties to read.\n * @param name The property name.\n * @param fallback The value to use when the property is missing or is not a usable number.\n * @returns The numeric value, or `fallback` (`undefined` when none was given).\n */\nexport function numberProperty(element: SceneElement, name: string): number | undefined;\nexport function numberProperty(element: SceneElement, name: string, fallback: number): number;\nexport function numberProperty(element: SceneElement, name: string, fallback?: number): number | undefined {\n    const value = element.properties[name];\n    return typeof value === 'number' && !Number.isNaN(value) ? value : fallback;\n}\n\n/**\n * Reads an array configuration value off a Scene element, as raw entries.\n *\n * Always returns an array - an absent or wrongly typed property becomes an empty one - because every\n * caller is about to map over it, and a component rendering nothing is a far better failure than one\n * throwing on `undefined.map`.\n *\n * @param element The element whose properties to read.\n * @param name The property name.\n * @returns The entries, or an empty array when the property is missing or is not an array.\n */\nexport function arrayProperty(element: SceneElement, name: string): unknown[] {\n    const value = element.properties[name];\n    return Array.isArray(value) ? value : [];\n}\n\n/**\n * Reads an array of strings off a Scene element, dropping any entry that is not one.\n *\n * @param element The element whose properties to read.\n * @param name The property name.\n * @returns The string entries, in order.\n */\nexport function stringArrayProperty(element: SceneElement, name: string): string[] {\n    return arrayProperty(element, name).filter((entry): entry is string => typeof entry === 'string');\n}\n\n/**\n * Reads an array of objects off a Scene element, dropping any entry that is not one.\n *\n * This is the shape row data, column definitions and menu items all arrive in, so it is the common\n * bottom step every structured reader in this package builds on.\n *\n * @param element The element whose properties to read.\n * @param name The property name.\n * @returns The object entries, in order.\n */\nexport function recordArrayProperty(element: SceneElement, name: string): Record<string, unknown>[] {\n    return arrayProperty(element, name).filter(\n        (entry): entry is Record<string, unknown> => typeof entry === 'object' && entry !== undefined && entry !== null && !Array.isArray(entry)\n    );\n}\n\n/**\n * Reads a selection component's options off a Scene element, normalizing both shapes a screen may use.\n *\n * A screen written by hand tends to say `options: ['Draft', 'Published']`; one generated from a model\n * says `options: [{ label: 'Draft', value: 'draft' }]`. Both are reasonable, so both are accepted and\n * flattened to {@link SelectOption} - an entry with only a label uses that label as its value, which is\n * exactly what the shorthand means.\n *\n * @param element The element whose properties to read.\n * @param name The property name.\n * @returns The normalized options, in order, skipping entries that carry no usable label.\n */\nexport function optionsProperty(element: SceneElement, name: string): SelectOption[] {\n    const options: SelectOption[] = [];\n    for (const entry of arrayProperty(element, name)) {\n        if (typeof entry === 'string') {\n            options.push({ label: entry, value: entry });\n            continue;\n        }\n\n        if (typeof entry !== 'object' || entry === undefined || entry === null || Array.isArray(entry)) continue;\n\n        const record = entry as Record<string, unknown>;\n        const label = typeof record.label === 'string' ? record.label : undefined;\n        const value = typeof record.value === 'string' ? record.value : label;\n        if (label !== undefined && value !== undefined) options.push({ label, value });\n    }\n\n    return options;\n}\n"],"names":["stringProperty","element","name","fallback","value","properties","booleanProperty","numberProperty","Number","isNaN","arrayProperty","Array","isArray","stringArrayProperty","filter","entry","recordArrayProperty","undefined","optionsProperty","options","push","label","record"],"mappings":"AAAA;AACA;AAsBO,SAASA,cAAAA,CAAeC,OAAqB,EAAEC,IAAY,EAAEC,QAAiB,EAAA;AACjF,IAAA,MAAMC,KAAAA,GAAQH,OAAAA,CAAQI,UAAU,CAACH,IAAAA,CAAK;IACtC,OAAO,OAAOE,KAAAA,KAAU,QAAA,GAAWA,KAAAA,GAAQD,QAAAA;AAC/C;AAYO,SAASG,eAAAA,CAAgBL,OAAqB,EAAEC,IAAY,EAAEC,QAAkB,EAAA;AACnF,IAAA,MAAMC,KAAAA,GAAQH,OAAAA,CAAQI,UAAU,CAACH,IAAAA,CAAK;IACtC,OAAO,OAAOE,KAAAA,KAAU,SAAA,GAAYA,KAAAA,GAAQD,QAAAA;AAChD;AAeO,SAASI,cAAAA,CAAeN,OAAqB,EAAEC,IAAY,EAAEC,QAAiB,EAAA;AACjF,IAAA,MAAMC,KAAAA,GAAQH,OAAAA,CAAQI,UAAU,CAACH,IAAAA,CAAK;IACtC,OAAO,OAAOE,UAAU,QAAA,IAAY,CAACI,OAAOC,KAAK,CAACL,SAASA,KAAAA,GAAQD,QAAAA;AACvE;AAEA;;;;;;;;;;AAUC,IACM,SAASO,aAAAA,CAAcT,OAAqB,EAAEC,IAAY,EAAA;AAC7D,IAAA,MAAME,KAAAA,GAAQH,OAAAA,CAAQI,UAAU,CAACH,IAAAA,CAAK;AACtC,IAAA,OAAOS,KAAAA,CAAMC,OAAO,CAACR,KAAAA,CAAAA,GAASA,QAAQ,EAAE;AAC5C;AAEA;;;;;;AAMC,IACM,SAASS,mBAAAA,CAAoBZ,OAAqB,EAAEC,IAAY,EAAA;IACnE,OAAOQ,aAAAA,CAAcT,SAASC,IAAAA,CAAAA,CAAMY,MAAM,CAAC,CAACC,KAAAA,GAA2B,OAAOA,KAAAA,KAAU,QAAA,CAAA;AAC5F;AAEA;;;;;;;;;AASC,IACM,SAASC,mBAAAA,CAAoBf,OAAqB,EAAEC,IAAY,EAAA;AACnE,IAAA,OAAOQ,cAAcT,OAAAA,EAASC,IAAAA,CAAAA,CAAMY,MAAM,CACtC,CAACC,KAAAA,GAA4C,OAAOA,KAAAA,KAAU,QAAA,IAAYA,UAAUE,SAAAA,IAAaF,KAAAA,KAAU,QAAQ,CAACJ,KAAAA,CAAMC,OAAO,CAACG,KAAAA,CAAAA,CAAAA;AAE1I;AAEA;;;;;;;;;;;AAWC,IACM,SAASG,eAAAA,CAAgBjB,OAAqB,EAAEC,IAAY,EAAA;AAC/D,IAAA,MAAMiB,UAA0B,EAAE;AAClC,IAAA,KAAK,MAAMJ,KAAAA,IAASL,aAAAA,CAAcT,OAAAA,EAASC,IAAAA,CAAAA,CAAO;QAC9C,IAAI,OAAOa,UAAU,QAAA,EAAU;AAC3BI,YAAAA,OAAAA,CAAQC,IAAI,CAAC;gBAAEC,KAAAA,EAAON,KAAAA;gBAAOX,KAAAA,EAAOW;AAAM,aAAA,CAAA;AAC1C,YAAA;AACJ,QAAA;QAEA,IAAI,OAAOA,KAAAA,KAAU,QAAA,IAAYA,KAAAA,KAAUE,SAAAA,IAAaF,UAAU,IAAA,IAAQJ,KAAAA,CAAMC,OAAO,CAACG,KAAAA,CAAAA,EAAQ;AAEhG,QAAA,MAAMO,MAAAA,GAASP,KAAAA;QACf,MAAMM,KAAAA,GAAQ,OAAOC,MAAAA,CAAOD,KAAK,KAAK,QAAA,GAAWC,MAAAA,CAAOD,KAAK,GAAGJ,SAAAA;QAChE,MAAMb,KAAAA,GAAQ,OAAOkB,MAAAA,CAAOlB,KAAK,KAAK,QAAA,GAAWkB,MAAAA,CAAOlB,KAAK,GAAGiB,KAAAA;AAChE,QAAA,IAAIA,UAAUJ,SAAAA,IAAab,KAAAA,KAAUa,SAAAA,EAAWE,OAAAA,CAAQC,IAAI,CAAC;AAAEC,YAAAA,KAAAA;AAAOjB,YAAAA;AAAM,SAAA,CAAA;AAChF,IAAA;IAEA,OAAOe,OAAAA;AACX;;;;"}

package/dist/esm/screen/PrimeAction.d.ts

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

package/dist/esm/screen/PrimeAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeAction.d.ts","sourceRoot":"","sources":["../../../screen/PrimeAction.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAoB/D,wBAAgB,WAAW,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB,+BAYhE"}

package/dist/esm/screen/PrimeAction.js

@@ -0,0 +1,33 @@
+import { jsx } from 'react/jsx-runtime';
+import { Button } from 'primereact/button';
+import { stringProperty, booleanProperty } from '../properties.js';
+
+/**
+ * The `PrimeReact:action` component - one of Screenplay's screen directives: something the user can do.
+ *
+ * A button, but not the same adapter as `button`. Screenplay describes an action by its *intent* - is
+ * this the main thing to do here, a secondary one, a destructive one - and that vocabulary is what a
+ * screen author writes. Translating intent to PrimeReact's `severity` here keeps the mapping in one
+ * place, so a change to how destructive actions look is one edit rather than one per screen.
+ */ const severityForIntent = {
+    primary: undefined,
+    secondary: 'secondary',
+    destructive: 'danger',
+    danger: 'danger',
+    positive: 'success',
+    success: 'success'
+};
+function PrimeAction({ element }) {
+    const intent = stringProperty(element, 'intent', 'primary');
+    return /*#__PURE__*/ jsx(Button, {
+        "data-scene-id": element.id,
+        label: stringProperty(element, 'label', ''),
+        icon: stringProperty(element, 'icon'),
+        severity: severityForIntent[intent],
+        outlined: intent === 'secondary',
+        disabled: booleanProperty(element, 'disabled', false)
+    });
+}
+
+export { PrimeAction };
+//# sourceMappingURL=PrimeAction.js.map

package/dist/esm/screen/PrimeAction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeAction.js","sources":["../../../screen/PrimeAction.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 { Button } from 'primereact/button';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:action` component - one of Screenplay's screen directives: something the user can do.\n *\n * A button, but not the same adapter as `button`. Screenplay describes an action by its *intent* - is\n * this the main thing to do here, a secondary one, a destructive one - and that vocabulary is what a\n * screen author writes. Translating intent to PrimeReact's `severity` here keeps the mapping in one\n * place, so a change to how destructive actions look is one edit rather than one per screen.\n */\nconst severityForIntent: Record<string, 'secondary' | 'success' | 'info' | 'warning' | 'danger' | 'help' | undefined> = {\n    primary: undefined,\n    secondary: 'secondary',\n    destructive: 'danger',\n    danger: 'danger',\n    positive: 'success',\n    success: 'success',\n};\n\nexport function PrimeAction({ element }: RegisteredComponentProps) {\n    const intent = stringProperty(element, 'intent', 'primary');\n    return (\n        <Button\n            data-scene-id={element.id}\n            label={stringProperty(element, 'label', '')}\n            icon={stringProperty(element, 'icon')}\n            severity={severityForIntent[intent]}\n            outlined={intent === 'secondary'}\n            disabled={booleanProperty(element, 'disabled', false)}\n        />\n    );\n}\n"],"names":["severityForIntent","primary","undefined","secondary","destructive","danger","positive","success","PrimeAction","element","intent","stringProperty","_jsx","Button","data-scene-id","id","label","icon","severity","outlined","disabled","booleanProperty"],"mappings":";;;;AAOA;;;;;;;AAOC,IACD,MAAMA,iBAAAA,GAAkH;IACpHC,OAAAA,EAASC,SAAAA;IACTC,SAAAA,EAAW,WAAA;IACXC,WAAAA,EAAa,QAAA;IACbC,MAAAA,EAAQ,QAAA;IACRC,QAAAA,EAAU,SAAA;IACVC,OAAAA,EAAS;AACb,CAAA;AAEO,SAASC,WAAAA,CAAY,EAAEC,OAAO,EAA4B,EAAA;IAC7D,MAAMC,MAAAA,GAASC,cAAAA,CAAeF,OAAAA,EAAS,QAAA,EAAU,SAAA,CAAA;AACjD,IAAA,qBACIG,GAAA,CAACC,MAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeL,QAAQM,EAAE;QACzBC,KAAAA,EAAOL,cAAAA,CAAeF,SAAS,OAAA,EAAS,EAAA,CAAA;AACxCQ,QAAAA,IAAAA,EAAMN,eAAeF,OAAAA,EAAS,MAAA,CAAA;QAC9BS,QAAAA,EAAUlB,iBAAiB,CAACU,MAAAA,CAAO;AACnCS,QAAAA,QAAAA,EAAUT,MAAAA,KAAW,WAAA;QACrBU,QAAAA,EAAUC,eAAAA,CAAgBZ,SAAS,UAAA,EAAY,KAAA;;AAG3D;;;;"}

package/dist/esm/screen/PrimeField.d.ts

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

package/dist/esm/screen/PrimeField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeField.d.ts","sourceRoot":"","sources":["../../../screen/PrimeField.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAU/D,wBAAgB,UAAU,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,wBAAwB,+BAYtE"}

package/dist/esm/screen/PrimeField.js

@@ -0,0 +1,38 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { stringProperty } from '../properties.js';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The `PrimeReact:field` component - one of Screenplay's screen directives: a labeled value.
+ *
+ * The label is bound to the value with `aria-labelledby` rather than left as two adjacent pieces of text,
+ * so the pair is announced as one thing. When the `content` slot carries an editor, that editor is shown
+ * instead of the static value - which is what lets the same directive serve a detail view and a form.
+ */ function PrimeField({ element, slots }) {
+    const labelId = `${element.id}-label`;
+    return /*#__PURE__*/ jsxs("div", {
+        "data-scene-id": element.id,
+        className: "flex flex-col gap-1",
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                id: labelId,
+                className: "text-sm",
+                style: {
+                    color: 'var(--scene-text-muted-color)'
+                },
+                children: stringProperty(element, 'label', '')
+            }),
+            /*#__PURE__*/ jsx("div", {
+                "aria-labelledby": labelId,
+                style: {
+                    color: 'var(--scene-text-color)'
+                },
+                children: slots.content?.length ? slots.content : stringProperty(element, 'value', '')
+            })
+        ]
+    });
+}
+
+export { PrimeField };
+//# sourceMappingURL=PrimeField.js.map

package/dist/esm/screen/PrimeField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeField.js","sources":["../../../screen/PrimeField.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 { RegisteredComponentProps } from '@cratis/scene.react';\nimport { stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:field` component - one of Screenplay's screen directives: a labeled value.\n *\n * The label is bound to the value with `aria-labelledby` rather than left as two adjacent pieces of text,\n * so the pair is announced as one thing. When the `content` slot carries an editor, that editor is shown\n * instead of the static value - which is what lets the same directive serve a detail view and a form.\n */\nexport function PrimeField({ element, slots }: RegisteredComponentProps) {\n    const labelId = `${element.id}-label`;\n    return (\n        <div data-scene-id={element.id} className='flex flex-col gap-1'>\n            <span id={labelId} className='text-sm' style={{ color: 'var(--scene-text-muted-color)' }}>\n                {stringProperty(element, 'label', '')}\n            </span>\n            <div aria-labelledby={labelId} style={{ color: 'var(--scene-text-color)' }}>\n                {slots.content?.length ? slots.content : stringProperty(element, 'value', '')}\n            </div>\n        </div>\n    );\n}\n"],"names":["PrimeField","element","slots","labelId","id","_jsxs","div","data-scene-id","className","_jsx","span","style","color","stringProperty","aria-labelledby","content","length"],"mappings":";;;AAAA;AACA;AAKA;;;;;;AAMC,IACM,SAASA,UAAAA,CAAW,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;AACnE,IAAA,MAAMC,UAAU,CAAA,EAAGF,OAAAA,CAAQG,EAAE,CAAC,MAAM,CAAC;AACrC,IAAA,qBACIC,IAAA,CAACC,KAAAA,EAAAA;AAAIC,QAAAA,eAAAA,EAAeN,QAAQG,EAAE;QAAEI,SAAAA,EAAU,qBAAA;;0BACtCC,GAAA,CAACC,MAAAA,EAAAA;gBAAKN,EAAAA,EAAID,OAAAA;gBAASK,SAAAA,EAAU,SAAA;gBAAUG,KAAAA,EAAO;oBAAEC,KAAAA,EAAO;AAAgC,iBAAA;AAClFC,gBAAAA,QAAAA,EAAAA,cAAAA,CAAeZ,SAAS,OAAA,EAAS,EAAA;;0BAEtCQ,GAAA,CAACH,KAAAA,EAAAA;gBAAIQ,iBAAAA,EAAiBX,OAAAA;gBAASQ,KAAAA,EAAO;oBAAEC,KAAAA,EAAO;AAA0B,iBAAA;0BACpEV,KAAAA,CAAMa,OAAO,EAAEC,MAAAA,GAASd,KAAAA,CAAMa,OAAO,GAAGF,cAAAA,CAAeZ,SAAS,OAAA,EAAS,EAAA;;;;AAI1F;;;;"}

package/dist/esm/screen/PrimeSection.d.ts

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

package/dist/esm/screen/PrimeSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeSection.d.ts","sourceRoot":"","sources":["../../../screen/PrimeSection.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAU/D,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,wBAAwB,+BAexE"}

package/dist/esm/screen/PrimeSection.js

@@ -0,0 +1,38 @@
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+import { Divider } from 'primereact/divider';
+import { stringProperty } from '../properties.js';
+
+/**
+ * The `PrimeReact:section` component - one of Screenplay's screen directives: a titled grouping.
+ *
+ * A real `<section>` with a heading, not a styled `div`: the grouping is the point of the directive, and
+ * only the semantic element actually creates one for assistive technology. The rule under the heading is
+ * PrimeReact's `Divider`, so the separation is themed with everything else rather than hard-coded.
+ */ function PrimeSection({ element, slots }) {
+    const title = stringProperty(element, 'title');
+    return /*#__PURE__*/ jsxs("section", {
+        "data-scene-id": element.id,
+        className: "flex flex-col",
+        children: [
+            title !== undefined && /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx("h2", {
+                        className: "text-lg font-semibold",
+                        style: {
+                            color: 'var(--scene-text-color)'
+                        },
+                        children: title
+                    }),
+                    /*#__PURE__*/ jsx(Divider, {})
+                ]
+            }),
+            /*#__PURE__*/ jsx("div", {
+                className: "flex flex-col gap-3",
+                children: slots.content
+            })
+        ]
+    });
+}
+
+export { PrimeSection };
+//# sourceMappingURL=PrimeSection.js.map

package/dist/esm/screen/PrimeSection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeSection.js","sources":["../../../screen/PrimeSection.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 { Divider } from 'primereact/divider';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:section` component - one of Screenplay's screen directives: a titled grouping.\n *\n * A real `<section>` with a heading, not a styled `div`: the grouping is the point of the directive, and\n * only the semantic element actually creates one for assistive technology. The rule under the heading is\n * PrimeReact's `Divider`, so the separation is themed with everything else rather than hard-coded.\n */\nexport function PrimeSection({ element, slots }: RegisteredComponentProps) {\n    const title = stringProperty(element, 'title');\n    return (\n        <section data-scene-id={element.id} className='flex flex-col'>\n            {title !== undefined && (\n                <>\n                    <h2 className='text-lg font-semibold' style={{ color: 'var(--scene-text-color)' }}>\n                        {title}\n                    </h2>\n                    <Divider />\n                </>\n            )}\n            <div className='flex flex-col gap-3'>{slots.content}</div>\n        </section>\n    );\n}\n"],"names":["PrimeSection","element","slots","title","stringProperty","_jsxs","section","data-scene-id","id","className","undefined","_Fragment","_jsx","h2","style","color","Divider","div","content"],"mappings":";;;;AAOA;;;;;;AAMC,IACM,SAASA,YAAAA,CAAa,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;IACrE,MAAMC,KAAAA,GAAQC,eAAeH,OAAAA,EAAS,OAAA,CAAA;AACtC,IAAA,qBACII,IAAA,CAACC,SAAAA,EAAAA;AAAQC,QAAAA,eAAAA,EAAeN,QAAQO,EAAE;QAAEC,SAAAA,EAAU,eAAA;;AACzCN,YAAAA,KAAAA,KAAUO,SAAAA,kBACPL,IAAA,CAAAM,QAAA,EAAA;;kCACIC,GAAA,CAACC,IAAAA,EAAAA;wBAAGJ,SAAAA,EAAU,uBAAA;wBAAwBK,KAAAA,EAAO;4BAAEC,KAAAA,EAAO;AAA0B,yBAAA;AAC3EZ,wBAAAA,QAAAA,EAAAA;;kCAELS,GAAA,CAACI,OAAAA,EAAAA,EAAAA;;;0BAGTJ,GAAA,CAACK,KAAAA,EAAAA;gBAAIR,SAAAA,EAAU,qBAAA;AAAuBP,gBAAAA,QAAAA,EAAAA,KAAAA,CAAMgB;;;;AAGxD;;;;"}

package/dist/esm/screen/PrimeSummary.d.ts

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

package/dist/esm/screen/PrimeSummary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeSummary.d.ts","sourceRoot":"","sources":["../../../screen/PrimeSummary.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAW/D,wBAAgB,YAAY,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,wBAAwB,+BAiBxE"}

package/dist/esm/screen/PrimeSummary.js

@@ -0,0 +1,45 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { Card } from 'primereact/card';
+import { recordArrayProperty, stringProperty } from '../properties.js';
+
+/**
+ * The `PrimeReact:summary` component - one of Screenplay's screen directives: the headline facts about
+ * one thing.
+ *
+ * Rendered as a description list inside a card. A description list is the correct element for
+ * label/value pairs and gets the pairing across to a screen reader for free, which a grid of `div`s does
+ * not.
+ */ function PrimeSummary({ element, slots }) {
+    const items = recordArrayProperty(element, 'items');
+    return /*#__PURE__*/ jsxs(Card, {
+        "data-scene-id": element.id,
+        title: stringProperty(element, 'title'),
+        children: [
+            /*#__PURE__*/ jsx("dl", {
+                className: "grid grid-cols-2 gap-2",
+                children: items.map((item, index)=>/*#__PURE__*/ jsxs("div", {
+                        className: "flex flex-col",
+                        children: [
+                            /*#__PURE__*/ jsx("dt", {
+                                className: "text-sm",
+                                style: {
+                                    color: 'var(--scene-text-muted-color)'
+                                },
+                                children: String(item.label ?? '')
+                            }),
+                            /*#__PURE__*/ jsx("dd", {
+                                style: {
+                                    color: 'var(--scene-text-color)'
+                                },
+                                children: String(item.value ?? '')
+                            })
+                        ]
+                    }, index))
+            }),
+            slots.content
+        ]
+    });
+}
+
+export { PrimeSummary };
+//# sourceMappingURL=PrimeSummary.js.map

package/dist/esm/screen/PrimeSummary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeSummary.js","sources":["../../../screen/PrimeSummary.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 { Card } from 'primereact/card';\nimport { RegisteredComponentProps } from '@cratis/scene.react';\nimport { recordArrayProperty, stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:summary` component - one of Screenplay's screen directives: the headline facts about\n * one thing.\n *\n * Rendered as a description list inside a card. A description list is the correct element for\n * label/value pairs and gets the pairing across to a screen reader for free, which a grid of `div`s does\n * not.\n */\nexport function PrimeSummary({ element, slots }: RegisteredComponentProps) {\n    const items = recordArrayProperty(element, 'items');\n    return (\n        <Card data-scene-id={element.id} title={stringProperty(element, 'title')}>\n            <dl className='grid grid-cols-2 gap-2'>\n                {items.map((item, index) => (\n                    <div key={index} className='flex flex-col'>\n                        <dt className='text-sm' style={{ color: 'var(--scene-text-muted-color)' }}>\n                            {String(item.label ?? '')}\n                        </dt>\n                        <dd style={{ color: 'var(--scene-text-color)' }}>{String(item.value ?? '')}</dd>\n                    </div>\n                ))}\n            </dl>\n            {slots.content}\n        </Card>\n    );\n}\n"],"names":["PrimeSummary","element","slots","items","recordArrayProperty","_jsxs","Card","data-scene-id","id","title","stringProperty","_jsx","dl","className","map","item","index","div","dt","style","color","String","label","dd","value","content"],"mappings":";;;;AAOA;;;;;;;AAOC,IACM,SAASA,YAAAA,CAAa,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;IACrE,MAAMC,KAAAA,GAAQC,oBAAoBH,OAAAA,EAAS,OAAA,CAAA;AAC3C,IAAA,qBACII,IAAA,CAACC,IAAAA,EAAAA;AAAKC,QAAAA,eAAAA,EAAeN,QAAQO,EAAE;AAAEC,QAAAA,KAAAA,EAAOC,eAAeT,OAAAA,EAAS,OAAA,CAAA;;0BAC5DU,GAAA,CAACC,IAAAA,EAAAA;gBAAGC,SAAAA,EAAU,wBAAA;AACTV,gBAAAA,QAAAA,EAAAA,KAAAA,CAAMW,GAAG,CAAC,CAACC,IAAAA,EAAMC,sBACdX,IAAA,CAACY,KAAAA,EAAAA;wBAAgBJ,SAAAA,EAAU,eAAA;;0CACvBF,GAAA,CAACO,IAAAA,EAAAA;gCAAGL,SAAAA,EAAU,SAAA;gCAAUM,KAAAA,EAAO;oCAAEC,KAAAA,EAAO;AAAgC,iCAAA;0CACnEC,MAAAA,CAAON,IAAAA,CAAKO,KAAK,IAAI,EAAA;;0CAE1BX,GAAA,CAACY,IAAAA,EAAAA;gCAAGJ,KAAAA,EAAO;oCAAEC,KAAAA,EAAO;AAA0B,iCAAA;0CAAIC,MAAAA,CAAON,IAAAA,CAAKS,KAAK,IAAI,EAAA;;;AAJjER,qBAAAA,EAAAA,KAAAA,CAAAA;;AAQjBd,YAAAA,KAAAA,CAAMuB;;;AAGnB;;;;"}

package/dist/esm/screen/PrimeText.d.ts

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

package/dist/esm/screen/PrimeText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeText.d.ts","sourceRoot":"","sources":["../../../screen/PrimeText.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAY/D,wBAAgB,SAAS,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,wBAAwB,+BAYrE"}

package/dist/esm/screen/PrimeText.js

@@ -0,0 +1,31 @@
+import { jsxs } from 'react/jsx-runtime';
+import { booleanProperty, stringProperty } from '../properties.js';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The `PrimeReact:text` component - a run of prose.
+ *
+ * PrimeReact has no text primitive, so this one is written directly rather than wrapped. It is still
+ * worth shipping: it claims the bare name `core` also declares, and unlike core's unstyled span it picks
+ * up the active theme's type color and muting through the Scene token bridge. That is the smallest
+ * possible demonstration of why override priority exists - the same screen, the same name, better output
+ * once a component library is in the profile.
+ */ function PrimeText({ element, slots }) {
+    const muted = booleanProperty(element, 'muted', false);
+    const strong = booleanProperty(element, 'strong', false);
+    return /*#__PURE__*/ jsxs("span", {
+        "data-scene-id": element.id,
+        className: `${muted ? 'opacity-75' : ''} ${strong ? 'font-semibold' : ''}`.trim(),
+        style: {
+            color: muted ? 'var(--scene-text-muted-color)' : 'var(--scene-text-color)'
+        },
+        children: [
+            stringProperty(element, 'text', ''),
+            slots.content
+        ]
+    });
+}
+
+export { PrimeText };
+//# sourceMappingURL=PrimeText.js.map

package/dist/esm/screen/PrimeText.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeText.js","sources":["../../../screen/PrimeText.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 { RegisteredComponentProps } from '@cratis/scene.react';\nimport { booleanProperty, stringProperty } from '../properties';\n\n/**\n * The `PrimeReact:text` component - a run of prose.\n *\n * PrimeReact has no text primitive, so this one is written directly rather than wrapped. It is still\n * worth shipping: it claims the bare name `core` also declares, and unlike core's unstyled span it picks\n * up the active theme's type color and muting through the Scene token bridge. That is the smallest\n * possible demonstration of why override priority exists - the same screen, the same name, better output\n * once a component library is in the profile.\n */\nexport function PrimeText({ element, slots }: RegisteredComponentProps) {\n    const muted = booleanProperty(element, 'muted', false);\n    const strong = booleanProperty(element, 'strong', false);\n    return (\n        <span\n            data-scene-id={element.id}\n            className={`${muted ? 'opacity-75' : ''} ${strong ? 'font-semibold' : ''}`.trim()}\n            style={{ color: muted ? 'var(--scene-text-muted-color)' : 'var(--scene-text-color)' }}>\n            {stringProperty(element, 'text', '')}\n            {slots.content}\n        </span>\n    );\n}\n"],"names":["PrimeText","element","slots","muted","booleanProperty","strong","_jsxs","span","data-scene-id","id","className","trim","style","color","stringProperty","content"],"mappings":";;;AAAA;AACA;AAKA;;;;;;;;AAQC,IACM,SAASA,SAAAA,CAAU,EAAEC,OAAO,EAAEC,KAAK,EAA4B,EAAA;IAClE,MAAMC,KAAAA,GAAQC,eAAAA,CAAgBH,OAAAA,EAAS,OAAA,EAAS,KAAA,CAAA;IAChD,MAAMI,MAAAA,GAASD,eAAAA,CAAgBH,OAAAA,EAAS,QAAA,EAAU,KAAA,CAAA;AAClD,IAAA,qBACIK,IAAA,CAACC,MAAAA,EAAAA;AACGC,QAAAA,eAAAA,EAAeP,QAAQQ,EAAE;QACzBC,SAAAA,EAAW,CAAA,EAAGP,KAAAA,GAAQ,YAAA,GAAe,EAAA,CAAG,CAAC,EAAEE,MAAAA,GAAS,eAAA,GAAkB,EAAA,CAAA,CAAI,CAACM,IAAI,EAAA;QAC/EC,KAAAA,EAAO;AAAEC,YAAAA,KAAAA,EAAOV,QAAQ,+BAAA,GAAkC;AAA0B,SAAA;;AACnFW,YAAAA,cAAAA,CAAeb,SAAS,MAAA,EAAQ,EAAA,CAAA;AAChCC,YAAAA,KAAAA,CAAMa;;;AAGnB;;;;"}

package/dist/esm/screen/PrimeTitle.d.ts

@@ -0,0 +1,9 @@
+import { RegisteredComponentProps } from '@cratis/scene.react';
+export declare function PrimeTitle({ element }: RegisteredComponentProps): import("react").ReactElement<{
+    'data-scene-id': string;
+    className: string;
+    style: {
+        color: string;
+    };
+}, string | import("react").JSXElementConstructor<any>>;
+//# sourceMappingURL=PrimeTitle.d.ts.map

package/dist/esm/screen/PrimeTitle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimeTitle.d.ts","sourceRoot":"","sources":["../../../screen/PrimeTitle.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAU/D,wBAAgB,UAAU,CAAC,EAAE,OAAO,EAAE,EAAE,wBAAwB;;;;QAQ3C,KAAK;;wDAIzB"}