@picked/client 0.0.1-dev.1789541668638 → 0.0.1-next.1

package/dist/types/entities/content/content.d.ts

@@ -1,53 +0,0 @@
-/** @file Content entity — Effector stores, types, and lifecycle helpers for CMS content records. */
-import { type Store } from 'effector';
-export interface Content {
-    id: string;
-    /**
-     * The `key` of the Content Model that produced this entry. Optional because
-     * non-wire producers may omit it; wire blobs always carry it (or `null`).
-     */
-    contentModelKey?: string | null;
-    data: Record<string, unknown>;
-}
-/**
- * Transforms a content record's `data`, returning the next blob.
- *
- * Applied inside the store's own update so the read-modify-write cannot interleave with another
- * write. Callers that want path-addressed ops build one of these with `applyContentOps` from
- * `@picked/client/preview`, which is code-split away from the main bundle because only the
- * live-preview channel needs it.
- */
-export type ContentDataPatch = (data: Record<string, unknown>) => Record<string, unknown>;
-export type ContentsStore = ReturnType<typeof createContentIndex>;
-declare const createContentIndexFactory: () => {
-    register: (content: Content) => void;
-    patch: (id: string, apply: ContentDataPatch) => void;
-    getById: (id: Content['id']) => Store<Content | null>;
-    listStore: Store<Content[]>;
-    indexStore: import("effector").StoreWritable<{
-        [id: string]: Content;
-    }>;
-};
-/**
- * Creates an Effector-based index for registering and retrieving content records.
- *
- * @returns {ContentsStore} A content index with register, getById, and listStore.
- * @example
- * ```typescript
- * const contents = createContentIndex()
- * ```
- */
-export declare function createContentIndex(): ReturnType<typeof createContentIndexFactory>;
-/**
- * Registers a content record with the given index via the helper function.
- *
- * @param {Content} content - The content record to register.
- * @param {ContentsStore} index - The content index to register the record with.
- * @example
- * ```typescript
- * setupContent(content, index)
- * ```
- */
-export declare function setupContent(content: Content, index: ContentsStore): void;
-export {};
-//# sourceMappingURL=content.d.ts.map

package/dist/types/entities/content/content.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../../src/entities/content/content.ts"],"names":[],"mappings":"AAAA,oGAAoG;AACpG,OAAO,EAA2B,KAAK,KAAK,EAAE,MAAM,UAAU,CAAA;AAK9D,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAA;IACV;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC9B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEzF,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEjE,QAAA,MAAM,yBAAyB;wBAiCF,OAAO,KAAG,IAAI;gBAkBtB,MAAM,SAAS,gBAAgB,KAAG,IAAI;kBAmBpC,OAAO,CAAC,IAAI,CAAC,KAAG,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC;;;;;CAW1D,CAAA;AAEF;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,IAAI,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAEjF;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,aAAa,GAAG,IAAI,CAEzE"}

package/dist/types/entities/content/reference.d.ts

