@salsita-ai/sdk 0.50.0-develop.f42416a4e6 → 0.50.0-develop.f81ab6ac76

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

package/dist/domain/core/reflection.js

@@ -1 +0,0 @@
-import{extendedSchemaValidator as t}from"./json-schema.js";import{domainEntityTypeFromId as e,isDomainEntityId as s}from"./model.js";export class SchemaReflection{_meta;constructor(e,s){this._meta={name:e,schema:s,validator:t.compile(s)}}is=t=>this._meta.validator(t);assert(t){if(!this._meta.validator(t))throw Error(`Expected value to match schema of '${this._meta.name}' but got ${t}`)}}export class EnumReflection extends SchemaReflection{constructor(t,e){for(let s of(super(t,e),e.enum))Object.defineProperty(this,s,{value:s,writable:!1,enumerable:!0,configurable:!1})}values=()=>this._meta.schema.enum}let o=class BaseDomainEntityReflection{type;constructor(t){this.type=t}is=t=>t.type===this.type;assert(t){if(!this.is(t))throw Error(`Expected entity #${t.id} to be of type ${this.type} but got ${t.type}`)}isId=t=>s(t)&&e(t)===this.type;assertId(t){if(!this.isId(t))throw Error(`Expected entity id to be of type ${this.type} but got ${t}`)}assertIds(t){t.forEach(t=>{this.assertId(t)})}};export class DomainEntityReflection extends o{_meta;constructor(e,s){super(e);let o=s.reduce((t,e)=>{let s=e.$defs;return"object"==typeof s&&null!==s&&Object.assign(t,s),t},{}),r={type:"object",properties:{id:{type:"string",pattern:`^${e}-[0-9]+$`},type:{type:"string",const:e},...s.reduce((t,e)=>({...t,...e.properties}),{})},required:["id","type",...s.flatMap(t=>t.required??[])],additionalProperties:!1},i={...r,$defs:o};this._meta={name:e,schema:r,validator:t.compile(i)}}}let r=class $DomainEntityReflectionClass extends o{expressions;constructor(t,e,s){super(t),this.expressions=e,Object.assign(this,s)}};export const $DomainEntityReflection=r;let i=class BaseAliasReflection{name;types;typeSet;constructor(t,e){this.name=t,this.types=e,this.typeSet=new Set(e)}is=t=>this.typeSet.has(t.type);assert(t){if(!this.is(t))throw Error(`Expected entity #${t.id} to be a member of alias ${this.name} but got ${t.type}`)}isId=t=>s(t)&&this.typeSet.has(e(t));assertId(t){if(!this.isId(t))throw Error(`Expected entity id to be of a member of alias ${this.name} but got ${t}`)}assertIds(t){t.forEach(t=>{this.assertId(t)})}};export class RawAliasReflection extends i{reflections;constructor(t,e){super(t,e.map(t=>t.type)),this.reflections=e}}let a=class EnhancedAliasReflectionClass extends i{constructor(t,e,s){super(t,e),Object.assign(this,s)}};export const EnhancedAliasReflection=a;export function assertString(t){if("string"!=typeof t)throw Error(`Expected value to be a string but got ${t}`)}export function assertNumber(t){if("number"!=typeof t)throw Error(`Expected value to be a number but got ${t}`)}export function assertBoolean(t){if("boolean"!=typeof t)throw Error(`Expected value to be a boolean but got ${t}`)}

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

