fict 0.0.1 → 0.0.3

package/src/resource.ts

@@ -0,0 +1,293 @@
+import { createSignal, createEffect, onCleanup, createSuspenseToken } from '@fictjs/runtime'
+
+export interface ResourceResult<T> {
+  data: T | undefined
+  loading: boolean
+  error: unknown
+  refresh: () => void
+}
+
+export interface ResourceCacheOptions {
+  mode?: 'memory' | 'none'
+  ttlMs?: number
+  staleWhileRevalidate?: boolean
+  cacheErrors?: boolean
+}
+
+export interface ResourceOptions<T, Args> {
+  key?: unknown
+  fetch: (ctx: { signal: AbortSignal }, args: Args) => Promise<T>
+  suspense?: boolean
+  cache?: ResourceCacheOptions
+  reset?: unknown | (() => unknown)
+}
+
+interface ResourceEntry<T, Args> {
+  data: ReturnType<typeof createSignal<T | undefined>>
+  loading: ReturnType<typeof createSignal<boolean>>
+  error: ReturnType<typeof createSignal<unknown>>
+  version: ReturnType<typeof createSignal<number>>
+  pendingToken: ReturnType<typeof createSuspenseToken> | null
+  lastArgs: Args | undefined
+  lastVersion: number
+  lastReset: unknown
+  hasValue: boolean
+  status: 'idle' | 'pending' | 'success' | 'error'
+  generation: number
+  expiresAt: number | undefined
+  inFlight: Promise<void> | undefined
+  controller: AbortController | undefined
+}
+
+const defaultCacheOptions: Required<ResourceCacheOptions> = {
+  mode: 'memory',
+  ttlMs: Number.POSITIVE_INFINITY,
+  staleWhileRevalidate: false,
+  cacheErrors: false,
+}
+
+/**
+ * Creates a resource factory that can be read with arguments.
+ *
+ * @param optionsOrFetcher - Configuration object or fetcher function
+ */
+export function resource<T, Args = void>(
+  optionsOrFetcher:
+    | ((ctx: { signal: AbortSignal }, args: Args) => Promise<T>)
+    | ResourceOptions<T, Args>,
+) {
+  const fetcher = typeof optionsOrFetcher === 'function' ? optionsOrFetcher : optionsOrFetcher.fetch
+  const useSuspense = typeof optionsOrFetcher === 'object' && !!optionsOrFetcher.suspense
+  const cacheOptions: ResourceCacheOptions =
+    typeof optionsOrFetcher === 'object' ? (optionsOrFetcher.cache ?? {}) : {}
+  const resolvedCacheOptions = { ...defaultCacheOptions, ...cacheOptions }
+  const cache = new Map<unknown, ResourceEntry<T, Args>>()
+
+  const readArgs = (argsAccessor: (() => Args) | Args): Args =>
+    typeof argsAccessor === 'function' ? (argsAccessor as () => Args)() : argsAccessor
+
+  const computeKey = (argsAccessor: (() => Args) | Args): unknown => {
+    const argsValue = readArgs(argsAccessor)
+    if (typeof optionsOrFetcher === 'object' && optionsOrFetcher.key !== undefined) {
+      const key = optionsOrFetcher.key
+      return typeof key === 'function' ? (key as (args: Args) => unknown)(argsValue) : key
+    }
+    return argsValue
+  }
+
+  const readResetToken = (): unknown => {
+    if (typeof optionsOrFetcher !== 'object') return undefined
+    const reset = optionsOrFetcher.reset
+    if (typeof reset === 'function' && (reset as () => unknown).length === 0) {
+      return (reset as () => unknown)()
+    }
+    return reset
+  }
+
+  const ensureEntry = (key: unknown): ResourceEntry<T, Args> => {
+    let state = cache.get(key)
+    if (!state) {
+      state = {
+        data: createSignal<T | undefined>(undefined),
+        loading: createSignal<boolean>(false),
+        error: createSignal<unknown>(undefined),
+        version: createSignal(0),
+        pendingToken: null,
+        lastArgs: undefined,
+        lastVersion: -1,
+        lastReset: undefined,
+        hasValue: false,
+        status: 'idle',
+        generation: 0,
+        expiresAt: undefined,
+        inFlight: undefined,
+        controller: undefined,
+      }
+      cache.set(key, state)
+    }
+    return state!
+  }
+
+  const isExpired = (entry: ResourceEntry<T, Args>): boolean => {
+    if (resolvedCacheOptions.mode === 'none') return true
+    if (!Number.isFinite(resolvedCacheOptions.ttlMs)) return false
+    if (entry.expiresAt === undefined) return false
+    return entry.expiresAt < Date.now()
+  }
+
+  const markExpiry = (entry: ResourceEntry<T, Args>) => {
+    if (resolvedCacheOptions.mode === 'none') {
+      entry.expiresAt = Date.now() - 1
+      return
+    }
+    entry.expiresAt = Number.isFinite(resolvedCacheOptions.ttlMs)
+      ? Date.now() + resolvedCacheOptions.ttlMs
+      : undefined
+  }
+
+  const startFetch = (entry: ResourceEntry<T, Args>, key: unknown, args: Args) => {
+    entry.controller?.abort()
+    entry.inFlight = undefined
+    const controller = new AbortController()
+    entry.controller = controller
+    entry.status = 'pending'
+    entry.loading(true)
+    entry.error(undefined)
+    entry.generation += 1
+    const currentGen = entry.generation
+
+    const shouldSuspend = useSuspense && !entry.hasValue
+    entry.pendingToken = shouldSuspend ? createSuspenseToken() : null
+
+    const fetchPromise = fetcher({ signal: controller.signal }, args)
+      .then(res => {
+        if (controller.signal.aborted || entry.generation !== currentGen) return
+        entry.data(res)
+        entry.hasValue = true
+        entry.status = 'success'
+        entry.loading(false)
+        markExpiry(entry)
+        if (entry.pendingToken) {
+          entry.pendingToken.resolve()
+          entry.pendingToken = null
+        }
+      })
+      .catch(err => {
+        if (controller.signal.aborted || entry.generation !== currentGen) return
+        entry.error(err)
+        entry.status = 'error'
+        entry.loading(false)
+        if (resolvedCacheOptions.cacheErrors) {
+          markExpiry(entry)
+        } else {
+          entry.expiresAt = Date.now() - 1
+          entry.hasValue = false
+        }
+        if (entry.pendingToken) {
+          entry.pendingToken.reject(err)
+          entry.pendingToken = null
+        }
+      })
+      .finally(() => {
+        entry.inFlight = undefined
+        entry.controller = undefined
+      })
+
+    entry.inFlight = fetchPromise
+
+    onCleanup(() => {
+      if (resolvedCacheOptions.mode === 'none') {
+        controller.abort()
+        cache.delete(key)
+      }
+    })
+  }
+
+  const invalidate = (key?: unknown) => {
+    if (key === undefined) {
+      cache.forEach(entry => {
+        entry.controller?.abort()
+        entry.version(entry.version() + 1)
+        entry.expiresAt = Date.now() - 1
+      })
+      cache.clear()
+      return
+    }
+    const entry = cache.get(key)
+    if (entry) {
+      entry.controller?.abort()
+      entry.version(entry.version() + 1)
+      entry.expiresAt = Date.now() - 1
+      cache.delete(key)
+    }
+  }
+
+  const prefetch = (args: Args, keyOverride?: unknown) => {
+    const key = keyOverride ?? computeKey(args)
+    const entry = ensureEntry(key)
+    const usableData = entry.hasValue && !isExpired(entry)
+    if (!usableData) {
+      entry.lastArgs = args
+      entry.lastVersion = entry.version()
+      startFetch(entry, key, args)
+    }
+  }
+
+  return {
+    read(argsAccessor: (() => Args) | Args): ResourceResult<T> {
+      const entryRef = createSignal<ResourceEntry<T, Args> | null>(null)
+
+      createEffect(() => {
+        const key = computeKey(argsAccessor)
+        const entry = ensureEntry(key)
+        entryRef(entry)
+        const args = readArgs(argsAccessor)
+        const currentVersion = entry.version()
+        const expired = isExpired(entry)
+        const argsChanged = entry.lastArgs !== args
+        const versionChanged = entry.lastVersion !== currentVersion
+        const resetToken = readResetToken()
+        const resetChanged = entry.lastReset !== resetToken
+        const shouldRefetch =
+          expired ||
+          argsChanged ||
+          versionChanged ||
+          resetChanged ||
+          (entry.status === 'error' && !resolvedCacheOptions.cacheErrors)
+
+        entry.lastArgs = args
+        entry.lastVersion = currentVersion
+        entry.lastReset = resetToken
+
+        if (shouldRefetch) {
+          if (entry.inFlight && (argsChanged || versionChanged)) {
+            entry.controller?.abort()
+            entry.inFlight = undefined
+          }
+          if (resetChanged) {
+            entry.hasValue = false
+            entry.expiresAt = Date.now() - 1
+          }
+          startFetch(entry, key, args as Args)
+        } else if (
+          entry.inFlight === undefined &&
+          resolvedCacheOptions.staleWhileRevalidate &&
+          expired &&
+          entry.hasValue
+        ) {
+          // stale-while-revalidate: return stale data but refresh.
+          startFetch(entry, key, args as Args)
+        }
+
+        if (resolvedCacheOptions.staleWhileRevalidate && entry.hasValue && expired) {
+          entry.loading(true)
+        }
+      })
+
+      return {
+        get data() {
+          const entry = entryRef()
+          if (!entry) return undefined
+          if (useSuspense && entry.pendingToken) {
+            throw entry.pendingToken.token
+          }
+          return entry.data()
+        },
+        get loading() {
+          const entry = entryRef()
+          return entry ? entry.loading() : false
+        },
+        get error() {
+          const entry = entryRef()
+          return entry ? entry.error() : undefined
+        },
+        refresh: () => {
+          const entry = entryRef()
+          if (entry) entry.version(entry.version() + 1)
+        },
+      }
+    },
+    invalidate,
+    prefetch,
+  }
+}