@@ -1,101 +0,0 @@
-/**
- * @file Reading `reference` field values out of a delivered content blob.
- *
- * A `reference` field arrives as a pointer at another Content record rather than
- * as the record itself. The referenced record travels separately and is
- * registered into the content index under its own id, so resolving a pointer is
- * a registry lookup — see `useReference` (`@picked/react`) and `getReference`
- * (`@picked/svelte`), which is what most consumers should reach for.
- *
- * This module is the framework-agnostic half: readers that turn a raw field
- * value into the id (or ids) to look up, tolerating both a single value and the
- * array a repeatable field delivers, plus the store derivations the framework
- * bindings wrap.
- */
-import { type Store } from 'effector';
-import type { Content, ContentsStore } from './content';
-/** A pointer at another Content record, as delivered inside a `reference` field. */
-export interface ContentReference {
-    /** Id of the referenced Content record, to look up in the content index. */
-    contentEntryId: string;
-    /** The `key` of the Content Model the target belongs to, or `null` when unresolved. */
-    contentModelKey?: string | null;
-}
-/**
- * Narrows an arbitrary field value to a {@link ContentReference}.
- *
- * A pointer that still carries inline `data` matches: the delivery surface emits
- * inline data alongside the separate record while that format is retired, and
- * both shapes address the same record.
- *
- * @param {unknown} value - The raw value read from a content blob's `data`.
- * @returns {boolean} Whether `value` is a reference pointer.
- * @example
- * ```typescript
- * if (isContentReference(content.author)) { content.author.contentEntryId }
- * ```
- */
-export declare function isContentReference(value: unknown): value is ContentReference;
-/**
- * Reads the referenced Content record id from a single `reference` field value.
- *
- * @param {unknown} value - The raw value read from a content blob's `data`.
- * @returns {string | null} The referenced id, or `null` when the field is unset or not a reference.
- * @example
- * ```typescript
- * const authorId = readReferenceId(content.author)
- * ```
- */
-export declare function readReferenceId(value: unknown): string | null;
-/**
- * Reads every referenced Content record id from a `reference` field, whether it
- * was authored as repeatable or not. Values that are not references are dropped,
- * so the result is always a list of ids that can be looked up.
- *
- * @param {unknown} value - The raw value read from a content blob's `data`.
- * @returns {string[]} The referenced ids, in field order.
- * @example
- * ```typescript
- * const authorIds = readReferenceIds(content.authors)
- * ```
- */
-export declare function readReferenceIds(value: unknown): string[];
-/**
- * Derives a store resolving a single `reference` field value against the content
- * registry.
- *
- * Reads the registry index rather than a per-id store so an unset field, an
- * unregistered target, and a target registered after first paint all flow
- * through one reactive path. The framework bindings (`useReference`,
- * `getReference`) wrap this; call it directly only outside React and Svelte.
- *
- * @param {ContentsStore} contents - The client's content registry.
- * @param {unknown} value - The raw `reference` value, or an Effector store carrying one. A
- *   store keeps the lookup live when the field arrives after this call.
- * @returns {Store<Content | null>} The referenced record, or `null` when the field is unset or its target is not registered.
- * @example
- * ```typescript
- * const author = deriveReference(client.contents, content.author)
- * ```
- */
-export declare function deriveReference(contents: ContentsStore, value: unknown): Store<Content | null>;
-/**
- * Derives a store resolving a repeatable `reference` field against the content
- * registry, in field order. A single (non-repeatable) value resolves to a
- * one-element list.
- *
- * The list is dense: a pointer whose target is not registered — deleted, cut off
- * by the reference depth cap, or belonging to another workspace — is skipped
- * rather than held as a hole, so consumers can iterate without a null check.
- *
- * @param {ContentsStore} contents - The client's content registry.
- * @param {unknown} value - The raw `reference` value, or an Effector store carrying one. A
- *   store keeps the lookup live when the field arrives after this call.
- * @returns {Store<Content[]>} The referenced records that resolved.
- * @example
- * ```typescript
- * const authors = deriveReferences(client.contents, content.authors)
- * ```
- */
-export declare function deriveReferences(contents: ContentsStore, value: unknown): Store<Content[]>;
-//# sourceMappingURL=reference.d.ts.map

package/dist/types/entities/content/reference.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../../src/entities/content/reference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,UAAU,CAAA;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEvD,oFAAoF;AACpF,MAAM,WAAW,gBAAgB;IAC/B,4EAA4E;IAC5E,cAAc,EAAE,MAAM,CAAA;IACtB,uFAAuF;IACvF,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAChC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAQ5E;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAE7D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAUzD;AAiCD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,CAS9F;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC,CAS1F"}

package/dist/types/entities/field/policies.d.ts

