@salsita-ai/sdk 0.50.0-develop.7d4723b0a5 → 0.50.0-develop.85e8f9df39

package/dist/react-sdk/domain-context/system-hooks/navigation-hooks.js

@@ -1 +1 @@
-import{useCallback as t}from"react";import{useDomain as e}from"../common-hooks/use-domain-context.js";import{useStoreSelector as o}from"../common-hooks/use-store-selector.js";export const useActiveNavigationState=()=>{let{navigationSystem:t}=e();return o(e=>t.getActiveNavigationState(e.state),[t])};export const useActiveViewState=()=>{let{navigationSystem:t}=e();return o(e=>t.getActiveViewState(e.state),[t])};export const useActiveToolState=()=>{let{navigationSystem:t}=e();return o(e=>t.getActiveToolState(e.state),[t])};export const useIsFullscreenActive=()=>{let{navigationSystem:t}=e();return o(e=>t.getActiveFullscreenState(e.state),[t])};export const useDraggedDomainEntityId=()=>{let{navigationSystem:t}=e();return o(e=>t.getActiveDragState(e.state),[t])};export const useActiveViewports=()=>{let{navigationSystem:t}=e();return o(e=>t.getActiveViewportState(e.state),[t])};export const useNavigate=()=>{let{storeSystem:o,navigationSystem:a}=e();return t(t=>{o.stageAndCommit([a.getNavigationUpdate(t)])},[o,a])};export const usePushNavigate=()=>{let{storeSystem:o,navigationSystem:a}=e();return t(t=>{o.stageAndCommit([a.getPushNavigationUpdate(t,o.stateSlices.committed.value.state)])},[o,a])};export const usePopNavigate=()=>{let{storeSystem:o,navigationSystem:a}=e();return t(()=>{let t=a.getPopNavigationUpdate(o.stateSlices.committed.value.state);t&&o.stageAndCommit([t])},[o,a])};
+import{useCallback as t}from"react";import{useDomain as e}from"../common-hooks/use-domain-context.js";import{useStoreSelector as o}from"../common-hooks/use-store-selector.js";export const useActiveNavigationState=()=>{let{navigationSystem:t}=e();return o(e=>t.getActiveNavigationState(e.state),[t])};export const useActiveViewState=()=>{let{navigationSystem:t}=e();return o(e=>t.getActiveViewState(e.state),[t])};export const useSetViewState=()=>{let{storeSystem:o,navigationSystem:s}=e();return t(t=>{o.stageAndCommit([s.getViewUpdate(t)])},[o,s])};export const useActiveToolState=()=>{let{navigationSystem:t}=e();return o(e=>t.getActiveToolState(e.state),[t])};export const useIsFullscreenActive=()=>{let{navigationSystem:t}=e();return o(e=>t.getActiveFullscreenState(e.state),[t])};export const useSetFullscreen=()=>{let{storeSystem:o,navigationSystem:s}=e();return t(t=>{o.stageAndCommit([s.getFullscreenUpdate(t)])},[o,s])};export const useDraggedDomainEntityId=()=>{let{navigationSystem:t}=e();return o(e=>t.getActiveDragState(e.state),[t])};export const useActiveViewports=()=>{let{navigationSystem:t}=e();return o(e=>t.getActiveViewportState(e.state),[t])};export const useNavigate=()=>{let{storeSystem:o,navigationSystem:s}=e();return t(t=>{o.stageAndCommit([s.getNavigationUpdate(t)])},[o,s])};export const usePushNavigate=()=>{let{storeSystem:o,navigationSystem:s}=e();return t(t=>{o.stageAndCommit([s.getPushNavigationUpdate(t,o.stateSlices.committed.value.state)])},[o,s])};export const usePopNavigate=()=>{let{storeSystem:o,navigationSystem:s}=e();return t(()=>{let t=s.getPopNavigationUpdate(o.stateSlices.committed.value.state);t&&o.stageAndCommit([t])},[o,s])};

package/dist/react-sdk/domain-context/system-hooks/step-navigation-hooks.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Where a step stands relative to the active step: before it, the active step itself, or after it.
+ */
+export type StepStatus = 'complete' | 'active' | 'upcoming';
+/**
+ * One step of the spec, ready to render.
+ */
+export interface NavigationStepEntry<NAVIGATION_STATE extends string = string> {
+    /** Position of the step in `steps`; what `goTo` takes */
+    readonly index: number;
+    /** The step's label, resolved for the active locale */
+    readonly label: string;
+    /** The step's navigation states; the step is active while one of them is */
+    readonly navigationStates: readonly NAVIGATION_STATE[];
+    /** `navigationStates[0]`, the state `goTo`, `next` and `previous` enter */
+    readonly state: NAVIGATION_STATE;
+    /** Before, at or after the active step; `'upcoming'` for every step while no step is active */
+    readonly status: StepStatus;
+}
+/**
+ * The steps of the spec and the means to move between them.
+ * - `steps`: the steps in spec order. `activeStep` and `activeIndex`: the first step whose navigation states include
+ *   the active one, or `null` and -1 while the active navigation state belongs to no step.
+ * - `isFirst` and `isLast`: whether the active step is the first or the last one; a single step is both.
+ * - `canGoNext` and `canGoPrevious`: whether a step follows or precedes the active one. While no step is active, the
+ *   next step is the first one and there is no previous step.
+ * - `next` and `previous`: enter the following or preceding step; each does nothing without one.
+ * - `goTo`: enters a step, given by its index or by any of its navigation states; an unknown step does nothing.
+ */
+export interface UseStepNavigationResult<NAVIGATION_STATE extends string = string> {
+    readonly steps: readonly NavigationStepEntry<NAVIGATION_STATE>[];
+    readonly activeStep: NavigationStepEntry<NAVIGATION_STATE> | null;
+    readonly activeIndex: number;
+    readonly isFirst: boolean;
+    readonly isLast: boolean;
+    readonly canGoNext: boolean;
+    readonly canGoPrevious: boolean;
+    readonly next: () => void;
+    readonly previous: () => void;
+    readonly goTo: (step: number | NAVIGATION_STATE) => void;
+}
+export type UseStepNavigation<NAVIGATION_STATE extends string> = () => UseStepNavigationResult<NAVIGATION_STATE>;
+/**
+ * Hook to read the steps the spec declares in `navigationSteps` and to move between them, as the built-in step
+ * buttons and the header's stepper do.
+ * - It reads the first active `navigationSteps` instance on the root entity, the one the built-in layout shows, so
+ *   several instances can be switched with `$filter`. Without one, `steps` is empty, `activeIndex` is -1 and the
+ *   actions do nothing.
+ * - A step without navigation states cannot be entered and is left out, with a warning in development.
+ * - `next` and `previous` read the committed state when they are called, so a second call before React renders
+ *   again moves one step further from where the first one arrived, never skipping a step on stale state.
+ * - Each action that enters a step pushes the analytics event of the built-in control: the next-step button's,
+ *   the previous-step button's, or the header stepper's for `goTo`. An action that does nothing pushes nothing.
+ *
+ * It enforces no order (`goTo` enters any step) and does not check read mode.
+ */
+export declare const useStepNavigation: () => UseStepNavigationResult;

