fict 0.1.0 → 0.2.1

package/src/resource.ts

@@ -1,42 +1,177 @@
+/**
+ * @fileoverview Async data fetching with caching and Suspense support.
+ *
+ * The `resource` function creates a reactive data fetcher that:
+ * - Automatically cancels in-flight requests when args change
+ * - Supports Suspense for loading states
+ * - Provides caching with TTL and stale-while-revalidate
+ * - Handles errors gracefully
+ */
+
 import { createEffect, onCleanup, createSuspenseToken } from '@fictjs/runtime'
 import { createSignal } from '@fictjs/runtime/advanced'
 
+/**
+ * The result of reading a resource.
+ *
+ * @typeParam T - The type of data returned by the fetcher
+ */
 export interface ResourceResult<T> {
-  data: T | undefined
-  loading: boolean
-  error: unknown
+  /** The fetched data, or undefined if not yet loaded or on error */
+  readonly data: T | undefined
+  /** Whether the resource is currently loading (initial fetch or refetch) */
+  readonly loading: boolean
+  /**
+   * Any error that occurred during fetching.
+   * Type is unknown since errors can be any value in JavaScript.
+   */
+  readonly error: unknown
+  /** Manually trigger a refetch of the resource */
   refresh: () => void
 }
 
+/**
+ * Cache configuration options for a resource.
+ */
 export interface ResourceCacheOptions {
+  /**
+   * Caching mode:
+   * - `'memory'`: Cache responses in memory (default)
+   * - `'none'`: No caching, always refetch
+   * @default 'memory'
+   */
   mode?: 'memory' | 'none'
+
+  /**
+   * Time-to-live in milliseconds before cached data is considered stale.
+   * @default Infinity
+   */
   ttlMs?: number
+
+  /**
+   * If true, return stale cached data immediately while refetching in background.
+   * @default false
+   */
   staleWhileRevalidate?: boolean
+
+  /**
+   * If true, cache error responses as well.
+   * @default false
+   */
   cacheErrors?: boolean
 }
 
+/**
+ * Configuration options for creating a resource.
+ *
+ * @typeParam T - The type of data returned by the fetcher
+ * @typeParam Args - The type of arguments passed to the fetcher
+ */
 export interface ResourceOptions<T, Args> {
-  key?: unknown
+  /**
+   * Custom cache key. Can be a static value or a function that computes
+   * the key from the args. If not provided, args are used as the key.
+   */
+  key?: unknown | ((args: Args) => unknown)
+
+  /**
+   * The fetcher function that performs the async data retrieval.
+   * Receives an AbortController signal for cancellation support.
+   */
   fetch: (ctx: { signal: AbortSignal }, args: Args) => Promise<T>
+
+  /**
+   * If true, the resource will throw a Suspense token while loading,
+   * enabling React-like Suspense boundaries.
+   * @default false
+   */
   suspense?: boolean
+
+  /**
+   * Cache configuration options.
+   */
   cache?: ResourceCacheOptions
+
+  /**
+   * A value or reactive getter that, when changed, resets the resource.
+   * Useful for clearing cache when certain conditions change.
+   */
   reset?: unknown | (() => unknown)
 }
 