@@ -1,10 +0,0 @@
-import type { ComponentSnapshot, SystemComponentTypeConstraint } from './component.js';
-import type { DomainEntity } from './model.js';
-export interface DomainState<ENTITIES extends DomainEntity<string>> {
-    readonly rootEntityId: ENTITIES['id'];
-    readonly rootEntityType: ENTITIES['type'];
-    readonly entities: readonly ENTITIES[];
-    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>;

package/dist/domain/domain-context/recipe-system/recipes.d.ts

@@ -1,57 +0,0 @@
-import type { OmitEmpty, OmitNever, UnionToIntersection } from '@salsita-ai/common/utils';
-import { type AliasMap, type EventualAlias, type ExpandAlias, type ExtractFromAliasedRecord, type TypeOrAlias } from '../../core/alias.js';
-import { type DomainEntity, type DomainEntityId, type EntityByType } from '../../core/model.js';
-import type { DomainEntityReflection } from '../../core/reflection.js';
-export type EntityDefaults<ENTITY extends DomainEntity<string>> = {
-    [K in Exclude<keyof ENTITY, 'id' | 'type'>]: ENTITY[K] extends DomainEntityId<any> ? null : ENTITY[K];
-};
-export type EntityRecipe<ENTITY extends DomainEntity<string>> = ENTITY;
-export type EntityOverrides<ENTITIES extends DomainEntity<string>, TYPE extends ENTITIES['type']> = Partial<Omit<EntityByType<ENTITIES, TYPE>, 'type'>> & {
-    type: TYPE;
-};
-export type DeclaredEntitiesDefaults<ENTITIES extends DomainEntity<string>> = {
-    [K in ENTITIES['type']]: EntityDefaults<EntityByType<ENTITIES, K>>;
-};
-type ExpandDefaults<ENTITIES extends DomainEntity<string>, ALIASES extends Readonly<Record<string, ENTITIES>>, ALIASED_DEFAULTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, unknown>>>> = {
-    [K in ENTITIES['type']]: ExtractFromAliasedRecord<ENTITIES, ALIASES, ALIASED_DEFAULTS, EventualAlias<ENTITIES, ALIASES, K> | K> extends infer DEFAULTS_FROM_ALIAS ? [
-        DEFAULTS_FROM_ALIAS
-    ] extends [never] ? Record<never, never> : unknown extends UnionToIntersection<DEFAULTS_FROM_ALIAS> ? never : UnionToIntersection<DEFAULTS_FROM_ALIAS> : never;
-};
-export type AliasedEntitiesDefaults<ENTITIES extends DomainEntity<string>, ALIASES extends Readonly<Record<string, ENTITIES>>> = {
-    [K in TypeOrAlias<ENTITIES, ALIASES>]?: Partial<EntityDefaults<ExpandAlias<ENTITIES, ALIASES, K>>>;
-};
-export type RecipeFactory<ENTITIES extends DomainEntity<string>> = <TYPE extends ENTITIES['type']>(overrides: EntityOverrides<ENTITIES, TYPE>) => EntityRecipe<EntityByType<ENTITIES, TYPE>>;
-type ConflictingDefaults<PROVIDED extends Record<string, Record<string, unknown>>, EXPECTED extends Record<string, Record<string, unknown>>> = OmitEmpty<OmitNever<{
-    [TYPE in keyof PROVIDED | keyof EXPECTED]: TYPE extends keyof EXPECTED ? TYPE extends keyof PROVIDED ? PROVIDED[TYPE] extends EXPECTED[TYPE] ? never : OmitNever<Exclude<EXPECTED[TYPE], PROVIDED[TYPE]>> : EXPECTED[TYPE] : never;
-}>>;
-type Build<ENTITIES extends DomainEntity<string>, PROVIDED extends Record<string, Record<string, unknown>>, EXPECTED extends Record<string, Record<string, unknown>>> = Record<string, never> extends ConflictingDefaults<PROVIDED, EXPECTED> ? {
-    build: () => RecipeFactory<ENTITIES>;
-} : {
-    /**
-     * DO NOT USE in runtime!
-     *
-     * This is just a dev-time tool to review which defaults you forgot to provide.
-     * Use your IDEs code-completion to see which entities have missing expressions
-     * and which expressions these are.
-     *
-     * Use the helper when you see the following error on the `.build()` method call:
-     * ```
-     * TS2349: This expression is not callable.
-     * Type never has no call signatures.
-     * ```
-     * simply
-     * ```ts
-     *   .withDefaults({...})
-     *   ._conflicts.Oven. // <- trigger code-completion here
-     * ```
-     */
-    _conflicts: ConflictingDefaults<PROVIDED, EXPECTED>;
-};
-export declare const RecipeFactoryBuilder: {
-    forAliases: <ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>>(aliasMap: AliasMap<ALIASES>) => {
-        forEntities: (entityReflections: ReadonlyArray<ENTITIES extends any ? DomainEntityReflection<ENTITIES> : never>) => {
-            withDefaults: <ALIASED_DEFAULTS extends AliasedEntitiesDefaults<ENTITIES, ALIASES>>(entitiesDefaults: ALIASED_DEFAULTS) => Build<ENTITIES, ExpandDefaults<ENTITIES, ALIASES, ALIASED_DEFAULTS>, DeclaredEntitiesDefaults<ENTITIES>>;
-        };
-    };
-};
-export {};

package/dist/domain/domain-context/recipe-system/recipes.js

@@ -1 +0,0 @@
-import{expandAlias as r}from"../../core/alias.js";import{_unsafeBuildDomainEntityId as e}from"../../core/model.js";export const RecipeFactoryBuilder={forAliases:t=>({forEntities:o=>({withDefaults:i=>{let a={};Object.entries(i).forEach(([e,o])=>{r(t,e).forEach(r=>{a[r]={...a[r],...o}})});let f=new Map(o.map(r=>[r.type,r._meta.validator]));return Object.entries(a).forEach(([r,t])=>{let o=f.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.`)}),{build:()=>r=>({id:e(r.type,1),...a[r.type],...r})}}})})};

package/dist/domain/expressions/constant-expressions.d.ts

@@ -1,9 +0,0 @@
-import type { ExpandAlias, TypeOrAlias } from '../core/alias.js';
-import type { AnonymousExpression, ExpressionMetas } from '../core/expression.js';
-import type { DomainEntity } from '../core/model.js';
-export type ConstantExpressions<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>, CONSTANTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, unknown>>>> = {
-    readonly [TYPE_OR_ALIAS in keyof CONSTANTS & string]: {
-        readonly [NAME in keyof CONSTANTS[TYPE_OR_ALIAS]]: AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, TYPE_OR_ALIAS>, CONSTANTS[TYPE_OR_ALIAS][NAME]>;
-    };
-};
-export declare const createConstantExpressionFactory: <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>>(metas: ExpressionMetas<ENTITIES, ALIASES>) => <CONSTANTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, unknown>>>>(constants: CONSTANTS) => ConstantExpressions<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, CONSTANTS>;

package/dist/domain/expressions/constant-expressions.js

@@ -1 +0,0 @@
-import{mapNestedObject as t}from"../utils/map-nested-object.js";export const createConstantExpressionFactory=e=>o=>t()(o,([t,o,a])=>[[t,o,{meta:e[t]?.[o]??{},evaluate:()=>a}]]);

package/dist/domain/expressions/custom-expression.d.ts

@@ -1,13 +0,0 @@
-import type { TypeOrAlias } from '../core/alias.js';
-import type { AnonymousExpression, ExpressionContext, ExpressionMeta, ExpressionMetas } from '../core/expression.js';
-import type { $DomainEntity, DomainEntity, EntityByType } from '../core/model.js';
-import type { DomainState } from '../core/state.js';
-import type { AliasedExpressions } from '../domain-builder.js';
-export type CustomExpression<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 $DomainEntity<ENTITIES>, T> = (self: SELF, state: DomainState<ENTITIES>, ctx: ExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>) => T;
-export type PotentialCustomExpressions<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>> = {
-    [TYPE_OR_ALIAS in keyof $MAP]?: {
-        [NAME in Extract<keyof $MAP[TYPE_OR_ALIAS], `$${string}`>]?: CustomExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, $MAP[TYPE_OR_ALIAS], $MAP[TYPE_OR_ALIAS][NAME]>;
-    };
-};
-export declare const createCustomExpressionFactory: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<TypeOrAlias<ENTITIES, ALIASES>, $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>>(metas: ExpressionMetas<ENTITIES, ALIASES>) => (implementations: PotentialCustomExpressions<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA>) => AliasedExpressions<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES>;
-export declare const createCustomExpression: <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 $DomainEntity<ENTITIES>, T>(evaluate: CustomExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, $SELF, T>, meta: ExpressionMeta) => AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, EntityByType<ENTITIES, $SELF['type']>, T>;

package/dist/domain/expressions/custom-expression.js

@@ -1 +0,0 @@
-import{mapNestedObject as e}from"../utils/map-nested-object.js";export const createCustomExpressionFactory=t=>o=>e()(o,([e,o,r])=>{if(!r)throw Error(`Custom expression for ${e}.${o} is of type undefined`);return[[e,o,createCustomExpression(r,t[e]?.[o]??{})]]});export const createCustomExpression=(e,t)=>({evaluate:(t,o,r)=>e(r.domain.get$Entity(t,o),o,r),meta:t});

package/dist/domain/expressions/index.d.ts

@@ -1 +0,0 @@
-export { prepareDomainExpressions } from './prepare-domain-expressions.js';

package/dist/domain/expressions/index.js

@@ -1 +0,0 @@
-export{prepareDomainExpressions}from"./prepare-domain-expressions.js";

package/dist/domain/expressions/memoize-expression.d.ts

@@ -1,17 +0,0 @@
-import type { Expression, ExpressionOrigin } from '../core/expression.js';
-import type { DomainEntity, DomainEntityId } from '../core/model.js';
-export interface ExpressionTrace {
-    origin: ExpressionOrigin;
-    entityId: DomainEntityId<string>;
-}
-export declare const traceToString: (trace: ExpressionTrace) => string;
-export declare class ExpressionEvaluationError extends Error {
-    readonly _tag = "expression-evaluation-error";
-    constructor(trace: ExpressionTrace, error: any);
-}
-export declare class CircularDependencyError extends Error {
-    readonly _tag = "circular-dependency-error";
-    readonly path: ExpressionTrace[];
-    constructor(trace: ExpressionTrace, cause?: CircularDependencyError);
-}
-export declare const memoizeExpression: <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>(expression: Expression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, SELF, T>) => Expression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, SELF, T>;

package/dist/domain/expressions/prepare-domain-expressions.d.ts

@@ -1,16 +0,0 @@
-import type { AnyExpressions } from '../core/expression.js';
-interface DomainExpressionsSource {
-    readonly expressions: AnyExpressions;
-    readonly $entityReflections: Record<string, {
-        readonly expressions: readonly string[];
-    }>;
-}
-/**
- * Derives the runnable expression table from the factory's spec data: validates the declared
- * (reflection) expressions against the implemented ones — missing implementations throw, extra
- * ones log — and wraps every expression in the per-state memoization. Pure with respect to its
- * input, so it can back a registry selector keyed on the factory identity: a hot-reloaded factory
- * produces a fresh table, an unchanged one keeps the memoized result.
- */
-export declare const prepareDomainExpressions: (source: DomainExpressionsSource) => AnyExpressions;
-export {};

package/dist/domain/invariants/builtin-invariant.d.ts

@@ -1,5 +0,0 @@
-import type { DomainEntity, DomainEntityId } from '../core/model.js';
-import type { DomainState } from '../core/state.js';
-import type { Invariant } from './invariants.js';
-import type { Violation } from './violation.js';
-export declare const createInvariant: <VIOLATION_TYPE extends string>(evaluate: (selfId: DomainEntityId<string>, state: DomainState<DomainEntity<string>>) => ReadonlyArray<Violation<VIOLATION_TYPE>>) => Invariant<DomainEntity<string>, DomainEntity<string>, Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, DomainEntity<string>, VIOLATION_TYPE>;

package/dist/domain/invariants/custom-invariants.d.ts

@@ -1,22 +0,0 @@
-import type { OmitEmpty, OmitNever } from '@salsita-ai/common/utils';
-import type { ExpandAlias, TypeOrAlias } from '../core/alias.js';
-import type { $DomainEntity, DomainEntity } from '../core/model.js';
-import type { CustomExpression } from '../expressions/custom-expression.js';
-import type { Invariant } from './invariants.js';
-import type { Violation } from './violation.js';
-export type CustomInvariantsFromBlueprints<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>, BLUEPRINTS extends Partial<Record<keyof $MAP & string, Record<string, boolean | string>>>> = {
-    [TYPE_OR_ALIAS in keyof BLUEPRINTS]: {
-        [NAME in keyof BLUEPRINTS[TYPE_OR_ALIAS]]: TYPE_OR_ALIAS extends keyof $MAP ? CustomExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, $MAP[TYPE_OR_ALIAS], BLUEPRINTS[TYPE_OR_ALIAS][NAME] extends string ? ReadonlyArray<Violation<BLUEPRINTS[TYPE_OR_ALIAS][NAME]>> : BLUEPRINTS[TYPE_OR_ALIAS][NAME]> : never;
-    };
-};
-export type StaticallyDefinedViolations<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, BLUEPRINTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, boolean | string>>>> = OmitEmpty<{
-    [TYPE_OR_ALIAS in keyof BLUEPRINTS]: OmitNever<{
-        [NAME in keyof BLUEPRINTS[TYPE_OR_ALIAS]]: BLUEPRINTS[TYPE_OR_ALIAS][NAME] extends boolean ? Violation<string> : never;
-    }>;
-}>;
-export type InvariantsFromBlueprints<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>, BLUEPRINTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, boolean | string>>>, STATIC_VIOLATIONS extends StaticallyDefinedViolations<ENTITIES, ALIASES, BLUEPRINTS>, PICK extends keyof BLUEPRINTS = keyof BLUEPRINTS> = {
-    readonly [TYPE_OR_ALIAS in keyof BLUEPRINTS & string & PICK]: ReadonlyArray<{
-        [NAME in keyof BLUEPRINTS[TYPE_OR_ALIAS]]: Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, TYPE_OR_ALIAS>, BLUEPRINTS[TYPE_OR_ALIAS][NAME] extends boolean ? TYPE_OR_ALIAS extends keyof STATIC_VIOLATIONS ? NAME extends keyof STATIC_VIOLATIONS[TYPE_OR_ALIAS] ? STATIC_VIOLATIONS[TYPE_OR_ALIAS][NAME]['type'] : never : never : BLUEPRINTS[TYPE_OR_ALIAS][NAME] extends string ? BLUEPRINTS[TYPE_OR_ALIAS][NAME] : never>;
-    }[keyof BLUEPRINTS[TYPE_OR_ALIAS]]>;
-};
-export declare const createCustomInvariantFactory: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<TypeOrAlias<ENTITIES, ALIASES>, $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>, BLUEPRINTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, boolean | string>>>>() => <STATIC_VIOLATIONS extends StaticallyDefinedViolations<ENTITIES, ALIASES, BLUEPRINTS>>(staticViolations: STATIC_VIOLATIONS) => <TYPES_OR_ALIASES extends keyof BLUEPRINTS & string>(implementations: Pick<CustomInvariantsFromBlueprints<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, BLUEPRINTS>, TYPES_OR_ALIASES>) => InvariantsFromBlueprints<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, BLUEPRINTS, STATIC_VIOLATIONS, TYPES_OR_ALIASES>;

package/dist/domain/invariants/custom-invariants.js

@@ -1 +0,0 @@
-import{withProfilerLabel as t}from"../utils/profiler-label.js";export const createCustomInvariantFactory=()=>e=>r=>{let n={};return Object.entries(r).forEach(([r,o])=>{let a=Object.entries(o).map(([n,o])=>({evaluate:t(`${r}_invariant_${n}`,(t,a,i)=>{let l=o(i.domain.get$Entity(t,a),a,i);if("boolean"==typeof l){let t=e[r]?.[n];if(!t)throw Error(`Cannot find statically defined violation for ${r}.${n}`);return l?[]:[t]}return l})}));n[r]=a}),n};

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

@@ -1,68 +0,0 @@
-import type { OmitNever } from '@salsita-ai/common/utils';
-import { type AliasMap, type EventualAlias, type ExpandAlias, type ExtractFromAliasedRecord, type TypeOrAlias } from '../core/alias.js';
-import type { AnonymousExpression, ExpressionContext } from '../core/expression.js';
-import type { $DomainEntity, DomainEntity, EntityByType } from '../core/model.js';
-import type { DomainState } from '../core/state.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 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;
-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);
-    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/invariants/invariants.js

@@ -1 +0,0 @@
-import{expandAlias as a}from"../core/alias.js";export class InvariantBuilder{aliasMap;invariants;constructor(a,i={}){this.aliasMap=a,this.invariants=i}withInvariants(i){let t={...this.invariants};return Object.entries(i).forEach(([i,s])=>{a(this.aliasMap,i).forEach(a=>{t[a]=[...t[a]??[],...s]})}),new InvariantBuilder(this.aliasMap,t)}_conflicts={};buildViolationExpressions=()=>{let a={};return Object.entries(this.invariants).forEach(([i,t])=>{a[i]={$violations:{evaluate:(a,i,s)=>t.flatMap(t=>t.evaluate(a,i,s)),meta:{}}}}),a}}

package/dist/domain/invariants/violation-component.js

@@ -1 +0,0 @@
-import{SystemComponentBuilder as o}from"../components/system-component-builder.js";import{ViolationSchema as t}from"./violation.js";export const violationsComponent=o.component("violations").withState({tsType:"ViolationComponentState",type:"object",properties:{violations:{type:"array",items:t}},required:["violations"],additionalProperties:!1}).build();

package/dist/domain/invariants/violation.d.ts

@@ -1,85 +0,0 @@
-import type { I18n } from '@lingui/core';
-import type { Localizable } from '@salsita-ai/common/utils';
-import type { $DomainEntity, DomainEntity, EntityId } from '../core/model.js';
-import type { StateEmission } from '../domain-context/store-system/store-system.js';
-/**
- * An **ORDERED** list of violation severities.
- * Do not change the order of the items in this list.
- */
-declare const VIOLATION_SEVERITIES: readonly [
-/**
- * A fatal error that will never be propagated to the scene, undo stack or saved.
- *
- *  If a feature uses "dry-run" to verify whether an action should be allowed,
- *  this severity will prohibit the change.
- */
-'fatal', 
-/**
- * Similar semantics to `fatal` - i.e. the violation will never be propagated to the scene, undo stack or saved
- * - but unlike `fatal`, "dry-run" will allow the change and expect a custom logic to suggest or apply a fix.
- */
-'fixable', 
-/**
- * A warning that will be propagated to the scene, undo stack and saved.
- * However, it will prevent the configuration from being "finalized" (e.g. added to e-commerce cart).
- */
-'warning', 
-/**
- * An informative notice that will be propagated to the scene, undo stack and saved.
- * This severity does not impose any restrictions on the configuration.
- */
-'notice'];
-export type ViolationSeverity = (typeof VIOLATION_SEVERITIES)[number];
-export declare const compareSeverity: (a: ViolationSeverity, b: ViolationSeverity) => number;
-export interface Violation<TYPE extends string> {
-    readonly type: TYPE;
-    readonly severity: ViolationSeverity;
-    readonly message?: Localizable;
-    /**
-     * Only violations with the highest priority will be shown during on input controls.
-     * If there are multiple violations with the same priority,
-     * all of them will be shown in the tooltip, concatenated with a dot.
-     *
-     * Default priority is 0.
-     */
-    readonly controlViolationPriority?: number;
-    /**
-     * An optional callback to format the violation message for control tooltips.
-     * Unlike the general `message` field, this callback receives the state emission
-     * and can format the message based on what updates occurred.
-     *
-     * @returns A message formatted specifically for this state emission,
-     * `null` to skip the message when generating tooltip text,
-     * or `undefined` to fallback to the general `message` field.
-     */
-    readonly formatControlViolationMessage?: (stateEmission: StateEmission<DomainEntity<string>, Record<string, $DomainEntity<DomainEntity<string>>>>, context: {
-        i18n: I18n;
-    }) => Localizable | undefined | null;
-}
-export declare const ViolationSchema: {
-    readonly type: 'object';
-    readonly properties: {
-        readonly type: {
-            readonly type: 'string';
-        };
-        readonly severity: {
-            readonly enum: ("fatal" | "fixable" | "notice" | "warning")[];
-        };
-        readonly message: {
-            readonly type: 'string';
-        };
-        readonly controlViolationPriority: {
-            readonly type: 'number';
-        };
-    };
-    readonly required: ["type", "severity"];
-    readonly additionalProperties: false;
-};
-export type ViolationTypesOf$Entity<$ENTITY extends $DomainEntity<DomainEntity<string>>> = $ENTITY extends {
-    $violations: ReadonlyArray<Violation<infer VIOLATION_TYPE>>;
-} ? VIOLATION_TYPE : never;
-export interface EntityViolation<ENTITIES extends DomainEntity<string>, VIOLATION_TYPE extends string> {
-    readonly entityId: EntityId<ENTITIES>;
-    readonly violation: Violation<VIOLATION_TYPE>;
-}
-export {};

package/dist/domain/invariants/violation.js

@@ -1 +0,0 @@
-let e=["fatal","fixable","warning","notice"];export const compareSeverity=(t,i)=>e.indexOf(t)-e.indexOf(i);export const ViolationSchema={type:"object",properties:{type:{type:"string"},severity:{enum:e.slice()},message:{type:"string"},controlViolationPriority:{type:"number"}},required:["type","severity"],additionalProperties:!1};

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

@@ -1,33 +0,0 @@
-import { type AliasMap, type TypeOrAlias } from '../core/alias.js';
-import type { ExpressionMeta } from '../core/expression.js';
-import type { DomainEntity, DomainEntityId } from '../core/model.js';
-import type { DomainState } from '../core/state.js';
-interface AllOfType0Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'allOfType';
-    target: TARGET;
-    cardinality: '0-1';
-    meta?: ExpressionMeta;
-}
-interface AllOfType1Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'allOfType';
-    target: TARGET;
-    cardinality: '1-1';
-    meta?: ExpressionMeta;
-}
-interface AllOfTypeNRelation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'allOfType';
-    target: TARGET;
-    cardinality: '0-N' | '1-N';
-    meta?: ExpressionMeta;
-}
-export type AllOfTypeRelation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> = AllOfType0Relation<ENTITIES, ALIASES, TARGET> | AllOfType1Relation<ENTITIES, ALIASES, TARGET> | AllOfTypeNRelation<ENTITIES, ALIASES, TARGET>;
-/**
- * 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: <ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>>(aliasMap: AliasMap<ALIASES>) => (relation: {
-    readonly target: TypeOrAlias<ENTITIES, ALIASES>;
-}) => (_selfId: DomainEntityId<string>, state: DomainState<ENTITIES>) => DomainEntityId<string>[];
-export {};

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

@@ -1 +0,0 @@
-import{expandAlias as e}from"../core/alias.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 ${String(o.target)} after evaluation started. Create all relation expressions before evaluating the domain state.`);let i=new Set(e(t,o.target)),l=[...i].sort().join("|");return r.set(l,i),(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(l)}};

package/dist/domain/relations/component-factories.d.ts

@@ -1,15 +0,0 @@
-import type { DomainEntity, DomainEntityId } from '../core/model.js';
-import type { DomainEntityReflection, RawAliasReflection } from '../core/reflection.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;
-export declare const createSingleReferenceWrite: <TARGET extends DomainEntity<string>>(targetReflection: DomainEntityReflection<TARGET> | RawAliasReflection<TARGET>, field: string) => (writableState: ReferenceComponentState) => {
-    [x: string]: DomainEntityId<string> | null;
-};
-export declare const createMultipleReferenceRead: <TARGET extends DomainEntity<string>>(_targetReflection: DomainEntityReflection<TARGET> | RawAliasReflection<TARGET>, field: string) => (self: object, state: unknown, ctx: unknown) => ReferenceComponentState;
-export declare const createMultipleReferenceWrite: <TARGET extends DomainEntity<string>>(targetReflection: DomainEntityReflection<TARGET> | RawAliasReflection<TARGET>, field: string) => (writableState: ReferenceComponentState) => {
-    [x: string]: readonly DomainEntityId<string>[];
-};
-export declare const createSingleCompositionRead: (relationName: string) => (self: object, state: unknown, ctx: unknown) => ComposedOfComponentState;
-export declare const createMultipleCompositionRead: (relationName: string) => (self: object, state: unknown, ctx: unknown) => ComposedOfComponentState;
-export declare const createEmptyWrite: () => () => {};

package/dist/domain/relations/component-factories.js

@@ -1 +0,0 @@
-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/composed-of.d.ts

@@ -1,12 +0,0 @@
-import { type DomainEntityId } from '../core/model.js';
-export type ComposedOfComponentState = {
-    /**
-     * List of entity IDs that the parent entity is composed of
-     */
-    readonly childEntityIds: ReadonlyArray<DomainEntityId<string>>;
-};
-/**
- * Defines a general composition of entities with no specific rules.
- */
-export declare const composedOfComponent: import("../index.js").SystemComponentType<"composedOf", ComposedOfComponentState, never>;
-export type ComposedOfComponent = typeof composedOfComponent;

package/dist/domain/relations/composed-of.js

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

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

@@ -1,29 +0,0 @@
-import type { ExpandAlias, TypeOrAlias } from '../core/alias.js';
-import type { ExpressionMeta } from '../core/expression.js';
-import type { DomainEntity } from '../core/model.js';
-import type { ArrayReferenceField, SingleReferenceField } from './reference-field.js';
-import type { RelationImplementation } from './relation-implementation.js';
-interface DirectArrayRelation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'direct';
-    target: TARGET;
-    field: ArrayReferenceField<ExpandAlias<ENTITIES, ALIASES, SELF>, ExpandAlias<ENTITIES, ALIASES, TARGET>>;
-    cardinality: '0-N' | '1-N';
-    meta?: ExpressionMeta;
-}
-interface DirectSingle1Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'direct';
-    target: TARGET;
-    field: SingleReferenceField<ExpandAlias<ENTITIES, ALIASES, SELF>, ExpandAlias<ENTITIES, ALIASES, TARGET>, never>;
-    cardinality: '1-1';
-    meta?: ExpressionMeta;
-}
-interface DirectSingle0Relation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> {
-    kind: 'direct';
-    target: TARGET;
-    field: SingleReferenceField<ExpandAlias<ENTITIES, ALIASES, SELF>, ExpandAlias<ENTITIES, ALIASES, TARGET>, null>;
-    cardinality: '0-1';
-    meta?: ExpressionMeta;
-}
-export type DirectRelation<ENTITIES extends DomainEntity<string>, ALIASES extends Record<string, ENTITIES>, SELF extends TypeOrAlias<ENTITIES, ALIASES>, TARGET extends TypeOrAlias<ENTITIES, ALIASES>> = DirectArrayRelation<ENTITIES, ALIASES, SELF, TARGET> | DirectSingle1Relation<ENTITIES, ALIASES, SELF, TARGET> | DirectSingle0Relation<ENTITIES, ALIASES, SELF, TARGET>;
-export declare const directRelation: RelationImplementation<'direct'>;
-export {};