@fluixi/core 1.0.0-alpha.92 → 1.0.0-alpha.93

package/dist/src/lib/storage/index.mjs

@@ -0,0 +1,231 @@
+/*! @fluixi/core v1.0.0-alpha.93 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/lib/storage/index.ts
+import { appendResponseHeader, getRequestContext, getServerData } from "@fluixi/dom";
+import { createContext, useContext } from "@fluixi/reactive/signal";
+import {
+  createAsyncStorage,
+  createSyncStorage,
+  memoryStorage,
+  StorageUnavailableError
+} from "@fluixi/storage";
+import { documentCookieAdapter, localStorageAdapter, sessionStorageAdapter } from "@fluixi/storage/browser";
+import { cookieStorage, requestStorage, toStorageRequest } from "@fluixi/storage/server";
+
+// src/lib/storage/persisted.ts
+import { getOwner, onCleanup, signal, untrack } from "@fluixi/reactive/signal";
+var isAsync = (storage) => "encryption" in storage;
+function persisted(storage, key, options = {}) {
+  const fallback = options.fallback ?? null;
+  const name = options.name ?? `storage:${storage.keyPrefix}${key}`;
+  const state = signal(isAsync(storage) ? fallback : storage.get(key) ?? fallback, { name });
+  const put = (value) => state.set(() => value);
+  const resolve = (next) => typeof next === "function" ? next(untrack(state)) : next;
+  const writeOptions = (extra) => ({
+    ...options.ttl !== void 0 ? { ttl: options.ttl } : {},
+    ...options.encrypt ? { encrypt: true } : {},
+    ...extra
+  });
+  if (!isAsync(storage)) {
+    const off2 = storage.subscribe(key, (event) => {
+      if (event.type !== "set") return put(fallback);
+      if (event.value !== void 0) put(event.value);
+    });
+    if (getOwner()) onCleanup(off2);
+    return Object.assign(() => state(), {
+      set(next, extra) {
+        const value = resolve(next);
+        storage.set(key, value, writeOptions(extra));
+        put(value);
+      },
+      remove() {
+        storage.remove(key);
+        put(fallback);
+      }
+    });
+  }
+  let written = false;
+  const reread = () => storage.get(key).then(
+    (value) => put(value ?? fallback),
+    () => void 0
+  );
+  const off = storage.subscribe(key, (event) => {
+    if (event.type !== "set") return put(fallback);
+    if (event.value !== void 0) put(event.value);
+    else void reread();
+  });
+  if (getOwner()) onCleanup(off);
+  const ready = storage.get(key).then((value) => {
+    if (!written) put(value ?? fallback);
+  });
+  return Object.assign(() => state(), {
+    ready,
+    async set(next, extra) {
+      const previous = untrack(state);
+      const value = resolve(next);
+      written = true;
+      put(value);
+      try {
+        await storage.set(key, value, writeOptions(extra));
+      } catch (error) {
+        put(previous);
+        throw error;
+      }
+    },
+    async remove() {
+      written = true;
+      await storage.remove(key);
+      put(fallback);
+    }
+  });
+}
+
+// src/lib/storage/cache.ts
+function storageCache(storage, options = {}) {
+  const inflight = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      try {
+        const entry = storage.getEntry(key);
+        return entry ? { value: entry.value, timestamp: entry.createdAt } : void 0;
+      } catch {
+        return void 0;
+      }
+    },
+    set(key, entry) {
+      try {
+        storage.set(key, entry.value, options.ttl !== void 0 ? { ttl: options.ttl } : void 0);
+      } catch {
+      }
+    },
+    delete: (key) => storage.remove(key),
+    keys: () => storage.keys(),
+    clear() {
+      storage.clear();
+      inflight.clear();
+    },
+    inflight
+  };
+}
+
+// src/lib/storage/index.ts
+var StorageContext = createContext(void 0, "storage");
+var AsyncStorageContext = createContext(void 0, "asyncStorage");
+var isAsyncStorage = (storage) => "encryption" in storage;
+function StorageProvider(props) {
+  const context = isAsyncStorage(props.storage) ? AsyncStorageContext : StorageContext;
+  return context.Provider({
+    value: props.storage,
+    get children() {
+      return props.children;
+    }
+  });
+}
+var isBrowser = () => typeof window !== "undefined" && typeof document !== "undefined";
+var perRequest = /* @__PURE__ */ new WeakMap();
+var perPage = /* @__PURE__ */ new Map();
+function cached(scope, id, make) {
+  let adapter = scope.get(id);
+  if (!adapter) scope.set(id, adapter = make());
+  return adapter;
+}
+function requestRequired(scope) {
+  throw new StorageUnavailableError(
+    `useStorage({ scope: '${scope}' }) on the server needs a request: call it during a render, a loader or a server function, or provide a storage with <StorageProvider>.`
+  );
+}
+function adapterFor(scope, cookie = {}) {
+  const ctx = getRequestContext();
+  const options = { httpOnly: false, ...cookie };
+  switch (scope) {
+    case "local":
+      return localStorageAdapter();
+    case "session":
+      return sessionStorageAdapter();
+    case "request":
+      if (isBrowser()) return cached(perPage, "request", memoryStorage);
+      if (!ctx) requestRequired(scope);
+      return cached(perRequest.get(ctx) ?? perRequest.set(ctx, /* @__PURE__ */ new Map()).get(ctx), "request", requestStorage);
+    case "cookie": {
+      const id = `cookie:${JSON.stringify(options)}`;
+      if (isBrowser()) {
+        const { httpOnly: _ignored, ...browser } = options;
+        return cached(perPage, id, () => documentCookieAdapter(browser));
+      }
+      if (!ctx) requestRequired(scope);
+      const raw = ctx.event.request;
+      const target = raw && typeof raw === "object" ? raw : void 0;
+      return cached(
+        perRequest.get(ctx) ?? perRequest.set(ctx, /* @__PURE__ */ new Map()).get(ctx),
+        id,
+        () => cookieStorage({
+          ...options,
+          request: raw && typeof raw === "object" && ("headers" in raw || "getHeader" in raw) ? toStorageRequest(raw) : void 0,
+          response: {
+            appendHeader(name, value) {
+              if (!appendResponseHeader(name, value, target)) {
+                throw new StorageUnavailableError("The response headers were already sent, so this cookie cannot reach the browser. Write it before the page head goes out: in middleware, a loader, a server function or the render before its first chunk.");
+              }
+            }
+          }
+        })
+      );
+    }
+  }
+}
+function useStorage(options = {}) {
+  const { scope = "auto", cookie, ...storageOptions } = options;
+  if (scope === "auto") {
+    const provided = useContext(StorageContext);
+    if (provided) return options.namespace ? provided.namespace(options.namespace) : provided;
+  }
+  return createSyncStorage({ ...storageOptions, adapter: resolveAdapter(scope, cookie) });
+}
+function useAsyncStorage(options = {}) {
+  const { scope = "auto", cookie, ...storageOptions } = options;
+  if (scope === "auto") {
+    const provided = useContext(AsyncStorageContext);
+    if (provided) return options.namespace ? provided.namespace(options.namespace) : provided;
+  }
+  return createAsyncStorage({ ...storageOptions, adapter: resolveAdapter(scope, cookie) });
+}
+function resolveAdapter(scope, cookie) {
+  if (scope !== "auto") return adapterFor(scope, cookie);
+  if (isBrowser()) return adapterFor("local");
+  if (!getRequestContext()) requestRequired(scope);
+  return adapterFor("request");
+}
+var SLOT = "__storage:";
+var seeded = /* @__PURE__ */ new Set();
+function hydrateStorage(storage, keys) {
+  const slot = SLOT + storage.keyPrefix;
+  if (!isBrowser()) {
+    const ctx = getRequestContext();
+    if (!ctx) return;
+    const entries2 = ctx.data.get(slot) ?? {};
+    for (const key of keys) {
+      const entry = storage.getEntry(key);
+      if (entry) entries2[key] = entry;
+    }
+    ctx.data.set(slot, entries2);
+    return;
+  }
+  const entries = getServerData()?.[slot];
+  if (!entries) return;
+  const fresh = {};
+  for (const key of keys) {
+    const id = slot + key;
+    if (seeded.has(id) || !entries[key]) continue;
+    seeded.add(id);
+    fresh[key] = entries[key];
+  }
+  storage.restore(fresh, { overwrite: true });
+}
+export {
+  StorageProvider,
+  hydrateStorage,
+  persisted,
+  storageCache,
+  useAsyncStorage,
+  useStorage
+};

