@picked/svelte 0.0.1-dev.1767845350659 → 0.0.1-dev.1767924764002

package/dist/form/form.svelte.d.ts

@@ -0,0 +1,186 @@
+import { FieldValue, ValidationError } from '@picked/client';
+import { EventCallable, Store } from 'effector';
+type ExtractFieldIds<TFieldIds extends readonly string[]> = TFieldIds[number];
+interface GetFormOptions<TFieldIds extends readonly string[]> {
+    id: string;
+    title: string;
+    fieldIds: TFieldIds;
+}
+type SuccessCallback<TFieldIds extends string = string> = (options: {
+    data: Record<TFieldIds, FieldValue>;
+    stopNavigation: EventCallable<void>;
+}) => void | Promise<void>;
+type ErrorCallback = (errors: ValidationError[]) => void | Promise<void>;
+type SubmitCallback<TFieldIds extends string = string> = (data: Record<TFieldIds, FieldValue>) => Record<TFieldIds, FieldValue> | void | Promise<Record<TFieldIds, FieldValue> | void>;
+type SubmitEventWithCurrentTarget = SubmitEvent & {
+    currentTarget: EventTarget & HTMLFormElement;
+};
+export declare function getForm<const TFieldIds extends readonly string[]>({ id: formId, title, fieldIds, }: GetFormOptions<TFieldIds>): {
+    form: {
+        onsubmit: EventCallable<SubmitEventWithCurrentTarget>;
+    };
+    fields: Store<({
+        value: FieldValue | undefined;
+        type: "text";
+        multiple: false;
+        defaultValue?: string;
+        options?: {
+            id: string;
+            label: string;
+            description?: string;
+            value: string;
+            condition?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        }[] | null;
+        id: string;
+        name: string;
+        label: string;
+        required: boolean;
+        condition?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        placeholder?: string;
+        description?: string;
+        helpText?: string;
+        validation?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        policies?: {
+            doNotTrackValue?: boolean;
+            doNotStoreValue?: boolean;
+        };
+    } | {
+        value: FieldValue | undefined;
+        type: "text";
+        multiple: true;
+        defaultValue?: string[];
+        options?: {
+            id: string;
+            label: string;
+            description?: string;
+            value: string;
+            condition
+            /**
+             * Factory function to create a callback observer with automatic cleanup
+             * Reduces duplication across success/error/submit callback patterns
+             */
+            ? /**
+             * Factory function to create a callback observer with automatic cleanup
+             * Reduces duplication across success/error/submit callback patterns
+             */: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        }[] | null;
+        id: string;
+        name: string;
+        label: string;
+        required: boolean;
+        condition?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        placeholder?: string;
+        description?: string;
+        helpText?: string;
+        validation?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        policies?: {
+            doNotTrackValue?: boolean;
+            doNotStoreValue?: boolean;
+        };
+    } | {
+        value: FieldValue | undefined;
+        type: "number";
+        multiple: false;
+        defaultValue?: number;
+        options?: {
+            id: string;
+            label: string;
+            description?: string;
+            value: number;
+            condition?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        }[] | null;
+        id: string;
+        name: string;
+        label: string;
+        required: boolean;
+        condition?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        placeholder?: string;
+        description?: string;
+        helpText?: string;
+        validation?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        policies?: {
+            doNotTrackValue?: boolean;
+            doNotStoreValue?: boolean;
+        };
+    } | {
+        value: FieldValue | undefined;
+        type: "number";
+        multiple: true;
+        defaultValue?: number[];
+        options?: {
+            id: string;
+            label: string;
+            description?: string;
+            value: number;
+            condition?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        }[] | null;
+        id: string;
+        name: string;
+        label: string;
+        required: boolean;
+        condition?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        placeholder?: string;
+        description?: string;
+        helpText?: string;
+        validation?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        policies?: {
+            doNotTrackValue?: boolean;
+            doNotStoreValue?: boolean;
+        };
+    } | {
+        value: FieldValue | undefined;
+        type: "boolean";
+        multiple: false;
+        defaultValue?: boolean;
+        options?: {
+            id: string;
+            label: string;
+            description?: string;
+            value: boolean;
+            condition?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        }[] | null;
+        id: string;
+        name: string;
+        label: string;
+        required: boolean;
+        condition?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        placeholder?: string;
+        description?: string;
+        helpText?: string;
+        validation?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        policies?: {
+            doNotTrackValue?: boolean;
+            doNotStoreValue?: boolean;
+        };
+    } | {
+        value: FieldValue | undefined;
+        type: "boolean";
+        multiple: true;
+        defaultValue?: boolean[];
+        options?: {
+            id: string;
+            label: string;
+            description?: string;
+            value: boolean;
+            condition?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        }[] | null;
+        id: string;
+        name: string;
+        label: string;
+        required: boolean;
+        condition?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        placeholder?: string;
+        description?: string;
+        helpText?: string;
+        validation?: import('node_modules/@picked/client/dist/types/logic-engine').LogicRule;
+        policies?: {
+            doNotTrackValue?: boolean;
+            doNotStoreValue?: boolean;
+        };
+    })[]>;
+    onFormSubmit: (callback: SubmitCallback<ExtractFieldIds<TFieldIds>>) => void;
+    onFormSuccess: (callback: SuccessCallback<ExtractFieldIds<TFieldIds>>) => void;
+    onFormError: (callback: ErrorCallback) => void;
+    isFormSubmitting: import('effector').StoreWritable<boolean>;
+};
+export {};

