@salsita-ai/sdk 0.50.0-develop.1492d82756 → 0.50.0-develop.1cc8da993f

package/dist/react-sdk/application-runtime/provider/ApplicationType.d.ts

@@ -6,4 +6,11 @@ interface ApplicationTypeProviderProps {
 }
 export declare const ApplicationTypeProvider: (props: ApplicationTypeProviderProps) => import("react/jsx-runtime").JSX.Element;
 export declare const useApplicationType: () => ApplicationType;
+/**
+ * The application type of the nearest `ApplicationTypeProvider`, or `null` outside one, for the
+ * hooks that some application-agnostic providers call and that have nothing to do there.
+ *
+ * @internal Runtime plumbing for the SDK's own UI.
+ */
+export declare const useOptionalApplicationType: () => ApplicationType | null;
 export {};

package/dist/react-sdk/application-runtime/provider/ApplicationType.js

@@ -1 +1 @@
-import{jsx as e}from"react/jsx-runtime";import{createContext as t,useContext as r}from"react";let o=t(null);export const ApplicationTypeProvider=t=>{let{children:r,type:p}=t;return e(o.Provider,{value:p,children:r})};export const useApplicationType=()=>{let e=r(o);if(!e)throw Error("ApplicationType context not found! useApplicationType() must be used within an ApplicationTypeProvider. Use the hook appropriately.");return e};
+import{jsx as e}from"react/jsx-runtime";import{createContext as t,useContext as o}from"react";let p=t(null);export const ApplicationTypeProvider=t=>{let{children:o,type:r}=t;return e(p.Provider,{value:r,children:o})};export const useApplicationType=()=>{let e=o(p);if(!e)throw Error("ApplicationType context not found! useApplicationType() must be used within an ApplicationTypeProvider. Use the hook appropriately.");return e};export const useOptionalApplicationType=()=>o(p);

package/dist/react-sdk/application-runtime/responsive/actions.d.ts

@@ -0,0 +1,47 @@
+import type { DomainApplicationType } from '#package/domain';
+import type { CanvasPadding, ResponsiveBreakpoints, ResponsiveRuntimeState, ResponsiveViewport } from './types.js';
+interface Context {
+    readonly setResponsive: (fn: (state: ResponsiveRuntimeState) => ResponsiveRuntimeState) => void;
+}
+/**
+ * Every action returns the slice unchanged when the value is already set, so the runtime publishes
+ * nothing and no subscriber recomputes.
+ */
+declare const createApplicationActions: (context: Context, applicationType: DomainApplicationType) => {
+    setViewport: (viewport: ResponsiveViewport) => void;
+    setBreakpoints: (breakpoints: ResponsiveBreakpoints) => void;
+    setCanvasPadding: (canvasPadding: CanvasPadding) => void;
+    expand: () => void;
+    collapse: () => void;
+    hide: () => void;
+    show: () => void;
+    setAnimating: (isAnimating: boolean) => void;
+    reset: () => void;
+};
+/** One set of actions per application, as the domain context keys its own. */
+export declare const createResponsiveActions: (context: Context) => {
+    configurator: {
+        setViewport: (viewport: ResponsiveViewport) => void;
+        setBreakpoints: (breakpoints: ResponsiveBreakpoints) => void;
+        setCanvasPadding: (canvasPadding: CanvasPadding) => void;
+        expand: () => void;
+        collapse: () => void;
+        hide: () => void;
+        show: () => void;
+        setAnimating: (isAnimating: boolean) => void;
+        reset: () => void;
+    };
+    admin: {
+        setViewport: (viewport: ResponsiveViewport) => void;
+        setBreakpoints: (breakpoints: ResponsiveBreakpoints) => void;
+        setCanvasPadding: (canvasPadding: CanvasPadding) => void;
+        expand: () => void;
+        collapse: () => void;
+        hide: () => void;
+        show: () => void;
+        setAnimating: (isAnimating: boolean) => void;
+        reset: () => void;
+    };
+};
+export type ResponsiveActions = ReturnType<typeof createApplicationActions>;
+export {};

