@salsita-ai/sdk 0.50.0-develop.9440e83ee3 → 0.50.0-develop.95b896fd8c

package/dist/react-sdk/application-runtime/host-properties/host-property-descriptors.d.ts

@@ -0,0 +1,21 @@
+import { type WebComponentPropertyDescriptor, type WebComponentSelectors } from '#package/domain';
+import { type MirroredHostPropertyName } from './host-property-scopes.js';
+import type { HostPropertiesSelectors } from './selectors.js';
+import type { HostPropertyValue } from './types.js';
+export declare const hostPropertyDescriptors: {
+    readonly [NAME in MirroredHostPropertyName]: WebComponentPropertyDescriptor<HostPropertyValue<NAME>>;
+};
+/** The runtime selectors of the two slices that keep mirrored properties. */
+interface MirroredHostPropertySelectors {
+    readonly hostProperties: HostPropertiesSelectors;
+    readonly webComponent: WebComponentSelectors;
+}
+/** Reads a mirrored property's current value from the slice its scope names. */
+export type MirroredHostPropertyReader<T> = (selectors: MirroredHostPropertySelectors) => T;
+/**
+ * The reader of the mirrored property a descriptor stands for, or `null` when the runtime does not
+ * mirror it. The map keys each reader by its own descriptor, so a reader returns its descriptor's
+ * value type; a `Map` cannot state that per entry, so the overload states it once here.
+ */
+export declare function findMirroredHostPropertyReader<T>(descriptor: WebComponentPropertyDescriptor<T>): MirroredHostPropertyReader<T> | null;
+export {};

package/dist/react-sdk/application-runtime/host-properties/host-property-descriptors.js

@@ -0,0 +1 @@
+import{standardWebComponentProperties as e}from"#package/domain";import{getDomainHostProperty as o}from"./domain-host-properties.js";import{domainHostPropertyNames as r,hostPropertyNames as t}from"./host-property-scopes.js";export const hostPropertyDescriptors={route:e.route,expanded:e.expanded,mode:e.mode,power:e.power,presetTags:e.presetTags,locale:e.locale,readonly:e.readonly,integrationMode:e.integrationMode,sessionToken:e.sessionToken,adminSessionToken:e.adminSessionToken,refreshToken:e.refreshToken,authorizationCode:e.authorizationCode};let s=new Map([...t.map(e=>[hostPropertyDescriptors[e],o=>o.hostProperties.getHostProperty(e)]),...r.map(e=>[hostPropertyDescriptors[e],r=>o(r.webComponent,e)])]);export function findMirroredHostPropertyReader(e){return s.get(e)??null}

package/dist/react-sdk/application-runtime/host-properties/host-property-scopes.d.ts

@@ -0,0 +1,42 @@
+import { standardWebComponentProperties } from '#package/domain';
+/**
+ * Where the runtime keeps a standard web-component property's current value:
+ * - `element`: only on the element, read from its property storage.
+ * - `application`: mirrored into the application runtime's `hostProperties` slice.
+ * - `domain`: mirrored into the domain runtime's `webComponent` slice, for domain systems that
+ *   read it without the application runtime.
+ */
+type HostPropertyScope = 'element' | 'application' | 'domain';
+type StandardPropertyName = keyof typeof standardWebComponentProperties;
+declare const hostPropertyScopes: {
+    readonly readonly: 'domain';
+    readonly locale: 'domain';
+    readonly route: 'application';
+    readonly expanded: 'application';
+    readonly mode: 'application';
+    readonly power: 'application';
+    readonly presetTags: 'application';
+    readonly integrationMode: 'application';
+    readonly sessionToken: 'application';
+    readonly adminSessionToken: 'application';
+    readonly refreshToken: 'application';
+    readonly authorizationCode: 'application';
+    readonly onEvent: 'element';
+    readonly onAttached: 'element';
+    readonly nonce: 'element';
+    readonly modalZIndex: 'element';
+    readonly containerZIndex: 'element';
+    readonly htmlFontSize: 'element';
+};
+type ScopedPropertyName<SCOPE extends HostPropertyScope> = {
+    [NAME in StandardPropertyName]: (typeof hostPropertyScopes)[NAME] extends SCOPE ? NAME : never;
+}[StandardPropertyName];
+/** The name of a standard web-component property the runtime mirrors into `hostProperties`. */
+export type HostPropertyName = ScopedPropertyName<'application'>;
+/** The name of a standard web-component property the runtime mirrors into the domain's `webComponent`. */
+export type DomainHostPropertyName = ScopedPropertyName<'domain'>;
+/** The name of a standard web-component property the runtime mirrors, into either slice. */
+export type MirroredHostPropertyName = HostPropertyName | DomainHostPropertyName;
+export declare const hostPropertyNames: ScopedPropertyName<"application">[];
+export declare const domainHostPropertyNames: ScopedPropertyName<"domain">[];
+export {};

