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

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

@@ -1,4 +1,4 @@
-/*! @fluixi/core v1.0.0-alpha.91 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+/*! @fluixi/core v1.0.0-alpha.93 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
 
 // src/lib/router/index.ts
 import {
@@ -6,8 +6,10 @@ import {
   createMemo as createMemo2,
   createResource as createResource3,
   createEffect,
-  getOwner,
+  createRoot,
+  getOwner as getOwner2,
   onCleanup,
+  runWithOwner,
   untrack as untrack2,
   flush
 } from "@fluixi/reactive/signal";
@@ -76,92 +78,35 @@ import {
   matchRoutes,
   matchPath
 } from "@fluixi/router";
-import {
-  createMemoryHistory,
-  createBrowserHistory as createBrowserHistory2,
-  matchRoutes as matchRoutes2,
-  matchPath as matchPath2
-} from "@fluixi/router";
 
 // src/lib/router/data.ts
 import {
   createResource,
   createSignal
 } from "@fluixi/reactive/signal";
-
-// src/lib/server/hydration.ts
-import { isServer as domIsServer } from "@fluixi/dom";
-var hydrating = false;
-var hydrationDataMap = /* @__PURE__ */ new Map();
-function isHydrating() {
-  return hydrating;
-}
-function setHydrationData(key, data) {
-  hydrationDataMap.set(key, data);
-}
-function getHydrationData(key) {
-  return hydrationDataMap.get(key);
-}
-function clearHydrationData() {
-  hydrationDataMap.clear();
-}
-function cleanupHydration() {
-  if (typeof window === "undefined") {
-    return;
-  }
-  const script = document.getElementById("__FLUIXI_HYDRATION__");
-  if (script) {
-    script.remove();
-  }
-  const walker = document.createTreeWalker(
-    document.body,
-    NodeFilter.SHOW_COMMENT,
-    null
-  );
-  const comments = [];
-  let node;
-  while (node = walker.nextNode()) {
-    const comment = node;
-    const text = comment.nodeValue || "";
-    if (text.startsWith("#") || text.startsWith("/")) {
-      comments.push(comment);
-    }
-  }
-  comments.forEach((comment) => comment.remove());
-  clearHydrationData();
-}
-if (typeof window !== "undefined") {
-  window.addEventListener("load", () => {
-    setTimeout(cleanupHydration, 100);
-  });
-}
-function isServerEnvironment() {
-  return domIsServer();
-}
+import { currentResourceCache } from "@fluixi/reactive/signal";
 
 // src/lib/context/context.ts
 import { asProvider } from "@fluixi/dom";