package/dist/form/form.svelte.ts

@@ -0,0 +1,451 @@
+import type {
+  CommitResponses,
+  ExperienceStep,
+  Field,
+  FieldValue,
+  ValidationError,
+  ExperienceInstance,
+} from '@picked/client'
+import { getStepFields } from '@picked/client'
+import {
+  attach,
+  createEffect,
+  createEvent,
+  createStore,
+  sample,
+  split,
+  type EventCallable,
+  type Store,
+  combine,
+} from 'effector'
+import { getPicked, getExperience, type FieldWithValue } from '../hooks'
+
+interface Response {
+  questionId: Field['id']
+  value: FieldValue
+}
+
+// Extract field IDs from a readonly string array
+type ExtractFieldIds<TFieldIds extends readonly string[]> = TFieldIds[number]
+
+interface GetFormOptions<TFieldIds extends readonly string[]> {
+  id: string
+  title: string
+  fieldIds: TFieldIds
+}
+
+interface CommitResult<TFieldIds extends string = string> {
+  data: Record<TFieldIds, FieldValue>
+  errors: ValidationError[]
+}
+
+type SuccessCallback<TFieldIds extends string = string> = (options: {
+  data: Record<TFieldIds, FieldValue>
+  stopNavigation: EventCallable<void>
+}) => void | Promise<void>
+
+type ErrorCallback = (errors: ValidationError[]) => void | Promise<void>
+
+type SubmitCallback<TFieldIds extends string = string> = (
+  data: Record<TFieldIds, FieldValue>,
+) => Record<TFieldIds, FieldValue> | void | Promise<Record<TFieldIds, FieldValue> | void>
+
+type SubmitEventWithCurrentTarget = SubmitEvent & { currentTarget: EventTarget & HTMLFormElement }
+
+/**
+ * Factory function to create a callback observer with automatic cleanup
+ * Reduces duplication across success/error/submit callback patterns
+ */
+function createObserver<TCallback extends (...args: any[]) => any, TReturn = void>(
+  executor: (callbacks: TCallback[], ...params: Parameters<TCallback>) => Promise<TReturn>,
+) {
+  let callbacks: TCallback[] = []
+
+  const executeFx = createEffect(async (...params: Parameters<TCallback>): Promise<TReturn> => {
+    return await executor(callbacks, ...params)
+  })
+
+  const register = (callback: TCallback) => {
+    $effect(() => {
+      callbacks.push(callback)
+      return () => {
+        callbacks = callbacks.filter((cb) => cb !== callback)
+      }
+    })
+  }
+
+  return { executeFx, register }
+}
+
+export function getForm<const TFieldIds extends readonly string[]>({
+  id: formId,
+  title,
+  fieldIds,
+}: GetFormOptions<TFieldIds>) {
+  type FieldId = ExtractFieldIds<TFieldIds>
+  const client = getPicked()
+
+  // Make experience and router context optional
+  let experienceInstance: ExperienceInstance | null = null
+  let stepStore: Store<ExperienceStep | null>
+  let goToNextStep: EventCallable<void> | null = null
+
+  try {
+    experienceInstance = getExperience()
+    stepStore = experienceInstance.currentStepStore
+    goToNextStep = experienceInstance.goToNextStep
+  } catch {
+    // Not in experience context - create null store for standalone forms
+    stepStore = createStore<ExperienceStep | null>(null)
+  }
+
+  // Create internal fields store
+  const fieldsStore = createStore<Field[]>([])
+
+  // Create fields with values store for UI
+  const fieldsWithValues = combine(
+    {
+      fields: fieldsStore,
+      responses: client.responses.listStore,
+    },
+    ({ fields, responses }) => {
+      return fields.map((field) => {
+        const value = responses.find((r) => r.fieldId === field.id)?.value
+        return { ...field, value }
+      })
+    },
+  )
+
+  // Filter and evaluate fields based on fieldIds
+  const evaluateFieldsFx = attach({
+    source: client.fields.listStore,
+    effect: createEffect(async (allFields: Field[]) => {
+      const filteredFields = allFields.filter((field) =>
+        (fieldIds as readonly string[]).includes(field.id)
+      )
+      return await getStepFields(client, filteredFields)
+    }),
+  })
+
+  // Populate fields store when fields are evaluated
+  sample({
+    clock: evaluateFieldsFx.doneData,
+    target: fieldsStore,
+  })
+
+  // Auto-trigger field evaluation on form creation
+  evaluateFieldsFx()
+
+  const submitEvent = createEvent<SubmitEventWithCurrentTarget>()
+  const formSuccessEvent = createEvent<Record<FieldId, FieldValue>>()
+  const formErrorEvent = createEvent<ValidationError[]>()
+  const stopNavigationEvent = createEvent<void>()
+  const allCallbacksCompleteEvent = createEvent<void>()
+
+  const isFormSubmitting = createStore<boolean>(false)
+  const stopNavigationStore = createStore(false)
+  stopNavigationStore
+    .on(stopNavigationEvent, () => true) // Set to true when stopNavigation is used in onFormSuccess
+    .on(submitEvent, () => false) // Reset to false on new submit
+
+  // Create observers for each callback type
+  const successObserver = createObserver<SuccessCallback<FieldId>>(async (callbacks, options) => {
+    await Promise.all(callbacks.map((callback) => Promise.resolve(callback(options))))
+  })
+
+  const errorObserver = createObserver<ErrorCallback>(async (callbacks, errors) => {
+    await Promise.all(callbacks.map((callback) => Promise.resolve(callback(errors))))
+  })
+
+  const submitObserver = createObserver<SubmitCallback<FieldId>, Record<FieldId, FieldValue>>(
+    async (callbacks, data) => {
+      let transformedData = data
+
+      // Apply each callback's transformation sequentially
+      for (const callback of callbacks) {
+        const result = await Promise.resolve(callback(transformedData))
+        // If callback returns data, use it; otherwise keep current
+        if (result !== undefined) {
+          transformedData = result
+        }
+      }
+
+      return transformedData
+    },
+  )
+
+  const commitFx = createEffect(async (responses: Record<FieldId, FieldValue>) => {
+    const result = await client.responses.commit(responses)
+    // Merge submitted data with validation result
+    return {
+      data: responses,
+      errors: result.errors,
+    }
+  })
+
+  const onSuccessFx = attach({
+    source: { step: stepStore },
+    mapParams: (commitResult: CommitResult<FieldId>, source) => ({
+      step: source.step,
+      data: commitResult.data,
+    }),
+    effect: createEffect(
+      async ({ step, data }: { step: ExperienceStep | null; data: Record<FieldId, FieldValue> }) => {
+        // Only fire events if in experience context
+        if (experienceInstance) {
+          client.eventBus({
+            type: 'form_submit_success',
+            form: { id: formId, title },
+            experience: experienceInstance,
+            step: step ?? undefined,
+          })
+        }
+        return data
+      },
+    ),
+  })
+
+  const onErrorFx = attach({
+    source: { step: stepStore },
+    mapParams: (commitResult: CommitResult<FieldId>, source) => ({
+      step: source.step,
+      errors: commitResult.errors,
+    }),
+    effect: createEffect(
+      async ({ step, errors }: { step: ExperienceStep | null; errors: ValidationError[] }) => {
+        // Only fire events if in experience context
+        if (experienceInstance) {
+          client.eventBus({
+            type: 'form_submit_error',
+            form: { id: formId, title },
+            exception: { reason: errors },
+            experience: experienceInstance,
+            step: step ?? undefined,
+          })
+
+          errors.forEach((exception) => {
+            client.eventBus({
+              type: 'field_validation_error',
+              exception: { reason: [exception] },
+              experience: experienceInstance!,
+              step: step ?? undefined,
+            })
+          })
+        }
+
+        return errors
+      },
+    ),
+  })
+
+  // set isFormSubmitting to true when the form is submitted
+  sample({
+    clock: submitEvent,
+    fn: () => true,
+    target: isFormSubmitting,
+  })
+
+  sample({
+    clock: submitEvent,
+    source: { step: stepStore },
+    fn: ({ step }) => ({ formId, title, step }),
+    target: createEffect(
+      ({
+        formId: formIdParam,
+        title: titleParam,
+        step,
+      }: {
+        formId: string
+        title: string
+        step: ExperienceStep | null
+      }) => {
+        // Only fire events if in experience context
+        if (experienceInstance) {
+          client.eventBus({
+            type: 'form_submit',
+            form: { id: formIdParam, title: titleParam },
+            experience: experienceInstance,
+            step: step ?? undefined,
+          })
+        }
+      },
+    ),
+  })
+
+  sample({
+    clock: submitEvent,
+    source: {
+      stepFields: fieldsStore,
+    },
+    fn: ({ stepFields }, event) => {
+      event.preventDefault()
+
+      const formData = new FormData(event.currentTarget)
+      const formDataEntries = Array.from(formData.entries())
+
+      const responses: { data: Record<Field['id'], FieldValue>; push: (item: Response) => void } = {
+        data: {},
+        push(item: Response) {
+          const questionId = item.questionId
+          const existing = this.data[questionId]
+
+          if (!existing) {
+            // No matching questionId, just add the new item
+            this.data[questionId] = item.value
+            // If both values are arrays, merge them
+          } else if (Array.isArray(existing) && Array.isArray(item.value)) {
+            if (Array.isArray(existing) && Array.isArray(item.value)) {
+              // Check what type FieldValue expects and convert accordingly
+              if (typeof existing[0] === 'string') {
+                this.data[questionId] = [...existing, ...item.value].map(String)
+              } else if (typeof existing[0] === 'number') {
+                this.data[questionId] = [...existing, ...item.value].map(Number)
+              } else if (typeof existing[0] === 'boolean') {
+                this.data[questionId] = [...existing, ...item.value].map((v) => Boolean(v))
+              } else {
+                this.data[questionId] = item.value
+              }
+            }
+          } else {
+            // Otherwise, override the existing value
+            this.data[questionId] = item.value
+          }
+        },
+      }
+
+      stepFields.forEach((field: Field) => {
+        let fieldEntries = formDataEntries.filter(([key]) => key === field.id)
+
+        if (fieldEntries.length === 0) {
+          fieldEntries = [[field.id, '']]
+        }
+
+        fieldEntries.forEach(([, value]) => {
+          const questionId = field.id
+
+          if (value === '') {
+            responses.push({
+              questionId,
+              value: null,
+            })
+
+            return
+          }
+
+          switch (field.type) {
+            case 'text':
+              responses.push({
+                questionId,
+                value: field.multiple ? [String(value)] : String(value),
+              })
+              break
+            case 'number':
+              responses.push({
+                questionId,
+                value: field.multiple ? [Number(value)] : Number(value),
+              })
+              break
+            case 'boolean':
+              responses.push({
+                questionId,
+                value: field.multiple ? [value === 'true'] : value === 'true',
+              })
+              break
+            // case 'object':
+            //   try {
+            //     responses.push({
+            //       questionId,
+            //       value: field.multiple ? [JSON.parse(String(value))] : JSON.parse(String(value)),
+            //     })
+            //   } catch {
+            //     responses.push({
+            //       questionId,
+            //       value: field.multiple ? [null] : null,
+            //     })
+            //   }
+
+            // break
+          }
+        })
+      })
+
+      return responses.data as Record<FieldId, FieldValue>
+    },
+    target: submitObserver.executeFx,
+  })
+
+  // Pass transformed data from submit callbacks to commit
+  sample({
+    clock: submitObserver.executeFx.doneData,
+    target: commitFx,
+  })
+
+  // Errors are returned from the commit even if it is a success, split to handle errors array
+  split({
+    source: commitFx.doneData,
+    match: {
+      hasErrors: ({ errors }) => errors.length > 0,
+    },
+    cases: {
+      hasErrors: onErrorFx,
+      __: onSuccessFx,
+    },
+  })
+
+  sample({
+    clock: onSuccessFx.doneData,
+    target: formSuccessEvent,
+  })
+
+  // When form succeeds, execute all callbacks
+  sample({
+    clock: formSuccessEvent,
+    fn: (data) => ({ data, stopNavigation: stopNavigationEvent }), // Pass form data and event reference to callbacks
+    target: successObserver.executeFx,
+  })
+
+  // When all callbacks complete, trigger navigation check
+  sample({
+    clock: successObserver.executeFx.done,
+    target: allCallbacksCompleteEvent,
+  })
+
+  // Check navigation after all callbacks complete (only if in router context)
+  if (goToNextStep) {
+    sample({
+      clock: allCallbacksCompleteEvent,
+      source: stopNavigationStore,
+      filter: (stop) => !stop,
+      target: goToNextStep,
+    })
+  }
+
+  // Declarative event wiring for error flow
+  sample({
+    clock: onErrorFx.doneData,
+    target: formErrorEvent,
+  })
+
+  // When form errors, execute all error callbacks
+  sample({
+    clock: formErrorEvent,
+    target: errorObserver.executeFx,
+  })
+
+  sample({
+    clock: [allCallbacksCompleteEvent, errorObserver.executeFx.done],
+    fn: () => false,
+    target: isFormSubmitting,
+  })
+
+  return {
+    form: {
+      onsubmit: submitEvent,
+    },
+    fields: fieldsWithValues,
+    onFormSubmit: submitObserver.register,
+    onFormSuccess: successObserver.register,
+    onFormError: errorObserver.register,
+    isFormSubmitting,
+  }
+}