@@ -1,35 +0,0 @@
-/** @file Field privacy policies — the policy shape and the normalisation applied at registration. */
-/**
- * Privacy policies governing what leaves the page. Both are opt-in, and neither affects
- * the in-memory response store.
- */
-export interface FieldPolicies {
-    /** Sends the captured value to analytics. */
-    trackValue?: boolean;
-    /** Persists the captured value in browser storage. */
-    storeValue?: boolean;
-    /**
-     * @deprecated Use `trackValue`. `doNotTrackValue: false` will be removed in a future version.
-     */
-    doNotTrackValue?: boolean;
-    /**
-     * @deprecated Use `storeValue`. `doNotStoreValue: false` will be removed in a future version.
-     */
-    doNotStoreValue?: boolean;
-}
-/**
- * Resolves the policies a field states into all four flags, so every reader downstream
- * consults `trackValue` and `storeValue` alone. The positive flag decides whenever the
- * field states it; otherwise the deprecated flag grants capture at an explicit `false`.
- * An absent `policies` object and an absent flag both withhold the value.
- *
- * @param {FieldPolicies | undefined} policies - The policies as the field states them.
- * @returns {Required<FieldPolicies>} All four flags, each deprecated flag the inverse of its replacement.
- * @example
- * ```typescript
- * normaliseFieldPolicies({ doNotTrackValue: false })
- * // { trackValue: true, storeValue: false, doNotTrackValue: false, doNotStoreValue: true }
- * ```
- */
-export declare function normaliseFieldPolicies(policies?: FieldPolicies): Required<FieldPolicies>;
-//# sourceMappingURL=policies.d.ts.map

package/dist/types/entities/field/policies.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"policies.d.ts","sourceRoot":"","sources":["../../../../src/entities/field/policies.ts"],"names":[],"mappings":"AAAA,qGAAqG;AAErG;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,6CAA6C;IAC7C,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,sDAAsD;IACtD,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B;AAQD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,CAAC,EAAE,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAC,CAWxF"}

package/dist/types/entities/response/response-validation.d.ts

@@ -1,75 +0,0 @@
-/** @file Validation utilities for response values — type checks, coercion, and field-level validation. */
-import type { Field, FieldValue } from '../field/field';
-import type { LogicObject, LogicRule } from '../../logic-engine';
-export interface ValidationError {
-    fieldKey: Field['key'];
-    userMessage: string;
-    systemMessage: string;
-    value: FieldValue;
-}
-/** Callback signature for evaluating rule-based validation logic. */
-type RuleEvaluator = (logic: LogicRule, context?: LogicObject) => Promise<unknown>;
-/**
- * Resolves a field from an array by id or key.
- *
- * @param {string} inputKey - The field id or key to look up.
- * @param {Field[]} allFields - All registered fields.
- * @returns {Field | null} The matching field, or null if not found.
- * @example
- * ```typescript
- * resolveField('email', allFields) // Field | null
- * ```
- */
-export declare function resolveField(inputKey: string, allFields: Field[]): Field | null;
-/**
- * Coerces a scalar value into a single-element array when the field expects multiple values.
- *
- * @param {Field} field - The field definition.
- * @param {FieldValue} value - The response value to coerce.
- * @returns {FieldValue} The original or coerced value.
- * @example
- * ```typescript
- * coerceToArray(multipleField, 'hello') // ['hello']
- * ```
- */
-export declare function coerceToArray(field: Field, value: FieldValue): FieldValue;
-/**
- * Validates that an object field value has the correct shape and is JSON-serializable.
- *
- * @param {Field} field - The field definition.
- * @param {FieldValue} value - The response value to validate.
- * @returns {ValidationError | null} A validation error if the value is invalid, or null if valid.
- * @example
- * ```typescript
- * getObjectValueError(objectField, { key: 'val' }) // null
- * ```
- */
-export declare function getObjectValueError(field: Field, value: FieldValue): ValidationError | null;
-/**
- * Validates that a response value matches one of the field's allowed options.
- *
- * @param {Field} field - The field definition with options.
- * @param {FieldValue} value - The response value to validate.
- * @returns {ValidationError | null} A validation error if the value is not a valid option, or null if valid.
- * @example
- * ```typescript
- * getOptionsError(fieldWithOptions, 'valid-option') // null
- * ```
- */
-export declare function getOptionsError(field: Field, value: FieldValue): ValidationError | null;
-/**
- * Runs field-level validation including rule-based validation, required checks, and multiplicity checks.
- *
- * @param {RuleEvaluator} evaluateRule - Callback to evaluate rule-based validation logic.
- * @param {Field} field - The field definition.
- * @param {FieldValue} value - The response value to validate.
- * @param {Record<string, FieldValue>} [responses] - All current responses for cross-field validation.
- * @returns {Promise<ValidationError | null>} A validation error if the field fails validation, or null if valid.
- * @example
- * ```typescript
- * await getFieldValidationError(evaluate, field, 'hello') // null
- * ```
- */
-export declare function getFieldValidationError(evaluateRule: RuleEvaluator, field: Field, value: FieldValue, responses?: Record<string, FieldValue>): Promise<ValidationError | null>;
-export {};
-//# sourceMappingURL=response-validation.d.ts.map