package/dist/react-sdk/application-runtime/responsive/actions.js

@@ -0,0 +1 @@
+import{initializeResponsiveApplication as t}from"./initialize.js";let e=(e,i)=>{let n=t=>{e.setResponsive(e=>{let n=e[i],s=t(n);return s===n?e:{...e,[i]:s}})},s=t=>{n(e=>e.isExpanded===t?e:{...e,isExpanded:t})},r=t=>{n(e=>e.isHidden===t?e:{...e,isHidden:t})};return{setViewport:t=>{n(e=>{let i;return(i=e.viewport,null!==i&&i.width===t.width&&i.height===t.height&&i.isLandscape===t.isLandscape&&i.isPortrait===t.isPortrait)?e:{...e,viewport:t}})},setBreakpoints:t=>{n(e=>{let i;return(i=e.breakpoints,i.sm===t.sm&&i.md===t.md&&i.lg===t.lg)?e:{...e,breakpoints:t}})},setCanvasPadding:t=>{n(e=>{let i;return(i=e.canvasPadding,i.top===t.top&&i.right===t.right&&i.bottom===t.bottom&&i.left===t.left)?e:{...e,canvasPadding:t}})},expand:()=>{s(!0)},collapse:()=>{s(!1)},hide:()=>{r(!0)},show:()=>{r(!1)},setAnimating:t=>{n(e=>e.isAnimating===t?e:{...e,isAnimating:t})},reset:()=>{n(()=>t())}}};export const createResponsiveActions=t=>({configurator:e(t,"configurator"),admin:e(t,"admin")});

package/dist/react-sdk/application-runtime/responsive/index.d.ts

@@ -0,0 +1,4 @@
+export * from './actions.js';
+export * from './initialize.js';
+export * from './selectors.js';
+export type * from './types.js';

package/dist/react-sdk/application-runtime/responsive/index.js

@@ -0,0 +1 @@
+export*from"./actions.js";export*from"./initialize.js";export*from"./selectors.js";

package/dist/react-sdk/application-runtime/responsive/initialize.d.ts

@@ -0,0 +1,3 @@
+import type { ResponsiveApplicationState, ResponsiveRuntimeState } from './types.js';
+export declare const initializeResponsiveApplication: () => ResponsiveApplicationState;
+export declare const initializeResponsive: () => ResponsiveRuntimeState;

package/dist/react-sdk/application-runtime/responsive/initialize.js

@@ -0,0 +1 @@
+export const initializeResponsiveApplication=()=>({viewport:null,breakpoints:{sm:480,md:768,lg:1024},canvasPadding:{top:0,right:0,bottom:0,left:0},isExpanded:!1,isHidden:!1,isAnimating:!1});export const initializeResponsive=()=>({configurator:initializeResponsiveApplication(),admin:initializeResponsiveApplication()});

package/dist/react-sdk/application-runtime/responsive/selectors.d.ts

@@ -0,0 +1,20 @@
+import type { DomainApplicationType } from '#package/domain';
+import type { ResponsiveRuntimeState, ResponsiveState, ResponsiveViewportSize } from './types.js';
+export interface ResponsiveSelectorState {
+    readonly responsive: ResponsiveRuntimeState;
+}
+interface Context {
+    readonly getState: () => ResponsiveSelectorState;
+    readonly applicationType: DomainApplicationType;
+}
+/** The selectors of one application's responsive state; the runtime creates one set per application. */
+export declare const createResponsiveSelectors: (context: Context) => {
+    selectResponsiveState: import("@salsita-ai/common/utils").Selector<ResponsiveSelectorState, ResponsiveState>;
+    selectViewportSize: import("@salsita-ai/common/utils").Selector<ResponsiveSelectorState, ResponsiveViewportSize>;
+    selectCanvasPadding: import("@salsita-ai/common/utils").Selector<ResponsiveSelectorState, import("./types.js").CanvasPadding>;
+    getResponsiveState: () => ResponsiveState;
+    getViewportSize: () => ResponsiveViewportSize;
+    getCanvasPadding: () => import("./types.js").CanvasPadding;
+};
+export type ResponsiveSelectors = ReturnType<typeof createResponsiveSelectors>;
+export {};