package/dist/react-sdk/application-runtime/host-properties/host-property-scopes.js

@@ -0,0 +1 @@
+import{standardWebComponentProperties as e}from"#package/domain";let o={readonly:"domain",locale:"domain",route:"application",expanded:"application",mode:"application",power:"application",presetTags:"application",integrationMode:"application",sessionToken:"application",adminSessionToken:"application",refreshToken:"application",authorizationCode:"application",onEvent:"element",onAttached:"element",nonce:"element",modalZIndex:"element",containerZIndex:"element",htmlFontSize:"element"},n=e=>n=>o[n]===e,t=Object.keys(e).filter(o=>Object.hasOwn(e,o));export const hostPropertyNames=t.filter(n("application"));export const domainHostPropertyNames=t.filter(n("domain"));

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

@@ -0,0 +1,8 @@
+export * from './actions.js';
+export * from './connect-host-properties.js';
+export * from './domain-host-properties.js';
+export * from './host-property-descriptors.js';
+export * from './host-property-scopes.js';
+export * from './initialize.js';
+export * from './selectors.js';
+export type * from './types.js';

package/dist/react-sdk/application-runtime/host-properties/index.js

@@ -0,0 +1 @@
+export*from"./actions.js";export*from"./connect-host-properties.js";export*from"./domain-host-properties.js";export*from"./host-property-descriptors.js";export*from"./host-property-scopes.js";export*from"./initialize.js";export*from"./selectors.js";

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

@@ -0,0 +1,7 @@
+import type { WebComponentApi } from '../web-component/index.js';
+import type { HostPropertiesState } from './types.js';
+/**
+ * The element's current property values. Without a web component the API's storages hold the
+ * defaults, so the slice does too.
+ */
+export declare const initializeHostProperties: (webComponentApi: WebComponentApi) => HostPropertiesState;

package/dist/react-sdk/application-runtime/host-properties/initialize.js

@@ -0,0 +1 @@
+import{hostPropertyDescriptors as e}from"./host-property-descriptors.js";export const initializeHostProperties=o=>{let r=r=>o.getPropertyValue(e[r]);return{route:r("route"),expanded:r("expanded"),mode:r("mode"),power:r("power"),presetTags:r("presetTags"),integrationMode:r("integrationMode"),sessionToken:r("sessionToken"),adminSessionToken:r("adminSessionToken"),refreshToken:r("refreshToken"),authorizationCode:r("authorizationCode")}};

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