package/dist/react-sdk/domain-context/system-hooks/step-navigation-hooks.js

@@ -0,0 +1 @@
+import{useCallback as t,useEffect as e,useMemo as a}from"react";import{navigationStepsComponent as o}from"#package/domain";import{FrontendAnalyticsFactory as i,useAnalyticsService as n,useIsDev as s}from"../../application-runtime/index.js";import{useResolveLocalizable as l}from"../../localizable/index.js";import{useDomain as p}from"../common-hooks/use-domain-context.js";import{useFirstRootComponent as m}from"../component-hooks/use-component.js";import{useActiveNavigationState as r}from"./navigation-hooks.js";let v=t=>t.flatMap(t=>{let e=t.navigationStates[0];return void 0===e?[]:[{step:t,state:e}]});export const useStepNavigation=()=>{var g,c;let d,u=m(o),S=r(),f=l(),h=n(),{componentReader:x,navigationSystem:N,storeSystem:k}=p(),j=a(()=>u?.state.steps??[],[u]),C=j.filter(t=>0===t.navigationStates.length);g=C.length>0,c=`The navigationSteps ${C.map(t=>`"${f(t.label)}"`).join(", ")} have no navigation states, so useStepNavigation leaves them out. Give each step at least one navigation state.`,e(()=>{d&&g&&console.warn(c)},[d=s(),g,c]);let b=a(()=>v(j),[j]),A=b.findIndex(({step:t})=>t.navigationStates.includes(S)),G=a(()=>b.map(({step:t,state:e},a)=>{let o=a<A?"complete":a===A?"active":"upcoming";return{index:a,label:f(t.label),navigationStates:t.navigationStates,state:e,status:o}}),[b,A,f]),T=t((t,e)=>{let a=k.stateSlices.committed.value.state,i=x.readFirstRootComponent({componentTypes:[o]},a),n=v(i?.state.steps??[]),s=N.getActiveNavigationState(a),l=n.findIndex(({step:t})=>t.navigationStates.includes(s)),p=n[l+t]?.state;void 0!==p&&(h.push(e()),k.stageAndCommit([N.getNavigationUpdate(p)]))},[h,x,N,k]),y=t(()=>T(1,i.NextStepButtonClicked),[T]),B=t(()=>T(-1,i.PreviousStepButtonClicked),[T]),F=t(t=>{let e="number"==typeof t?G[t]:G.find(e=>e.navigationStates.includes(t));e&&(h.push(i.TopNavigationStepClicked(e.state)),k.stageAndCommit([N.getNavigationUpdate(e.state)]))},[G,h,k,N]);return{steps:G,activeStep:G[A]??null,activeIndex:A,isFirst:0===A,isLast:-1!==A&&A===G.length-1,canGoNext:A+1<G.length,canGoPrevious:A>0,next:y,previous:B,goTo:F}};

package/dist/react-sdk/domain-context/system-hooks/tab-navigation-hooks.d.ts

@@ -0,0 +1,61 @@
+import { type ReactNode } from 'react';
+import { type DomainEntityId } from '#package/domain';
+/**
+ * The spec component a layout's tabs come from: the `sidebarTabs` of an entity, or the configurator's
+ * `horizontalTabs`.
+ */
+export type TabSource = 'sidebarTabs' | 'horizontalTabs';
+/**
+ * One tab of the spec, ready to render.
+ */
+export interface TabEntry<NAVIGATION_STATE extends string = string> {
+    /** Position of the tab in `tabs`; what `select` takes */
+    readonly index: number;
+    /** The tab's label, resolved for the active locale */
+    readonly label: string;
+    /** A PhxIcon name, when the spec gives the icon as a string */
+    readonly icon: string | undefined;
+    /** A React node, when TypeScript spec code gives the icon as one (`sidebarTabs` only) */
+    readonly iconNode: ReactNode | undefined;
+    /** The tab's navigation states; the tab is active while one of them is */
+    readonly navigationStates: readonly NAVIGATION_STATE[];
+    /** `navigationStates[0]`, the state `select` enters */
+    readonly state: NAVIGATION_STATE;
+    readonly isActive: boolean;
+}
+/**
+ * Which tabs `useTabNavigation` reads.
+ * - `source`: `'auto'` (default) reads the entity's `sidebarTabs` and, without any, the `horizontalTabs`.
+ * - `entityId`: whose `sidebarTabs` are read; the selected entity by default (the root while nothing is selected).
+ */
+export interface UseTabNavigationOptions {
+    readonly source?: 'auto' | TabSource;
+    readonly entityId?: DomainEntityId<string>;
+}
+/**
+ * The tabs of the spec and the means to switch between them.
+ * - `source`: the component the tabs come from, or `null` when no active instance of it exists.
+ * - `tabs`: the tabs in spec order. `activeTab`: the first tab whose navigation states include the active one.
+ * - `select`: enters a tab, given by its index or by any of its navigation states; an unknown tab does nothing.
+ */
+export interface UseTabNavigationResult<NAVIGATION_STATE extends string = string> {
+    readonly source: TabSource | null;
+    readonly tabs: readonly TabEntry<NAVIGATION_STATE>[];
+    readonly activeTab: TabEntry<NAVIGATION_STATE> | null;
+    readonly select: (tab: number | NAVIGATION_STATE) => void;
+}
+export type UseTabNavigation<NAVIGATION_STATE extends string> = (options?: UseTabNavigationOptions) => UseTabNavigationResult<NAVIGATION_STATE>;
+/**
+ * Hook to read the tabs the spec declares, `sidebarTabs` or `horizontalTabs`, and to switch between them, as the
+ * built-in tabs do.
+ * - `sidebarTabs`: every active instance on the entity, flattened in spec order. `horizontalTabs`: the first active
+ *   instance, on any entity.
+ * - With `source: 'auto'` and both kinds active, `sidebarTabs` win; several active `horizontalTabs` use the first.
+ *   Both log a warning in development and never throw.
+ * - A tab without navigation states cannot be entered and is left out, with a warning in development.
+ * - `select` enters the tab's first navigation state. For `horizontalTabs` it pushes the analytics event the
+ *   built-in horizontal tabs push; for `sidebarTabs` none, as the built-in sidebar tabs.
+ *
+ * It does not check read mode: switching tabs is navigation, not editing.
+ */
+export declare const useTabNavigation: (options?: UseTabNavigationOptions) => UseTabNavigationResult;

