@floegence/floe-webapp-core 0.65.1 → 0.66.0

package/dist/floe.css

@@ -1,3 +1,4 @@
+@import './primitives.css';
 @import './input-focus.css';
 @import './surface.css';
 @import './file-icons.css';
@@ -20,23 +21,6 @@
 @import './themes/dark.css';
 @import './themes/shell-presets.generated.css';
 
-:root {
-  --radius: 0.375rem;
-  --font-sans: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-  --font-mono: 'JetBrains Mono', 'Fira Code', 'SF Mono', Menlo, Monaco, Consolas, monospace;
-  --floe-type-caption: 0.6875rem;
-  --floe-type-control: 0.8125rem;
-  --floe-type-body: 0.875rem;
-  --floe-type-heading: 1rem;
-  --floe-space-1: 0.25rem;
-  --floe-space-2: 0.5rem;
-  --floe-space-3: 0.75rem;
-  --floe-space-4: 1rem;
-  --floe-space-6: 1.5rem;
-  --floe-radius-control: 0.375rem;
-  --floe-radius-group: 0.5rem;
-  --floe-radius-floating: 12px;
-}
 
 /*
  * TailwindCSS v4 requires @theme for utilities. However, CSS variable

package/dist/primitives.css

@@ -0,0 +1,18 @@
+/* Shared typography, spacing and shape; no layout or palette ownership. */
+:root {
+  --radius: 0.375rem;
+  --font-sans: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  --font-mono: 'JetBrains Mono', 'Fira Code', 'SF Mono', Menlo, Monaco, Consolas, monospace;
+  --floe-type-caption: 0.6875rem;
+  --floe-type-control: 0.8125rem;
+  --floe-type-body: 0.875rem;
+  --floe-type-heading: 1rem;
+  --floe-space-1: 0.25rem;
+  --floe-space-2: 0.5rem;
+  --floe-space-3: 0.75rem;
+  --floe-space-4: 1rem;
+  --floe-space-6: 1.5rem;
+  --floe-radius-control: 0.375rem;
+  --floe-radius-group: 0.5rem;
+  --floe-radius-floating: 12px;
+}

package/dist/resource-cache.d.ts

@@ -0,0 +1,49 @@
+/** Disposable presentation snapshots. Authorization and polling belong to the consumer. */
+export interface ResourceCacheStorage {
+    /** Reads also update the entry's last-access time. */
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
+    list(): Promise<readonly {
+        key: string;
+        bytes: number;
+        lastAccessedAt: number;
+    }[]>;
+}
+export interface ResourceSnapshot<T> {
+    readonly data: T | undefined;
+    readonly refreshing: boolean;
+    readonly stale: boolean;
+    readonly error: unknown;
+}
+export interface CachedResource<T> {
+    snapshot(): ResourceSnapshot<T>;
+    subscribe(listener: () => void): () => void;
+    hydrate(): Promise<void>;
+    refresh(fetcher: (signal: AbortSignal) => Promise<T>): Promise<T>;
+    set(value: T): void;
+    /** Keeps the visible snapshot by default, but removes its durable copy. */
+    invalidate(clear?: boolean): void;
+}
+export interface CachedResourceDefinition<T> {
+    scope: string;
+    key: string;
+    version: number;
+    /** Validate and decode untrusted persisted content; throw to reject it. */
+    decode(value: unknown): T;
+    /** Persist an explicit presentation projection when live data contains private fields. */
+    persist?(value: T): unknown;
+}
+export interface ResourceCache {
+    resource<T>(definition: CachedResourceDefinition<T>): CachedResource<T>;
+    clearScope(scope: string): Promise<void>;
+    flush(): Promise<void>;
+    dispose(): void;
+}
+export declare function createResourceCache(options: {
+    storage: ResourceCacheStorage;
+    maxBytes?: number;
+    writeDelayMs?: number;
+}): ResourceCache;
+/** A dedicated database containing disposable snapshots only, never application settings. */
+export declare function createIndexedDBResourceCacheStorage(name?: string): ResourceCacheStorage;

package/dist/resource-cache.js