package/dist/form/index.d.ts

@@ -1,16 +1 @@
-import { ValidationError } from '@picked/client';
-interface GetFormOptions {
-    id: string;
-    title: string;
-    onSuccess?: () => void | Promise<void>;
-    onError?: (errors: ValidationError[]) => void | Promise<void>;
-}
-type SubmitEventWithCurrentTarget = SubmitEvent & {
-    currentTarget: EventTarget & HTMLFormElement;
-};
-export declare function getForm({ id: formId, title, onError, onSuccess }: GetFormOptions): {
-    form: {
-        onsubmit: import('effector').EventCallable<SubmitEventWithCurrentTarget>;
-    };
-};
-export {};
+export { getForm } from './form.svelte';

package/dist/form/index.js

@@ -1 +1 @@
-import{createEvent as k,createEffect as m,attach as b,sample as g,split as D}from"effector";import{getPicked as F,getExperience as S}from"../hooks/client.js";import"@picked/client";import{getStep as B}from"../hooks/step.js";import"svelte";import"svelte/store";import"@picked/analytics";function z({id:f,title:l,onError:d,onSuccess:h}){const o=F(),x=B(),n=S(),{currentStepStore:u}=n,v=k(),y=m(r=>o.responses.commit(r)),A=b({source:{step:u},effect:m(({step:r})=>{o.eventBus({type:"form_submit_success",form:{id:f,title:l},experience:n,step:r??void 0}),h==null||h()})}),_=b({source:{step:u},mapParams:(r,a)=>({step:a.step,errors:r.errors}),effect:m(({step:r,errors:a})=>{o.eventBus({type:"form_submit_error",form:{id:f,title:l},exception:{reason:a},experience:n,step:r??void 0}),a.forEach(p=>{o.eventBus({type:"field_validation_error",exception:{reason:[p]},experience:n,step:r??void 0})}),d==null||d(a)})});return g({clock:v,source:{step:u},fn:({step:r})=>({formId:f,title:l,step:r}),target:m(({formId:r,title:a,step:p})=>{o.eventBus({type:"form_submit",form:{id:r,title:a},experience:n,step:p??void 0})})}),g({clock:v,source:{fields:o.fields.listStore,stepFields:x.fields,step:u},fn:({stepFields:r},a)=>{a.preventDefault();const p=new FormData(a.currentTarget),E=Array.from(p.entries()),c={data:{},push(t){const s=t.questionId,e=this.data[s];e?Array.isArray(e)&&Array.isArray(t.value)?Array.isArray(e)&&Array.isArray(t.value)&&(typeof e[0]=="string"?this.data[s]=[...e,...t.value].map(String):typeof e[0]=="number"?this.data[s]=[...e,...t.value].map(Number):typeof e[0]=="boolean"?this.data[s]=[...e,...t.value].map(i=>!!i):this.data[s]=t.value):this.data[s]=t.value:this.data[s]=t.value}};return r.forEach(t=>{let s=E.filter(([e])=>e===t.id);s.length===0&&(s=[[t.id,""]]),s.forEach(([,e])=>{const i=t.id;if(e===""){c.push({questionId:i,value:null});return}switch(t.type){case"text":c.push({questionId:i,value:t.multiple?[String(e)]:String(e)});break;case"number":c.push({questionId:i,value:t.multiple?[Number(e)]:Number(e)});break;case"boolean":c.push({questionId:i,value:t.multiple?[e==="true"]:e==="true"});break}})}),c.data},target:y}),D({source:y.doneData,match:{hasErrors:({errors:r})=>r.length>0},cases:{hasErrors:_,__:A}}),{form:{onsubmit:v}}}export{z as getForm};
+import{getForm as e}from"./form.svelte";export{e as getForm};

