npm - @taujs/server - Versions diffs - 0.0.7 → 0.0.9 - Mend

@taujs/server 0.0.7 → 0.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/README.md +10 -166
package/dist/data.d.ts +49 -0
package/dist/data.js +179 -0
package/dist/{SSRServer.d.ts → index.d.ts} +17 -3
package/dist/{SSRServer.js → index.js} +64 -39
package/package.json +22 -35
package/dist/SSRDataStore.d.ts +0 -15
package/dist/SSRDataStore.js +0 -58
package/dist/SSRRender.d.ts +0 -18
package/dist/SSRRender.js +0 -31

package/README.md CHANGED Viewed

@@ -6,7 +6,7 @@
 `pnpm add @taujs/server`
-## Streaming React SSR & Hydration
+## SPA; SSR; Streaming SSR; Hydration; Fastify + React 18
 Fastify Plugin for integration with taujs [ τjs ] template https://github.com/aoede3/taujs
@@ -38,122 +38,27 @@ Integrated ViteDevServer HMR + Vite Runtime API run alongside tsx (TS eXecute) p
 ### Fastify
-```
-import { SSRServer } from '@taujs/server;
-void (await fastify.register(SSRServer, {
-    clientEntryClient: 'entry-client',
-    clientEntryServer: 'entry-server',
-    clientHtmlTemplate: 'index.html',
-    clientRoot: path.resolve(__dirname, '../client'),
-    routes,
-    serviceRegistry,
-}));
-```
+https://github.com/aoede3/taujs/blob/main/src/server/index.ts
 Not utilising taujs [ τjs ] template? Add in your own `alias` object for your own particular setup e.g. `alias: { object }`
 ### React 'entry-client.tsx'
-```
-import React from 'react';
-import { hydrateRoot } from 'react-dom/client';
-import { createSSRStore, SSRStoreProvider } from '@taujs/server/data-store';
-import AppBootstrap from './AppBootstrap';
-const bootstrap = () => {
-  const initialDataPromise = Promise.resolve(window.__INITIAL_DATA__);
-  const store = createSSRStore(initialDataPromise);
-  hydrateRoot(
-    document.getElementById('root') as HTMLElement,
-    <SSRStoreProvider store={store}>
-      <AppBootstrap />
-    </SSRStoreProvider>,
-  );
-};
-if (document.readyState !== 'loading') {
-  bootstrap();
-} else {
-  document.addEventListener('DOMContentLoaded', () => {
-    bootstrap();
-  });
-}
-```
+https://github.com/aoede3/taujs/blob/main/src/client/entry-client.tsx
 ### React 'entry-server.tsx'
 Extended pipe object with callbacks to @taujs/server enabling additional manipulation of HEAD content from client code
-```
-import { ServerResponse } from 'node:http';
-import React from 'react';
-import { createSSRStore, SSRStoreProvider } from '@taujs/server/data-store';
-import { createStreamRenderer } from '@taujs/server/render';
-import AppBootstrap from '@client/AppBootstrap';
-import type { RenderCallbacks } from '@taujs/server';
-export const streamRender = (
-  serverResponse: ServerResponse,
-  { onHead, onFinish, onError }: RenderCallbacks,
-  initialDataPromise: Promise<Record<string, unknown>>,
-  bootstrapModules: string,
-) => {
-  const store = createSSRStore(initialDataPromise);
-  const headContent = `
-    <meta name="description" content="taujs [ τjs ]">
-    <link rel="icon" type="image/svg+xml" href="/taujs.svg" />
-    <title>taujs [ τjs ]</title>
-  `;
-  createStreamRenderer(
-    serverResponse,
-    { onHead, onFinish, onError },
-    {
-      appElement: (
-        <SSRStoreProvider store={store}>
-          <AppBootstrap />
-        </SSRStoreProvider>
-      ),
-      bootstrapModules,
-      getStoreSnapshot: store.getSnapshot,
-      headContent,
-    },
-  );
-};
-```
+https://github.com/aoede3/taujs/blob/main/src/client/entry-server.tsx
 ### index.html
