@salsita-ai/sdk 0.50.0-develop.d81d7591c5 → 0.50.0-develop.d96df76afa

package/dist/domain/domain-runtime/spec/selectors.js

@@ -1 +1 @@
-import{createSelector as e}from"@salsita-ai/common/utils";import{buildAssistantManifest as t}from"../../application/assistant/index.js";import{systemElementRegistry as n}from"../../application/element-registration.js";export const createSpecSelectors=a=>{let{getState:s}=a,r=e.withTypes(),o=r([r.leaf(e=>e.spec)],e=>e),l=r([o],e=>e.version),i=r([o],e=>e.baseResourcesUrl),m=r([o],e=>e.configurator),g=r([o],e=>e.dataConfig),p=r([o],e=>e.chunks),d=r([o],e=>e.publishedDataHash),c=r([o],e=>e.initialPublishedData),u=r([o],e=>e.canCreate),y=r([o],e=>e.enableAdminRelease),h=r([o],e=>e.textLanguages),f=r([m],e=>e.modelVersion),C=r([o],e=>e.admin),A=r([C],e=>e.preset),E=r([C],e=>e.modelVersion),b=r([m],e=>e.theme),x=r([m],e=>e.assistant),H=r([x],e=>e?t(e):null),D=r([m],e=>e.factory),P=r([C],e=>e.factory),S=r([m],e=>e.componentOptics),w=r([C],e=>e.componentOptics),O=r([m],e=>e.appLoader),T=r([m],e=>e.preview),V=r([m],e=>e.alwaysExpand),L=r([m],e=>e.presets),R=r([m],e=>e.deploymentQueryDisabled),U=r([m],e=>e.prefetchTextureUrls),v=r([m],e=>e.handlerHashes),j=r([m],e=>e.handlers),k=r([j,v],(e,t)=>({...(e=>{let t={},n={},a={};for(let s of e)"phoenix"===s.type&&(t[s.name]=s.handler),"system"===s.type&&(n[s.name]=s.handler),"system-async"===s.type&&(a[s.name]=s.handler);return{handlers:t,systemHandlers:n,systemAsyncHandlers:a}})(e),hashes:t})),F=r([m],e=>e.elementHashes),M=r([m],e=>e.elements),Q=r([M,F],(e,t)=>({...(e=>{let t={},a={};for(let n of e)"layout"===n.type&&(t[n.name]=n.element),"entity"===n.type&&(a[n.name]=n.element);return{entityElements:{...n.entityElements,...a},layoutElements:{...n.layoutElements,...t}}})(e),hashes:t}));return{selectSpec:o,selectVersion:l,selectBaseResourcesUrl:i,selectConfiguratorSpec:m,selectConfiguratorModelVersion:f,selectAdminSpec:C,selectAdminPreset:A,selectAdminModelVersion:E,selectThemeOptions:b,selectAssistant:H,selectConfiguratorFactory:D,selectAdminFactory:P,selectConfiguratorComponentOptics:S,selectAdminComponentOptics:w,selectAppLoader:O,selectPreview:T,selectAlwaysExpand:V,selectPresetSeed:L,selectDeploymentQueryDisabled:R,selectPrefetchTextureUrls:U,selectTextLanguages:h,selectHandlerHashes:v,selectHandlers:j,selectHandlerSlots:k,selectElementHashes:F,selectElements:M,selectElementSlots:Q,selectDataConfig:g,selectChunks:p,selectPublishedDataHash:d,selectInitialPublishedData:c,selectCanCreate:u,selectEnableAdminRelease:y,getVersion:()=>l(s()),getBaseResourcesUrl:()=>i(s()),getConfiguratorSpec:()=>m(s()),getConfiguratorModelVersion:()=>f(s()),getAdminSpec:()=>C(s()),getAdminPreset:()=>A(s()),getAdminModelVersion:()=>E(s()),getThemeOptions:()=>b(s()),getAssistant:()=>H(s()),getConfiguratorFactory:()=>D(s()),getAdminFactory:()=>P(s()),getConfiguratorComponentOptics:()=>S(s()),getAdminComponentOptics:()=>w(s()),getAppLoader:()=>O(s()),getPreview:()=>T(s()),getAlwaysExpand:()=>V(s()),getPresetSeed:()=>L(s()),getDeploymentQueryDisabled:()=>R(s()),getPrefetchTextureUrls:()=>U(s()),getTextLanguages:()=>h(s()),getHandlerHashes:()=>v(s()),getHandlers:()=>j(s()),getHandlerSlots:()=>k(s()),getElementHashes:()=>F(s()),getElements:()=>M(s()),getElementSlots:()=>Q(s()),getDataConfig:()=>g(s()),getChunks:()=>p(s()),getPublishedDataHash:()=>d(s()),getInitialPublishedData:()=>c(s()),getCanCreate:()=>u(s()),getEnableAdminRelease:()=>y(s())}};
+import{createSelector as e}from"@salsita-ai/common/utils";import{buildAssistantManifest as t}from"../../application/assistant/index.js";export const createSpecSelectors=a=>{let{getState:n}=a,s=e.withTypes(),r=s([s.leaf(e=>e.spec)],e=>e),l=s([r],e=>e.version),o=s([r],e=>e.baseResourcesUrl),i=s([r],e=>e.configurator),m=s([r],e=>e.dataConfig),g=s([r],e=>e.chunks),p=s([r],e=>e.publishedDataHash),d=s([r],e=>e.initialPublishedData),c=s([r],e=>e.canCreate),u=s([r],e=>e.enableAdminRelease),h=s([r],e=>e.textLanguages),y=s([i],e=>e.modelVersion),f=s([r],e=>e.admin),C=s([f],e=>e.preset),E=s([f],e=>e.modelVersion),A=s([i],e=>e.theme),b=s([i],e=>e.assistant),x=s([b],e=>e?t(e):null),H=s([i],e=>e.factory),D=s([f],e=>e.factory),P=s([i],e=>e.componentOptics),S=s([f],e=>e.componentOptics),w=s([i],e=>e.appLoader),O=s([i],e=>e.preview),T=s([i],e=>e.alwaysExpand),V=s([i],e=>e.presets),F=s([i],e=>e.deploymentQueryDisabled),L=s([i],e=>e.prefetchTextureUrls),R=s([i],e=>e.handlerHashes),U=s([i],e=>e.handlers),v=s([U,R],(e,t)=>({...(e=>{let t={},a={},n={};for(let s of e)"phoenix"===s.type&&(t[s.name]=s.handler),"system"===s.type&&(a[s.name]=s.handler),"system-async"===s.type&&(n[s.name]=s.handler);return{handlers:t,systemHandlers:a,systemAsyncHandlers:n}})(e),hashes:t})),k=s([i],e=>e.elementHashes),M=s([i],e=>e.elements),Q=s([i],e=>e.defaultElements),j=s([Q,M,k],(e,t,a)=>({...(e=>{let t={},a={},n={};for(let s of e)"layout"===s.type&&(t[s.name]=s.element),"entity"===s.type&&(a[s.name]=s.element),"assistantFormElement"===s.type&&(n[s.name]=s.element);return{entityElements:a,layoutElements:t,assistantFormElements:n}})([...e,...t]),hashes:a}));return{selectSpec:r,selectVersion:l,selectBaseResourcesUrl:o,selectConfiguratorSpec:i,selectConfiguratorModelVersion:y,selectAdminSpec:f,selectAdminPreset:C,selectAdminModelVersion:E,selectThemeOptions:A,selectAssistant:x,selectConfiguratorFactory:H,selectAdminFactory:D,selectConfiguratorComponentOptics:P,selectAdminComponentOptics:S,selectAppLoader:w,selectPreview:O,selectAlwaysExpand:T,selectPresetSeed:V,selectDeploymentQueryDisabled:F,selectPrefetchTextureUrls:L,selectTextLanguages:h,selectHandlerHashes:R,selectHandlers:U,selectHandlerSlots:v,selectElementHashes:k,selectElements:M,selectElementSlots:j,selectDataConfig:m,selectChunks:g,selectPublishedDataHash:p,selectInitialPublishedData:d,selectCanCreate:c,selectEnableAdminRelease:u,getVersion:()=>l(n()),getBaseResourcesUrl:()=>o(n()),getConfiguratorSpec:()=>i(n()),getConfiguratorModelVersion:()=>y(n()),getAdminSpec:()=>f(n()),getAdminPreset:()=>C(n()),getAdminModelVersion:()=>E(n()),getThemeOptions:()=>A(n()),getAssistant:()=>x(n()),getConfiguratorFactory:()=>H(n()),getAdminFactory:()=>D(n()),getConfiguratorComponentOptics:()=>P(n()),getAdminComponentOptics:()=>S(n()),getAppLoader:()=>w(n()),getPreview:()=>O(n()),getAlwaysExpand:()=>T(n()),getPresetSeed:()=>V(n()),getDeploymentQueryDisabled:()=>F(n()),getPrefetchTextureUrls:()=>L(n()),getTextLanguages:()=>h(n()),getHandlerHashes:()=>R(n()),getHandlers:()=>U(n()),getHandlerSlots:()=>v(n()),getElementHashes:()=>k(n()),getElements:()=>M(n()),getElementSlots:()=>j(n()),getDataConfig:()=>m(n()),getChunks:()=>g(n()),getPublishedDataHash:()=>p(n()),getInitialPublishedData:()=>d(n()),getCanCreate:()=>c(n()),getEnableAdminRelease:()=>u(n())}};