package/dist/src/lib/storage/persisted.cjs

@@ -0,0 +1,91 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/storage/persisted.ts
+var persisted_exports = {};
+__export(persisted_exports, {
+  persisted: () => persisted
+});
+module.exports = __toCommonJS(persisted_exports);
+var import_signal = require("@fluixi/reactive/signal");
+var isAsync = (storage) => "encryption" in storage;
+function persisted(storage, key, options = {}) {
+  const fallback = options.fallback ?? null;
+  const name = options.name ?? `storage:${storage.keyPrefix}${key}`;
+  const state = (0, import_signal.signal)(isAsync(storage) ? fallback : storage.get(key) ?? fallback, { name });
+  const put = (value) => state.set(() => value);
+  const resolve = (next) => typeof next === "function" ? next((0, import_signal.untrack)(state)) : next;
+  const writeOptions = (extra) => ({
+    ...options.ttl !== void 0 ? { ttl: options.ttl } : {},
+    ...options.encrypt ? { encrypt: true } : {},
+    ...extra
+  });
+  if (!isAsync(storage)) {
+    const off2 = storage.subscribe(key, (event) => {
+      if (event.type !== "set") return put(fallback);
+      if (event.value !== void 0) put(event.value);
+    });
+    if ((0, import_signal.getOwner)()) (0, import_signal.onCleanup)(off2);
+    return Object.assign(() => state(), {
+      set(next, extra) {
+        const value = resolve(next);
+        storage.set(key, value, writeOptions(extra));
+        put(value);
+      },
+      remove() {
+        storage.remove(key);
+        put(fallback);
+      }
+    });
+  }
+  let written = false;
+  const reread = () => storage.get(key).then(
+    (value) => put(value ?? fallback),
+    () => void 0
+  );
+  const off = storage.subscribe(key, (event) => {
+    if (event.type !== "set") return put(fallback);
+    if (event.value !== void 0) put(event.value);
+    else void reread();
+  });
+  if ((0, import_signal.getOwner)()) (0, import_signal.onCleanup)(off);
+  const ready = storage.get(key).then((value) => {
+    if (!written) put(value ?? fallback);
+  });
+  return Object.assign(() => state(), {
+    ready,
+    async set(next, extra) {
+      const previous = (0, import_signal.untrack)(state);
+      const value = resolve(next);
+      written = true;
+      put(value);
+      try {
+        await storage.set(key, value, writeOptions(extra));
+      } catch (error) {
+        put(previous);
+        throw error;
+      }
+    },
+    async remove() {
+      written = true;
+      await storage.remove(key);
+      put(fallback);
+    }
+  });
+}

