@craft-ts/core 0.7.0-beta.13

package/src/lib/standard-schema.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Minimal local copy of the Standard Schema V1 types used by Craft.
+ *
+ * Source: https://github.com/standard-schema/standard-schema/blob/main/packages/spec/src/index.ts
+ * The upstream project is distributed under the MIT license.
+ *
+ * Nested types used to live in `export namespace StandardSchemaV1`; that form
+ * is replaced by sibling interfaces so the package stays `erasableSyntaxOnly`.
+ */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly '~standard': StandardSchemaV1Props<Input, Output>;
+}
+export interface StandardSchemaV1Props<Input = unknown, Output = Input> {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly types?: StandardSchemaV1Types<Input, Output>;
+    readonly validate: (value: unknown, options?: StandardSchemaV1Options) => StandardSchemaV1Result<Output> | Promise<StandardSchemaV1Result<Output>>;
+}
+export interface StandardSchemaV1Types<Input = unknown, Output = Input> {
+    readonly input: Input;
+    readonly output: Output;
+}
+export interface StandardSchemaV1Options {
+    readonly libraryOptions?: Record<string, unknown>;
+}
+export type StandardSchemaV1Result<Output> = StandardSchemaV1SuccessResult<Output> | StandardSchemaV1FailureResult;
+export interface StandardSchemaV1SuccessResult<Output> {
+    readonly value: Output;
+    readonly issues?: undefined;
+}
+export interface StandardSchemaV1FailureResult {
+    readonly issues: ReadonlyArray<StandardSchemaV1Issue>;
+}
+export interface StandardSchemaV1Issue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | StandardSchemaV1PathSegment>;
+}
+export interface StandardSchemaV1PathSegment {
+    readonly key: PropertyKey;
+}
+export type StandardSchemaV1InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+export type StandardSchemaV1InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+//# sourceMappingURL=standard-schema.d.ts.map

package/src/lib/standard-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/standard-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;IAC/D,QAAQ,CAAC,WAAW,EAAE,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,qBAAqB,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;IACpE,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACtD,QAAQ,CAAC,QAAQ,EAAE,CACjB,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,uBAAuB,KAC9B,sBAAsB,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC,CAAC;CAC/E;AAED,MAAM,WAAW,qBAAqB,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;IACpE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnD;AAED,MAAM,MAAM,sBAAsB,CAAC,MAAM,IACrC,6BAA6B,CAAC,MAAM,CAAC,GACrC,6BAA6B,CAAC;AAElC,MAAM,WAAW,6BAA6B,CAAC,MAAM;IACnD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;CAC7B;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC;CACvD;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,WAAW,GAAG,2BAA2B,CAAC,CAAC;CAC1E;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;CAC3B;AAED,MAAM,MAAM,0BAA0B,CAAC,MAAM,SAAS,gBAAgB,IACpE,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;AAErD,MAAM,MAAM,2BAA2B,CAAC,MAAM,SAAS,gBAAgB,IACrE,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC"}

package/src/lib/standard-schema.js

@@ -0,0 +1 @@
+//# sourceMappingURL=standard-schema.js.map

package/src/lib/standard-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/standard-schema.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Minimal local copy of the Standard Schema V1 types used by Craft.\n *\n * Source: https://github.com/standard-schema/standard-schema/blob/main/packages/spec/src/index.ts\n * The upstream project is distributed under the MIT license.\n *\n * Nested types used to live in `export namespace StandardSchemaV1`; that form\n * is replaced by sibling interfaces so the package stays `erasableSyntaxOnly`.\n */\nexport interface StandardSchemaV1<Input = unknown, Output = Input> {\n  readonly '~standard': StandardSchemaV1Props<Input, Output>;\n}\n\nexport interface StandardSchemaV1Props<Input = unknown, Output = Input> {\n  readonly version: 1;\n  readonly vendor: string;\n  readonly types?: StandardSchemaV1Types<Input, Output>;\n  readonly validate: (\n    value: unknown,\n    options?: StandardSchemaV1Options,\n  ) => StandardSchemaV1Result<Output> | Promise<StandardSchemaV1Result<Output>>;\n}\n\nexport interface StandardSchemaV1Types<Input = unknown, Output = Input> {\n  readonly input: Input;\n  readonly output: Output;\n}\n\nexport interface StandardSchemaV1Options {\n  readonly libraryOptions?: Record<string, unknown>;\n}\n\nexport type StandardSchemaV1Result<Output> =\n  | StandardSchemaV1SuccessResult<Output>\n  | StandardSchemaV1FailureResult;\n\nexport interface StandardSchemaV1SuccessResult<Output> {\n  readonly value: Output;\n  readonly issues?: undefined;\n}\n\nexport interface StandardSchemaV1FailureResult {\n  readonly issues: ReadonlyArray<StandardSchemaV1Issue>;\n}\n\nexport interface StandardSchemaV1Issue {\n  readonly message: string;\n  readonly path?: ReadonlyArray<PropertyKey | StandardSchemaV1PathSegment>;\n}\n\nexport interface StandardSchemaV1PathSegment {\n  readonly key: PropertyKey;\n}\n\nexport type StandardSchemaV1InferInput<Schema extends StandardSchemaV1> =\n  NonNullable<Schema['~standard']['types']>['input'];\n\nexport type StandardSchemaV1InferOutput<Schema extends StandardSchemaV1> =\n  NonNullable<Schema['~standard']['types']>['output'];\n"]}