package/dist/react-sdk/domain-context/system-hooks/tab-navigation-hooks.js

@@ -0,0 +1 @@
+import{useCallback as t,useEffect as o,useMemo as a}from"react";import{horizontalTabsComponent as e,sidebarTabsComponent as i}from"#package/domain";import{FrontendAnalyticsFactory as n,useAnalyticsService as s,useIsDev as r}from"../../application-runtime/index.js";import{useResolveLocalizable as l}from"../../localizable/index.js";import{useDomain as m}from"../common-hooks/use-domain-context.js";import{useComponents as c}from"../component-hooks/use-component.js";import{useActiveNavigationState as p}from"./navigation-hooks.js";import{useSelectedDomainEntityId as b}from"./selection-hooks.js";let h=(t,a)=>{let e=r();o(()=>{e&&t&&console.warn(a)},[e,t,a])};export const useTabNavigation=(o={})=>{let{source:r="auto",entityId:v}=o,g=p(),d=b(),f=l(),u=s(),{navigationSystem:T,storeSystem:z}=m(),S=c({componentTypes:[i],entityIds:[v??d]}),j=c({componentTypes:[e]}),N="horizontalTabs"!==r&&S.length>0,k="sidebarTabs"!==r&&j.length>0,y=N?"sidebarTabs":k?"horizontalTabs":null;h(N&&k,"Both sidebarTabs and horizontalTabs are active, so useTabNavigation shows the sidebarTabs. Remove one of them from the spec, or pass `source` to choose."),h("horizontalTabs"===y&&j.length>1,"Several horizontalTabs are active, so useTabNavigation shows the first one. Keep one active, for example with $filter.");let x=a(()=>"sidebarTabs"===y?S.flatMap(t=>t.state.tabs):"horizontalTabs"===y?j[0]?.state.tabs??[]:[],[y,S,j]),w=x.filter(t=>0===t.navigationStates.length);h(w.length>0,`The ${y} tabs ${w.map(t=>`"${f(t.label)}"`).join(", ")} have no navigation states, so useTabNavigation leaves them out. Give each tab at least one navigation state.`);let $=a(()=>x.flatMap(t=>{let o=t.navigationStates[0];return void 0===o?[]:[{tab:t,state:o}]}).map(({tab:t,state:o},a)=>({index:a,label:f(t.label),icon:"string"==typeof t.icon?t.icon:void 0,iconNode:"string"==typeof t.icon||null===t.icon?void 0:t.icon,navigationStates:t.navigationStates,state:o,isActive:t.navigationStates.includes(g)})),[x,g,f]),A=$.find(t=>t.isActive)??null,C=t(t=>{let o="number"==typeof t?$[t]:$.find(o=>o.navigationStates.includes(t));o&&("horizontalTabs"===y&&u.push(n.TopNavigationStepClicked(o.state)),z.stageAndCommit([T.getNavigationUpdate(o.state)]))},[$,y,u,z,T]);return{source:y,tabs:$,activeTab:A,select:C}};

package/dist/react-sdk/domain-context/system-hooks/undo-redo-hooks.d.ts

@@ -0,0 +1,20 @@
+/**
+ * What a project layout needs to offer undo and redo.
+ * - `canUndo` and `canRedo`: whether the undo history has a step to go back or forward to; they follow every change.
+ * - `undo`: returns to the previous step and pushes the undo-button analytics event; does nothing while `canUndo`
+ *   is false.
+ * - `redo`: returns to the next step and pushes the redo-button analytics event; does nothing while `canRedo` is
+ *   false.
+ */
+export interface UseUndoRedoResult {
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    readonly undo: () => void;
+    readonly redo: () => void;
+}
+export type UseUndoRedo = () => UseUndoRedoResult;
+/**
+ * Hook to undo and redo changes of the configuration, as the built-in toolbar's undo and redo buttons do. It does
+ * not check read mode; a layout hides undo and redo for a viewer.
+ */
+export declare const useUndoRedo: UseUndoRedo;

package/dist/react-sdk/domain-context/system-hooks/undo-redo-hooks.js

@@ -0,0 +1 @@
+import{useCallback as o}from"react";import{FrontendAnalyticsFactory as e,useAnalyticsService as n}from"../../application-runtime/index.js";import{useDomain as t}from"../common-hooks/use-domain-context.js";import{useEagerObservableValue as r}from"../common-hooks/use-observable-selector.js";export const useUndoRedo=()=>{let d=n(),{undoSystem:m}=t(),{canUndo:s,canRedo:c}=r(m.can$);return{canUndo:s,canRedo:c,undo:o(()=>{m.canUndo()&&(d.push(e.UndoButtonClicked()),m.undo())},[d,m]),redo:o(()=>{m.canRedo()&&(d.push(e.RedoButtonClicked()),m.redo())},[d,m])}};

package/dist/react-sdk/domain-controls/hooks/use-angle-dimension.d.ts