package/dist/types/entities/response/response-validation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"response-validation.d.ts","sourceRoot":"","sources":["../../../../src/entities/response/response-validation.ts"],"names":[],"mappings":"AAAA,0GAA0G;AAC1G,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAuB,MAAM,gBAAgB,CAAA;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAGhE,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;IACtB,WAAW,EAAE,MAAM,CAAA;IACnB,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,UAAU,CAAA;CAClB;AAED,qEAAqE;AACrE,KAAK,aAAa,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AA+ElF;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,KAAK,GAAG,IAAI,CAE/E;AAED;;;;;;;;;;GAUG;AAEH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,GAAG,UAAU,CASzE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,GAAG,eAAe,GAAG,IAAI,CAgE3F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,GAAG,eAAe,GAAG,IAAI,CAuCvF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,uBAAuB,CAC3C,YAAY,EAAE,aAAa,EAC3B,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,UAAU,EACjB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GACrC,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAsCjC"}

package/dist/types/entities/session/session.d.ts

@@ -1,46 +0,0 @@
-/** @file Session entity — single Effector store for the visitor session (id, isUser flag, identifiers) plus mutator events generated via `createApi`. Persists to localStorage when available. */
-import { type EventCallable, type Store } from 'effector';
-/** Plain shape of a persisted session — id, optional isUser flag, optional identifiers map. */
-export interface Session {
-    id: string;
-    isUser?: boolean;
-    identifiers?: Record<string, string>;
-}
-/**
- * Session entity exposing the reactive `Session` store and mutator events. Field reads
- * derive from the store via `.map`, which is reference-equality memoised so per-field
- * subscribers only re-emit when their slice actually changes.
- *
- * @example
- * ```typescript
- * const session = createSession()
- * session.store.map((s) => s.id).watch((id) => console.log('Session id:', id))
- * session.setIsUser(true)
- * session.setIdentifier({ key: 'fp_id', value: 'abc' })
- * ```
- */
-export interface SessionEntity {
-    /** Reactive store of the full session. Hydrated synchronously from localStorage when available; otherwise minted fresh in memory. */
-    store: Store<Session>;
-    /** Event — sets the isUser flag. */
-    setIsUser: EventCallable<boolean>;
-    /** Event — adds or replaces an identifier in the identifiers map. */
-    setIdentifier: EventCallable<{
-        key: string;
-        value: string;
-    }>;
-    /** Event — removes an identifier from the identifiers map. */
-    removeIdentifier: EventCallable<string>;
-}
-/**
- * Initialises a session entity. Always succeeds — persistence is gated internally on `supportsLocalStorage()`, so callers do not need to null-check the result.
- *
- * @returns {SessionEntity} A ready-to-use session entity.
- * @example
- * ```typescript
- * const session = initialiseSession()
- * console.log(session.store.getState().id)
- * ```
- */
-export declare function initialiseSession(): SessionEntity;
-//# sourceMappingURL=session.d.ts.map

