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

package/dist/experience/ExperienceSlot.svelte

@@ -1,154 +0,0 @@
-<script lang="ts">
-  /**
-   * @file Slot-based experience renderer. Renders every registered experience that targets the
-   * named slot and whose condition is active, ordered by placement. Active is read synchronously
-   * from the seeded condition-results store (sync on SSR / hydration first paint); on a cache miss
-   * (standalone, no snapshot) the condition is evaluated asynchronously and the store update
-   * re-renders reactively.
-   */
-  import type { ExperienceStore, ExperienceTarget } from '@picked/client'
-  import { evaluateConditionMemo, hashRule, ruleReferencesActionDeep } from '@picked/client/server'
-  import { getPicked, useUnit } from '../hooks'
-  import ExperienceHost from './ExperienceHost.svelte'
-
-  type ExperienceConfig = ReturnType<ExperienceStore['configStore']['getState']>
-  type ConditionRule = ExperienceConfig['decisionLogic']
-
-  interface Props {
-    /**
-     * Slot name. Maps to the `.picked-slot-<name>` selector that targeted experiences declare.
-     * Named `name` rather than `slot` because Svelte's compiler reserves the `slot` attribute for
-     * legacy named-slot assignment, so it cannot be used as a component prop.
-     */
-    name: string
-  }
-
-  const { name }: Props = $props()
-
-  const client = getPicked()
-  const selector = $derived(`.picked-slot-${name}`)
-
-  const PLACEMENT_ORDER: ExperienceTarget['placement'][] = [
-    'replace',
-    'before',
-    'prepend',
-    'append',
-    'after',
-  ]
-
-  interface Candidate {
-    experience: ExperienceStore
-    placement: ExperienceTarget['placement']
-    condition: ConditionRule
-    hash: string
-  }
-
-  const experiences = useUnit(client.experiences.listStore)
-  const conditionResults = useUnit(client.conditionResults.store)
-  const conditions = useUnit(client.conditions.listStore)
-
-  const conditionsByKey = $derived.by(() => {
-    const byKey: Parameters<typeof ruleReferencesActionDeep>[1] = {}
-    for (const condition of $conditions) {
-      byKey[condition.key] = condition
-    }
-
-    return byKey
-  })
-
-  /**
-   * Returns the sort rank for a placement; unknown placements sort last.
-   *
-   * @param {ExperienceTarget['placement']} placement - The target placement.
-   * @returns {number} The placement's index in the precedence order.
-   * @example
-   * placementRank('append')
-   */
-  function placementRank(placement: ExperienceTarget['placement']): number {
-    const index = PLACEMENT_ORDER.indexOf(placement)
-    return index === -1 ? PLACEMENT_ORDER.length : index
-  }
-
-  /**
-   * Maps an experience to a slot candidate, or null when it does not target this slot or carries
-   * an action-referencing condition.
-   *
-   * @param {ExperienceStore} experience - The experience to inspect.
-   * @returns {Candidate | null} The candidate, or null when the experience is not an eligible slot match.
-   * @example
-   * toCandidate(experienceStore)
-   */
-  function toCandidate(experience: ExperienceStore): Candidate | null {
-    const config = experience.configStore.getState()
-    const target = config.targetSelectors.find(
-      (selectorTarget) => selectorTarget.selector === selector,
-    )
-    if (!target) {
-      return null
-    }
-
-    // Action-referencing conditions are never cached (their side effect must re-run), so they can
-    // never resolve through the synchronous `peek` the slot path relies on. Slots do not support
-    // action-gated conditions in v1; excluding them also stops the selection effect from re-firing
-    // the action on every render. The deep check follows composed `conditions.<key>` references so a
-    // condition that reaches an action transitively is excluded too.
-    if (ruleReferencesActionDeep(config.decisionLogic, conditionsByKey)) {
-      return null
-    }
-
-    return {
-      experience,
-      placement: target.placement,
-      condition: config.decisionLogic,
-      hash: hashRule(config.decisionLogic),
-    }
-  }
-
-  const candidates = $derived(
-    $experiences
-      .map(toCandidate)
-      .filter((candidate): candidate is Candidate => candidate !== null)
-      .sort((a, b) => placementRank(a.placement) - placementRank(b.placement)),
-  )
-
-  // Referencing `$conditionResults` keeps this recompute reactive to late condition writes
-  // (the standalone cache-miss path), so a `peek` that returned `undefined` re-renders once
-  // the async evaluation resolves and writes the store. An active `replace` experience wins:
-  // the first one (it sorts first) renders alone, replacing any other slot matches.
-  const active = $derived.by(() => {
-    void $conditionResults
-    const activeCandidates = candidates.filter(
-      (candidate) => client.conditionResults.peek(candidate.hash) === true,
-    )
-    const firstReplace = activeCandidates.find((candidate) => candidate.placement === 'replace')
-    return firstReplace ? [firstReplace] : activeCandidates
-  })
-
-  /**
-   * Builds a plain, JSON-serialisable subset of the current URL for the evaluation context.
-   * The live `Location` object is intentionally not passed: json-logic predicates read plain
-   * values, and this mirrors the `SerializeLocation` shape the server selects against.
-   *
-   * @returns {Record<string, string>} The plain location subset.
-   * @example
-   * buildLocationContext()
-   */
-  function buildLocationContext(): Record<string, string> {
-    const { href, pathname, search, hostname, origin, protocol, port, host, hash } = window.location
-    return { href, pathname, search, hostname, origin, protocol, port, host, hash }
-  }
-
-  $effect(() => {
-    for (const candidate of candidates) {
-      if (client.conditionResults.peek(candidate.hash) === undefined) {
-        void evaluateConditionMemo(client, candidate.condition, {
-          context: { location: buildLocationContext() },
-        })
-      }
-    }
-  })
-</script>
-
-{#each active as candidate (candidate.experience.id)}
-  <ExperienceHost experience={candidate.experience} {client} />
-{/each}

package/dist/experience/HtmlRender.svelte

@@ -1,52 +0,0 @@
-<script lang="ts">
-  /**
-   * @file Renders a resolved html-asset field into a shadow root and re-executes its
-   * Picked-tagged scripts. On the server the markup is emitted as a declarative shadow DOM
-   * template, a parser-only feature the browser attaches as a real shadow root while parsing
-   * the response, so content is present from first paint. On the client, the first commit
-   * adopts that parser-attached root and only rehydrates its scripts; a client-only mount or a
-   * later content change attaches and writes the shadow root imperatively instead.
-   */
-  import {
-    isHtmlAssetValue,
-    rehydrateScripts,
-    supportsShadowRoot,
-    supportsWindow,
-  } from '@picked/client'
-
-  interface Props {
-    /** The resolved html-asset field value (for example `content.body`). */
-    html: unknown
-  }
-
-  const { html }: Props = $props()
-
-  const value = $derived(isHtmlAssetValue(html) ? html : null)
-  const markup = $derived(value?.content ?? '')
-  const serverMarkup = $derived(
-    supportsWindow() ? '' : `<template shadowrootmode="open">${markup}</template>`,
-  )
-
-  let host = $state<HTMLDivElement>()
-  let seeded = false
-
-  $effect(() => {
-    if (!supportsShadowRoot() || !host) return
-
-    const existingShadow = host.shadowRoot
-    const isFirstRun = !seeded
-    seeded = true
-
-    if (existingShadow && isFirstRun) {
-      if (markup) void rehydrateScripts(existingShadow)
-      return
-    }
-
-    const shadow = existingShadow ?? host.attachShadow({ mode: 'open' })
-    shadow.innerHTML = markup
-    if (markup) void rehydrateScripts(shadow)
-  })
-</script>
-
-<!-- eslint-disable-next-line svelte/no-at-html-tags -- markup is a trusted, Picked-transformed html-asset field, not arbitrary user input -->
-<div bind:this={host}>{@html serverMarkup}</div>

package/dist/experience/set-picked-context.d.ts

@@ -1,29 +0,0 @@
-import type { CreateClientOptions, Picked } from '@picked/client';
-import { type PickedSnapshot } from '@picked/client/server';
-type SetPickedContextParams = {
-    client: Picked;
-    snapshot?: PickedSnapshot;
-} | {
-    options: CreateClientOptions;
-    snapshot?: PickedSnapshot;
-};
-/**
- * Provides a Picked client to descendant components through Svelte context, starting it in the browser.
- *
- * Call this once at the top of a component's `<script>` so `setContext` and `onMount` run during
- * component initialisation. Pass `options` to create the client and synchronously hydrate it from an
- * optional SSR snapshot (a `versionId` mismatch is tolerated; the client reconciles via `start()`),
- * or pass an existing `client` (such as the app's single global client) to render experiences
- * against it — supply `snapshot` alongside `client` to SSR-seed that shared client rather than
- * creating a second one. In the browser the client is started from `onMount`; `start()` is
- * idempotent, so a client that was already started is left untouched.
- *
- * @param {SetPickedContextParams} params - `{ client, snapshot? }` or `{ options, snapshot? }`.
- * @returns {Picked} The client placed into context.
- * @example
- * setPickedContext({ options })
- * @example
- * setPickedContext({ client: globalClient, snapshot })
- */
-export declare function setPickedContext(params: SetPickedContextParams): Picked;
-export {};

package/dist/experience/set-picked-context.js

@@ -1 +0,0 @@
-import{CLIENT_CONTEXT_KEY as e}from"../context.js";import{onMount as t,setContext as n}from"svelte";import{createClient as r,supportsWindow as i}from"@picked/client";import{registerProjectConfig as a}from"@picked/client/server";function o(e,t){let n=e.session.store.getState().id;e.seededVersionId=t.versionId,a(e,t.projectConfig,{isPreview:!1,sessionId:n}),t.content.forEach(t=>e.registerContent(t)),e.conditionResults.seed(t.conditionResults)}function s(e,t){let n=r(e);return t&&o(n,t),n}function c(r){let a;return`client`in r?(r.snapshot&&o(r.client,r.snapshot),a=r.client):a=s(r.options,r.snapshot),n(e,a),t(()=>{i()&&a.start()}),a}export{c as setPickedContext};

package/dist/form/__tests__/CreateFormHarness.svelte

@@ -1,30 +0,0 @@
-<script lang="ts">
-  // Test-only harness. `createForm` registers option callbacks with `$effect`,
-  // which requires a real component instance — mounting this is how the callback
-  // lifecycle (registration on mount, teardown on unmount) gets exercised.
-  import { untrack } from 'svelte'
-  import type { Store } from 'effector'
-  import { createForm, type FormCallbackOptions } from '../create-form.svelte'
-
-  interface HarnessProps {
-    formId: string
-    title: Store<string>
-    fieldKeys: Store<string[]>
-    options?: FormCallbackOptions
-    imperativeCallback?: () => void
-  }
-
-  const { formId, title, fieldKeys, options, imperativeCallback }: HarnessProps = $props()
-
-  // Props are read once, at init, on purpose: the harness is mounted with fixed
-  // props to exercise registration and teardown, and `createForm` itself is an
-  // init-time call. `untrack` states that intent rather than suppressing the
-  // state_referenced_locally warning.
-  untrack(() => {
-    const instance = createForm(formId, title, fieldKeys, options)
-
-    if (imperativeCallback) {
-      instance.form.onSuccess(imperativeCallback)
-    }
-  })
-</script>

package/dist/form/create-form.js

@@ -1 +0,0 @@
-import{getExperience as e,getPicked as t}from"../hooks/client.js";import{createForm as n}from"@picked/client/form";import*as r from"svelte/internal/client";function i(i,a,o,s){let c=n({client:t(),experienceInstance:e()},i,a,o);if(s?.onBeforeSubmit){let e=s.onBeforeSubmit;r.user_effect(()=>c.form.onBeforeSubmit(e))}if(s?.onSuccess){let e=s.onSuccess;r.user_effect(()=>c.form.onSuccess(e))}if(s?.onError){let e=s.onError;r.user_effect(()=>c.form.onError(e))}return{...c,form:{...c.form,props:{...c.form.props,onsubmit:e=>c.form.props.onsubmit(e)},onBeforeSubmit:e=>{r.user_effect(()=>c.form.onBeforeSubmit(e))},onSuccess:e=>{r.user_effect(()=>c.form.onSuccess(e))},onError:e=>{r.user_effect(()=>c.form.onError(e))}}}}export{i as createForm};

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

@@ -1,40 +0,0 @@
-/** @file Svelte wrapper for createForm — lifecycle management and plain-function event handlers. */
-import type { Store } from 'effector';
-import { type FormInstance as CoreFormInstance, type ErrorCallback, type FormCallbackOptions, type SubmitCallback, type SubmitEventWithCurrentTarget, type SuccessCallback } from '@picked/client/form';
-export type { FormField, FormCallbackOptions } from '@picked/client/form';
-/**
- * Svelte FormInstance — identical to core but callback registration returns void
- * (cleanup is handled automatically via $effect, not by the consumer).
- */
-export interface FormInstance<TFieldKeys extends string = string> extends Omit<CoreFormInstance<TFieldKeys>, 'form'> {
-    form: Omit<CoreFormInstance<TFieldKeys>['form'], 'onBeforeSubmit' | 'onSuccess' | 'onError' | 'props'> & {
-        props: {
-            onsubmit: (e: SubmitEventWithCurrentTarget) => void;
-        };
-        onBeforeSubmit: (callback: SubmitCallback<TFieldKeys>) => void;
-        onSuccess: (callback: SuccessCallback<TFieldKeys>) => void;
-        onError: (callback: ErrorCallback) => void;
-    };
-}
-/**
- * Creates a form instance with Svelte lifecycle management.
- *
- * Wraps the framework-agnostic createForm from `@picked/client/form`:
- * - Injects client and experienceInstance from Svelte context.
- * - Wraps `form.props.onsubmit` as a plain function (not an Effector EventCallable).
- * - Auto-wires callback cleanup via `$effect` so consumers don't need to manage lifecycle.
- *
- * Used internally by setStepContext — access via getStep() in components.
- *
- * @param {string} formId - Unique identifier for this form instance.
- * @param {Store<string>} title - Reactive store holding the form/step title.
- * @param {Store<string[]>} fieldKeys - Reactive store of field keys that belong to this form.
- * @param {FormCallbackOptions} [options] - Submit callback slots, registered once for the component's lifetime.
- * @returns {FormInstance} A form instance with reactive field stores, submission handlers, and callback registration.
- * @example
- * ```ts
- * const { form, fields } = createForm('lead-capture', $title, $fieldKeys, { onSuccess })
- * ```
- * @design-parity Mirrors `useForm`'s options argument in `@picked/react`.
- */
-export declare function createForm(formId: string, title: Store<string>, fieldKeys: Store<string[]>, options?: FormCallbackOptions): FormInstance;

package/dist/form/create-form.svelte.js

@@ -1 +0,0 @@
-export * from './create-form.js';

package/dist/form/get-form.d.ts

@@ -1,30 +0,0 @@
-/** @file Legacy getForm() helper — imperative form submission with callback-based lifecycle. */
-import type { 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;
-};
-/**
- * Creates a form submission handler with imperative callback lifecycle.
- *
- * Wires an Effector pipeline that builds responses from FormData and commits them.
- * Unhandled commit failures are surfaced via the onError callback.
- *
- * @param {GetFormOptions} options - Form configuration including callbacks.
- * @returns {object} An object with the form submit event to spread onto a form element.
- * @example
- * ```ts
- * const { form } = getForm({ id: 'lead', title: 'Lead Capture', onSuccess: () => {} })
- * ```
- */
-export declare function getForm({ id: formId, title, onError, onSuccess }: GetFormOptions): {
-    form: {
-        onsubmit: import("effector").EventCallable<SubmitEventWithCurrentTarget>;
-    };
-};
-export {};

package/dist/form/get-form.js

@@ -1 +0,0 @@
-import{getExperience as e,getPicked as t}from"../hooks/client.js";import{getStep as n}from"../hooks/step.js";import"../hooks/index.js";import{buildResponsesFromFormData as r}from"@picked/client/form";import{attach as i,createEffect as a,createEvent as o,sample as s,split as c}from"effector";function l({id:l,title:u,onError:d,onSuccess:f}){let p=t(),m=n(),h=e(),{currentStepStore:g}=h,_=o(),v=a(e=>p.responses.commit(e)),y=i({source:{step:g},effect:a(({step:e})=>{p.eventBus({type:`form_submit_success`,form:{id:l,title:u},experience:h,step:e??void 0}),f?.()})}),b=i({source:{step:g},mapParams:(e,t)=>({step:t.step,errors:e.errors}),effect:a(({step:e,errors:t})=>{p.eventBus({type:`form_submit_error`,form:{id:l,title:u},exception:{reason:t},experience:h,step:e??void 0}),t.forEach(t=>{p.eventBus({type:`field_validation_error`,exception:{reason:[t]},experience:h,step:e??void 0})}),d?.(t)})});return s({clock:_,source:{step:g},fn:({step:e})=>({formId:l,title:u,step:e}),target:a(({formId:e,title:t,step:n})=>{p.eventBus({type:`form_submit`,form:{id:e,title:t},experience:h,step:n??void 0})})}),s({clock:_,source:{fields:p.fields.listStore,stepFields:m.fields,step:g},fn:({stepFields:e},t)=>(t.preventDefault(),r(e,new FormData(t.currentTarget))),target:v}),c({source:v.doneData,match:{hasErrors:({errors:e})=>e.length>0},cases:{hasErrors:b,__:y}}),s({clock:v.fail,fn:({error:e})=>({errors:[{fieldKey:``,userMessage:`An unexpected error occurred`,systemMessage:e instanceof Error?e.message:String(e),value:null}]}),target:b}),{form:{onsubmit:_}}}export{l as getForm};

package/dist/hooks/action.d.ts

@@ -1,40 +0,0 @@
-/** @file Svelte hooks for consuming registered actions from the Picked client. */
-import { type Action, type ActionKeys, type ExperienceInstance } from '@picked/client';
-import { type Store } from 'effector';
-/**
- * Returns the reactive evokable action store for the given action key.
- *
- * When `options.experience` is provided, the wrapped call passes that
- * experience as the action's context, so manually-invoked handlers can
- * behave as if they were triggered by that experience — for example to
- * call `context.experience.close()` after a submit.
- *
- * @param {ActionKeys} actionKey - Action key from the workspace schema.
- * @param {object} [options] - Optional invocation overrides.
- * @param {ExperienceInstance} options.experience - Experience to bind as the action's context.
- * @returns {Store<() => ReturnType<Action>>} A store containing the callable action function or undefined.
- * @example
- * ```ts
- * const actionStore = getAction('log-event')
- * const bound = getAction('submit-form', { experience: getExperience() })
- * ```
- */
-export declare function getAction(actionKey: ActionKeys, options?: {
-    experience: ExperienceInstance;
-}): Store<() => ReturnType<Action>>;
-/**
- * Returns a reactive store holding the latest result of invoking the keyed action.
- * Re-evaluates automatically when the underlying action store updates.
- *
- * @param {ActionKeys} actionKey - Action key from the workspace schema.
- * @param {object} [options] - Optional invocation overrides.
- * @param {ExperienceInstance} options.experience - Experience to bind as the action's context.
- * @returns {Store<string | string[] | boolean | void | undefined>} A store containing the latest action return value.
- * @example
- * ```ts
- * const result = getActionResult('is-logged-in')
- * ```
- */
-export declare function getActionResult(actionKey: ActionKeys, options?: {
-    experience: ExperienceInstance;
-}): import("effector").StoreWritable<void | string | boolean | string[] | undefined>;

package/dist/hooks/action.js

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

package/dist/hooks/content.d.ts

@@ -1,18 +0,0 @@
-/**
- * @file Svelte lookup helper for the Picked content registry. Mirrors `getField(key)`
- * — returns the registry store, leaving subscription to the consumer.
- */
-import type { Store } from 'effector';
-import { type TypedContent } from '@picked/client';
-/**
- * Returns the registry store for a content id.
- *
- * @template TData
- * @param {string} id - The content record id to look up.
- * @returns {Store<TypedContent<TData> | null>} The registry store; `null` until content is registered.
- * @example
- * ```svelte
- * const banner = getContent<WelcomePage>('lc_banner')
- * ```
- */
-export declare function getContent<TData extends Record<string, unknown> = Record<string, unknown>>(id: string): Store<TypedContent<TData> | null>;

package/dist/hooks/content.js

@@ -1 +0,0 @@
-import{getPicked as e}from"./client.js";import{toTypedContentStore as t}from"@picked/client";function n(n){let r=e();return t(r.contents.getById(n))}export{n as getContent};

package/dist/hooks/create-query/index.d.ts

@@ -1,145 +0,0 @@
-import { type Store } from 'effector';
-interface QueryOptions {
-    refetch?: boolean;
-    staleTime?: number;
-    retry?: number;
-    retryDelay?: number;
-}
-export interface QueryResult<T> {
-    data: Store<T | null>;
-    error: Store<Error | null>;
-    isLoading: Store<boolean>;
-    refetch: () => Promise<T>;
-    invalidate: () => void;
-}
-export type QueryFactory<Params, Results> = (params: Params, queryOptions?: QueryOptions) => QueryResult<Results>;
-/**
- * Effector-powered data fetching helper inspired by [SWR](https://www.npmjs.com/package/swr).
- *
- * It provides:
- * - Request de-duplication per key (in-flight promise reuse)
- * - Stale-while-revalidate caching with per-key timestamps
- * - Automatic retries with exponential backoff
- * - Fine-grained invalidation (per key, per namespace, or global)
- *
- * Behavior overview:
- * - Cache key: built from the `keyFn(params)` within a `namespace` to avoid collisions across domains.
- * - Staleness: when a record is older than `staleTime`, the next read will revalidate in the background.
- * - Deduplication: concurrent reads for the same key share the same promise.
- * - Retries: failures are retried up to `retry` times using exponential backoff starting at `retryDelay` ms.
- *
- * Type parameters:
- * - Params: the shape of parameters passed to the fetcher
- * - Results: the shape of the resolved fetcher result
- *
- * @param fetcher A function that performs the async request and returns a Promise of the result.
- * @param keyFn A function that builds a stable cache key from the provided params.
- *               Use all inputs that affect the result to prevent collisions.
- * @param options Optional configuration applied to all queries created by this factory.
- * @param options.namespace Logical grouping for cache separation. Defaults to "default".
- * @param options.defaultStaleTime Default time in ms before data is considered stale. Defaults to 5 minutes.
- * @param options.defaultRetry Default max retry attempts on failure. Defaults to 3.
- * @param options.defaultRetryDelay Base delay in ms for retries; exponential backoff is applied. Defaults to 1000ms.
- *
- * @returns A QueryFactory(params, queryOptions) that produces QueryResult stores and controls for a specific key.
- *
- * Example: Basic usage with request de-duplication and caching
- * ```typescript
- * type User = { id: string; name: string }
- *
- * async function fetchUser({ id }: { id: string }): Promise<User> {
- *   const res = await fetch(`/api/users/${id}`)
- *   if (!res.ok) throw new Error('Failed to load user')
- *   return res.json()
- * }
- *
- * const userQuery = createQuery(fetchUser, (p) => `user:${p.id}`, {
- *   namespace: 'users',
- *   defaultStaleTime: 60_000, // 1 minute
- *   defaultRetry: 2,
- *   defaultRetryDelay: 500,
- * })
- *
- * // Later in your code (each call uses the same key -> dedup + cache)
- * const { data, error, isLoading, refetch, invalidate } = userQuery({ id: '42' })
- *
- * // Subscribe reactively via Effector API:
- * const stopDataWatch = data.watch((value) => {
- *   console.log('User data changed:', value)
- * })
- * const stopErrorWatch = error.watch((err) => {
- *   if (err) console.error('User query error:', err)
- * })
- * const stopLoadingWatch = isLoading.watch((pending) => {
- *   console.log('Loading:', pending)
- * })
- *
- * // Manually refetch (ignores staleness)
- * refetch()
- *
- * // Invalidate only this key (forces next read to refetch)
- * invalidate()
- *
- * // Clean up watchers when leaving scope
- * stopDataWatch()
- * stopErrorWatch()
- * stopLoadingWatch()
- * ```
- *
- * Example: Per-call overrides (staleTime, retry)
- * ```typescript
- * const fastUserQuery = createQuery(fetchUser, (p) => `user:${p.id}`, {
- *   namespace: 'users',
- *   defaultStaleTime: 5 * 60_000, // 5 minutes
- * })
- *
- * // For this call, we want fresher data and fewer retries:
- * const fast = fastUserQuery({ id: '42' }, { staleTime: 5_000, retry: 1 })
- *
- * // For another call, rely on defaults:
- * const normal = fastUserQuery({ id: '42' })
- * ```
- *
- * Example: Using multiple params in the key
- * ```typescript
- * type ListParams = { page: number; q?: string }
- * const listQuery = createQuery(
- *   async (p: ListParams) => {
- *     const u = new URL('/api/items', window.location.origin)
- *     u.searchParams.set('page', String(p.page))
- *     if (p.q) u.searchParams.set('q', p.q)
- *     const r = await fetch(u)
- *     if (!r.ok) throw new Error('Failed')
- *     return r.json() as Promise<{ items: unknown[]; total: number }>
- *   },
- *   // Include all inputs that affect response:
- *   (p) => `items:page=${p.page}:q=${p.q ?? ''}`,
- *   { namespace: 'items' },
- * )
- * ```
- */
-export declare function createQuery<Params, Results>(fetcher: (params: Params) => Promise<Results>, keyFn: (params: Params) => string, options?: {
-    namespace?: string;
-    defaultStaleTime?: number;
-    defaultRetry?: number;
-    defaultRetryDelay?: number;
-}): QueryFactory<Params, Results>;
-export declare const queryCache: {
-    invalidate: (namespace: string, key?: string) => void;
-    clear: () => void;
-};
-export declare const queryPresets: {
-    realtime: {
-        defaultStaleTime: number;
-        defaultRetry: number;
-    };
-    standard: {
-        defaultStaleTime: number;
-        defaultRetry: number;
-    };
-    static: {
-        defaultStaleTime: number;
-        defaultRetry: number;
-    };
-};
-export {};

package/dist/hooks/create-query/index.js

@@ -1 +0,0 @@
-import{createEffect as e,createStore as t,sample as n}from"effector";var r=new Map;function i(e){return r.has(e)||r.set(e,new Map),r.get(e)}function a(e,t){let n=i(e).get(t);n&&(n.promise=null,n.timestamp=0)}function o(e){i(e).forEach(e=>{e.promise=null,e.timestamp=0})}function s(){r.clear()}function c(r,o,s={}){let{namespace:c=`default`,defaultStaleTime:u=3e5,defaultRetry:d=3,defaultRetryDelay:f=1e3}=s,p=i(c),m=e(async e=>{let{key:t,params:n,options:i}=e,a=p.get(t)?.promise,o=p.get(t),s=i.refetch||!a||o&&Date.now()-o.timestamp>(i.staleTime??o.staleTime);if(!a||s){a=l(()=>r(n),i.retry??d,i.retryDelay??f);let e=p.get(t);e&&(e.promise=a,e.timestamp=Date.now(),e.staleTime=i.staleTime??u)}return{key:t,promise:a,result:await a}});return(r,i={})=>{let s=o(r),l=p.get(s);l||(l={promise:null,data:t(null),error:t(null),isLoading:t(!1),timestamp:0,staleTime:i.staleTime??u},p.set(s,l));let d=e(e=>e);return n({source:m.doneData,filter:e=>e.key===s,fn:e=>e.promise,target:d}),l.isLoading.on(m.pending,(e,t)=>t),l.isLoading.on(d.pending,(e,t)=>t),l.data.on(d.doneData,(e,t)=>t),l.error.on(d.doneData,()=>null),l.error.on(d.failData,(e,t)=>t),l.error.on(m.failData,(e,t)=>t),(!l.promise||Date.now()-l.timestamp>l.staleTime)&&m({key:s,params:r,options:i}),{data:l.data,error:l.error,isLoading:l.isLoading,refetch:()=>m({key:s,params:r,options:{...i,refetch:!0}}).then(({result:e})=>e),invalidate:()=>a(c,s)}}}async function l(e,t,n){let r;for(let i=0;i<=t;i++)try{return await e()}catch(e){r=e instanceof Error?e:Error(String(e)),i<t&&await new Promise(e=>{setTimeout(e,n*2**i)})}throw r}var u={invalidate:(e,t)=>{t?a(e,t):o(e)},clear:()=>s()},d={realtime:{defaultStaleTime:5e3,defaultRetry:1},standard:{defaultStaleTime:3e5,defaultRetry:3},static:{defaultStaleTime:36e5,defaultRetry:2}};export{c as createQuery,u as queryCache,d as queryPresets};

package/dist/hooks/events.d.ts

@@ -1,2 +0,0 @@
-import type { AnalyticsProductList } from '@picked/analytics';
-export declare const getTrackRecommendationPresentEvent: () => import("effector").Effect<AnalyticsProductList, void, Error>;

package/dist/hooks/events.js

@@ -1 +0,0 @@
-import{getExperience as e,getPicked as t}from"./client.js";import{attach as n}from"effector";import{trackRecommendationPresentEvent as r}from"@picked/analytics";var i=()=>{let{session:i,projectId:a}=t(),o=e();return n({source:{config:o.configStore,step:o.currentStepStore,sessionSnapshot:i.store},async effect({config:e,step:t,sessionSnapshot:n},i){if(!t)throw Error(`Cannot track recommendation present event: missing experience step.`);return r({projectId:a,experience:{id:o.experienceId,title:e.name},sessionId:n.id,identifiers:n.identifiers,isUser:n.isUser,step:t,productList:i})}})};export{i as getTrackRecommendationPresentEvent};

package/dist/hooks/feature.d.ts

@@ -1,47 +0,0 @@
-/**
- * @file Svelte hooks for accessing feature flag evaluation from the Picked client.
- */
-import type { Store } from 'effector';
-import type { FeatureKeys, FeatureResult, FeatureValueFor } from '@picked/client';
-type FeatureBucketValue = boolean | string | undefined;
-/**
- * Returns the reactive store wrapping a feature in an evokable function.
- *
- * @param {FeatureKeys} featureName - Feature key from the workspace schema.
- * @returns {Store<() => Promise<FeatureBucketValue>>} The evokable-feature store.
- * @example
- * const $evokable = getFeature('winter-sale')
- */
-export declare function getFeature(featureName: FeatureKeys): Store<() => Promise<FeatureBucketValue>>;
-/**
- * Returns a store that resolves to a feature's evaluated bucket result.
- *
- * The evaluation wiring belongs to the client, which builds it once per feature and
- * resolves it once, so repeated calls share one store instead of growing the graph.
- *
- * The key type is inferred from the argument, so a workspace-known text feature narrows
- * its `bucket` to that feature's declared arms.
- *
- * @template K
- * @param {K} featureName - Feature key from the workspace schema.
- * @returns {Store<FeatureResult<FeatureValueFor<K>> | undefined>} A store holding the resolved bucket result, or undefined until resolved.
- * @example
- * const $result = getFeatureResult('winter-sale')
- */
-export declare function getFeatureResult<K extends FeatureKeys>(featureName: K): Store<FeatureResult<FeatureValueFor<K>> | undefined>;
-/**
- * Returns a store holding a feature's admin `enabled` flag.
- *
- * Unlike {@link getFeatureResult}, this reads the static config flag directly and does not
- * trigger bucket resolution — so a disabled feature (`enabled: false`) can be told apart
- * from an enabled feature whose session simply was not allocated. Resolves to `undefined`
- * when the feature is unregistered or carries no `enabled` metadata (for example,
- * manually-registered features).
- *
- * @param {FeatureKeys} featureName - Feature key from the workspace schema.
- * @returns {Store<boolean | undefined>} A store holding the feature's `enabled` flag, or undefined when unknown.
- * @example
- * const $enabled = getFeatureEnabled('winter-sale')
- */
-export declare function getFeatureEnabled(featureName: FeatureKeys): Store<boolean | undefined>;
-export {};

package/dist/hooks/feature.js

@@ -1 +0,0 @@
-import{getPicked as e}from"./client.js";function t(t){return e().features.getEvokableFeature(t)}function n(t){return e().features.getFeatureResult(t)}function r(t){return e().features.getById(t).map(e=>e?.enabled,{skipVoid:!1})}export{t as getFeature,r as getFeatureEnabled,n as getFeatureResult};

package/dist/hooks/predicate.d.ts

@@ -1,3 +0,0 @@
-import { type 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

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