@@ -0,0 +1,162 @@
+function I(m) {
+  const d = m.storage, E = Math.max(0, m.maxBytes ?? 32 * 1024 * 1024), v = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map();
+  let n, t = Promise.resolve(), o = !1;
+  const i = (e) => (t = t.then(e).catch(() => {
+  }), t), h = async () => {
+    const e = [...await d.list()].sort((l, s) => l.lastAccessedAt - s.lastAccessedAt);
+    let r = e.reduce((l, s) => l + s.bytes, 0);
+    for (const l of e) {
+      if (r <= E) break;
+      await d.remove(l.key), r -= l.bytes;
+    }
+  }, f = async () => {
+    clearTimeout(n), n = void 0;
+    const e = [...c];
+    c.clear(), e.length && i(async () => {
+      for (const [r, l] of e)
+        if (l.valid())
+          try {
+            await d.set(r, l.value), l.stored();
+          } catch {
+          }
+      await h();
+    }), await t;
+  }, k = (e, r, l, s) => {
+    c.set(e, { value: r, valid: l, stored: s }), n === void 0 && (n = setTimeout(() => {
+      f();
+    }, m.writeDelayMs ?? 100));
+  };
+  return {
+    resource: (e) => {
+      if (o) throw new Error("Resource cache is disposed");
+      if (!e.scope || !e.key || !Number.isSafeInteger(e.version)) throw new Error("Invalid resource identity");
+      const r = JSON.stringify([e.scope, e.key, e.version]), l = v.get(r);
+      if (l) return l.handle;
+      let s = { data: void 0, refreshing: !1, stale: !0, error: void 0 };
+      const S = /* @__PURE__ */ new Set();
+      let x = 0, y = 0, q, D, w, p;
+      const b = () => {
+        for (const a of S) a();
+      }, R = (a) => {
+        ++x, s = { data: a, refreshing: s.refreshing, stale: !1, error: void 0 };
+        try {
+          const u = JSON.stringify({ version: e.version, data: e.persist ? e.persist(a) : a });
+          q = u, u !== D ? k(r, u, () => q === u, () => {
+            D = u;
+          }) : c.delete(r);
+        } catch {
+        }
+        b();
+      }, O = x, P = d.get(r).then((a) => {
+        if (!(o || x !== O || a === null))
+          try {
+            const u = JSON.parse(a);
+            if (u.version !== e.version) throw new Error("Unsupported snapshot");
+            const g = e.decode(u.data);
+            s = { ...s, data: g, stale: !0 }, q = a, D = a, b();
+          } catch {
+            i(() => d.remove(r));
+          }
+      }).catch(() => {
+      }), N = {
+        snapshot: () => s,
+        subscribe: (a) => (S.add(a), () => {
+          S.delete(a);
+        }),
+        hydrate: () => P,
+        refresh: (a) => {
+          if (p) return p;
+          const u = ++y, g = new AbortController();
+          return w = g, s = { ...s, refreshing: !0, error: void 0 }, b(), p = Promise.resolve().then(() => a(g.signal)).then((A) => (!o && u === y && !g.signal.aborted && R(A), A), (A) => {
+            throw !o && u === y && !g.signal.aborted && (s = { ...s, stale: !0, error: A }, b()), A;
+          }).finally(() => {
+            u === y && (p = void 0, w = void 0, s = { ...s, refreshing: !1 }, b());
+          }), p;
+        },
+        set: (a) => {
+          ++y, w?.abort(), p = void 0, s = { ...s, refreshing: !1 }, R(a);
+        },
+        invalidate: (a = !1) => {
+          ++x, ++y, w?.abort(), w = void 0, p = void 0, q = void 0, D = void 0, c.delete(r), s = { data: a ? void 0 : s.data, refreshing: !1, stale: !0, error: void 0 }, b(), i(() => d.remove(r));
+        }
+      };
+      return v.set(r, { scope: e.scope, handle: N, stop: () => {
+        ++y, w?.abort(), S.clear();
+      } }), N;
+    },
+    flush: f,
+    clearScope: async (e) => {
+      for (const r of v.values()) r.scope === e && r.handle.invalidate(!0);
+      await i(async () => {
+        for (const r of await d.list())
+          try {
+            JSON.parse(r.key)[0] === e && await d.remove(r.key);
+          } catch {
+          }
+      });
+    },
+    dispose: () => {
+      if (!o) {
+        o = !0;
+        for (const e of v.values()) e.stop();
+        f(), v.clear();
+      }
+    }
+  };
+}
+function J(m = "floe-resource-cache") {
+  let d;
+  const E = () => d ??= new Promise((c, n) => {
+    const t = indexedDB.open(m, 1);
+    t.onupgradeneeded = () => t.result.createObjectStore("snapshots", { keyPath: "key" }), t.onsuccess = () => {
+      const o = t.result;
+      o.onversionchange = () => {
+        o.close(), d = void 0;
+      }, c(o);
+    }, t.onerror = () => {
+      d = void 0, n(t.error);
+    }, t.onblocked = () => {
+      d = void 0, n(new Error("Resource cache database is blocked"));
+    };
+  }), v = async (c, n) => {
+    const t = await E();
+    return new Promise((o, i) => {
+      const h = t.transaction("snapshots", c);
+      let f;
+      h.oncomplete = () => o(f), h.onerror = () => i(h.error), h.onabort = () => i(h.error ?? new Error("Resource cache transaction aborted")), n(h.objectStore("snapshots"), (k) => {
+        f = k;
+      });
+    });
+  };
+  return {
+    get: (c) => v("readwrite", (n, t) => {
+      const o = n.get(c);
+      o.onsuccess = () => {
+        const i = o.result;
+        i && n.put({ ...i, lastAccessedAt: Date.now() }), t(i?.value ?? null);
+      };
+    }),
+    set: (c, n) => v("readwrite", (t, o) => {
+      t.put({ key: c, value: n, bytes: new TextEncoder().encode(n).byteLength, lastAccessedAt: Date.now() }), o(void 0);
+    }),
+    remove: (c) => v("readwrite", (n, t) => {
+      n.delete(c), t(void 0);
+    }),
+    list: () => v("readonly", (c, n) => {
+      const t = [], o = c.openCursor();
+      o.onsuccess = () => {
+        const i = o.result;
+        if (!i) {
+          n(t);
+          return;
+        }
+        const { key: h, bytes: f, lastAccessedAt: k } = i.value;
+        t.push({ key: h, bytes: f, lastAccessedAt: k }), i.continue();
+      };
+    })
+  };
+}
+export {
+  J as createIndexedDBResourceCacheStorage,
+  I as createResourceCache
+};

package/dist/standalone.css

@@ -0,0 +1,11 @@
+/* First-party standalone documents: the same themes, geometry tokens and
+ * material as Floe, without the shell, Tailwind utilities or renderer runtime.
+ * Set .light/.dark, data-floe-shell-theme and data-floe-surface-style on <html>.
+ * Applications own layout and declare data-floe-surface on visible boundaries.
+ */
+@import './primitives.css';
+@import './themes/light.css';
+@import './themes/dark.css';
+@import './themes/shell-presets.generated.css';
+@import './surface.css';
+@import './input-focus.css';