@fluixi/core 1.0.0-alpha.82 → 1.0.0-alpha.84

package/dist/src/lib/client/router-X526HSWQ.mjs

@@ -0,0 +1,548 @@
+/*! @fluixi/core v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+import {
+  getHydrationData,
+  isHydrating,
+  isServerEnvironment,
+  lazy,
+  setHydrationData
+} from "./chunk-2C2KDDQV.mjs";
+
+// src/lib/router/index.ts
+import {
+  createSignal as createSignal2,
+  createMemo,
+  createResource as createResource2,
+  createEffect,
+  getOwner,
+  onCleanup,
+  untrack
+} from "@fluixi/reactive/signal";
+import {
+  insert,
+  createComponent,
+  createNativeElement,
+  setAttribute
+} from "@fluixi/dom";
+import { createContext as createContext2, useContext as useContext2 } from "@fluixi/reactive/signal";
+import { get } from "@fluixi/utils/object";
+import { deepEqual } from "@fluixi/utils/compare";
+import {
+  createRouter as createCoreRouter,
+  createBrowserHistory,
+  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/context/context.ts
+import { asProvider } from "@fluixi/dom";
+import { createContext as createReactiveContext, useContext as useReactiveContext } from "@fluixi/reactive/signal";
+import {
+  readChildren
+} from "@fluixi/reactive/signal";
+function createContext(defaultValue, name) {
+  const context = createReactiveContext(defaultValue, name);
+  const Provider = (props) => {
+    if (props.debug === true) {
+    }
+    return 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),
+    defaultValue
+  };
+}
+
+// src/lib/router/data.ts
+var globalCache = /* @__PURE__ */ new Map();
+var inflightRequests = /* @__PURE__ */ new Map();
+function cache(fn, name) {
+  return async (...args) => {
+    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);
+        }
+        return val;
+      },
+      (err) => {
+        inflightRequests.delete(key);
+        throw err;
+      }
+    );
+    inflightRequests.set(key, promise);
+    return promise;
+  };
+}
+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);
+    }
+  }
+  setRevalidationVersion((v) => v + 1);
+}
+function createAsync(fetcher, source) {
+  const [data] = createResource(source || (() => true), fetcher);
+  return data;
+}
+var submissionState = /* @__PURE__ */ new Map();
+function getSubmissionSignal(url) {
+  if (!submissionState.has(url)) {
+    submissionState.set(
+      url,
+      createSignal(void 0)
+    );
+  }
+  return submissionState.get(url);
+}
+function action(fn, name) {
+  const actionUrl = name || fn.name || "action";
+  const submit = async (input) => {
+    const [, setSubmission] = getSubmissionSignal(actionUrl);
+    const clear = () => setSubmission(void 0);
+    const retry = () => submit(input);
+    setSubmission({
+      input,
+      // Approximate type for tracking
+      pending: true,
+      clear,
+      retry
+    });
+    try {
+      const result = await fn(input);
+      setSubmission({
+        input,
+        result,
+        pending: false,
+        clear,
+        retry
+      });
+      return result;
+    } catch (error) {
+      setSubmission({
+        input,
+        error,
+        pending: false,
+        clear,
+        retry
+      });
+      throw error;
+    }
+  };
+  submit.url = actionUrl;
+  submit.with = (args) => action((...a) => fn(args, ...a), name);
+  return submit;
+}
+function useSubmission(actionFn) {
+  const [submission] = getSubmissionSignal(actionFn.url);
+  return submission;
+}
+function useAction(actionFn) {
+  return actionFn;
+}
+var RouteDataContext = createContext(void 0, "route-data");
+var RouteDataProvider = RouteDataContext.Provider;
+
+// src/lib/router/index.ts
+import { runWithOwner } from "@fluixi/reactive/signal";
+var RouterContext = createContext2(void 0, "router");
+var OutletContext = createContext2(void 0, "outlet");
+var LevelParamsContext = createContext2(void 0, "route-params");
+var RouteDataContext2 = createContext2(void 0, "route-data");
+function renderLayer(m, depth, base) {
+  let data;
+  const loader = m.route.data;
+  if (typeof loader === "function") {
+    let cancelled = false;
+    onCleanup(() => {
+      cancelled = true;
+    });
+    const owner = getOwner();
+    const [resource] = createResource2(
+      () => loader({ params: base.params, location: base.location }, owner, () => cancelled)
+    );
+    data = resource;
+  }
+  const buildPage = () => RouteDataContext2.Provider({
+    value: data,
+    get children() {
+      return LevelParamsContext.Provider({
+        value: m.params,
+        get children() {
+          return OutletContext.Provider({
+            value: { depth, ...base },
+            get children() {
+              return createComponent(m.component, {});
+            }
+          });
+        }
+      });
+    }
+  });
+  if (!data) return buildPage();
+  const res = data;
+  const isLoading = () => res.loading;
+  const [ready, setReady] = createSignal2(untrack(() => !isLoading()));
+  createEffect(() => setReady(!isLoading()));
+  return createMemo(() => ready() ? buildPage() : null);
+}
+function renderChild(ctx) {
+  const childIdx = ctx.depth + 1;
+  const [childComp, setChildComp] = createSignal2(
+    untrack(() => ctx.matched()[childIdx]?.component)
+  );
+  createEffect(() => {
+    const c = ctx.matched()[childIdx]?.component;
+    setChildComp(() => c);
+  });
+  return createMemo(() => {
+    const component = childComp();
+    if (!component) {
+      return ctx.notFound ? ctx.notFound() : null;
+    }
+    const m = untrack(() => ctx.matched())[childIdx];
+    return renderLayer(m, childIdx, {
+      matched: ctx.matched,
+      params: ctx.params,
+      location: ctx.location
+    });
+  });
+}
+function renderNotFound(notFound) {
+  if (notFound == null) return buildDefaultNotFound();
+  return typeof notFound === "function" ? createComponent(notFound, {}) : notFound;
+}
+function buildDefaultNotFound() {
+  const el = createNativeElement("div");
+  setAttribute(el, "class", "fx-not-found");
+  setAttribute(el, "role", "main");
+  setAttribute(
+    el,
+    "style",
+    "min-height:60vh;display:grid;place-content:center;gap:.25rem;text-align:center;font-family:system-ui,-apple-system,sans-serif"
+  );
+  const h1 = createNativeElement("h1");
+  setAttribute(h1, "style", "margin:0;font-size:2.5rem;font-weight:700");
+  insert(h1, "404");
+  const p = createNativeElement("p");
+  setAttribute(p, "style", "margin:0;opacity:.7");
+  insert(p, "This page could not be found.");
+  el.appendChild(h1);
+  el.appendChild(p);
+  return el;
+}
+function Router(props) {
+  const history = props.history ?? createBrowserHistory();
+  const router = createCoreRouter({
+    routes: props.routes,
+    base: props.base,
+    history
+  });
+  const [state, setState] = createSignal2(router.state());
+  const unsub = router.subscribe(setState);
+  onCleanup(() => {
+    unsub();
+    router.destroy();
+  });
+  const matched = createMemo(
+    () => (state().match?.matched ?? []).filter((m) => m.component)
+  );
+  const ctx = {
+    router,
+    location: createMemo(() => state().location),
+    params: createMemo(() => state().match?.params ?? {})
+  };
+  const root = {
+    depth: -1,
+    matched,
+    params: ctx.params,
+    location: ctx.location,
+    // Only the root carries this: renderChild shows it when the URL matched nothing.
+    notFound: () => renderNotFound(props.notFound)
+  };
+  let rootView;
+  return RouterContext.Provider({
+    value: ctx,
+    get children() {
+      return rootView ??= renderChild(root);
+    }
+  });
+}
+function Outlet() {
+  const ctx = useContext2(OutletContext);
+  if (!ctx) return null;
+  return renderChild(ctx);
+}
+function Redirect(props) {
+  const ctx = useContext2(RouterContext);
+  if (ctx && typeof window !== "undefined") {
+    let cancelled = false;
+    onCleanup(() => cancelled = true);
+    queueMicrotask(() => {
+      if (!cancelled) ctx.router.navigate(props.to, { replace: props.replace !== false });
+    });
+  }
+  return null;
+}
+var _ssrRouterStub = {
+  router: { navigate: () => {
+  } },
+  location: () => ({ pathname: "", search: "", hash: "", query: {} }),
+  params: () => ({})
+};
+function useRouter() {
+  const ctx = useContext2(RouterContext);
+  if (ctx) return ctx;
+  if (typeof window === "undefined") return _ssrRouterStub;
+  throw new Error("[router] useRouter must be used within <Router>");
+}
+function useParams() {
+  const params = useRouter().params;
+  return createMemo(() => params(), {}, {
+    equals: (a, b) => JSON.stringify(a) === JSON.stringify(b)
+  });
+}
+function useLevelParams() {
+  return useContext2(LevelParamsContext) ?? {};
+}
+function useParam(key) {
+  const params = useParams();
+  return createMemo(() => params()[key]);
+}
+function useParamSelector(selector, equals) {
+  const params = useParams();
+  return createMemo(
+    () => selector(params()),
+    void 0,
+    equals ? { equals } : void 0
+  );
+}
+function useMatch(path) {
+  const location = useLocation();
+  return createMemo(
+    () => matchPath(typeof path === "function" ? path() : path, location.pathname)
+  );
+}
+function useSearchParams() {
+  const location = useLocation();
+  const navigate = useNavigate();
+  const params = createMemo(() => location.query);
+  const setParams = (next, options) => {
+    const current = new URLSearchParams(location.search);
+    for (const [k, v] of Object.entries(next)) {
+      if (v === null) current.delete(k);
+      else current.set(k, v);
+    }
+    const search = current.toString();
+    navigate(location.pathname + (search ? `?${search}` : ""), options);
+  };
+  return [params, setParams];
+}
+function select(source, key) {
+  const equals = (a, b) => deepEqual(a, b);
+  if (key !== void 0) {
+    return createMemo(
+      () => get(source(), key),
+      void 0,
+      { equals }
+    );
+  }
+  return createMemo(source, void 0, { equals });
+}
+function useLocation() {
+  const { location } = useRouter();
+  return new Proxy({}, {
+    get: (_t, key) => location()[key],
+    has: (_t, key) => key in location(),
+    ownKeys: () => Reflect.ownKeys(location()),
+    getOwnPropertyDescriptor: (_t, key) => Object.getOwnPropertyDescriptor(location(), key)
+  });
+}
+function useLinkNavigation(options = {}) {
+  const ctx = useContext2(RouterContext);
+  return (event) => {
+    if (!ctx || event.defaultPrevented || event.button !== 0) return;
+    if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+    const target = event.target;
+    const anchor = target?.closest?.("a");
+    if (!anchor || !anchor.getAttribute("href")) return;
+    if (anchor.target && anchor.target !== "_self") return;
+    if (anchor.hasAttribute("download")) return;
+    if (/(^|\s)external(\s|$)/.test(anchor.getAttribute("rel") ?? "")) return;
+    const url = new URL(anchor.href);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return;
+    if (url.origin !== window.location.origin) return;
+    if (url.hash && url.pathname === window.location.pathname && url.search === window.location.search) return;
+    if (options.shouldNavigate && !options.shouldNavigate(url, anchor)) return;
+    event.preventDefault();
+    ctx.router.navigate(url.pathname + url.search + url.hash, { replace: options.replace });
+  };
+}
+function useNavigate() {
+  const { router } = useRouter();
+  return (to, options) => router.navigate(to, options);
+}
+function useRouteData() {
+  const acc = useContext2(RouteDataContext2);
+  return acc ?? (() => void 0);
+}
+var read = (v) => typeof v === "function" ? v() : v;
+var LINK_OWN_PROPS = /* @__PURE__ */ new Set([
+  "href",
+  "slot",
+  "class",
+  "className",
+  "active",
+  "activeClass",
+  "replace",
+  "children"
+]);
+function Link(props) {
+  const ctx = useContext2(RouterContext);
+  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 a.addEventListener === "function") {
+    a.addEventListener("click", (e) => {
+      if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+      e.preventDefault();
+      navigate();
+    });
+  } else {
+    const base = read(props.className ?? props.class) ?? "";
+    if (base) setAttribute(a, "class", base);
+  }
+  if (typeof a.addEventListener === "function") {
+    createEffect(() => {
+      const href = read(props.href) ?? "";
+      a.setAttribute("href", href);
+      const base = read(props.className ?? props.class) ?? "";
+      const activeClass = read(props.activeClass) ?? "";
+      const active = read(props.active) ?? ctx?.location().pathname === href;
+      a.className = [base, active ? activeClass : ""].filter(Boolean).join(" ");
+    });
+  }
+  const linkChildren = props.children;
+  if (linkChildren != null) insert(a, linkChildren);
+  return a;
+}
+var A = Link;
+function Form(props) {
+  const action2 = props.action;
+  const cls = props.className ?? props.class;
+  const url = action2.url ?? "";
+  const form = createNativeElement("form");
+  setAttribute(form, "method", "post");
+  if (url) setAttribute(form, "action", url);
+  if (cls) setAttribute(form, "class", cls);
+  for (const k of Object.keys(props)) {
+    if (k === "action" || k === "children" || k === "class" || k === "className") continue;
+    const v = props[k];
+    if (v != null && typeof v !== "function") setAttribute(form, k, String(v));
+  }
+  if (typeof form.addEventListener === "function") {
+    form.addEventListener("submit", (e) => {
+      e.preventDefault();
+      const data = {};
+      new FormData(form).forEach((v, k) => {
+        data[k] = v;
+      });
+      Promise.resolve(action2(data)).catch(() => {
+      });
+    });
+  }
+  const children = props.children;
+  if (children != null) insert(form, children);
+  return form;
+}
+async function preloadRoutes(routes, pathname) {
+  const match = matchRoutes(routes, pathname);
+  if (!match) return;
+  const loads = [];
+  for (const m of match.matched) {
+    const c = m.component;
+    if (c && typeof c.preload === "function") loads.push(c.preload());
+  }
+  await Promise.all(loads);
+}
+export {
+  A,
+  Form,
+  Link,
+  Outlet,
+  Redirect,
+  Router,
+  action,
+  cache,
+  createAsync,
+  createBrowserHistory2 as createBrowserHistory,
+  createMemoryHistory,
+  lazy,
+  matchPath2 as matchPath,
+  matchRoutes2 as matchRoutes,
+  preloadRoutes,
+  revalidate,
+  runWithOwner,
+  select,
+  useAction,
+  useLevelParams,
+  useLinkNavigation,
+  useLocation,
+  useMatch,
+  useNavigate,
+  useParam,
+  useParamSelector,
+  useParams,
+  useRouteData,
+  useRouter,
+  useSearchParams,
+  useSubmission
+};

