@taujs/server 0.1.9 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taujs/server",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "description": "taujs | τjs",
   "author": "Aoede <taujs@aoede.uk.net> (https://www.aoede.uk.net)",
   "license": "MIT",
@@ -58,7 +58,7 @@
     "react-dom": "^19.0.0",
     "tsup": "^8.2.4",
     "typescript": "^5.5.4",
-    "vite": "^5.4.2",
+    "vite": "^6.3.5",
     "vitest": "^2.0.5"
   },
   "peerDependencies": {
@@ -66,7 +66,7 @@
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "typescript": "^5.5.4",
-    "vite": "^6.2.5"
+    "vite": "^6.3.5"
   },
   "scripts": {
     "build": "tsup",

package/dist/data.d.ts

@@ -1,49 +0,0 @@
-import React from 'react';
-import { ServerResponse } from 'node:http';
-
-type SSRStore<T> = {
-    getSnapshot: () => T;
-    getServerSnapshot: () => T;
-    setData: (newData: T) => void;
-    subscribe: (callback: () => void) => () => void;
-};
-declare const createSSRStore: <T>(initialDataOrPromise: T | Promise<T>) => SSRStore<T>;
-declare const SSRStoreProvider: React.FC<React.PropsWithChildren<{
-    store: SSRStore<Record<string, unknown>>;
-}>>;
-declare const useSSRStore: <T>() => T;
-
-type HydrateAppOptions = {
-    appComponent: React.ReactElement;
-    initialDataKey?: keyof Window;
-    rootElementId?: string;
-    debug?: boolean;
-};
-declare const hydrateApp: ({ appComponent, initialDataKey, rootElementId, debug }: HydrateAppOptions) => void;
-
-type RendererOptions = {
-    appComponent: (props: {
-        location: string;
-    }) => React.ReactElement;
-    headContent: string | ((data: Record<string, unknown>) => string);
-};
-type RenderCallbacks = {
-    onHead: (headContent: string) => void;
-    onFinish: (initialDataResolved: unknown) => void;
-    onError: (error: unknown) => void;
-};
-declare const resolveHeadContent: (headContent: string | ((meta: Record<string, unknown>) => string), meta?: Record<string, unknown>) => string;
-declare const createRenderer: ({ appComponent, headContent }: RendererOptions) => {
-    renderSSR: (initialDataResolved: Record<string, unknown>, location: string, meta?: Record<string, unknown>) => Promise<{
-        headContent: string;
-        appHtml: string;
-    }>;
-    renderStream: (serverResponse: ServerResponse, callbacks: RenderCallbacks, initialDataResolved: Record<string, unknown>, location: string, bootstrapModules?: string, meta?: Record<string, unknown>) => void;
-};
-declare const createRenderStream: (serverResponse: ServerResponse, { onHead, onFinish, onError }: RenderCallbacks, { appComponent, headContent, initialDataResolved, location, bootstrapModules, }: RendererOptions & {
-    initialDataResolved: Record<string, unknown>;
-    location: string;
-    bootstrapModules?: string;
-}) => void;
-
-export { type SSRStore, SSRStoreProvider, createRenderStream, createRenderer, createSSRStore, hydrateApp, resolveHeadContent, useSSRStore };

package/dist/data.js

@@ -1,182 +0,0 @@
-// src/SSRDataStore.tsx
-import { createContext, useContext, useSyncExternalStore } from "react";
-import { jsx } from "react/jsx-runtime";
-var createSSRStore = (initialDataOrPromise) => {
-  let currentData;
-  let status;
-  const subscribers = /* @__PURE__ */ new Set();
-  let serverDataPromise;
-  if (initialDataOrPromise instanceof Promise) {
-    status = "pending";
-    serverDataPromise = initialDataOrPromise.then((data) => {
-      currentData = data;
-      status = "success";
-      subscribers.forEach((callback) => callback());
-    }).catch((error) => {
-      console.error("Failed to load initial data:", error);
-      status = "error";
-    }).then(() => {
-    });
-  } else {
-    currentData = initialDataOrPromise;
-    status = "success";
-    serverDataPromise = Promise.resolve();
-  }
-  const setData = (newData) => {
-    currentData = newData;
-    status = "success";
-    subscribers.forEach((callback) => callback());
-  };
-  const subscribe = (callback) => {
-    subscribers.add(callback);
-    return () => subscribers.delete(callback);
-  };
-  const getSnapshot = () => {
-    if (status === "pending") {
-      throw serverDataPromise;
-    } else if (status === "error") {
-      throw new Error("An error occurred while fetching the data.");
-    }
-    return currentData;
-  };
-  const getServerSnapshot = () => {
-    if (status === "pending") {
-      throw serverDataPromise;
-    } else if (status === "error") {
-      throw new Error("Data is not available on the server.");
-    }
-    return currentData;
-  };
-  return { getSnapshot, getServerSnapshot, setData, subscribe };
-};
-var SSRStoreContext = createContext(null);
-var SSRStoreProvider = ({ store, children }) => /* @__PURE__ */ jsx(SSRStoreContext.Provider, { value: store, children });
-var useSSRStore = () => {
-  const store = useContext(SSRStoreContext);
-  if (!store) throw new Error("useSSRStore must be used within a SSRStoreProvider");
-  return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot);
-};
-
-// src/SSRHydration.tsx
-import React2 from "react";
-import { createRoot, hydrateRoot } from "react-dom/client";
-
-// src/utils/Logger.ts
-var createLogger = (debug) => ({
-  log: (...args) => {
-    if (debug) console.log(...args);
-  },
-  warn: (...args) => {
-    if (debug) console.warn(...args);
-  },
-  error: (...args) => {
-    if (debug) console.error(...args);
-  }
-});
-
-// src/SSRHydration.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
-var hydrateApp = ({ appComponent, initialDataKey = "__INITIAL_DATA__", rootElementId = "root", debug = false }) => {
-  const { log, warn, error } = createLogger(debug);
-  const bootstrap = () => {
-    log("Hydration started");
-    const rootElement = document.getElementById(rootElementId);
-    if (!rootElement) {
-      error(`Root element with id "${rootElementId}" not found.`);
-      return;
-    }
-    const initialData = window[initialDataKey];
-    if (!initialData) {
-      warn(`Initial data key "${initialDataKey}" is undefined on window. Defaulting to SPA createRoot`);
-      const root = createRoot(rootElement);
-      root.render(/* @__PURE__ */ jsx2(React2.StrictMode, { children: appComponent }));
-    } else {
-      log("Initial data loaded:", initialData);
-      const initialDataPromise = Promise.resolve(initialData);
-      const store = createSSRStore(initialDataPromise);
-      log("Store created:", store);
-      hydrateRoot(
-        rootElement,
-        /* @__PURE__ */ jsx2(React2.StrictMode, { children: /* @__PURE__ */ jsx2(SSRStoreProvider, { store, children: appComponent }) })
-      );
-      log("Hydration completed");
-    }
-  };
-  if (document.readyState !== "loading") {
-    bootstrap();
-  } else {
-    document.addEventListener("DOMContentLoaded", bootstrap);
-  }
-};
-
-// src/SSRRender.tsx
-import "http";
-import { Writable } from "stream";
-import "react";
-import { renderToPipeableStream, renderToString } from "react-dom/server";
-import { jsx as jsx3 } from "react/jsx-runtime";
-var resolveHeadContent = (headContent, meta = {}) => typeof headContent === "function" ? headContent(meta) : headContent;
-var createRenderer = ({ appComponent, headContent }) => {
-  const renderSSR = async (initialDataResolved, location, meta = {}) => {
-    const dataForHeadContent = Object.keys(initialDataResolved).length > 0 ? initialDataResolved : meta;
-    const dynamicHeadContent = resolveHeadContent(headContent, dataForHeadContent);
-    const appHtml = renderToString(/* @__PURE__ */ jsx3(SSRStoreProvider, { store: createSSRStore(initialDataResolved), children: appComponent({ location }) }));
-    return {
-      headContent: dynamicHeadContent,
-      appHtml
-    };
-  };
-  const renderStream = (serverResponse, callbacks, initialDataResolved, location, bootstrapModules, meta = {}) => {
-    const dynamicHeadContent = resolveHeadContent(headContent, meta);
-    createRenderStream(serverResponse, callbacks, {
-      appComponent: (props) => appComponent({ ...props, location }),
-      headContent: dynamicHeadContent,
-      initialDataResolved,
-      location,
-      bootstrapModules
-    });
-  };
-  return { renderSSR, renderStream };
-};
-var createRenderStream = (serverResponse, { onHead, onFinish, onError }, {
-  appComponent,
-  headContent,
-  initialDataResolved,
-  location,
-  bootstrapModules
-}) => {
-  const store = createSSRStore(initialDataResolved);
-  const appElement = /* @__PURE__ */ jsx3(SSRStoreProvider, { store, children: appComponent({ location }) });
-  const { pipe } = renderToPipeableStream(appElement, {
-    bootstrapModules: bootstrapModules ? [bootstrapModules] : void 0,
-    onShellReady() {
-      const dynamicHeadContent = resolveHeadContent(headContent, initialDataResolved);
-      onHead(dynamicHeadContent);
-      pipe(
-        new Writable({
-          write(chunk, _encoding, callback) {
-            serverResponse.write(chunk, callback);
-          },
-          final(callback) {
-            onFinish(store.getSnapshot());
-            callback();
-          }
-        })
-      );
-    },
-    onAllReady() {
-    },
-    onError(error) {
-      onError(error);
-    }
-  });
-};
-export {
-  SSRStoreProvider,
-  createRenderStream,
-  createRenderer,
-  createSSRStore,
-  hydrateApp,
-  resolveHeadContent,
-  useSSRStore
-};