package/dist/src/lib/storage/persisted.d.ts

@@ -0,0 +1,53 @@
+import { type Accessor } from '@fluixi/reactive/signal';
+import type { AsyncTypedStorage, SetOptions, StorageKey, StorageSchema, TypedStorage } from '@fluixi/storage';
+type Next<T> = T | ((previous: T) => T);
+export interface PersistedOptions<T> {
+    /** The value while the key is absent, expired or removed. Without it, null. */
+    fallback?: T;
+    /** Every write expires this long after it is made. */
+    ttl?: number;
+    /** Async storage only: store each write encrypted. */
+    encrypt?: boolean;
+    /** For devtools. Defaults to `storage:<prefix><key>`. */
+    name?: string;
+}
+/** A signal whose value lives in a storage key. Writes go to the storage first. */
+export type Persisted<T> = Accessor<T> & {
+    /** Writes the storage, then the signal. Throws what the storage throws, leaving both as they were. */
+    set(next: Next<T>, options?: SetOptions): void;
+    /** Removes the key; the signal falls back. */
+    remove(): void;
+};
+/** The awaited form, over an async (or encrypted) storage. */
+export type AsyncPersisted<T> = Accessor<T> & {
+    /** Sets the signal at once and writes the storage; on failure the signal goes back and this rejects. */
+    set(next: Next<T>, options?: SetOptions & {
+        encrypt?: boolean;
+    }): Promise<void>;
+    remove(): Promise<void>;
+    /** Settles once the stored value has been read. Until then the signal holds the fallback. */
+    readonly ready: Promise<void>;
+};
+/**
+ * A signal bound to one key of a storage: it starts with the stored value, writes through on
+ * `set`, and follows changes made by any other storage over the same adapter, or by another
+ * tab where the adapter reports them. Created under an owner, it stops listening with it.
+ *
+ * Over a cookie storage it reads the same value in the server render and in the browser, so a
+ * stored preference renders without a flash. An async storage cannot answer during the render;
+ * the signal holds the fallback until `ready`.
+ *
+ * @example
+ * const theme = persisted(useStorage({ scope: 'cookie', namespace: 'ui' }), 'theme', { fallback: 'light' });
+ * theme.set((t) => (t === 'light' ? 'dark' : 'light'));
+ */
+export declare function persisted<S extends StorageSchema, K extends StorageKey<S>>(storage: TypedStorage<S>, key: K, options: PersistedOptions<S[K]> & {
+    fallback: S[K];
+}): Persisted<S[K]>;
+export declare function persisted<S extends StorageSchema, K extends StorageKey<S>>(storage: TypedStorage<S>, key: K, options?: PersistedOptions<S[K]>): Persisted<S[K] | null>;
+export declare function persisted<S extends StorageSchema, K extends StorageKey<S>>(storage: AsyncTypedStorage<S>, key: K, options: PersistedOptions<S[K]> & {
+    fallback: S[K];
+}): AsyncPersisted<S[K]>;
+export declare function persisted<S extends StorageSchema, K extends StorageKey<S>>(storage: AsyncTypedStorage<S>, key: K, options?: PersistedOptions<S[K]>): AsyncPersisted<S[K] | null>;
+export {};
+//# sourceMappingURL=persisted.d.ts.map