package/dist/hooks/index.d.ts

@@ -1,8 +1,10 @@
 export { getPicked, getExperience } from './client';
-export { getPredicate, getPredicateResult } from './predicate';
-export { getFeature, getFeatureResult } from './feature';
+export { getStep, setStepContext, type FieldWithValue } from './step';
+export { getField } from './field';
+export { getForm } from '../form';
 export { getAction, getActionResult } from './action';
-export { getStep, setStepContext } from './step';
+export { getFeature, getFeatureResult } from './feature';
+export { getPredicate, getPredicateResult } from './predicate';
 export { useUnit, getContextScope, setContextScope } from './stores';
 export { createSessionStorageStore, createLocalStorageStore } from './storage.js';
 export { getTrackRecommendationPresentEvent } from './events';

package/dist/hooks/index.js

@@ -1 +1 @@
-import{getExperience as r,getPicked as o}from"./client.js";import{getPredicate as p,getPredicateResult as a}from"./predicate.js";import{getFeature as x,getFeatureResult as n}from"./feature.js";import{getAction as s,getActionResult as f}from"./action.js";import{getStep as u,setStepContext as S}from"./step.js";import{getContextScope as d,setContextScope as l,useUnit as C}from"./stores.js";import{createLocalStorageStore as y,createSessionStorageStore as k}from"./storage.js";import{getTrackRecommendationPresentEvent as A}from"./events.js";import{createQuery as F,queryCache as h,queryPresets as v}from"./create-query/index.js";export{y as createLocalStorageStore,F as createQuery,k as createSessionStorageStore,s as getAction,f as getActionResult,d as getContextScope,r as getExperience,x as getFeature,n as getFeatureResult,o as getPicked,p as getPredicate,a as getPredicateResult,u as getStep,A as getTrackRecommendationPresentEvent,h as queryCache,v as queryPresets,l as setContextScope,S as setStepContext,C as useUnit};
+import{getExperience as r,getPicked as o}from"./client.js";import{getStep as c,setStepContext as g}from"./step.js";import{getField as m}from"./field.js";import{getForm as n}from"../form/form.svelte";import{getAction as s,getActionResult as i}from"./action.js";import{getFeature as S,getFeatureResult as d}from"./feature.js";import{getPredicate as P,getPredicateResult as C}from"./predicate.js";import{getContextScope as R,setContextScope as y,useUnit as k}from"./stores.js";import{createLocalStorageStore as A,createSessionStorageStore as E}from"./storage.js";import{getTrackRecommendationPresentEvent as v}from"./events.js";import{createQuery as Q,queryCache as T,queryPresets as U}from"./create-query/index.js";export{A as createLocalStorageStore,Q as createQuery,E as createSessionStorageStore,s as getAction,i as getActionResult,R as getContextScope,r as getExperience,S as getFeature,d as getFeatureResult,m as getField,n as getForm,o as getPicked,P as getPredicate,C as getPredicateResult,c as getStep,v as getTrackRecommendationPresentEvent,T as queryCache,U as queryPresets,y as setContextScope,g as setStepContext,k as useUnit};