-```
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <!--ssr-head-->
-  </head>
-  <body>
-    <main id="root"><!--ssr-html--></main>
-  </body>
-</html>
-```
+https://github.com/aoede3/taujs/blob/main/src/client/index.html
 ### client.d.ts
-```
-interface Window {
-  __INITIAL_DATA__: Record<string, unknown>;
-}
-```
+https://github.com/aoede3/taujs/blob/main/src/client/client.d.ts
 ### Routes
@@ -172,73 +77,12 @@ In supporting Option 2. there is a registry of services. More detail in 'Service
 Each routes 'path' is a simple URL regex as per below examples.
-```
-import type { Route, RouteParams } from '@taujs/server';
-export const routes: Route<RouteParams>[] = [
-  {
-    path: '/',
-    attributes: {
-      fetch: async () => {
-        return {
-          url: 'http://localhost:5173/api/initial',
-          options: {
-            method: 'GET',
-          },
-        };
-      },
-    },
-  },
-  {
-    path: '/:id',
-    attributes: {
-      fetch: async (params: RouteParams) => {
-        return {
-          url: `http://localhost:5173/api/initial/${params.id}`,
-          options: {
-            method: 'GET',
-          },
-        };
-      },
-    },
-  },
-  {
-    path: '/:id/:another',
-    attributes: {
-      fetch: async (params: RouteParams) => {
-        return {
-          options: { params },
-          serviceMethod: 'exampleMethod',
-          serviceName: 'ServiceExample',
-        };
-      },
-    },
-  },
-];
-```
+https://github.com/aoede3/taujs/blob/main/src/shared/routes/Routes.ts
 ### Service Registry
 In supporting internal calls via τjs a registry of available services and methods provides the linkage to your own architectural setup and developmental patterns
-```
-import { ServiceExample } from './ServiceExample';
-import type { ServiceRegistry } from '@taujs/server';
-export const serviceRegistry: ServiceRegistry = {
-  ServiceExample,
-};
-```
-```
-export const ServiceExample = {
-  async exampleMethod(params: Record<string, unknown>): Promise<Record<string, unknown>> {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve({ hello: `world internal service call response with id: ${params.id} and another: ${params.another}` });
-      }, 5500);
-    });
-  },
-};
-```
+https://github.com/aoede3/taujs/blob/main/src/server/services/ServiceRegistry.ts
+https://github.com/aoede3/taujs/blob/main/src/server/services/ServiceExample.ts

package/dist/data.d.ts ADDED Viewed

@@ -0,0 +1,49 @@
+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 ADDED Viewed

@@ -0,0 +1,179 @@
+// 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 { 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.`);
+    } 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 { Writable } from "node: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
+};

package/dist/{SSRServer.d.ts → index.d.ts} RENAMED Viewed

@@ -1,6 +1,11 @@
 import { FastifyPluginAsync } from 'fastify';
 import { ServerResponse } from 'node:http';
