npm - @teyik0/furin - Versions diffs - 0.1.0-alpha.3 - Mend

@teyik0/furin 0.1.0-alpha.3

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 (71) hide show

package/dist/adapter/bun.d.ts +3 -0
package/dist/build/client.d.ts +14 -0
package/dist/build/compile-entry.d.ts +22 -0
package/dist/build/entry-template.d.ts +13 -0
package/dist/build/hydrate.d.ts +20 -0
package/dist/build/index.d.ts +7 -0
package/dist/build/index.js +2212 -0
package/dist/build/route-types.d.ts +20 -0
package/dist/build/scan-server.d.ts +8 -0
package/dist/build/server-routes-entry.d.ts +22 -0
package/dist/build/shared.d.ts +12 -0
package/dist/build/types.d.ts +53 -0
package/dist/cli/config.d.ts +9 -0
package/dist/cli/index.d.ts +1 -0
package/dist/cli/index.js +2240 -0
package/dist/client.d.ts +158 -0
package/dist/client.js +20 -0
package/dist/config.d.ts +16 -0
package/dist/config.js +23 -0
package/dist/furin.d.ts +45 -0
package/dist/furin.js +937 -0
package/dist/internal.d.ts +18 -0
package/dist/link.d.ts +119 -0
package/dist/link.js +281 -0
package/dist/plugin/index.d.ts +20 -0
package/dist/plugin/index.js +1408 -0
package/dist/plugin/transform-client.d.ts +9 -0
package/dist/render/assemble.d.ts +13 -0
package/dist/render/cache.d.ts +7 -0
package/dist/render/element.d.ts +4 -0
package/dist/render/index.d.ts +26 -0
package/dist/render/loaders.d.ts +12 -0
package/dist/render/shell.d.ts +17 -0
package/dist/render/template.d.ts +4 -0
package/dist/router.d.ts +32 -0
package/dist/router.js +575 -0
package/dist/runtime-env.d.ts +3 -0
package/dist/tsconfig.dts.tsbuildinfo +1 -0
package/dist/utils.d.ts +6 -0
package/package.json +74 -0
package/src/adapter/README.md +13 -0
package/src/adapter/bun.ts +119 -0
package/src/build/client.ts +110 -0
package/src/build/compile-entry.ts +99 -0
package/src/build/entry-template.ts +62 -0
package/src/build/hydrate.ts +106 -0
package/src/build/index.ts +120 -0
package/src/build/route-types.ts +88 -0
package/src/build/scan-server.ts +88 -0
package/src/build/server-routes-entry.ts +38 -0
package/src/build/shared.ts +80 -0
package/src/build/types.ts +60 -0
package/src/cli/config.ts +68 -0
package/src/cli/index.ts +106 -0
package/src/client.ts +237 -0
package/src/config.ts +31 -0
package/src/furin.ts +251 -0
package/src/internal.ts +36 -0
package/src/link.tsx +480 -0
package/src/plugin/index.ts +80 -0
package/src/plugin/transform-client.ts +372 -0
package/src/render/assemble.ts +57 -0
package/src/render/cache.ts +9 -0
package/src/render/element.tsx +28 -0
package/src/render/index.ts +312 -0
package/src/render/loaders.ts +67 -0
package/src/render/shell.ts +128 -0
package/src/render/template.ts +54 -0
package/src/router.ts +234 -0
package/src/runtime-env.ts +6 -0
package/src/utils.ts +68 -0

package/dist/router.js ADDED Viewed