package/dist/hooks/step.d.ts

@@ -1,13 +1,12 @@
 import { Store } from 'effector';
-import { ExperienceStep, Field, Response } from '@picked/client';
-type FieldWithValue = Field & {
+import { ExperienceStep, Response, Field } from '@picked/client';
+import { getForm } from '../form';
+export type FieldWithValue = Field & {
     value: Response | undefined;
 };
-export interface StepContext {
+export interface StepContext extends ReturnType<typeof getForm> {
     step: Store<ExperienceStep>;
-    fields: Store<FieldWithValue[]>;
     isActiveStep: Store<boolean>;
 }
 export declare function getStep(): StepContext;
 export declare function setStepContext(stepId: string): StepContext;
-export {};

package/dist/hooks/step.js

@@ -1 +1 @@
-import{getContext as v,setContext as E}from"svelte";import{createStore as h,combine as a,attach as w,createEffect as C,sample as l}from"effector";import{getStepFields as A}from"@picked/client";import{STEP_CONTEXT_KEY as d}from"../context.js";import{getStepRouter as F}from"../router/context.js";import{getExperience as T,getPicked as P}from"./client.js";function N(){return v(d)}function O(o){const u=T(),i=P(),{activeStep:m}=F(),n=m.map(e=>(e==null?void 0:e.id)===o),s=u.treeStore.map(e=>{const t=e.steps.find(r=>r.id===o);if(!t)throw new Error(`Step with id "${o}" not found in the experience tree.`);return t}),c=h([]),S=a({fields:c,responses:i.responses.listStore},({fields:e,responses:t})=>e.map(r=>{var f;const g=(f=t.find(x=>x.fieldId===r.id))==null?void 0:f.value;return{...r,value:g}})),p=w({source:a({step:s,fields:i.fields.listStore}),effect:C(async({step:{fieldIds:e},fields:t})=>await A(i,t.filter(r=>e.includes(r.id))))});return l({source:{isActiveStep:n},filter:({isActiveStep:e})=>e,target:p}),l({source:p.doneData,target:c}),E(d,{step:s,fields:S,isActiveStep:n})}export{N as getStep,O as setStepContext};
+import{getContext as x,setContext as u}from"svelte";import{STEP_CONTEXT_KEY as n}from"../context.js";import{getStepRouter as a}from"../router/context.js";import{getForm as g}from"../form/form.svelte";import{getExperience as E}from"./client.js";function w(){return x(n)}function T(t){const i=E(),{activeStep:c}=a(),m=c.map(e=>(e==null?void 0:e.id)===t),o=i.treeStore.map(e=>{const r=e.steps.find(s=>s.id===t);if(!r)throw new Error(`Step with id "${t}" not found in the experience tree.`);return r}),{label:p,fieldIds:f}=o.getState(),S=g({id:`${t}`,title:p||t,fieldIds:f});return u(n,{step:o,isActiveStep:m,...S})}export{w as getStep,T as setStepContext};

package/dist/index.d.ts

@@ -1,3 +1,2 @@
-/// <reference path="./picked-elements.d.ts" />
 export { adaptSvelteComponent, isValidAdaptedComponent } from './component';
 export type * from './component';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@picked/svelte",
-  "version": "0.0.1-dev.1767845350659",
+  "version": "0.0.1-dev.1767924764002",
   "dependencies": {
     "d3": "^7.9.0"
   },
@@ -68,11 +68,6 @@
       "import": "./dist/plugins/devtools/index.js",
       "svelte": "./dist/plugins/devtools/index.js",
       "default": "./dist/plugins/devtools/index.js"
-    },
-    "./elements": {
-      "types": "./dist/picked-elements.d.ts",
-      "import": "./dist/picked-elements.js",
-      "default": "./dist/picked-elements.js"
     }
   },
   "files": [
@@ -80,7 +75,7 @@
   ],
   "module": "./dist/index.js",
   "peerDependencies": {
-    "@picked/client": "0.0.1-dev.1767845350659",
+    "@picked/client": "0.0.1-dev.1767924764002",
     "effector": "^23.3.0",
     "svelte": "^5.34.3"
   },

package/dist/picked-elements.d.js

@@ -1 +0,0 @@
-

package/dist/picked-elements.d.ts

@@ -1,10 +0,0 @@
-import type { PickedHTMLAttributes } from '@picked/client'
-
-declare module 'svelte/elements' {
-  // Augment the base HTMLAttributes interface to include Picked custom attributes
-  // This makes picked-click, picked-scroll, etc. available on all HTML elements
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  interface HTMLAttributes<T> extends PickedHTMLAttributes {}
-}
-
-export {}

package/dist/picked-elements.js

@@ -1 +0,0 @@
-

package/dist/vite-env.d.ts

@@ -1,2 +0,0 @@
-/// <reference types="svelte" />
-/// <reference types="vite/client" />