@cratis/stage.runtime 4.186.0 → 4.187.1

package/dist/src/stageComponentOutputs.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `onComponentOutputsChanged` of one rendered tree - the screen, or a dialog above it.
+ *
+ * Scene keeps the outputs of each tree it renders apart and hands over all of them on every change, so a tree publishes under a scope of its own:
+ * a dialog that opens publishes beside the screen instead of over it, and when it closes only what it published goes - the row the screen had
+ * selected still resolves.
+ *
+ * @returns The callback to hand the tree's `SceneElementView`.
+ */
+export declare function useComponentOutputsPublisher(): (outputs: Record<string, Record<string, unknown>>) => void;

package/dist/src/stageComponents.d.ts

@@ -24,7 +24,9 @@ export declare function StageAction({ element, interactions, slots }: Registered
 /**
  * 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.
+ * group of fields, a list. The identifier the command acts on - the shopper's basket - is not asked for: the session supplies it, or creates it on
+ * submit. A reference to another entity - the product an add to basket is for - is the person's to choose, and is asked for unless the screen's
+ * address or the session already supplies it; the form then submits what was not asked by the same rule.
  */
 export declare function StageSliceDialog(props: Partial<RegisteredProps>): import("react").JSX.Element;
 /**

package/dist/src/stageData.d.ts

@@ -1,8 +1,6 @@
 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. */
@@ -43,7 +41,14 @@ export interface StageDataState {
     screen: string;
     routes: StageRoutes | undefined;
     routesReady: boolean;
+    /** The parameters the screen's address carries - and nothing else. */
     parameters: Record<string, string>;
+    /**
+     * The identities the session acts as, by the name a screen parameter gives them (`basketId`). They are not the screen's parameters: only
+     * what reads the session on purpose does - a form populating the identity it does not show, the key a `data` declaration is read by
+     * when the address does not carry it (`screen.keys.<name>` in a binding), and the query bindings the session narrows.
+     */
+    session: Record<string, string>;
     queries: Record<string, QueryState>;
     selected: Record<string, unknown> | undefined;
     selections: Record<string, Record<string, unknown> | undefined>;
@@ -51,8 +56,14 @@ 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;
+    /**
+     * Takes what the components of one rendered tree publish (a list's selected row, a search box's text) so bindings and interactions elsewhere
+     * on the page read it. The screen and a dialog above it are each a tree of their own, so each publishes under its own scope and replaces only
+     * what it published before; see `useComponentOutputsPublisher`.
+     */
+    publishComponentOutputs: (scope: string, outputs: Record<string, Record<string, unknown>>) => void;
+    /** Forgets what a rendered tree published, once it is gone - a closed dialog - leaving what every other tree published. */
+    withdrawComponentOutputs: (scope: string) => 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;

package/dist/src/stageDataSources.d.ts

@@ -7,9 +7,9 @@ export declare const dataComponent = "core:data";
  * A screen declares its data once - `data CommentsForWorkItem by workItemId` - and the table that follows it in
  * the same section, or any section nested after it, shows that read model. The table itself only names the read
  * model type, so without this it would read the unfiltered collection: every comment of every work item. This
- * carries the declaration's query and its `by` parameter onto the table, bound to the screen parameter of the
- * same name, so the table reads only what the declaration asked for and reads nothing while that parameter has
- * no value.
+ * carries the declaration's query and its `by` parameter onto the table, bound to the screen's key of the same
+ * name - the address's parameter, or the session's identity of that name - so the table reads only what the
+ * declaration asked for and reads nothing while that key has no value.
  *
  * @param element The composed screen.
  * @returns The screen with every fed table bound to its declaration.

package/dist/src/stageFormSchema.d.ts

@@ -6,6 +6,11 @@ export interface SchemaProperty {
     name: string;
     /** The identifier concept of a uuid property (`x-concept`) - `BasketId`; what a session holds one value of. */
     identifier?: string;
+    /**
+     * Whether this is the identifier the command acts on (`x-identity`) - the basket an add to basket appends to - rather than a reference to
+     * another entity, such as the product it adds. Only the schema a task dialog is built from says so.
+     */
+    identity?: boolean;
     type?: 'text' | 'number' | 'boolean' | 'date';
     required: boolean;
     unsupportedReason?: string;

package/dist/src/stageSession.d.ts

@@ -0,0 +1,25 @@
+/** Where a session keeps the identity it acts as, one per identifier concept. */
+export declare const sessionIdentifierPrefix = "stage.session.";
+/**
+ * The identity the session already holds for an identifier concept - the shopper's basket - without creating one.
+ *
+ * @param concept The identifier concept, as the command's schema names it: `BasketId`.
+ * @returns The identity, or nothing when the session holds none or storage is refused.
+ */
+export declare function heldSessionIdentity(concept: string): string | undefined;
+/**
+ * The identity the session acts as for an identifier concept: the one it holds, or a new one it keeps from now on - the same basket for
+ * every add, change and checkout in this browser, a different one in another.
+ *
+ * @param concept The identifier concept, as the command's schema names it: `BasketId`.
+ * @returns The identity.
+ */
+export declare function sessionIdentity(concept: string): string;
+/**
+ * Every identity the session holds, by the name a screen parameter gives it: `stage.session.BasketId` is `basketId`. These are not the
+ * screen's parameters - only what reads the session on purpose (a form's hidden identifiers, a `data` declaration the address does not key)
+ * reads them.
+ *
+ * @returns The identities, by parameter name.
+ */
+export declare function sessionIdentities(): Record<string, string>;

package/package.json

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