@cratis/stage.runtime 4.184.0 → 4.186.0

package/dist/src/stageComponents.d.ts

@@ -21,6 +21,12 @@ export declare function StageTable({ element, slots }: RegisteredProps): import(
 export { StageCommandForm };
 /** Executes a modeled command against the route the Stage registered for it. */
 export declare function StageAction({ element, interactions, slots }: RegisteredProps): import("react").JSX.Element;
+/**
+ * The task dialog of a toolbar slice button. Scene's own dialog asks for a text, a number, a switch or a date for each property of
+ * the command; a command that takes an enumeration, a record or a collection is asked through the command's own form instead - a choice, a
+ * group of fields, a list - and the identity the session acts as (the shopper's basket) is not asked for at all.
+ */
+export declare function StageSliceDialog(props: Partial<RegisteredProps>): import("react").JSX.Element;
 /**
  * The components the Stage renders a scene with: Scene's own core vocabulary, with the two that have to reach
  * this running application - the table that reads a modeled query, and the action that executes a modeled

package/dist/src/stageData.d.ts

@@ -1,8 +1,14 @@
 import type React from 'react';
 import type { BindingExpression } from '@cratis/scene.model';
 import type { StageRoutes } from './stageRoutes';
+/** Where a session keeps the identity it acts as, one per identifier concept. */
+export declare const sessionIdentifierPrefix = "stage.session.";
 interface QueryState {
     name?: string;
+    /** The read model's name, under which the rows are published to the binding scope as well - where a summary looks them up. */
+    alias?: string;
+    /** The rows are always a list in the binding scope, even when there is one: a path reads `0.count`, never `count`. */
+    list?: boolean;
     route: string;
     rows: Record<string, unknown>[];
     loading: boolean;
@@ -15,6 +21,10 @@ export interface StageQueryRequest {
     route?: string;
     arguments?: Record<string, unknown>;
     ready?: boolean;
+    /** Publishes the rows under this name too: the read model a `data` declaration shows, so a summary finds them by it. */
+    alias?: string;
+    /** Whether the rows are published to bindings as a list always, so a path such as `0.lineCount` reads the same for one row as for many. */
+    list?: boolean;
     /**
      * Whether the result is published to the screen's bindings. A query read only to decide something - the item a
      * guard is evaluated against - is not, so it does not show up twice where the screen reads the same query.
@@ -41,6 +51,10 @@ export interface StageDataState {
     clearSelection: (scope: string) => void;
     setState: (key: string, value: unknown) => void;
     setComponentOutput: (componentId: string, path: string, value: unknown) => void;
+    /** Takes what the components of the rendered tree publish (a list's selected row, a search box's text) so bindings and interactions elsewhere on the page read it. */
+    publishComponentOutputs: (outputs: Record<string, Record<string, unknown>>) => void;
+    /** The rows of every query the page has read, by scope and by query name - what a `queryResult` binding resolves against. */
+    queryResults: Record<string, unknown>;
     refreshQuery: (query?: string) => void;
     refreshAfterCommand: () => void;
     resolveBinding: (binding: BindingExpression | string | undefined) => unknown;
@@ -65,7 +79,7 @@ export interface StageDataProviderProps {
     screen: string;
     children: React.ReactNode;
 }
-export declare function StageDataProvider({ routes, routesReady, parameters, locale, locales, screen, children }: StageDataProviderProps): React.JSX.Element;
+export declare function StageDataProvider({ routes, routesReady, parameters: addressParameters, locale, locales, screen, children }: StageDataProviderProps): React.JSX.Element;
 export declare const useStageData: () => StageDataState;
 export declare function useStageQuery(request: StageQueryRequest): StageQueryResult;
 export declare function dataChanged(): void;

package/dist/src/stageFormSchema.d.ts

@@ -0,0 +1,45 @@
+/**
+ * What a command's presentation schema says about one property, in the terms a form needs: its scalar type, the
+ * values an enumeration declares, the members of a record and the element of a collection.
+ */
+export interface SchemaProperty {
+    name: string;
+    /** The identifier concept of a uuid property (`x-concept`) - `BasketId`; what a session holds one value of. */
+    identifier?: string;
+    type?: 'text' | 'number' | 'boolean' | 'date';
+    required: boolean;
+    unsupportedReason?: string;
+    /** The values an enumeration declares, in declaration order; the property is presented as a choice among them. */
+    options?: string[];
+    /** The members of a record (`PostalAddress`); the property is presented as a group of fields. */
+    members?: SchemaProperty[];
+    /** The element of a collection (`OrderLine[]`); the property is presented as a list of them. */
+    item?: SchemaProperty;
+    /** Whether a date also carries a time of day. */
+    withTime?: boolean;
+}
+/**
+ * The properties a command's JSON schema declares, with the type the native form gives each and whether it is required. A toolbar
+ * slice's task dialog is built from the same reading, so a command is the same fields wherever it is presented.
+ */
+export declare function schemaPropertiesOf(schema: string): SchemaProperty[];
+/** Humanizes a member name the way a field label reads: `postalCode` is “Postal code”. */
+export declare function humanize(name: string): string;
+/**
+ * What is missing from a record or collection a form is about to submit: a member the schema requires that holds nothing.
+ *
+ * @param property The property the value is for.
+ * @param value What the form holds for it.
+ * @param label How the property reads on the form.
+ * @returns The first message, or nothing when the value is complete.
+ */
+export declare function missingMember(property: SchemaProperty, value: unknown, label: string): string | undefined;
+/**
+ * Brings a value read from the application to the form a command takes it in: an enumeration is the name of its member, however the read
+ * model stored it (by name, by case, or by its position), and a record or a collection is the same all the way down.
+ *
+ * @param property The property the value is for.
+ * @param value What a query answered for it.
+ * @returns The value as the command takes it.
+ */
+export declare function asCommandValue(property: SchemaProperty, value: unknown): unknown;

package/dist/src/stageQueryBindings.d.ts

@@ -0,0 +1,37 @@
+import type { SceneElement } from '@cratis/scene.model';
+/**
+ * The names of the queries an element tree binds property values to - `{ kind: 'queryResult', query, path }` - wherever it is
+ * placed: a count in the shell's topbar, a figure in a template, a value in a screen.
+ *
+ * @param element The composed screen, shell included.
+ * @returns The distinct query names, in first-use order.
+ */
+export declare function queryBindingNames(element: SceneElement): string[];
+/** A modeled `data` declaration: the read model a screen shows, the query that reads it and the parameter that query is read by. */
+export interface StageDataSource {
+    typeName: string;
+    query: string;
+    by?: string;
+    route?: string;
+}
+/**
+ * The `data` declarations of an element tree - `data BasketSize via query GetBasketSize by id` - that a table or summary shows a read model through.
+ *
+ * @param element The composed screen.
+ * @returns One source for each read model, in first-use order.
+ */
+export declare function dataSourcesOf(element: SceneElement): StageDataSource[];
+/**
+ * Runs the queries that element properties are bound to.
+ *
+ * A table reads its own read model; a property bound to a query result - the basket count of a storefront's topbar - and a summary
+ * of a `data` declaration have no table to read it, so without this they would stay empty. Each distinct query is read once, follows
+ * the refresh a command triggers (so the count changes after an add to basket), and publishes its rows next to every other query's;
+ * a `data` declaration's rows are published under the read model's name, as a list.
+ *
+ * @param props.element The composed screen.
+ * @returns Nothing visible.
+ */
+export declare function StageQueryBindings({ element }: {
+    element: SceneElement;
+}): import("react").JSX.Element;

package/dist/src/stageSlices.d.ts

@@ -2,8 +2,8 @@ import type { SliceCommandField, SliceInvoker } from '@cratis/scene.react';
 import type { StageCommandOutcome } from './StageCommandOutcome';
 /**
  * The fields of a command, for the task dialog a toolbar slice button opens. They are what the command's schema declares -
- * the same reading the native command form uses - so the dialog asks for exactly what the command takes. A property the form
- * cannot present (a collection, an object) is left out rather than shown as a field that cannot be filled.
+ * the same reading the native command form uses - so the dialog asks for exactly what the command takes. A property the dialog
+ * cannot present (a collection, a record) is left out rather than shown as a field that cannot be filled.
  *
  * @param schemas The JSON schema of every modeled command, by command name.
  * @returns The fields of a command; none for a command the application does not describe.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cratis/stage.runtime",
-  "version": "4.184.0",
+  "version": "4.186.0",
   "description": "The Cratis Stage application runtime for Arc and Scene",
   "type": "module",
   "license": "MIT",