@cratis/stage.runtime 4.190.1 → 4.190.3

package/dist/src/StageCommandForm.d.ts

@@ -1,4 +1,5 @@
 import type { ExternalComponent, FormField } from '@cratis/scene.model';
+import type { StageDataState } from './stageData';
 import { schemaPropertiesOf } from './stageFormSchema';
 import type { SchemaProperty } from './stageFormSchema';
 export { schemaPropertiesOf };
@@ -27,8 +28,16 @@ export declare function StageCommandForm({ element }: StageCommandFormProps): im
  * A schema that marks the identifier the command acts on (`x-identity`, a task dialog's) says which one that is: only it is created, and a
  * reference to another entity gets only what the address or the session supplies. A schema that marks none - an authored form's - leaves
  * every identifier it does not show to the session, as it always has.
+ *
+ * The address wins, then the selected row, then the identity the session already holds: a row the person selected is the entity the action is
+ * about, even when the session holds another one. An identifier that a row the person could select carries (`selectableRows`) names an entity
+ * that already exists: with no row selected the session does not invent it, so the value stays missing until a row is chosen. The identifier
+ * a task dialog acts on (`x-identity`) is still created - the basket a shopper starts - even when a row on the screen shows the same name.
+ *
+ * An action on a list (`rowAction`) acts on the row the person selected, whatever the schema marks: an identifier a row carries comes from the
+ * address or the selected row only - never from the session, and is never created.
  */
-export declare function sessionIdentifiers(fields: FormField[], schema: SchemaProperty[], parameters: Record<string, string>, selectedRows?: Record<string, unknown>[]): StageCommandContent;
+export declare function sessionIdentifiers(fields: FormField[], schema: SchemaProperty[], parameters: Record<string, string>, selectedRows?: Record<string, unknown>[], selectableRows?: Record<string, unknown>[], rowAction?: boolean): StageCommandContent;
 /**
  * Whether a task dialog leaves an identifier out of what it asks: the identifier the command acts on (`x-identity`) - the shopper's basket,
  * which the session supplies or creates - or one the address or the session already supplies. Every other identifier is a reference to
@@ -58,3 +67,19 @@ export declare function suppliedIdentifier(property: SchemaProperty, parameters:
  * @returns The selected row's value, or nothing when no selected row (or more than one, differently) carries one.
  */
 export declare function selectedIdentifier(property: SchemaProperty, selectedRows: Record<string, unknown>[]): string | undefined;
+/** Whether a row the person could select carries a property of this name - the key of an entity that already exists on the screen. */
+export declare function carriedBy(property: SchemaProperty, rows: Record<string, unknown>[]): boolean;
+/** The rows of every query the screen has read: the rows a table shows and the person could select. */
+export declare function selectableRowsOf(queries: StageDataState['queries']): Record<string, unknown>[];
+/**
+ * The required identifiers a command acts on that the form does not show and that a selectable row supplies, and for which no row has been
+ * selected yet and nothing else (the screen's address) supplies them. A toolbar action with any of these waits for a selected row - also when
+ * the schema marks it as the identifier the command acts on (`x-identity`), which the host does for every modeled command.
+ *
+ * @param schema The command's properties.
+ * @param parameters The screen's address parameters.
+ * @param selectedRows The rows currently selected on the screen.
+ * @param selectableRows The rows the person could select.
+ * @returns The names of the identifiers still waiting for a selection.
+ */
+export declare function identifiersAwaitingSelection(schema: SchemaProperty[], parameters: Record<string, string>, selectedRows: Record<string, unknown>[], selectableRows: Record<string, unknown>[]): string[];

package/dist/src/StageConfirmDialog.d.ts

@@ -0,0 +1,11 @@
+import type { ExternalComponent } from '@cratis/scene.model';
+interface StageConfirmDialogProps {
+    element: ExternalComponent;
+}
+/**
+ * A screen that confirms a decision: its title, a button for each decision and, once one is chosen, only that decision's form. The entity the
+ * decision is about is the screen's, so the identifier the command acts on is not asked for - the address, the selected row or the identity the action creates supplies it - and a
+ * successful decision takes the person to the screen the action names.
+ */
+export declare function StageConfirmDialog({ element }: StageConfirmDialogProps): import("react").JSX.Element;
+export {};

package/dist/src/commandExecutor.d.ts

@@ -1,14 +1,10 @@
 import { type ArcConfiguration } from '@cratis/arc.react';
 import { Command, type ICommandResult } from '@cratis/arc/commands';
 import type { StageCommandOutcome } from './StageCommandOutcome';
+import { hostedBasePath } from './hostedBasePath';
+export { hostedBasePath };
 /** Resolves only native Arc command proxies; unrelated registry entries cannot execute. */
 export declare function registeredCommand(name: string, typeName?: string, route?: string): (new () => Command) | undefined;
-/**
- * The path the page is served under, without a trailing slash: empty at the root of a host, `/api/play/{id}` when a
- * reverse proxy (Studio's Play) hangs the Stage off a prefix. Registered command routes start with `/`, so without this
- * they would be posted to the root of the proxy's host instead of to the Stage.
- */
-export declare function hostedBasePath(): string;
 /**
  * Points a command at the path the page is served under when Arc was not given a base path. Arc's own command form builds its command from
  * Arc's default configuration, whose empty base path posts to the root of the host - Studio's Play at `/api/play/{id}/` refused that with `405`.

package/dist/src/hostedBasePath.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The path the page is served under, without a trailing slash: empty at the root of a host, `/api/play/{id}` when a
+ * reverse proxy (Studio's Play) hangs the Stage off a prefix. Registered command and query routes start with `/`, so without
+ * this they would go to the root of the proxy's host instead of to the Stage.
+ */
+export declare function hostedBasePath(): string;
+/** Arc's default configuration carries an empty base path, so an empty one means "not configured" just like an absent one. */
+export declare function apiBasePathFor(arcApiBasePath?: string): string;