package/dist/src/lib/storage/persisted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persisted.d.ts","sourceRoot":"","sources":["../../../../src/lib/storage/persisted.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/storage/persisted.js

@@ -0,0 +1,75 @@
+import { getOwner, onCleanup, signal, untrack } from '@fluixi/reactive/signal';
+const isAsync = (storage) => 'encryption' in storage;
+export function persisted(storage, key, options = {}) {
+    const fallback = options.fallback ?? null;
+    const name = options.name ?? `storage:${storage.keyPrefix}${key}`;
+    // `set(() => v)`: a stored function value would otherwise be called as an updater.
+    const state = signal(isAsync(storage) ? fallback : (storage.get(key) ?? fallback), { name });
+    const put = (value) => state.set(() => value);
+    const resolve = (next) => (typeof next === 'function' ? next(untrack(state)) : next);
+    const writeOptions = (extra) => ({
+        ...(options.ttl !== undefined ? { ttl: options.ttl } : {}),
+        ...(options.encrypt ? { encrypt: true } : {}),
+        ...extra,
+    });
+    if (!isAsync(storage)) {
+        const off = storage.subscribe(key, (event) => {
+            if (event.type !== 'set')
+                return put(fallback);
+            // An external write to an encrypted entry carries no value; reading it here would throw.
+            if (event.value !== undefined)
+                put(event.value);
+        });
+        if (getOwner())
+            onCleanup(off);
+        return Object.assign(() => state(), {
+            set(next, extra) {
+                const value = resolve(next);
+                storage.set(key, value, writeOptions(extra));
+                put(value);
+            },
+            remove() {
+                storage.remove(key);
+                put(fallback);
+            },
+        });
+    }
+    let written = false;
+    const reread = () => storage.get(key).then((value) => put(value ?? fallback), () => undefined);
+    const off = storage.subscribe(key, (event) => {
+        if (event.type !== 'set')
+            return put(fallback);
+        if (event.value !== undefined)
+            put(event.value);
+        else
+            void reread();
+    });
+    if (getOwner())
+        onCleanup(off);
+    const ready = storage.get(key).then((value) => {
+        // A write made before the first read finished is newer than what it found.
+        if (!written)
+            put(value ?? fallback);
+    });
+    return Object.assign(() => state(), {
+        ready,
+        async set(next, extra) {
+            const previous = untrack(state);
+            const value = resolve(next);
+            written = true;
+            put(value);
+            try {
+                await storage.set(key, value, writeOptions(extra));
+            }
+            catch (error) {
+                put(previous);
+                throw error;
+            }
+        },
+        async remove() {
+            written = true;
+            await storage.remove(key);
+            put(fallback);
+        },
+    });
+}

