@cratis/scene.blueprint.components 0.1.0

package/.storybook/main.ts

@@ -0,0 +1,61 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { StorybookConfig } from "@storybook/react-vite";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import type { InlineConfig } from 'vite';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const config: StorybookConfig = {
+    // Scoped away from `dist/` so a story is never indexed twice - once as source and once as the
+    // tsc-emitted copy beside it.
+    stories: ["../*.stories.@(js|jsx|mjs|ts|tsx)", "../!(dist|node_modules)/**/*.stories.@(js|jsx|mjs|ts|tsx)"],
+    addons: [getAbsolutePath("@storybook/addon-links")],
+    framework: { name: getAbsolutePath("@storybook/react-vite"), options: {} },
+    async viteFinal(config: InlineConfig) {
+        config.resolve = config.resolve || {};
+        // The two packages this blueprint is built on are aliased alongside the three it shares with every
+        // other package here. Without that, `@cratis/scene.components` would come from its built `dist`
+        // while the engine and the React renderer came from source - and the binding registry is
+        // module-level state, so a story registering a fake through one copy would be invisible to the
+        // adapter reading the other.
+        config.resolve.alias = {
+            ...config.resolve.alias,
+            '@cratis/scene.engine': resolve(__dirname, '../../engine/index.ts'),
+            '@cratis/scene.model': resolve(__dirname, '../../model/index.ts'),
+            '@cratis/scene.react': resolve(__dirname, '../../react/index.ts'),
+            '@cratis/scene.components': resolve(__dirname, '../../components/index.ts'),
+            '@cratis/scene.blueprint.default': resolve(__dirname, '../../blueprint.default/index.ts'),
+        };
+        // `@cratis/arc`, `@cratis/arc.react` and `@cratis/fundamentals` are peer dependencies of
+        // `@cratis/components` that the *host application* supplies. A Storybook preview is not a host: it
+        // has no Arc client and no backend, which is exactly the situation these templates are designed
+        // around, so they are not installed here.
+        //
+        // Every Arc-bound adapter reaches them through a dynamic `import()`, which puts that half of the
+        // library in its own chunk. Marking these external lets the chunk be emitted with its imports left
+        // bare instead of failing the build. A story that registers a binding will make the browser fail to
+        // load that chunk and the `ArcRuntimeBoundary` around it will say so - which is the same thing a
+        // real host without Arc installed sees, and is worth seeing rather than hiding.
+        config.build = config.build || {};
+        config.build.rollupOptions = {
+            ...(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` ships `dist/esm/TimeMachine/Properties.css` with `//` line comments, which
+        // are not CSS. esbuild's minifier tolerates them. This blueprint is the first package here to place
+        // a `timeMachine` on a page, so it is the first to pull that file in. The same workaround is in the
+        // Cratis Components package's own preview tooling, and both come out once that file ships with
+        // `/* */` comments.
+        config.build.cssMinify = 'esbuild';
+        return config;
+    },
+};
+export default config;
+
+function getAbsolutePath(value: string): string {
+    return dirname(fileURLToPath(import.meta.resolve(join(value, "package.json"))));
+}

package/.storybook/preview.tsx

@@ -0,0 +1,42 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { Preview } from '@storybook/react';
+import { CratisComponentsProvider } from '@cratis/components/Common';
+
+// The stylesheet layers a page in this blueprint needs, in the order they resolve. PrimeReact 10 ships
+// every widget's *structural* CSS inside its theme file, so without a theme the wrapped widgets render as
+// bare HTML. `@cratis/components`' own sheet adds its Tailwind utilities and the `--cratis-*` token layer,
+// the Scene package's bridge puts Scene's `--scene-*` tokens in front of that, and the default blueprint's
+// `layout.css` draws the shell every one of these pages sits inside - which is the sheet this package does
+// not have and does not want, because the shell is not its.
+//
+// The last two are reached by relative path rather than through their packages' `./styles` export,
+// because `main.ts` aliases those package names to their sources and a Vite string alias matches by
+// prefix - `@cratis/scene.components/styles` would be rewritten into a path inside `index.ts`.
+import 'primereact/resources/themes/lara-light-blue/theme.css';
+import 'primeicons/primeicons.css';
+import '@cratis/components/styles';
+import '../../components/theme/sceneTokenBridge.css';
+import '../../blueprint.default/shell/layout.css';
+
+/**
+ * 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 show something subtly different from what an application renders - which defeats the
+ * point of having stories at all.
+ */
+const preview: Preview = {
+    decorators: [
+        Story => (
+            <CratisComponentsProvider>
+                <Story />
+            </CratisComponentsProvider>
+        ),
+    ],
+    parameters: {
+        controls: { matchers: { color: /(background|color)$/i, date: /Date$/i } },
+    },
+};
+
+export default preview;

package/BorrowedComponentName.ts

@@ -0,0 +1,22 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * Names this blueprint's templates reference that come from neither `Cratis.Components` nor itself.
+ *
+ * There is one, and it is worth stating why rather than leaving it as a bare string in a builder.
+ *
+ * `Cratis.Components`' data table and data page take their columns as children - the library's own
+ * documentation says the columns arrive in the `content` slot - but the library declares no `column` name
+ * of its own, because its tables are `DataTableForQuery` wrapping PrimeReact's `DataTable`, and a column
+ * is PrimeReact's `Column`. So a template that wants a table with real columns has to name PrimeReact's,
+ * and this blueprint's manifest declares PrimeReact as a dependency partly for that reason.
+ *
+ * It is checked the same way every other borrowed name in this repository is: against the owning
+ * package's own manifest, by a spec, rather than assumed. The default blueprint learned that the hard way
+ * when it referenced `chart` and `fileUpload`, which neither library declares.
+ */
+export enum BorrowedComponentName {
+    /** PrimeReact's `Column` - one column of a data table, given a `field` and a `header`. */
+    Column = 'column',
+}

package/ComponentName.ts

@@ -0,0 +1,27 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * The bare names this package declares components under.
+ *
+ * There is exactly one, and that is the design rather than an unfinished list. This blueprint's value is
+ * in its **templates** - a `dataPage` already wired to a query, a `commandForm` page with its action bar -
+ * and a template is data a host can rearrange. A component is code it cannot. So the rule this package
+ * holds itself to is: register a component only when a template's content tree genuinely cannot express
+ * the composition, and reach for a template every other time. A blueprint whose value sat in its
+ * components rather than its templates would have misunderstood its job.
+ *
+ * {@link ArcPageHeader} is the one thing that clears that bar. Everything else in this package is a tree.
+ */
+export enum ComponentName {
+    /**
+     * A page header that derives its heading, its subtitle and its breadcrumb trail from **one** binding
+     * name, and reports whether that binding is registered.
+     *
+     * A content tree cannot do this. It can hold a title, a subtitle and a trail as three literals, but
+     * it cannot *derive* them from a single `query`/`command` property, and it certainly cannot look that
+     * name up in the binding registry to say whether a host has wired it. Both are behavior at render
+     * time, not structure - which is exactly the line this package uses to decide what earns a component.
+     */
+    ArcPageHeader = 'arcPageHeader',
+}

package/CompositeName.ts

@@ -0,0 +1,97 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * The `Cratis.Components` names this blueprint's templates are built from.
+ *
+ * These are not this package's names - `Cratis.Components` declares every one of them, and this blueprint
+ * only writes them into its templates. They are collected here anyway, for two reasons.
+ *
+ * The first is the ordinary one: a bare name written inline is a magic string, and a typo in it renders as
+ * a dashed red box in the middle of a screen with nothing pointing back at the template that caused it.
+ *
+ * The second is what makes this worth an enum rather than a comment. A spec asserts that every member
+ * below appears in `cratisComponentsPackageManifest.components`, so this file is a standing check that
+ * this blueprint and the component library it is built from still agree. If a name is ever renamed
+ * upstream, that spec fails here rather than a screen failing silently in someone's application.
+ *
+ * A screen template writes bare names on purpose: `resolveComponentName` decides which active package
+ * wins each one against the profile's priority order, so a template that qualified its names would pin
+ * itself to one library and stop being a template.
+ */
+export enum CompositeName {
+    /** The library's page primitive - a full-height column whose optional panel chrome matches everything inside it. */
+    Page = 'page',
+
+    /** The whole list-screen composite: title bar, menubar, filterable table and optional details pane, all from one query. */
+    DataPage = 'dataPage',
+
+    /** A table that performs a query, pages against the server, and wires filtering and sorting back into it. */
+    DataTable = 'dataTable',
+
+    /** The live variant - an observable query, a WebSocket subscription, and a re-render when the read model changes. */
+    ObservableDataTable = 'observableDataTable',
+
+    /** A form generated from a command's own property descriptors, so it follows the command rather than going stale. */
+    CommandForm = 'commandForm',
+
+    /** A single-line text field bound to one command property. */
+    InputTextField = 'inputTextField',
+
+    /** A numeric field bound to one command property. */
+    NumberField = 'numberField',
+
+    /** A multi-line text field bound to one command property. */
+    TextAreaField = 'textAreaField',
+
+    /** A single-selection field over a list the screen carries inline. */
+    DropdownField = 'dropdownField',
+
+    /** A date field bound to one command property. */
+    CalendarField = 'calendarField',
+
+    /** The Arc-aware dialog, whose result resolves through Arc's dialog context rather than through `visible` state. */
+    Dialog = 'dialog',
+
+    /** A dialog whose confirm button *is* the command's execution - it submits, feeds validation back, and only closes on success. */
+    CommandDialog = 'commandDialog',
+
+    /** The blocking spinner shown while a long-running command is in flight. */
+    BusyIndicatorDialog = 'busyIndicatorDialog',
+
+    /** An icon, with the shorthand forms people actually write normalized into the class PrimeIcons expects. */
+    Icon = 'icon',
+
+    /** A standalone selection control, not bound to a command property. */
+    Dropdown = 'dropdown',
+
+    /** Scopes a failure to a region, so one broken widget does not take the screen with it. */
+    ErrorBoundary = 'errorBoundary',
+
+    /** Renders an arbitrary JSON document against its schema, with a control per declared type. */
+    ObjectContentEditor = 'objectContentEditor',
+
+    /** The trail that says where you are inside a nested document, and lets you climb back out. */
+    ObjectNavigationalBar = 'objectNavigationalBar',
+
+    /** Edits a JSON schema as a typed property tree rather than as text. */
+    SchemaEditor = 'schemaEditor',
+
+    /** Scrubs through successive versions of something on a timeline. */
+    TimeMachine = 'timeMachine',
+
+    /** The filter toggle and the panel it anchors, as one placeable element. */
+    FilterPanel = 'filterPanel',
+
+    /** The container for a tool palette, which also establishes the drag context its buttons read. */
+    Toolbar = 'toolbar',
+
+    /** One button in a tool palette. */
+    ToolbarButton = 'toolbarButton',
+
+    /** Related buttons kept together inside a toolbar. */
+    ToolbarGroup = 'toolbarGroup',
+
+    /** The divider between groups of tools. */
+    ToolbarSeparator = 'toolbarSeparator',
+}

package/README.md

@@ -0,0 +1,40 @@
+# Scene
+
+The object model and runtime for Screenplay-based UIs: `Scene.Model` (platform-agnostic screens, layouts,
+forms, contribution points, ui profiles and themes), `Scene.Engine` (binding/resolution runtime), and
+`Scene.React` (the React renderer).
+
+## Packages / Deployables
+
+[![Nuget](https://img.shields.io/nuget/v/Cratis.Scene.Model?logo=nuget)](http://nuget.org/packages/Cratis.Scene.Model)
+[![NPM](https://img.shields.io/npm/v/@cratis/scene.model?label=@cratis/scene.model&logo=npm)](https://www.npmjs.com/package/@cratis/scene.model)
+[![NPM](https://img.shields.io/npm/v/@cratis/scene.engine?label=@cratis/scene.engine&logo=npm)](https://www.npmjs.com/package/@cratis/scene.engine)
+[![NPM](https://img.shields.io/npm/v/@cratis/scene.react?label=@cratis/scene.react&logo=npm)](https://www.npmjs.com/package/@cratis/scene.react)
+
+## Builds
+
+[![.NET Build](https://github.com/cratis/scene/actions/workflows/dotnet-build.yml/badge.svg)](https://github.com/cratis/scene/actions/workflows/dotnet-build.yml)
+[![JavaScript Build](https://github.com/cratis/scene/actions/workflows/javascript-build.yml/badge.svg)](https://github.com/cratis/scene/actions/workflows/javascript-build.yml)
+
+## Description
+
+Scene owns the *object model and runtime* half of the Screenplay stack. `Scene.Model` is the platform-agnostic
+C# object model that Stage translates Screenplay's parsed language constructs into, and that Studio's
+design-time tooling reads and writes. `Scene.Engine` walks that graph, resolves bindings (data, action, form,
+navigation contribution) and drives whichever renderer is plugged in — it does not know React exists.
+`Scene.React` is one renderer implementing the abstract vocabulary against real React/DOM; sibling positions
+are reserved for future `Scene.Native` / `Scene.Desktop` renderers. Vendor and internal component packages
+(PrimeReact, internal widget libraries) are adapters plugging into the renderer contract, not part of it.
+
+The design-time editor built on top of this object model lives in Studio, not here — see
+[StudioIssues#156](https://github.com/Cratis/StudioIssues/issues/156).
+
+## Support
+
+Cratis is an open community, and we are glad to help users, teams evaluating the stack, and contributors.
+
+| Channel | Details |
+|---|---|
+| Discord | Join the community on [Discord](https://discord.gg/kt4AMpV8WV) for questions and discussions |
+| GitHub Issues | [Report bugs or request features](https://github.com/Cratis/Scene/issues) |
+| Documentation | Read the docs at [cratis.io](https://cratis.io) |

package/componentsBlueprint.ts

@@ -0,0 +1,72 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { PackageKind, ScenePackage } from '@cratis/scene.model';
+import { ScenePackageBundle } from '@cratis/scene.react';
+import { ComponentName } from './ComponentName';
+import { componentsBlueprintComponents } from './componentsBlueprintComponents';
+import { componentsGalleryScreens } from './gallery';
+import { componentsBlueprintName } from './packageName';
+import { componentsDialogTemplates, componentsScreenTemplates } from './templates';
+
+/**
+ * This blueprint's declaration.
+ *
+ * Where the default blueprint answers "what does an application look like", this one answers "what does a
+ * *page* look like once it is bound to Arc". Its templates are whole pages already wired to the composites
+ * in `Cratis.Components`: a data list page is a `dataPage` with its query, columns, empty message, data key
+ * and filter fields all decided, under a header that says what it is bound to. An application picks the
+ * template and supplies a query name.
+ *
+ * `layouts` is empty, and that is the most important line in this file.
+ *
+ * A layout is an application's base navigational shell, and an application has exactly one. This package
+ * deliberately ships none: it depends on `Cratis.Blueprint.Default` and reuses that blueprint's `AppShell`,
+ * its slot vocabulary, its shell components and its themes. That is what the dependency on another
+ * blueprint *means* - and this is the first blueprint-on-blueprint dependency in Scene, so it is worth
+ * stating plainly rather than leaving to be inferred from an empty array.
+ *
+ * The alternative would have been to ship a second application shell. It would have looked like value and
+ * been the opposite: an application can activate only one shell, so the two blueprints would have become
+ * mutually exclusive, and picking Arc-bound pages would have meant giving up the eight layout modes, the
+ * themes and the navigation that the default blueprint already does well. Layering means both can be
+ * active at once, which is the only arrangement in which either is worth having.
+ *
+ * `themes` is empty for the same reason at a smaller scale: the shell being themed is the default
+ * blueprint's, so its themes are the right ones, and a theme shipped here would be this package asserting
+ * a look for a shell it does not own.
+ */
+export const componentsBlueprintManifest: ScenePackage = {
+    name: componentsBlueprintName,
+    version: '1.0.0',
+    kind: PackageKind.Blueprint,
+    dependencies: [{ name: 'Cratis.Blueprint.Default' }, { name: 'Cratis.Components' }],
+    components: Object.values(ComponentName),
+    layouts: [],
+    screenTemplates: componentsScreenTemplates.map(template => template.name),
+    dialogTemplates: componentsDialogTemplates.map(template => template.name),
+    themes: [],
+    displayName: 'Cratis Components Blueprint',
+    description: 'Arc-bound screen and dialog templates: whole pages built from the Cratis Components composites, for the default blueprint shell.',
+    module: '@cratis/scene.blueprint.components',
+};
+
+/**
+ * This blueprint as a loadable bundle.
+ *
+ * The manifest names things; this provides them. `validatePackageBundle` is what proves the two agree, and
+ * this package's specs run it - a manifest promising a template the bundle never provided is a failure that
+ * only shows up when someone picks that template and gets nothing.
+ *
+ * The screens are the gallery: real `Screen` instances naming the default blueprint's `AppShell`, its
+ * chrome and one of these templates, so a preview boots them through the real engine as a working
+ * miniature application rather than a set of pictures. They render with unregistered bindings, which is the
+ * normal design-time state - the placeholders naming each wanted binding are exactly what should be there.
+ */
+export const componentsBlueprint: ScenePackageBundle = {
+    manifest: componentsBlueprintManifest,
+    components: componentsBlueprintComponents,
+    screenTemplates: componentsScreenTemplates,
+    dialogTemplates: componentsDialogTemplates,
+    screens: componentsGalleryScreens,
+};

package/componentsBlueprintComponents.ts

@@ -0,0 +1,23 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ComponentRegistry, componentRegistryKey } from '@cratis/scene.react';
+import { ComponentName } from './ComponentName';
+import { componentsBlueprintName } from './packageName';
+import { ArcPageHeader } from './header';
+
+/**
+ * The components this package registers, keyed the way the renderer looks them up.
+ *
+ * Every key is built with `componentRegistryKey` rather than written out, because the separator between
+ * package and component name is the registry's own business - it is deliberately not the `.` a screen uses
+ * to qualify a name, so that a package name containing dots stays unambiguous. Building a key by hand is
+ * how a component ends up registered under something no lookup will ever produce.
+ *
+ * One entry, and a short registry is the healthy outcome here rather than a gap. What this blueprint
+ * contributes is templates; a component only appears when a template genuinely could not express the
+ * composition, and `validatePackageBundle` proves that whatever *is* here is also declared in the manifest.
+ */
+export const componentsBlueprintComponents: ComponentRegistry = {
+    [componentRegistryKey(componentsBlueprintName, ComponentName.ArcPageHeader)]: ArcPageHeader,
+};

package/dist/cjs/BorrowedComponentName.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * Names this blueprint's templates reference that come from neither `Cratis.Components` nor itself.
+ *
+ * There is one, and it is worth stating why rather than leaving it as a bare string in a builder.
+ *
+ * `Cratis.Components`' data table and data page take their columns as children - the library's own
+ * documentation says the columns arrive in the `content` slot - but the library declares no `column` name
+ * of its own, because its tables are `DataTableForQuery` wrapping PrimeReact's `DataTable`, and a column
+ * is PrimeReact's `Column`. So a template that wants a table with real columns has to name PrimeReact's,
+ * and this blueprint's manifest declares PrimeReact as a dependency partly for that reason.
+ *
+ * It is checked the same way every other borrowed name in this repository is: against the owning
+ * package's own manifest, by a spec, rather than assumed. The default blueprint learned that the hard way
+ * when it referenced `chart` and `fileUpload`, which neither library declares.
+ */ var BorrowedComponentName = /*#__PURE__*/ function(BorrowedComponentName) {
+    /** PrimeReact's `Column` - one column of a data table, given a `field` and a `header`. */ BorrowedComponentName["Column"] = "column";
+    return BorrowedComponentName;
+}({});
+
+exports.BorrowedComponentName = BorrowedComponentName;
+//# sourceMappingURL=BorrowedComponentName.js.map

package/dist/cjs/BorrowedComponentName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BorrowedComponentName.js","sources":["../../BorrowedComponentName.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/**\n * Names this blueprint's templates reference that come from neither `Cratis.Components` nor itself.\n *\n * There is one, and it is worth stating why rather than leaving it as a bare string in a builder.\n *\n * `Cratis.Components`' data table and data page take their columns as children - the library's own\n * documentation says the columns arrive in the `content` slot - but the library declares no `column` name\n * of its own, because its tables are `DataTableForQuery` wrapping PrimeReact's `DataTable`, and a column\n * is PrimeReact's `Column`. So a template that wants a table with real columns has to name PrimeReact's,\n * and this blueprint's manifest declares PrimeReact as a dependency partly for that reason.\n *\n * It is checked the same way every other borrowed name in this repository is: against the owning\n * package's own manifest, by a spec, rather than assumed. The default blueprint learned that the hard way\n * when it referenced `chart` and `fileUpload`, which neither library declares.\n */\nexport enum BorrowedComponentName {\n    /** PrimeReact's `Column` - one column of a data table, given a `field` and a `header`. */\n    Column = 'column',\n}\n"],"names":["BorrowedComponentName"],"mappings":";;AAAA;AACA;AAEA;;;;;;;;;;;;;;IAeO,IAAKA,qBAAAA,iBAAAA,SAAAA,qBAAAA,EAAAA;+FACgF,qBAAA,CAAA,QAAA,CAAA,GAAA,QAAA;AADhFA,IAAAA,OAAAA,qBAAAA;AAGX,CAAA,CAAA,EAAA;;;;"}

package/dist/cjs/ComponentName.js

@@ -0,0 +1,30 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The bare names this package declares components under.
+ *
+ * There is exactly one, and that is the design rather than an unfinished list. This blueprint's value is
+ * in its **templates** - a `dataPage` already wired to a query, a `commandForm` page with its action bar -
+ * and a template is data a host can rearrange. A component is code it cannot. So the rule this package
+ * holds itself to is: register a component only when a template's content tree genuinely cannot express
+ * the composition, and reach for a template every other time. A blueprint whose value sat in its
+ * components rather than its templates would have misunderstood its job.
+ *
+ * {@link ArcPageHeader} is the one thing that clears that bar. Everything else in this package is a tree.
+ */ var ComponentName = /*#__PURE__*/ function(ComponentName) {
+    /**
+     * A page header that derives its heading, its subtitle and its breadcrumb trail from **one** binding
+     * name, and reports whether that binding is registered.
+     *
+     * A content tree cannot do this. It can hold a title, a subtitle and a trail as three literals, but
+     * it cannot *derive* them from a single `query`/`command` property, and it certainly cannot look that
+     * name up in the binding registry to say whether a host has wired it. Both are behavior at render
+     * time, not structure - which is exactly the line this package uses to decide what earns a component.
+     */ ComponentName["ArcPageHeader"] = "arcPageHeader";
+    return ComponentName;
+}({});
+
+exports.ComponentName = ComponentName;
+//# sourceMappingURL=ComponentName.js.map

package/dist/cjs/ComponentName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentName.js","sources":["../../ComponentName.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/**\n * The bare names this package declares components under.\n *\n * There is exactly one, and that is the design rather than an unfinished list. This blueprint's value is\n * in its **templates** - a `dataPage` already wired to a query, a `commandForm` page with its action bar -\n * and a template is data a host can rearrange. A component is code it cannot. So the rule this package\n * holds itself to is: register a component only when a template's content tree genuinely cannot express\n * the composition, and reach for a template every other time. A blueprint whose value sat in its\n * components rather than its templates would have misunderstood its job.\n *\n * {@link ArcPageHeader} is the one thing that clears that bar. Everything else in this package is a tree.\n */\nexport enum ComponentName {\n    /**\n     * A page header that derives its heading, its subtitle and its breadcrumb trail from **one** binding\n     * name, and reports whether that binding is registered.\n     *\n     * A content tree cannot do this. It can hold a title, a subtitle and a trail as three literals, but\n     * it cannot *derive* them from a single `query`/`command` property, and it certainly cannot look that\n     * name up in the binding registry to say whether a host has wired it. Both are behavior at render\n     * time, not structure - which is exactly the line this package uses to decide what earns a component.\n     */\n    ArcPageHeader = 'arcPageHeader',\n}\n"],"names":["ComponentName"],"mappings":";;AAAA;AACA;AAEA;;;;;;;;;;;IAYO,IAAKA,aAAAA,iBAAAA,SAAAA,aAAAA,EAAAA;AACR;;;;;;;;AAQC,QAAA,aAAA,CAAA,eAAA,CAAA,GAAA,eAAA;AATOA,IAAAA,OAAAA,aAAAA;AAWX,CAAA,CAAA,EAAA;;;;"}

package/dist/cjs/CompositeName.js

@@ -0,0 +1,52 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The `Cratis.Components` names this blueprint's templates are built from.
+ *
+ * These are not this package's names - `Cratis.Components` declares every one of them, and this blueprint
+ * only writes them into its templates. They are collected here anyway, for two reasons.
+ *
+ * The first is the ordinary one: a bare name written inline is a magic string, and a typo in it renders as
+ * a dashed red box in the middle of a screen with nothing pointing back at the template that caused it.
+ *
+ * The second is what makes this worth an enum rather than a comment. A spec asserts that every member
+ * below appears in `cratisComponentsPackageManifest.components`, so this file is a standing check that
+ * this blueprint and the component library it is built from still agree. If a name is ever renamed
+ * upstream, that spec fails here rather than a screen failing silently in someone's application.
+ *
+ * A screen template writes bare names on purpose: `resolveComponentName` decides which active package
+ * wins each one against the profile's priority order, so a template that qualified its names would pin
+ * itself to one library and stop being a template.
+ */ var CompositeName = /*#__PURE__*/ function(CompositeName) {
+    /** The library's page primitive - a full-height column whose optional panel chrome matches everything inside it. */ CompositeName["Page"] = "page";
+    /** The whole list-screen composite: title bar, menubar, filterable table and optional details pane, all from one query. */ CompositeName["DataPage"] = "dataPage";
+    /** A table that performs a query, pages against the server, and wires filtering and sorting back into it. */ CompositeName["DataTable"] = "dataTable";
+    /** The live variant - an observable query, a WebSocket subscription, and a re-render when the read model changes. */ CompositeName["ObservableDataTable"] = "observableDataTable";
+    /** A form generated from a command's own property descriptors, so it follows the command rather than going stale. */ CompositeName["CommandForm"] = "commandForm";
+    /** A single-line text field bound to one command property. */ CompositeName["InputTextField"] = "inputTextField";
+    /** A numeric field bound to one command property. */ CompositeName["NumberField"] = "numberField";
+    /** A multi-line text field bound to one command property. */ CompositeName["TextAreaField"] = "textAreaField";
+    /** A single-selection field over a list the screen carries inline. */ CompositeName["DropdownField"] = "dropdownField";
+    /** A date field bound to one command property. */ CompositeName["CalendarField"] = "calendarField";
+    /** The Arc-aware dialog, whose result resolves through Arc's dialog context rather than through `visible` state. */ CompositeName["Dialog"] = "dialog";
+    /** A dialog whose confirm button *is* the command's execution - it submits, feeds validation back, and only closes on success. */ CompositeName["CommandDialog"] = "commandDialog";
+    /** The blocking spinner shown while a long-running command is in flight. */ CompositeName["BusyIndicatorDialog"] = "busyIndicatorDialog";
+    /** An icon, with the shorthand forms people actually write normalized into the class PrimeIcons expects. */ CompositeName["Icon"] = "icon";
+    /** A standalone selection control, not bound to a command property. */ CompositeName["Dropdown"] = "dropdown";
+    /** Scopes a failure to a region, so one broken widget does not take the screen with it. */ CompositeName["ErrorBoundary"] = "errorBoundary";
+    /** Renders an arbitrary JSON document against its schema, with a control per declared type. */ CompositeName["ObjectContentEditor"] = "objectContentEditor";
+    /** The trail that says where you are inside a nested document, and lets you climb back out. */ CompositeName["ObjectNavigationalBar"] = "objectNavigationalBar";
+    /** Edits a JSON schema as a typed property tree rather than as text. */ CompositeName["SchemaEditor"] = "schemaEditor";
+    /** Scrubs through successive versions of something on a timeline. */ CompositeName["TimeMachine"] = "timeMachine";
+    /** The filter toggle and the panel it anchors, as one placeable element. */ CompositeName["FilterPanel"] = "filterPanel";
+    /** The container for a tool palette, which also establishes the drag context its buttons read. */ CompositeName["Toolbar"] = "toolbar";
+    /** One button in a tool palette. */ CompositeName["ToolbarButton"] = "toolbarButton";
+    /** Related buttons kept together inside a toolbar. */ CompositeName["ToolbarGroup"] = "toolbarGroup";
+    /** The divider between groups of tools. */ CompositeName["ToolbarSeparator"] = "toolbarSeparator";
+    return CompositeName;
+}({});
+
+exports.CompositeName = CompositeName;
+//# sourceMappingURL=CompositeName.js.map

package/dist/cjs/CompositeName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompositeName.js","sources":["../../CompositeName.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/**\n * The `Cratis.Components` names this blueprint's templates are built from.\n *\n * These are not this package's names - `Cratis.Components` declares every one of them, and this blueprint\n * only writes them into its templates. They are collected here anyway, for two reasons.\n *\n * The first is the ordinary one: a bare name written inline is a magic string, and a typo in it renders as\n * a dashed red box in the middle of a screen with nothing pointing back at the template that caused it.\n *\n * The second is what makes this worth an enum rather than a comment. A spec asserts that every member\n * below appears in `cratisComponentsPackageManifest.components`, so this file is a standing check that\n * this blueprint and the component library it is built from still agree. If a name is ever renamed\n * upstream, that spec fails here rather than a screen failing silently in someone's application.\n *\n * A screen template writes bare names on purpose: `resolveComponentName` decides which active package\n * wins each one against the profile's priority order, so a template that qualified its names would pin\n * itself to one library and stop being a template.\n */\nexport enum CompositeName {\n    /** The library's page primitive - a full-height column whose optional panel chrome matches everything inside it. */\n    Page = 'page',\n\n    /** The whole list-screen composite: title bar, menubar, filterable table and optional details pane, all from one query. */\n    DataPage = 'dataPage',\n\n    /** A table that performs a query, pages against the server, and wires filtering and sorting back into it. */\n    DataTable = 'dataTable',\n\n    /** The live variant - an observable query, a WebSocket subscription, and a re-render when the read model changes. */\n    ObservableDataTable = 'observableDataTable',\n\n    /** A form generated from a command's own property descriptors, so it follows the command rather than going stale. */\n    CommandForm = 'commandForm',\n\n    /** A single-line text field bound to one command property. */\n    InputTextField = 'inputTextField',\n\n    /** A numeric field bound to one command property. */\n    NumberField = 'numberField',\n\n    /** A multi-line text field bound to one command property. */\n    TextAreaField = 'textAreaField',\n\n    /** A single-selection field over a list the screen carries inline. */\n    DropdownField = 'dropdownField',\n\n    /** A date field bound to one command property. */\n    CalendarField = 'calendarField',\n\n    /** The Arc-aware dialog, whose result resolves through Arc's dialog context rather than through `visible` state. */\n    Dialog = 'dialog',\n\n    /** A dialog whose confirm button *is* the command's execution - it submits, feeds validation back, and only closes on success. */\n    CommandDialog = 'commandDialog',\n\n    /** The blocking spinner shown while a long-running command is in flight. */\n    BusyIndicatorDialog = 'busyIndicatorDialog',\n\n    /** An icon, with the shorthand forms people actually write normalized into the class PrimeIcons expects. */\n    Icon = 'icon',\n\n    /** A standalone selection control, not bound to a command property. */\n    Dropdown = 'dropdown',\n\n    /** Scopes a failure to a region, so one broken widget does not take the screen with it. */\n    ErrorBoundary = 'errorBoundary',\n\n    /** Renders an arbitrary JSON document against its schema, with a control per declared type. */\n    ObjectContentEditor = 'objectContentEditor',\n\n    /** The trail that says where you are inside a nested document, and lets you climb back out. */\n    ObjectNavigationalBar = 'objectNavigationalBar',\n\n    /** Edits a JSON schema as a typed property tree rather than as text. */\n    SchemaEditor = 'schemaEditor',\n\n    /** Scrubs through successive versions of something on a timeline. */\n    TimeMachine = 'timeMachine',\n\n    /** The filter toggle and the panel it anchors, as one placeable element. */\n    FilterPanel = 'filterPanel',\n\n    /** The container for a tool palette, which also establishes the drag context its buttons read. */\n    Toolbar = 'toolbar',\n\n    /** One button in a tool palette. */\n    ToolbarButton = 'toolbarButton',\n\n    /** Related buttons kept together inside a toolbar. */\n    ToolbarGroup = 'toolbarGroup',\n\n    /** The divider between groups of tools. */\n    ToolbarSeparator = 'toolbarSeparator',\n}\n"],"names":["CompositeName"],"mappings":";;AAAA;AACA;AAEA;;;;;;;;;;;;;;;;;IAkBO,IAAKA,aAAAA,iBAAAA,SAAAA,aAAAA,EAAAA;yHAC0G,aAAA,CAAA,MAAA,CAAA,GAAA,MAAA;gIAGO,aAAA,CAAA,UAAA,CAAA,GAAA,UAAA;kHAGd,aAAA,CAAA,WAAA,CAAA,GAAA,WAAA;0HAGQ,aAAA,CAAA,qBAAA,CAAA,GAAA,qBAAA;0HAGA,aAAA,CAAA,aAAA,CAAA,GAAA,aAAA;mEAGvD,aAAA,CAAA,gBAAA,CAAA,GAAA,gBAAA;0DAGT,aAAA,CAAA,aAAA,CAAA,GAAA,aAAA;kEAGQ,aAAA,CAAA,eAAA,CAAA,GAAA,eAAA;2EAGS,aAAA,CAAA,eAAA,CAAA,GAAA,eAAA;uDAGpB,aAAA,CAAA,eAAA,CAAA,GAAA,eAAA;yHAGkE,aAAA,CAAA,QAAA,CAAA,GAAA,QAAA;uIAGc,aAAA,CAAA,eAAA,CAAA,GAAA,eAAA;iFAGtD,aAAA,CAAA,qBAAA,CAAA,GAAA,qBAAA;iHAGgC,aAAA,CAAA,MAAA,CAAA,GAAA,MAAA;4EAGrC,aAAA,CAAA,UAAA,CAAA,GAAA,UAAA;gGAGoB,aAAA,CAAA,eAAA,CAAA,GAAA,eAAA;oGAGI,aAAA,CAAA,qBAAA,CAAA,GAAA,qBAAA;oGAGA,aAAA,CAAA,uBAAA,CAAA,GAAA,uBAAA;6EAGvB,aAAA,CAAA,cAAA,CAAA,GAAA,cAAA;0EAGH,aAAA,CAAA,aAAA,CAAA,GAAA,aAAA;iFAGO,aAAA,CAAA,aAAA,CAAA,GAAA,aAAA;uGAGsB,aAAA,CAAA,SAAA,CAAA,GAAA,SAAA;yCAG9D,aAAA,CAAA,eAAA,CAAA,GAAA,eAAA;2DAGkB,aAAA,CAAA,cAAA,CAAA,GAAA,cAAA;gDAGX,aAAA,CAAA,kBAAA,CAAA,GAAA,kBAAA;AAzEjCA,IAAAA,OAAAA,aAAAA;AA2EX,CAAA,CAAA,EAAA;;;;"}

package/dist/cjs/componentsBlueprint.js

@@ -0,0 +1,93 @@
+'use strict';
+
+var scene_model = require('@cratis/scene.model');
+var ComponentName = require('./ComponentName.js');
+var componentsBlueprintComponents = require('./componentsBlueprintComponents.js');
+require('./gallery/navigation.js');
+require('@cratis/scene.blueprint.default');
+var screens = require('./gallery/screens.js');
+require('./gallery/previewProfile.js');
+require('./gallery/GalleryScreenPreview.js');
+require('react/jsx-runtime');
+require('react');
+require('@cratis/scene.react');
+require('./templates/listTemplates.js');
+require('./templates/workspaceTemplates.js');
+require('./templates/commandTemplates.js');
+require('./templates/editorTemplates.js');
+require('./templates/nesting.js');
+var dialogTemplates = require('./templates/dialogTemplates.js');
+var screenTemplates = require('./templates/screenTemplates.js');
+var packageName = require('./packageName.js');
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * This blueprint's declaration.
+ *
+ * Where the default blueprint answers "what does an application look like", this one answers "what does a
+ * *page* look like once it is bound to Arc". Its templates are whole pages already wired to the composites
+ * in `Cratis.Components`: a data list page is a `dataPage` with its query, columns, empty message, data key
+ * and filter fields all decided, under a header that says what it is bound to. An application picks the
+ * template and supplies a query name.
+ *
+ * `layouts` is empty, and that is the most important line in this file.
+ *
+ * A layout is an application's base navigational shell, and an application has exactly one. This package
+ * deliberately ships none: it depends on `Cratis.Blueprint.Default` and reuses that blueprint's `AppShell`,
+ * its slot vocabulary, its shell components and its themes. That is what the dependency on another
+ * blueprint *means* - and this is the first blueprint-on-blueprint dependency in Scene, so it is worth
+ * stating plainly rather than leaving to be inferred from an empty array.
+ *
+ * The alternative would have been to ship a second application shell. It would have looked like value and
+ * been the opposite: an application can activate only one shell, so the two blueprints would have become
+ * mutually exclusive, and picking Arc-bound pages would have meant giving up the eight layout modes, the
+ * themes and the navigation that the default blueprint already does well. Layering means both can be
+ * active at once, which is the only arrangement in which either is worth having.
+ *
+ * `themes` is empty for the same reason at a smaller scale: the shell being themed is the default
+ * blueprint's, so its themes are the right ones, and a theme shipped here would be this package asserting
+ * a look for a shell it does not own.
+ */ const componentsBlueprintManifest = {
+    name: packageName.componentsBlueprintName,
+    version: '1.0.0',
+    kind: scene_model.PackageKind.Blueprint,
+    dependencies: [
+        {
+            name: 'Cratis.Blueprint.Default'
+        },
+        {
+            name: 'Cratis.Components'
+        }
+    ],
+    components: Object.values(ComponentName.ComponentName),
+    layouts: [],
+    screenTemplates: screenTemplates.componentsScreenTemplates.map((template)=>template.name),
+    dialogTemplates: dialogTemplates.componentsDialogTemplates.map((template)=>template.name),
+    themes: [],
+    displayName: 'Cratis Components Blueprint',
+    description: 'Arc-bound screen and dialog templates: whole pages built from the Cratis Components composites, for the default blueprint shell.',
+    module: '@cratis/scene.blueprint.components'
+};
+/**
+ * This blueprint as a loadable bundle.
+ *
+ * The manifest names things; this provides them. `validatePackageBundle` is what proves the two agree, and
+ * this package's specs run it - a manifest promising a template the bundle never provided is a failure that
+ * only shows up when someone picks that template and gets nothing.
+ *
+ * The screens are the gallery: real `Screen` instances naming the default blueprint's `AppShell`, its
+ * chrome and one of these templates, so a preview boots them through the real engine as a working
+ * miniature application rather than a set of pictures. They render with unregistered bindings, which is the
+ * normal design-time state - the placeholders naming each wanted binding are exactly what should be there.
+ */ const componentsBlueprint = {
+    manifest: componentsBlueprintManifest,
+    components: componentsBlueprintComponents.componentsBlueprintComponents,
+    screenTemplates: screenTemplates.componentsScreenTemplates,
+    dialogTemplates: dialogTemplates.componentsDialogTemplates,
+    screens: screens.componentsGalleryScreens
+};
+
+exports.componentsBlueprint = componentsBlueprint;
+exports.componentsBlueprintManifest = componentsBlueprintManifest;
+//# sourceMappingURL=componentsBlueprint.js.map