package/src/slim.ts

@@ -0,0 +1,2 @@
+// Slim distribution that targets the fine-grained DOM runtime only.
+export * from '@fictjs/runtime/slim'

package/src/store.ts

@@ -0,0 +1,165 @@
+import { createSignal, type Signal } from '@fictjs/runtime'
+
+type AnyFn = (...args: unknown[]) => unknown
+interface BoundMethodEntry {
+  ref: AnyFn
+  bound: AnyFn
+}
+
+const PROXY_CACHE = new WeakMap<object, unknown>()
+const SIGNAL_CACHE = new WeakMap<object, Record<string | symbol, Signal<unknown>>>()
+const BOUND_METHOD_CACHE = new WeakMap<object, Map<string | symbol, BoundMethodEntry>>()
+const ITERATE_KEY = Symbol('iterate')
+
+function getSignal(target: object, prop: string | symbol): Signal<unknown> {
+  let signals = SIGNAL_CACHE.get(target)
+  if (!signals) {
+    signals = {}
+    SIGNAL_CACHE.set(target, signals)
+  }
+  if (!signals[prop]) {
+    const initial = prop === ITERATE_KEY ? 0 : (target as Record<string | symbol, unknown>)[prop]
+    signals[prop] = createSignal(initial)
+  }
+  return signals[prop]
+}
+
+function triggerIteration(target: object) {
+  const signals = SIGNAL_CACHE.get(target)
+  if (signals && signals[ITERATE_KEY]) {
+    const current = signals[ITERATE_KEY]() as number
+    signals[ITERATE_KEY](current + 1)
+  }
+}
+
+export function $store<T extends object>(initialValue: T): T {
+  if (typeof initialValue !== 'object' || initialValue === null) {
+    return initialValue
+  }
+
+  if (PROXY_CACHE.has(initialValue)) {
+    return PROXY_CACHE.get(initialValue) as T
+  }
+
+  const proxy = new Proxy(initialValue, {
+    get(target, prop, receiver) {
+      // Always touch the signal so reference changes to this property are tracked,
+      // even if the value is an object we proxy further.
+      const signal = getSignal(target, prop)
+      const trackedValue = signal()
+
+      const currentValue = Reflect.get(target, prop, receiver ?? proxy)
+      if (currentValue !== trackedValue) {
+        // If the value has changed (e.g. via direct mutation of the underlying object not via proxy),
+        // we update the signal to keep it in sync.
+        // Note: This is a bit of a heuristic. Ideally all mutations go through proxy.
+        signal(currentValue)
+      }
+
+      if (typeof currentValue === 'function') {
+        let boundMethods = BOUND_METHOD_CACHE.get(target)
+        if (!boundMethods) {
+          boundMethods = new Map()
+          BOUND_METHOD_CACHE.set(target, boundMethods)
+        }
+        const cached = boundMethods.get(prop)
+        if (cached && cached.ref === currentValue) {
+          return cached.bound
+        }
+
+        const bound = (currentValue as AnyFn).bind(receiver ?? proxy)
+        boundMethods.set(prop, { ref: currentValue as AnyFn, bound })
+        return bound
+      }
+
+      // If the value is an object/array, we recursively wrap it in a store
+      if (typeof currentValue === 'object' && currentValue !== null) {
+        return $store(currentValue as Record<string, unknown>)
+      }
+
+      // For primitives (and functions), we return the signal value (which tracks the read)
+      return currentValue
+    },
+
+    set(target, prop, newValue, receiver) {
+      const oldValue = Reflect.get(target, prop, receiver)
+      const hadKey = Object.prototype.hasOwnProperty.call(target, prop)
+
+      // If value hasn't changed, do nothing
+      if (oldValue === newValue && hadKey) {
+        return true
+      }
+
+      const result = Reflect.set(target, prop, newValue, receiver)
+
+      // IMPORTANT: Clear bound method cache BEFORE updating the signal
+      const boundMethods = BOUND_METHOD_CACHE.get(target)
+      if (boundMethods && boundMethods.has(prop)) {
+        boundMethods.delete(prop)
+      }
+
+      // Update the signal if it exists
+      const signals = SIGNAL_CACHE.get(target)
+      if (signals && signals[prop]) {
+        signals[prop](newValue)
+      }
+
+      // If new property, trigger iteration update
+      if (!hadKey) {
+        triggerIteration(target)
+      }
+
+      // Ensure array length subscribers are notified even if the native push/pop
+      // doesn't trigger a separate set trap for "length" (defensive).
+      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)
+        }
+      }
+
+      // 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') {
+        triggerIteration(target)
+      }
+
+      return result
+    },
+
+    deleteProperty(target, prop) {
+      const hadKey = Object.prototype.hasOwnProperty.call(target, prop)
+      const result = Reflect.deleteProperty(target, prop)
+
+      if (result && hadKey) {
+        const signals = SIGNAL_CACHE.get(target)
+        if (signals && signals[prop]) {
+          signals[prop](undefined)
+        }
+
+        // Clear bound method cache
+        const boundMethods = BOUND_METHOD_CACHE.get(target)
+        if (boundMethods && boundMethods.has(prop)) {
+          boundMethods.delete(prop)
+        }
+
+        triggerIteration(target)
+      }
+
+      return result
+    },
+
+    ownKeys(target) {
+      getSignal(target, ITERATE_KEY)()
+      return Reflect.ownKeys(target)
+    },
+
+    has(target, prop) {
+      getSignal(target, prop)()
+      return Reflect.has(target, prop)
+    },
+  })
+
+  PROXY_CACHE.set(initialValue, proxy)
+  return proxy
+}