@@ -0,0 +1,54 @@
+import { type Selector } from '@salsita-ai/common/utils';
+import type { HostPropertyName } from './host-property-scopes.js';
+import type { HostPropertiesState } from './types.js';
+export interface HostPropertiesSelectorState {
+    readonly hostProperties: HostPropertiesState;
+}
+interface Context {
+    readonly getState: () => HostPropertiesSelectorState;
+}
+type HostPropertySelectors = {
+    readonly [NAME in HostPropertyName]: Selector<HostPropertiesSelectorState, HostPropertiesState[NAME]>;
+};
+export declare const createHostPropertiesSelectors: (context: Context) => {
+    getHostPropertySelector: <NAME extends HostPropertyName>(name: NAME) => HostPropertySelectors[NAME];
+    selectRoute: Selector<HostPropertiesSelectorState, {
+        route: "Index";
+    } | {
+        route: "Configuration";
+        configurationId: string;
+        accessToken?: string | undefined;
+    } | {
+        readonly route: "Index";
+    }>;
+    selectExpanded: Selector<HostPropertiesSelectorState, boolean>;
+    selectMode: Selector<HostPropertiesSelectorState, "admin" | "configurator" | "standalone-admin">;
+    selectPower: Selector<HostPropertiesSelectorState, "off" | "on" | "standby">;
+    selectPresetTags: Selector<HostPropertiesSelectorState, string[] | null>;
+    selectIntegrationMode: Selector<HostPropertiesSelectorState, "handoff" | "headless" | "page" | "widget">;
+    selectSessionToken: Selector<HostPropertiesSelectorState, string | undefined>;
+    selectAdminSessionToken: Selector<HostPropertiesSelectorState, string | undefined>;
+    selectRefreshToken: Selector<HostPropertiesSelectorState, string | undefined>;
+    selectAuthorizationCode: Selector<HostPropertiesSelectorState, string | undefined>;
+    getHostProperty: <NAME extends HostPropertyName>(name: NAME) => HostPropertiesState[NAME];
+    getRoute: () => {
+        route: "Index";
+    } | {
+        route: "Configuration";
+        configurationId: string;
+        accessToken?: string | undefined;
+    } | {
+        readonly route: "Index";
+    };
+    getExpanded: () => boolean;
+    getMode: () => "admin" | "configurator" | "standalone-admin";
+    getPower: () => "off" | "on" | "standby";
+    getPresetTags: () => string[] | null;
+    getIntegrationMode: () => "handoff" | "headless" | "page" | "widget";
+    getSessionToken: () => string | undefined;
+    getAdminSessionToken: () => string | undefined;
+    getRefreshToken: () => string | undefined;
+    getAuthorizationCode: () => string | undefined;
+};
+export type HostPropertiesSelectors = ReturnType<typeof createHostPropertiesSelectors>;
+export {};

package/dist/react-sdk/application-runtime/host-properties/selectors.js

@@ -0,0 +1 @@
+import{createSelector as e}from"@salsita-ai/common/utils";export const createHostPropertiesSelectors=o=>{let{getState:t}=o,s=e.withTypes(),r={route:s.leaf(e=>e.hostProperties.route),expanded:s.leaf(e=>e.hostProperties.expanded),mode:s.leaf(e=>e.hostProperties.mode),power:s.leaf(e=>e.hostProperties.power),presetTags:s.leaf(e=>e.hostProperties.presetTags),integrationMode:s.leaf(e=>e.hostProperties.integrationMode),sessionToken:s.leaf(e=>e.hostProperties.sessionToken),adminSessionToken:s.leaf(e=>e.hostProperties.adminSessionToken),refreshToken:s.leaf(e=>e.hostProperties.refreshToken),authorizationCode:s.leaf(e=>e.hostProperties.authorizationCode)},n=e=>r[e];return{getHostPropertySelector:n,selectRoute:r.route,selectExpanded:r.expanded,selectMode:r.mode,selectPower:r.power,selectPresetTags:r.presetTags,selectIntegrationMode:r.integrationMode,selectSessionToken:r.sessionToken,selectAdminSessionToken:r.adminSessionToken,selectRefreshToken:r.refreshToken,selectAuthorizationCode:r.authorizationCode,getHostProperty:e=>n(e)(t()),getRoute:()=>r.route(t()),getExpanded:()=>r.expanded(t()),getMode:()=>r.mode(t()),getPower:()=>r.power(t()),getPresetTags:()=>r.presetTags(t()),getIntegrationMode:()=>r.integrationMode(t()),getSessionToken:()=>r.sessionToken(t()),getAdminSessionToken:()=>r.adminSessionToken(t()),getRefreshToken:()=>r.refreshToken(t()),getAuthorizationCode:()=>r.authorizationCode(t())}};

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

@@ -0,0 +1,18 @@
+import type { WebComponentPropertyDescriptor, standardWebComponentProperties } from '#package/domain';
+import type { HostPropertyName, MirroredHostPropertyName } from './host-property-scopes.js';
+type StandardWebComponentProperties = typeof standardWebComponentProperties;
+type PropertyValue<DESCRIPTOR> = DESCRIPTOR extends WebComponentPropertyDescriptor<infer T> ? T : never;
+/** The value type of a mirrored standard web-component property. */
+export type HostPropertyValue<NAME extends MirroredHostPropertyName> = PropertyValue<StandardWebComponentProperties[NAME]>;
+/**
+ * The current value of each application-scoped standard web-component property, as the host set
+ * it on the element, or the property's default. The domain-scoped ones, `readonly` and `locale`,
+ * live in the domain's `webComponent` slice instead.
+ *
+ * A read mirror: the element's property storage stays the single store, and writes keep going
+ * through the element setters.
+ */
+export type HostPropertiesState = {
+    readonly [NAME in HostPropertyName]: HostPropertyValue<NAME>;
+};
+export {};

