@fluixi/core 1.0.0-alpha.100

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

@@ -0,0 +1,164 @@
+/**
+ * @module @fluixi/core/server
+ *
+ * Implements Unified SSR Engine compatible with Lit and JSX.
+ */
+import { serializeHydrationData, setHydrating, isHydrating, setHydrationData, getHydrationData, hasHydrationData, clearHydrationData, clearHydrationDataKey, deserializeHydrationData, hydrationMarker, hydrationMarkerStart, hydrationMarkerEnd, createHydratableResource, useHydrationData, cleanupHydration, isServerEnvironment, isClientEnvironment, } from './hydration.js';
+// SSR runs through @fluixi/server: the universal renderer + request-scoping,
+// with AsyncLocalStorage injected so concurrent renders are isolated.
+import { renderToString as domRenderToString } from '@fluixi/server';
+// ============================================================================
+// SSR CONTEXT MANAGEMENT
+// ============================================================================
+let currentSSRContext = null;
+/**
+ * Get current SSR context
+ */
+export function getSSRContext() {
+    return currentSSRContext;
+}
+/**
+ * Set SSR context
+ */
+export function setSSRContext(context) {
+    currentSSRContext = context;
+}
+/**
+ * Run function with SSR context
+ */
+export function withSSRContext(context, fn) {
+    const prev = currentSSRContext;
+    currentSSRContext = context;
+    try {
+        return fn();
+    }
+    finally {
+        currentSSRContext = prev;
+    }
+}
+// ============================================================================
+// HTML GENERATION
+// ============================================================================
+/**
+ * Render complete HTML page
+ */
+export async function renderToPage(code, options = {}) {
+    const content = await renderToString(code);
+    return createHtmlDocument(content, options);
+}
+/**
+ * Create HTML document wrapper
+ */
+export 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>`;
+}
+// ============================================================================
+// ENVIRONMENT DETECTION
+// ============================================================================
+/**
+ * Whether this is a server render.
+ *
+ * Re-exported from `@fluixi/dom`, which owns the answer: the flag lives on a realm
+ * singleton that `renderToString` sets, so it is true for the whole of a server render
+ * even in a jsdom process where `window` exists.
+ *
+ * This used to be a local `typeof window === 'undefined'`, which meant
+ * `@fluixi/core/server` and `@fluixi/core` disagreed about the same question, and the
+ * local one was wrong in exactly the case that matters. Four copies of that test were
+ * the alpha.83 SSR bug; do not add a fifth.
+ */
+export { isServer } from '@fluixi/dom';
+/** Whether this is running in a browser, which is the negation of a server render. */
+export function isClient() {
+    return !domIsServer();
+}
+/**
+ * Run `fn` only during a server render, otherwise take `fallback`.
+ *
+ * @example
+ * ```ts
+ * const secret = onServer(() => process.env.API_KEY, '');
+ * ```
+ */
+export function onServer(fn, fallback) {
+    return domIsServer() ? fn() : fallback;
+}
+/**
+ * Run `fn` only in the browser, otherwise take `fallback`.
+ *
+ * @example
+ * ```ts
+ * const width = onClient(() => window.innerWidth, 0);
+ * ```
+ */
+export function onClient(fn, fallback) {
+    return !domIsServer() ? fn() : fallback;
+}
+// ============================================================================
+// EXPORTS
+// ============================================================================
+/**
+ * Render component to HTML string
+ */
+export async function renderToString(code) {
+    const html = await domRenderToString(code);
+    const script = serializeHydrationData();
+    return html + script;
+}
+/**
+ * Render component to stream (includes hydration data)
+ */
+export async function renderToStream(code) {
+    const html = await domRenderToString(code);
+    const script = serializeHydrationData();
+    return html + script;
+}
+/**
+ * Standard server entry point.
+ * Returns an object with render/stream/page helpers
+ * for use in server frameworks (Express, Hono, Nitro, etc.)
+ *
+ * @example
+ * ```ts
+ * // entry-server.ts
+ * import { startServer } from '@fluixi/core/server';
+ * import App from './app';
+ *
+ * export default startServer(App);
+ * ```
+ */
+export 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),
+    };
+}
+// Re-export server-mapped reactive primitives
+export { createSignal, createEffect, createMemo, createRoot, batch, untrack, onCleanup, getOwner, runWithOwner, createContext, useContext, createComputed, createRenderEffect, createDeferred, createSelector, createResource, startTransition, isServer as isServerReactive, isClient as isClientReactive, } from './reactive.js';
+import { isServer as domIsServer } from '@fluixi/dom';
+// Re-export all hydration utilities
+export { isHydrating, setHydrating, setHydrationData, getHydrationData, hasHydrationData, clearHydrationData, clearHydrationDataKey, serializeHydrationData, deserializeHydrationData, hydrationMarker, hydrationMarkerStart, hydrationMarkerEnd, createHydratableResource, useHydrationData, cleanupHydration, isServerEnvironment, isClientEnvironment, };

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

@@ -0,0 +1,384 @@
+/*! @fluixi/core v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// 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 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 domIsServer();
+}
+function isClientEnvironment() {
+  return !domIsServer();
+}
+
+// src/lib/server/index.ts
+import { renderToString as domRenderToString } from "@fluixi/server";
+import { isServer as isServer2 } from "@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
+import { isServer as domIsServer2 } from "@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 !domIsServer2();
+}
+function onServer(fn, fallback) {
+  return domIsServer2() ? fn() : fallback;
+}
+function onClient(fn, fallback) {
+  return !domIsServer2() ? fn() : fallback;
+}
+async function renderToString(code) {
+  const html = await domRenderToString(code);
+  const script = serializeHydrationData();
+  return html + script;
+}
+async function renderToStream(code) {
+  const html = await domRenderToString(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)
+  };
+}
+export {
+  batch,
+  cleanupHydration,
+  clearHydrationData,
+  clearHydrationDataKey,
+  createComputed,
+  createContext,
+  createDeferred,
+  createEffect,
+  createHtmlDocument,
+  createHydratableResource,
+  createMemo,
+  createRenderEffect,
+  createResource,
+  createRoot,
+  createSelector,
+  createSignal,
+  deserializeHydrationData,
+  getHydrationData,
+  getOwner,
+  getSSRContext,
+  hasHydrationData,
+  hydrationMarker,
+  hydrationMarkerEnd,
+  hydrationMarkerStart,
+  isClient2 as isClient,
+  isClientEnvironment,
+  isClient as isClientReactive,
+  isHydrating,
+  isServer2 as isServer,
+  isServerEnvironment,
+  isServer as isServerReactive,
+  onCleanup,
+  onClient,
+  onServer,
+  renderToPage,
+  renderToStream,
+  renderToString,
+  runWithOwner,
+  serializeHydrationData,
+  setHydrating,
+  setHydrationData,
+  setSSRContext,
+  startServer,
+  startTransition,
+  untrack,
+  useContext,
+  useHydrationData,
+  withSSRContext
+};