@@ -2,7 +2,7 @@ import { type AnalyticsEvent, type AngleDimensionComponent, AngleUnit, type Comp
 export declare const AngleDimensionSliderUpdateTag = "setAngleDimension";
 export type IsAngleDimensionUpdate<ENTITIES extends DomainEntity<string>> = (update: StateUpdate<ENTITIES, ENTITIES>, types: ReadonlyArray<ENTITIES['type']>, instanceName: string) => update is ComponentModification<AngleDimensionComponent>;
 export declare const isAngleDimensionUpdate: (update: StateUpdate<DomainEntity<string>, DomainEntity<string>>, types: readonly string[], instanceName: string) => update is ComponentModification<AngleDimensionComponent>;
-export declare const useAngleDimension: (entityId: DomainEntityId<string>, instanceName: string, fixableViolations?: string[], createAnalyticsEvent?: (instanceName: string, entityId: DomainEntityId<string>, value: number) => AnalyticsEvent, stageOnUpdate?: boolean) => {
+export declare const useAngleDimension: (entityId: DomainEntityId<string>, instanceName: string, fixableViolations?: readonly string[], createAnalyticsEvent?: (instanceName: string, entityId: DomainEntityId<string>, value: number) => AnalyticsEvent, stageOnUpdate?: boolean) => {
     value: number;
     min: number | undefined;
     max: number | undefined;

package/dist/react-sdk/handlers/FinalizeActionRunner.d.ts

@@ -0,0 +1,13 @@
+import type { FinalizeActionsStore } from './finalize-actions-store.js';
+interface FinalizeActionRunnerProps {
+    /** The component key of the `finalizeAction` the runner runs */
+    readonly actionKey: string;
+    readonly handler: string;
+    readonly store: FinalizeActionsStore;
+}
+/**
+ * The hidden runner of one `finalizeAction`. `PhoenixHandlerBoundary` remounts it, its error boundary included,
+ * when the handler's source changes, so an edited or fixed handler takes effect without a reload.
+ */
+export declare const FinalizeActionRunner: (props: FinalizeActionRunnerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/react-sdk/handlers/FinalizeActionRunner.js

@@ -0,0 +1 @@
+import{jsx as r}from"react/jsx-runtime";import{useLayoutEffect as e}from"react";import{ErrorBoundary as n}from"react-error-boundary";import{useLogger as i}from"../application-runtime/index.js";import{PhoenixHandlerBoundary as o}from"./PhoenixHandlerBoundary.js";import{useFinalizeAction as a}from"./use-finalize-action.js";let t=({actionKey:r,handler:n,store:i})=>{let o=a(n);return e(()=>{i.publish(r,{status:"ready",action:o})}),e(()=>()=>i.remove(r),[r,i]),null},l=({actionKey:r,handler:n,store:o,error:a})=>{let t=i();return e(()=>{let e=a instanceof Error?a:Error(String(a??"The finalize handler failed."),{cause:a});return t.error(`The finalize handler "${n}" failed to load, so its finalize action cannot run.`,{error:e.message}),o.publish(r,{status:"failed",error:e}),()=>o.remove(r)},[r,a,n,t,o]),null};export const FinalizeActionRunner=e=>r(o,{name:e.handler,children:r(n,{fallbackRender:({error:n})=>r(l,{...e,error:n}),children:r(t,{...e})})});

package/dist/react-sdk/handlers/FinalizeActionsHost.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Runs the spec's finalize actions for `useFinalizeActions()`. For every active `finalizeAction` component it
+ * mounts a hidden runner, which calls `useFinalizeAction` with the component's handler and publishes its state into
+ * the enclosing `FinalizeActionsProvider`. It renders nothing.
+ *
+ * The configurator mounts it once beside the configurator layout, inside its `ModalProvider`, so a handler can use
+ * `useModal`; a project does not mount it. The handlers' hooks run here, outside the layout, so a handler uses only
+ * what the configurator provides above its layout.
+ */
+export declare const FinalizeActionsHost: () => import("react/jsx-runtime").JSX.Element | null;

package/dist/react-sdk/handlers/FinalizeActionsHost.js

@@ -0,0 +1 @@
+import{jsx as n,Fragment as i}from"react/jsx-runtime";import{useContext as t,useEffect as o}from"react";import{finalizeActionComponent as e,getComponentSnapshotKey as r}from"#package/domain";import{useLogger as a}from"../application-runtime/index.js";import{useComponents as s}from"../domain-context/index.js";import{FinalizeActionRunner as m}from"./FinalizeActionRunner.js";import{FinalizeActionsContext as l}from"./finalize-actions-context.js";export const FinalizeActionsHost=()=>{let c=t(l),p=s({componentTypes:[e]}),u=a(),d=null!==c;return(o(()=>{d||u.warn("FinalizeActionsHost is mounted outside a FinalizeActionsProvider, so it runs no finalize actions.")},[d,u]),null===c)?null:n(i,{children:p.map(i=>{let t=r(i);return n(m,{actionKey:t,handler:i.state.handler,store:c},t)})})};

package/dist/react-sdk/handlers/FinalizeActionsProvider.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+/**
+ * Holds the state of the spec's finalize actions for `useFinalizeActions()` in its children; the runners of
+ * `FinalizeActionsHost`, mounted somewhere inside it, publish into it.
+ *
+ * The configurator mounts it once above its `ModalProvider`, so a dialog a layout opens with `useModal` sees the
+ * actions too; a project does not mount it.
+ */
+export declare const FinalizeActionsProvider: ({ children }: {
+    readonly children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/react-sdk/handlers/FinalizeActionsProvider.js

@@ -0,0 +1 @@
+import{jsx as r}from"react/jsx-runtime";import{useState as i}from"react";import{FinalizeActionsContext as o}from"./finalize-actions-context.js";import{createFinalizeActionsStore as t}from"./finalize-actions-store.js";export const FinalizeActionsProvider=({children:e})=>{let[n]=i(t);return r(o.Provider,{value:n,children:e})};

package/dist/react-sdk/handlers/finalize-actions-context.d.ts

@@ -0,0 +1,6 @@
+import type { FinalizeActionsStore } from './finalize-actions-store.js';
+/**
+ * The store of the enclosing `FinalizeActionsProvider`, or `null` outside one. The built-in finalize buttons read
+ * the outcome of a run from it, which outlives the button; a layout uses `useFinalizeActions()` instead.
+ */
+export declare const FinalizeActionsContext: import("react").Context<FinalizeActionsStore | null>;

package/dist/react-sdk/handlers/finalize-actions-context.js

@@ -0,0 +1 @@
+import{createContext as t}from"react";export const FinalizeActionsContext=t(null);

package/dist/react-sdk/handlers/finalize-actions-store.d.ts

@@ -0,0 +1,23 @@
+import type { UseFinalizeActionResult } from './use-finalize-action.js';
+/**
+ * What the hidden runner of one `finalizeAction` publishes: the state of its `useFinalizeAction` call, or the error
+ * its handler threw while it was resolved, in which case the action cannot run.
+ */
+export type FinalizeActionRunnerState = {
+    readonly status: 'ready';
+    readonly action: UseFinalizeActionResult;
+} | {
+    readonly status: 'failed';
+    readonly error: Error;
+};
+/**
+ * The runner states of the active `finalizeAction` components, by component key. `FinalizeActionsProvider` owns
+ * one; the runners of `FinalizeActionsHost` publish into it and `useFinalizeActions()` reads it.
+ */
+export interface FinalizeActionsStore {
+    readonly subscribe: (listener: () => void) => () => void;
+    readonly getSnapshot: () => ReadonlyMap<string, FinalizeActionRunnerState>;
+    readonly publish: (key: string, state: FinalizeActionRunnerState) => void;
+    readonly remove: (key: string) => void;
+}
+export declare const createFinalizeActionsStore: () => FinalizeActionsStore;

package/dist/react-sdk/handlers/finalize-actions-store.js

@@ -0,0 +1 @@
+export const createFinalizeActionsStore=()=>{let t=new Map,e=new Set,a=a=>{t=a,e.forEach(t=>t())};return{subscribe:t=>(e.add(t),()=>{e.delete(t)}),getSnapshot:()=>t,publish:(e,i)=>{var n;n=t.get(e),(void 0===n||n.status!==i.status||("failed"===n.status||"failed"===i.status?"failed"!==n.status||"failed"!==i.status||n.error!==i.error:n.action.run!==i.action.run||n.action.isPending!==i.action.isPending||n.action.error!==i.action.error||n.action.disabled!==i.action.disabled||n.action.hints!==i.action.hints))&&a(new Map(t).set(e,i))},remove:e=>{if(!t.has(e))return;let i=new Map(t);i.delete(e),a(i)}}};

package/dist/react-sdk/handlers/index.d.ts

@@ -1,2 +1,8 @@
 export { usePhoenixHandler, useSystemPhoenixHandler, useSystemPhoenixAsyncHandler } from './PhoenixHandler.js';
 export { PhoenixHandlerBoundary } from './PhoenixHandlerBoundary.js';
+export { type UseFinalizeAction, type UseFinalizeActionResult, useFinalizeAction } from './use-finalize-action.js';
+export { FinalizeActionsHost } from './FinalizeActionsHost.js';
+export { FinalizeActionsProvider } from './FinalizeActionsProvider.js';
+export { FinalizeActionsContext } from './finalize-actions-context.js';
+export { type FinalizeActionRunnerState, type FinalizeActionsStore } from './finalize-actions-store.js';
+export { type FinalizeActionEntry, type UseFinalizeActions, type UseFinalizeActionsResult, useFinalizeActions, } from './use-finalize-actions.js';

package/dist/react-sdk/handlers/index.js

@@ -1 +1 @@
-export{usePhoenixHandler,useSystemPhoenixHandler,useSystemPhoenixAsyncHandler}from"./PhoenixHandler.js";export{PhoenixHandlerBoundary}from"./PhoenixHandlerBoundary.js";
+export{usePhoenixHandler,useSystemPhoenixHandler,useSystemPhoenixAsyncHandler}from"./PhoenixHandler.js";export{PhoenixHandlerBoundary}from"./PhoenixHandlerBoundary.js";export{useFinalizeAction}from"./use-finalize-action.js";export{FinalizeActionsHost}from"./FinalizeActionsHost.js";export{FinalizeActionsProvider}from"./FinalizeActionsProvider.js";export{FinalizeActionsContext}from"./finalize-actions-context.js";export{useFinalizeActions}from"./use-finalize-actions.js";

package/dist/react-sdk/handlers/use-finalize-action.d.ts

@@ -0,0 +1,32 @@
+/**
+ * What a project layout needs to show and run one `finalizeAction` of the spec.
+ * - `run`: pushes the finalize-button analytics event, then runs the action's handler. Does nothing while
+ *   `disabled` or `isPending`. The promise it returns never rejects: it resolves after the handler has settled and
+ *   React has had the chance to render the outcome, or at once when the run does nothing; a failure is `error`.
+ * - `isPending`: the handler is running.
+ * - `error`: what the handler's last run rejected with, `null` after a run that resolved and while a new run is
+ *   pending. A rejection that is not an `Error` is wrapped in one, with the rejected value as its `cause`. No snackbar
+ *   is raised; the layout shows it its own way.
+ * - `disabled` and `hints`: from `useFinalizeViolations()`; the configuration cannot be finalized while it has
+ *   a `warning` or worse, or while it is out of sync with the server, and `hints` says why.
+ *
+ * `isPending` and `error` belong to the mounted component: when it unmounts during a run, the handler keeps
+ * running, and a component mounted afterwards starts with `isPending` false and no `error`.
+ */
+export interface UseFinalizeActionResult {
+    readonly run: () => Promise<void>;
+    readonly isPending: boolean;
+    readonly error: Error | null;
+    readonly disabled: boolean;
+    readonly hints: string | undefined;
+}
+export type UseFinalizeAction = (handler: string) => UseFinalizeActionResult;
+/**
+ * Runs the project handler a `finalizeAction` component names, with the state a finalize button shows.
+ *
+ * It calls `usePhoenixHandler(handler)`, which calls the project's handler factory and the hooks inside it, so:
+ * call it once per component, never in a loop or conditionally, render one component per action, and wrap that
+ * component in `<PhoenixHandlerBoundary name={handler}>` from `@salsita-ai/sdk/react`, so an edited handler takes
+ * effect without a reload. It does not check read mode; a layout hides finalization for a viewer.
+ */
+export declare const useFinalizeAction: UseFinalizeAction;

package/dist/react-sdk/handlers/use-finalize-action.js

@@ -0,0 +1 @@
+import{useMutation as r}from"@tanstack/react-query";import{useCallback as t,useRef as e}from"react";import{FrontendAnalyticsFactory as n,useAnalyticsService as i,useLogger as a}from"../application-runtime/index.js";import{useFinalizeViolations as o}from"../domain-context/index.js";import{usePhoenixHandler as c}from"./PhoenixHandler.js";export const useFinalizeAction=s=>{let{handler:l}=c(s),m=i(),u=a(),{disabled:f,hints:d}=o(),h=e(!1),{mutateAsync:p,isPending:w,error:y}=r({mutationFn:async()=>{try{await l()}catch(r){throw r instanceof Error?r:Error(null==r?"The finalize handler failed without a reason.":String(r),{cause:r})}finally{h.current=!1}},onError:r=>{u.error("Failed to finalize",{error:r.message})}});return{run:t(async()=>{if(!f&&!h.current){h.current=!0,m.push(n.FinalizeButtonClicked());try{await p()}catch{}await new Promise(r=>setTimeout(r,0))}},[m,f,p]),isPending:w,error:y,disabled:f,hints:d}};

package/dist/react-sdk/handlers/use-finalize-actions.d.ts

@@ -0,0 +1,53 @@
+import { type FinalizeActionComponentState } from '#package/domain';
+/**
+ * One active `finalizeAction` of the spec, ready to render and run.
+ * - `key`: the stable key of the component instance, for React's `key`.
+ * - `handler`: the name of the project handler the action runs.
+ * - `variant`, `label`, `title` and `icon`: the component's fields, `label` and `title` resolved to the current
+ *   language; `icon` is a `PhxIcon` name.
+ * - `run`: pushes the finalize-button analytics event and runs the handler, as `useFinalizeAction(handler).run`
+ *   does. It does nothing while `disabled` or `isPending`. The promise it returns never rejects: it resolves once
+ *   the entry shows the outcome of the run, or at once when the run does nothing.
+ * - `isPending`: the handler is running.
+ * - `error`: what the handler's last run rejected with, as an `Error`, or `null`; cleared when the action runs
+ *   again. It is also the error the handler threw while it was loaded, when it could not be loaded at all.
+ * - `disabled`: finalizing is blocked, as in `useFinalizeViolations()`, or the handler could not be loaded.
+ */
+export interface FinalizeActionEntry {
+    readonly key: string;
+    readonly handler: string;
+    readonly variant: FinalizeActionComponentState['variant'];
+    readonly label: string;
+    readonly title: string;
+    readonly icon: string;
+    readonly run: () => Promise<void>;
+    readonly isPending: boolean;
+    readonly error: Error | null;
+    readonly disabled: boolean;
+}
+/**
+ * The spec's finalize actions for a layout.
+ * - `actions`: every active `finalizeAction` component, in spec order.
+ * - `primary`: the first `'primary'` action, else the first action, else `null`; the built-in footer's button.
+ * - `secondary`: the other actions, in spec order; the built-in footer's menu.
+ * - `disabled` and `hints`: those of `useFinalizeViolations()`.
+ */
+export interface UseFinalizeActionsResult {
+    readonly actions: readonly FinalizeActionEntry[];
+    readonly primary: FinalizeActionEntry | null;
+    readonly secondary: readonly FinalizeActionEntry[];
+    readonly disabled: boolean;
+    readonly hints: string | undefined;
+}
+export type UseFinalizeActions = () => UseFinalizeActionsResult;
+/**
+ * The spec's finalize actions, each with its own `run`, for a layout that renders its own finalize buttons. The
+ * configurator runs the handlers itself, so a layout calls this hook anywhere, as often as it likes, and renders
+ * the entries in a loop. To run a single action the layout already knows, `useFinalizeAction(handler)` works too.
+ *
+ * It needs the configurator's `FinalizeActionsProvider` and `FinalizeActionsHost`, which are mounted around and
+ * beside every configurator layout, and also reach the dialogs a layout opens with `useModal`. Outside them it
+ * returns no actions and logs a warning. It does not check read mode; a layout hides finalization for a
+ * viewer.
+ */
+export declare const useFinalizeActions: UseFinalizeActions;

package/dist/react-sdk/handlers/use-finalize-actions.js

@@ -0,0 +1 @@
+import{useContext as e,useEffect as i,useMemo as t,useSyncExternalStore as r}from"react";import{finalizeActionComponent as n,getComponentSnapshotKey as o}from"#package/domain";import{useLogger as a}from"../application-runtime/index.js";import{useComponents as s,useFinalizeViolations as l}from"../domain-context/index.js";import{useResolveLocalizable as u}from"../localizable/index.js";import{FinalizeActionsContext as d}from"./finalize-actions-context.js";let m=()=>Promise.resolve(),p=new Map,c=()=>()=>{},f=()=>p;export const useFinalizeActions=()=>{let p=e(d),g=r(p?.subscribe??c,p?.getSnapshot??f),b=s({componentTypes:[n]}),{disabled:y,hints:x}=l(),z=u(),j=a(),h=null!==p;return i(()=>{h||j.warn("useFinalizeActions() is used outside the configurator layout and its dialogs, so it returns no finalize actions. Call it inside a ConfiguratorLayout element or a dialog it opens.")},[h,j]),t(()=>{if(!h)return{actions:[],primary:null,secondary:[],disabled:y,hints:x};let e=b.map(e=>{let i=o(e),{variant:t,label:r,title:n,icon:a,handler:s}=e.state,l=g.get(i),u={key:i,handler:s,variant:t,label:z(r),title:z(n),icon:a};if(l?.status==="ready"){let{run:e,isPending:i,error:t,disabled:r}=l.action;return{...u,run:e,isPending:i,error:t,disabled:r}}return{...u,run:m,isPending:!1,error:l?.status==="failed"?l.error:null,disabled:!0}}),i=e.find(e=>"primary"===e.variant)??e[0]??null,t=e.filter(e=>e!==i);return{actions:e,primary:i,secondary:t,disabled:y,hints:x}},[b,y,h,x,z,g])};

package/dist/react-sdk/index.d.ts

@@ -8,6 +8,7 @@ export * from './invalid-deployment/index.js';
 export * from './web-component/index.js';
 export * from './localizable/index.js';
 export * from './loading-state/index.js';
+export * from './responsive-state/index.js';
 export * from './elements/index.js';
 export * from './handlers/index.js';
 export * from './application-runtime/index.js';

package/dist/react-sdk/index.js

@@ -1 +1 @@
-export*from"./theme/index.js";export*from"./utils/index.js";export*from"./session/index.js";export*from"./domain-context/index.js";export*from"./domain-application-context/index.js";export*from"./domain-controls/index.js";export*from"./invalid-deployment/index.js";export*from"./web-component/index.js";export*from"./localizable/index.js";export*from"./loading-state/index.js";export*from"./elements/index.js";export*from"./handlers/index.js";export*from"./application-runtime/index.js";
+export*from"./theme/index.js";export*from"./utils/index.js";export*from"./session/index.js";export*from"./domain-context/index.js";export*from"./domain-application-context/index.js";export*from"./domain-controls/index.js";export*from"./invalid-deployment/index.js";export*from"./web-component/index.js";export*from"./localizable/index.js";export*from"./loading-state/index.js";export*from"./responsive-state/index.js";export*from"./elements/index.js";export*from"./handlers/index.js";export*from"./application-runtime/index.js";

package/dist/react-sdk/responsive-state/ResponsiveStateProvider.d.ts

@@ -0,0 +1,25 @@
+import { type ReactNode } from 'react';
+import type { ResponsiveStateManager } from './responsive-state-manager.js';
+export declare const ResponsiveStateContext: import("react").Context<ResponsiveStateManager | null>;
+/**
+ * The props of `ResponsiveStateProvider`.
+ *
+ * @internal Runtime plumbing behind `useResponsiveState`, for the SDK's own UI. A project layout
+ * uses `useActiveViewports()` from `@salsita-ai/sdk/react` and `useSceneSafeArea()` from
+ * `@salsita-ai/sdk/configurator`.
+ */
+export interface ResponsiveStateProviderProps {
+    readonly children: ReactNode;
+    /** The responsive state of the application mounted inside. One per mounted application. */
+    readonly manager: ResponsiveStateManager;
+}
+/**
+ * Provides the responsive state of one mounted application to the lifecycle and UI inside it.
+ * Each mounted application has its own, because each has its own root container: an admin that
+ * embeds a configurator runs both in one application runtime.
+ *
+ * @internal Exists for the SDK's own UI, which reaches the runtime's responsive state through it.
+ * A project layout does not use it: it uses `useActiveViewports()` from `@salsita-ai/sdk/react`
+ * and `useSceneSafeArea()` from `@salsita-ai/sdk/configurator`.
+ */
+export declare const ResponsiveStateProvider: (props: ResponsiveStateProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react-sdk/responsive-state/ResponsiveStateProvider.js

@@ -0,0 +1 @@
+import{jsx as e}from"react/jsx-runtime";import{createContext as t}from"react";export const ResponsiveStateContext=t(null);export const ResponsiveStateProvider=t=>{let{children:r,manager:o}=t;return e(ResponsiveStateContext.Provider,{value:o,children:r})};

package/dist/react-sdk/responsive-state/canvas-padding.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The part of the canvas, in pixels from each edge, that overlay UI covers. The camera frames the
+ * scene inside what is left, so the scene stays visible beside a sidebar or under a preview body.
+ *
+ * @internal Runtime plumbing behind `useResponsiveState`, for the SDK's own UI. A project layout
+ * uses `useActiveViewports()` from `@salsita-ai/sdk/react` and `useSceneSafeArea()` from
+ * `@salsita-ai/sdk/configurator`.
+ */
+export interface CanvasPadding {
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+}

package/dist/react-sdk/responsive-state/canvas-padding.js

@@ -0,0 +1 @@
+export{};

package/dist/react-sdk/responsive-state/index.d.ts

@@ -0,0 +1,5 @@
+export { type CanvasPadding } from './canvas-padding.js';
+export { type ResponsiveBreakpoints, type ResponsiveState, ResponsiveStateManager, type ResponsiveStateManagerOptions, type ResponsiveViewport, } from './responsive-state-manager.js';
+export { ResponsiveStateProvider, type ResponsiveStateProviderProps } from './ResponsiveStateProvider.js';
+export { useResponsiveState } from './use-responsive-state.js';
+export { useResponsiveStateManager } from './use-responsive-state-manager.js';

package/dist/react-sdk/responsive-state/index.js

@@ -0,0 +1 @@
+export{ResponsiveStateManager}from"./responsive-state-manager.js";export{ResponsiveStateProvider}from"./ResponsiveStateProvider.js";export{useResponsiveState}from"./use-responsive-state.js";export{useResponsiveStateManager}from"./use-responsive-state-manager.js";

package/dist/react-sdk/responsive-state/responsive-state-manager.d.ts

@@ -0,0 +1,111 @@
+import { BehaviorSubject, type Observable } from 'rxjs';
+import type { CanvasPadding } from './canvas-padding.js';
+/**
+ * The widths, in pixels, that split the application's root container into phone, tablet and
+ * desktop. The theme decides them; the UI library pushes its theme's values in with
+ * `setBreakpoints`.
+ *
+ * @internal Runtime plumbing behind `useResponsiveState`, for the SDK's own UI. A project layout
+ * uses `useActiveViewports()` from `@salsita-ai/sdk/react` and `useSceneSafeArea()` from
+ * `@salsita-ai/sdk/configurator`.
+ */
+export interface ResponsiveBreakpoints {
+    readonly sm: number;
+    readonly md: number;
+    readonly lg: number;
+}
+/**
+ * One measurement of the application's root container. The orientation comes from the window,
+ * not from the container's aspect ratio.
+ *
+ * @internal Runtime plumbing behind `useResponsiveState`, for the SDK's own UI. A project layout
+ * uses `useActiveViewports()` from `@salsita-ai/sdk/react` and `useSceneSafeArea()` from
+ * `@salsita-ai/sdk/configurator`.
+ */
+export interface ResponsiveViewport {
+    readonly width: number;
+    readonly height: number;
+    readonly isLandscape: boolean;
+    readonly isPortrait: boolean;
+}
+/**
+ * The responsive state of one mounted application: the size classes of its root container, the
+ * canvas padding the scene is framed with, and whether the container is expanded over the host
+ * page, hidden, or in a layout animation.
+ *
+ * Every size class is `false` until the container is measured for the first time.
+ *
+ * @internal Runtime plumbing behind `useResponsiveState`, for the SDK's own UI. A project layout
+ * uses `useActiveViewports()` from `@salsita-ai/sdk/react` and `useSceneSafeArea()` from
+ * `@salsita-ai/sdk/configurator`.
+ */
+export interface ResponsiveState {
+    /** `width < sm` */
+    readonly isPhone: boolean;
+    /** `width <= md` */
+    readonly isMobile: boolean;
+    /** `sm < width < lg` */
+    readonly isTablet: boolean;
+    /** `width > md` */
+    readonly isDesktop: boolean;
+    readonly isLandscape: boolean;
+    readonly isPortrait: boolean;
+    readonly canvasPadding: CanvasPadding;
+    readonly isExpanded: boolean;
+    readonly isHidden: boolean;
+    readonly isAnimating: boolean;
+}
+/**
+ * How a `ResponsiveStateManager` starts.
+ *
+ * @internal Runtime plumbing behind `useResponsiveState`, for the SDK's own UI. A project layout
+ * uses `useActiveViewports()` from `@salsita-ai/sdk/react` and `useSceneSafeArea()` from
+ * `@salsita-ai/sdk/configurator`.
+ */
+export interface ResponsiveStateManagerOptions {
+    /** A measurement to start from, for a test or a host that knows its size up front. */
+    readonly viewport?: ResponsiveViewport;
+    /** Defaults to the Phoenix theme's breakpoints: 480, 768 and 1024. */
+    readonly breakpoints?: ResponsiveBreakpoints;
+}
+/**
+ * Holds the responsive state of one mounted application, without any UI: the UI measures its root
+ * container into it and reads it back, and the lifecycle (preview, viewport sync, the loader) reads
+ * and sets it through `useResponsiveState` and `useResponsiveStateManager`. A test sets a fixed
+ * viewport with `setViewport` and renders no UI at all.
+ *
+ * `state$` emits only when a value in `ResponsiveState` changes; a resize within one size class
+ * reaches `viewport$` alone.
+ *
+ * @internal Exists for the SDK's own UI, which reaches the runtime's responsive state through it.
+ * A project layout does not use it: it uses `useActiveViewports()` from `@salsita-ai/sdk/react`
+ * and `useSceneSafeArea()` from `@salsita-ai/sdk/configurator`.
+ */
+export declare class ResponsiveStateManager {
+    private _viewport;
+    private _breakpoints;
+    private readonly _state$;
+    /** The measured size of the root container, rounded up to whole pixels. */
+    readonly viewport$: BehaviorSubject<{
+        width: number;
+        height: number;
+    }>;
+    readonly state$: Observable<ResponsiveState>;
+    constructor(options?: ResponsiveStateManagerOptions);
+    private readonly update;
+    readonly getState: () => ResponsiveState;
+    readonly setViewport: (viewport: ResponsiveViewport) => void;
+    readonly setBreakpoints: (breakpoints: ResponsiveBreakpoints) => void;
+    readonly getCanvasPadding: () => CanvasPadding;
+    readonly setCanvasPadding: (canvasPadding: CanvasPadding) => void;
+    /** Lays the root container over the host page. */
+    readonly expand: () => void;
+    readonly collapse: () => void;
+    readonly hide: () => void;
+    readonly show: () => void;
+    /**
+     * Whether a layout animation is in flight, so the root container clips the transient overflow
+     * of motion FLIP transforms instead of flashing scrollbars on the host page.
+     */
+    readonly setAnimating: (isAnimating: boolean) => void;
+}

package/dist/react-sdk/responsive-state/responsive-state-manager.js

@@ -0,0 +1 @@
+import{BehaviorSubject as t}from"rxjs";let i={sm:480,md:768,lg:1024},s={top:0,right:0,bottom:0,left:0},e={isPhone:!1,isMobile:!1,isTablet:!1,isDesktop:!1,isLandscape:!1,isPortrait:!1},a=(t,i)=>{if(!t)return e;let{width:s}=t;return{isPhone:s<i.sm,isMobile:s<=i.md,isTablet:s<i.lg&&s>i.sm,isDesktop:s>i.md,isLandscape:t.isLandscape,isPortrait:t.isPortrait}};export class ResponsiveStateManager{_viewport;_breakpoints;_state$;viewport$;state$;constructor(e={}){this._viewport=e.viewport??null,this._breakpoints=e.breakpoints??i,this.viewport$=new t({width:Math.ceil(this._viewport?.width??0),height:Math.ceil(this._viewport?.height??0)}),this._state$=new t({...a(this._viewport,this._breakpoints),canvasPadding:s,isExpanded:!1,isHidden:!1,isAnimating:!1}),this.state$=this._state$.asObservable()}update=t=>{let i=this._state$.value,s={...i,...a(this._viewport,this._breakpoints),...t};(i.isPhone!==s.isPhone||i.isMobile!==s.isMobile||i.isTablet!==s.isTablet||i.isDesktop!==s.isDesktop||i.isLandscape!==s.isLandscape||i.isPortrait!==s.isPortrait||i.isExpanded!==s.isExpanded||i.isHidden!==s.isHidden||i.isAnimating!==s.isAnimating||i.canvasPadding.top!==s.canvasPadding.top||i.canvasPadding.right!==s.canvasPadding.right||i.canvasPadding.bottom!==s.canvasPadding.bottom||i.canvasPadding.left!==s.canvasPadding.left)&&this._state$.next(s)};getState=()=>this._state$.value;setViewport=t=>{this._viewport=t,this.update({}),this.viewport$.next({width:Math.ceil(t.width),height:Math.ceil(t.height)})};setBreakpoints=t=>{this._breakpoints=t,this.update({})};getCanvasPadding=()=>this._state$.value.canvasPadding;setCanvasPadding=t=>{this.update({canvasPadding:t})};expand=()=>{this.update({isExpanded:!0})};collapse=()=>{this.update({isExpanded:!1})};hide=()=>{this.update({isHidden:!0})};show=()=>{this.update({isHidden:!1})};setAnimating=t=>{this.update({isAnimating:t})}}

package/dist/react-sdk/responsive-state/use-responsive-state-manager.d.ts

@@ -0,0 +1,10 @@
+import type { ResponsiveStateManager } from './responsive-state-manager.js';
+/**
+ * The responsive state manager of the application this component is mounted in, to set canvas
+ * padding, expand or hide the root container, or read the state without subscribing to it.
+ *
+ * @internal Exists for the SDK's own UI, which reaches the runtime's responsive state through it.
+ * A project layout does not use it: it uses `useActiveViewports()` from `@salsita-ai/sdk/react`
+ * and `useSceneSafeArea()` from `@salsita-ai/sdk/configurator`.
+ */
+export declare const useResponsiveStateManager: () => ResponsiveStateManager;

package/dist/react-sdk/responsive-state/use-responsive-state-manager.js

@@ -0,0 +1 @@
+import{useContext as e}from"react";import{ResponsiveStateContext as t}from"./ResponsiveStateProvider.js";export const useResponsiveStateManager=()=>{let o=e(t);if(!o)throw Error("useResponsiveStateManager() found no responsive state: it is used outside a ResponsiveStateProvider. Use it inside a mounted Phoenix application, or wrap a test in <ResponsiveStateProvider manager={new ResponsiveStateManager()}>.");return o};

package/dist/react-sdk/responsive-state/use-responsive-state.d.ts

@@ -0,0 +1,11 @@
+import type { ResponsiveState } from './responsive-state-manager.js';
+/**
+ * The responsive state of the application this component is mounted in: the size classes of its
+ * root container, the canvas padding, and whether the container is expanded, hidden or animating.
+ * Re-renders when any of them changes.
+ *
+ * @internal Exists for the SDK's own UI, which reaches the runtime's responsive state through it.
+ * A project layout does not use it: it uses `useActiveViewports()` from `@salsita-ai/sdk/react`
+ * and `useSceneSafeArea()` from `@salsita-ai/sdk/configurator`.
+ */
+export declare const useResponsiveState: () => ResponsiveState;

package/dist/react-sdk/responsive-state/use-responsive-state.js

@@ -0,0 +1 @@
+import{useCallback as e,useSyncExternalStore as t}from"react";import{useResponsiveStateManager as r}from"./use-responsive-state-manager.js";export const useResponsiveState=()=>{let s=r();return t(e(e=>{let t=s.state$.subscribe(e);return()=>{t.unsubscribe()}},[s]),s.getState)};