package/dist/react-sdk/application-runtime/host-properties/types.js

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

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

@@ -4,7 +4,10 @@ export * from './hooks/index.js';
 export * from './web-component/index.js';
 export * from './common-services/index.js';
 export * from './domain-application-context/index.js';
+export type { HostPropertiesState, HostPropertyName } from './host-properties/index.js';
 export * from './integration/index.js';
+export { type LoadingActions, type LoadingApplicationState, type LoadingPhase, type LoadingRuntimeState, type LoadingState, } from './loading/index.js';
+export { type CanvasPadding, type ResponsiveApplicationState, type ResponsiveBreakpoints, type ResponsiveRuntimeState, type ResponsiveState, type ResponsiveViewport, type ResponsiveViewportSize, } from './responsive/index.js';
 export * from './routing/index.js';
 export * from './session/index.js';
 export * from './mocks/index.js';

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

@@ -0,0 +1,45 @@
+import type { DomainApplicationType } from '#package/domain';
+import type { LoadingPhase, LoadingRuntimeState } from './types.js';
+interface Context {
+    readonly setLoading: (fn: (state: LoadingRuntimeState) => LoadingRuntimeState) => 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) => {
+    startPhase: (phase: LoadingPhase) => void;
+    endPhase: (id: string) => void;
+    reportError: () => void;
+    clearError: () => void;
+    expectPhase: (id: string) => void;
+    dropExpectation: (id: string) => void;
+    resetSlot: () => void;
+};
+/** One set of actions per application, as the domain context keys its own. */
+export declare const createLoadingActions: (context: Context) => {
+    configurator: {
+        startPhase: (phase: LoadingPhase) => void;
+        endPhase: (id: string) => void;
+        reportError: () => void;
+        clearError: () => void;
+        expectPhase: (id: string) => void;
+        dropExpectation: (id: string) => void;
+        resetSlot: () => void;
+    };
+    admin: {
+        startPhase: (phase: LoadingPhase) => void;
+        endPhase: (id: string) => void;
+        reportError: () => void;
+        clearError: () => void;
+        expectPhase: (id: string) => void;
+        dropExpectation: (id: string) => void;
+        resetSlot: () => void;
+    };
+};
+/**
+ * @internal Runtime plumbing for the SDK's own UI. A project reports a phase with
+ * `phx.frontend.useLoadingState()`.
+ */
+export type LoadingActions = ReturnType<typeof createApplicationActions>;
+export {};

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

@@ -0,0 +1 @@
+import{initializeLoadingApplication as e}from"./initialize.js";let t=(e,t)=>e.has(t)?e:new Set([...e,t]),s=(s,r)=>{let a=e=>{s.setLoading(t=>{let s=t[r],a=e(s);return a===s?t:{...t,[r]:a}})},n=e=>{a(t=>t.hasError===e?t:{...t,hasError:e})};return{startPhase:e=>{a(s=>{let r=((e,t)=>{let s=e.findIndex(e=>e.id===t.id);if(-1===s)return[...e,t];let r=e[s];return void 0!==r&&r.id===t.id&&r.progress===t.progress&&r.label===t.label?e:e.map(e=>e.id===t.id?t:e)})(s.phases,e),a=t(s.seenPhaseIds,e.id);return r===s.phases&&a===s.seenPhaseIds?s:{...s,phases:r,seenPhaseIds:a}})},endPhase:e=>{a(t=>t.phases.some(t=>t.id===e)?{...t,phases:t.phases.filter(t=>t.id!==e)}:t)},reportError:()=>{n(!0)},clearError:()=>{n(!1)},expectPhase:e=>{a(s=>{let r=s.expectationCounts.get(e)??0,a=new Map(s.expectationCounts).set(e,r+1);return{...s,expectationCounts:a,expectedPhaseIds:t(s.expectedPhaseIds,e)}})},dropExpectation:e=>{a(t=>{let s=t.expectationCounts.get(e);if(void 0===s)return t;let r=new Map(t.expectationCounts);return s>1?(r.set(e,s-1),{...t,expectationCounts:r}):(r.delete(e),{...t,expectationCounts:r,expectedPhaseIds:((e,t)=>{if(!e.has(t))return e;let s=new Set(e);return s.delete(t),s})(t.expectedPhaseIds,e)})})},resetSlot:()=>{a(t=>0!==t.phases.length||t.hasError||0!==t.expectedPhaseIds.size||0!==t.seenPhaseIds.size?e():t)}}};export const createLoadingActions=e=>({configurator:s(e,"configurator"),admin:s(e,"admin")});