package/dist/src/lib/context/context.cjs

@@ -1 +1,118 @@
-"use strict";var a=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var m=Object.prototype.hasOwnProperty;var P=(e,r)=>{for(var t in r)a(e,t,{get:r[t],enumerable:!0})},g=(e,r,t,n)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of y(r))!m.call(e,o)&&o!==t&&a(e,o,{get:()=>r[o],enumerable:!(n=f(r,o))||n.enumerable});return e};var b=e=>g(a({},"__esModule",{value:!0}),e);var k={};P(k,{composeProviders:()=>v,createConsumer:()=>R,createContext:()=>p,createContextWithProvider:()=>A,createProvider:()=>s,useContext:()=>c,useProvide:()=>V});module.exports=b(k);var u=require("@fluixi/dom"),i=require("@fluixi/reactive/signal"),C=require("@fluixi/reactive/signal"),l=!1;function S(){l||(l=!0,!(typeof process<"u")&&console.warn("[fluixi] createProvider({ context, value, children }) reads `children` eagerly: the object literal materialises `children` BEFORE the context is stamped, so a routed <Outlet/> that has siblings inside the provider renders detached and its descendants see no context under SSR. Use the lazy form instead:\n  createProvider(Context, value, props)   // children stays a getter\n  // or JSX:  <Context.Provider value={…}>{props.children}</Context.Provider>"))}function s(e,r,t){let n=!!e?.Provider,o=n?e:e.context,d=n?r:e.value,x=n?!1:e.debug??!1;n||S();let T=typeof d=="function"?d():d,h=n?t:e;return o.Provider({value:T,get children(){return h?.children},debug:x})}function A(e){let r=p(e);return[r,n=>s(r,n.value,n)]}function v(e,r){if(e.length===0)return(0,C.readChildren)(()=>r);let[t,n]=e[0],o=e.slice(1);return s(t,n,{get children(){return v(o,r)}})}function R(e){return r=>{let t=c(e);return r.children(t)}}function V(e,r){let t=c(e);return t===e.defaultValue?r():t}function p(e){let r=(0,i.createContext)(e),t=n=>(n.debug,r.Provider({value:n.value,get children(){return n.children},debug:n.debug}));return typeof Symbol<"u"&&Symbol.for&&(t.$$typeof=Symbol.for("react.provider")),t.$$typeof=Symbol.for("react.provider"),{id:r.id,Provider:(0,u.asProvider)(t),defaultValue:e}}function c(e){let r=(0,i.useContext)(e);return r!==void 0?r:e.defaultValue}
+"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/context/context.ts
+var context_exports = {};
+__export(context_exports, {
+  composeProviders: () => composeProviders,
+  createConsumer: () => createConsumer,
+  createContext: () => createContext,
+  createContextWithProvider: () => createContextWithProvider,
+  createProvider: () => createProvider,
+  useContext: () => useContext,
+  useProvide: () => useProvide
+});
+module.exports = __toCommonJS(context_exports);
+var import_dom = require("@fluixi/dom");
+var import_signal = require("@fluixi/reactive/signal");
+var import_signal2 = require("@fluixi/reactive/signal");
+var _warnedEagerProvider = false;
+function warnEagerProvider() {
+  if (_warnedEagerProvider) return;
+  _warnedEagerProvider = true;
+  if (typeof process !== "undefined" && true) return;
+  console.warn(
+    "[fluixi] createProvider({ context, value, children }) reads `children` eagerly: the object literal materialises `children` BEFORE the context is stamped, so a routed <Outlet/> that has siblings inside the provider renders detached and its descendants see no context under SSR. Use the lazy form instead:\n  createProvider(Context, value, props)   // children stays a getter\n  // or JSX:  <Context.Provider value={...}>{props.children}</Context.Provider>"
+  );
+}
+function createProvider(a, value, childProps) {
+  const isLazyForm = !!a?.Provider;
+  const context = isLazyForm ? a : a.context;
+  const rawValue = isLazyForm ? value : a.value;
+  const debug = isLazyForm ? false : a.debug ?? false;
+  if (!isLazyForm) warnEagerProvider();
+  const resolvedValue = typeof rawValue === "function" ? rawValue() : rawValue;
+  const sourceProps = isLazyForm ? childProps : a;
+  return context.Provider({
+    value: resolvedValue,
+    get children() {
+      return sourceProps?.children;
+    },
+    debug
+  });
+}
+function createContextWithProvider(defaultValue) {
+  const context = createContext(defaultValue);
+  const provider = (props) => {
+    return createProvider(context, props.value, props);
+  };
+  return [context, provider];
+}
+function composeProviders(contexts, children) {
+  if (contexts.length === 0) {
+    return (0, import_signal2.readChildren)(() => children);
+  }
+  const [context, value] = contexts[0];
+  const remaining = contexts.slice(1);
+  return createProvider(context, value, {
+    get children() {
+      return composeProviders(remaining, children);
+    }
+  });
+}
+function createConsumer(context) {
+  return (props) => {
+    const value = useContext(context);
+    return props.children(value);
+  };
+}
+function useProvide(context, factory) {
+  const existing = useContext(context);
+  if (existing === context.defaultValue) {
+    return factory();
+  }
+  return existing;
+}
+function createContext(defaultValue, name) {
+  const context = (0, import_signal.createContext)(defaultValue, name);
+  const Provider = (props) => {
+    if (props.debug === true) {
+    }
+    return 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: (0, import_dom.asProvider)(Provider),
+    defaultValue
+  };
+}
+function useContext(context) {
+  const value = (0, import_signal.useContext)(context);
+  return value !== void 0 ? value : context.defaultValue;
+}