package/dist/types/entities/session/session.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../src/entities/session/session.ts"],"names":[],"mappings":"AAAA,kMAAkM;AAClM,OAAO,EAAkC,KAAK,aAAa,EAAU,KAAK,KAAK,EAAE,MAAM,UAAU,CAAA;AAKjG,+FAA+F;AAC/F,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACrC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,aAAa;IAC5B,qIAAqI;IACrI,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAA;IAErB,oCAAoC;IACpC,SAAS,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;IACjC,qEAAqE;IACrE,aAAa,EAAE,aAAa,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC5D,8DAA8D;IAC9D,gBAAgB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CACxC;AA+GD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,IAAI,aAAa,CAEjD"}

package/dist/types/entities/step/step.d.ts

@@ -1,56 +0,0 @@
-/** @file Step entity — Effector stores, types, and lifecycle helpers for experience steps. */
-import { type Store } from 'effector';
-import type { Content } from '../content/content';
-export type StepsStore = ReturnType<typeof createStepIndex>;
-export interface ExperienceStep {
-    id: string;
-    key: string;
-    name: string;
-    fieldKeys: string[];
-    layoutName?: string | null;
-    /**
-     * Optional reference to a CMS Content record that supplies the step's layout data.
-     * The actual content is registered separately via `client.registerContent` and
-     * resolved at render time through `layoutContentStore` against the global content registry.
-     */
-    layoutContentId?: string | null;
-    /**
-     * Reactive store of the content record this step references. Composed at registration
-     * time against `client.contents.getById(layoutContentId)`. `null` when the step has no
-     * `layoutContentId`. Reads stay reactive — content registered after the step
-     * (or updated mid-session) flows through automatically.
-     */
-    layoutContentStore?: Store<Content | null> | null;
-}
-declare const createStepIndexFactory: () => {
-    register: (step: ExperienceStep) => void;
-    getById: (id: ExperienceStep['id']) => Store<ExperienceStep | null>;
-    getByKey: (key: ExperienceStep['key']) => Store<ExperienceStep | null>;
-    listStore: Store<ExperienceStep[]>;
-    indexStore: import("effector").StoreWritable<{
-        [id: string]: ExperienceStep;
-    }>;
-};
-/**
- * Creates an Effector-based index for registering and retrieving steps.
- *
- * @returns {ReturnType<typeof createStepIndexFactory>} A step index with register, getById, getByKey, listStore, and indexStore.
- * @example
- * ```typescript
- * const steps = createStepIndex()
- * ```
- */
-export declare function createStepIndex(): ReturnType<typeof createStepIndexFactory>;
-/**
- * Registers a step with the given index via the helper function.
- *
- * @param {ExperienceStep} step - The step definition to register.
- * @param {ReturnType<typeof createStepIndex>} index - The step index to register the step with.
- * @example
- * ```typescript
- * setupStep(step, index)
- * ```
- */
-export declare function setupStep(step: ExperienceStep, index: ReturnType<typeof createStepIndex>): void;
-export {};
-//# sourceMappingURL=step.d.ts.map

package/dist/types/entities/step/step.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../../../src/entities/step/step.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,OAAO,EAA2B,KAAK,KAAK,EAAE,MAAM,UAAU,CAAA;AAE9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAEjD,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAA;AAI3D,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,IAAI,CAAA;CAClD;AAED,QAAA,MAAM,sBAAsB;qBAuBF,cAAc,KAAG,IAAI;kBAkBxB,cAAc,CAAC,IAAI,CAAC,KAAG,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC;oBAcjD,cAAc,CAAC,KAAK,CAAC,KAAG,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC;;;;;CAa3E,CAAA;AAEF;;;;;;;;GAQG;AACH,wBAAgB,eAAe,IAAI,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAE3E;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,GAAG,IAAI,CAE/F"}