+/**
+ * Return type of the resource factory.
+ *
+ * @typeParam T - The type of data returned by the fetcher
+ * @typeParam Args - The type of arguments passed to the fetcher
+ */
+export interface Resource<T, Args> {
+  /**
+   * Read the resource data, triggering a fetch if needed.
+   * Can accept static args or a reactive getter.
+   *
+   * @param argsAccessor - Arguments or a getter returning arguments
+   */
+  read(argsAccessor: (() => Args) | Args): ResourceResult<T>
+
+  /**
+   * Invalidate cached data, causing the next read to refetch.
+   *
+   * @param key - Optional specific key to invalidate. If omitted, invalidates all.
+   */
+  invalidate(key?: unknown): void
+
+  /**
+   * Prefetch data without reading it. Useful for eager loading.
+   *
+   * @param args - Arguments to pass to the fetcher
+   * @param keyOverride - Optional cache key override
+   */
+  prefetch(args: Args, keyOverride?: unknown): void
+}
+
+/**
+ * Resource status values for tracking fetch lifecycle.
+ * @internal
+ */
+export type ResourceStatus = 'idle' | 'pending' | 'success' | 'error'
+
+/**
+ * Internal cache entry for a resource.
+ * Tracks the reactive state and metadata for a single cached fetch.
+ *
+ * @typeParam T - The type of data returned by the fetcher
+ * @typeParam Args - The type of arguments passed to the fetcher
+ * @internal
+ */
 interface ResourceEntry<T, Args> {
+  /** Reactive signal for the fetched data */
   data: ReturnType<typeof createSignal<T | undefined>>
+  /** Reactive signal for loading state */
   loading: ReturnType<typeof createSignal<boolean>>
+  /** Reactive signal for error state */
   error: ReturnType<typeof createSignal<unknown>>
+  /** Version counter for invalidation */
   version: ReturnType<typeof createSignal<number>>
+  /** Suspense token when using suspense mode */
   pendingToken: ReturnType<typeof createSuspenseToken> | null
+  /** Last used arguments for change detection */
   lastArgs: Args | undefined
+  /** Last seen version for change detection */
   lastVersion: number
+  /** Last reset token value for change detection */
   lastReset: unknown
+  /** Whether we have a valid cached value */
   hasValue: boolean
-  status: 'idle' | 'pending' | 'success' | 'error'
+  /** Current fetch status */
+  status: ResourceStatus
+  /** Generation counter to handle race conditions */
   generation: number
+  /** Timestamp when the cached value expires */
   expiresAt: number | undefined
+  /** Currently in-flight fetch promise */
   inFlight: Promise<void> | undefined
+  /** AbortController for cancelling in-flight requests */
   controller: AbortController | undefined
 }
 