package/dist/src/lib/storage/persisted.mjs

@@ -0,0 +1,70 @@
+// src/lib/storage/persisted.ts
+import { getOwner, onCleanup, signal, untrack } from "@fluixi/reactive/signal";
+var isAsync = (storage) => "encryption" in storage;
+function persisted(storage, key, options = {}) {
+  const fallback = options.fallback ?? null;
+  const name = options.name ?? `storage:${storage.keyPrefix}${key}`;
+  const state = signal(isAsync(storage) ? fallback : storage.get(key) ?? fallback, { name });
+  const put = (value) => state.set(() => value);
+  const resolve = (next) => typeof next === "function" ? next(untrack(state)) : next;
+  const writeOptions = (extra) => ({
+    ...options.ttl !== void 0 ? { ttl: options.ttl } : {},
+    ...options.encrypt ? { encrypt: true } : {},
+    ...extra
+  });
+  if (!isAsync(storage)) {
+    const off2 = storage.subscribe(key, (event) => {
+      if (event.type !== "set") return put(fallback);
+      if (event.value !== void 0) put(event.value);
+    });
+    if (getOwner()) onCleanup(off2);
+    return Object.assign(() => state(), {
+      set(next, extra) {
+        const value = resolve(next);
+        storage.set(key, value, writeOptions(extra));
+        put(value);
+      },
+      remove() {
+        storage.remove(key);
+        put(fallback);
+      }
+    });
+  }
+  let written = false;
+  const reread = () => storage.get(key).then(
+    (value) => put(value ?? fallback),
+    () => void 0
+  );
+  const off = storage.subscribe(key, (event) => {
+    if (event.type !== "set") return put(fallback);
+    if (event.value !== void 0) put(event.value);
+    else void reread();
+  });
+  if (getOwner()) onCleanup(off);
+  const ready = storage.get(key).then((value) => {
+    if (!written) put(value ?? fallback);
+  });
+  return Object.assign(() => state(), {
+    ready,
+    async set(next, extra) {
+      const previous = untrack(state);
+      const value = resolve(next);
+      written = true;
+      put(value);
+      try {
+        await storage.set(key, value, writeOptions(extra));
+      } catch (error) {
+        put(previous);
+        throw error;
+      }
+    },
+    async remove() {
+      written = true;
+      await storage.remove(key);
+      put(fallback);
+    }
+  });
+}
+export {
+  persisted
+};