@salsita-ai/sdk 0.50.0-develop.2331d4a6b7 → 0.50.0-develop.257ef311fd

package/dist/domain/components/system-virtual-entity.js

@@ -1 +0,0 @@
-import{createVirtualEntityId as t}from"../core/model.js";export const systemVirtualEntityId=t("system");

package/dist/domain/components/tool-state-component.d.ts

@@ -1,14 +0,0 @@
-import type { EntityId } from '../core/model.js';
-export type ToolStateComponentState = {
-    readonly activeState: string;
-};
-/**
- * Component used to hold tool state for system virtual entity. Use this only via NavigationSystem
- */
-export declare const toolStateComponent: import("../index.js").SystemComponentType<"toolState", ToolStateComponentState, "activeState">;
-/**
- * Component used to hold tool state for system virtual entity. Use this only via NavigationSystem
- */
-export type ToolStateComponent = typeof toolStateComponent;
-export declare const isToolStateComponentSnapshot: (entityId: EntityId) => (snapshot: import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentType<"toolState", ToolStateComponentState, "activeState">>;
-export declare const isSystemToolStateComponentSnapshot: (snapshot: import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentType<"toolState", ToolStateComponentState, "activeState">>;

package/dist/domain/components/tool-state-component.js

@@ -1 +0,0 @@
-import{isSnapshotInstance as t}from"../core/component.js";import{SystemComponentBuilder as o}from"./system-component-builder.js";import{systemVirtualEntityId as e}from"./system-virtual-entity.js";export const toolStateComponent=o.component("toolState").withState({type:"object",properties:{activeState:{type:"string"}},required:["activeState"],additionalProperties:!1}).withWritableKeys(["activeState"]).build();export const isToolStateComponentSnapshot=o=>t(o,"singleton",toolStateComponent);export const isSystemToolStateComponentSnapshot=t(e,"singleton",toolStateComponent);

package/dist/domain/components/updates.d.ts

@@ -1,108 +0,0 @@
-import type { Localizable } from '@salsita-ai/common/utils';
-import type { ComponentInstance, StateOfComponent, SystemComponentType, SystemComponentTypeConstraint, WritableStateOfComponent } from '../core/component.js';
-import type { DomainEntity, EntityByType, EntityId } from '../core/model.js';
-import type { OneComponentFilter } from './component-reader-types.js';
-export interface ComponentModification<COMPONENT_TYPE extends SystemComponentTypeConstraint> {
-    kind: 'modifyComponent';
-    entityId: EntityId;
-    updateTag: string;
-    hint?: Localizable;
-    componentInstance: ComponentInstance<COMPONENT_TYPE>;
-    writableState: WritableStateOfComponent<COMPONENT_TYPE>;
-    metadata?: Record<string, unknown>;
-}
-export declare const isComponentModificationOfType: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(componentType: COMPONENT_TYPE) => (update: StateUpdate<any, any>) => update is ComponentModification<COMPONENT_TYPE>;
-export interface EphemeralRecordModification<COMPONENT_TYPE extends SystemComponentTypeConstraint = SystemComponentTypeConstraint> {
-    kind: 'modifyEphemeralRecord';
-    entityId: EntityId;
-    updateTag: string;
-    hint?: Localizable;
-    componentInstance: ComponentInstance<COMPONENT_TYPE>;
-    writableState: WritableStateOfComponent<COMPONENT_TYPE>;
-}
-export interface EphemeralRecordCreation<COMPONENT_TYPE extends SystemComponentTypeConstraint = SystemComponentTypeConstraint> {
-    kind: 'createEphemeralRecord';
-    entityId: EntityId;
-    updateTag: string;
-    hint?: Localizable;
-    componentInstance: ComponentInstance<COMPONENT_TYPE>;
-    initialState: StateOfComponent<COMPONENT_TYPE>;
-}
-export interface EphemeralRecordDeletion<COMPONENT_TYPE extends SystemComponentTypeConstraint = SystemComponentTypeConstraint> {
-    kind: 'deleteEphemeralRecord';
-    entityId: EntityId;
-    componentInstance: ComponentInstance<COMPONENT_TYPE>;
-    updateTag: string;
-    hint?: Localizable;
-}
-export type DomainEntityStateDelta<ENTITY extends DomainEntity<string>> = Partial<Omit<ENTITY, 'id' | 'type'>>;
-export interface DomainEntityModification<ENTITY extends DomainEntity<string> = DomainEntity<string>> {
-    kind: 'modifyDomainEntity';
-    entityId: ENTITY['id'];
-    updateTag: string;
-    hint?: Localizable;
-    stateDelta: DomainEntityStateDelta<ENTITY>;
-    origin?: ComponentModification<SystemComponentTypeConstraint>;
-}
-export interface DomainEntityCreation<ENTITY extends DomainEntity<string>, PARENT extends DomainEntity<string>> {
-    kind: 'createDomainEntity';
-    entityId: ENTITY['id'];
-    entity: ENTITY;
-    updateTag: string;
-    /**
-     * Collection this entity is part of. This should be the instanceName of referenceComponents where this entity should be added.
-     */
-    collection?: string;
-    parentId: PARENT['id'];
-    hint?: Localizable;
-}
-export interface DomainEntityReplacement<ENTITY extends DomainEntity<string>> {
-    kind: 'replaceDomainEntity';
-    entityId: EntityId<ENTITY>;
-    replacementEntity: ENTITY;
-    updateTag: string;
-    keepChildren: boolean;
-    hint?: Localizable;
-}
-export interface EntityDeletion<ENTITY extends DomainEntity<string>> {
-    kind: 'deleteEntity';
-    entityId: EntityId<ENTITY>;
-    updateTag: string;
-    hint?: Localizable;
-}
-export type DataUpdate<ENTITY extends DomainEntity<string>, PARENT extends DomainEntity<string>> = EphemeralRecordModification | EphemeralRecordCreation | EphemeralRecordDeletion | DomainEntityModification<ENTITY> | DomainEntityCreation<ENTITY, PARENT> | DomainEntityReplacement<ENTITY> | EntityDeletion<ENTITY>;
-export type StateUpdate<ENTITY extends DomainEntity<string>, PARENT extends DomainEntity<string>> = ComponentModification<SystemComponentTypeConstraint> | DataUpdate<ENTITY, PARENT>;
-type ComponentUpdate<COMPONENT_TYPE extends SystemComponentTypeConstraint> = ComponentModification<COMPONENT_TYPE> | EphemeralRecordModification<COMPONENT_TYPE> | EphemeralRecordCreation<COMPONENT_TYPE> | EphemeralRecordDeletion<COMPONENT_TYPE>;
-type ComponentUpdateDetails<COMPONENT_TYPE extends SystemComponentTypeConstraint, UPDATE extends ComponentUpdate<COMPONENT_TYPE>> = {
-    readonly componentInstance: OneComponentFilter<COMPONENT_TYPE>;
-} & (COMPONENT_TYPE extends SystemComponentType<any, Record<never, never>, never> ? Omit<UPDATE, 'kind' | 'entityId' | 'componentInstance' | 'writableState' | 'initialState'> : Omit<UPDATE, 'kind' | 'entityId' | 'componentInstance'>);
-export declare const createUpdateFactory: <ENTITIES extends DomainEntity<string>>() => {
-    ComponentModification: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, ComponentModification<COMPONENT_TYPE>>) => ComponentModification<COMPONENT_TYPE>;
-    DomainEntityCreation: <ENTITY extends ENTITIES, PARENT extends ENTITIES>(details: Omit<DomainEntityCreation<ENTITY, PARENT>, 'kind' | 'entityId'>) => DomainEntityCreation<ENTITY, PARENT>;
-    DomainEntityReplacement: <ENTITY extends ENTITIES>(details: Omit<DomainEntityReplacement<ENTITY>, 'kind'>) => DomainEntityReplacement<ENTITY>;
-    EphemeralRecordCreation: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, EphemeralRecordCreation<COMPONENT_TYPE>>) => EphemeralRecordCreation<COMPONENT_TYPE>;
-    DomainEntityModification: <TYPE extends ENTITIES['type']>(details: Omit<DomainEntityModification<EntityByType<ENTITIES, TYPE>>, 'kind'>) => DomainEntityModification<EntityByType<ENTITIES, TYPE>>;
-    EphemeralRecordModification: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, EphemeralRecordModification<COMPONENT_TYPE>>) => EphemeralRecordModification<COMPONENT_TYPE>;
-    EphemeralRecordDeletion: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, EphemeralRecordDeletion<COMPONENT_TYPE>>) => EphemeralRecordDeletion<COMPONENT_TYPE>;
-    EntityDeletion: <ENTITY extends ENTITIES>(details: Omit<EntityDeletion<ENTITY>, 'kind'>) => EntityDeletion<ENTITY>;
-};
-export type UpdateFactory<ENTITIES extends DomainEntity<string>> = ReturnType<typeof createUpdateFactory<ENTITIES>>;
-/**
- * Factory for creating system updates. It is not typed to a specific domain.
- * This should never be used in a project code! It is just internal tool for sdk.
- */
-export declare const systemUpdateFactory: {
-    ComponentModification: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, ComponentModification<COMPONENT_TYPE>>) => ComponentModification<COMPONENT_TYPE>;
-    DomainEntityCreation: <ENTITY extends DomainEntity<string>, PARENT extends DomainEntity<string>>(details: Omit<DomainEntityCreation<ENTITY, PARENT>, "entityId" | "kind">) => DomainEntityCreation<ENTITY, PARENT>;
-    DomainEntityReplacement: <ENTITY extends DomainEntity<string>>(details: Omit<DomainEntityReplacement<ENTITY>, "kind">) => DomainEntityReplacement<ENTITY>;
-    EphemeralRecordCreation: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, EphemeralRecordCreation<COMPONENT_TYPE>>) => EphemeralRecordCreation<COMPONENT_TYPE>;
-    DomainEntityModification: <TYPE extends string>(details: Omit<DomainEntityModification<Extract<DomainEntity<string>, {
-        type: TYPE;
-    }>>, "kind">) => DomainEntityModification<Extract<DomainEntity<string>, {
-        type: TYPE;
-    }>>;
-    EphemeralRecordModification: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, EphemeralRecordModification<COMPONENT_TYPE>>) => EphemeralRecordModification<COMPONENT_TYPE>;
-    EphemeralRecordDeletion: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(details: ComponentUpdateDetails<COMPONENT_TYPE, EphemeralRecordDeletion<COMPONENT_TYPE>>) => EphemeralRecordDeletion<COMPONENT_TYPE>;
-    EntityDeletion: <ENTITY extends DomainEntity<string>>(details: Omit<EntityDeletion<ENTITY>, "kind">) => EntityDeletion<ENTITY>;
-};
-export {};