package/dist/react-sdk/application-runtime/responsive/selectors.js

@@ -0,0 +1 @@
+import{createSelector as e}from"@salsita-ai/common/utils";export const createResponsiveSelectors=i=>{let{getState:s,applicationType:t}=i,a=e.withTypes(),o=a.leaf(e=>null!==e.responsive[t].viewport),n=a.leaf(e=>e.responsive[t].viewport?.width??0),r=a.leaf(e=>e.responsive[t].viewport?.height??0),p=a.leaf(e=>e.responsive[t].viewport?.isLandscape??!1),l=a.leaf(e=>e.responsive[t].viewport?.isPortrait??!1),v=a.leaf(e=>e.responsive[t].breakpoints),d=a.leaf(e=>e.responsive[t].canvasPadding),f=a.leaf(e=>e.responsive[t].isExpanded),g=a.leaf(e=>e.responsive[t].isHidden),h=a.leaf(e=>e.responsive[t].isAnimating),m=a([o,n,v],(e,i,s)=>e&&i<s.sm),w=a([o,n,v],(e,i,s)=>e&&i<=s.md),c=a([o,n,v],(e,i,s)=>e&&i<s.lg&&i>s.sm),u=a([o,n,v],(e,i,s)=>e&&i>s.md),P=a([m,w,c,u,p,l,d,f,g,h],(e,i,s,t,a,o,n,r,p,l)=>({isPhone:e,isMobile:i,isTablet:s,isDesktop:t,isLandscape:a,isPortrait:o,canvasPadding:n,isExpanded:r,isHidden:p,isAnimating:l})),S=a([n,r],(e,i)=>({width:Math.ceil(e),height:Math.ceil(i)}));return{selectResponsiveState:P,selectViewportSize:S,selectCanvasPadding:d,getResponsiveState:()=>P(s()),getViewportSize:()=>S(s()),getCanvasPadding:()=>d(s())}};

package/dist/react-sdk/application-runtime/responsive/types.d.ts

@@ -0,0 +1,104 @@
+/**
+ * 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 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;
+}
+/**
+ * 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 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 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 size of the application's root container, rounded up to whole pixels.
+ *
+ * @internal Runtime plumbing 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 ResponsiveViewportSize {
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * The responsive state of one mounted application: what it measured of its root container, the
+ * breakpoints that classify it, the canvas padding the scene is framed with, and whether the
+ * container is expanded over the host page, hidden, or in a layout animation.
+ *
+ * The configurator's root container writes it while it is mounted and resets it when it unmounts.
+ *
+ * @internal Runtime plumbing 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 ResponsiveApplicationState {
+    /** `null` until the root container is measured for the first time. */
+    readonly viewport: ResponsiveViewport | null;
+    readonly breakpoints: ResponsiveBreakpoints;
+    readonly canvasPadding: CanvasPadding;
+    readonly isExpanded: boolean;
+    readonly isHidden: boolean;
+    readonly isAnimating: boolean;
+}
+/**
+ * The `responsive` slice, one entry per application: an admin that embeds a configurator runs both
+ * in one runtime, and each has its own root container.
+ *
+ * @internal Runtime plumbing 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 ResponsiveRuntimeState {
+    readonly configurator: ResponsiveApplicationState;
+    readonly admin: ResponsiveApplicationState;
+}
+/**
+ * The responsive state the UI and the lifecycle read: the size classes of the root container, the
+ * canvas padding, and whether the container is expanded, hidden or animating.
+ *
+ * Every size class is `false` until the container is measured for the first time.
+ *
+ * @internal Runtime plumbing 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;
+}

package/dist/react-sdk/application-runtime/responsive/types.js

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