@fluixi/core 1.0.0-alpha.100

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

@@ -0,0 +1,188 @@
+// src/lib/utils/index.ts
+function debounce(fn, delay) {
+  let timeoutId;
+  return (...args) => {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => fn(...args), delay);
+  };
+}
+function throttle(fn, limit) {
+  let inThrottle;
+  return (...args) => {
+    if (!inThrottle) {
+      fn(...args);
+      inThrottle = true;
+      setTimeout(() => inThrottle = false, limit);
+    }
+  };
+}
+function memoize(fn) {
+  const cache = /* @__PURE__ */ new Map();
+  return ((...args) => {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  });
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof Array) {
+    return Array.from(obj).map((item) => deepClone(item));
+  }
+  if (obj instanceof Set) {
+    return new Set(Array.from(obj).map((item) => deepClone(item)));
+  }
+  if (obj instanceof Map) {
+    return new Map(
+      Array.from(obj.entries()).map(([key, value]) => [
+        deepClone(key),
+        deepClone(value)
+      ])
+    );
+  }
+  const clonedObj = {};
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      clonedObj[key] = deepClone(obj[key]);
+    }
+  }
+  return clonedObj;
+}
+function deepMerge(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        const value = obj[key];
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+          result[key] = deepMerge(
+            result[key] || {},
+            value
+          );
+        } else {
+          result[key] = value;
+        }
+      }
+    }
+  }
+  return result;
+}
+function uniqueId(prefix = "") {
+  return prefix + Math.random().toString(36).substr(2, 9);
+}
+function formatNumber(num) {
+  return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+function formatBytes(bytes, decimals = 2) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + " " + sizes[i];
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function kebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function camelCase(str) {
+  return str.replace(/[-_\s](.)/g, (_, char) => char.toUpperCase());
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function random(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function isEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim().length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+function pick(obj, ...keys) {
+  const result = {};
+  keys.forEach((key) => {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  });
+  return result;
+}
+function omit(obj, ...keys) {
+  const result = { ...obj };
+  keys.forEach((key) => {
+    delete result[key];
+  });
+  return result;
+}
+function groupBy(array, fn) {
+  return array.reduce((acc, item) => {
+    const key = fn(item);
+    const group = acc.get(key) || [];
+    group.push(item);
+    acc.set(key, group);
+    return acc;
+  }, /* @__PURE__ */ new Map());
+}
+function range(start, end, step = 1) {
+  const result = [];
+  for (let i = start; i <= end; i += step) {
+    result.push(i);
+  }
+  return result;
+}
+async function retry(fn, retries = 3, delay = 1e3) {
+  try {
+    return await fn();
+  } catch (error) {
+    if (retries <= 0) throw error;
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return retry(fn, retries - 1, delay);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isDefined(value) {
+  return value !== null && value !== void 0;
+}
+function pipe(...fns) {
+  return (arg) => fns.reduce((acc, fn) => fn(acc), arg);
+}
+export {
+  camelCase,
+  capitalize,
+  clamp,
+  debounce,
+  deepClone,
+  deepMerge,
+  formatBytes,
+  formatNumber,
+  groupBy,
+  isDefined,
+  isEmpty,
+  kebabCase,
+  memoize,
+  omit,
+  pick,
+  pipe,
+  random,
+  range,
+  retry,
+  sleep,
+  throttle,
+  uniqueId
+};

package/dist/src/routes.cjs

@@ -0,0 +1,37 @@
+/*! @fluixi/core v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"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/routes.ts
+var routes_exports = {};
+__export(routes_exports, {
+  routes: () => routes
+});
+module.exports = __toCommonJS(routes_exports);
+function missingPlugin() {
+  throw new Error(
+    "[fluixi] '@fluixi/core/routes' was imported but fluixiRoutesPlugin did not replace it, so there is no route tree. Add the plugin to your Vite config, or, in a @fluixi/start app, build with `fluixi build`/`fluixi dev` rather than calling vite directly."
+  );
+}
+var routes = new Proxy([], {
+  get: (target, key) => (
+    // `then` is probed by any `await`; answering undefined keeps this from looking thenable.
+    key === "then" ? void 0 : missingPlugin()
+  )
+});

package/dist/src/routes.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The file-system route tree.
+ *
+ * ```ts
+ * import { routes } from '@fluixi/core/routes';
+ * ```
+ *
+ * This module is a **typed stand-in**. `fluixiRoutesPlugin` intercepts the specifier and
+ * serves the generated tree in its place, so what you import at runtime is the real thing
+ * scanned from `src/routes`.
+ *
+ * It exists as a real module so the types come from this package rather than from an
+ * ambient `declare module` the plugin writes into your `src/`. That generated file could
+ * drift, raised a gitignore question, and left `virtual:fluixi-routes` invisible to
+ * anything not running the Vite plugin: plain `tsc`, an editor, a test runner.
+ *
+ * `virtual:fluixi-routes` still resolves, so existing apps keep working.
+ */
+import type { RouteDefinition } from './lib/router/index.js';
+/** Routes discovered under the configured routes directory (default `src/routes`). */
+export declare const routes: RouteDefinition[];
+//# sourceMappingURL=routes.d.ts.map

package/dist/src/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAmB7D,sFAAsF;AACtF,eAAO,MAAM,MAAM,EAAE,eAAe,EAIlC,CAAC"}

package/dist/src/routes.js

@@ -0,0 +1,20 @@
+/**
+ * Reaching this code means the plugin did not replace the module.
+ *
+ * The alternative, exporting an empty array, is worse than it looks: the app builds, the
+ * router mounts, and every route 404s with nothing to explain why. A virtual specifier at
+ * least failed loudly when the plugin was missing, and giving that up for better types
+ * should not also give up the error. TypeScript never evaluates this, so type-checking is
+ * unaffected.
+ */
+function missingPlugin() {
+    throw new Error("[fluixi] '@fluixi/core/routes' was imported but fluixiRoutesPlugin did not replace it, " +
+        'so there is no route tree. Add the plugin to your Vite config, or, in a @fluixi/start ' +
+        'app, build with `fluixi build`/`fluixi dev` rather than calling vite directly.');
+}
+/** Routes discovered under the configured routes directory (default `src/routes`). */
+export const routes = new Proxy([], {
+    get: (target, key) => 
+    // `then` is probed by any `await`; answering undefined keeps this from looking thenable.
+    key === 'then' ? undefined : missingPlugin(),
+});

package/dist/src/routes.mjs

@@ -0,0 +1,17 @@
+/*! @fluixi/core v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/routes.ts
+function missingPlugin() {
+  throw new Error(
+    "[fluixi] '@fluixi/core/routes' was imported but fluixiRoutesPlugin did not replace it, so there is no route tree. Add the plugin to your Vite config, or, in a @fluixi/start app, build with `fluixi build`/`fluixi dev` rather than calling vite directly."
+  );
+}
+var routes = new Proxy([], {
+  get: (target, key) => (
+    // `then` is probed by any `await`; answering undefined keeps this from looking thenable.
+    key === "then" ? void 0 : missingPlugin()
+  )
+});
+export {
+  routes
+};

package/dist/src/server.cjs

@@ -0,0 +1,405 @@
+"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/server.ts
+var server_exports = {};
+__export(server_exports, {
+  batch: () => batch,
+  cleanupHydration: () => cleanupHydration,
+  clearHydrationData: () => clearHydrationData,
+  clearHydrationDataKey: () => clearHydrationDataKey,
+  createComputed: () => createComputed,
+  createContext: () => createContext,
+  createDeferred: () => createDeferred,
+  createEffect: () => createEffect,
+  createHtmlDocument: () => createHtmlDocument,
+  createHydratableResource: () => createHydratableResource,
+  createMemo: () => createMemo,
+  createRenderEffect: () => createRenderEffect,
+  createResource: () => createResource,
+  createRoot: () => createRoot,
+  createSelector: () => createSelector,
+  createSignal: () => createSignal,
+  deserializeHydrationData: () => deserializeHydrationData,
+  getHydrationData: () => getHydrationData,
+  getOwner: () => getOwner,
+  getSSRContext: () => getSSRContext,
+  hasHydrationData: () => hasHydrationData,
+  hydrationMarker: () => hydrationMarker,
+  hydrationMarkerEnd: () => hydrationMarkerEnd,
+  hydrationMarkerStart: () => hydrationMarkerStart,
+  isClient: () => isClient2,
+  isClientEnvironment: () => isClientEnvironment,
+  isClientReactive: () => isClient,
+  isHydrating: () => isHydrating,
+  isServer: () => import_dom2.isServer,
+  isServerEnvironment: () => isServerEnvironment,
+  isServerReactive: () => isServer,
+  onCleanup: () => onCleanup,
+  onClient: () => onClient,
+  onServer: () => onServer,
+  renderToPage: () => renderToPage,
+  renderToStream: () => renderToStream,
+  renderToString: () => renderToString,
+  runWithOwner: () => runWithOwner,
+  serializeHydrationData: () => serializeHydrationData,
+  setHydrating: () => setHydrating,
+  setHydrationData: () => setHydrationData,
+  setSSRContext: () => setSSRContext,
+  startServer: () => startServer,
+  startTransition: () => startTransition,
+  untrack: () => untrack,
+  useContext: () => useContext,
+  useHydrationData: () => useHydrationData,
+  withSSRContext: () => withSSRContext
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/lib/server/hydration.ts
+var import_dom = require("@fluixi/dom");
+var hydrating = false;
+var hydrationDataMap = /* @__PURE__ */ new Map();
+function isHydrating() {
+  return hydrating;
+}
+function setHydrating(state) {
+  hydrating = state;
+}
+function setHydrationData(key, data) {
+  hydrationDataMap.set(key, data);
+}
+function getHydrationData(key) {
+  return hydrationDataMap.get(key);
+}
+function hasHydrationData(key) {
+  return hydrationDataMap.has(key);
+}
+function clearHydrationData() {
+  hydrationDataMap.clear();
+}
+function clearHydrationDataKey(key) {
+  hydrationDataMap.delete(key);
+}
+function serializeHydrationData() {
+  if (hydrationDataMap.size === 0) {
+    return "";
+  }
+  const data = Object.fromEntries(hydrationDataMap);
+  const json = JSON.stringify(data);
+  return `<script type="application/json" id="__FLUIXI_HYDRATION__">${json}<\/script>`;
+}
+function deserializeHydrationData() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  const script = document.getElementById("__FLUIXI_HYDRATION__");
+  if (!script || script.getAttribute("type") !== "application/json") {
+    return false;
+  }
+  try {
+    const json = script.textContent || "{}";
+    const data = JSON.parse(json);
+    for (const [key, value] of Object.entries(data)) {
+      hydrationDataMap.set(key, value);
+    }
+    return true;
+  } catch (error) {
+    console.error("Failed to deserialize hydration data:", error);
+    return false;
+  }
+}
+function hydrationMarker(id) {
+  return `<!--#${id}-->`;
+}
+function hydrationMarkerStart(id) {
+  return `<!--#${id}-->`;
+}
+function hydrationMarkerEnd(id) {
+  return `<!--/${id}-->`;
+}
+function createHydratableResource(key, fetcher) {
+  return async () => {
+    if (isHydrating() || typeof window !== "undefined") {
+      const cached = getHydrationData(key);
+      if (cached !== void 0) {
+        return cached;
+      }
+    }
+    const data = await fetcher();
+    if (typeof window === "undefined") {
+      setHydrationData(key, data);
+    }
+    return data;
+  };
+}
+function useHydrationData(key, value) {
+  const hydrationData = getHydrationData(key);
+  if (hydrationData !== void 0) {
+    return hydrationData;
+  }
+  const computedValue = typeof value === "function" ? value() : value;
+  if (typeof window === "undefined") {
+    setHydrationData(key, computedValue);
+  }
+  return computedValue;
+}
+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 (0, import_dom.isServer)();
+}
+function isClientEnvironment() {
+  return !(0, import_dom.isServer)();
+}
+
+// src/lib/server/index.ts
+var import_server = require("@fluixi/server");
+var import_dom2 = require("@fluixi/dom");
+
+// src/lib/server/reactive.ts
+function createSignal(value, options) {
+  let current = value;
+  const read = (() => current);
+  const write = (newValue) => {
+    if (typeof newValue === "function") {
+      current = newValue(current);
+    } else {
+      current = newValue;
+    }
+    return current;
+  };
+  return [read, write];
+}
+function createEffect(fn, value, options) {
+  try {
+    fn(value);
+  } catch (error) {
+    console.error("[Fluixi Server] Effect error:", error);
+  }
+  return { dispose: () => {
+  } };
+}
+function createMemo(fn, value, options) {
+  const computed = fn(value);
+  return (() => computed);
+}
+function createRoot(fn) {
+  const cleanups = [];
+  const dispose = () => {
+    cleanups.forEach((cleanup) => {
+      try {
+        cleanup();
+      } catch (error) {
+        console.error("[Fluixi Server] Cleanup error:", error);
+      }
+    });
+    cleanups.length = 0;
+  };
+  try {
+    return fn(dispose);
+  } catch (error) {
+    dispose();
+    throw error;
+  }
+}
+function batch(fn) {
+  return fn();
+}
+function untrack(fn) {
+  return fn();
+}
+var currentCleanups = null;
+function onCleanup(fn) {
+  if (currentCleanups) {
+    currentCleanups.push(fn);
+  }
+}
+var currentOwner = null;
+function getOwner() {
+  return currentOwner;
+}
+function runWithOwner(owner, fn) {
+  const prev = currentOwner;
+  currentOwner = owner;
+  try {
+    return fn();
+  } finally {
+    currentOwner = prev;
+  }
+}
+var contextMap = /* @__PURE__ */ new Map();
+function createContext(defaultValue) {
+  const id = /* @__PURE__ */ Symbol("context");
+  const Provider = (props) => {
+    const prevValue = contextMap.get(id);
+    contextMap.set(id, props.value);
+    try {
+      return props.children;
+    } finally {
+      if (prevValue !== void 0) {
+        contextMap.set(id, prevValue);
+      } else {
+        contextMap.delete(id);
+      }
+    }
+  };
+  return {
+    id,
+    Provider,
+    defaultValue
+  };
+}
+function useContext(context) {
+  const value = contextMap.get(context.id);
+  return value !== void 0 ? value : context.defaultValue;
+}
+function createComputed(fn) {
+  return createEffect(fn);
+}
+function createRenderEffect(fn) {
+  return createEffect(fn);
+}
+function createDeferred(fn) {
+  return createMemo(fn);
+}
+function createSelector(source) {
+  const value = source();
+  return (key) => key === value;
+}
+function createResource(source, fetcher, options) {
+  return [
+    () => void 0,
+    {
+      mutate: (v) => v,
+      refetch: () => {
+      }
+    }
+  ];
+}
+function startTransition(fn) {
+  fn();
+}
+var isServer = true;
+var isClient = false;
+
+// src/lib/server/index.ts
+var import_dom3 = require("@fluixi/dom");
+var currentSSRContext = null;
+function getSSRContext() {
+  return currentSSRContext;
+}
+function setSSRContext(context) {
+  currentSSRContext = context;
+}
+function withSSRContext(context, fn) {
+  const prev = currentSSRContext;
+  currentSSRContext = context;
+  try {
+    return fn();
+  } finally {
+    currentSSRContext = prev;
+  }
+}
+async function renderToPage(code, options = {}) {
+  const content = await renderToString(code);
+  return createHtmlDocument(content, options);
+}
+function createHtmlDocument(content, options = {}) {
+  const {
+    title = "Fluixi App",
+    lang = "en",
+    stylesheets = [],
+    scripts = [],
+    head = "",
+    bodyAttributes = ""
+  } = options;
+  const styleTags = stylesheets.map((href) => `<link rel="stylesheet" href="${href}">`).join("\n    ");
+  const scriptTags = scripts.map((src) => `<script type="module" src="${src}"><\/script>`).join("\n    ");
+  return `<!DOCTYPE html>
+<html lang="${lang}">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title}</title>
+    ${styleTags}
+    ${head}
+  </head>
+  <body${bodyAttributes ? " " + bodyAttributes : ""}>
+    ${content}
+    ${scriptTags}
+  </body>
+</html>`;
+}
+function isClient2() {
+  return !(0, import_dom3.isServer)();
+}
+function onServer(fn, fallback) {
+  return (0, import_dom3.isServer)() ? fn() : fallback;
+}
+function onClient(fn, fallback) {
+  return !(0, import_dom3.isServer)() ? fn() : fallback;
+}
+async function renderToString(code) {
+  const html = await (0, import_server.renderToString)(code);
+  const script = serializeHydrationData();
+  return html + script;
+}
+async function renderToStream(code) {
+  const html = await (0, import_server.renderToString)(code);
+  const script = serializeHydrationData();
+  return html + script;
+}
+function startServer(App) {
+  return {
+    /** Render the app to a full HTML string (includes hydration data) */
+    render: (url) => renderToString(() => App({ url })),
+    /** Render the app to a streamable HTML string (includes hydration data) */
+    stream: (url) => renderToStream(() => App({ url })),
+    /** Render the app to a complete HTML page document */
+    page: (url, opts) => renderToPage(() => App({ url }), opts)
+  };
+}