package/dist/types/form/build-responses.d.ts

@@ -1,18 +0,0 @@
-/** @file Parses FormData snapshots into typed field-response records keyed by field key. */
-import type { FieldBase, FieldValue } from '../entities/field/field';
-/**
- * Parses a FormData snapshot into a typed record of field responses keyed by field key. Fields
- * absent from FormData are mapped to `null`. Empty string values are mapped to `null`. Repeated
- * entries for the same field (such as multi-select checkboxes) are merged into a typed array
- * matching the field's declared element type. Values are coerced to the field's declared type.
- *
- * @param fields - The field definitions to parse against.
- * @param formData - The FormData snapshot to parse.
- * @returns A record of field keys to their parsed values.
- * @example
- * ```typescript
- * buildResponsesFromFormData([field], new FormData(formElement))
- * ```
- */
-export declare function buildResponsesFromFormData(fields: FieldBase[], formData: FormData): Record<string, FieldValue>;
-//# sourceMappingURL=build-responses.d.ts.map

package/dist/types/form/build-responses.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-responses.d.ts","sourceRoot":"","sources":["../../../src/form/build-responses.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAwCpE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EAAE,EACnB,QAAQ,EAAE,QAAQ,GACjB,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAsC5B"}

package/dist/types/form/create-field-evaluator.d.ts

@@ -1,28 +0,0 @@
-/** @file Reactive field evaluator — filters and re-evaluates fields when responses or step context change. */
-import { type Store, type StoreWritable } from 'effector';
-import type { Field, FieldValue } from '../entities/field/field';
-import type { Picked } from '../picked';
-/**
- * Creates a reactive store of evaluated fields for a given set of field keys.
- *
- * Fields are re-evaluated whenever:
- * - The available field keys change (e.g. A step is entered)
- * - Any response is committed (options may depend on prior answers)
- * - The global field registry changes (fields registered after init)
- * - Staged values change (field visibility conditions may reference responses.*).
- *
- * Evaluation runs `getStepFields` with effective responses (committed + staged) as context,
- * so visibility conditions see live in-session values rather than only committed responses.
- *
- * @param client - The Picked client instance.
- * @param fieldKeys - Store of field keys to evaluate.
- * @param stagedValuesStore - Store of in-progress field values not yet committed.
- * @example
- * ```typescript
- * const { fieldsStore } = createFieldEvaluator(client, fieldKeysStore, stagedStore)
- * ```
- */
-export declare function createFieldEvaluator(client: Picked, fieldKeys: Store<string[]>, stagedValuesStore: StoreWritable<Record<string, FieldValue>>): {
-    fieldsStore: Store<Field[]>;
-};
-//# sourceMappingURL=create-field-evaluator.d.ts.map

package/dist/types/form/create-field-evaluator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-field-evaluator.d.ts","sourceRoot":"","sources":["../../../src/form/create-field-evaluator.ts"],"names":[],"mappings":"AAAA,8GAA8G;AAC9G,OAAO,EAA6C,KAAK,KAAK,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AACpG,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAGvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,EAC1B,iBAAiB,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,GAC3D;IAAE,WAAW,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CA8CjC"}

package/dist/types/form/create-field-validation.d.ts