package/src/lib/state-method-runtime-context.d.ts

@@ -0,0 +1,13 @@
+import type { Provider, Signal } from './host/craft-compat';
+import { type PrimitiveMethodRuntimeContext } from './primitive-method-runtime-context';
+export type StateMethodRuntimeContext = PrimitiveMethodRuntimeContext<'state'>;
+type StateInsertionContext = Readonly<{
+    state: Signal<unknown>;
+    set(value: unknown): unknown;
+    update(updater: (current: unknown) => unknown): unknown;
+    patch(updater: (current: unknown) => object): unknown;
+}>;
+export declare function injectStateMethodRuntimeContext(): StateMethodRuntimeContext | undefined;
+export declare function ɵprovideStateMethodRuntimeContext(context: StateInsertionContext, originalFactory: (...args: never[]) => unknown): Provider;
+export {};
+//# sourceMappingURL=state-method-runtime-context.d.ts.map

package/src/lib/state-method-runtime-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-method-runtime-context.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/state-method-runtime-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAGL,KAAK,6BAA6B,EACnC,MAAM,oCAAoC,CAAC;AAE5C,MAAM,MAAM,yBAAyB,GAAG,6BAA6B,CAAC,OAAO,CAAC,CAAC;AAE/E,KAAK,qBAAqB,GAAG,QAAQ,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IACvB,GAAG,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IAC7B,MAAM,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC;IACxD,KAAK,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,GAAG,OAAO,CAAC;CACvD,CAAC,CAAC;AAEH,wBAAgB,+BAA+B,IAC3C,yBAAyB,GACzB,SAAS,CAKZ;AAED,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,qBAAqB,EAC9B,eAAe,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,GAC7C,QAAQ,CAMV"}

package/src/lib/state-method-runtime-context.js

@@ -0,0 +1,11 @@
+import { injectPrimitiveMethodRuntimeContext, ɵprovidePrimitiveMethodRuntimeContext, } from './primitive-method-runtime-context';
+export function injectStateMethodRuntimeContext() {
+    const context = injectPrimitiveMethodRuntimeContext();
+    return context?.kind === 'state'
+        ? context
+        : undefined;
+}
+export function ɵprovideStateMethodRuntimeContext(context, originalFactory) {
+    return ɵprovidePrimitiveMethodRuntimeContext('state', context, originalFactory);
+}
+//# sourceMappingURL=state-method-runtime-context.js.map

package/src/lib/state-method-runtime-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-method-runtime-context.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/state-method-runtime-context.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mCAAmC,EACnC,qCAAqC,GAEtC,MAAM,oCAAoC,CAAC;AAW5C,MAAM,UAAU,+BAA+B;IAG7C,MAAM,OAAO,GAAG,mCAAmC,EAAE,CAAC;IACtD,OAAO,OAAO,EAAE,IAAI,KAAK,OAAO;QAC9B,CAAC,CAAE,OAAqC;QACxC,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,iCAAiC,CAC/C,OAA8B,EAC9B,eAA8C;IAE9C,OAAO,qCAAqC,CAC1C,OAAO,EACP,OAAO,EACP,eAAe,CAChB,CAAC;AACJ,CAAC","sourcesContent":["import type { Provider, Signal } from './host/craft-compat';\nimport {\n  injectPrimitiveMethodRuntimeContext,\n  ɵprovidePrimitiveMethodRuntimeContext,\n  type PrimitiveMethodRuntimeContext,\n} from './primitive-method-runtime-context';\n\nexport type StateMethodRuntimeContext = PrimitiveMethodRuntimeContext<'state'>;\n\ntype StateInsertionContext = Readonly<{\n  state: Signal<unknown>;\n  set(value: unknown): unknown;\n  update(updater: (current: unknown) => unknown): unknown;\n  patch(updater: (current: unknown) => object): unknown;\n}>;\n\nexport function injectStateMethodRuntimeContext():\n  | StateMethodRuntimeContext\n  | undefined {\n  const context = injectPrimitiveMethodRuntimeContext();\n  return context?.kind === 'state'\n    ? (context as StateMethodRuntimeContext)\n    : undefined;\n}\n\nexport function ɵprovideStateMethodRuntimeContext(\n  context: StateInsertionContext,\n  originalFactory: (...args: never[]) => unknown,\n): Provider {\n  return ɵprovidePrimitiveMethodRuntimeContext(\n    'state',\n    context,\n    originalFactory,\n  );\n}\n"]}