@@ -48,15 +183,52 @@ const defaultCacheOptions: Required<ResourceCacheOptions> = {
 }
 
 /**
- * Creates a resource factory that can be read with arguments.
+ * Create a reactive async data resource.
+ *
+ * Resources handle async data fetching with automatic caching, cancellation,
+ * and optional Suspense integration.
+ *
+ * @param optionsOrFetcher - A fetcher function or full configuration object
+ * @returns A resource factory with read, invalidate, and prefetch methods
+ *
+ * @example
+ * ```tsx
+ * import { resource } from 'fict'
+ *
+ * // Simple fetcher
+ * const userResource = resource(
+ *   ({ signal }, userId: string) =>
+ *     fetch(`/api/users/${userId}`, { signal }).then(r => r.json())
+ * )
+ *
+ * // With full options
+ * const postsResource = resource({
+ *   fetch: ({ signal }, userId: string) =>
+ *     fetch(`/api/users/${userId}/posts`, { signal }).then(r => r.json()),
+ *   suspense: true,
+ *   cache: {
+ *     ttlMs: 60_000,
+ *     staleWhileRevalidate: true,
+ *   },
+ * })
+ *
+ * // Usage in component
+ * function UserProfile({ userId }: { userId: string }) {
+ *   const { data, loading, error, refresh } = userResource.read(() => userId)
+ *
+ *   if (loading) return <Spinner />
+ *   if (error) return <ErrorMessage error={error} />
+ *   return <div>{data.name}</div>
+ * }
+ * ```
  *
- * @param optionsOrFetcher - Configuration object or fetcher function
+ * @public
  */
 export function resource<T, Args = void>(
   optionsOrFetcher:
     | ((ctx: { signal: AbortSignal }, args: Args) => Promise<T>)
     | ResourceOptions<T, Args>,
-) {
+): Resource<T, Args> {
   const fetcher = typeof optionsOrFetcher === 'function' ? optionsOrFetcher : optionsOrFetcher.fetch
   const useSuspense = typeof optionsOrFetcher === 'object' && !!optionsOrFetcher.suspense
   const cacheOptions: ResourceCacheOptions =

package/src/slim.ts

@@ -0,0 +1,25 @@
+/**
+ * @fileoverview Fict Slim entrypoint
+ *
+ * Exposes compiler macros only. Intended for users who want the smallest
+ * runtime surface and rely on the compiler to erase macro calls.
+ *
+ * @public
+ * @packageDocumentation
+ */
+
+/**
+ * Compiler macro for reactive state.
+ * This is transformed at compile time and should never be called at runtime.
+ */
+export function $state<T>(_initialValue: T): T {
+  throw new Error('$state() is a compiler macro and should be transformed at compile time')
+}
+
+/**
+ * Compiler macro for reactive effects.
+ * This is transformed at compile time and should never be called at runtime.
+ */
+export function $effect(_fn: () => void | (() => void)): void {
+  throw new Error('$effect() is a compiler macro and should be transformed at compile time')
+}

package/src/store.ts

@@ -1,16 +1,46 @@
+/**
+ * @fileoverview Deep reactive store implementation for Fict.
+ *
+ * $store creates a deeply reactive proxy that tracks property access at the path level.
+ * Unlike $state (which is shallow), $store allows direct mutation of nested properties.
+ *
+ * @example
+ * ```typescript
+ * const user = $store({ name: 'Alice', address: { city: 'London' } })
+ * user.address.city = 'Paris' // Fine-grained reactive update
+ * ```
+ */
+
 import { createSignal, type Signal } from '@fictjs/runtime/advanced'
 
+/** Function type for bound methods */
 type AnyFn = (...args: unknown[]) => unknown
+
+/** Cache entry for bound methods to preserve identity */
 interface BoundMethodEntry {
   ref: AnyFn
   bound: AnyFn
 }
 
+/** Type for objects with indexable properties */
+type IndexableObject = Record<string | symbol, unknown>
+
+/** Cache of proxied objects to avoid duplicate proxies */
 const PROXY_CACHE = new WeakMap<object, unknown>()
+
+/** Cache of signals per object property */
 const SIGNAL_CACHE = new WeakMap<object, Record<string | symbol, Signal<unknown>>>()
+
+/** Cache of bound methods to preserve function identity across reads */
 const BOUND_METHOD_CACHE = new WeakMap<object, Map<string | symbol, BoundMethodEntry>>()
+
+/** Special key for tracking iteration (Object.keys, for-in, etc.) */
 const ITERATE_KEY = Symbol('iterate')
 
+/**
+ * Get or create a signal for a specific property on a target object.
+ * @internal
+ */
 function getSignal(target: object, prop: string | symbol): Signal<unknown> {
   let signals = SIGNAL_CACHE.get(target)
   if (!signals) {
@@ -18,13 +48,17 @@ function getSignal(target: object, prop: string | symbol): Signal<unknown> {
     SIGNAL_CACHE.set(target, signals)
   }
   if (!signals[prop]) {
-    const initial = prop === ITERATE_KEY ? 0 : (target as Record<string | symbol, unknown>)[prop]
+    const initial = prop === ITERATE_KEY ? 0 : (target as IndexableObject)[prop]
     signals[prop] = createSignal(initial)
   }
   return signals[prop]
 }
 
-function triggerIteration(target: object) {
+/**
+ * Trigger iteration signal to notify consumers that keys have changed.
+ * @internal
+ */
+function triggerIteration(target: object): void {
   const signals = SIGNAL_CACHE.get(target)
   if (signals && signals[ITERATE_KEY]) {
     const current = signals[ITERATE_KEY]() as number
@@ -32,6 +66,35 @@ function triggerIteration(target: object) {
   }
 }
 
+/**
+ * Create a deep reactive store using Proxy.
+ *
+ * Unlike `$state` (which is shallow and compiler-transformed), `$store` provides:
+ * - **Deep reactivity**: Nested objects are automatically wrapped in proxies
+ * - **Direct mutation**: Modify properties directly without spread operators
+ * - **Path-level tracking**: Only components reading changed paths re-render
+ *
+ * @param initialValue - The initial object to make reactive
+ * @returns A reactive proxy of the object
+ *
+ * @example
+ * ```tsx
+ * import { $store } from 'fict'
+ *
+ * const form = $store({
+ *   user: { name: '', email: '' },
+ *   settings: { theme: 'light' }
+ * })
+ *
+ * // Direct mutation works
+ * form.user.name = 'Alice'
+ *
+ * // In JSX - only updates when form.user.name changes
+ * <input value={form.user.name} />
+ * ```
+ *
+ * @public
+ */
 export function $store<T extends object>(initialValue: T): T {
   if (typeof initialValue !== 'object' || initialValue === null) {
     return initialValue
@@ -82,6 +145,7 @@ export function $store<T extends object>(initialValue: T): T {
     },
 
     set(target, prop, newValue, receiver) {
+      const oldLength = Array.isArray(target) && prop === 'length' ? target.length : undefined
       const oldValue = Reflect.get(target, prop, receiver)
       const hadKey = Object.prototype.hasOwnProperty.call(target, prop)
 
@@ -114,13 +178,24 @@ export function $store<T extends object>(initialValue: T): T {
       if (Array.isArray(target) && prop !== 'length') {
         const signals = SIGNAL_CACHE.get(target)
         if (signals && signals.length) {
-          signals.length((target as unknown as { length: number }).length)
+          signals.length(target.length)
         }
       }
 
       // If it's an array and length changed implicitly, we might need to handle it.
-      // But usually 'length' is set explicitly or handled by the runtime.
       if (Array.isArray(target) && prop === 'length') {
+        const nextLength = target.length
+        if (typeof oldLength === 'number' && nextLength < oldLength) {
+          const signals = SIGNAL_CACHE.get(target)
+          if (signals) {
+            for (let i = nextLength; i < oldLength; i += 1) {
+              const key = String(i)
+              if (signals[key]) {
+                signals[key](undefined)
+              }
+            }
+          }
+        }
         triggerIteration(target)
       }
 

package/dist/chunk-5AWNWCDT.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/store.ts"],"names":["signals"],"mappings":";;;AAQA,IAAM,WAAA,uBAAkB,OAAA,EAAyB;AACjD,IAAM,YAAA,uBAAmB,OAAA,EAA0D;AACnF,IAAM,kBAAA,uBAAyB,OAAA,EAAwD;AACvF,IAAM,WAAA,GAAc,OAAO,SAAS,CAAA;AAEpC,SAAS,SAAA,CAAU,QAAgB,IAAA,EAAwC;AACzE,EAAA,IAAI,OAAA,GAAU,YAAA,CAAa,GAAA,CAAI,MAAM,CAAA;AACrC,EAAA,IAAI,CAAC,OAAA,EAAS;AACZ,IAAA,OAAA,GAAU,EAAC;AACX,IAAA,YAAA,CAAa,GAAA,CAAI,QAAQ,OAAO,CAAA;AAAA,EAClC;AACA,EAAA,IAAI,CAAC,OAAA,CAAQ,IAAI,CAAA,EAAG;AAClB,IAAA,MAAM,OAAA,GAAU,IAAA,KAAS,WAAA,GAAc,CAAA,GAAK,OAA4C,IAAI,CAAA;AAC5F,IAAA,OAAA,CAAQ,IAAI,CAAA,GAAI,YAAA,CAAa,OAAO,CAAA;AAAA,EACtC;AACA,EAAA,OAAO,QAAQ,IAAI,CAAA;AACrB;AAEA,SAAS,iBAAiB,MAAA,EAAgB;AACxC,EAAA,MAAM,OAAA,GAAU,YAAA,CAAa,GAAA,CAAI,MAAM,CAAA;AACvC,EAAA,IAAI,OAAA,IAAW,OAAA,CAAQ,WAAW,CAAA,EAAG;AACnC,IAAA,MAAM,OAAA,GAAU,OAAA,CAAQ,WAAW,CAAA,EAAE;AACrC,IAAA,OAAA,CAAQ,WAAW,CAAA,CAAE,OAAA,GAAU,CAAC,CAAA;AAAA,EAClC;AACF;AAEO,SAAS,OAAyB,YAAA,EAAoB;AAC3D,EAAA,IAAI,OAAO,YAAA,KAAiB,QAAA,IAAY,YAAA,KAAiB,IAAA,EAAM;AAC7D,IAAA,OAAO,YAAA;AAAA,EACT;AAEA,EAAA,IAAI,WAAA,CAAY,GAAA,CAAI,YAAY,CAAA,EAAG;AACjC,IAAA,OAAO,WAAA,CAAY,IAAI,YAAY,CAAA;AAAA,EACrC;AAEA,EAAA,MAAM,KAAA,GAAQ,IAAI,KAAA,CAAM,YAAA,EAAc;AAAA,IACpC,GAAA,CAAI,MAAA,EAAQ,IAAA,EAAM,QAAA,EAAU;AAG1B,MAAA,MAAM,MAAA,GAAS,SAAA,CAAU,MAAA,EAAQ,IAAI,CAAA;AACrC,MAAA,MAAM,eAAe,MAAA,EAAO;AAE5B,MAAA,MAAM,eAAe,OAAA,CAAQ,GAAA,CAAI,MAAA,EAAQ,IAAA,EAAM,YAAY,KAAK,CAAA;AAChE,MAAA,IAAI,iBAAiB,YAAA,EAAc;AAIjC,QAAA,MAAA,CAAO,YAAY,CAAA;AAAA,MACrB;AAEA,MAAA,IAAI,OAAO,iBAAiB,UAAA,EAAY;AACtC,QAAA,IAAI,YAAA,GAAe,kBAAA,CAAmB,GAAA,CAAI,MAAM,CAAA;AAChD,QAAA,IAAI,CAAC,YAAA,EAAc;AACjB,UAAA,YAAA,uBAAmB,GAAA,EAAI;AACvB,UAAA,kBAAA,CAAmB,GAAA,CAAI,QAAQ,YAAY,CAAA;AAAA,QAC7C;AACA,QAAA,MAAM,MAAA,GAAS,YAAA,CAAa,GAAA,CAAI,IAAI,CAAA;AACpC,QAAA,IAAI,MAAA,IAAU,MAAA,CAAO,GAAA,KAAQ,YAAA,EAAc;AACzC,UAAA,OAAO,MAAA,CAAO,KAAA;AAAA,QAChB;AAEA,QAAA,MAAM,KAAA,GAAS,YAAA,CAAuB,IAAA,CAAK,QAAA,IAAY,KAAK,CAAA;AAC5D,QAAA,YAAA,CAAa,IAAI,IAAA,EAAM,EAAE,GAAA,EAAK,YAAA,EAAuB,OAAO,CAAA;AAC5D,QAAA,OAAO,KAAA;AAAA,MACT;AAGA,MAAA,IAAI,OAAO,YAAA,KAAiB,QAAA,IAAY,YAAA,KAAiB,IAAA,EAAM;AAC7D,QAAA,OAAO,OAAO,YAAuC,CAAA;AAAA,MACvD;AAGA,MAAA,OAAO,YAAA;AAAA,IACT,CAAA;AAAA,IAEA,GAAA,CAAI,MAAA,EAAQ,IAAA,EAAM,QAAA,EAAU,QAAA,EAAU;AACpC,MAAA,MAAM,QAAA,GAAW,OAAA,CAAQ,GAAA,CAAI,MAAA,EAAQ,MAAM,QAAQ,CAAA;AACnD,MAAA,MAAM,SAAS,MAAA,CAAO,SAAA,CAAU,cAAA,CAAe,IAAA,CAAK,QAAQ,IAAI,CAAA;AAGhE,MAAA,IAAI,QAAA,KAAa,YAAY,MAAA,EAAQ;AACnC,QAAA,OAAO,IAAA;AAAA,MACT;AAEA,MAAA,MAAM,SAAS,OAAA,CAAQ,GAAA,CAAI,MAAA,EAAQ,IAAA,EAAM,UAAU,QAAQ,CAAA;AAG3D,MAAA,MAAM,YAAA,GAAe,kBAAA,CAAmB,GAAA,CAAI,MAAM,CAAA;AAClD,MAAA,IAAI,YAAA,IAAgB,YAAA,CAAa,GAAA,CAAI,IAAI,CAAA,EAAG;AAC1C,QAAA,YAAA,CAAa,OAAO,IAAI,CAAA;AAAA,MAC1B;AAGA,MAAA,MAAM,OAAA,GAAU,YAAA,CAAa,GAAA,CAAI,MAAM,CAAA;AACvC,MAAA,IAAI,OAAA,IAAW,OAAA,CAAQ,IAAI,CAAA,EAAG;AAC5B,QAAA,OAAA,CAAQ,IAAI,EAAE,QAAQ,CAAA;AAAA,MACxB;AAGA,MAAA,IAAI,CAAC,MAAA,EAAQ;AACX,QAAA,gBAAA,CAAiB,MAAM,CAAA;AAAA,MACzB;AAIA,MAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,MAAM,CAAA,IAAK,SAAS,QAAA,EAAU;AAC9C,QAAA,MAAMA,QAAAA,GAAU,YAAA,CAAa,GAAA,CAAI,MAAM,CAAA;AACvC,QAAA,IAAIA,QAAAA,IAAWA,SAAQ,MAAA,EAAQ;AAC7B,UAAAA,QAAAA,CAAQ,MAAA,CAAQ,MAAA,CAAyC,MAAM,CAAA;AAAA,QACjE;AAAA,MACF;AAIA,MAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,MAAM,CAAA,IAAK,SAAS,QAAA,EAAU;AAC9C,QAAA,gBAAA,CAAiB,MAAM,CAAA;AAAA,MACzB;AAEA,MAAA,OAAO,MAAA;AAAA,IACT,CAAA;AAAA,IAEA,cAAA,CAAe,QAAQ,IAAA,EAAM;AAC3B,MAAA,MAAM,SAAS,MAAA,CAAO,SAAA,CAAU,cAAA,CAAe,IAAA,CAAK,QAAQ,IAAI,CAAA;AAChE,MAAA,MAAM,MAAA,GAAS,OAAA,CAAQ,cAAA,CAAe,MAAA,EAAQ,IAAI,CAAA;AAElD,MAAA,IAAI,UAAU,MAAA,EAAQ;AACpB,QAAA,MAAM,OAAA,GAAU,YAAA,CAAa,GAAA,CAAI,MAAM,CAAA;AACvC,QAAA,IAAI,OAAA,IAAW,OAAA,CAAQ,IAAI,CAAA,EAAG;AAC5B,UAAA,OAAA,CAAQ,IAAI,EAAE,MAAS,CAAA;AAAA,QACzB;AAGA,QAAA,MAAM,YAAA,GAAe,kBAAA,CAAmB,GAAA,CAAI,MAAM,CAAA;AAClD,QAAA,IAAI,YAAA,IAAgB,YAAA,CAAa,GAAA,CAAI,IAAI,CAAA,EAAG;AAC1C,UAAA,YAAA,CAAa,OAAO,IAAI,CAAA;AAAA,QAC1B;AAEA,QAAA,gBAAA,CAAiB,MAAM,CAAA;AAAA,MACzB;AAEA,MAAA,OAAO,MAAA;AAAA,IACT,CAAA;AAAA,IAEA,QAAQ,MAAA,EAAQ;AACd,MAAA,SAAA,CAAU,MAAA,EAAQ,WAAW,CAAA,EAAE;AAC/B,MAAA,OAAO,OAAA,CAAQ,QAAQ,MAAM,CAAA;AAAA,IAC/B,CAAA;AAAA,IAEA,GAAA,CAAI,QAAQ,IAAA,EAAM;AAChB,MAAA,SAAA,CAAU,MAAA,EAAQ,IAAI,CAAA,EAAE;AACxB,MAAA,OAAO,OAAA,CAAQ,GAAA,CAAI,MAAA,EAAQ,IAAI,CAAA;AAAA,IACjC;AAAA,GACD,CAAA;AAED,EAAA,WAAA,CAAY,GAAA,CAAI,cAAc,KAAK,CAAA;AACnC,EAAA,OAAO,KAAA;AACT","file":"chunk-5AWNWCDT.js","sourcesContent":["import { createSignal, type Signal } from '@fictjs/runtime/advanced'\n\ntype AnyFn = (...args: unknown[]) => unknown\ninterface BoundMethodEntry {\n  ref: AnyFn\n  bound: AnyFn\n}\n\nconst PROXY_CACHE = new WeakMap<object, unknown>()\nconst SIGNAL_CACHE = new WeakMap<object, Record<string | symbol, Signal<unknown>>>()\nconst BOUND_METHOD_CACHE = new WeakMap<object, Map<string | symbol, BoundMethodEntry>>()\nconst ITERATE_KEY = Symbol('iterate')\n\nfunction getSignal(target: object, prop: string | symbol): Signal<unknown> {\n  let signals = SIGNAL_CACHE.get(target)\n  if (!signals) {\n    signals = {}\n    SIGNAL_CACHE.set(target, signals)\n  }\n  if (!signals[prop]) {\n    const initial = prop === ITERATE_KEY ? 0 : (target as Record<string | symbol, unknown>)[prop]\n    signals[prop] = createSignal(initial)\n  }\n  return signals[prop]\n}\n\nfunction triggerIteration(target: object) {\n  const signals = SIGNAL_CACHE.get(target)\n  if (signals && signals[ITERATE_KEY]) {\n    const current = signals[ITERATE_KEY]() as number\n    signals[ITERATE_KEY](current + 1)\n  }\n}\n\nexport function $store<T extends object>(initialValue: T): T {\n  if (typeof initialValue !== 'object' || initialValue === null) {\n    return initialValue\n  }\n\n  if (PROXY_CACHE.has(initialValue)) {\n    return PROXY_CACHE.get(initialValue) as T\n  }\n\n  const proxy = new Proxy(initialValue, {\n    get(target, prop, receiver) {\n      // Always touch the signal so reference changes to this property are tracked,\n      // even if the value is an object we proxy further.\n      const signal = getSignal(target, prop)\n      const trackedValue = signal()\n\n      const currentValue = Reflect.get(target, prop, receiver ?? proxy)\n      if (currentValue !== trackedValue) {\n        // If the value has changed (e.g. via direct mutation of the underlying object not via proxy),\n        // we update the signal to keep it in sync.\n        // Note: This is a bit of a heuristic. Ideally all mutations go through proxy.\n        signal(currentValue)\n      }\n\n      if (typeof currentValue === 'function') {\n        let boundMethods = BOUND_METHOD_CACHE.get(target)\n        if (!boundMethods) {\n          boundMethods = new Map()\n          BOUND_METHOD_CACHE.set(target, boundMethods)\n        }\n        const cached = boundMethods.get(prop)\n        if (cached && cached.ref === currentValue) {\n          return cached.bound\n        }\n\n        const bound = (currentValue as AnyFn).bind(receiver ?? proxy)\n        boundMethods.set(prop, { ref: currentValue as AnyFn, bound })\n        return bound\n      }\n\n      // If the value is an object/array, we recursively wrap it in a store\n      if (typeof currentValue === 'object' && currentValue !== null) {\n        return $store(currentValue as Record<string, unknown>)\n      }\n\n      // For primitives (and functions), we return the signal value (which tracks the read)\n      return currentValue\n    },\n\n    set(target, prop, newValue, receiver) {\n      const oldValue = Reflect.get(target, prop, receiver)\n      const hadKey = Object.prototype.hasOwnProperty.call(target, prop)\n\n      // If value hasn't changed, do nothing\n      if (oldValue === newValue && hadKey) {\n        return true\n      }\n\n      const result = Reflect.set(target, prop, newValue, receiver)\n\n      // IMPORTANT: Clear bound method cache BEFORE updating the signal\n      const boundMethods = BOUND_METHOD_CACHE.get(target)\n      if (boundMethods && boundMethods.has(prop)) {\n        boundMethods.delete(prop)\n      }\n\n      // Update the signal if it exists\n      const signals = SIGNAL_CACHE.get(target)\n      if (signals && signals[prop]) {\n        signals[prop](newValue)\n      }\n\n      // If new property, trigger iteration update\n      if (!hadKey) {\n        triggerIteration(target)\n      }\n\n      // Ensure array length subscribers are notified even if the native push/pop\n      // doesn't trigger a separate set trap for \"length\" (defensive).\n      if (Array.isArray(target) && prop !== 'length') {\n        const signals = SIGNAL_CACHE.get(target)\n        if (signals && signals.length) {\n          signals.length((target as unknown as { length: number }).length)\n        }\n      }\n\n      // If it's an array and length changed implicitly, we might need to handle it.\n      // But usually 'length' is set explicitly or handled by the runtime.\n      if (Array.isArray(target) && prop === 'length') {\n        triggerIteration(target)\n      }\n\n      return result\n    },\n\n    deleteProperty(target, prop) {\n      const hadKey = Object.prototype.hasOwnProperty.call(target, prop)\n      const result = Reflect.deleteProperty(target, prop)\n\n      if (result && hadKey) {\n        const signals = SIGNAL_CACHE.get(target)\n        if (signals && signals[prop]) {\n          signals[prop](undefined)\n        }\n\n        // Clear bound method cache\n        const boundMethods = BOUND_METHOD_CACHE.get(target)\n        if (boundMethods && boundMethods.has(prop)) {\n          boundMethods.delete(prop)\n        }\n\n        triggerIteration(target)\n      }\n\n      return result\n    },\n\n    ownKeys(target) {\n      getSignal(target, ITERATE_KEY)()\n      return Reflect.ownKeys(target)\n    },\n\n    has(target, prop) {\n      getSignal(target, prop)()\n      return Reflect.has(target, prop)\n    },\n  })\n\n  PROXY_CACHE.set(initialValue, proxy)\n  return proxy\n}\n"]}

package/dist/store-BmwKJIj6.d.cts

@@ -1,3 +0,0 @@
-declare function $store<T extends object>(initialValue: T): T;
-
-export { $store as $ };

package/dist/store-BmwKJIj6.d.ts

@@ -1,3 +0,0 @@
-declare function $store<T extends object>(initialValue: T): T;
-
-export { $store as $ };