@@ -1,60 +0,0 @@
-/** @file Creates the client-side field validation slice (touched tracking, error stores, staged values). */
-import { type EventCallable, type Store, type StoreWritable } from 'effector';
-import type { Field, FieldValue } from '../entities/field/field';
-import type { ValidationError } from '../entities/response/response';
-import type { Picked } from '../picked';
-export interface FieldValidation {
-    /** Dispatch on keyboard input — updates staged values and runs validation if the field has been touched. */
-    fieldInputEvent: EventCallable<{
-        fieldKey: string;
-        value: FieldValue;
-    }>;
-    /** Dispatch when a field value is committed (onchange) — updates staged values and runs validation if the field has been touched. */
-    fieldChangeEvent: EventCallable<{
-        fieldKey: string;
-        value: FieldValue;
-    }>;
-    /** Dispatch when a field loses focus — always runs full validation including required check. */
-    fieldBlurEvent: EventCallable<{
-        fieldKey: string;
-        value: FieldValue;
-    }>;
-    /** Which fields have been interacted with — used by formFieldsStore to show/hide errors. */
-    touchedStore: StoreWritable<Partial<Record<string, boolean>>>;
-    /**
-     * Per-field validation errors — written by client-side validation and overwritten
-     * by server errors on commit failure. Exposed as writable so the submit pipeline
-     * can populate server errors and reset state on new submit attempts.
-     */
-    fieldErrorsStore: StoreWritable<Partial<Record<string, ValidationError>>>;
-    /** Flat list of all current validation errors — derived from fieldErrorsStore. */
-    formErrorsStore: Store<ValidationError[]>;
-    /**
-     * Current in-session field values — updated on every onChange/onBlur before commit.
-     * Used as the responses context for condition evaluation so conditions react to
-     * live input without writing to client.responses prematurely.
-     */
-    stagedValuesStore: StoreWritable<Record<string, FieldValue>>;
-}
-/**
- * Creates the client-side validation slice for a form.
- *
- * Responsibilities:
- * - Tracks which fields have been touched (first blur = touched).
- * - Validates on blur (full: includes required check) and on change (if already touched).
- * - Uses the same json-logic evaluator the server uses, so client and server results match.
- * - Maintains stagedValuesStore: current in-session values used as responses context for
- *   condition evaluation, avoiding premature writes to client.responses.
- *
- * @param {Picked} client - The Picked client instance providing responses and field registry.
- * @param {Store<Field[]>} fieldsStore - Reactive store of the current field definitions.
- * @param {StoreWritable<Record<string, FieldValue>>} stagedValuesStore - Writable store of in-session field values.
- * @returns {FieldValidation} The validation slice containing events, stores, and wiring.
- * @example
- * ```ts
- * const validation = createFieldValidation(client, fieldsStore, stagedValuesStore)
- * validation.fieldInputEvent({ fieldKey: 'email', value: 'hi' })
- * ```
- */
-export declare function createFieldValidation(client: Picked, fieldsStore: Store<Field[]>, stagedValuesStore: StoreWritable<Record<string, FieldValue>>): FieldValidation;
-//# sourceMappingURL=create-field-validation.d.ts.map

package/dist/types/form/create-field-validation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-field-validation.d.ts","sourceRoot":"","sources":["../../../src/form/create-field-validation.ts"],"names":[],"mappings":"AAAA,4GAA4G;AAC5G,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,KAAK,EACV,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AACpE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAkBvC,MAAM,WAAW,eAAe;IAC9B,4GAA4G;IAC5G,eAAe,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,UAAU,CAAA;KAAE,CAAC,CAAA;IACvE,qIAAqI;IACrI,gBAAgB,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,UAAU,CAAA;KAAE,CAAC,CAAA;IACxE,gGAAgG;IAChG,cAAc,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,UAAU,CAAA;KAAE,CAAC,CAAA;IACtE,4FAA4F;IAC5F,YAAY,EAAE,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;IAC7D;;;;OAIG;IACH,gBAAgB,EAAE,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,CAAA;IACzE,kFAAkF;IAClF,eAAe,EAAE,KAAK,CAAC,eAAe,EAAE,CAAC,CAAA;IACzC;;;;OAIG;IACH,iBAAiB,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAA;CAC7D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,EAC3B,iBAAiB,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,GAC3D,eAAe,CA2KjB"}