-import { createContext as createReactiveContext, useContext as useReactiveContext } from "@fluixi/reactive/signal";
 import {
-  readChildren
+  createContext as createReactiveContext,
+  getOwner,
+  useContext as useReactiveContext
 } from "@fluixi/reactive/signal";
 function createContext(defaultValue, name) {
   const context = createReactiveContext(defaultValue, name);
-  const Provider = (props) => {
-    if (props.debug === true) {
-    }
-    return context.Provider({
+  const Provider = (props) => (
+    // Children stay a getter: the reactive Provider reads them after stamping the value on
+    // its owner. Reading `props.children` here would render them, and any <Outlet/> in them,
+    // before the context exists.
+    context.Provider({
       value: props.value,
       get children() {
         return props.children;
       },
       debug: props.debug
-    });
-  };
-  if (typeof Symbol !== "undefined" && Symbol.for) {
-    Provider.$$typeof = /* @__PURE__ */ Symbol.for("react.provider");
-  }
-  Provider.$$typeof = /* @__PURE__ */ Symbol.for("react.provider");
+    })
+  );
   return {
     id: context.id,
     Provider: asProvider(Provider),
@@ -170,53 +115,73 @@ function createContext(defaultValue, name) {
 }
 
 // src/lib/router/data.ts
-var globalCache = /* @__PURE__ */ new Map();
-var inflightRequests = /* @__PURE__ */ new Map();
-function cache(fn, name) {
-  return async (...args) => {
+var revalidationListeners = /* @__PURE__ */ new Set();
+function onRevalidate(listener) {
+  revalidationListeners.add(listener);
+  return () => void revalidationListeners.delete(listener);
+}
+var reloadMounted = () => {
+  for (const listener of [...revalidationListeners]) listener();
+};
+function cache(fn, name, options = {}) {
+  const { ttl = Infinity, staleWhileRevalidate = true } = options;
+  return (...args) => {
+    const store = options.cache ?? currentResourceCache();
     const key = name + ":" + JSON.stringify(args);
-    if (isHydrating() || typeof window !== "undefined") {
-      const hydrated = getHydrationData(key);
-      if (hydrated !== void 0) {
-        return hydrated;
-      }
-    }
-    if (globalCache.has(key)) {
-      return globalCache.get(key);
-    }
-    if (inflightRequests.has(key)) {
-      return inflightRequests.get(key);
-    }
-    const promise = Promise.resolve(fn(...args)).then(
-      (val) => {
-        globalCache.set(key, val);
-        inflightRequests.delete(key);
-        if (isServerEnvironment()) {
-          setHydrationData(key, val);
+    const fetchFresh = () => {
+      const running = store.inflight.get(key);
+      if (running) return running;
+      const promise = Promise.resolve(fn(...args)).then(
+        (value) => {
+          store.set(key, { value, timestamp: Date.now() });
+          store.inflight.delete(key);
+          return value;
+        },
+        (error) => {
+          store.inflight.delete(key);
+          throw error;
         }
-        return val;
-      },
-      (err) => {
-        inflightRequests.delete(key);
-        throw err;
-      }
-    );
-    inflightRequests.set(key, promise);
-    return promise;
+      );
+      store.inflight.set(key, promise);
+      return promise;
+    };
+    const hit = store.get(key);
+    if (hit && (ttl === Infinity || Date.now() - hit.timestamp <= ttl)) return Promise.resolve(hit.value);
+    if (hit && staleWhileRevalidate) {
+      fetchFresh().then(reloadMounted, () => void 0);
+      return Promise.resolve(hit.value);
+    }
+    return fetchFresh();
   };
 }
-var [revalidationVersion, setRevalidationVersion] = createSignal(0);
-var revalidationKeys = /* @__PURE__ */ new Set();
-function revalidate(key) {
-  const predicate = typeof key === "string" ? (k) => k.startsWith(key) : key;
-  for (const k of globalCache.keys()) {
-    if (predicate(k)) {
-      globalCache.delete(k);
-      revalidationKeys.add(k);
-    }
+function revalidate(key, store) {
+  const names = typeof key === "string" ? [key] : Array.isArray(key) ? key : null;
+  drop(names ?? key, store ?? currentResourceCache());
+  if (names && !store) tellOtherTabs(names);
+}
+function drop(what, store) {
+  const matches = Array.isArray(what) ? (k) => what.some((n) => k === n || k.startsWith(n + ":")) : what;
+  for (const k of [...store.keys()]) if (matches(k)) store.delete(k);
+  reloadMounted();
+}
+var TABS_KEY = "fluixi:revalidate";
+function tellOtherTabs(names) {
+  try {
+    localStorage.setItem(TABS_KEY, JSON.stringify({ names, at: Date.now() + Math.random() }));
+  } catch {
   }
-  setRevalidationVersion((v) => v + 1);
 }
+if (typeof window !== "undefined") {
+  window.addEventListener("storage", (event) => {
+    if (event.key !== TABS_KEY || !event.newValue) return;
+    try {
+      const names = JSON.parse(event.newValue).names;
+      if (Array.isArray(names) && names.every((n) => typeof n === "string")) drop(names, currentResourceCache());
+    } catch {
+    }
+  });
+}
+globalThis[/* @__PURE__ */ Symbol.for("fluixi.revalidate")] = (names) => revalidate(names);
 function createAsync(fetcher, source) {
   const [data] = createResource(source || (() => true), fetcher);
   return data;
@@ -231,19 +196,39 @@ function getSubmissionSignal(url) {
   }
   return submissionState.get(url);
 }
-function action(fn, name) {
+var submissionsState = /* @__PURE__ */ new Map();
+function getSubmissionsSignal(url) {
+  if (!submissionsState.has(url)) submissionsState.set(url, createSignal([]));
+  return submissionsState.get(url);
+}
+function action(fn, name, options = {}) {
   const actionUrl = name || fn.name || "action";
   const submit = async (input) => {
     const [, setSubmission] = getSubmissionSignal(actionUrl);
-    const clear = () => setSubmission(void 0);
-    const retry = () => submit(input);
-    setSubmission({
+    const [, setSubmissions] = getSubmissionsSignal(actionUrl);
+    let entry;
+    const drop2 = () => setSubmissions((list) => list.filter((s) => s !== entry));
+    const settle = (next) => {
+      setSubmissions((list) => list.map((s) => s === entry ? next : s));
+      entry = next;
+    };
+    const clear = () => {
+      setSubmission(void 0);
+      drop2();
+    };
+    const retry = () => {
+      drop2();
+      return submit(input);
+    };
+    entry = {
       input,
       // Approximate type for tracking
       pending: true,
       clear,
       retry
-    });
+    };
+    setSubmission(entry);
+    setSubmissions((list) => [...list, entry]);
     try {
       const result = await fn(input);
       setSubmission({
@@ -253,32 +238,49 @@ function action(fn, name) {
         clear,
         retry
       });
+      drop2();
+      const stale = typeof options.invalidates === "function" ? options.invalidates(result) : options.invalidates;
+      for (const key of stale ?? []) revalidate(key);
       return result;
     } catch (error) {
-      setSubmission({
+      const failed = {
         input,
         error,
         pending: false,
         clear,
         retry
-      });
+      };
+      setSubmission(failed);
+      settle(failed);
       throw error;
     }
   };
   submit.url = actionUrl;
-  submit.with = (args) => action((...a) => fn(args, ...a), name);
+  submit.with = (args) => action((...a) => fn(args, ...a), name, options);
   return submit;
 }
 function useSubmission(actionFn) {
   const [submission] = getSubmissionSignal(actionFn.url);
   return submission;
 }
+function useSubmissions(actionFn) {
+  const [submissions] = getSubmissionsSignal(actionFn.url);
+  return submissions;
+}
 function useAction(actionFn) {
   return actionFn;
 }
 var RouteDataContext = createContext(void 0, "route-data");
 var RouteDataProvider = RouteDataContext.Provider;
 
+// src/lib/router/index.ts
+import {
+  createMemoryHistory,
+  createBrowserHistory as createBrowserHistory2,
+  matchRoutes as matchRoutes2,
+  matchPath as matchPath2
+} from "@fluixi/router";
+
 // src/lib/render/lazy.ts
 import { createComponent } from "@fluixi/dom";
 import {
@@ -328,7 +330,7 @@ function lazy(loader, options) {
 }
 
 // src/lib/router/index.ts
-import { runWithOwner } from "@fluixi/reactive/signal";
+import { runWithOwner as runWithOwner2 } from "@fluixi/reactive/signal";
 var RouterContext = createContext2(void 0, "router");
 var OutletContext = createContext2(void 0, "outlet");
 var LevelParamsContext = createContext2(void 0, "route-params");
@@ -341,11 +343,33 @@ function renderLayer(m, depth, base) {
     onCleanup(() => {
       cancelled = true;
     });
-    const owner = getOwner();
-    const [resource] = createResource3(
-      () => loader({ params: base.params, location: base.location }, owner, () => cancelled)
-    );
-    data = resource;
+    const owner = getOwner2();
+    const router = useContext2(RouterContext);
+    let watching = false;
+    const trackDeps = (deps) => {
+      if (watching || cancelled) return;
+      watching = true;
+      runWithOwner(owner, () => {
+        let first = true;
+        createEffect(() => {
+          deps();
+          if (first) first = false;
+          else untrack2(() => void refetch());
+        });
+      });
+    };
+    const [resource, { refetch }] = createResource3(() => {
+      const result = loader({ params: base.params, location: base.location }, owner, () => cancelled, trackDeps);
+      return router ? router.trackLoad(result) : result;
+    });
+    onCleanup(onRevalidate(() => void refetch()));
+    data = () => {
+      const error = resource.error;
+      if (error !== void 0 && error !== null) throw error;
+      return resource();
+    };
+    Object.defineProperty(data, "loading", { get: () => resource.loading });
+    Object.defineProperty(data, "state", { get: () => resource.state });
   }
   const buildPage = () => RouteDataContext2.Provider({
     value: data,
@@ -363,12 +387,15 @@ function renderLayer(m, depth, base) {
       });
     }
   });
-  if (!data) return buildPage();
+  if (!data) return { view: buildPage(), ready: () => true };
   const res = data;
-  const isLoading = () => res.loading;
+  const isLoading = () => {
+    const state = res.state;
+    return state === void 0 ? res.loading : state === "pending" || state === "unresolved";
+  };
   const [ready, setReady] = createSignal2(untrack2(() => !isLoading()));
   createEffect(() => setReady(!isLoading()));
-  return createMemo2(() => ready() ? buildPage() : null);
+  return { view: createMemo2(() => ready() ? buildPage() : null), ready };
 }
 function renderChild(ctx) {
   const childIdx = ctx.depth + 1;
@@ -379,17 +406,43 @@ function renderChild(ctx) {
     const c = ctx.matched()[childIdx]?.component;
     if (untrack2(childComp) !== c) setChildComp(() => c);
   });
-  return createMemo2(() => {
+  const owner = getOwner2();
+  let shown = null;
+  let pending = null;
+  const drop2 = (layer) => layer?.dispose();
+  onCleanup(() => {
+    drop2(shown);
+    drop2(pending);
+    shown = pending = null;
+  });
+  const incoming = createMemo2(() => {
     const component = childComp();
-    if (!component) {
+    if (!component) return null;
+    const m = untrack2(() => ctx.matched())[childIdx];
+    return runWithOwner(
+      owner,
+      () => createRoot((dispose) => ({
+        ...renderLayer(m, childIdx, { matched: ctx.matched, params: ctx.params, location: ctx.location }),
+        dispose
+      }))
+    );
+  });
+  return createMemo2(() => {
+    const next = incoming();
+    if (!next) {
+      drop2(shown);
+      drop2(pending);
+      shown = pending = null;
       return ctx.notFound ? ctx.notFound() : null;
     }
-    const m = untrack2(() => ctx.matched())[childIdx];
-    return renderLayer(m, childIdx, {
-      matched: ctx.matched,
-      params: ctx.params,
-      location: ctx.location
-    });
+    if (next === shown) return shown.view;
+    if (pending && pending !== next) drop2(pending);
+    pending = next;
+    if (shown && !next.ready()) return shown.view;
+    drop2(shown);
+    shown = next;
+    pending = null;
+    return shown.view;
   });
 }
 function renderNotFound(notFound) {
@@ -424,6 +477,8 @@ function Router(props) {
     history
   });
   const [state, setState] = createSignal2(router.state());
+  const [navigating, setNavigating] = createSignal2(false);
+  const [loads, setLoads] = createSignal2(0);
   let navigationId = 0;
   const takeMode = () => {
     const mode = pendingTransitionMode ?? (props.transition ?? "auto");
@@ -433,12 +488,15 @@ function Router(props) {
   const unsub = router.subscribe((next) => {
     const id = ++navigationId;
     const mode = takeMode();
+    setNavigating(true);
     const prepared = prepareComponents(
       (next.match?.matched ?? []).map((m) => m.component).filter(Boolean)
     );
     const commit = () => {
       setState(next);
-      return flush();
+      const flushed = flush();
+      if (id === navigationId) setNavigating(false);
+      return flushed;
     };
     if (!prepared) {
       void runTransition(mode, commit);
@@ -460,7 +518,18 @@ function Router(props) {
   const ctx = {
     router,
     location: createMemo2(() => state().location),
-    params: createMemo2(() => state().match?.params ?? {})
+    params: createMemo2(() => state().match?.params ?? {}),
+    isRouting: () => navigating() || loads() > 0,
+    // Counted by the promise, not by an owner: a load a newer navigation superseded still
+    // settles and uncounts itself, and a resource seeded from the server never calls it.
+    trackLoad(result) {
+      if (result && typeof result.finally === "function") {
+        setLoads((n) => n + 1);
+        void result.finally(() => setLoads((n) => n - 1)).catch(() => {
+        });
+      }
+      return result;
+    }
   };
   const root = {
     depth: -1,
@@ -483,6 +552,21 @@ function Outlet() {
   if (!ctx) return null;
   return renderChild(ctx);
 }
+function useIsRouting(options = {}) {
+  const routing = useContext2(RouterContext)?.isRouting ?? (() => false);
+  const delay = options.delay ?? 0;
+  if (delay <= 0) return routing;
+  const [late, setLate] = createSignal2(false);
+  createEffect(() => {
+    if (!routing()) {
+      setLate(false);
+      return;
+    }
+    const timer = setTimeout(() => setLate(true), delay);
+    onCleanup(() => clearTimeout(timer));
+  });
+  return () => routing() && late();
+}
 function Redirect(props) {
   const ctx = useContext2(RouterContext);
   if (ctx && typeof window !== "undefined") {
@@ -498,7 +582,9 @@ var _ssrRouterStub = {
   router: { navigate: () => {
   } },
   location: () => ({ pathname: "", search: "", hash: "", query: {} }),
-  params: () => ({})
+  params: () => ({}),
+  isRouting: () => false,
+  trackLoad: (result) => result
 };
 function useRouter() {
   const ctx = useContext2(RouterContext);
@@ -613,18 +699,31 @@ var LINK_OWN_PROPS = /* @__PURE__ */ new Set([
 ]);
 function Link(props) {
   const ctx = useContext2(RouterContext);
-  const navigate = () => ctx?.router.navigate(read(props.href) ?? "", { replace: read(props.replace) });
+  const navigate = () => ctx.router.navigate(read(props.href) ?? "", { replace: read(props.replace) });
   const a = createNativeElement("a");
   setAttribute(a, "href", read(props.href) ?? "");
   if (props.slot) setAttribute(a, "slot", read(props.slot));
   for (const k of Object.keys(props)) {
     if (LINK_OWN_PROPS.has(k)) continue;
     const v = props[k];
-    if (v != null && typeof v !== "function") setAttribute(a, k, String(v));
+    if (typeof v === "function") {
+      if (/^on[A-Z]/.test(k)) continue;
+      const read2 = v;
+      const apply = () => {
+        const value = read2();
+        if (value == null || value === false) a.removeAttribute?.(k);
+        else setAttribute(a, k, String(value));
+      };
+      if (typeof a.addEventListener === "function") createEffect(apply);
+      else apply();
+      continue;
+    }
+    if (v != null) setAttribute(a, k, String(v));
   }
   if (typeof a.addEventListener === "function") {
     a.addEventListener("click", (e) => {
       if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+      if (!ctx) return;
       e.preventDefault();
       navigate();
     });
@@ -703,10 +802,11 @@ export {
   prefersReducedMotion,
   preloadRoutes,
   revalidate,
-  runWithOwner,
+  runWithOwner2 as runWithOwner,
   select,
   supportsViewTransitions,
   useAction,
+  useIsRouting,
   useLevelParams,
   useLinkNavigation,
   useLocation,
@@ -718,5 +818,6 @@ export {
   useRouteData,
   useRouter,
   useSearchParams,
-  useSubmission
+  useSubmission,
+  useSubmissions
 };

package/dist/src/lib/server/index.cjs

@@ -1,4 +1,4 @@
-/*! @fluixi/core v1.0.0-alpha.91 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+/*! @fluixi/core v1.0.0-alpha.93 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;

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

@@ -1,4 +1,4 @@
-/*! @fluixi/core v1.0.0-alpha.91 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+/*! @fluixi/core v1.0.0-alpha.93 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
 
 // src/lib/server/hydration.ts
 import { isServer as domIsServer } from "@fluixi/dom";

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

@@ -0,0 +1,51 @@
+"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/cache.ts
+var cache_exports = {};
+__export(cache_exports, {
+  storageCache: () => storageCache
+});
+module.exports = __toCommonJS(cache_exports);
+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
+  };
+}

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

@@ -0,0 +1,18 @@
+import type { ResourceCache } from '@fluixi/reactive/cached-resource';
+import type { TypedStorage } from '@fluixi/storage';
+/**
+ * A `cachedResource` cache kept in a storage, so fetched data outlives the page: session
+ * storage for the tab, local storage across visits. Values pass through the storage's
+ * serializer, so they must be plain data. In-flight fetches stay in memory.
+ *
+ * Give it its own namespace, since `clearCachedResources()` clears that storage, and a `ttl`
+ * so entries do not pile up after the resource that wrote them is gone.
+ *
+ * @example
+ * const cache = storageCache(useStorage({ scope: 'session', namespace: 'cache' }), { ttl: 10 * 60_000 });
+ * const orgs = cachedResource(() => api.get('/orgs'), { name: 'orgs', ttl: 60_000, cache });
+ */
+export declare function storageCache(storage: TypedStorage<any>, options?: {
+    ttl?: number;
+}): ResourceCache;
+//# sourceMappingURL=cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../../src/lib/storage/cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,YAAY,CAAC,GAAG,CAAC,EAAE,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,aAAa,CA2BtG"}