package/dist/react-sdk/application-runtime/loading/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/loading/index.js

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

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

@@ -0,0 +1,3 @@
+import type { LoadingApplicationState, LoadingRuntimeState } from './types.js';
+export declare const initializeLoadingApplication: () => LoadingApplicationState;
+export declare const initializeLoading: () => LoadingRuntimeState;

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

@@ -0,0 +1 @@
+export const initializeLoadingApplication=()=>({phases:[],hasError:!1,expectedPhaseIds:new Set,expectationCounts:new Map,seenPhaseIds:new Set});export const initializeLoading=()=>({configurator:initializeLoadingApplication(),admin:initializeLoadingApplication()});

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

@@ -0,0 +1,18 @@
+import type { DomainApplicationType } from '#package/domain';
+import type { LoadingRuntimeState, LoadingState } from './types.js';
+export interface LoadingSelectorState {
+    readonly loading: LoadingRuntimeState;
+}
+interface Context {
+    readonly getState: () => LoadingSelectorState;
+    readonly applicationType: DomainApplicationType;
+}
+/** The selectors of one application's loading state; the runtime creates one set per application. */
+export declare const createLoadingSelectors: (context: Context) => {
+    selectLoadingState: import("@salsita-ai/common/utils").Selector<LoadingSelectorState, LoadingState>;
+    getLoadingState: () => LoadingState;
+    /** Whether the phase `id` is expected and has not started since the last reset. */
+    getIsAwaitingPhase: (id: string) => boolean;
+};
+export type LoadingSelectors = ReturnType<typeof createLoadingSelectors>;
+export {};

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

@@ -0,0 +1 @@
+import{createSelector as e}from"@salsita-ai/common/utils";export const createLoadingSelectors=a=>{let{getState:s,applicationType:t}=a,i=e.withTypes(),o=i.leaf(e=>e.loading[t].phases),l=i.leaf(e=>e.loading[t].hasError),n=i.leaf(e=>e.loading[t].expectedPhaseIds),r=i.leaf(e=>e.loading[t].seenPhaseIds),g=i([o,l,n],(e,a,s)=>({isLoading:e.length>0,hasError:a,phases:e,expectedPhaseIds:s}));return{selectLoadingState:g,getLoadingState:()=>g(s()),getIsAwaitingPhase:e=>{let a=s();return n(a).has(e)&&!r(a).has(e)}}};

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