+declare const RENDERTYPE: {
+    ssr: string;
+    streaming: string;
+};
 declare const SSRServer: FastifyPluginAsync<SSRServerOptions>;
 type ServiceRegistry = {
     [serviceName: string]: {
@@ -40,8 +45,15 @@ type Manifest = {
         assets?: string[];
     };
 };
+type RenderSSR = (initialDataResolved: Record<string, unknown>, location: string, meta?: Record<string, unknown>) => Promise<{
+    headContent: string;
+    appHtml: string;
+    initialDataScript: string;
+}>;
+type RenderStream = (serverResponse: ServerResponse, callbacks: RenderCallbacks, initialDataPromise: Promise<Record<string, unknown>>, location: string, bootstrapModules?: string, meta?: Record<string, unknown>) => void;
 type RenderModule = {
-    streamRender: (serverResponse: ServerResponse, callbacks: RenderCallbacks, initialDataPromise: Promise<Record<string, unknown>>, bootstrapModules: string) => void;
+    renderSSR: RenderSSR;
+    renderStream: RenderStream;
 };
 type RouteAttributes<Params = {}> = {
     fetch: (params?: Params, options?: RequestInit & {
@@ -54,9 +66,11 @@ type RouteAttributes<Params = {}> = {
         serviceMethod?: string;
         url?: string;
     }>;
+    meta?: Record<string, unknown>;
+    render?: typeof RENDERTYPE.ssr | typeof RENDERTYPE.streaming;
 };
 type Route<Params = {}> = {
-    attributes?: RouteAttributes<Params>;
+    attr?: RouteAttributes<Params>;
     path: string;
 };
 interface InitialRouteParams extends Record<string, unknown> {
@@ -66,4 +80,4 @@ interface InitialRouteParams extends Record<string, unknown> {
 type RouteParams = InitialRouteParams & Record<string, unknown>;
 type RoutePathsAndAttributes<Params = {}> = Omit<Route<Params>, 'element'>;
-export { type FetchConfig, type InitialRouteParams, type Manifest, type RenderCallbacks, type RenderModule, type Route, type RouteAttributes, type RouteParams, type RoutePathsAndAttributes, SSRServer, type SSRServerOptions, type ServiceRegistry };
+export { type FetchConfig, type InitialRouteParams, type Manifest, type RenderCallbacks, type RenderModule, type RenderSSR, type RenderStream, type Route, type RouteAttributes, type RouteParams, type RoutePathsAndAttributes, SSRServer, type SSRServerOptions, type ServiceRegistry };

package/dist/{SSRServer.js → index.js} RENAMED Viewed

@@ -121,7 +121,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { createViteRuntime } from "vite";
-// src/utils/index.ts
+// src/utils/Utils.ts
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { match } from "path-to-regexp";
@@ -211,9 +211,9 @@ var fetchData = async ({ url, options }) => {
   }
   throw new Error("URL must be provided to fetch data");
 };
-var fetchInitialData = async (attributes, params, serviceRegistry) => {
-  if (attributes && typeof attributes.fetch === "function") {
-    return attributes.fetch(params, {
+var fetchInitialData = async (attr, params, serviceRegistry) => {
+  if (attr && typeof attr.fetch === "function") {
+    return attr.fetch(params, {
       headers: { "Content-Type": "application/json" },
       params
     }).then(async (data) => {
@@ -257,6 +257,16 @@ var overrideCSSHMRConsoleError = () => {
   };
 };
+// src/constants.ts
+var RENDERTYPE = {
+  ssr: "ssr",
+  streaming: "streaming"
+};
+var SSRTAG = {
+  ssrHead: "<!--ssr-head-->",
+  ssrHtml: "<!--ssr-html-->"
+};
 // src/SSRServer.ts
 var SSRServer = (0, import_fastify_plugin.default)(
   async (app, opts) => {
@@ -275,6 +285,12 @@ var SSRServer = (0, import_fastify_plugin.default)(
     let template = templateHtml;
     let viteDevServer;
     let viteRuntime;
+    void await app.register(import("@fastify/static"), {
+      index: false,
+      prefix: "/",
+      root: clientRoot,
+      wildcard: false
+    });
     if (isDevelopment) {
       const { createServer } = await import("vite");
       viteDevServer = await createServer({
@@ -326,14 +342,10 @@ var SSRServer = (0, import_fastify_plugin.default)(
       });
     } else {
       renderModule = await import(path.join(clientRoot, `${clientEntryServer}.js`));
-      void await app.register(import("@fastify/static"), {
-        index: false,
-        root: path.resolve(clientRoot),
-        wildcard: false
-      });
     }
     void app.get("/*", async (req, reply) => {
       try {
+        if (/\.\w+$/.test(req.raw.url ?? "")) return reply.callNotFound();
         const url = req.url ? new URL(req.url, `http://${req.headers.host}`).pathname : "/";
         const matchedRoute = matchRoute(url, routes);
         if (!matchedRoute) {
@@ -341,41 +353,54 @@ var SSRServer = (0, import_fastify_plugin.default)(
           return;
         }
         if (isDevelopment) {
-          template = await viteDevServer.transformIndexHtml(url, template);
+          template = template.replace(/<script type="module" src="\/@vite\/client"><\/script>/g, "");
+          template = template.replace(/<style type="text\/css">[\s\S]*?<\/style>/g, "");
           renderModule = await viteRuntime.executeEntrypoint(path.join(clientRoot, `${clientEntryServer}.tsx`));
           styles = await collectStyle(viteDevServer, [`${clientRoot}/${clientEntryServer}.tsx`]);
           template = template.replace("</head>", `<style type="text/css">${styles}</style></head>`);
+          template = await viteDevServer.transformIndexHtml(url, template);
         }
-        const { streamRender } = renderModule;
         const { route, params } = matchedRoute;
-        const { attributes } = route;
-        const [beforeBody = "", afterBody] = template.split("<!--ssr-html-->");
-        const [beforeHead, afterHead] = beforeBody.split("<!--ssr-head-->");
-        const initialDataPromise = fetchInitialData(attributes, params, serviceRegistry);
-        reply.raw.writeHead(200, { "Content-Type": "text/html" });
-        reply.raw.write(beforeHead);
-        streamRender(
-          reply.raw,
-          {
-            onHead: (headContent) => {
-              let fullHeadContent = headContent;
-              if (ssrManifest) fullHeadContent += preloadLinks;
-              if (manifest) fullHeadContent += cssLinks;
-              reply.raw.write(`${fullHeadContent}${afterHead}`);
-            },
-            onFinish: async (initialDataResolved) => {
-              reply.raw.write(`<script>window.__INITIAL_DATA__ = ${JSON.stringify(initialDataResolved).replace(/</g, "\\u003c")}</script>`);
-              reply.raw.write(afterBody);
-              reply.raw.end();
+        const { attr } = route;
+        const renderType = attr?.render || RENDERTYPE.streaming;
+        const [beforeBody = "", afterBody] = template.split(SSRTAG.ssrHtml);
+        const [beforeHead, afterHead] = beforeBody.split(SSRTAG.ssrHead);
+        const initialDataPromise = fetchInitialData(attr, params, serviceRegistry);
+        if (renderType === RENDERTYPE.ssr) {
+          const { renderSSR } = renderModule;
+          const initialDataResolved = await initialDataPromise;
+          const initialDataScript = `<script>window.__INITIAL_DATA__ = ${JSON.stringify(initialDataResolved).replace(/</g, "\\u003c")}</script>`;
+          const { headContent, appHtml } = await renderSSR(initialDataResolved, req.url, attr?.meta);
+          const fullHtml = template.replace(SSRTAG.ssrHead, headContent).replace(SSRTAG.ssrHtml, `${appHtml}${initialDataScript}<script type="module" src="${bootstrapModules}" async=""></script>`);
+          return reply.status(200).header("Content-Type", "text/html").send(fullHtml);
+        } else {
+          const { renderStream } = renderModule;
+          reply.raw.writeHead(200, { "Content-Type": "text/html" });
+          renderStream(
+            reply.raw,
+            {
+              onHead: (headContent) => {
+                let aggregateHeadContent = headContent;
+                if (ssrManifest) aggregateHeadContent += preloadLinks;
+                if (manifest) aggregateHeadContent += cssLinks;
+                reply.raw.write(`${beforeHead}${aggregateHeadContent}${afterHead}`);
+              },
+              onFinish: async (initialDataResolved) => {
+                reply.raw.write(`<script>window.__INITIAL_DATA__ = ${JSON.stringify(initialDataResolved).replace(/</g, "\\u003c")}</script>`);
+                reply.raw.write(afterBody);
+                reply.raw.end();
+              },
+              onError: (error) => {
+                console.error("Critical rendering onError:", error);
+                reply.raw.end("Internal Server Error");
+              }
             },
-            onError: (error) => {
-              console.error("Critical rendering onError:", error);
-              reply.raw.end("Internal Server Error");
-            }
-          },
-          initialDataPromise,
-          bootstrapModules
-        );
+            initialDataPromise,
+            req.url,
+            bootstrapModules,
+            attr?.meta
+          );
+        }
       } catch (error) {
         console.error("Error setting up SSR stream:", error);
         if (!reply.raw.headersSent) reply.raw.writeHead(500, { "Content-Type": "text/plain" });
@@ -386,7 +411,7 @@ var SSRServer = (0, import_fastify_plugin.default)(
       if (/\.\w+$/.test(req.raw.url ?? "")) return reply.callNotFound();
       try {
         let template2 = templateHtml;
-        template2 = template2.replace("<!--ssr-head-->", "").replace("<!--ssr-html-->", "");
+        template2 = template2.replace(SSRTAG.ssrHead, "").replace(SSRTAG.ssrHtml, "");
         if (!isDevelopment) template2 = template2.replace("</head>", `${getCssLinks(manifest)}</head>`);
         template2 = template2.replace("</body>", `<script type="module" src="${bootstrapModules}" async=""></script></body>`);
         reply.status(200).type("text/html").send(template2);

package/package.json CHANGED Viewed

@@ -1,10 +1,17 @@
 {
+  "name": "@taujs/server",
+  "version": "0.0.9",
+  "description": "taujs | τjs",
   "author": "Aoede <taujs@aoede.uk.net> (https://www.aoede.uk.net)",
+  "license": "MIT",
+  "homepage": "https://github.com/aoede3/taujs-server",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aoede3/taujs-server.git"
+  },
   "bugs": {
     "url": "https://github.com/aoede3/taujs-server/issues"
   },
-  "description": "taujs | τjs",
-  "homepage": "https://github.com/aoede3/taujs-server",
   "keywords": [
     "fastify",
     "typescript",
@@ -14,46 +21,25 @@
     "react",
     "ssr"
   ],
-  "license": "MIT",
-  "name": "@taujs/server",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/aoede3/taujs-server.git"
-  },
-  "version": "0.0.7",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/SSRServer.js",
-      "types": "./dist/SSRServer.d.ts"
-    },
-    "./data-store": {
-      "import": "./dist/SSRDataStore.js",
-      "types": "./dist/SSRDataStore.d.ts"
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     },
-    "./render": {
-      "import": "./dist/SSRRender.js",
-      "types": "./dist/SSRRender.d.ts"
+    "./data": {
+      "import": "./dist/data.js",
+      "types": "./dist/data.d.ts"
     },
     "./package.json": "./package.json"
   },
   "files": [
     "dist"
   ],
-  "main": "./dist/SSRServer.js",
-  "types": "./dist/SSRServer.d.ts",
-  "typesVersions": {
-    "*": {
-      "data-store": [
-        "./dist/SSRDataStore.d.ts"
-      ],
-      "render": [
-        "./dist/SSRRender.d.ts"
-      ]
-    }
-  },
-  "type": "module",
   "dependencies": {
-    "@fastify/static": "^7.0.4",
+    "@fastify/static": "^8.0.2",
     "path-to-regexp": "^8.1.0"
   },
   "devDependencies": {
@@ -66,7 +52,7 @@
     "@types/react": "^18.3.3",
     "@types/react-dom": "^18.3.0",
     "@vitest/coverage-v8": "^2.1.0",
-    "fastify": "^4.28.0",
+    "fastify": "^5.0.0",
     "jsdom": "^25.0.0",
     "prettier": "^3.3.3",
     "react-dom": "^18.3.1",
@@ -76,7 +62,6 @@
     "vitest": "^2.0.5"
   },
   "peerDependencies": {
-    "@vitejs/plugin-react": "^4.3.1",
     "fastify": "^5.0.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
@@ -85,9 +70,11 @@
   },
   "scripts": {
     "build": "tsup",
-    "ci": "npm run build && npm run check-format && npm run check-exports && npm run lint",
+    "build-local": "tsup && ./move.sh",
+    "ci": "npm run build && npm run check-format && npm run lint",
     "lint": "tsc",
     "test": "vitest run",
+    "test:ui": "vitest --ui --coverage.enabled=true",
     "coverage": "vitest run --coverage",
     "format": "prettier --write .",
     "check-format": "prettier --check .",

package/dist/SSRDataStore.d.ts DELETED Viewed

@@ -1,15 +0,0 @@
-import React from 'react';
-type SSRStore<T> = {
-    getSnapshot: () => T;
-    getServerSnapshot: () => T;
-    setData: (newData: T) => void;
-    subscribe: (callback: () => void) => () => void;
-};
-declare const createSSRStore: <T>(initialDataPromise: Promise<T>) => SSRStore<T>;
-declare const SSRStoreProvider: React.FC<React.PropsWithChildren<{
-    store: SSRStore<Record<string, unknown>>;
-}>>;
-declare const useSSRStore: <T>() => SSRStore<T>;
-export { type SSRStore, SSRStoreProvider, createSSRStore, useSSRStore };

package/dist/SSRDataStore.js DELETED Viewed

@@ -1,58 +0,0 @@
-// src/SSRDataStore.tsx
-import { createContext, useContext, useSyncExternalStore } from "react";
-import { jsx } from "react/jsx-runtime";
-var createSSRStore = (initialDataPromise) => {
-  let currentData;
-  let status = "pending";
-  const subscribers = /* @__PURE__ */ new Set();
-  let resolvePromise = null;
-  const serverDataPromise = new Promise((resolve) => resolvePromise = resolve);
-  initialDataPromise.then((data) => {
-    currentData = data;
-    status = "success";
-    subscribers.forEach((callback) => callback());
-    if (resolvePromise) resolvePromise();
-  }).catch((error) => {
-    console.error("Failed to load initial data:", error);
-    status = "error";
-  });
-  const setData = (newData) => {
-    currentData = newData;
-    status = "success";
-    subscribers.forEach((callback) => callback());
-    if (resolvePromise) resolvePromise();
-  };
-  const subscribe = (callback) => {
-    subscribers.add(callback);
-    return () => subscribers.delete(callback);
-  };
-  const getSnapshot = () => {
-    if (status === "pending") {
-      throw initialDataPromise;
-    } 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);
-};
-export {
-  SSRStoreProvider,
-  createSSRStore,
-  useSSRStore
-};

package/dist/SSRRender.d.ts DELETED Viewed

@@ -1,18 +0,0 @@
-import { ServerResponse } from 'node:http';
-import React from 'react';
-type RenderCallbacks = {
-    onHead: (headContent: string) => void;
-    onFinish: (initialDataResolved: unknown) => void;
-    onError: (error: unknown) => void;
-};
-type StreamRender = {
-    appElement: React.JSX.Element;
-    bootstrapModules: string;
-    headContent: string;
-    getStoreSnapshot: () => unknown;
-};
-declare const createStreamRenderer: (serverResponse: ServerResponse, { onHead, onFinish, onError }: RenderCallbacks, { appElement, bootstrapModules, headContent, getStoreSnapshot }: StreamRender) => void;
-export { createStreamRenderer };

package/dist/SSRRender.js DELETED Viewed

@@ -1,31 +0,0 @@
-// src/SSRRender.ts
-import { Writable } from "node:stream";
-import "react";
-import { renderToPipeableStream } from "react-dom/server";
-var createStreamRenderer = (serverResponse, { onHead, onFinish, onError }, { appElement, bootstrapModules, headContent, getStoreSnapshot }) => {
-  const { pipe } = renderToPipeableStream(appElement, {
-    bootstrapModules: [bootstrapModules],
-    onShellReady() {
-      onHead(headContent);
-      pipe(
-        new Writable({
-          write(chunk, _encoding, callback) {
-            serverResponse.write(chunk, callback);
-          },
-          final(callback) {
-            onFinish(getStoreSnapshot());
-            callback();
-          }
-        })
-      );
-    },
-    onAllReady() {
-    },
-    onError(error) {
-      onError(error);
-    }
-  });
-};
-export {
-  createStreamRenderer
-};