package/src/lib/state.d.ts

@@ -0,0 +1,158 @@
+import { type Provider, Signal } from './host/craft-compat';
+import { type CraftSignal } from './host/craft-signal';
+import { InsertionsStateFactory } from './query.core';
+import { type CraftPrimitiveGen, type NamedPrimitive } from './craft-primitive-gen';
+import type { BrandedServiceProvider, MergeServiceDependencyMaps, SERVICE_HELPER_DEPENDENCIES, ServiceDependencyMapFromValues, ServiceDependencyMapFromYielded } from './craft-service';
+import { Source$ as SourceDollarType } from './source$';
+import { MergeObject } from './util/types/util.type';
+import { FilterSource, IsEmptyObject } from './util/util.type';
+import { type BrandReactiveProperties, type YieldableInsertionMethods } from './yieldable';
+import type { StandardSchemaV1InferInput, StandardSchemaV1InferOutput } from './standard-schema';
+import { type CraftSchema, type SchemaValidationPolicy } from './schema-validation';
+import type { AnyCraftException } from './craft-exception';
+import { DEEP_YIELDABLE_INSERTION, type DeepYieldableReaderOf, type YieldableReactiveValue } from './reactive-read';
+type Source$Method<SourceType> = [SourceType] extends [void] ? () => Generator<never, void, unknown> : (value: SourceType) => Generator<never, void, unknown>;
+export type ExposedStateInsertions<Insertions> = YieldableInsertionMethods<MergeObject<IsEmptyObject<Insertions> extends true ? {} : FilterSource<Insertions>, {
+    [K in keyof FilterSource<Insertions> as FilterSource<Insertions>[K] extends SourceDollarType<any> ? K : never]: FilterSource<Insertions>[K] extends SourceDollarType<infer SourceType> ? Source$Method<SourceType> : never;
+}>>;
+type StateReader<StateType, Insertions, Deep extends boolean = false, Name extends string = string> = Deep extends true ? DeepYieldableReaderOf<YieldableReactiveValue<StateType, Name>> : Insertions extends {
+    readonly [DEEP_YIELDABLE_INSERTION]: true;
+} ? DeepYieldableReaderOf<YieldableReactiveValue<StateType, Name>> : YieldableReactiveValue<StateType, Name>;
+export type StateOutput<StateType, Insertions, Dependencies = {}, HasSchema extends boolean = false, Deep extends boolean = false, Name extends string = string> = HasSchema extends true ? MergeObject<StateReader<StateType, Insertions, Deep, Name>, MergeObject<BrandReactiveProperties<ExposedStateInsertions<Insertions>>, {
+    readonly hasSchema: YieldableReactiveValue<true, 'hasSchema'>;
+    readonly hasException: YieldableReactiveValue<boolean, 'hasException'>;
+    readonly exceptions: YieldableReactiveValue<{
+        list: AnyCraftException[];
+        parse: {
+            state?: AnyCraftException;
+        };
+    }, 'exceptions'>;
+    readonly [SERVICE_HELPER_DEPENDENCIES]?: Dependencies;
+}>> : MergeObject<StateReader<StateType, Insertions, Deep, Name>, MergeObject<BrandReactiveProperties<ExposedStateInsertions<Insertions>>, {
+    readonly [SERVICE_HELPER_DEPENDENCIES]?: Dependencies;
+}>>;
+export type StateSchemaConfig<Schema extends CraftSchema> = {
+    readonly $self: StandardSchemaV1InferInput<Schema> | Signal<StandardSchemaV1InferInput<Schema>>;
+    readonly schema: Schema;
+    readonly providers?: readonly Provider[];
+    readonly schemaValidationPolicy?: SchemaValidationPolicy;
+};
+type ResolvedStateType<StateInput> = StateInput extends {
+    readonly $self: infer V;
+} ? ResolvedStateType<V> : StateInput extends Signal<infer State> ? State : StateInput extends CraftSignal<infer State> ? State : StateInput extends (...args: any[]) => Generator<any, infer Output, unknown> ? ResolvedStateType<Output> : StateInput;
+type StateConfigYielded<StateInput> = StateInput extends {
+    readonly $self: infer V;
+} ? StateConfigYielded<V> : StateInput extends (...args: any[]) => Generator<infer Yielded, any, unknown> ? Yielded : never;
+type StateInputProviderNames<StateInput> = StateInput extends {
+    readonly $self: any;
+    readonly providers: readonly (infer P)[];
+} ? P extends BrandedServiceProvider<infer Name, any, any> ? Name : never : never;
+type SatisfyDependencies<Deps, SatisfiedNames extends string> = {
+    [K in keyof Deps as K extends SatisfiedNames ? never : K]: Deps[K];
+};
+type StateTrackedDependencies<StateInput = never, InsertionsYielded = never, Insertions = never> = [StateInputProviderNames<StateInput>] extends [never] ? MergeServiceDependencyMaps<ServiceDependencyMapFromYielded<StateConfigYielded<StateInput> | InsertionsYielded>, ServiceDependencyMapFromValues<Insertions>> : SatisfyDependencies<MergeServiceDependencyMaps<ServiceDependencyMapFromYielded<StateConfigYielded<StateInput> | InsertionsYielded>, ServiceDependencyMapFromValues<Insertions>>, StateInputProviderNames<StateInput>>;
+/**
+ * Creates a signal state with an optional insertion for adding methods and computed properties.
+ *
+ * The `state` function allows you to create a Signal-based state that can be extended with custom
+ * methods and properties through an insertion. The insertion receives a context object with
+ * `state`, `set` and `update` methods. Compose several insertions with
+ * `insertStatePipe(insertion1, insertion2)`.
+ *
+ * @remarks
+ * For the best TypeScript inference, pass Angular `Signal` values (e.g. `signal`, `linkedSignal`)
+ * rather than manually widening to `WritableSignal`. This avoids some overload inference limits
+ * and keeps the public state read-only.
+ *
+ * @param name - The state name. Used for host tagging and reactive branding
+ * (`const counter = yield* state('counter', 0)`) and as the injector host
+ * tag (`state:counter`), so the state is precisely locatable in snapshots and logs.
+ * @param stateConfig - The initial state value or a Signal (e.g., linkedSignal)
+ * @param insertion1 - Optional single insertion factory to extend the state with methods and properties
+ * @returns A single-use primitive generator resolving to the state Signal
+ * merged with all insertion properties
+ * and methods. Consume it with `yield*`
+ * inside a generator host (craftService factory, craftGen, …) or with
+ * `craftUse(...)` elsewhere (typically a component field).
+ *
+ * @example
+ * // Simple state with a primitive value (component field)
+ * const counter = craftUse(state('counter', 0));
+ * console.log(counter()); // 0
+ *
+ * @example
+ * // Inside a craftService generator factory
+ * const { Counter } = craftService(
+ *   { name: 'Counter', providedIn: 'global' },
+ *   function* () {
+ *     const counter = yield* state('counter', 0);
+ *     return { counter };
+ *   },
+ * );
+ *
+ * @example
+ * // State with a computed
+ * const origin = signal(5);
+ * const doubled = craftUse(state('doubled', computed(() => origin() * 2)));
+ * console.log(doubled()); // 10
+ *
+ * @example
+ * // State with insertions to add methods (Method-based)
+ * const origin = signal(5);
+ * const counter = craftUse(state(
+ *   'counter',
+ *   computed(() => origin() * 2),
+ *   ({ update, set }) => ({
+ *     increment: () => update((current) => current + 1),
+ *     reset: () => set(0),
+ *   })
+ * ));
+ * console.log(counter()); // 10
+ * craftUse(counter.increment());
+ * console.log(counter()); // 11
+ * craftUse(counter.reset());
+ * console.log(counter()); // 0
+ *
+ * @example
+ * // State with multiple insertions, composed with insertStatePipe
+ * const origin = signal(5);
+ * const counterDouble = craftUse(state(
+ *   'counterDouble',
+ *   computed(() => origin() * 2),
+ *   insertStatePipe(
+ *       ({ update, set }) => ({
+ *         increment: () => update((current) => current + 1),
+ *         reset: () => set(0),
+ *       }),
+ *       ({ state }) => ({
+ *         isOdd: computed(() => state() % 2 === 1),
+ *       }),
+ *     ),
+ * ));
+ * console.log(counterDouble()); // 10
+ * console.log(counterDouble.isOdd()); // false
+ * craftUse(counterDouble.increment());
+ * console.log(counterDouble()); // 11
+ * console.log(counterDouble.isOdd()); // true
+ *
+ * @example
+ * // State with source binding (Event-based)
+ * const increment = source$<void>('increment');
+ * const reset = source$<void>('reset');
+ * const myState = craftUse(state('myState', 0, ({ update, set }) => ({
+ *   setValue: on$(increment, () => update(value => value + 1)),
+ *   reset: () => on$(reset, () => set(0)),
+ * })));
+ * console.log(myState()); // 0
+ * // Note: setValue is not exposed on myState, only used internally
+ * increment.emit();
+ * console.log(myState()); // 34
+ * reset.emit();
+ * console.log(myState()); // 0
+ */
+export declare function state<StateInput>(stateConfig: StateInput): CraftPrimitiveGen<StateOutput<ResolvedStateType<StateInput>, {}, StateTrackedDependencies<StateInput>>>;
+export declare function state<Name extends string, Schema extends CraftSchema>(name: Name, stateConfig: StateSchemaConfig<Schema>): CraftPrimitiveGen<NamedPrimitive<Name, StateOutput<StandardSchemaV1InferOutput<Schema>, {}, {}, true, false, Name>>>;
+export declare function state<Name extends string, StateInput>(name: Name, stateConfig: StateInput): CraftPrimitiveGen<NamedPrimitive<Name, StateOutput<ResolvedStateType<StateInput>, {}, StateTrackedDependencies<StateInput>, false, false, Name>>>;
+export declare function state<Name extends string, StateInput, Insertion1, Insertion1Yielded = never>(name: Name, stateConfig: StateInput, insertion1: InsertionsStateFactory<NoInfer<ResolvedStateType<StateInput>>, Insertion1, {}, Insertion1Yielded>): CraftPrimitiveGen<NamedPrimitive<Name, StateOutput<ResolvedStateType<StateInput>, Insertion1, StateTrackedDependencies<StateInput, Insertion1Yielded, Insertion1>, false, false, Name>>>;
+export {};
+//# sourceMappingURL=state.d.ts.map

