@salsita-ai/sdk 0.50.0-develop.6d8967bc99 → 0.50.0-develop.70dc8d05b6

package/dist/domain/core/invariant/invariants.d.ts

@@ -1,76 +1,10 @@
-import type { OmitNever } from '@salsita-ai/common/utils';
-import { type ProjectModule } from '../../project-modules/index.js';
-import type { AnonymousExpression, ExpressionContext } from '../expression/index.js';
-import { type $DomainEntity, type AliasMap, type DomainEntity, type EntityByType, type EventualAlias, type ExpandAlias, type ExtractFromAliasedRecord, type TypeOrAlias } from '../model/index.js';
+import type { OpenExpressionContext } from '../expression/index.js';
+import type { DomainEntity, ExpandAlias, TypeOrAlias } from '../model/index.js';
 import type { DomainState } from '../state/index.js';
 import { type Violation } from './violation.js';
-export interface Invariant<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>, ENTITY extends ENTITIES, VIOLATION_TYPE extends string> {
-    evaluate(selfId: ENTITY['id'], state: DomainState<ENTITIES>, ctx: ExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>): ReadonlyArray<Violation<VIOLATION_TYPE>>;
+export interface Invariant<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>, ENTITY extends ENTITIES, VIOLATION_TYPE extends string, CONTEXT_EXTENSION = unknown> {
+    evaluate(selfId: ENTITY['id'], state: DomainState<ENTITIES>, ctx: OpenExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, CONTEXT_EXTENSION>): ReadonlyArray<Violation<VIOLATION_TYPE>>;
 }
 export type AliasedInvariants<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>, ALIASES extends Record<string, ENTITIES>, VIOLATION_TYPES extends string> = {
     [K in TypeOrAlias<ENTITIES, ALIASES>]?: ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, K>, VIOLATION_TYPES>>;
 };
-export type DeclaredInvariants<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>> = {
-    readonly [TYPE in ENTITIES['type']]: '$violations' extends keyof $MAP[TYPE] ? $MAP[TYPE]['$violations'] extends () => ReadonlyArray<Violation<infer VIOLATION_TYPE>> ? ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, VIOLATION_TYPE>> : never : never;
-};
-type ConflictingInvariants<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>, EXPECTED extends Partial<Record<ENTITIES['type'], ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>>, IMPLEMENTED extends Partial<Record<ENTITIES['type'], ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>>> = OmitNever<{
-    [K in keyof EXPECTED]: EXPECTED[K] extends [never] ? never : K extends keyof IMPLEMENTED ? ViolationTypeOfInvariants<EXPECTED[K]> extends ViolationTypeOfInvariants<IMPLEMENTED[K]> ? ViolationTypeOfInvariants<IMPLEMENTED[K]> extends ViolationTypeOfInvariants<EXPECTED[K]> ? never : {
-        missing: Exclude<ViolationTypeOfInvariants<EXPECTED[K]>, ViolationTypeOfInvariants<IMPLEMENTED[K]>>;
-        extra: Exclude<ViolationTypeOfInvariants<IMPLEMENTED[K]>, ViolationTypeOfInvariants<EXPECTED[K]>>;
-    } : {
-        missing: Exclude<ViolationTypeOfInvariants<EXPECTED[K]>, ViolationTypeOfInvariants<IMPLEMENTED[K]>>;
-        extra: Exclude<ViolationTypeOfInvariants<IMPLEMENTED[K]>, ViolationTypeOfInvariants<EXPECTED[K]>>;
-    } : {
-        missing: ViolationTypeOfInvariants<EXPECTED[K]>;
-        extra: never;
-    };
-}>;
-type ViolationOfInvariants<INVARIANTS> = INVARIANTS extends ReadonlyArray<infer INVARIANT> ? INVARIANT : never;
-type ViolationTypeOfInvariants<INVARIANTS> = ViolationOfInvariants<INVARIANTS> extends Invariant<any, any, any, any, any, any, infer VIOLATION_TYPE> ? VIOLATION_TYPE : never;
-type ExpandAndMergeInvariants<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>, ALIASES extends Readonly<Record<string, ENTITIES>>, EXPANDED extends Partial<Record<ENTITIES['type'], ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>>, ALIASED extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>>> = {
-    [K in keyof EXPANDED | ExpandAlias<ENTITIES, ALIASES, keyof ALIASED & string>['type']]: K extends ENTITIES['type'] ? ExtractFromAliasedRecord<ENTITIES, ALIASES, ALIASED, EventualAlias<ENTITIES, ALIASES, K> | K> extends infer INVARIANTS_FROM_ALIAS ? [
-        INVARIANTS_FROM_ALIAS
-    ] extends [never] ? K extends keyof EXPANDED ? EXPANDED[K] : never : K extends keyof EXPANDED ? ReadonlyArray<ViolationOfInvariants<EXPANDED[K]> | ViolationOfInvariants<INVARIANTS_FROM_ALIAS>> : ReadonlyArray<ViolationOfInvariants<INVARIANTS_FROM_ALIAS>> : never : never;
-};
-type ExpressionsFromInvariants<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>, INVARIANTS extends Partial<Record<ENTITIES['type'], ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>>> = {
-    [K in keyof INVARIANTS & ENTITIES['type']]: {
-        $violations: AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, EntityByType<ENTITIES, K>, ReadonlyArray<Violation<INVARIANTS[K] extends ReadonlyArray<infer ELEMENT> ? ELEMENT extends Invariant<any, any, any, any, any, any, infer VIOLATION_TYPE> ? VIOLATION_TYPE : never : never>>>;
-    };
-};
-type BuildViolationExpressions<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, INVARIANTS extends Partial<Record<ENTITIES['type'], ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>>> = Record<never, never> extends ConflictingInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, DeclaredInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>, INVARIANTS> ? () => ExpressionsFromInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, INVARIANTS> : never;
-type AnyInvariant = Invariant<any, any, any, any, any, any, string>;
-/** Validates the `src/invariants/` files and concatenates their invariants per entity type or alias. */
-export declare const resolveInvariantModules: (modules: readonly ProjectModule[]) => Readonly<Record<string, readonly AnyInvariant[]>>;
-export declare class InvariantBuilder<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, INVARIANTS extends Partial<Record<ENTITIES['type'], ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITIES, string>>>> = Record<never, never>> {
-    private readonly aliasMap;
-    private readonly invariants;
-    constructor(aliasMap: AliasMap<ALIASES>, invariants?: INVARIANTS);
-    /**
-     * Adds the invariants of the `src/invariants/` files, as the generated barrel lists them, after
-     * checking each file against the folder's contract.
-     */
-    withInvariantModules(modules: readonly ProjectModule[]): InvariantBuilder<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, ExpandAndMergeInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, INVARIANTS, AliasedInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, string>>>;
-    withInvariants<ALIASED_INVARIANTS extends AliasedInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, string>>(aliasedInvariants: ALIASED_INVARIANTS): InvariantBuilder<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, ExpandAndMergeInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, INVARIANTS, ALIASED_INVARIANTS>>;
-    /**
-     * DO NOT USE in runtime!
-     *
-     * This is just a dev-time to review conflicts in declared and actually reportable violations.
-     * Use your IDEs code-completion to see which entities have conflicts and which violations are the conflicting ones.
-     *
-     * Use the helper when you see the following error on the `.buildViolationExpressions()` method call:
-     * ```
-     * TS2349: This expression is not callable.
-     * Type never has no call signatures.
-     * ```
-     * simply
-     * ```ts
-     * const violationExpressions = invariantBuilder
-     *   .withInvariants(createBuiltinInvariants(domainComponentReader))
-     *   .withInvariants(kitchenRangeInvariants)
-     *   ._conflicts.Oven. // <- trigger code-completion here
-     * ```
-     */
-    _conflicts: ConflictingInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, DeclaredInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>, INVARIANTS>;
-    buildViolationExpressions: BuildViolationExpressions<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, INVARIANTS>;
-}
-export {};

package/dist/domain/core/invariant/invariants.js

@@ -1 +1 @@
-import{SHARED_FOLDER_HINT as t,createContractError as e,isRecord as a}from"../../project-modules/index.js";import{expandAlias as i}from"../model/index.js";let r={expected:"an object of invariant lists keyed by entity type or alias",fix:`Create it with phx.domain.implementCustomInvariants({ ... }) (phx.domain.admin.implementCustomInvariants({ ... }) under src/admin/), ${t}.`},n=t=>a(t)&&"function"==typeof t.evaluate,s=t=>a(t)&&Object.values(t).every(t=>Array.isArray(t)&&t.every(n));export const resolveInvariantModules=t=>{let a={};for(let i of t){if(!s(i.exports))throw e(i.origin,r,i.exports);for(let[t,e]of Object.entries(i.exports))a[t]=[...a[t]??[],...e]}return a};export class InvariantBuilder{aliasMap;invariants;constructor(t,e={}){this.aliasMap=t,this.invariants=e}withInvariantModules(t){return this.withInvariants(resolveInvariantModules(t))}withInvariants(t){let e={...this.invariants};return Object.entries(t).forEach(([t,a])=>{i(this.aliasMap,t).forEach(t=>{e[t]=[...e[t]??[],...a]})}),new InvariantBuilder(this.aliasMap,e)}_conflicts={};buildViolationExpressions=()=>{let t={};return Object.entries(this.invariants).forEach(([e,a])=>{t[e]={$violations:{evaluate:(t,e,i)=>a.flatMap(a=>a.evaluate(t,e,i)),meta:{}}}}),t}}
+export{};

package/dist/domain/core/invariant/violation.d.ts

@@ -1,6 +1,6 @@
 import type { I18n } from '@lingui/core';
 import type { Localizable } from '@salsita-ai/common/utils';
-import type { StateEmission } from '../../domain-context/store-system/store-system.js';
+import type { StateEmission } from '../emission/index.js';
 import type { $DomainEntity, DomainEntity, EntityId } from '../model/index.js';
 /**
  * An **ORDERED** list of violation severities.

package/dist/domain/core/recipe/index.d.ts

@@ -0,0 +1 @@
+export * from './recipes.js';

package/dist/domain/core/recipe/index.js

@@ -0,0 +1 @@
+export*from"./recipes.js";

package/dist/domain/core/recipe/recipes.d.ts

@@ -0,0 +1,23 @@
+import { type AnyAliasMap, type DomainEntity, type DomainEntityReflection, type EntityByType } from '../model/index.js';
+/** The entity a recipe yields: a whole entity, which the recipe system gives a new id when it cooks the recipe. */
+export type EntityRecipe<ENTITY extends DomainEntity<string>> = ENTITY;
+/** What a project passes to its recipe factory: the entity type, and the properties that differ from the defaults. */
+export type EntityOverrides<ENTITIES extends DomainEntity<string>, TYPE extends ENTITIES['type']> = Partial<Omit<EntityByType<ENTITIES, TYPE>, 'type'>> & {
+    type: TYPE;
+};
+/** The function a project creates recipes with, `phx.domain.createRecipe`. */
+export type RecipeFactory<ENTITIES extends DomainEntity<string>> = <TYPE extends ENTITIES['type']>(overrides: EntityOverrides<ENTITIES, TYPE>) => EntityRecipe<EntityByType<ENTITIES, TYPE>>;
+/**
+ * Creates the recipe factory of a domain from the `defaults` of its spec.
+ *
+ * Defaults declared for an alias apply to every entity type of the alias, and a later key overrides
+ * an earlier one. The defaults of an entity type must be a whole entity of that type: they are
+ * validated here against the entity's schema, so a domain with invalid defaults fails when its
+ * module loads. An entity type without defaults is not checked.
+ *
+ * `ENTITIES` is the only type the result depends on, and no argument determines it, so the caller
+ * states it.
+ *
+ * @param defaults Property values by entity type or alias.
+ */
+export declare const createRecipeFactory: <ENTITIES extends DomainEntity<string>>(aliasMap: AnyAliasMap, entityReflections: ReadonlyArray<ENTITIES extends unknown ? DomainEntityReflection<ENTITIES> : never>, defaults: Readonly<Record<string, Readonly<Record<string, unknown>>>>) => RecipeFactory<ENTITIES>;

package/dist/domain/core/recipe/recipes.js

@@ -0,0 +1 @@
+import{_unsafeBuildDomainEntityId as e,expandAlias as r}from"../model/index.js";export const createRecipeFactory=(t,o,i)=>{let a={};Object.entries(i).forEach(([e,o])=>{r(t,e).forEach(e=>{a[e]={...a[e],...o}})});let n=new Map(o.map(e=>[e.type,e._meta.validator]));return Object.entries(a).forEach(([r,t])=>{let o=n.get(r);if(!o)throw Error(`Defaults provided for unknown entity ${r}`);if(!o({id:e(r,1),type:r,...t}))throw console.error(o.errors,t),Error(`Invalid defaults for ${r} entity.`)}),r=>({id:e(r.type,1),...a[r.type],...r})};

package/dist/domain/core/relation/all-of-type-relation.d.ts

@@ -0,0 +1,19 @@
+import type { ExpressionMeta } from '../expression/index.js';
+import { type AnyAliasMap, type DomainEntity, type DomainEntityId } from '../model/index.js';
+import type { DomainState } from '../state/index.js';
+/** A relation whose related entities are all entities of the target type or alias. */
+export interface AllOfTypeRelation {
+    kind: 'allOfType';
+    target: string;
+    cardinality: '0-1' | '1-1' | '0-N' | '1-N';
+    meta?: ExpressionMeta;
+}
+/**
+ * Resolves `allOfType` relations from a per-state index. Relations targeting the same set of types
+ * share one bucket; the first resolution on a state walks the entities once to fill every bucket,
+ * and every later resolution on that state is a lookup. Registration closes once the first state
+ * has been indexed, so a bucket can never be missing from an index that was already built.
+ */
+export declare const createAllOfTypeRelation: (aliasMap: AnyAliasMap) => (relation: {
+    readonly target: string;
+}) => (_selfId: DomainEntityId<string>, state: DomainState<DomainEntity<string>>) => DomainEntityId<string>[];

package/dist/domain/core/relation/all-of-type-relation.js

@@ -0,0 +1 @@
+import{expandAlias as e}from"../model/index.js";export const createAllOfTypeRelation=t=>{let r=new Map,a=new WeakMap,n=!1;return o=>{if(n)throw Error(`Cannot register all-of-type relation targeting ${o.target} after evaluation started. Create all relation expressions before evaluating the domain state.`);let l=new Set(e(t,o.target)),i=[...l].sort().join("|");return r.set(i,l),(e,t)=>(e=>{let t=a.get(e);if(t)return t;n=!0;let o=new Map([...r.keys()].map(e=>[e,[]]));for(let t of e.entities)for(let[e,a]of r)a.has(t.type)&&o.get(e).push(t.id);return a.set(e,o),o})(t).get(i)}};

package/dist/domain/{relations → core/relation}/component-factories.d.ts

@@ -1,4 +1,4 @@
-import type { DomainEntity, DomainEntityId, DomainEntityReflection, RawAliasReflection } from '../core/index.js';
+import type { DomainEntity, DomainEntityId, DomainEntityReflection, RawAliasReflection } from '../model/index.js';
 import type { ComposedOfComponentState } from './composed-of.js';
 import type { ReferenceComponentState } from './reference-component.js';
 export declare const createSingleReferenceRead: <TARGET extends DomainEntity<string>>(_targetReflection: DomainEntityReflection<TARGET> | RawAliasReflection<TARGET>, field: string) => (self: object, state: unknown, ctx: unknown) => ReferenceComponentState;

package/dist/domain/core/relation/component-factories.js

@@ -0,0 +1 @@
+import{memoEval as e}from"../../utils/memo-eval.js";export const createSingleReferenceRead=(t,r)=>e(e=>[e[r]],e=>({referencedEntityIds:null===e?[]:[e]}));export const createSingleReferenceWrite=(e,t)=>r=>{let n=r.referencedEntityIds[0];return n&&e.assertId(n),{[t]:n??null}};export const createMultipleReferenceRead=(t,r)=>e(e=>[e[r]],e=>({referencedEntityIds:e}));export const createMultipleReferenceWrite=(e,t)=>r=>(e.assertIds(r.referencedEntityIds),{[t]:r.referencedEntityIds});export const createSingleCompositionRead=t=>e(e=>[e[t]?.id??null],e=>({childEntityIds:null===e?[]:[e]}));export const createMultipleCompositionRead=t=>e(e=>e[t].map(e=>e.id),(...e)=>({childEntityIds:e}));export const createEmptyWrite=()=>()=>({});

package/dist/domain/{relations → core/relation}/composed-of.d.ts

@@ -1,4 +1,4 @@
-import { type DomainEntityId } from '../core/index.js';
+import { type DomainEntityId } from '../model/index.js';
 export type ComposedOfComponentState = {
     /**
      * List of entity IDs that the parent entity is composed of

package/dist/domain/core/relation/composed-of.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as o}from"../component/index.js";import{EntityIdSchema as t}from"../model/index.js";export const composedOfComponent=o.component("composedOf").withState({type:"object",properties:{childEntityIds:{type:"array",items:t}},required:["childEntityIds"],additionalProperties:!1}).build();

package/dist/domain/core/relation/direct-relation.d.ts

@@ -0,0 +1,17 @@
+import type { AnyDomain } from '../domain.js';
+import type { ExpressionMeta } from '../expression/index.js';
+import type { DomainEntity, DomainEntityId } from '../model/index.js';
+import type { DomainState } from '../state/index.js';
+/**
+ * A relation whose related entities are the ones a field of the entity itself references. The
+ * application-spec parser checks that `field` is a reference field of the entity that fits the
+ * target and the cardinality.
+ */
+export interface DirectRelation {
+    kind: 'direct';
+    target: string;
+    field: string;
+    cardinality: '0-1' | '1-1' | '0-N' | '1-N';
+    meta?: ExpressionMeta;
+}
+export declare const directRelation: (relation: DirectRelation) => (selfId: DomainEntityId<string>, state: DomainState<DomainEntity<string>>, domain: AnyDomain) => Array<DomainEntityId<string>>;

package/dist/domain/core/relation/index.d.ts

@@ -0,0 +1,8 @@
+export * from './all-of-type-relation.js';
+export * from './component-factories.js';
+export * from './composed-of.js';
+export * from './direct-relation.js';
+export * from './indirect-relation.js';
+export * from './reference-component.js';
+export type * from './reference-field.js';
+export * from './relation-factory.js';

package/dist/domain/core/relation/index.js

@@ -0,0 +1 @@
+export*from"./all-of-type-relation.js";export*from"./component-factories.js";export*from"./composed-of.js";export*from"./direct-relation.js";export*from"./indirect-relation.js";export*from"./reference-component.js";export*from"./relation-factory.js";

package/dist/domain/core/relation/indirect-relation.d.ts

@@ -0,0 +1,25 @@
+import type { ExpressionMeta } from '../expression/index.js';
+import { type AnyAliasMap, type DomainEntity, type DomainEntityId } from '../model/index.js';
+import type { DomainState } from '../state/index.js';
+/**
+ * A relation whose related entities are the ones that reference the entity in their `field`. The
+ * application-spec parser checks that `field` is a reference field of the target that points back.
+ */
+export interface IndirectRelation {
+    kind: 'indirect';
+    target: string;
+    field: string;
+    cardinality: '0-1' | '1-1' | '0-N' | '1-N';
+    meta?: ExpressionMeta;
+}
+/**
+ * Resolves `indirect` relations from a per-state reverse-reference index. Relations reading the
+ * same field on the same set of target types share one index mapping each referenced id to the
+ * entities that reference it; the first resolution on a state walks the entities once to fill
+ * every index, and every later resolution on that state is a lookup. Registration closes once the
+ * first state has been indexed, so an index can never be missing from a state already walked.
+ */
+export declare const createIndirectRelation: (aliasMap: AnyAliasMap) => (relation: {
+    readonly target: string;
+    readonly field: string;
+}) => (sourceId: DomainEntityId<string>, state: DomainState<DomainEntity<string>>) => DomainEntityId<string>[];

package/dist/domain/core/relation/indirect-relation.js

@@ -0,0 +1 @@
+import{isArray as e}from"@salsita-ai/common/utils";import{expandAlias as t}from"../model/index.js";let r=e=>"string"==typeof e;export const createIndirectRelation=i=>{let n=new Map,o=new WeakMap,a=!1;return l=>{if(a)throw Error(`Cannot register indirect relation ${l.target}#${l.field} after evaluation started. Create all relation expressions before evaluating the domain state.`);let s=new Set(t(i,l.target)),f=`${l.field}|${[...s].sort().join("|")}`;return n.set(f,{field:l.field,targetTypes:s}),(t,i)=>(t=>{let i=o.get(t);if(i)return i;a=!0;let l=new Map([...n.keys()].map(e=>[e,new Map]));for(let i of t.entities)for(let[t,{field:o,targetTypes:a}]of n){if(!a.has(i.type))continue;let n=i[o],s=e(n)?new Set(n.filter(r)):r(n)?[n]:[],f=l.get(t);for(let e of s){let t=f.get(e);t||(t=[],f.set(e,t)),t.push(i.id)}}return o.set(t,l),l})(i).get(f).get(t)??[]}};

package/dist/domain/{relations → core/relation}/reference-component.d.ts

@@ -1,4 +1,5 @@
-import { type $DomainEntity, type DomainComponentOpticBuilder, type DomainEntity, type DomainEntityId, type DomainEntityReflection, type RawAliasReflection } from '../core/index.js';
+import { type DomainComponentOpticBuilder } from '../component/index.js';
+import { type $DomainEntity, type DomainEntity, type DomainEntityId, type DomainEntityReflection, type RawAliasReflection } from '../model/index.js';
 import type { ArrayReferenceField, SingleReferenceField } from './reference-field.js';
 export type ReferenceComponentState = {
     /**
@@ -12,5 +13,5 @@ export type ReferenceComponentState = {
  */
 export declare const referenceComponent: import("../index.js").SystemComponentType<"reference", ReferenceComponentState, "referencedEntityIds">;
 export type ReferenceComponent = typeof referenceComponent;
-export declare const attachSingleReferenceComponent: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, ENTITY extends ENTITIES, $ENTITY extends $DomainEntity<ENTITY>, TARGET_ENTITY extends ENTITIES>(attachComponent: DomainComponentOpticBuilder<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, ENTITY, $ENTITY, typeof referenceComponent>, targetReflection: DomainEntityReflection<TARGET_ENTITY> | RawAliasReflection<TARGET_ENTITY>, field: SingleReferenceField<ENTITY, TARGET_ENTITY, any>) => import("../index.js").DomainComponentSimpleOptic<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITY, import("../index.js").SystemComponentType<"reference", ReferenceComponentState, "referencedEntityIds">>;
-export declare const attachMultipleReferenceComponent: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, ENTITY extends ENTITIES, $ENTITY extends $DomainEntity<ENTITY>, TARGET_ENTITY extends ENTITIES>(attachComponent: DomainComponentOpticBuilder<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, ENTITY, $ENTITY, typeof referenceComponent>, targetReflection: DomainEntityReflection<TARGET_ENTITY> | RawAliasReflection<TARGET_ENTITY>, field: ArrayReferenceField<ENTITY, TARGET_ENTITY>) => import("../index.js").DomainComponentSimpleOptic<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITY, import("../index.js").SystemComponentType<"reference", ReferenceComponentState, "referencedEntityIds">>;
+export declare const attachSingleReferenceComponent: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, ENTITY extends ENTITIES, $ENTITY extends $DomainEntity<ENTITY>, TARGET_ENTITY extends ENTITIES, CONTEXT_EXTENSION = unknown>(attachComponent: DomainComponentOpticBuilder<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, ENTITY, $ENTITY, typeof referenceComponent, CONTEXT_EXTENSION>, targetReflection: DomainEntityReflection<TARGET_ENTITY> | RawAliasReflection<TARGET_ENTITY>, field: SingleReferenceField<ENTITY, TARGET_ENTITY, any>) => import("../index.js").DomainComponentSimpleOptic<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITY, import("../index.js").SystemComponentType<"reference", ReferenceComponentState, "referencedEntityIds">, CONTEXT_EXTENSION>;
+export declare const attachMultipleReferenceComponent: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, ENTITY extends ENTITIES, $ENTITY extends $DomainEntity<ENTITY>, TARGET_ENTITY extends ENTITIES, CONTEXT_EXTENSION = unknown>(attachComponent: DomainComponentOpticBuilder<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, ENTITY, $ENTITY, typeof referenceComponent, CONTEXT_EXTENSION>, targetReflection: DomainEntityReflection<TARGET_ENTITY> | RawAliasReflection<TARGET_ENTITY>, field: ArrayReferenceField<ENTITY, TARGET_ENTITY>) => import("../index.js").DomainComponentSimpleOptic<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ENTITY, import("../index.js").SystemComponentType<"reference", ReferenceComponentState, "referencedEntityIds">, CONTEXT_EXTENSION>;

package/dist/domain/core/relation/reference-component.js

@@ -0,0 +1 @@
+import{memoEval as e}from"../../utils/memo-eval.js";import{SystemComponentBuilder as t}from"../component/index.js";import{EntityIdSchema as r}from"../model/index.js";export const referenceComponent=t.component("reference").withState({type:"object",properties:{referencedEntityIds:{type:"array",items:r}},required:["referencedEntityIds"],additionalProperties:!1}).withWritableKeys(["referencedEntityIds"]).build();export const attachSingleReferenceComponent=(t,r,n)=>t.attach(e(e=>[e[n]],e=>({referencedEntityIds:null===e?[]:[e]})),e=>{let t=e.referencedEntityIds[0];return t&&r.assertId(t),{[n]:t??null}});export const attachMultipleReferenceComponent=(t,r,n)=>t.attach(e(e=>[e[n]],e=>({referencedEntityIds:e})),e=>(r.assertIds(e.referencedEntityIds),{[n]:e.referencedEntityIds}));

package/dist/domain/{relations → core/relation}/reference-field.d.ts

@@ -1,4 +1,4 @@
-import type { DomainEntity } from '../core/index.js';
+import type { DomainEntity } from '../model/index.js';
 export type SingleReferenceField<FROM extends DomainEntity<string>, TO extends DomainEntity<string>, OPTIONALITY extends null | never> = {
     [K in keyof FROM]: TO['id'] | OPTIONALITY extends FROM[K] ? FROM[K] extends TO['id'] | OPTIONALITY ? K & string : never : never;
 }[keyof FROM];

package/dist/domain/core/relation/reference-field.js

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

package/dist/domain/core/relation/relation-factory.d.ts

@@ -0,0 +1,22 @@
+import type { AnonymousExpression } from '../expression/index.js';
+import { type $DomainEntity, type AnyAliasMap, type DomainEntity } from '../model/index.js';
+import { type AllOfTypeRelation } from './all-of-type-relation.js';
+import { type DirectRelation } from './direct-relation.js';
+import { type IndirectRelation } from './indirect-relation.js';
+/** A relation as a spec declares it: where the related entities are found and how many there may be. */
+export type Relation = DirectRelation | AllOfTypeRelation | IndirectRelation;
+type RelatedEntity = $DomainEntity<DomainEntity<string>>;
+/**
+ * The expression of a relation as a domain takes it. The entity and data types are erased, so that
+ * the domain of any project accepts it: an expression typed with the base entity type is not
+ * assignable to one typed with a project's entities. The type a project reads from a relation is
+ * the one its generated model declares for the relation's property.
+ */
+type RelationExpression = AnonymousExpression<any, any, any, any, any, any, RelatedEntity | null | ReadonlyArray<RelatedEntity>>;
+/**
+ * Makes the expression of one relation: it collects the related entities of an entity and returns
+ * them as the cardinality says, one entity, one entity or `null`, or an array.
+ */
+export type RelationFactory = (relation: Relation) => RelationExpression;
+export declare const createRelationFactory: (aliasMap: AnyAliasMap) => RelationFactory;
+export {};

package/dist/domain/core/relation/relation-factory.js

@@ -0,0 +1 @@
+import{match as t}from"ts-pattern";import{expandAlias as e}from"../model/index.js";import{createAllOfTypeRelation as r}from"./all-of-type-relation.js";import{directRelation as i}from"./direct-relation.js";import{createIndirectRelation as n}from"./indirect-relation.js";export const createRelationFactory=o=>{let a=r(o),l=n(o);return r=>{let n=t(r).with({kind:"direct"},t=>i(t)).with({kind:"indirect"},t=>l(t)).with({kind:"allOfType"},t=>a(t)).exhaustive(),d=t(r).with({cardinality:"0-1"},()=>t=>{if(t.length>1)throw Error(`Expected at most one entity, but got ${t.length}`);return t[0]??null}).with({cardinality:"1-1"},()=>t=>{let[e,...r]=t;if(void 0===e||r.length>0)throw Error(`Expected exactly one entity, but got ${t.length}`);return e}).with({cardinality:"0-N"},()=>t=>t).with({cardinality:"1-N"},()=>t=>{if(0===t.length)throw Error("Expected at least one entity, but got none");return t}).exhaustive(),c=e(o,r.target);return{meta:{alwaysEvaluate:!0,...r.meta},evaluate:(t,e,i)=>{let o=n(t,e,i.domain),a=i.domain.get$Entities(o,e);if(!a.every(t=>c.includes(t.type))){let t=a.map(t=>t.type).filter(t=>!c.includes(t));throw Error(`Expected ${r.target} entities, but got ${t.join(", ")}`)}return d(a)}}}};

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

@@ -48,51 +48,20 @@ export type MigrateFunction<LATEST_ENTITIES extends DomainEntity<string>> = (ver
     state: ReadonlyArray<DomainEntity<string>>;
 }, options: MigrateFunctionOptions) => readonly LATEST_ENTITIES[];
 /**
- * Builder for the state migration function.
+ * Creates the function that migrates a state of any registered version of the model to the latest
+ * one. The state is validated against the reflections of its own version, and again after every
+ * migration against the reflections of the version that migration yields.
+ *
+ * @param modelVersions the entity reflections of every version of the model, keyed by version
+ * @param latestVersion the version the state is migrated to
+ * @param migrations the migration to each version above the first: the one under key `n` takes a
+ * state of version `n - 1` to version `n`
  * @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 const migrate = createMigrateFunction(
+ *   { 1: v1Reflections, 2: v2Reflections, 3: v3Reflections },
+ *   3,
+ *   { 2: migrationToV2, 3: migrationToV3 }
+ * )
  */
-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 declare const createMigrateFunction: <VERSIONS extends Record<number, EntityReflections<any>>, LATEST extends keyof VERSIONS & number>(modelVersions: VERSIONS, latestVersion: LATEST, migrations: Record<Exclude<keyof VERSIONS, 1>, Migration<any, any>>) => MigrateFunction<EntitiesOfReflections<VERSIONS[LATEST]>>;
 export {};

package/dist/domain/core/state/migrations.js

@@ -1 +1 @@
-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}})})})};
+import t from"lodash-es/pick.js";export class StateMigrationError extends Error{constructor(t){super(t),this.name="StateMigrationError"}}export const isStateMigrationError=t=>t instanceof StateMigrationError;let e=(e,r,i,o)=>e.map(e=>{let n=r[e.type];if(!n)throw new StateMigrationError(`Unknown entity type "${e.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(e))return e;if(i){let r=t(e,Object.keys(n._meta.schema.properties));if(n._meta.validator(e))return o?.error(`Entity ${e.type}#${e.id} had extra fields that had to be trimmed: ${Object.keys(r)}`),r}throw new StateMigrationError(`Entity "${e.type}#${e.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 createMigrateFunction=(t,r,i)=>(o,{logger:n,trimExtraProperties:a})=>{let s=t[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 the model versions passed to createMigrateFunction, or correct the version stored on the state.`);let d=e(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=t[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 the model versions passed to createMigrateFunction.`);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 under key ${s+1} in the migrations passed to createMigrateFunction.`);d=e(g(d),h,a,n)}return d};

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

@@ -6,4 +6,4 @@ export interface DomainState<ENTITIES extends DomainEntity<string>> {
     readonly ephemeralRecords: ReadonlyArray<ComponentSnapshot<SystemComponentTypeConstraint>>;
 }
 export type DomainStateFactory<ENTITIES extends DomainEntity<string>> = (entities: readonly ENTITIES[], ephemeralRecords: ReadonlyArray<ComponentSnapshot<SystemComponentTypeConstraint>>, rootEntityType: ENTITIES['type']) => DomainState<ENTITIES>;
-export declare const createInitialDomainState: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES>(entities: readonly ENTITIES[], rootEntityType: ALLOWED_ROOT_ENTITIES['type']) => DomainState<ENTITIES>;
+export declare const createInitialDomainState: <ENTITIES extends DomainEntity<string>>(entities: readonly ENTITIES[], rootEntityType: ENTITIES['type']) => DomainState<ENTITIES>;

package/dist/domain/domain-builder.d.ts

@@ -1,9 +1,6 @@
 import { type ExtendedJsonSchema } from '@salsita-ai/common/utils';
-import { type $DomainEntity, type $DomainEntityReflection, type ActionDefinition, type AliasMap, type AnonymousExpression, type AnyActionImplementations, type DomainEntity, DomainFactory, type EntityByType, type EntityReflections, type ExpandAlias, type MigrateFunction, type SchemaOfObject, type TypeOrAlias } from './core/index.js';
-import { type ProjectModule } from './project-modules/index.js';
-export type AliasedExpressions<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>, ALIASES extends Record<string, ENTITIES>> = {
-    [K in TypeOrAlias<ENTITIES, ALIASES>]?: Record<string, AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, K>, unknown>>;
-};
+import { type $DomainEntity, type $DomainEntityReflection, type ActionDefinition, type AliasMap, type AliasedExpressions, type AnyActionImplementations, type DomainEntity, DomainFactory, type EntityByType, type EntityReflections, type MigrateFunction, type SchemaOfObject } from './core/index.js';
+import { type ProjectModule } from './domain-runtime/index.js';
 type $EntityReflections<ENTITIES extends DomainEntity<string>> = {
     [TYPE in ENTITIES['type']]: $DomainEntityReflection<$DomainEntity<EntityByType<ENTITIES, TYPE>>>;
 };

package/dist/domain/domain-builder.js

@@ -1 +1 @@
-import{DomainFactory as t,MigrateFunctionBuilder as i,expandAlias as e}from"./core/index.js";import{resolveActionModules as s,resolveExpressionModules as n}from"./project-modules/index.js";import{withProfilerLabel as a}from"./utils/profiler-label.js";export class DomainBuilder{entities;aliasMap;$entityReflections;allowedRootEntityTypes;implemented;modelVersion;publishedData;sessionData;frontendData;backendData;migrate;isAdminDomain;actions;actionImplementations;constructor(t,i,e,s,n,a,o,h,l,r,m,d,p,c){this.entities=t,this.aliasMap=i,this.$entityReflections=e,this.allowedRootEntityTypes=s,this.implemented=n,this.modelVersion=a,this.publishedData=o,this.sessionData=h,this.frontendData=l,this.backendData=r,this.migrate=m,this.isAdminDomain=d,this.actions=p,this.actionImplementations=c}static from(t,e,s,n,a,o,h,l,r,m){let d=i.fromVersions({1:t}).to(1).using({}).build();return new DomainBuilder(t,e,s,n,{},a,o,h,l,r,d,m,{},{})}withMigrate(t){return new DomainBuilder(this.entities,this.aliasMap,this.$entityReflections,this.allowedRootEntityTypes,this.implemented,this.modelVersion,this.publishedData,this.sessionData,this.frontendData,this.backendData,t,this.isAdminDomain,this.actions,this.actionImplementations)}withExpressions(t){let i={...this.implemented};return Object.entries(t).forEach(([t,s])=>{e(this.aliasMap,t).forEach(e=>{let n={...i[e]};i[e]=n,Object.entries(s).forEach(([i,s])=>{let o=n[i];if(o)throw Error(`Duplicate expression ${e}.${i}: The expression is defined on both ${t} and ${o.origin.typeOrAlias}, which would lead to ambiguous usage. Please ensure that expressions are only defined once.`);n[i]={...s,evaluate:a(`${e}_${i}`,s.evaluate),origin:{name:i,typeOrAlias:t}}})})}),new DomainBuilder(this.entities,this.aliasMap,this.$entityReflections,this.allowedRootEntityTypes,i,this.modelVersion,this.publishedData,this.sessionData,this.frontendData,this.backendData,this.migrate,this.isAdminDomain,this.actions,this.actionImplementations)}withExpressionModules(t){return n(t,this.aliasMap).reduce((t,i)=>t.withExpressions(i.expressions),this)}withActions(t){return new DomainBuilder(this.entities,this.aliasMap,this.$entityReflections,this.allowedRootEntityTypes,this.implemented,this.modelVersion,this.publishedData,this.sessionData,this.frontendData,this.backendData,this.migrate,this.isAdminDomain,Object.fromEntries(t.map(t=>[t.name,t])),this.actionImplementations)}withActionModules(t){return this.withActionImplementations(s(t))}withActionImplementations(t){return new DomainBuilder(this.entities,this.aliasMap,this.$entityReflections,this.allowedRootEntityTypes,this.implemented,this.modelVersion,this.publishedData,this.sessionData,this.frontendData,this.backendData,this.migrate,this.isAdminDomain,this.actions,{...this.actionImplementations,...t})}build=()=>{let e=this.implemented,s=this.migrate??i.fromVersions({1:this.entities}).to(1).using({}).build();return new t({aliasMap:this.aliasMap,entityReflections:this.entities,$entityReflections:this.$entityReflections,expressions:e,allowedRootEntityTypes:this.allowedRootEntityTypes,modelVersion:this.modelVersion,migrate:s,publishedData:this.publishedData,sessionData:this.sessionData,frontendData:this.frontendData,backendData:this.backendData,isAdminDomain:this.isAdminDomain,actions:this.actions,actionImplementations:this.actionImplementations})}}
+import{DomainFactory as t,createMigrateFunction as i,expandAlias as e}from"./core/index.js";import{resolveActionModules as s,resolveExpressionModules as n}from"./domain-runtime/index.js";import{withProfilerLabel as a}from"./utils/profiler-label.js";export class DomainBuilder{entities;aliasMap;$entityReflections;allowedRootEntityTypes;implemented;modelVersion;publishedData;sessionData;frontendData;backendData;migrate;isAdminDomain;actions;actionImplementations;constructor(t,i,e,s,n,a,o,h,l,m,r,d,p,c){this.entities=t,this.aliasMap=i,this.$entityReflections=e,this.allowedRootEntityTypes=s,this.implemented=n,this.modelVersion=a,this.publishedData=o,this.sessionData=h,this.frontendData=l,this.backendData=m,this.migrate=r,this.isAdminDomain=d,this.actions=p,this.actionImplementations=c}static from(t,e,s,n,a,o,h,l,m,r){let d=i({1:t},1,{});return new DomainBuilder(t,e,s,n,{},a,o,h,l,m,d,r,{},{})}withMigrate(t){return new DomainBuilder(this.entities,this.aliasMap,this.$entityReflections,this.allowedRootEntityTypes,this.implemented,this.modelVersion,this.publishedData,this.sessionData,this.frontendData,this.backendData,t,this.isAdminDomain,this.actions,this.actionImplementations)}withExpressions(t){let i={...this.implemented};return Object.entries(t).forEach(([t,s])=>{e(this.aliasMap,t).forEach(e=>{let n={...i[e]};i[e]=n,Object.entries(s).forEach(([i,s])=>{let o=n[i];if(o)throw Error(`Duplicate expression ${e}.${i}: The expression is defined on both ${t} and ${o.origin.typeOrAlias}, which would lead to ambiguous usage. Please ensure that expressions are only defined once.`);n[i]={...s,evaluate:a(`${e}_${i}`,s.evaluate),origin:{name:i,typeOrAlias:t}}})})}),new DomainBuilder(this.entities,this.aliasMap,this.$entityReflections,this.allowedRootEntityTypes,i,this.modelVersion,this.publishedData,this.sessionData,this.frontendData,this.backendData,this.migrate,this.isAdminDomain,this.actions,this.actionImplementations)}withExpressionModules(t){return n(t,this.aliasMap).reduce((t,i)=>t.withExpressions(i.expressions),this)}withActions(t){return new DomainBuilder(this.entities,this.aliasMap,this.$entityReflections,this.allowedRootEntityTypes,this.implemented,this.modelVersion,this.publishedData,this.sessionData,this.frontendData,this.backendData,this.migrate,this.isAdminDomain,Object.fromEntries(t.map(t=>[t.name,t])),this.actionImplementations)}withActionModules(t){return this.withActionImplementations(s(t))}withActionImplementations(t){return new DomainBuilder(this.entities,this.aliasMap,this.$entityReflections,this.allowedRootEntityTypes,this.implemented,this.modelVersion,this.publishedData,this.sessionData,this.frontendData,this.backendData,this.migrate,this.isAdminDomain,this.actions,{...this.actionImplementations,...t})}build=()=>{let e=this.implemented,s=this.migrate??i({1:this.entities},1,{});return new t({aliasMap:this.aliasMap,entityReflections:this.entities,$entityReflections:this.$entityReflections,expressions:e,allowedRootEntityTypes:this.allowedRootEntityTypes,modelVersion:this.modelVersion,migrate:s,publishedData:this.publishedData,sessionData:this.sessionData,frontendData:this.frontendData,backendData:this.backendData,isAdminDomain:this.isAdminDomain,actions:this.actions,actionImplementations:this.actionImplementations})}}

package/dist/domain/domain-context/action-system/action-system.d.ts

@@ -1,5 +1,5 @@
-import { type $DomainEntity, type ActionContext, type ActionTypes, type DomainEntity, type DomainState, type PreparedAction } from '../../core/index.js';
-import type { DomainContextSelectors } from '../../domain-runtime/domain-context/index.js';
+import { type $DomainEntity, type ActionTypes, type DomainEntity, type DomainState, type PreparedAction } from '../../core/index.js';
+import type { ActionContext, DomainContextSelectors } from '../../domain-runtime/index.js';
 export interface ActionSystemContext {
     /**
      * The action system's window into the runtime registry: the declared actions and their

package/dist/domain/domain-context/action-system/action-system.js

@@ -1 +1 @@
-import{createSelector as t}from"@salsita-ai/common/utils";import{createUpdateFactory as e,extendedSchemaValidator as s}from"../../core/index.js";import{getIdSequence as n}from"../store-system/next-domain-entity-id.js";export class ActionSystem{_context;_selectValidators=t([t.leaf(t=>t)],t=>new Map(Object.values(t).map(t=>[t.name,s.compile(t.params)])));_updates=e();constructor(t){this._context=t}createContext=t=>({expressionContext:this._context.selectors.getExpressionContext(),systems:this._context.selectors.getDomainSystems(),getIdSequence:()=>n(t.entities,[]),updates:this._updates});prepareAction=(t,e,n)=>{let o=this._context.selectors.getActionDefinitions(),i=Object.values(o).find(e=>e.name===t);if(!i){let e=Object.values(o).map(t=>`"${t.name}"`);throw Error(`Unknown action "${t}". ${e.length>0?`The application declares these actions: ${e.join(", ")}.`:"The application declares no actions."} Declare it under "actions" in a spec file and implement it in src/actions/.`)}let a=this._selectValidators(o).get(i.name);if(a&&!a(e))throw Error(`The arguments of action "${t}" do not fit its params: ${s.errorsText(a.errors)}. Nothing was changed. Send arguments that fit the params the action declares.`);return(Object.entries(this._context.selectors.getActionImplementations()).find(([e])=>e===t)?.[1])(e,n,this.createContext(n))}}
+import{createSelector as t}from"@salsita-ai/common/utils";import{createUpdateFactory as e,extendedSchemaValidator as s}from"../../core/index.js";import{getIdSequence as n}from"../store-system/index.js";export class ActionSystem{_context;_selectValidators=t([t.leaf(t=>t)],t=>new Map(Object.values(t).map(t=>[t.name,s.compile(t.params)])));_updates=e();constructor(t){this._context=t}createContext=t=>({expressionContext:this._context.selectors.getExpressionContext(),systems:this._context.selectors.getDomainSystems(),getIdSequence:()=>n(t.entities,[]),updates:this._updates});prepareAction=(t,e,n)=>{let o=this._context.selectors.getActionDefinitions(),i=Object.values(o).find(e=>e.name===t);if(!i){let e=Object.values(o).map(t=>`"${t.name}"`);throw Error(`Unknown action "${t}". ${e.length>0?`The application declares these actions: ${e.join(", ")}.`:"The application declares no actions."} Declare it under "actions" in a spec file and implement it in src/actions/.`)}let a=this._selectValidators(o).get(i.name);if(a&&!a(e))throw Error(`The arguments of action "${t}" do not fit its params: ${s.errorsText(a.errors)}. Nothing was changed. Send arguments that fit the params the action declares.`);return(Object.entries(this._context.selectors.getActionImplementations()).find(([e])=>e===t)?.[1])(e,n,this.createContext(n))}}

package/dist/domain/domain-context/action-system/index.d.ts

@@ -0,0 +1 @@
+export { ActionSystem, type ActionSystemContext, type AnyActionSystem } from './action-system.js';

package/dist/domain/domain-context/action-system/index.js

@@ -0,0 +1 @@
+export{ActionSystem}from"./action-system.js";

package/dist/domain/domain-context/analytics-system/index.d.ts

@@ -0,0 +1,2 @@
+export { type AnalyticsEvent, AnalyticsEventFactory, AnalyticsEventType, type DataLoadedEvent, type InitEvent, type NavigationEvent, type SessionAuthenticatedEvent, type SystemEvent, type UserActionEvent, } from './analytics-contracts.js';
+export { type AnalyticsSystem, NoopAnalyticsSystem } from './analytics-system.js';

package/dist/domain/domain-context/analytics-system/index.js

@@ -0,0 +1 @@
+export{AnalyticsEventFactory,AnalyticsEventType}from"./analytics-contracts.js";export{NoopAnalyticsSystem}from"./analytics-system.js";

package/dist/domain/domain-context/create-transformer.d.ts

@@ -1,5 +1,5 @@
 import type { $DomainEntity, DomainEntity } from '../core/index.js';
 import type { DomainContextSystems } from './domain-context-systems.js';
-import type { UpdateTransformer } from './store-system/store-system.js';
+import type { UpdateTransformer } from './store-system/index.js';
 export declare const createTransformer: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, NAVIGATION_STATES extends string, VIEW_STATES extends string, TOOL_STATES extends string, EXPORT_STATES extends string>(transformer: (ctx: DomainContextSystems<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES>) => UpdateTransformer<ENTITIES>) => (ctx: DomainContextSystems<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES>) => UpdateTransformer<ENTITIES>;
 export type TransformerFactory<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, NAVIGATION_STATES extends string, VIEW_STATES extends string, TOOL_STATES extends string, EXPORT_STATES extends string> = (transformer: (ctx: DomainContextSystems<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES>) => UpdateTransformer<ENTITIES>) => (ctx: DomainContextSystems<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES>) => UpdateTransformer<ENTITIES>;

package/dist/domain/domain-context/dimension-system/dimension-system.d.ts

@@ -1,7 +1,7 @@
 import type { DomainEntity, DomainState, EntityViolation } from '../../core/index.js';
 import { DimensionUnit, type UnitsConfig } from '../../dimensions/index.js';
-import type { DomainContextSelectors } from '../../domain-runtime/domain-context/index.js';
-import { SystemState } from '../store-system/system-state.js';
+import type { DomainContextSelectors } from '../../domain-runtime/index.js';
+import { SystemState } from '../store-system/index.js';
 import { type DimensionStateComponent } from './dimension-state.js';
 export type DistanceDimensionViolation = `${string}.distanceDimension.tooLarge` | `${string}.distanceDimension.tooSmall`;
 export type GenericDimensionViolation = `${string}.genericDimension.tooLarge` | `${string}.genericDimension.tooSmall`;

package/dist/domain/domain-context/dimension-system/dimension-system.js

@@ -1 +1 @@
-import{AngleUnit as t,DEFAULT_DECIMAL_PLACES as e,DimensionUnit as i,defaultAngleToUnit as n,formatDistanceValue as a,isDimensionGreaterThanMax as o,isDimensionLowerThanMin as s}from"../../dimensions/index.js";import{angleDimensionComponent as l,applicationConfigComponent as m,distanceDimensionComponent as r,genericDimensionComponent as c}from"../../system-components/index.js";import{SystemState as u}from"../store-system/system-state.js";import{dimensionStateComponent as g}from"./dimension-state.js";let d={[t.degree]:"\xb0",[t.radian]:"rad"},p={mm:{strategy:"decimal",decimalPlaces:0},cm:{strategy:"decimal",decimalPlaces:1},m:{strategy:"decimal",decimalPlaces:2},inch:{strategy:"fraction",fractionBasis:[3,4]},feet:{strategy:"fraction-inch",fractionBasis:[3,4]}},h=["mm","cm","m","inch","feet"];function f(t,e){let i={sourceUnit:t.sourceUnit,displayUnit:t.displayUnit,unitDisplayConfig:t.unitDisplayConfig,locale:t.locale,omitLeadingZeroUnits:!0},n=a(t.limitValue,i),o=a(t.currentValue,i);return"tooLarge"===e?{id:"sdk.distanceDimension.hintMessageTooLarge",message:"Current value is {0}, which is larger than allowed maximum of {1}.",values:{0:o.valueWithUnit,1:n.valueWithUnit}}:{id:"sdk.distanceDimension.hintMessageTooSmall",message:"Current value is {0}, which is smaller than allowed minimum of {1}.",values:{0:o.valueWithUnit,1:n.valueWithUnit}}}function y(t,e){let i=`${t.currentValue.toFixed(t.decimalPlaces)}\u00A0${t.unit}`,n=`${t.limitValue}\u00A0${t.unit}`;return"tooLarge"===e?{id:"sdk.genericDimension.hintMessageTooLarge",message:"Current value is {currentWithUnit}, which is larger than allowed maximum of {limitWithUnit}.",values:{currentWithUnit:i,limitWithUnit:n}}:{id:"sdk.genericDimension.hintMessageTooSmall",message:"Current value is {currentWithUnit}, which is smaller than allowed minimum of {limitWithUnit}.",values:{currentWithUnit:i,limitWithUnit:n}}}function v(t,e){let i=`${n(t.currentValue,t.unit).toFixed(t.decimalPlaces)}\u00A0${t.unitLabel}`,a=`${n(t.limitValue,t.unit).toFixed(t.decimalPlaces)}\u00A0${t.unitLabel}`;return"tooLarge"===e?{id:"sdk.angleDimension.hintMessageTooLarge",message:"Current value is {currentWithUnit}, which is larger than allowed maximum of {limitWithUnit}.",values:{currentWithUnit:i,limitWithUnit:a}}:{id:"sdk.angleDimension.hintMessageTooSmall",message:"Current value is {currentWithUnit}, which is smaller than allowed minimum of {limitWithUnit}.",values:{currentWithUnit:i,limitWithUnit:a}}}export class DimensionSystem{_context;state;constructor(t){this._context=t,this.state=new u({selectors:this._context.selectors,componentType:g,getInitialState:t=>{let e=this._context.selectors.getComponentReader().readFirstRootComponent({componentTypes:[m]},t);return{unit:e?.state.initialGlobalUnit??e?.state.distanceDataUnit??i.mm}}})}initialize=t=>this.state.getInitialUpdates(t);getDimensionConfig=t=>{let e=this._context.selectors.getComponentReader().readFirstRootComponent({componentTypes:[m]},t);return{distanceDataUnit:e?.state.distanceDataUnit??i.mm,unitDisplayConfig:e?.state.unitDisplayConfig??p,availableDimensions:e?.state.availableDimensions??h}};getDataDistanceUnit=t=>this.getDimensionConfig(t).distanceDataUnit;getGlobalUnit=t=>this.state.get(t).unit;getSetGlobalUnitUpdates=(t,e)=>this.state.getUpdates(e=>({...e,unit:t}),e);_getDistanceComponentViolations=t=>{let e=this.getDimensionConfig(t),i=this.state.get(t),n=this._context.selectors.getComponentReader().readManyComponents({componentTypes:[r]},t),a=[];for(let t of n){let n=t.state.displayUnit??i.unit,l=t.state.unitDisplayConfig?.[n]??e.unitDisplayConfig[n];if(!l)throw Error(`Unit config for ${n} not found!`);let m=t.state.max;if(void 0!==m&&o(t.state.value,m)){let i={currentValue:t.state.value,limitValue:m,sourceUnit:e.distanceDataUnit,displayUnit:n,unitDisplayConfig:l};a.push({entityId:t.componentInstance.entityId,violation:{type:`${t.componentInstance.instanceName}.distanceDimension.tooLarge`,severity:"fatal",message:f({...i,locale:"en-US"},"tooLarge"),formatControlViolationMessage:(t,e)=>f({...i,locale:e.i18n.locale},"tooLarge")}})}let r=t.state.min;if(void 0!==r&&s(t.state.value,r)){let i={currentValue:t.state.value,limitValue:r,sourceUnit:e.distanceDataUnit,displayUnit:n,unitDisplayConfig:l};a.push({entityId:t.componentInstance.entityId,violation:{type:`${t.componentInstance.instanceName}.distanceDimension.tooSmall`,severity:"fatal",message:f({...i,locale:"en-US"},"tooSmall"),formatControlViolationMessage:(t,e)=>f({...i,locale:e.i18n.locale},"tooSmall")}})}}return a};_getGenericComponentViolations=t=>{let i=this._context.selectors.getComponentReader().readManyComponents({componentTypes:[c]},t),n=[];for(let t of i){if(void 0!==t.state.max&&o(t.state.value,t.state.max)){let i={currentValue:t.state.value,limitValue:t.state.max,decimalPlaces:t.state.decimalPlaces??e,unit:t.state.unit};n.push({entityId:t.componentInstance.entityId,violation:{type:`${t.componentInstance.instanceName}.genericDimension.tooLarge`,severity:"fatal",message:y(i,"tooLarge"),formatControlViolationMessage:()=>y(i,"tooLarge")}})}if(void 0!==t.state.min&&s(t.state.value,t.state.min)){let i={currentValue:t.state.value,limitValue:t.state.min,decimalPlaces:t.state.decimalPlaces??e,unit:t.state.unit};n.push({entityId:t.componentInstance.entityId,violation:{type:`${t.componentInstance.instanceName}.genericDimension.tooSmall`,severity:"fatal",message:y(i,"tooSmall"),formatControlViolationMessage:()=>y(i,"tooSmall")}})}}return n};_getAngleComponentViolations=t=>{let i=this._context.selectors.getComponentReader().readManyComponents({componentTypes:[l]},t),n=[];for(let t of i){let i=t.state.unit??"degree",a=d[i],l=t.state.decimalPlaces??e;if(void 0!==t.state.max&&o(t.state.value,t.state.max)){let e={currentValue:t.state.value,limitValue:t.state.max,unit:i,unitLabel:a,decimalPlaces:l};n.push({entityId:t.componentInstance.entityId,violation:{type:`${t.componentInstance.instanceName}.angleDimension.tooLarge`,severity:"fatal",message:v(e,"tooLarge"),formatControlViolationMessage:()=>v(e,"tooLarge")}})}if(void 0!==t.state.min&&s(t.state.value,t.state.min)){let e={currentValue:t.state.value,limitValue:t.state.min,unit:i,unitLabel:a,decimalPlaces:l};n.push({entityId:t.componentInstance.entityId,violation:{type:`${t.componentInstance.instanceName}.angleDimension.tooSmall`,severity:"fatal",message:v(e,"tooSmall"),formatControlViolationMessage:()=>v(e,"tooSmall")}})}}return n};validateState=t=>[...this._getDistanceComponentViolations(t),...this._getGenericComponentViolations(t),...this._getAngleComponentViolations(t)]}
+import{AngleUnit as t,DEFAULT_DECIMAL_PLACES as e,DimensionUnit as i,defaultAngleToUnit as n,formatDistanceValue as a,isDimensionGreaterThanMax as o,isDimensionLowerThanMin as s}from"../../dimensions/index.js";import{angleDimensionComponent as l,applicationConfigComponent as m,distanceDimensionComponent as r,genericDimensionComponent as c}from"../../system-components/index.js";import{SystemState as u}from"../store-system/index.js";import{dimensionStateComponent as g}from"./dimension-state.js";let d={[t.degree]:"\xb0",[t.radian]:"rad"},p={mm:{strategy:"decimal",decimalPlaces:0},cm:{strategy:"decimal",decimalPlaces:1},m:{strategy:"decimal",decimalPlaces:2},inch:{strategy:"fraction",fractionBasis:[3,4]},feet:{strategy:"fraction-inch",fractionBasis:[3,4]}},h=["mm","cm","m","inch","feet"];function f(t,e){let i={sourceUnit:t.sourceUnit,displayUnit:t.displayUnit,unitDisplayConfig:t.unitDisplayConfig,locale:t.locale,omitLeadingZeroUnits:!0},n=a(t.limitValue,i),o=a(t.currentValue,i);return"tooLarge"===e?{id:"sdk.distanceDimension.hintMessageTooLarge",message:"Current value is {0}, which is larger than allowed maximum of {1}.",values:{0:o.valueWithUnit,1:n.valueWithUnit}}:{id:"sdk.distanceDimension.hintMessageTooSmall",message:"Current value is {0}, which is smaller than allowed minimum of {1}.",values:{0:o.valueWithUnit,1:n.valueWithUnit}}}function y(t,e){let i=`${t.currentValue.toFixed(t.decimalPlaces)}\u00A0${t.unit}`,n=`${t.limitValue}\u00A0${t.unit}`;return"tooLarge"===e?{id:"sdk.genericDimension.hintMessageTooLarge",message:"Current value is {currentWithUnit}, which is larger than allowed maximum of {limitWithUnit}.",values:{currentWithUnit:i,limitWithUnit:n}}:{id:"sdk.genericDimension.hintMessageTooSmall",message:"Current value is {currentWithUnit}, which is smaller than allowed minimum of {limitWithUnit}.",values:{currentWithUnit:i,limitWithUnit:n}}}function v(t,e){let i=`${n(t.currentValue,t.unit).toFixed(t.decimalPlaces)}\u00A0${t.unitLabel}`,a=`${n(t.limitValue,t.unit).toFixed(t.decimalPlaces)}\u00A0${t.unitLabel}`;return"tooLarge"===e?{id:"sdk.angleDimension.hintMessageTooLarge",message:"Current value is {currentWithUnit}, which is larger than allowed maximum of {limitWithUnit}.",values:{currentWithUnit:i,limitWithUnit:a}}:{id:"sdk.angleDimension.hintMessageTooSmall",message:"Current value is {currentWithUnit}, which is smaller than allowed minimum of {limitWithUnit}.",values:{currentWithUnit:i,limitWithUnit:a}}}export class DimensionSystem{_context;state;constructor(t){this._context=t,this.state=new u({selectors:this._context.selectors,componentType:g,getInitialState:t=>{let e=this._context.selectors.getComponentReader().readFirstRootComponent({componentTypes:[m]},t);return{unit:e?.state.initialGlobalUnit??e?.state.distanceDataUnit??i.mm}}})}initialize=t=>this.state.getInitialUpdates(t);getDimensionConfig=t=>{let e=this._context.selectors.getComponentReader().readFirstRootComponent({componentTypes:[m]},t);return{distanceDataUnit:e?.state.distanceDataUnit??i.mm,unitDisplayConfig:e?.state.unitDisplayConfig??p,availableDimensions:e?.state.availableDimensions??h}};getDataDistanceUnit=t=>this.getDimensionConfig(t).distanceDataUnit;getGlobalUnit=t=>this.state.get(t).unit;getSetGlobalUnitUpdates=(t,e)=>this.state.getUpdates(e=>({...e,unit:t}),e);_getDistanceComponentViolations=t=>{let e=this.getDimensionConfig(t),i=this.state.get(t),n=this._context.selectors.getComponentReader().readManyComponents({componentTypes:[r]},t),a=[];for(let t of n){let n=t.state.displayUnit??i.unit,l=t.state.unitDisplayConfig?.[n]??e.unitDisplayConfig[n];if(!l)throw Error(`Unit config for ${n} not found!`);let m=t.state.max;if(void 0!==m&&o(t.state.value,m)){let i={currentValue:t.state.value,limitValue:m,sourceUnit:e.distanceDataUnit,displayUnit:n,unitDisplayConfig:l};a.push({entityId:t.componentInstance.entityId,violation:{type:`${t.componentInstance.instanceName}.distanceDimension.tooLarge`,severity:"fatal",message:f({...i,locale:"en-US"},"tooLarge"),formatControlViolationMessage:(t,e)=>f({...i,locale:e.i18n.locale},"tooLarge")}})}let r=t.state.min;if(void 0!==r&&s(t.state.value,r)){let i={currentValue:t.state.value,limitValue:r,sourceUnit:e.distanceDataUnit,displayUnit:n,unitDisplayConfig:l};a.push({entityId:t.componentInstance.entityId,violation:{type:`${t.componentInstance.instanceName}.distanceDimension.tooSmall`,severity:"fatal",message:f({...i,locale:"en-US"},"tooSmall"),formatControlViolationMessage:(t,e)=>f({...i,locale:e.i18n.locale},"tooSmall")}})}}return a};_getGenericComponentViolations=t=>{let i=this._context.selectors.getComponentReader().readManyComponents({componentTypes:[c]},t),n=[];for(let t of i){if(void 0!==t.state.max&&o(t.state.value,t.state.max)){let i={currentValue:t.state.value,limitValue:t.state.max,decimalPlaces:t.state.decimalPlaces??e,unit:t.state.unit};n.push({entityId:t.componentInstance.entityId,violation:{type:`${t.componentInstance.instanceName}.genericDimension.tooLarge`,severity:"fatal",message:y(i,"tooLarge"),formatControlViolationMessage:()=>y(i,"tooLarge")}})}if(void 0!==t.state.min&&s(t.state.value,t.state.min)){let i={currentValue:t.state.value,limitValue:t.state.min,decimalPlaces:t.state.decimalPlaces??e,unit:t.state.unit};n.push({entityId:t.componentInstance.entityId,violation:{type:`${t.componentInstance.instanceName}.genericDimension.tooSmall`,severity:"fatal",message:y(i,"tooSmall"),formatControlViolationMessage:()=>y(i,"tooSmall")}})}}return n};_getAngleComponentViolations=t=>{let i=this._context.selectors.getComponentReader().readManyComponents({componentTypes:[l]},t),n=[];for(let t of i){let i=t.state.unit??"degree",a=d[i],l=t.state.decimalPlaces??e;if(void 0!==t.state.max&&o(t.state.value,t.state.max)){let e={currentValue:t.state.value,limitValue:t.state.max,unit:i,unitLabel:a,decimalPlaces:l};n.push({entityId:t.componentInstance.entityId,violation:{type:`${t.componentInstance.instanceName}.angleDimension.tooLarge`,severity:"fatal",message:v(e,"tooLarge"),formatControlViolationMessage:()=>v(e,"tooLarge")}})}if(void 0!==t.state.min&&s(t.state.value,t.state.min)){let e={currentValue:t.state.value,limitValue:t.state.min,unit:i,unitLabel:a,decimalPlaces:l};n.push({entityId:t.componentInstance.entityId,violation:{type:`${t.componentInstance.instanceName}.angleDimension.tooSmall`,severity:"fatal",message:v(e,"tooSmall"),formatControlViolationMessage:()=>v(e,"tooSmall")}})}}return n};validateState=t=>[...this._getDistanceComponentViolations(t),...this._getGenericComponentViolations(t),...this._getAngleComponentViolations(t)]}

package/dist/domain/domain-context/dimension-system/index.d.ts

@@ -0,0 +1 @@
+export { type AngleDimensionViolation, type AnyDimensionSystem, DimensionSystem, type DimensionSystemContext, type DistanceDimensionViolation, type GenericDimensionViolation, } from './dimension-system.js';

package/dist/domain/domain-context/dimension-system/index.js

@@ -0,0 +1 @@
+export{DimensionSystem}from"./dimension-system.js";

package/dist/domain/domain-context/domain-context-systems.d.ts

@@ -1,12 +1,12 @@
 import type { $DomainEntity, ActionTypes, Domain, DomainEntity } from '../core/index.js';
-import type { ComponentReader, DomainContextSelectors } from '../domain-runtime/domain-context/index.js';
+import type { ComponentReader, DomainContextSelectors } from '../domain-runtime/index.js';
 import type { BlenderProjections, CollisionProjections, CompositionProjections, ConstraintProjections, PositionProjections, ProjectedEntitiesProjections, SnappingProjections, ValidationProjections } from '../projections/index.js';
-import type { SketchingProjections } from '../sketching/sketching-projections.js';
-import type { ActionSystem } from './action-system/action-system.js';
-import type { DimensionSystem } from './dimension-system/dimension-system.js';
-import type { NavigationSystem } from './navigation-system/navigation-system.js';
-import type { RecipeCookerSystem } from './recipe-system/recipe-cooker-system.js';
-import type { StoreSystem } from './store-system/store-system.js';
+import type { SketchingProjections } from '../sketching/index.js';
+import type { ActionSystem } from './action-system/index.js';
+import type { DimensionSystem } from './dimension-system/index.js';
+import type { NavigationSystem } from './navigation-system/index.js';
+import type { RecipeCookerSystem } from './recipe-system/index.js';
+import type { StoreSystem } from './store-system/index.js';
 import type { UndoSystem } from './undo-system.js';
 /**
  * Stable domain system graph owned by one application slot in the domain runtime.