@picked/svelte 0.0.1-dev.1767922288295 → 0.0.1-dev.1767932013788

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

@@ -1,26 +1,177 @@
-import { CommitResponses, Field, ValidationError } from '@picked/client';
+import { FieldValue, ValidationError } from '@picked/client';
 import { EventCallable, Store } from 'effector';
-import { FieldWithValue } from '../hooks';
-interface GetFormOptions {
+type ExtractFieldIds<TFieldIds extends readonly string[]> = TFieldIds[number];
+interface GetFormOptions<TFieldIds extends readonly string[]> {
     id: string;
     title: string;
-    fields: Store<Field[] | FieldWithValue[]>;
+    fieldIds: TFieldIds;
 }
-type SuccessCallback = (options: {
-    data: CommitResponses;
+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 = (data: CommitResponses) => CommitResponses | void | Promise<CommitResponses | 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({ id: formId, title, fields }: GetFormOptions): {
+export declare function getForm<const TFieldIds extends readonly string[]>({ id: formId, title, fieldIds, }: GetFormOptions<TFieldIds>): {
     form: {
         onsubmit: EventCallable<SubmitEventWithCurrentTarget>;
     };
-    onFormSubmit: (callback: SubmitCallback) => void;
-    onFormSuccess: (callback: SuccessCallback) => void;
+    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?: 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>;
 };

package/dist/form/form.svelte.ts

@@ -1,11 +1,11 @@
 import type {
-  CommitResponses,
   ExperienceStep,
   Field,
   FieldValue,
   ValidationError,
   ExperienceInstance,
 } from '@picked/client'
+import { getStepFields } from '@picked/client'
 import {
   attach,
   createEffect,
@@ -15,33 +15,39 @@ import {
   split,
   type EventCallable,
   type Store,
+  combine,
 } from 'effector'
-import { getPicked, getExperience, type FieldWithValue } from '../hooks'
+import { getPicked, getExperience } from '../hooks'
 
 interface Response {
   questionId: Field['id']
   value: FieldValue
 }
 
-interface GetFormOptions {
+// 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
-  fields: Store<Field[] | FieldWithValue[]>
+  fieldIds: TFieldIds
 }
 
-interface CommitResult {
-  data: CommitResponses
+interface CommitResult<TFieldIds extends string = string> {
+  data: Record<TFieldIds, FieldValue>
   errors: ValidationError[]
 }
 
-type SuccessCallback = (options: {
-  data: CommitResponses
+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 = (
-  data: CommitResponses,
-) => CommitResponses | void | Promise<CommitResponses | 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 }
 
@@ -70,13 +76,67 @@ function createObserver<TCallback extends (...args: any[]) => any, TReturn = voi
   return { executeFx, register }
 }
 
-export function getForm({ id: formId, title, fields }: GetFormOptions) {
+export function getForm<const TFieldIds extends readonly string[]>({
+  id: formId,
+  title,
+  fieldIds,
+}: GetFormOptions<TFieldIds>) {
+  type FieldId = ExtractFieldIds<TFieldIds>
   const client = getPicked()
-  const experienceInstance: ExperienceInstance = getExperience()
-  const { currentStepStore: stepStore, goToNextStep } = experienceInstance
+
+  // 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.some((id) => id === 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<CommitResponses>()
+  const formSuccessEvent = createEvent<Record<FieldId, FieldValue>>()
   const formErrorEvent = createEvent<ValidationError[]>()
   const stopNavigationEvent = createEvent<void>()
   const allCallbacksCompleteEvent = createEvent<void>()
@@ -88,7 +148,7 @@ export function getForm({ id: formId, title, fields }: GetFormOptions) {
     .on(submitEvent, () => false) // Reset to false on new submit
 
   // Create observers for each callback type
-  const successObserver = createObserver<SuccessCallback>(async (callbacks, options) => {
+  const successObserver = createObserver<SuccessCallback<FieldId>>(async (callbacks, options) => {
     await Promise.all(callbacks.map((callback) => Promise.resolve(callback(options))))
   })
 
@@ -96,7 +156,7 @@ export function getForm({ id: formId, title, fields }: GetFormOptions) {
     await Promise.all(callbacks.map((callback) => Promise.resolve(callback(errors))))
   })
 
-  const submitObserver = createObserver<SubmitCallback, CommitResponses>(
+  const submitObserver = createObserver<SubmitCallback<FieldId>, Record<FieldId, FieldValue>>(
     async (callbacks, data) => {
       let transformedData = data
 
@@ -113,7 +173,7 @@ export function getForm({ id: formId, title, fields }: GetFormOptions) {
     },
   )
 
-  const commitFx = createEffect(async (responses: CommitResponses) => {
+  const commitFx = createEffect(async (responses: Record<FieldId, FieldValue>) => {
     const result = await client.responses.commit(responses)
     // Merge submitted data with validation result
     return {
@@ -124,18 +184,28 @@ export function getForm({ id: formId, title, fields }: GetFormOptions) {
 
   const onSuccessFx = attach({
     source: { step: stepStore },
-    mapParams: (commitResult: CommitResult, source) => ({
+    mapParams: (commitResult: CommitResult<FieldId>, source) => ({
       step: source.step,
       data: commitResult.data,
     }),
     effect: createEffect(
-      async ({ step, data }: { step: ExperienceStep | null; data: CommitResponses }) => {
-        client.eventBus({
-          type: 'form_submit_success',
-          form: { id: formId, title },
-          experience: experienceInstance,
-          step: step ?? undefined,
-        })
+      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
       },
     ),
@@ -143,28 +213,31 @@ export function getForm({ id: formId, title, fields }: GetFormOptions) {
 
   const onErrorFx = attach({
     source: { step: stepStore },
-    mapParams: (commitResult: CommitResult, source) => ({
+    mapParams: (commitResult: CommitResult<FieldId>, source) => ({
       step: source.step,
       errors: commitResult.errors,
     }),
     effect: createEffect(
       async ({ step, errors }: { step: ExperienceStep | null; errors: ValidationError[] }) => {
-        client.eventBus({
-          type: 'form_submit_error',
-          form: { id: formId, title },
-          exception: { reason: errors },
-          experience: experienceInstance,
-          step: step ?? undefined,
-        })
-
-        errors.forEach((exception) => {
+        // Only fire events if in experience context
+        if (experienceInstance) {
           client.eventBus({
-            type: 'field_validation_error',
-            exception: { reason: [exception] },
+            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
       },
@@ -192,12 +265,15 @@ export function getForm({ id: formId, title, fields }: GetFormOptions) {
         title: string
         step: ExperienceStep | null
       }) => {
-        client.eventBus({
-          type: 'form_submit',
-          form: { id: formIdParam, title: titleParam },
-          experience: experienceInstance,
-          step: step ?? undefined,
-        })
+        // Only fire events if in experience context
+        if (experienceInstance) {
+          client.eventBus({
+            type: 'form_submit',
+            form: { id: formIdParam, title: titleParam },
+            experience: experienceInstance,
+            step: step ?? undefined,
+          })
+        }
       },
     ),
   })
@@ -205,10 +281,9 @@ export function getForm({ id: formId, title, fields }: GetFormOptions) {
   sample({
     clock: submitEvent,
     source: {
-      fields: client.fields.listStore,
-      stepFields: fields,
+      stepFields: fieldsStore,
     },
-    fn: ({ stepFields }, event) => {
+    fn: ({ stepFields }, event): Record<FieldId, FieldValue> => {
       event.preventDefault()
 
       const formData = new FormData(event.currentTarget)
@@ -244,7 +319,7 @@ export function getForm({ id: formId, title, fields }: GetFormOptions) {
         },
       }
 
-      stepFields.forEach((field) => {
+      stepFields.forEach((field: Field) => {
         let fieldEntries = formDataEntries.filter(([key]) => key === field.id)
 
         if (fieldEntries.length === 0) {
@@ -341,13 +416,15 @@ export function getForm({ id: formId, title, fields }: GetFormOptions) {
     target: allCallbacksCompleteEvent,
   })
 
-  // Check navigation after all callbacks complete
-  sample({
-    clock: allCallbacksCompleteEvent,
-    source: stopNavigationStore,
-    filter: (stop) => !stop,
-    target: goToNextStep,
-  })
+  // 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({
@@ -371,6 +448,7 @@ export function getForm({ id: formId, title, fields }: GetFormOptions) {
     form: {
       onsubmit: submitEvent,
     },
+    fields: fieldsWithValues,
     onFormSubmit: submitObserver.register,
     onFormSuccess: successObserver.register,
     onFormError: errorObserver.register,

package/dist/hooks/action.d.ts

@@ -0,0 +1,2 @@
+export declare function getAction(actionName: string): import('effector').Store<(<T = void>(params?: T) => void) | undefined>;
+export declare function getActionResult(actionName: string): import('effector').StoreWritable<void | undefined>;

package/dist/hooks/action.js

@@ -0,0 +1 @@
+import{createStore as s,createEvent as f,attach as l,createEffect as u,sample as a}from"effector";import{getPicked as m}from"./client.js";function g(t){return m().actions.getEvokableAction(t)}function v(t){const c=g(t),o=s(void 0,{skipVoid:!1}),n=f(),r=l({source:c,mapParams:(e,i)=>i,effect:u(async e=>{if(e)return e()})});return a({clock:n,target:r}),a({clock:r.doneData,target:o}),n(),o}export{g as getAction,v as getActionResult};

package/dist/hooks/feature.d.ts

@@ -0,0 +1,5 @@
+export declare function getFeature(featureName: string): import('effector').Store<() => Promise<boolean | string | undefined>>;
+export declare function getFeatureResult(featureName: string): import('effector').StoreWritable<{
+    id: string;
+    bucket: string | boolean;
+} | undefined>;

package/dist/hooks/feature.js

@@ -0,0 +1 @@
+import{createStore as i,createEvent as s,attach as f,createEffect as l,sample as o}from"effector";import{getPicked as v}from"./client.js";function d(t){return v().features.getEvokableFeature(t)}function m(t){const r=d(t),c=i(void 0,{skipVoid:!1}),a=s(),n=f({source:r,mapParams:(e,u)=>u,effect:l(async e=>await e())});return o({clock:a,target:n}),o({clock:n.doneData,fn:e=>{if(e!==void 0)return{id:t,bucket:e}},target:c}),a(),o({clock:r,target:a}),c}export{d as getFeature,m as getFeatureResult};

package/dist/hooks/index.d.ts

@@ -1,6 +1,10 @@
 export { getPicked, getExperience } from './client';
 export { getStep, setStepContext, type FieldWithValue } from './step';
 export { getField } from './field';
+export { getForm } from '../form';
+export { getAction, getActionResult } from './action';
+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{getStep as c,setStepContext as x}from"./step.js";import{getField as a}from"./field.js";import{getContextScope as S,setContextScope as g,useUnit as s}from"./stores.js";import{createLocalStorageStore as i,createSessionStorageStore as u}from"./storage.js";import{getTrackRecommendationPresentEvent as d}from"./events.js";import{createQuery as P,queryCache as k,queryPresets as l}from"./create-query/index.js";export{i as createLocalStorageStore,P as createQuery,u as createSessionStorageStore,S as getContextScope,r as getExperience,a as getField,o as getPicked,c as getStep,d as getTrackRecommendationPresentEvent,k as queryCache,l as queryPresets,g as setContextScope,x as setStepContext,s 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/predicate.d.ts

@@ -0,0 +1,3 @@
+import { Predicate } from '@picked/client';
+export declare function getPredicate(predicateName: string): import('effector').Store<() => ReturnType<Predicate>>;
+export declare function getPredicateResult(predicateName: string): import('effector').StoreWritable<string | boolean | string[] | undefined>;

package/dist/hooks/predicate.js

@@ -0,0 +1 @@
+import"@picked/client";import{createStore as s,createEvent as d,attach as l,createEffect as f,sample as a}from"effector";import{getPicked as u}from"./client.js";function m(e){return u().predicates.getEvokablePredicate(e)}function v(e){const t=m(e),o=s(void 0,{skipVoid:!1}),r=d(),i=l({source:t,mapParams:(c,n)=>n,effect:f(async c=>{if(c)return await c()})});return a({clock:r,target:i}),a({clock:i.doneData,target:o}),r(),a({clock:t,target:r}),o}export{m as getPredicate,v as getPredicateResult};

package/dist/hooks/step.d.ts

@@ -1,30 +1,12 @@
 import { Store } from 'effector';
-import { ExperienceStep, Field, Response } from '@picked/client';
+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>;
-    form: ReturnType<typeof getForm>;
 }
-export declare function getStep(): {
-    form: {
-        onsubmit: import('effector').EventCallable<SubmitEvent & {
-            currentTarget: EventTarget & HTMLFormElement;
-        }>;
-    };
-    onFormSubmit: (callback: (data: import('@picked/client').CommitResponses) => import('@picked/client').CommitResponses | void | Promise<import('@picked/client').CommitResponses | void>) => void;
-    onFormSuccess: (callback: (options: {
-        data: import('@picked/client').CommitResponses;
-        stopNavigation: import('effector').EventCallable<void>;
-    }) => void | Promise<void>) => void;
-    onFormError: (callback: (errors: import('@picked/client').ValidationError[]) => void | Promise<void>) => void;
-    isFormSubmitting: import('effector').StoreWritable<boolean>;
-    step: Store<ExperienceStep>;
-    fields: Store<FieldWithValue[]>;
-    isActiveStep: Store<boolean>;
-};
+export declare function getStep(): StepContext;
 export declare function setStepContext(stepId: string): StepContext;

package/dist/hooks/step.js

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

@@ -1,6 +1,6 @@
 {
   "name": "@picked/svelte",
-  "version": "0.0.1-dev.1767922288295",
+  "version": "0.0.1-dev.1767932013788",
   "dependencies": {
     "d3": "^7.9.0"
   },
@@ -75,7 +75,7 @@
   ],
   "module": "./dist/index.js",
   "peerDependencies": {
-    "@picked/client": "0.0.1-dev.1767922288295",
+    "@picked/client": "0.0.1-dev.1767932013788",
     "effector": "^23.3.0",
     "svelte": "^5.34.3"
   },