package/src/lib/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../libs/core/src/lib/state.ts"],"names":[],"mappings":"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"}

package/src/lib/state.js

@@ -0,0 +1,388 @@
+import { assertInInjectionContext, DestroyRef, inject, Injector, isSignal, isWritableSignal, linkedSignal, runInInjectionContext, } from './host/craft-compat';
+import { takeUntilDestroyed } from './host/craft-compat';
+const UNSET_ANGULAR_STATE = Symbol('unset-angular-state');
+import { craftComputed, craftLinkedSignal, craftSignal, isCraftSignal, } from './host/craft-signal';
+import { createNamedPrimitiveGen, createPrimitiveGen, } from './craft-primitive-gen';
+import { isGenerator, runCraftGenerator } from './craft-generator-runtime';
+import { injectFnWrapper } from './fn-wrapper';
+import { ɵcreateHostTaggedInjector, ɵHOST_TAG_LIST } from './craft-service';
+import { APP_SNAPSHOT_REGISTRY, INSERTION_SNAPSHOT_REGISTRY, InsertionSnapshotRegistry, triggerAndCollectInsertions, } from './take-app-snapshot';
+import { isSource } from './util/util';
+import { ɵprovideStateMethodRuntimeContext } from './state-method-runtime-context';
+import { ɵregisterCraftPrimitive } from './craft-primitive-registry';
+import { createYieldableInsertionMethod, isNonYieldableInsertionMethod, yieldableInvocation, } from './yieldable';
+import { decideSchemaValidation, parseSchema, useSchemaValidationPolicy, } from './schema-validation';
+import { createYieldableReactiveFacade, createYieldableReactiveValue, deepYieldable, hasDeepYieldableInsertion, DEEP_YIELDABLE_INSERTION, isYieldableReactiveValue, nameInsertedReactiveValue, } from './reactive-read';
+const createLinkedSignalWithOptions = craftLinkedSignal;
+const createCraftLinkedSignalWithOptions = linkedSignal;
+const STATE_INVALID_YIELD_ERROR_MESSAGE = 'state generators can only yield craftService dependencies or exposed dependency helpers.';
+const STATE_APP_START_ERROR_MESSAGE = 'state generators do not support onAppStart(...).';
+function isSource$(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'emit' in value &&
+        typeof value.emit === 'function' &&
+        'subscribe' in value &&
+        typeof value.subscribe === 'function');
+}
+function isGeneratorFunction(value) {
+    return (typeof value === 'function' &&
+        (value.constructor?.name === 'GeneratorFunction' ||
+            Object.prototype.toString.call(value) === '[object GeneratorFunction]'));
+}
+function executeStateFactory(factory, thisArg, getInjector, ...args) {
+    const injector = getInjector();
+    const wrappedFactory = runInInjectionContext(injector, () => injectFnWrapper()(factory));
+    const result = wrappedFactory.apply(thisArg, args);
+    if (!isGenerator(result)) {
+        return result;
+    }
+    return runInInjectionContext(injector, () => {
+        return runCraftGenerator({
+            iterator: result,
+            injector,
+            hostScope: 'function',
+            invalidYieldErrorMessage: STATE_INVALID_YIELD_ERROR_MESSAGE,
+            multipleAppStartErrorMessage: STATE_APP_START_ERROR_MESSAGE,
+            onAppStartNotSupportedErrorMessage: STATE_APP_START_ERROR_MESSAGE,
+        }).value;
+    });
+}
+export function state(nameOrStateConfig, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+stateConfig, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+...insertions
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    const isNamed = typeof nameOrStateConfig === 'string' && arguments.length >= 2;
+    const name = isNamed ? nameOrStateConfig : 'state';
+    const config = isNamed ? stateConfig : nameOrStateConfig;
+    const ref = createStateRef(name, config, ...(isNamed ? insertions : []));
+    return isNamed ? createNamedPrimitiveGen(name, ref) : createPrimitiveGen(ref);
+}
+function createStateRef(name, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+stateConfig, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+...insertions
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    const insertionSnapshotRegistry = new InsertionSnapshotRegistry();
+    const hasSelfConfig = typeof stateConfig === 'object' &&
+        stateConfig !== null &&
+        '$self' in stateConfig;
+    const extraProviders = hasSelfConfig ? (stateConfig.providers ?? []) : [];
+    const rawConfig = hasSelfConfig ? stateConfig.$self : stateConfig;
+    const schema = hasSelfConfig
+        ? stateConfig.schema
+        : undefined;
+    const localSchemaPolicy = hasSelfConfig
+        ? stateConfig.schemaValidationPolicy
+        : undefined;
+    let baseInjector;
+    try {
+        baseInjector = inject(Injector);
+    }
+    catch {
+        // A state can still be constructed outside an injection context when no
+        // generator/schema work needs the injector until it is read.
+    }
+    const getBaseInjector = () => (baseInjector ??= (() => {
+        assertInInjectionContext(state);
+        return inject(Injector);
+    })());
+    let injector;
+    const getInjector = () => {
+        injector ??= ɵcreateHostTaggedInjector(getBaseInjector(), `state:${name}`, [
+            {
+                provide: INSERTION_SNAPSHOT_REGISTRY,
+                useValue: insertionSnapshotRegistry,
+            },
+            ...extraProviders,
+        ]);
+        return injector;
+    };
+    const resolvedStateConfig = isGeneratorFunction(rawConfig)
+        ? executeStateFactory(rawConfig, undefined, getInjector)
+        : rawConfig;
+    const isSignalState = isCraftSignal(resolvedStateConfig) || isSignal(resolvedStateConfig);
+    const isAngularSignalState = isSignal(resolvedStateConfig) && !isCraftSignal(resolvedStateConfig);
+    const isCraftWritableState = isCraftSignal(resolvedStateConfig) &&
+        typeof Reflect.get(resolvedStateConfig, 'set') === 'function';
+    const readResolvedState = () => resolvedStateConfig();
+    const wrapAngularReadonlyState = () => {
+        const override = craftSignal(UNSET_ANGULAR_STATE);
+        const value = (() => {
+            const local = override();
+            return local === UNSET_ANGULAR_STATE
+                ? readResolvedState()
+                : local;
+        });
+        value.set = (next) => {
+            override.set(next);
+        };
+        value.update = (updateFn) => value.set(updateFn(value()));
+        value.asReadonly = () => value;
+        return value;
+    };
+    let lastValidState;
+    let latestStateException;
+    let skipInitialSourceValidation = isSignalState;
+    const applySchema = (value, operation) => {
+        if (!schema) {
+            return value;
+        }
+        if (operation === 'source' && skipInitialSourceValidation) {
+            skipInitialSourceValidation = false;
+            return lastValidState;
+        }
+        const parsed = parseSchema(schema, value, {
+            primitive: 'state',
+            name,
+            stage: 'state',
+            operation,
+        });
+        if (parsed instanceof Promise) {
+            // Signals are synchronous. Async Standard Schema implementations are
+            // supported by the resource primitives, but cannot safely publish a
+            // pending state value.
+            return lastValidState;
+        }
+        const decision = decideSchemaValidation(parsed, {
+            primitive: 'state',
+            name,
+            stage: 'state',
+            operation,
+        }, useSchemaValidationPolicy(getInjector(), localSchemaPolicy));
+        if (!decision.accepted) {
+            latestStateException = decision.exception;
+            return lastValidState;
+        }
+        latestStateException = undefined;
+        lastValidState = decision.value;
+        return lastValidState;
+    };
+    const initialStateValue = applySchema(isSignalState ? readResolvedState() : resolvedStateConfig, 'initial');
+    const stateSignal = !schema && isSignalState
+        ? isWritableSignal(resolvedStateConfig) || isCraftWritableState
+            ? resolvedStateConfig
+            : isAngularSignalState
+                ? wrapAngularReadonlyState()
+                : craftLinkedSignal({
+                    source: readResolvedState,
+                    computation: () => readResolvedState(),
+                })
+        : isSignalState
+            ? isAngularSignalState
+                ? createCraftLinkedSignalWithOptions({
+                    source: readResolvedState,
+                    computation: () => applySchema(readResolvedState(), 'source'),
+                    equal: () => false,
+                })
+                : createLinkedSignalWithOptions({
+                    source: readResolvedState,
+                    computation: () => applySchema(readResolvedState(), 'source'),
+                    equal: () => false,
+                })
+            : craftSignal(initialStateValue);
+    const readonlyStateSignal = isAngularSignalState &&
+        !(isWritableSignal(resolvedStateConfig) || isCraftWritableState)
+        ? stateSignal
+        : isCraftSignal(stateSignal)
+            ? craftComputed(() => stateSignal())
+            : 'asReadonly' in stateSignal &&
+                typeof stateSignal.asReadonly ===
+                    'function'
+                ? stateSignal.asReadonly()
+                : stateSignal;
+    const publicStateReader = createYieldableReactiveValue(readonlyStateSignal, name, { primitive: 'state', path: name });
+    const originalSet = stateSignal.set.bind(stateSignal);
+    const setState = (newState) => {
+        if (!schema) {
+            originalSet(newState);
+            return newState;
+        }
+        const next = applySchema(newState, 'set');
+        if (!latestStateException) {
+            originalSet(next);
+        }
+        return next;
+    };
+    const updateState = (updateFn) => {
+        if (!schema) {
+            const next = updateFn(stateSignal());
+            originalSet(next);
+            return next;
+        }
+        const next = applySchema(updateFn(stateSignal()), 'update');
+        if (!latestStateException) {
+            originalSet(next);
+        }
+        return next;
+    };
+    if (schema) {
+        stateSignal.set = setState;
+        stateSignal.update = updateState;
+    }
+    const insertionsOutput = insertions.reduce((acc, insert) => {
+        const insertionContext = {
+            state: publicStateReader,
+            set: (newState) => yieldableInvocation(setState(newState)),
+            update: (updateFn) => yieldableInvocation(updateState(updateFn)),
+            patch: (patchFn) => yieldableInvocation(updateState((current) => ({
+                ...current,
+                ...patchFn(current),
+            }))),
+            insertions: Object.entries(acc.rawInsertionsOutput).reduce((previous, [key, value]) => {
+                if (isSource$(value))
+                    previous[key] = value;
+                return previous;
+            }, { ...acc.exposedInsertionsOutput }),
+        };
+        const nextRawInsertions = executeStateFactory(insert, undefined, getBaseInjector, insertionContext);
+        const nextExposedInsertions = Object.entries(nextRawInsertions).reduce((exposedAcc, [key, value]) => {
+            if (isSource(value)) {
+                return exposedAcc;
+            }
+            if (isSource$(value)) {
+                const localSource = value;
+                const sourceInjector = ɵcreateHostTaggedInjector(getInjector(), `source:${key}`);
+                const wrappedEmit = runInInjectionContext(sourceInjector, () => injectFnWrapper()((payload) => localSource.emit(payload)));
+                exposedAcc[key] = createYieldableInsertionMethod((payload) => wrappedEmit(payload), {
+                    injector: sourceInjector,
+                    invalidYieldErrorMessage: STATE_INVALID_YIELD_ERROR_MESSAGE,
+                    multipleAppStartErrorMessage: STATE_APP_START_ERROR_MESSAGE,
+                    onAppStartNotSupportedErrorMessage: STATE_APP_START_ERROR_MESSAGE,
+                });
+                return exposedAcc;
+            }
+            if (isYieldableReactiveValue(value)) {
+                exposedAcc[key] = nameInsertedReactiveValue(value, key, 'state', `${name}.${key}`);
+                return exposedAcc;
+            }
+            if (typeof value === 'function' &&
+                !isCraftSignal(value) &&
+                !isSignal(value) &&
+                !isYieldableReactiveValue(value) &&
+                !isNonYieldableInsertionMethod(value)) {
+                const methodInjector = ɵcreateHostTaggedInjector(getInjector(), `method:${key}`, [
+                    ɵprovideStateMethodRuntimeContext(insertionContext, value),
+                ]);
+                const wrappedFn = runInInjectionContext(methodInjector, () => injectFnWrapper()(value));
+                exposedAcc[key] = createYieldableInsertionMethod(wrappedFn, {
+                    injector: methodInjector,
+                    invalidYieldErrorMessage: STATE_INVALID_YIELD_ERROR_MESSAGE,
+                    multipleAppStartErrorMessage: STATE_APP_START_ERROR_MESSAGE,
+                    onAppStartNotSupportedErrorMessage: STATE_APP_START_ERROR_MESSAGE,
+                });
+            }
+            else {
+                exposedAcc[key] = value;
+            }
+            return exposedAcc;
+        }, {});
+        return {
+            rawInsertionsOutput: {
+                ...acc.rawInsertionsOutput,
+                ...nextRawInsertions,
+            },
+            exposedInsertionsOutput: {
+                ...acc.exposedInsertionsOutput,
+                ...nextExposedInsertions,
+            },
+        };
+    }, {
+        rawInsertionsOutput: {},
+        exposedInsertionsOutput: {},
+    });
+    const stateOutput = Object.assign(readonlyStateSignal, insertionsOutput.exposedInsertionsOutput, {
+        hasSchema: craftSignal(schema !== undefined),
+        exceptions: craftComputed(() => {
+            // Keep the exception signal reactive when a derived source changes.
+            stateSignal();
+            const parse = latestStateException
+                ? { state: latestStateException }
+                : {};
+            return { list: Object.values(parse), parse };
+        }),
+        hasException: craftComputed(() => {
+            stateSignal();
+            return latestStateException !== undefined;
+        }),
+    });
+    const snapshotRegistry = injector
+        ? injector.get(APP_SNAPSHOT_REGISTRY, null)
+        : (() => {
+            try {
+                return inject(APP_SNAPSHOT_REGISTRY, { optional: true });
+            }
+            catch {
+                return null;
+            }
+        })();
+    const hostTagList = injector
+        ? (injector.get(ɵHOST_TAG_LIST, null) ?? [])
+        : (() => {
+            try {
+                return inject(ɵHOST_TAG_LIST, { optional: true }) ?? [];
+            }
+            catch {
+                return [];
+            }
+        })();
+    const destroyRef = injector
+        ? injector.get(DestroyRef, null)
+        : (() => {
+            try {
+                return inject(DestroyRef, { optional: true });
+            }
+            catch {
+                return null;
+            }
+        })();
+    // Addressable handle for tooling: read and write this very instance by name.
+    const registration = ɵregisterCraftPrimitive({
+        kind: 'state',
+        name,
+        read: () => stateSignal(),
+        write: (value) => setState(value),
+        ...(injector ? { injector } : {}),
+    });
+    if (snapshotRegistry && destroyRef) {
+        snapshotRegistry.triggerSnapshot$
+            .pipe(takeUntilDestroyed(destroyRef))
+            .subscribe(() => {
+            const insertionSnapshots = triggerAndCollectInsertions(insertionSnapshotRegistry);
+            let stateSnapshot;
+            try {
+                stateSnapshot = {
+                    value: stateSignal(),
+                    ...(insertionSnapshots ? { insertions: insertionSnapshots } : {}),
+                };
+            }
+            catch (error) {
+                stateSnapshot = {
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+            snapshotRegistry.allSnapShot$.next({
+                source: 'state',
+                from: hostTagList,
+                state: stateSnapshot,
+            });
+        });
+    }
+    const publicState = createYieldableReactiveFacade(stateOutput, {
+        name,
+        primitive: 'state',
+        path: name,
+    });
+    // The ref the application holds is what a feature names when it has to
+    // capture a primitive declared outside its own host.
+    registration.link(publicState);
+    return hasDeepYieldableInsertion(insertions)
+        ? deepYieldable(publicState)
+        : publicState;
+}
+//# sourceMappingURL=state.js.map