@@ -0,0 +1,59 @@
+/**
+ * One step of an application's load that the loader shows while it runs: authenticating the
+ * session, fetching data, loading the 3D scene, or a step a project reports itself.
+ */
+export interface LoadingPhase {
+    readonly id: string;
+    /** From 0 to 1, when the step can tell how far it is. */
+    readonly progress?: number;
+    readonly label?: string;
+}
+/**
+ * The aggregated loading state the loader renders: the running phases in the order they started,
+ * and whether the load failed.
+ */
+export interface LoadingState {
+    /** `true` while at least one phase runs. */
+    readonly isLoading: boolean;
+    readonly hasError: boolean;
+    readonly phases: readonly LoadingPhase[];
+    /** The phases the loader waits for before they start, so it does not flash off in between. */
+    readonly expectedPhaseIds: ReadonlySet<string>;
+}
+/**
+ * The loading state of one application.
+ *
+ * The loader host resets it when it mounts, which happens when the configurator is powered on or
+ * remounted; phases written before that are not shown. Whether a component is below the loader
+ * host is not part of it: that is a fact about the React tree, read with `useIsLoaderHosted()`.
+ *
+ * @internal Runtime plumbing for the SDK's own UI. A project reads the loading state with
+ * `phx.frontend.useLoadingStateValue()` and reports a phase with `phx.frontend.useLoadingState()`.
+ */
+export interface LoadingApplicationState {
+    /** The running phases, in the order they started. Restarting a phase keeps its position. */
+    readonly phases: readonly LoadingPhase[];
+    readonly hasError: boolean;
+    readonly expectedPhaseIds: ReadonlySet<string>;
+    /**
+     * How many callers expect each phase of `expectedPhaseIds`: the components that mount the canvas
+     * nest, and an inner one unmounting must not drop the phase an outer one still expects.
+     */
+    readonly expectationCounts: ReadonlyMap<string, number>;
+    /**
+     * Every phase that started since the last reset. An expected phase that was seen once is no
+     * longer waited for, so a second configuration does not wait for the scene again.
+     */
+    readonly seenPhaseIds: ReadonlySet<string>;
+}
+/**
+ * The `loading` slice, one entry per application: an admin that embeds a configurator runs both in
+ * one runtime, and only the configurator hosts a loader.
+ *
+ * @internal Runtime plumbing for the SDK's own UI. A project reads the loading state with
+ * `phx.frontend.useLoadingStateValue()` and reports a phase with `phx.frontend.useLoadingState()`.
+ */
+export interface LoadingRuntimeState {
+    readonly configurator: LoadingApplicationState;
+    readonly admin: LoadingApplicationState;
+}

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

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

package/dist/react-sdk/application-runtime/mocks/create-mock-application-runtime.js