@@ -0,0 +1,575 @@
+// @bun
+// src/router.ts
+import { existsSync } from "fs";
+import { readdir } from "fs/promises";
+import { join, parse } from "path";
+import { Elysia } from "elysia";
+// src/internal.ts
+var _compileCtx = null;
+function getCompileContext() {
+  return _compileCtx;
+}
+// src/render/index.ts
+import { renderToReadableStream } from "react-dom/server";
+// src/render/shell.ts
+function extractTitle(meta) {
+  if (!meta) {
+    return;
+  }
+  for (const entry of meta) {
+    if ("title" in entry) {
+      return entry.title;
+    }
+  }
+  return;
+}
+function isMetaTag(entry) {
+  return !(("title" in entry) || ("charSet" in entry) || ("script:ld+json" in entry) || ("tagName" in entry));
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function safeJson(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+function renderAttrs(obj) {
+  return Object.entries(obj).filter(([, v]) => v !== undefined).map(([k, v]) => `${k}="${escapeHtml(String(v))}"`).join(" ");
+}
+function buildMetaParts(meta) {
+  const parts = [];
+  const title = extractTitle(meta);
+  if (title) {
+    parts.push(`<title>${escapeHtml(title)}</title>`);
+  }
+  for (const m of meta) {
+    if (isMetaTag(m)) {
+      parts.push(`<meta ${renderAttrs(m)} />`);
+    }
+    if ("script:ld+json" in m) {
+      parts.push(`<script type="application/ld+json">${safeJson(m["script:ld+json"])}</script>`);
+    }
+  }
+  return parts;
+}
+function buildLinkParts(links) {
+  return links.map((link) => `<link ${renderAttrs(link)} />`);
+}
+function buildScriptParts(scripts) {
+  return scripts.map((script) => {
+    const { children, ...rest } = script;
+    const attrs = renderAttrs(rest);
+    if (children) {
+      return `<script ${attrs}>${children}</script>`;
+    }
+    return `<script ${attrs}></script>`;
+  });
+}
+function buildStyleParts(styles) {
+  return styles.map((style) => {
+    const typeAttr = style.type ? ` type="${escapeHtml(style.type)}"` : "";
+    return `<style${typeAttr}>${style.children}</style>`;
+  });
+}
+function buildHeadInjection(headData) {
+  const parts = [];
+  if (headData?.meta) {
+    parts.push(...buildMetaParts(headData.meta));
+  }
+  if (headData?.links) {
+    parts.push(...buildLinkParts(headData.links));
+  }
+  if (headData?.scripts) {
+    parts.push(...buildScriptParts(headData.scripts));
+  }
+  if (headData?.styles) {
+    parts.push(...buildStyleParts(headData.styles));
+  }
+  return parts.length > 0 ? `
+  ${parts.join(`
+  `)}
+` : "";
+}
+function generateIndexHtml() {
+  return `<!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>
+    <div id="root"><!--ssr-outlet--></div>
+    <script type="module" src="./_hydrate.tsx"></script>
+  </body>
+</html>
+`;
+}
+// src/render/assemble.ts
+function resolvePath(pattern, params) {
+  let path = pattern;
+  for (const [key, val] of Object.entries(params ?? {})) {
+    path = path.replace(key === "*" ? "*" : `:${key}`, val);
+  }
+  return path;
+}
+async function streamToString(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let html = "";
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    html += decoder.decode(value, { stream: true });
+  }
+  html += decoder.decode();
+  return html;
+}
+function splitTemplate(template) {
+  const [headPre, afterHead = ""] = template.split("<!--ssr-head-->");
+  const [bodyPre, bodyPost = ""] = afterHead.split("<!--ssr-outlet-->");
+  return { headPre, bodyPre, bodyPost };
+}
+function assembleHTML(template, headData, reactHtml, data) {
+  const { headPre, bodyPre, bodyPost } = splitTemplate(template);
+  const dataScript = data ? `<script id="__FURIN_DATA__" type="application/json">${safeJson(data)}</script>` : "";
+  return headPre + headData + bodyPre + reactHtml + dataScript + bodyPost;
+}
+// src/render/cache.ts
+var isrCache = new Map;
+var ssgCache = new Map;
+// src/render/element.tsx
+import { jsxDEV } from "react/jsx-dev-runtime";
+function buildElement(route, data, rootLayout) {
+  const Component = route.page.component;
+  let element = /* @__PURE__ */ jsxDEV(Component, {
+    ...data
+  }, undefined, false, undefined, this);
+  for (let i = route.routeChain.length - 1;i >= 1; i--) {
+    const routeEntry = route.routeChain[i];
+    if (routeEntry?.layout) {
+      const Layout = routeEntry.layout;
+      element = /* @__PURE__ */ jsxDEV(Layout, {
+        ...data,
+        children: element
+      }, undefined, false, undefined, this);
+    }
+  }
+  if (rootLayout.layout) {
+    const RootLayoutComponent = rootLayout.layout;
+    element = /* @__PURE__ */ jsxDEV(RootLayoutComponent, {
+      ...data,
+      children: element
+    }, undefined, false, undefined, this);
+  }
+  return element;
+}
+// src/render/loaders.ts
+async function runLoaders(route, ctx, rootLayout) {
+  try {
+    const loaderMap = new Map;
+    const deps = (routeRef) => loaderMap.get(routeRef) ?? Promise.resolve({});
+    const rootData = rootLayout.loader ? await rootLayout.loader({ ...ctx }, deps) ?? {} : {};
+    const ctxWithRoot = { ...ctx, ...rootData };
+    for (let i = 1;i < route.routeChain.length; i++) {
+      const ancestor = route.routeChain[i];
+      if (ancestor?.loader) {
+        loaderMap.set(ancestor, Promise.resolve(ancestor.loader(ctxWithRoot, deps)).then((r) => r ?? {}));
+      }
+    }
+    const pagePromise = route.page?.loader ? Promise.resolve(route.page.loader(ctxWithRoot, deps)).then((r) => r ?? {}) : Promise.resolve({});
+    const results = await Promise.all([...loaderMap.values(), pagePromise]);
+    const data = Object.assign({}, rootData, ...results);
+    const headers = {};
+    Object.assign(headers, ctx.set.headers);
+    return { type: "data", data, headers };
+  } catch (err) {
+    if (err instanceof Response) {
+      return { type: "redirect", response: err };
+    }
+    throw err;
+  }
+}
+// src/render/template.ts
+import { readFileSync } from "fs";
+var devTemplatePromises = new Map;
+var _prodTemplatePath = null;
+var _prodTemplateContent = null;
+function getDevTemplate(origin) {
+  const cached = devTemplatePromises.get(origin);
+  if (cached) {
+    return cached;
+  }
+  const promise = fetch(`${origin}/_bun_hmr_entry`).then((r) => {
+    if (!r.ok) {
+      throw new Error(`/_bun_hmr_entry returned ${r.status}`);
+    }
+    return r.text();
+  }).catch((err) => {
+    devTemplatePromises.delete(origin);
+    throw err;
+  });
+  devTemplatePromises.set(origin, promise);
+  return promise;
+}
+function getProductionTemplate() {
+  if (_prodTemplateContent !== null) {
+    return _prodTemplateContent;
+  }
+  if (!_prodTemplatePath) {
+    return null;
+  }
+  try {
+    _prodTemplateContent = readFileSync(_prodTemplatePath, "utf8");
+    return _prodTemplateContent;
+  } catch {
+    return null;
+  }
+}
+// src/runtime-env.ts
+var IS_DEV = true;
+// src/render/index.ts
+function catchRedirect(err) {
+  if (err instanceof Response) {
+    return err;
+  }
+  throw err;
+}
+async function renderForPath(route, params, root, origin) {
+  const resolvedPath = resolvePath(route.pattern, params);
+  return await renderToHTML(route, {
+    params,
+    query: {},
+    request: new Request(`${origin}${resolvedPath}`),
+    headers: {},
+    cookie: {},
+    redirect: (url, status = 302) => new Response(null, { status, headers: { Location: url } }),
+    set: { headers: {} },
+    path: resolvedPath
+  }, root);
+}
+async function renderToHTML(route, ctx, root) {
+  const loaderResult = await runLoaders(route, ctx, root.route);
+  if (loaderResult.type === "redirect") {
+    throw loaderResult.response;
+  }
+  const { data, headers } = loaderResult;
+  const componentProps = {
+    ...data,
+    params: ctx.params,
+    query: ctx.query,
+    path: ctx.path
+  };
+  const headData = buildHeadInjection(route.page?.head?.(componentProps));
+  const element = buildElement(route, componentProps, root.route);
+  const stream = await renderToReadableStream(element);
+  await stream.allReady;
+  const reactHtml = await streamToString(stream);
+  const template = IS_DEV ? await getDevTemplate(new URL(ctx.request.url).origin) : getProductionTemplate() ?? generateIndexHtml();
+  return {
+    html: assembleHTML(template, headData, reactHtml, data),
+    headers
+  };
+}
+async function prerenderSSG(route, params, root, origin = "http://localhost:3000") {
+  const resolvedPath = resolvePath(route.pattern, params);
+  const cached = ssgCache.get(resolvedPath);
+  if (cached && !IS_DEV) {
+    return cached;
+  }
+  const result = await renderForPath(route, params, root, origin);
+  if (!IS_DEV) {
+    ssgCache.set(resolvedPath, result.html);
+  }
+  return result.html;
+}
+async function renderSSR(route, ctx, root) {
+  try {
+    const loaderResult = await runLoaders(route, ctx, root.route);
+    if (loaderResult.type === "redirect") {
+      return loaderResult.response;
+    }
+    const { data, headers } = loaderResult;
+    const componentProps = { ...data, params: ctx.params, query: ctx.query, path: ctx.path };
+    const headData = buildHeadInjection(route.page.head?.(componentProps));
+    const template = IS_DEV ? await getDevTemplate(new URL(ctx.request.url).origin) : getProductionTemplate() ?? generateIndexHtml();
+    const { headPre, bodyPre, bodyPost } = splitTemplate(template);
+    const dataScript = `<script id="__FURIN_DATA__" type="application/json">${safeJson(data)}</script>`;
+    const element = buildElement(route, componentProps, root.route);
+    const reactStream = await renderToReadableStream(element);
+    const { readable, writable } = new TransformStream;
+    const writer = writable.getWriter();
+    const enc = new TextEncoder;
+    (async () => {
+      await writer.write(enc.encode(headPre + headData + bodyPre));
+      const reader = reactStream.getReader();
+      for (;; ) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        await writer.write(value);
+      }
+      await writer.write(enc.encode(dataScript + bodyPost));
+      await writer.close();
+    })().catch((err) => writer.abort(err));
+    return new Response(readable, {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        "Cache-Control": "no-cache, no-store, must-revalidate",
+        ...headers
+      }
+    });
+  } catch (err) {
+    return catchRedirect(err);
+  }
+}
+async function handleISR(route, ctx, root) {
+  const revalidate = route.page._route.revalidate ?? 60;
+  const params = ctx.params ?? {};
+  const cacheKey = resolvePath(route.pattern, params);
+  const cached = isrCache.get(cacheKey);
+  if (cached && !IS_DEV) {
+    const age = Date.now() - cached.generatedAt;
+    const isFresh = age < revalidate * 1000;
+    if (!isFresh) {
+      revalidateInBackground(route, params, cacheKey, revalidate, root, ctx);
+    }
+    ctx.set.headers["content-type"] = "text/html; charset=utf-8";
+    ctx.set.headers["cache-control"] = isFresh ? `public, s-maxage=${revalidate}, stale-while-revalidate=${revalidate}` : "public, s-maxage=0, must-revalidate";
+    return cached.html;
+  }
+  try {
+    const result = await renderToHTML(route, ctx, root);
+    if (!IS_DEV) {
+      isrCache.set(cacheKey, { html: result.html, generatedAt: Date.now(), revalidate });
+    }
+    ctx.set.headers["content-type"] = "text/html; charset=utf-8";
+    ctx.set.headers["cache-control"] = `public, s-maxage=${revalidate}, stale-while-revalidate=${revalidate}`;
+    return result.html;
+  } catch (err) {
+    return catchRedirect(err);
+  }
+}
+function revalidateInBackground(route, params, cacheKey, revalidate, root, originalCtx) {
+  renderForPath(route, params, root, new URL(originalCtx.request.url).origin).then((result) => {
+    isrCache.set(cacheKey, {
+      html: result.html,
+      generatedAt: Date.now(),
+      revalidate
+    });
+  }).catch((err) => {
+    console.error("[furin] ISR background revalidation failed:", err);
+  });
+}
+// src/utils.ts
+function isFurinPage(value) {
+  return typeof value === "object" && value !== null && "__type" in value && value.__type === "FURIN_PAGE";
+}
+function isFurinRoute(value) {
+  return typeof value === "object" && value !== null && "__type" in value && value.__type === "FURIN_ROUTE";
+}
+function collectRouteChainFromRoute(route) {
+  const chain = [];
+  let current = route;
+  while (current) {
+    chain.unshift(current);
+    current = current.parent;
+  }
+  return chain;
+}
+function hasCycle(route) {
+  const visited = new Set;
+  let current = route;
+  while (current) {
+    if (visited.has(current)) {
+      return true;
+    }
+    visited.add(current);
+    current = current.parent;
+  }
+  return false;
+}
+function validateRouteChain(chain, root, pagePath) {
+  const hasRoot = chain.some((r) => r === root);
+  if (!hasRoot) {
+    const location = pagePath ? `in ${pagePath}` : "";
+    throw new Error(`[furin] Page ${location} must inherit from root route. ` + 'Add: import { route } from "./root"; and use route.page() or set parent: route');
+  }
+  for (const route of chain) {
+    if (hasCycle(route)) {
+      throw new Error("[furin] Cycle detected in route chain. A route cannot be its own ancestor.");
+    }
+  }
+}
+// src/router.ts
+function createRoutePlugin(route, root) {
+  const { pattern, mode, routeChain } = route;
+  const plugins = [];
+  const allParams = routeChain.find((r) => r.params)?.params;
+  const allQuery = routeChain.find((r) => r.query)?.query;
+  if (allParams || allQuery) {
+    plugins.push(new Elysia().guard({
+      params: allParams,
+      query: allQuery
+    }));
+  }
+  plugins.push(new Elysia().get(pattern, async (ctx) => {
+    switch (mode) {
+      case "ssg": {
+        ctx.set.headers["content-type"] = "text/html; charset=utf-8";
+        ctx.set.headers["cache-control"] = "public, max-age=0, must-revalidate";
+        const origin = new URL(ctx.request.url).origin;
+        return await prerenderSSG(route, ctx.params, root, origin);
+      }
+      case "isr":
+        return handleISR(route, ctx, root);
+      default:
+        return renderSSR(route, ctx, root);
+    }
+  }));
+  return plugins.reduce((app, plugin) => app.use(plugin), new Elysia);
+}
+async function scanRootLayout(pagesDir) {
+  const rootPath = `${pagesDir}/root.tsx`;
+  const ctx = getCompileContext();
+  if (!(existsSync(rootPath) || ctx?.modules[rootPath])) {
+    throw new Error("[furin] root.tsx: not found.");
+  }
+  const mod = ctx?.modules[rootPath] ?? await import(rootPath);
+  const rootExport = mod.route ?? mod.default;
+  if (!(rootExport && isFurinRoute(rootExport))) {
+    throw new Error("[furin] root.tsx: createRoute() export not found.");
+  }
+  if (!rootExport.layout) {
+    throw new Error("[furin] root.tsx: createRoute() has no layout.");
+  }
+  return { path: rootPath, route: rootExport };
+}
+async function collectPageFilePaths(dir) {
+  const files = [];
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    const absolutePath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectPageFilePaths(absolutePath));
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(absolutePath);
+    }
+  }
+  return files;
+}
+async function scanPageFiles(pagesDir, root) {
+  const routes = [];
+  for (const absolutePath of await collectPageFilePaths(pagesDir)) {
+    if (![".tsx", ".ts", ".jsx", ".js"].some((ext) => absolutePath.endsWith(ext))) {
+      continue;
+    }
+    const relativePath = absolutePath.replace(`${pagesDir}/`, "");
+    const fileName = parse(relativePath).name;
+    if (fileName.startsWith("_") || fileName === "root") {
+      continue;
+    }
+    const ctx = getCompileContext();
+    const pageMod = ctx?.modules[absolutePath] ?? await import(absolutePath);
+    const page = pageMod.default;
+    if (!isFurinPage(page)) {
+      throw new Error(`[furin] ${relativePath}: no valid createRoute().page() export found`);
+    }
+    const routeChain = collectRouteChainFromRoute(page._route);
+    validateRouteChain(routeChain, root.route, relativePath);
+    routes.push({
+      pattern: filePathToPattern(relativePath),
+      page,
+      path: absolutePath,
+      routeChain,
+      mode: resolveMode(page, routeChain)
+    });
+  }
+  return routes;
+}
+async function scanPages(pagesDir) {
+  const ctx = getCompileContext();
+  if (ctx) {
+    return loadProdRoutes(ctx);
+  }
+  const root = await scanRootLayout(pagesDir);
+  const routes = await scanPageFiles(pagesDir, root);
+  return { root, routes };
+}
+function loadProdRoutes(ctx) {
+  const rootMod = ctx.modules[ctx.rootPath];
+  const rootExport = rootMod.route ?? rootMod.default;
+  if (!(rootExport && isFurinRoute(rootExport) && rootExport.layout)) {
+    throw new Error("[furin] root.tsx: createRoute() with layout not found in CompileContext.");
+  }
+  const root = { path: ctx.rootPath, route: rootExport };
+  const routes = [];
+  for (const { pattern, path, mode } of ctx.routes) {
+    const pageMod = ctx.modules[path];
+    const page = pageMod.default;
+    if (!isFurinPage(page)) {
+      throw new Error(`[furin] ${path}: invalid page module in CompileContext.`);
+    }
+    const routeChain = collectRouteChainFromRoute(page._route);
+    validateRouteChain(routeChain, root.route, path);
+    routes.push({ pattern, page, path, routeChain, mode });
+  }
+  return { root, routes };
+}
+function resolveMode(page, routeChain) {
+  const routeConfig = page._route;
+  if (routeConfig.mode) {
+    return routeConfig.mode;
+  }
+  const hasLoader = routeChain.some((r) => r.loader) || !!page.loader;
+  if (!hasLoader) {
+    return "ssg";
+  }
+  if (routeConfig.revalidate && routeConfig.revalidate > 0) {
+    return "isr";
+  }
+  return "ssr";
+}
+function filePathToPattern(path) {
+  const parts = path.replaceAll("\\", "/").split("/");
+  const segments = [];
+  for (const part of parts) {
+    const name = parse(part).name;
+    if (name === "index") {
+      continue;
+    }
+    if (name.startsWith("[") && name.endsWith("]")) {
+      const inner = name.slice(1, -1);
+      if (inner.startsWith("...")) {
+        segments.push("*");
+        continue;
+      }
+      segments.push(`:${inner}`);
+      continue;
+    }
+    segments.push(name);
+  }
+  return `/${segments.join("/")}`;
+}
+export {
+  scanRootLayout,
+  scanPages,
+  resolveMode,
+  loadProdRoutes,
+  filePathToPattern,
+  createRoutePlugin
+};

package/dist/runtime-env.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export declare let IS_DEV: boolean;
+/** @internal test-only — overrides IS_DEV via live binding */
+export declare function __setDevMode(val: boolean): void;