package/dist/domain/components/view-state-component.d.ts

@@ -1,14 +0,0 @@
-import type { EntityId } from '../core/model.js';
-export type ViewStateComponentState = {
-    readonly activeState: string;
-};
-/**
- * Component used to hold view state for system virtual entity. Use this only via NavigationSystem
- */
-export declare const viewStateComponent: import("../index.js").SystemComponentType<"viewState", ViewStateComponentState, "activeState">;
-/**
- * Component used to hold view state for system virtual entity. Use this only via NavigationSystem
- */
-export type ViewStateComponent = typeof viewStateComponent;
-export declare const isViewComponentSnapshot: (entityId: EntityId) => (snapshot: import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentType<"viewState", ViewStateComponentState, "activeState">>;
-export declare const isSystemViewComponentSnapshot: (snapshot: import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentType<"viewState", ViewStateComponentState, "activeState">>;

package/dist/domain/components/view-state-component.js

@@ -1 +0,0 @@
-import{isSnapshotInstance as t}from"../core/component.js";import{SystemComponentBuilder as e}from"./system-component-builder.js";import{systemVirtualEntityId as o}from"./system-virtual-entity.js";export const viewStateComponent=e.component("viewState").withState({type:"object",properties:{activeState:{type:"string"}},required:["activeState"],additionalProperties:!1}).withWritableKeys(["activeState"]).build();export const isViewComponentSnapshot=e=>t(e,"singleton",viewStateComponent);export const isSystemViewComponentSnapshot=t(o,"singleton",viewStateComponent);

package/dist/domain/components/viewport-state-component.d.ts

@@ -1,29 +0,0 @@
-import type { EntityId } from '../core/model.js';
-/**
- * A responsive class the configurator container currently satisfies. The values mirror the
- * responsive flags computed by the UI layer from the theme breakpoints (`isPhone`, `isMobile`,
- * `isTablet`, `isDesktop`, `isLandscape`, `isPortrait`), so several can be active at once —
- * a 600px wide container is `mobile` and `tablet` at the same time.
- */
-export type Viewport = 'phone' | 'mobile' | 'tablet' | 'desktop' | 'landscape' | 'portrait';
-export declare const VIEWPORTS: readonly ["phone", "mobile", "tablet", "desktop", "landscape", "portrait"];
-export type ViewportStateComponentState = {
-    /**
-     * Every viewport class the container currently satisfies, or `null` while nothing has measured
-     * the container yet (image rendering, tests, non-browser evaluation). Component filters skip
-     * their `viewports` criterion while the value is `null`.
-     */
-    readonly active: readonly Viewport[] | null;
-};
-/**
- * Component used to hold the active responsive viewport classes for the system virtual entity.
- * Seeded by the NavigationSystem and written by the configurator UI whenever the responsive
- * flags change. Use this only via NavigationSystem.
- */
-export declare const viewportStateComponent: import("../index.js").SystemComponentType<"viewportState", ViewportStateComponentState, "active">;
-/**
- * Component used to hold the active responsive viewport classes for the system virtual entity. Use this only via NavigationSystem
- */
-export type ViewportStateComponent = typeof viewportStateComponent;
-export declare const isViewportStateComponentSnapshot: (entityId: EntityId) => (snapshot: import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentType<"viewportState", ViewportStateComponentState, "active">>;
-export declare const isSystemViewportStateComponentSnapshot: (snapshot: import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentTypeConstraint>) => snapshot is import("../index.js").ComponentSnapshot<import("../index.js").SystemComponentType<"viewportState", ViewportStateComponentState, "active">>;

package/dist/domain/components/viewport-state-component.js

@@ -1 +0,0 @@
-import{isSnapshotInstance as t}from"../core/component.js";import{SystemComponentBuilder as e}from"./system-component-builder.js";import{systemVirtualEntityId as o}from"./system-virtual-entity.js";export const VIEWPORTS=["phone","mobile","tablet","desktop","landscape","portrait"];export const viewportStateComponent=e.component("viewportState").withState({type:"object",properties:{active:{oneOf:[{type:"array",items:{type:"string",enum:[...VIEWPORTS]}},{type:"null"}]}},required:["active"],additionalProperties:!1,tsType:"ViewportStateComponentState",import:[{module:"@salsita-ai/sdk/domain",member:"ViewportStateComponentState"}]}).withWritableKeys(["active"]).build();export const isViewportStateComponentSnapshot=e=>t(e,"singleton",viewportStateComponent);export const isSystemViewportStateComponentSnapshot=t(o,"singleton",viewportStateComponent);

package/dist/domain/core/component.d.ts

@@ -1,46 +0,0 @@
-import { type ExtendedJsonSchema } from '@salsita-ai/common/utils';
-import type { EntityId } from './model.js';
-import type { PhxValidateFunction } from './schema-validator.js';
-/**
- * Definition of how the component looks like, it's name, state and other properties. It is used to instantiate components.
- */
-export interface SystemComponentType<NAME extends string, COMPONENT_STATE extends Record<string, unknown>, WRITABLE_KEYS extends keyof COMPONENT_STATE> {
-    readonly name: NAME;
-    readonly writableKeys: WRITABLE_KEYS[];
-    readonly schema: ExtendedJsonSchema;
-    readonly validateState: PhxValidateFunction<COMPONENT_STATE>;
-    readonly validateWritableState: PhxValidateFunction<Pick<COMPONENT_STATE, WRITABLE_KEYS>>;
-}
-/**
- * Concrete version of SystemComponentType with the widest possible constraints. Use it when you don't care about generic constraints
- * of component types, eg. in extend expressions.
- */
-export type SystemComponentTypeConstraint = SystemComponentType<string, Record<string, unknown>, string>;
-/**
- * Instantiation of a component for a specific entity and instance name. It is used as concrete identification of a component in the system.
- */
-export interface ComponentInstance<COMPONENT_TYPE extends SystemComponentTypeConstraint> {
-    readonly entityId: EntityId;
-    readonly instanceName: string;
-    readonly componentType: COMPONENT_TYPE;
-}
-export declare const isInstanceOfComponentType: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(componentType: COMPONENT_TYPE) => (instance: ComponentInstance<SystemComponentTypeConstraint>) => instance is ComponentInstance<COMPONENT_TYPE>;
-/**
- * Checks if two component instances are equal - are of same ComponentType, belong to the same entity and have the same instance name.
- */
-export declare const isEqualComponentInstance: (a: ComponentInstance<SystemComponentTypeConstraint>, b: ComponentInstance<SystemComponentTypeConstraint>) => boolean;
-export type StateOfComponent<COMPONENT_TYPE extends SystemComponentTypeConstraint> = COMPONENT_TYPE extends SystemComponentType<any, infer COMPONENT_STATE, any> ? COMPONENT_STATE : never;
-export type WritableStateOfComponent<COMPONENT_TYPE extends SystemComponentTypeConstraint> = COMPONENT_TYPE extends SystemComponentType<any, infer COMPONENT_STATE, infer WRITABLE_KEYS> ? Pick<COMPONENT_STATE, WRITABLE_KEYS> : never;
-/**
- * Instantiated component for a given entity/instanceName with a state. Snapshots are returned from the component reader.
- */
-export interface ComponentSnapshot<COMPONENT_TYPE extends SystemComponentTypeConstraint> {
-    readonly componentInstance: ComponentInstance<COMPONENT_TYPE>;
-    readonly state: StateOfComponent<COMPONENT_TYPE>;
-}
-export declare const isEqualComponentSnapshot: (a: ComponentSnapshot<SystemComponentTypeConstraint>, b: ComponentSnapshot<SystemComponentTypeConstraint>) => boolean;
-export declare const areEqualComponentSnapshots: (a: ReadonlyArray<ComponentSnapshot<SystemComponentTypeConstraint>>, b: ReadonlyArray<ComponentSnapshot<SystemComponentTypeConstraint>>) => boolean;
-export declare const isSnapshotOfComponentType: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(componentType: COMPONENT_TYPE) => (snapshot: ComponentSnapshot<SystemComponentTypeConstraint>) => snapshot is ComponentSnapshot<COMPONENT_TYPE>;
-export declare const isSnapshotInstance: <COMPONENT_TYPE extends SystemComponentTypeConstraint>(entityId: EntityId, instanceName: string, componentType: COMPONENT_TYPE) => (snapshot: ComponentSnapshot<SystemComponentTypeConstraint>) => snapshot is ComponentSnapshot<COMPONENT_TYPE>;
-export declare const getComponentInstanceKey: (componentInstance: ComponentInstance<SystemComponentTypeConstraint>) => string;
-export declare const getComponentSnapshotKey: (snapshot: ComponentSnapshot<SystemComponentTypeConstraint>) => string;

package/dist/domain/core/expression.d.ts

@@ -1,50 +0,0 @@
-import type { SessionRole } from '@salsita-ai/contracts/api';
-import type { ComponentReader } from '../domain-runtime/domain-context/index.js';
-import type { CollisionProjections, ConstraintProjections, PositionProjections, ProjectedEntitiesProjections, SnappingProjections } from '../projections/index.js';
-import type { SketchingProjections } from '../sketching/index.js';
-import type { TypeOrAlias } from './alias.js';
-import type { Domain } from './domain.js';
-import type { MigrateFunction } from './migrations.js';
-import type { $DomainEntity, DomainEntity } from './model.js';
-import type { DomainState } from './state.js';
-export interface ExpressionContext<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>> {
-    readonly mode: 'owner' | 'read' | 'finalize';
-    readonly role: SessionRole;
-    readonly publishedData: PUBLISHED_DATA;
-    readonly frontendData: FRONTEND_DATA;
-    readonly backendData: Record<string, unknown> | undefined;
-    readonly sessionData: SESSION_DATA;
-    readonly domain: Domain<ENTITIES, ALLOWED_ROOT_ENTITIES, Record<ENTITIES['type'], $DomainEntity<ENTITIES>>>;
-    readonly componentReader: ComponentReader<ENTITIES>;
-    readonly migrate: MigrateFunction<ENTITIES>;
-    readonly positionProjections: PositionProjections<ENTITIES>;
-    readonly sketchingProjections: SketchingProjections<ENTITIES>;
-    readonly collisionProjections: CollisionProjections<ENTITIES>;
-    readonly constraintProjections: ConstraintProjections<ENTITIES>;
-    readonly snappingProjections: SnappingProjections<ENTITIES>;
-    readonly projectedEntitiesProjections: ProjectedEntitiesProjections<ENTITIES>;
-}
-export type AnyExpressionContext = ExpressionContext<any, any, any, any, any>;
-export interface ExpressionMeta {
-    /**
-     * By enabling this flag, expression will be run during validation. It is primarily used to check validity of relations.
-     */
-    readonly alwaysEvaluate?: boolean;
-}
-export type ExpressionMetas<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>> = Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, ExpressionMeta>>>;
-/**
- * Metadata used for debugging of expression exceptions.
- */
-export interface ExpressionOrigin {
-    readonly typeOrAlias: string;
-    readonly name: string;
-}
-export interface AnonymousExpression<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, SELF extends ENTITIES, T> {
-    evaluate(selfId: SELF['id'], state: DomainState<ENTITIES>, ctx: ExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>): T;
-    readonly meta: ExpressionMeta;
-}
-export interface Expression<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, SELF extends ENTITIES, T> extends AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, SELF, T> {
-    readonly origin: ExpressionOrigin;
-}
-export type AnyExpression = Expression<any, any, any, any, any, any, any>;
-export type AnyExpressions = Record<string, Record<string, AnyExpression>>;

package/dist/domain/core/json-schema.js

@@ -1 +0,0 @@
-import{createAjvSchemaValidator as e}from"./schema-validator-ajv.js";import{createCspSchemaValidator as a}from"./schema-validator-csp.js";let d="csp-compatible"===globalThis.PHX_SCHEMA_VALIDATOR?a:e;export const getExtendedSchemaValidator=()=>{let e=d();return e.addKeyword("tsType"),e.addKeyword("import"),e.addKeyword("declared"),e};export const extendedSchemaValidator=getExtendedSchemaValidator();

package/dist/domain/core/migrations.d.ts

@@ -1,99 +0,0 @@
-import { type Logger } from '@salsita-ai/common/utils';
-import type { DomainEntity } from './model.js';
-import type { EntityReflections } from './reflection.js';
-/**
- * Thrown when domain state cannot be validated/migrated to the latest model
- * version: an entity is invalid against its schema, an entity type or model
- * version is unknown, or a migration is missing.
- */
-export declare class StateMigrationError extends Error {
-    constructor(message: string);
-}
-export declare const isStateMigrationError: (error: unknown) => error is StateMigrationError;
-/**
- * Migration between two consecutive versions of the model.
- */
-export type Migration<FROM extends DomainEntity<string>, TO extends DomainEntity<string>> = (state: readonly FROM[]) => readonly TO[];
-/**
- * Domain state (array of entities) with a version number attached.
- */
-export interface VersionedState<VERSION extends number, ENTITIES extends DomainEntity<string>> {
-    version: VERSION;
-    state: readonly ENTITIES[];
-}
-/**
- * Simple helper type to extract the entity types from their reflections.
- */
-type EntitiesOfReflections<REFLECTIONS extends EntityReflections<DomainEntity<string>>> = REFLECTIONS extends EntityReflections<infer ENTITIES> ? ENTITIES : never;
-/**
- * Union of all versioned states for all versions of the model.
- */
-export type AnyVersionedState<VERSIONS extends Record<number, EntityReflections<any>>> = {
-    [VERSION in keyof VERSIONS & number]: VersionedState<VERSION, EntitiesOfReflections<VERSIONS[VERSION]>>;
-}[keyof VERSIONS & number];
-export interface MigrateFunctionOptions {
-    logger?: Logger;
-    /**
-     * If true, extra properties in entities will be removed during migration.
-     *
-     * This should be set to `true` in production environment ONLY. In all other environments, extra properties should
-     * cause the migration to fail.
-     */
-    trimExtraProperties: boolean;
-}
-/**
- * Function that migrates the state between any arbitrary versions of the model always to the latest version.
- */
-export type MigrateFunction<LATEST_ENTITIES extends DomainEntity<string>> = (versionedState: {
-    version: number;
-    state: ReadonlyArray<DomainEntity<string>>;
-}, options: MigrateFunctionOptions) => readonly LATEST_ENTITIES[];
-/**
- * Builder for the state migration function.
- * @example
-
- export const migrateState = MigrateFunctionBuilder
-
-   // the reflections are used for validation and sanitization
-   .fromVersions({
-     1: v1Reflections,
-     2: v2Reflections,
-     3: v3Reflections,
-   })
-
-   // the latest version of the model
-   .to(2)
-
-   // the migrations between the versions
-   .using({
-     2: migrationToV2,
-     3: migrationToV3,
-   })
-
-   .build()
-
- */
-export declare const MigrateFunctionBuilder: {
-    /**
-     * Provide the entity reflections for all versions of the model.
-     */
-    fromVersions: <VERSIONS extends Record<number, EntityReflections<any>>>(modelVersions: VERSIONS) => {
-        /**
-         * Specify the latest version of the model. I.e. the version to which the state will be migrated.
-         */
-        to: <LATEST extends keyof VERSIONS & number>(latestVersion: LATEST) => {
-            /**
-             * Provide the migrations between each consecutive version of the model.
-             *
-             * Migration with index `i` should migrate the state from version `i - 1` to version `i`.
-             */
-            using: (migrations: Record<Exclude<keyof VERSIONS, 1>, Migration<any, any>>) => {
-                /**
-                 * Finally, build the migration function.
-                 */
-                build: () => MigrateFunction<EntitiesOfReflections<VERSIONS[LATEST]>>;
-            };
-        };
-    };
-};
-export {};

package/dist/domain/core/migrations.js

@@ -1 +0,0 @@
-import e from"lodash-es/pick.js";export class StateMigrationError extends Error{constructor(e){super(e),this.name="StateMigrationError"}}export const isStateMigrationError=e=>e instanceof StateMigrationError;let t=(t,r,i,o)=>t.map(t=>{let n=r[t.type];if(!n)throw new StateMigrationError(`Unknown entity type "${t.type}". The state contains an entity whose type is not registered in the domain model for this version. Fix: register the entity type in the domain spec, or remove/migrate the stale entity from the preset or configuration data.`);if(n._meta.validator(t))return t;if(i){let r=e(t,Object.keys(n._meta.schema.properties));if(n._meta.validator(t))return o?.error(`Entity ${t.type}#${t.id} had extra fields that had to be trimmed: ${Object.keys(r)}`),r}throw new StateMigrationError(`Entity "${t.type}#${t.id}" does not match its schema in the current domain model. Validation errors: ${JSON.stringify(n._meta.validator.errors)}. Fix: update the entity data to match the schema, add a migration that transforms older data into the current shape, or re-register the schema if it changed.`)});export const MigrateFunctionBuilder={fromVersions:e=>({to:r=>({using:i=>({build:()=>(o,{logger:n,trimExtraProperties:a})=>{let s=e[o.version];if(!s)throw new StateMigrationError(`Unknown model version ${o.version}. The state declares a version that has no registered reflections. Fix: register the version in MigrateFunctionBuilder.fromVersions({ ... }), or correct the version stored on the state.`);let d=t(o.state,s,a,n);o.version===r?n?.debug(`State is already in the latest version ${r}`):n?.debug(`Migrating state from version ${o.version} to ${r}`);for(let s=o.version;s<r;s++){n?.debug(`Applying intermediate migration to version ${s+1}`);let h=e[s+1];if(!h)throw new StateMigrationError(`Unknown model version ${s+1} while migrating from ${o.version} to ${r}. An intermediate version has no registered reflections. Fix: register version ${s+1} in MigrateFunctionBuilder.fromVersions({ ... }).`);let g=i[s+1];if(!g)throw new StateMigrationError(`Missing migration from version ${s} to ${s+1}. No migration is registered for this step while migrating to ${r}. Fix: add the migration in MigrateFunctionBuilder.using({ ${s+1}: ... }).`);d=t(g(d),h,a,n)}if(!e[o.version])throw new StateMigrationError(`Unknown model version ${o.version}. The state declares a version that has no registered reflections. Fix: register the version in MigrateFunctionBuilder.fromVersions({ ... }), or correct the version stored on the state.`);return d}})})})};

package/dist/domain/core/model.d.ts

@@ -1,127 +0,0 @@
-declare const VirtualEntityIdSymbol: unique symbol;
-export interface VirtualEntityId {
-    [VirtualEntityIdSymbol]: true;
-    name: string;
-    toString: () => string;
-}
-export declare const VirtualEntityIdSchema: {
-    readonly type: 'object';
-    readonly properties: {
-        readonly [VirtualEntityIdSymbol]: {
-            readonly type: 'boolean';
-            readonly const: true;
-        };
-        readonly name: {
-            readonly type: 'string';
-        };
-    };
-    readonly required: ["name"];
-    readonly additionalProperties: false;
-    readonly import: [{
-        readonly module: '@salsita-ai/sdk/domain';
-        readonly member: 'VirtualEntityId';
-    }];
-    readonly tsType: 'VirtualEntityId';
-};
-export declare const createVirtualEntityId: (name: string) => VirtualEntityId;
-export declare const isVirtualEntityId: (value: EntityId<any>) => value is VirtualEntityId;
-export type DomainEntityId<TYPE extends string> = `${TYPE}-${number}` & {
-    __brand: TYPE;
-};
-/**
- * This function is meant for internal use and for test fixtures only.
- * **DO NOT USE IT IN PRODUCTION CODE.**
- */
-export declare const _unsafeBuildDomainEntityId: <TYPE extends string>(type: TYPE, sequenceNumber: number) => DomainEntityId<TYPE>;
-export declare const parseDomainEntityId: <TYPE extends string>(id: DomainEntityId<TYPE>) => {
-    type: TYPE;
-    sequenceNumber: number;
-};
-export declare const domainEntityTypeFromId: <TYPE extends string>(id: DomainEntityId<TYPE>) => TYPE;
-export declare const isDomainEntityId: <ENTITIES extends DomainEntity<string> = DomainEntity<string>>(value: EntityId<ENTITIES>) => value is ENTITIES['id'];
-export declare const isEqualEntityTypeAndId: (a: DomainEntity<string>, b: DomainEntity<string>) => boolean;
-export declare const DomainEntityIdSchema: {
-    readonly type: 'string';
-    readonly pattern: '^[A-Z]\\w*-\\d+$';
-    readonly import: [{
-        readonly module: '@salsita-ai/sdk/domain';
-        readonly member: 'DomainEntityId';
-    }];
-    readonly tsType: 'DomainEntityId';
-};
-export type EntityId<ENTITY extends DomainEntity<string> = DomainEntity<string>> = ENTITY['id'] | VirtualEntityId;
-export declare const EntityIdSchema: {
-    readonly anyOf: [{
-        readonly type: 'string';
-        readonly pattern: '^[A-Z]\\w*-\\d+$';
-        readonly import: [{
-            readonly module: '@salsita-ai/sdk/domain';
-            readonly member: 'DomainEntityId';
-        }];
-        readonly tsType: 'DomainEntityId';
-    }, {
-        readonly type: 'object';
-        readonly properties: {
-            readonly [VirtualEntityIdSymbol]: {
-                readonly type: 'boolean';
-                readonly const: true;
-            };
-            readonly name: {
-                readonly type: 'string';
-            };
-        };
-        readonly required: ["name"];
-        readonly additionalProperties: false;
-        readonly import: [{
-            readonly module: '@salsita-ai/sdk/domain';
-            readonly member: 'VirtualEntityId';
-        }];
-        readonly tsType: 'VirtualEntityId';
-    }];
-};
-export interface DomainEntity<TYPE extends string> {
-    type: TYPE;
-    id: DomainEntityId<TYPE>;
-}
-export declare const DomainEntitySchema: {
-    readonly type: 'object';
-    readonly properties: {
-        readonly id: {
-            readonly $ref: '#/definitions/DomainEntityId';
-        };
-        readonly type: {
-            readonly type: 'string';
-        };
-    };
-    readonly import: [{
-        readonly module: '@salsita-ai/sdk/domain';
-        readonly member: 'DomainEntity';
-    }];
-    readonly tsType: 'DomainEntity';
-};
-export type $DomainEntity<ENTITY extends DomainEntity<string>> = ENTITY & {
-    _raw: ENTITY;
-};
-export declare const $DomainEntitySchema: {
-    readonly type: 'object';
-    readonly properties: {
-        readonly _raw: {
-            readonly $ref: '#/definitions/DomainEntity';
-        };
-        readonly id: {
-            readonly $ref: '#/definitions/DomainEntityId';
-        };
-        readonly type: {
-            readonly type: 'string';
-        };
-    };
-    readonly import: [{
-        readonly module: '@salsita-ai/sdk/domain';
-        readonly member: '$DomainEntity';
-    }];
-    readonly tsType: '$DomainEntity';
-};
-export type EntityByType<ENTITIES extends DomainEntity<string>, TYPE extends ENTITIES['type']> = Extract<ENTITIES, {
-    type: TYPE;
-}>;
-export {};

package/dist/domain/core/reflection.d.ts

@@ -1,114 +0,0 @@
-import type { ExtendedJsonSchema } from '@salsita-ai/common/utils';
-import { type $DomainEntity, type DomainEntity, type EntityByType, type EntityId } from './model.js';
-import type { PhxValidateFunction } from './schema-validator.js';
-type RequiredKeys<T> = {
-    [K in keyof T]: undefined extends T[K] ? never : K;
-}[keyof T];
-export type SchemaOfObject<T extends object> = ExtendedJsonSchema & {
-    type: 'object';
-    properties: {
-        [K in keyof T]: ExtendedJsonSchema;
-    };
-    required: Array<RequiredKeys<T>>;
-    additionalProperties: false;
-};
-interface SchemaReflectionMeta<T, S extends ExtendedJsonSchema> {
-    readonly name: string;
-    readonly schema: S;
-    readonly validator: PhxValidateFunction<T>;
-}
-export type PartialSchemaOfObject<T extends object> = ExtendedJsonSchema & {
-    type: 'object';
-    properties: {
-        [K in keyof T]?: ExtendedJsonSchema;
-    };
-    required: Array<RequiredKeys<T>>;
-    additionalProperties: false;
-};
-export declare class SchemaReflection<T, S extends ExtendedJsonSchema = ExtendedJsonSchema> {
-    readonly _meta: SchemaReflectionMeta<T, S>;
-    constructor(name: string, schema: S);
-    is: (value: unknown) => value is T;
-    assert(value: unknown): asserts value is T;
-}
-export declare class EnumReflection<T extends string> extends SchemaReflection<T, ExtendedJsonSchema & {
-    readonly enum: T[];
-}> {
-    constructor(name: string, schema: ExtendedJsonSchema & {
-        readonly enum: T[];
-    });
-    values: () => T[];
-}
-export type EnumLike<T extends string> = EnumReflection<T> & {
-    [K in T]: K;
-};
-declare class BaseDomainEntityReflection<UNKNOWN extends DomainEntity<string> | $DomainEntity<DomainEntity<string>>, ENTITY extends UNKNOWN> {
-    readonly type: ENTITY['type'];
-    constructor(type: ENTITY['type']);
-    is: (entity: UNKNOWN) => entity is ENTITY;
-    assert(entity: UNKNOWN): asserts entity is ENTITY;
-    isId: (entityId: EntityId) => entityId is ENTITY['id'];
-    assertId(entityId: EntityId): asserts entityId is ENTITY['id'];
-    assertIds(entityIds: readonly EntityId[]): asserts entityIds is ReadonlyArray<ENTITY['id']>;
-}
-export declare class DomainEntityReflection<ENTITY extends DomainEntity<string>> extends BaseDomainEntityReflection<DomainEntity<string>, ENTITY> {
-    readonly _meta: SchemaReflectionMeta<ENTITY, SchemaOfObject<ENTITY>>;
-    constructor(type: ENTITY['type'], schemas: Array<PartialSchemaOfObject<ENTITY>>);
-}
-/**
- * Expression member names of an enhanced entity type — the keys an enhanced reflection may
- * expose as module-level constants.
- */
-export type ExpressionKeys<ENTITY> = Extract<keyof ENTITY, `$${string}`>;
-declare class $DomainEntityReflectionClass<ENTITY extends $DomainEntity<DomainEntity<string>>, CONSTANT_KEYS extends ExpressionKeys<ENTITY>> extends BaseDomainEntityReflection<$DomainEntity<DomainEntity<string>>, ENTITY> {
-    readonly expressions: string[];
-    constructor(type: ENTITY['type'], expressions: string[], constants: Pick<ENTITY, CONSTANT_KEYS>);
-}
-/**
- * Enhanced entity reflection: knows the entity's expression names and exposes its self-free
- * `constants:` values as own members, so `phx.domain.enhancedModel.$Wall.$maxWidth` reads a
- * constant without an entity instance. `CONSTANT_KEYS` names the exposed constants; their types
- * come from the entity's expression types.
- */
-export type $DomainEntityReflection<ENTITY extends $DomainEntity<DomainEntity<string>>, CONSTANT_KEYS extends ExpressionKeys<ENTITY> = never> = $DomainEntityReflectionClass<ENTITY, CONSTANT_KEYS> & Pick<ENTITY, CONSTANT_KEYS>;
-interface $DomainEntityReflectionConstructor {
-    new <ENTITY extends $DomainEntity<DomainEntity<string>>, CONSTANT_KEYS extends ExpressionKeys<ENTITY> = never>(type: ENTITY['type'], expressions: string[], constants: Pick<ENTITY, CONSTANT_KEYS>): $DomainEntityReflection<ENTITY, CONSTANT_KEYS>;
-}
-export declare const $DomainEntityReflection: $DomainEntityReflectionConstructor;
-export type Any$EntityReflections = Record<string, $DomainEntityReflection<$DomainEntity<DomainEntity<string>>>>;
-declare class BaseAliasReflection<UNKNOWN extends DomainEntity<string> | $DomainEntity<DomainEntity<string>>, ENTITIES extends UNKNOWN> {
-    readonly name: string;
-    readonly types: ReadonlyArray<ENTITIES['type']>;
-    readonly typeSet: Set<ENTITIES['type']>;
-    constructor(name: string, types: ReadonlyArray<ENTITIES['type']>);
-    is: (entity: UNKNOWN) => entity is ENTITIES;
-    assert(entity: UNKNOWN): asserts entity is ENTITIES;
-    isId: (entityId: EntityId) => entityId is ENTITIES['id'];
-    assertId(entityId: EntityId): asserts entityId is ENTITIES['id'];
-    assertIds(entityIds: readonly EntityId[]): asserts entityIds is ReadonlyArray<ENTITIES['id']>;
-}
-export declare class RawAliasReflection<ENTITIES extends DomainEntity<string>> extends BaseAliasReflection<DomainEntity<string>, ENTITIES> {
-    readonly reflections: ReadonlyArray<ENTITIES extends any ? DomainEntityReflection<ENTITIES> : never>;
-    constructor(name: string, reflections: ReadonlyArray<ENTITIES extends any ? DomainEntityReflection<ENTITIES> : never>);
-}
-declare class EnhancedAliasReflectionClass<ENTITIES extends $DomainEntity<DomainEntity<string>>, CONSTANT_KEYS extends ExpressionKeys<ENTITIES>> extends BaseAliasReflection<$DomainEntity<DomainEntity<string>>, ENTITIES> {
-    constructor(name: string, types: ReadonlyArray<ENTITIES['type']>, constants: Pick<ENTITIES, CONSTANT_KEYS>);
-}
-/**
- * Enhanced alias reflection: the alias membership check plus the alias-declared self-free
- * `constants:` values as own members (`phx.domain.enhancedModel.$TopElement.$defaultHeight`).
- * Alias expressions exist on every member, so `CONSTANT_KEYS` picks from the member union.
- */
-export type EnhancedAliasReflection<ENTITIES extends $DomainEntity<DomainEntity<string>>, CONSTANT_KEYS extends ExpressionKeys<ENTITIES> = never> = EnhancedAliasReflectionClass<ENTITIES, CONSTANT_KEYS> & Pick<ENTITIES, CONSTANT_KEYS>;
-interface EnhancedAliasReflectionConstructor {
-    new <ENTITIES extends $DomainEntity<DomainEntity<string>>, CONSTANT_KEYS extends ExpressionKeys<ENTITIES> = never>(name: string, types: ReadonlyArray<ENTITIES['type']>, constants: Pick<ENTITIES, CONSTANT_KEYS>): EnhancedAliasReflection<ENTITIES, CONSTANT_KEYS>;
-}
-export declare const EnhancedAliasReflection: EnhancedAliasReflectionConstructor;
-export type EntityReflections<ENTITIES extends DomainEntity<string>> = {
-    [TYPE in ENTITIES['type']]: DomainEntityReflection<EntityByType<ENTITIES, TYPE>>;
-};
-export type AnyEntityReflections = Record<string, DomainEntityReflection<DomainEntity<string>>>;
-export declare function assertString(value: unknown): asserts value is string;
-export declare function assertNumber(value: unknown): asserts value is number;
-export declare function assertBoolean(value: unknown): asserts value is boolean;
-export {};