@@ -1 +1 @@
-import{memoOnce as e}from"@salsita-ai/common/utils";import{AccessLevel as t}from"@salsita-ai/contracts/api";import{createDomainRuntime as o,createMockDomainRuntimeServices as n,createMockSessionContext as s}from"#package/domain";import{createCommonServicesSelectors as i}from"../common-services/index.js";import{createDomainApplicationContextSelectors as a}from"../domain-application-context/index.js";import{createIntegrationActions as r,createIntegrationSelectors as c,initializeIntegration as m}from"../integration/index.js";import{createRoutingActions as d,createRoutingSelectors as p,initializeRouting as l}from"../routing/index.js";import{SessionService as S,createSessionRuntimeActions as g,createSessionRuntimeSelectors as v,initializeSessionRuntime as u}from"../session/index.js";import{createMockWebComponentApi as f}from"../web-component/index.js";export const createMockApplicationRuntime=(C,x)=>{var b;let w,y,A,D,k,E,I,R,h,j,O,T,L,F,M,{sessionData:U,mode:V,role:z}=x,q=n(),B=(b={webComponentOptions:x.webComponentOptions??C.mount.options,webComponentApi:x.webComponentApi??f()},A=u(),D=o({config:C,services:q,getExtensionSystems:e=>M[e].getInitializableSystems()}),k=new Set,E=()=>{k.forEach(e=>{e()})},I=r({setIntegration:e=>{w=e(w),E()}}),w=m(),R=c({getState:()=>({integration:w}),actions:I}),h=d({setRouting:e=>{y=e(y),E()}}),y=l(),j=p({getState:()=>({...D.getState(),routing:y}),actions:h,accessActions:D.actions.access,loadedDataActions:D.actions.loadedData,domainServicesSelectors:D.selectors.domainServices,overridesSelectors:D.selectors.overrides}),O=i({getState:()=>({...D.getState(),session:A}),environmentSelectors:D.selectors.environment,specSelectors:D.selectors.spec,accessSelectors:D.selectors.access,domainServicesSelectors:D.selectors.domainServices,webComponentOptions:b.webComponentOptions,webComponentApi:b.webComponentApi,getSessionService:()=>F(),routingSelectors:j}),T=g({setSessionRuntime:e=>{A=e(A),E()}}),L=v({getState:()=>({...D.getState(),session:A}),sessionContextSelectors:D.selectors.sessionContext}),F=e(()=>new S({getLogger:()=>D.selectors.domainServices.getLogger(),getAnalyticsService:()=>D.selectors.domainServices.getAnalyticsService(),getUnauthenticatedClient:O.getUnauthenticatedClient,environmentSelectors:D.selectors.environment,sessionActions:T,setSessionContext:D.actions.sessionContext.setSessionContext,sessionSelectors:L,specSelectors:D.selectors.spec})),M={configurator:a({applicationType:"configurator",commonServicesSelectors:O,domainServicesSelectors:D.selectors.domainServices,domainContextSelectors:D.selectors.domainContext.configurator,getApplicationRuntimeExtensions:()=>[]}),admin:a({applicationType:"admin",commonServicesSelectors:O,domainServicesSelectors:D.selectors.domainServices,domainContextSelectors:D.selectors.domainContext.admin,getApplicationRuntimeExtensions:()=>[]})},{subscribe:e=>{k.add(e);let t=D.subscribe(e);return()=>{k.delete(e),t()}},getState:()=>({...D.getState(),integration:w,routing:y,session:A}),selectors:{...D.selectors,commonServices:O,integration:R,routing:j,session:L,domainApplicationContext:M},actions:{...D.actions,integration:I,routing:h,session:T}}),G=B.getState().spec;return B.actions.spec.updateSpec({...G,configurator:{...G.configurator,createTransformers:e=>x.transformers.map(t=>t.transformer.register(e,t.priority??1/0))}}),B.actions.sessionContext.setSessionContext(s(z,U)),B.actions.access.setConfiguratorAccessInfo({raw:"mock-access-token",access:"read"===V?t.Read:t.Owner,viewMode:"read"===V,revisionId:void 0,configurationId:"mock"}),B.actions.domainData.setDomainData({publishedData:x.publishedData,frontendData:x.frontendData,backendData:x.backendData}),B.actions.loadedData.completeConfiguratorLoad({initialRevisionId:"mock-revision",initialEntities:x.entities,modelVersion:C.domain.domainFactory.modelVersion,rootEntityType:x.rootEntityType,schemaIdentity:C.domain.domainFactory}),B};
+import{memoOnce as e}from"@salsita-ai/common/utils";import{AccessLevel as t}from"@salsita-ai/contracts/api";import{createDomainRuntime as o,createMockDomainRuntimeServices as n,createMockSessionContext as i}from"#package/domain";import{createCommonServicesSelectors as s}from"../common-services/index.js";import{createDomainApplicationContextSelectors as a}from"../domain-application-context/index.js";import{connectHostProperties as r,createHostPropertiesActions as c,createHostPropertiesSelectors as m,initializeHostProperties as p}from"../host-properties/index.js";import{createIntegrationActions as d,createIntegrationSelectors as l,initializeIntegration as g}from"../integration/index.js";import{createLoadingActions as S,createLoadingSelectors as f,initializeLoading as v}from"../loading/index.js";import{createResponsiveActions as u,createResponsiveSelectors as C,initializeResponsive as x}from"../responsive/index.js";import{createRoutingActions as b,createRoutingSelectors as y,initializeRouting as w}from"../routing/index.js";import{SessionService as A,createSessionRuntimeActions as D,createSessionRuntimeSelectors as R,initializeSessionRuntime as h}from"../session/index.js";import{createMockWebComponentApi as j}from"../web-component/index.js";export const createMockApplicationRuntime=(T,k)=>{var E;let I,L,O,M,F,P,U,V,z,H,q,B,G,J,K,N,Q,W,X,Y,Z,$,_,ee,{sessionData:et,mode:eo,role:en}=k,ei=n(),es=(E={webComponentOptions:k.webComponentOptions??T.mount.options,webComponentApi:k.webComponentApi??j()},O=h(),M=o({config:T,services:ei,getExtensionSystems:e=>ee[e].getInitializableSystems()}),F=new Set,P=()=>{F.forEach(e=>{e()})},U=d({setIntegration:e=>{I=e(I),P()}}),I=g(),V=l({getState:()=>({integration:I}),actions:U}),z=b({setRouting:e=>{L=e(L),P()}}),L=w(),H=y({getState:()=>({...M.getState(),routing:L}),actions:z,accessActions:M.actions.access,loadedDataActions:M.actions.loadedData,domainServicesSelectors:M.selectors.domainServices,overridesSelectors:M.selectors.overrides}),q=x(),B=u({setResponsive:e=>{let t=e(q);t!==q&&(q=t,P())}}),G={configurator:C({getState:()=>({responsive:q}),applicationType:"configurator"}),admin:C({getState:()=>({responsive:q}),applicationType:"admin"})},J=v(),K=S({setLoading:e=>{let t=e(J);t!==J&&(J=t,P())}}),N={configurator:f({getState:()=>({loading:J}),applicationType:"configurator"}),admin:f({getState:()=>({loading:J}),applicationType:"admin"})},Q=p(E.webComponentApi),W=c({setHostProperties:e=>{let t=e(Q);t!==Q&&(Q=t,P())}}),X=m({getState:()=>({hostProperties:Q})}),r({webComponentApi:E.webComponentApi,actions:W,domainSelectors:M.selectors.webComponent,domainActions:{setReadonly:M.actions.webComponent.setReadonly,setLocale:M.hostMirrorActions.setLocale}}),Y=s({getState:()=>({...M.getState(),session:O}),environmentSelectors:M.selectors.environment,specSelectors:M.selectors.spec,accessSelectors:M.selectors.access,domainServicesSelectors:M.selectors.domainServices,webComponentOptions:E.webComponentOptions,webComponentApi:E.webComponentApi,getSessionService:()=>_(),routingSelectors:H}),Z=D({setSessionRuntime:e=>{O=e(O),P()}}),$=R({getState:()=>({...M.getState(),session:O}),sessionContextSelectors:M.selectors.sessionContext}),_=e(()=>new A({getLogger:()=>M.selectors.domainServices.getLogger(),getAnalyticsService:()=>M.selectors.domainServices.getAnalyticsService(),getUnauthenticatedClient:Y.getUnauthenticatedClient,environmentSelectors:M.selectors.environment,sessionActions:Z,setSessionContext:M.actions.sessionContext.setSessionContext,sessionSelectors:$,specSelectors:M.selectors.spec})),ee={configurator:a({applicationType:"configurator",commonServicesSelectors:Y,domainServicesSelectors:M.selectors.domainServices,domainContextSelectors:M.selectors.domainContext.configurator,getApplicationRuntimeExtensions:()=>[]}),admin:a({applicationType:"admin",commonServicesSelectors:Y,domainServicesSelectors:M.selectors.domainServices,domainContextSelectors:M.selectors.domainContext.admin,getApplicationRuntimeExtensions:()=>[]})},{subscribe:e=>{F.add(e);let t=M.subscribe(e);return()=>{F.delete(e),t()}},getState:()=>({...M.getState(),hostProperties:Q,integration:I,loading:J,responsive:q,routing:L,session:O}),selectors:{...M.selectors,commonServices:Y,hostProperties:X,integration:V,loading:N,responsive:G,routing:H,session:$,domainApplicationContext:ee},actions:{...M.actions,integration:U,loading:K,responsive:B,routing:z,session:Z}}),ea=es.getState().spec;return es.actions.spec.updateSpec({...ea,configurator:{...ea.configurator,createTransformers:e=>k.transformers.map(t=>t.transformer.register(e,t.priority??1/0))}}),es.actions.sessionContext.setSessionContext(i(en,et)),es.actions.access.setConfiguratorAccessInfo({raw:"mock-access-token",access:"read"===eo?t.Read:t.Owner,viewMode:"read"===eo,revisionId:void 0,configurationId:"mock"}),es.actions.domainData.setDomainData({publishedData:k.publishedData,frontendData:k.frontendData,backendData:k.backendData}),es.actions.loadedData.completeConfiguratorLoad({initialRevisionId:"mock-revision",initialEntities:k.entities,modelVersion:T.domain.domainFactory.modelVersion,rootEntityType:k.rootEntityType,schemaIdentity:T.domain.domainFactory}),es};

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

@@ -5,5 +5,11 @@ interface ApplicationRuntimeProviderProps {
     readonly runtime: ApplicationRuntime;
 }
 export declare const ApplicationRuntimeProvider: (props: ApplicationRuntimeProviderProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * The runtime, or `null` outside an `ApplicationRuntimeProvider`, for hooks that must work without one.
+ *
+ * @internal Runtime plumbing for the SDK's own UI.
+ */
+export declare const useOptionalApplicationRuntime: () => ApplicationRuntime | null;
 export declare const useApplicationRuntime: () => ApplicationRuntime;
 export {};

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

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

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;
+}