package/dist/domain/domain-runtime/spec/types.d.ts

@@ -1,9 +1,9 @@
 import type { ThemeOptions } from '@mui/material';
 import type { SessionRole } from '@salsita-ai/contracts/api';
-import type { AssistantResolvedManifest, ChunksSpec, DataSpec, ElementRegistration, HandlerRegistration } from '../../application/index.js';
-import type { AnyDomainComponentOptic } from '../../components/index.js';
-import type { ActionDefinitions, Any$EntityReflections, AnyActionImplementations, AnyAliasMap, AnyAllowedRootEntityTypes, AnyDomainFactory, AnyEntityReflections, AnyExpressions, AnyProductPreset, DomainEntity, MigrateFunction } from '../../core/index.js';
-import type { AnyCreateTransformersFactory } from '../../domain-context/store-system/store-system.js';
+import type { AssistantResolvedManifest, ChunksSpec, DataSpec } from '../../application/index.js';
+import type { ActionDefinitions, Any$EntityReflections, AnyActionImplementations, AnyAliasMap, AnyAllowedRootEntityTypes, AnyDomainComponentOptic, AnyDomainFactory, AnyEntityReflections, AnyExpressions, AnyProductPreset, DomainEntity, MigrateFunction } from '../../core/index.js';
+import type { AnyCreateTransformersFactory } from '../../domain-context/index.js';
+import type { ElementRegistration, HandlerRegistration } from './module-checks/index.js';
 export interface ApplicationConfiguratorSpec {
     readonly modelVersion: number;
     readonly factory: AnyDomainFactory;
@@ -35,6 +35,8 @@ export interface ApplicationConfiguratorSpec {
      */
     readonly handlerHashes: Record<string, string>;
     readonly elements: readonly ElementRegistration[];
+    /** The SDK's default element registrations; an entry of `elements` with the same name replaces one. */
+    readonly defaultElements: readonly ElementRegistration[];
     /**
      * Per-element content hash. Used as remount key so only the specific element
      * whose source changed remounts. Unchanged elements keep their hash and stay mounted.

package/dist/domain/extensions/angle-indicator.d.ts

@@ -0,0 +1,21 @@
+import { type Localizable } from '@salsita-ai/common/utils';
+import { type ComponentSnapshot } from '../core/index.js';
+import { type AngleIndicatorBaseState } from './common/index.js';
+export type AngleIndicatorComponentState = AngleIndicatorBaseState & {
+    /**
+     * Indicator label. If no label is provided, the measured angle in degrees will be shown.
+     */
+    readonly label?: Localizable;
+    /**
+     * If true, the indicator will be visible. Default is true.
+     */
+    readonly visible?: boolean;
+    /**
+     * If true, the indicator will always be shown regardless of the global dimension indicator visibility setting.
+     */
+    readonly force?: boolean;
+};
+export declare const angleIndicatorComponent: import("../index.js").SystemComponentType<"angleIndicator", AngleIndicatorComponentState, never>;
+export type AngleIndicatorComponent = typeof angleIndicatorComponent;
+export type AngleIndicatorComponentSnapshot = ComponentSnapshot<AngleIndicatorComponent>;
+export declare const isAngleIndicatorSnapshot: (snapshot: ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is ComponentSnapshot<import("../index.js").SystemComponentType<"angleIndicator", AngleIndicatorComponentState, never>>;

package/dist/domain/extensions/angle-indicator.js

@@ -0,0 +1 @@
+import{EnhancedLocalizableSchema as o}from"@salsita-ai/common/utils";import{SystemComponentBuilder as t,isSnapshotOfComponentType as e}from"../core/index.js";import{AngleIndicatorProperties as n}from"./common/index.js";export const angleIndicatorComponent=t.component("angleIndicator").withState({tsType:"AngleIndicatorComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"AngleIndicatorComponentState"}],type:"object",properties:{...n,label:o,visible:{type:"boolean"},force:{type:"boolean"}},required:["positionX","positionY","positionZ","startAngle","sweepAngle"],additionalProperties:!1}).build();export const isAngleIndicatorSnapshot=e(angleIndicatorComponent);

package/dist/domain/extensions/attribute-switch.d.ts

@@ -0,0 +1,8 @@
+export declare const AttributeSwitchValueSchema: {
+    readonly type: 'boolean';
+};
+export type AttributeSwitchComponentState = {
+    readonly value: boolean;
+};
+export declare const attributeSwitchComponent: import("../index.js").SystemComponentType<"attributeSwitch", AttributeSwitchComponentState, "value">;
+export type AttributeSwitchComponent = typeof attributeSwitchComponent;

package/dist/domain/extensions/attribute-switch.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as t}from"../core/index.js";export const AttributeSwitchValueSchema={type:"boolean"};export const attributeSwitchComponent=t.component("attributeSwitch").withState({type:"object",properties:{value:AttributeSwitchValueSchema},tsType:"AttributeSwitchComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"AttributeSwitchComponentState"}],required:["value"],additionalProperties:!1}).withWritableKeys(["value"]).build();

package/dist/domain/extensions/autorotate-camera-component.d.ts

@@ -0,0 +1,19 @@
+import { type ComponentSnapshot } from '../core/index.js';
+export type AutorotateCameraComponentState = {
+    /**
+     * Speed of autorotation in radians per second.
+     */
+    readonly speed?: number | undefined;
+    /**
+     * Whether to pause autorotation on user interaction.
+     */
+    readonly pauseOnInteraction?: boolean | undefined;
+    /**
+     * Delay in milliseconds before resuming autorotation after user interaction.
+     */
+    readonly resumeDelay?: number | undefined;
+};
+export declare const AutorotateCameraComponentName = "autorotateCamera";
+export declare const autorotateCameraComponent: import("../index.js").SystemComponentType<"autorotateCamera", AutorotateCameraComponentState, never>;
+export type AutorotateCameraComponent = typeof autorotateCameraComponent;
+export declare const isAutorotateCameraComponent: (state: ComponentSnapshot<any>) => state is ComponentSnapshot<AutorotateCameraComponent>;

package/dist/domain/extensions/autorotate-camera-component.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as e}from"../core/index.js";export const AutorotateCameraComponentName="autorotateCamera";export const autorotateCameraComponent=e.component(AutorotateCameraComponentName).withState({type:"object",tsType:"AutorotateCameraComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"AutorotateCameraComponentState"}],properties:{speed:{type:"number"},pauseOnInteraction:{type:"boolean"},resumeDelay:{type:"number"}},required:[],additionalProperties:!1}).build();export const isAutorotateCameraComponent=e=>e.componentInstance.componentType.name===AutorotateCameraComponentName;

package/dist/domain/extensions/basic-sidebar-footer.d.ts

@@ -0,0 +1,8 @@
+import { type ComponentInstance, type ComponentSnapshot } from '../core/index.js';
+export type BasicSidebarFooterComponentState = Record<string, never>;
+export declare const basicSidebarFooterComponent: import("../index.js").SystemComponentType<"basicSidebarFooter", BasicSidebarFooterComponentState, never>;
+export type BasicSidebarFooterComponent = typeof basicSidebarFooterComponent;
+export type BasicSidebarFooterComponentSnapshot = ComponentSnapshot<BasicSidebarFooterComponent>;
+export type BasicSidebarFooterComponentInstance = ComponentInstance<BasicSidebarFooterComponent>;
+export declare const isBasicSidebarFooterSnapshot: (snapshot: ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is ComponentSnapshot<import("../index.js").SystemComponentType<"basicSidebarFooter", BasicSidebarFooterComponentState, never>>;
+export declare const isBasicSidebarFooterInstance: (instance: ComponentInstance<import("../index.js").SystemComponentTypeConstraint>) => instance is ComponentInstance<import("../index.js").SystemComponentType<"basicSidebarFooter", BasicSidebarFooterComponentState, never>>;

package/dist/domain/extensions/basic-sidebar-footer.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as o,isInstanceOfComponentType as e,isSnapshotOfComponentType as t}from"../core/index.js";export const basicSidebarFooterComponent=o.component("basicSidebarFooter").withState({type:"object",tsType:"BasicSidebarFooterComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"BasicSidebarFooterComponentState"}],properties:{},required:[],additionalProperties:!1}).build();export const isBasicSidebarFooterSnapshot=t(basicSidebarFooterComponent);export const isBasicSidebarFooterInstance=e(basicSidebarFooterComponent);

package/dist/domain/extensions/camera-based-hidden-entity-object.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as e,isSnapshotOfComponentType as t}from"../core/index.js";export const cameraBasedHiddenEntityObjectComponent=e.component("cameraBasedHiddenEntityObject").withState({type:"object",tsType:"CameraBasedHiddenEntityObjectComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"CameraBasedHiddenEntityObjectComponentState"}],properties:{normal:{type:"object",properties:{x:{type:"number"},y:{type:"number"},z:{type:"number"}},required:["x","y","z"],additionalProperties:!1},constant:{type:"number"},behind:{type:"boolean"}},required:["normal","constant"],additionalProperties:!1}).build();export const isCameraBasedHiddenEntityObjectComponent=t(cameraBasedHiddenEntityObjectComponent);

package/dist/domain/extensions/camera-based-hidden-entity.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as e,isSnapshotOfComponentType as t}from"../core/index.js";export const cameraBasedHiddenEntityComponent=e.component("cameraBasedHiddenEntity").withState({type:"object",tsType:"CameraBasedHiddenEntityComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"CameraBasedHiddenEntityComponentState"}],properties:{normal:{type:"object",properties:{x:{type:"number"},y:{type:"number"},z:{type:"number"}},required:["x","y","z"],additionalProperties:!1},constant:{type:"number"},behind:{type:"boolean"}},required:["normal","constant"],additionalProperties:!1}).build();export const isCameraBasedHiddenEntityComponent=t(cameraBasedHiddenEntityComponent);

package/dist/domain/extensions/canvas-config.d.ts

@@ -0,0 +1,87 @@
+import { type ComponentInstance, type ComponentSnapshot } from '../core/index.js';
+export type CanvasConfigComponentState = {
+    /**
+     * If true, highlighting will be disabled.
+     */
+    readonly highlightingDisabled?: boolean;
+    /**
+     * Frameloop mode for the canvas.
+     */
+    readonly frameloop?: 'always' | 'demand' | 'never';
+    /**
+     * **Temporary workaround for Ambient Occlusion issues.** Do not use, unless you know you need this.
+     *
+     * If `true`, the canvas environment will not be wrapped in `Suspense`.
+     */
+    readonly __doNotSuspendEnvironment?: boolean;
+    /**
+     * shader precision. Can be "highp", "mediump" or "lowp".
+     */
+    readonly precision?: 'highp' | 'mediump' | 'lowp';
+    /**
+     * default is false.
+     */
+    readonly alpha?: boolean | undefined;
+    /**
+     * default is true.
+     */
+    readonly premultipliedAlpha?: boolean | undefined;
+    /**
+     * default is false.
+     */
+    readonly antialias?: boolean | undefined;
+    /**
+     * default is true.
+     */
+    readonly stencil?: boolean | undefined;
+    /**
+     * default is false.
+     */
+    readonly preserveDrawingBuffer?: boolean | undefined;
+    /**
+     * Can be "high-performance", "low-power" or "default"
+     */
+    readonly powerPreference?: 'high-performance' | 'low-power' | 'default' | undefined;
+    /**
+     * default is true.
+     */
+    readonly depth?: boolean | undefined;
+    /**
+     * default is false.
+     */
+    readonly logarithmicDepthBuffer?: boolean | undefined;
+    /**
+     * default is false.
+     */
+    readonly failIfMajorPerformanceCaveat?: boolean | undefined;
+    /**
+     * Shadows config for the canvas. Can be "basic", "percentage", "soft" or "variance".
+     */
+    readonly shadows?: 'basic' | 'percentage' | 'soft' | 'variance';
+    /**
+     * When true, uses an optimized emissive-based highlight instead of the default clone-based highlight.
+     * This modifies material emissive properties directly rather than cloning geometry.
+     *
+     * When enabled, the clone-based highlight is automatically disabled.
+     * Fast highlight works even when `highlightingDisabled` is true.
+     */
+    readonly enableFastHighlight?: boolean;
+    /**
+     * Color for the fast emissive highlight effect. Accepts any CSS color string.
+     * Only applies when `enableFastHighlight` is true.
+     * @default 'white'
+     */
+    readonly fastHighlightColor?: string;
+    /**
+     * Intensity of the fast emissive highlight effect (0-1 range).
+     * Only applies when `enableFastHighlight` is true.
+     * @default 0.1
+     */
+    readonly fastHighlightIntensity?: number;
+};
+export declare const canvasConfigComponent: import("../index.js").SystemComponentType<"canvasConfig", CanvasConfigComponentState, never>;
+export type CanvasConfigComponent = typeof canvasConfigComponent;
+export type CanvasConfigComponentInstance = ComponentInstance<CanvasConfigComponent>;
+export type CanvasConfigComponentSnapshot = ComponentSnapshot<CanvasConfigComponent>;
+export declare const isCanvasConfigSnapshot: (snapshot: ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is ComponentSnapshot<import("../index.js").SystemComponentType<"canvasConfig", CanvasConfigComponentState, never>>;
+export declare const isCanvasConfigInstance: (instance: ComponentInstance<import("../index.js").SystemComponentTypeConstraint>) => instance is ComponentInstance<import("../index.js").SystemComponentType<"canvasConfig", CanvasConfigComponentState, never>>;

package/dist/domain/extensions/canvas-config.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as e,isInstanceOfComponentType as n,isSnapshotOfComponentType as o}from"../core/index.js";export const canvasConfigComponent=e.component("canvasConfig").withState({type:"object",tsType:"CanvasConfigComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"CanvasConfigComponentState"}],properties:{highlightingDisabled:{type:"boolean"},frameloop:{type:"string",enum:["always","demand","never"]},__doNotSuspendEnvironment:{type:"boolean"},precision:{type:"string",enum:["highp","mediump","lowp"]},alpha:{type:"boolean"},premultipliedAlpha:{type:"boolean"},antialias:{type:"boolean"},stencil:{type:"boolean"},preserveDrawingBuffer:{type:"boolean"},powerPreference:{type:"string",enum:["high-performance","low-power","default"]},depth:{type:"boolean"},logarithmicDepthBuffer:{type:"boolean"},failIfMajorPerformanceCaveat:{type:"boolean"},shadows:{type:"string",enum:["basic","percentage","soft","variance"]},enableFastHighlight:{type:"boolean"},fastHighlightColor:{type:"string"},fastHighlightIntensity:{type:"number"}},required:[],additionalProperties:!1}).build();export const isCanvasConfigSnapshot=o(canvasConfigComponent);export const isCanvasConfigInstance=n(canvasConfigComponent);

package/dist/domain/extensions/canvas-custom-environment.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as n,isInstanceOfComponentType as t,isSnapshotOfComponentType as o}from"../core/index.js";export const canvasCustomEnvironmentComponent=n.component("canvasCustomEnvironment").withState({type:"object",tsType:"CanvasCustomEnvironmentComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"CanvasCustomEnvironmentComponentState"}],properties:{name:{type:"string"}},required:["name"],additionalProperties:!1}).build();export const isCanvasCustomEnvironmentSnapshot=o(canvasCustomEnvironmentComponent);export const isCanvasCustomEnvironmentInstance=t(canvasCustomEnvironmentComponent);

package/dist/domain/extensions/canvas-padding.d.ts

@@ -0,0 +1,25 @@
+import { type ComponentInstance, type ComponentSnapshot } from '../core/index.js';
+export type CanvasPaddingComponentState = {
+    /**
+     * Fraction of the available left space to be applied to the left side of the canvas.
+     */
+    readonly left?: number;
+    /**
+     * Fraction of the available right space to be applied to the right side of the canvas.
+     */
+    readonly right?: number;
+    /**
+     * Fraction of the available top space to be applied to the top side of the canvas.
+     */
+    readonly top?: number;
+    /**
+     * Fraction of the available bottom space to be applied to the bottom side of the canvas.
+     */
+    readonly bottom?: number;
+};
+export declare const canvasPaddingComponent: import("../index.js").SystemComponentType<"canvasPadding", CanvasPaddingComponentState, never>;
+export type CanvasPaddingComponent = typeof canvasPaddingComponent;
+export type CanvasPaddingComponentInstance = ComponentInstance<CanvasPaddingComponent>;
+export type CanvasPaddingComponentSnapshot = ComponentSnapshot<CanvasPaddingComponent>;
+export declare const isCanvasPaddingSnapshot: (snapshot: ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is ComponentSnapshot<import("../index.js").SystemComponentType<"canvasPadding", CanvasPaddingComponentState, never>>;
+export declare const isCanvasPaddingInstance: (instance: ComponentInstance<import("../index.js").SystemComponentTypeConstraint>) => instance is ComponentInstance<import("../index.js").SystemComponentType<"canvasPadding", CanvasPaddingComponentState, never>>;

package/dist/domain/extensions/canvas-padding.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as n,isInstanceOfComponentType as t,isSnapshotOfComponentType as e}from"../core/index.js";export const canvasPaddingComponent=n.component("canvasPadding").withState({type:"object",tsType:"CanvasPaddingComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"CanvasPaddingComponentState"}],properties:{left:{type:"number"},right:{type:"number"},top:{type:"number"},bottom:{type:"number"}},required:[],additionalProperties:!1}).build();export const isCanvasPaddingSnapshot=e(canvasPaddingComponent);export const isCanvasPaddingInstance=t(canvasPaddingComponent);

package/dist/domain/extensions/canvas-preset-environment.d.ts

@@ -0,0 +1,37 @@
+import { type ComponentInstance, type ComponentSnapshot } from '../core/index.js';
+export type CanvasPresetEnvironmentComponentState = {
+    /**
+     * Intensity of ambient light in the scene. Defaults to 0.7 if not specified.
+     */
+    readonly ambientLightIntensity?: number;
+    /**
+     * Number of frames to render for animated environment maps.
+     */
+    readonly frames?: number;
+    /**
+     * Near clipping plane distance for the environment map.
+     */
+    readonly near?: number;
+    /**
+     * Far clipping plane distance for the environment map.
+     */
+    readonly far?: number;
+    /**
+     * Drei environment preset name. Available presets provide HDR environment maps for lighting and reflections.
+     */
+    readonly preset?: 'apartment' | 'city' | 'dawn' | 'forest' | 'lobby' | 'night' | 'park' | 'studio' | 'sunset' | 'warehouse';
+    /**
+     * Resolution of the environment map texture in pixels.
+     */
+    readonly resolution?: number;
+    /**
+     * Blur amount applied to the environment map. Higher values create softer reflections.
+     */
+    readonly blur?: number;
+};
+export declare const canvasPresetEnvironmentComponent: import("../index.js").SystemComponentType<"canvasPresetEnvironment", CanvasPresetEnvironmentComponentState, never>;
+export type CanvasPresetEnvironmentComponent = typeof canvasPresetEnvironmentComponent;
+export type CanvasPresetEnvironmentComponentInstance = ComponentInstance<CanvasPresetEnvironmentComponent>;
+export type CanvasPresetEnvironmentComponentSnapshot = ComponentSnapshot<CanvasPresetEnvironmentComponent>;
+export declare const isCanvasPresetEnvironmentSnapshot: (snapshot: ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is ComponentSnapshot<import("../index.js").SystemComponentType<"canvasPresetEnvironment", CanvasPresetEnvironmentComponentState, never>>;
+export declare const isCanvasPresetEnvironmentInstance: (instance: ComponentInstance<import("../index.js").SystemComponentTypeConstraint>) => instance is ComponentInstance<import("../index.js").SystemComponentType<"canvasPresetEnvironment", CanvasPresetEnvironmentComponentState, never>>;

package/dist/domain/extensions/canvas-preset-environment.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as e,isInstanceOfComponentType as n,isSnapshotOfComponentType as t}from"../core/index.js";export const canvasPresetEnvironmentComponent=e.component("canvasPresetEnvironment").withState({type:"object",tsType:"CanvasPresetEnvironmentComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"CanvasPresetEnvironmentComponentState"}],properties:{ambientLightIntensity:{type:"number"},frames:{type:"number"},near:{type:"number"},far:{type:"number"},preset:{type:"string",enum:["apartment","city","dawn","forest","lobby","night","park","studio","sunset","warehouse"]},resolution:{type:"number"},blur:{type:"number"}},required:[],additionalProperties:!1}).build();export const isCanvasPresetEnvironmentSnapshot=t(canvasPresetEnvironmentComponent);export const isCanvasPresetEnvironmentInstance=n(canvasPresetEnvironmentComponent);

package/dist/domain/extensions/child-entity-recipe-hierarchy.d.ts

@@ -0,0 +1,21 @@
+import { type ComponentInstance, type ComponentSnapshot, type SystemComponentTypeConstraint } from '../core/index.js';
+import { type GroupedRecipeItems } from '../system-components/index.js';
+export type ChildEntityRecipeHierarchyComponentState = {
+    /**
+     * The fixable violations.
+     */
+    readonly fixableViolations?: readonly string[];
+    /**
+     * The recipes to display. Can be a group of recipes or a list of recipes.
+     */
+    readonly recipes: GroupedRecipeItems;
+};
+/**
+ * Defines a hierarhcy of recipes that can be added as children of a given entity
+ */
+export declare const childEntityRecipeHierarchyComponent: import("../index.js").SystemComponentType<"childEntityRecipeHierarchy", ChildEntityRecipeHierarchyComponentState, never>;
+export type ChildEntityRecipeHierarchyComponent = typeof childEntityRecipeHierarchyComponent;
+export type ChildEntityRecipeHierarchyComponentSnapshot = ComponentSnapshot<typeof childEntityRecipeHierarchyComponent>;
+export type ChildEntityRecipeHierarchyComponentInstance = ComponentInstance<typeof childEntityRecipeHierarchyComponent>;
+export declare const isChildEntityRecipeHierarchySnapshot: (snapshot: ComponentSnapshot<SystemComponentTypeConstraint>) => snapshot is ChildEntityRecipeHierarchyComponentSnapshot;
+export declare const isChildEntityRecipeHierarchyInstance: (instance: ComponentInstance<SystemComponentTypeConstraint>) => instance is ChildEntityRecipeHierarchyComponentInstance;

package/dist/domain/extensions/child-entity-recipe-hierarchy.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as e}from"../core/index.js";import{GroupedRecipeItemsSchema as i}from"../system-components/index.js";export const childEntityRecipeHierarchyComponent=e.component("childEntityRecipeHierarchy").withState({type:"object",tsType:"ChildEntityRecipeHierarchyComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"ChildEntityRecipeHierarchyComponentState"}],properties:{recipes:i,fixableViolations:{type:"array",items:{type:"string"}}},definitions:{GroupedRecipeItems:i},required:["recipes"],additionalProperties:!1}).build();export const isChildEntityRecipeHierarchySnapshot=e=>e.componentInstance.componentType===childEntityRecipeHierarchyComponent;export const isChildEntityRecipeHierarchyInstance=e=>e.componentType===childEntityRecipeHierarchyComponent;

package/dist/domain/extensions/color-value.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as e}from"../core/index.js";export const ColorValueSchema={type:"object",tsType:"ColorValueSchema",import:[{module:"@salsita-ai/sdk/domain",member:"ColorValueSchema"}],properties:{value:{type:"string"}},required:["value"],additionalProperties:!1};export const colorValueComponent=e.component("colorValue").withState(ColorValueSchema).withWritableKeys(["value"]).build();

package/dist/domain/extensions/common/angle-indicator-schema.d.ts

@@ -0,0 +1,292 @@
+import { type Localizable } from '@salsita-ai/common/utils';
+import { type AngleUnit } from '../../dimensions/index.js';
+import type { DeepWritable } from '../../utils/deep-writable.js';
+export type AngleIndicatorBaseState = {
+    /**
+     * Vertex X coordinate in 3D space, related to the entity's origin.
+     */
+    readonly positionX: number;
+    /**
+     * Vertex Y coordinate in 3D space, related to the entity's origin.
+     */
+    readonly positionY: number;
+    /**
+     * Vertex Z coordinate in 3D space, related to the entity's origin.
+     */
+    readonly positionZ: number;
+    /**
+     * Starting direction of the arc in radians, measured in the component's angle convention.
+     */
+    readonly startAngle: number;
+    /**
+     * Angular span of the arc in radians, added to startAngle to determine the end direction.
+     */
+    readonly sweepAngle: number;
+    /**
+     * Additional rotation offset applied to the arc in radians.
+     */
+    readonly angleOffset?: number;
+    /**
+     * Diameter of the arc indicator. Default is 200 (mm if unit is also default).
+     */
+    readonly arcDiameter?: number;
+    /**
+     * Width of the arc and radial lines. Default is 1mm.
+     */
+    readonly lineWidth?: number;
+    /**
+     * Color of the arc and radial lines.
+     */
+    readonly indicatorLineColor?: string | number;
+    /**
+     * Set to true to make the indicator lines dashed.
+     */
+    readonly indicatorLineDashed?: boolean;
+    /**
+     * Scale of line dash. Larger values increase granularity. Default is 50.
+     */
+    readonly dashScale?: number;
+    /**
+     * URL of a custom font file to be used. Supported formats are .ttf, .otf, and .woff.
+     */
+    readonly labelFont?: string;
+    /**
+     * Font size of the indicator label. Default is 50 (mm if unit is also default).
+     */
+    readonly labelFontSize?: number;
+    /**
+     * Color of the label.
+     */
+    readonly labelColor?: string | number;
+    /**
+     * Base direction for the text.
+     */
+    readonly labelDirection?: 'auto' | 'ltr' | 'rtl';
+    /**
+     * Opacity of the glyph's fill area. Default is 1.
+     */
+    readonly labelFillOpacity?: number;
+    /**
+     * Font style, either 'italic' or 'normal'. Default is 'normal'.
+     */
+    readonly labelFontStyle?: 'normal' | 'italic';
+    /**
+     * Font weight: a number, or a keyword such as 'normal' or 'bold'.
+     */
+    readonly labelFontWeight?: number | string;
+    /**
+     * Spacing between letters. Default is 0.
+     */
+    readonly labelLetterSpacing?: number;
+    /**
+     * Line height as a multiple of the font size.
+     */
+    readonly labelLineHeight?: number;
+    /**
+     * Maximum width of the text block, beyond which text may wrap.
+     */
+    readonly labelMaxWidth?: number;
+    /**
+     * Blur radius for the outer edge of the text's outline.
+     */
+    readonly labelOutlineBlur?: number | string;
+    /**
+     * Color for the text outline.
+     */
+    readonly labelOutlineColor?: string | number;
+    /**
+     * Horizontal offset for the text outline.
+     */
+    readonly labelOutlineOffsetX?: number | string;
+    /**
+     * Vertical offset for the text outline.
+     */
+    readonly labelOutlineOffsetY?: number | string;
+    /**
+     * Opacity of the text outline (0-1). Default is 1.
+     */
+    readonly labelOutlineOpacity?: number;
+    /**
+     * Width of the outline drawn around each text glyph.
+     */
+    readonly labelOutlineWidth?: number | string;
+    /**
+     * How text wraps when maxWidth is set.
+     */
+    readonly labelOverflowWrap?: 'normal' | 'break-word';
+    /**
+     * Color of the stroke drawn inside the glyph paths.
+     */
+    readonly labelStrokeColor?: string | number;
+    /**
+     * Opacity of the stroke (0-1). Default is 1.
+     */
+    readonly labelStrokeOpacity?: number;
+    /**
+     * Width of the stroke drawn inside the glyph paths.
+     */
+    readonly labelStrokeWidth?: number | string;
+    /**
+     * How whitespace inside the text is handled.
+     */
+    readonly labelWhiteSpace?: 'normal' | 'nowrap' | 'pre-wrap';
+    /**
+     * Optional prefix rendered before the label text, separated by a space.
+     */
+    readonly labelPrefix?: Localizable;
+    /**
+     * Color of the label prefix.
+     */
+    readonly labelPrefixFontColor?: string | number;
+    /**
+     * If true, indicator will always render over other objects in view. Default is true.
+     */
+    readonly indicatorAlwaysVisible?: boolean;
+    /**
+     * Render order override for the indicator group. Default is 0.
+     */
+    readonly renderOrder?: number;
+    /**
+     * Whether the indicator should be sized in screen space (pixels) rather than world units.
+     */
+    readonly screenSized?: boolean;
+    /**
+     * Unit for the default label display. Defaults to 'degree'.
+     * Only affects the auto-generated label; has no effect when a custom `label` is provided.
+     */
+    readonly angleUnit?: AngleUnit;
+};
+declare const AngleIndicatorBasePropertiesTmp: {
+    readonly positionX: {
+        readonly type: 'number';
+    };
+    readonly positionY: {
+        readonly type: 'number';
+    };
+    readonly positionZ: {
+        readonly type: 'number';
+    };
+    readonly startAngle: {
+        readonly type: 'number';
+    };
+    readonly sweepAngle: {
+        readonly type: 'number';
+    };
+    readonly angleOffset: {
+        readonly type: 'number';
+    };
+    readonly arcDiameter: {
+        readonly type: 'number';
+    };
+    readonly lineWidth: {
+        readonly type: 'number';
+    };
+    readonly indicatorLineColor: {
+        readonly type: readonly ['string', 'number'];
+    };
+    readonly indicatorLineDashed: {
+        readonly type: 'boolean';
+    };
+    readonly dashScale: {
+        readonly type: 'number';
+    };
+    readonly labelFont: {
+        readonly type: 'string';
+    };
+    readonly labelFontSize: {
+        readonly type: 'number';
+    };
+    readonly labelColor: {
+        readonly type: readonly ['string', 'number'];
+    };
+    readonly labelDirection: {
+        readonly type: 'string';
+        readonly enum: readonly ['auto', 'ltr', 'rtl'];
+    };
+    readonly labelFillOpacity: {
+        readonly type: 'number';
+    };
+    readonly labelFontStyle: {
+        readonly type: 'string';
+        readonly enum: readonly ['normal', 'italic'];
+    };
+    readonly labelFontWeight: {
+        readonly type: readonly ['number', 'string'];
+    };
+    readonly labelLetterSpacing: {
+        readonly type: 'number';
+    };
+    readonly labelLineHeight: {
+        readonly type: 'number';
+    };
+    readonly labelMaxWidth: {
+        readonly type: 'number';
+    };
+    readonly labelOutlineBlur: {
+        readonly type: readonly ['number', 'string'];
+    };
+    readonly labelOutlineColor: {
+        readonly type: readonly ['string', 'number'];
+    };
+    readonly labelOutlineOffsetX: {
+        readonly type: readonly ['number', 'string'];
+    };
+    readonly labelOutlineOffsetY: {
+        readonly type: readonly ['number', 'string'];
+    };
+    readonly labelOutlineOpacity: {
+        readonly type: 'number';
+    };
+    readonly labelOutlineWidth: {
+        readonly type: readonly ['number', 'string'];
+    };
+    readonly labelOverflowWrap: {
+        readonly type: 'string';
+        readonly enum: readonly ['normal', 'break-word'];
+    };
+    readonly labelStrokeColor: {
+        readonly type: readonly ['string', 'number'];
+    };
+    readonly labelStrokeOpacity: {
+        readonly type: 'number';
+    };
+    readonly labelStrokeWidth: {
+        readonly type: readonly ['number', 'string'];
+    };
+    readonly labelWhiteSpace: {
+        readonly type: 'string';
+        readonly enum: readonly ['normal', 'nowrap', 'pre-wrap'];
+    };
+    readonly labelPrefix: {
+        readonly anyOf: [{
+            readonly type: 'string';
+        }, {
+            readonly $ref: '#/definitions/EnhancedMessageDescriptor';
+        }, {
+            readonly $ref: '#/definitions/MultilingualString';
+        }];
+        readonly import: [{
+            readonly module: '@salsita-ai/sdk/common/utils';
+            readonly member: 'EnhancedLocalizable';
+        }];
+        readonly tsType: 'EnhancedLocalizable';
+    };
+    readonly labelPrefixFontColor: {
+        readonly type: readonly ['string', 'number'];
+    };
+    readonly indicatorAlwaysVisible: {
+        readonly type: 'boolean';
+    };
+    readonly renderOrder: {
+        readonly type: 'number';
+    };
+    readonly screenSized: {
+        readonly type: 'boolean';
+    };
+    readonly angleUnit: {
+        readonly type: 'string';
+        readonly enum: ("degree" | "radian")[];
+    };
+};
+export declare const AngleIndicatorProperties: DeepWritable<typeof AngleIndicatorBasePropertiesTmp>;
+export {};

package/dist/domain/extensions/common/angle-indicator-schema.js

@@ -0,0 +1 @@
+import{EnhancedLocalizableSchema as e}from"@salsita-ai/common/utils";import{AngleUnitSchema as t}from"../../dimensions/index.js";export const AngleIndicatorProperties={positionX:{type:"number"},positionY:{type:"number"},positionZ:{type:"number"},startAngle:{type:"number"},sweepAngle:{type:"number"},angleOffset:{type:"number"},arcDiameter:{type:"number"},lineWidth:{type:"number"},indicatorLineColor:{type:["string","number"]},indicatorLineDashed:{type:"boolean"},dashScale:{type:"number"},labelFont:{type:"string"},labelFontSize:{type:"number"},labelColor:{type:["string","number"]},labelDirection:{type:"string",enum:["auto","ltr","rtl"]},labelFillOpacity:{type:"number"},labelFontStyle:{type:"string",enum:["normal","italic"]},labelFontWeight:{type:["number","string"]},labelLetterSpacing:{type:"number"},labelLineHeight:{type:"number"},labelMaxWidth:{type:"number"},labelOutlineBlur:{type:["number","string"]},labelOutlineColor:{type:["string","number"]},labelOutlineOffsetX:{type:["number","string"]},labelOutlineOffsetY:{type:["number","string"]},labelOutlineOpacity:{type:"number"},labelOutlineWidth:{type:["number","string"]},labelOverflowWrap:{type:"string",enum:["normal","break-word"]},labelStrokeColor:{type:["string","number"]},labelStrokeOpacity:{type:"number"},labelStrokeWidth:{type:["number","string"]},labelWhiteSpace:{type:"string",enum:["normal","nowrap","pre-wrap"]},labelPrefix:e,labelPrefixFontColor:{type:["string","number"]},indicatorAlwaysVisible:{type:"boolean"},renderOrder:{type:"number"},screenSized:{type:"boolean"},angleUnit:t};