npm - @fluixi/start - Versions diffs - 0.1.0-alpha.73 → 0.1.0-alpha.74 - Mend

@fluixi/start 0.1.0-alpha.73 → 0.1.0-alpha.74

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

package/dist/adapter.cjs +748 -0
package/dist/adapter.mjs +717 -0
package/dist/adapters/entry.cjs +122 -0
package/dist/adapters/entry.mjs +95 -0
package/dist/adapters/platforms.cjs +311 -0
package/dist/adapters/platforms.mjs +284 -0
package/dist/api-RH6E5UTH.mjs +114 -0
package/dist/api.cjs +145 -0
package/dist/api.mjs +116 -0
package/dist/commands/api-23MJFSYL.mjs +17 -0
package/dist/commands/api-4IYNQRKG.mjs +16 -0
package/dist/commands/api-RH6E5UTH.mjs +114 -0
package/dist/commands/build.cjs +870 -0
package/dist/commands/build.mjs +710 -0
package/dist/commands/chunk-NS5GR2GX.mjs +115 -0
package/dist/commands/chunk-OCPCK4ZJ.mjs +117 -0
package/dist/commands/dev.cjs +663 -0
package/dist/commands/dev.mjs +505 -0
package/dist/commands/index.cjs +1138 -0
package/dist/commands/index.mjs +975 -0
package/dist/commands/prerender.cjs +402 -0
package/dist/commands/prerender.mjs +375 -0
package/dist/commands/start.cjs +461 -0
package/dist/commands/start.mjs +426 -0
package/dist/config.cjs +144 -0
package/dist/config.mjs +108 -0
package/dist/di.cjs +200 -0
package/dist/di.mjs +169 -0
package/dist/document.cjs +115 -0
package/dist/document.mjs +86 -0
package/dist/generated-api.cjs +43 -0
package/dist/generated-api.mjs +18 -0
package/dist/generated-server-fns.cjs +43 -0
package/dist/generated-server-fns.mjs +18 -0
package/dist/handler-core.cjs +211 -0
package/dist/handler-core.mjs +185 -0
package/dist/handler.cjs +181 -0
package/dist/handler.mjs +150 -0
package/dist/head.cjs +25 -0
package/dist/head.mjs +4 -0
package/dist/image.cjs +146 -0
package/dist/image.mjs +120 -0
package/dist/index.cjs +1036 -0
package/dist/index.mjs +968 -0
package/dist/interceptors.cjs +71 -0
package/dist/interceptors.mjs +42 -0
package/dist/internal.cjs +388 -0
package/dist/internal.mjs +218 -0
package/dist/middleware.cjs +58 -0
package/dist/middleware.mjs +31 -0
package/dist/preload.cjs +42 -0
package/dist/preload.mjs +18 -0
package/dist/router.cjs +25 -0
package/dist/router.mjs +4 -0
package/dist/server-fn-setup.cjs +46 -0
package/dist/server-fn-setup.mjs +22 -0
package/dist/server-fn.cjs +109 -0
package/dist/server-fn.mjs +79 -0
package/dist/tsconfig.lib.tsbuildinfo +1 -1
package/dist/ui.cjs +123 -0
package/dist/ui.mjs +93 -0
package/package.json +45 -25

package/dist/commands/dev.mjs ADDED Viewed

@@ -0,0 +1,505 @@
+import {
+  API_VIRTUAL_MODULE,
+  isApiPath
+} from "./chunk-NS5GR2GX.mjs";
+// src/commands/dev.ts
+import { createServer as createHttp } from "node:http";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+// src/config.ts
+import { resolve, isAbsolute } from "node:path";
+function resolveConfig(config = {}) {
+  const root = resolve(config.root ?? process.cwd());
+  return {
+    root,
+    ssr: config.ssr ?? true,
+    port: config.port ?? 3e3,
+    serverEntry: config.serverEntry ?? "src/entry-server.ts",
+    clientEntry: config.clientEntry ?? "src/entry-client.ts",
+    template: config.template ?? "index.html",
+    mountId: config.mountId ?? "root",
+    routesDir: config.routesDir ?? "src/routes",
+    apiDir: config.apiDir ?? "src/api",
+    middleware: config.middleware ?? "src/middleware.ts",
+    ssrNoExternal: config.ssrNoExternal ?? [],
+    resolve: config.resolve ?? [],
+    adapter: config.adapter,
+    i18n: resolveI18n(config.i18n),
+    prerender: resolvePrerender(config.prerender)
+  };
+}
+function resolvePrerender(prerender) {
+  if (!prerender) return false;
+  const opts = typeof prerender === "object" ? prerender : {};
+  return {
+    routes: opts.routes?.length ? opts.routes : ["/"],
+    crawl: opts.crawl ?? true
+  };
+}
+function resolveI18n(i18n) {
+  if (i18n === false) return false;
+  const opts = typeof i18n === "object" ? i18n : {};
+  return {
+    dir: opts.dir ?? "src/i18n",
+    defaultLocale: opts.defaultLocale,
+    locales: opts.locales
+  };
+}
+// src/internal.ts
+import { readdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { resolve as resolvePath, relative as relativePath } from "node:path";
+// src/document.ts
+import { extractHeadMarker } from "@fluixi/head";
+function injectApp(template, appHtml, mountId = "root") {
+  const mount = new RegExp(`<div id=["']${mountId}["']\\s*>\\s*</div>`);
+  if (mount.test(template)) {
+    return template.replace(mount, `<div id="${mountId}">${appHtml}</div>`);
+  }
+  if (template.includes("<!--ssr-outlet-->")) {
+    return template.replace("<!--ssr-outlet-->", appHtml);
+  }
+  return template.replace("</body>", `<div id="${mountId}">${appHtml}</div></body>`);
+}
+function splitTemplate(template, mountId = "root") {
+  const mount = new RegExp(`<div id=["']${mountId}["']\\s*>\\s*</div>`);
+  const m = template.match(mount);
+  if (m && m.index !== void 0) {
+    return {
+      head: template.slice(0, m.index) + `<div id="${mountId}">`,
+      tail: `</div>` + template.slice(m.index + m[0].length)
+    };
+  }
+  const outlet = template.indexOf("<!--ssr-outlet-->");
+  if (outlet !== -1) {
+    return {
+      head: template.slice(0, outlet),
+      tail: template.slice(outlet + "<!--ssr-outlet-->".length)
+    };
+  }
+  const body = template.indexOf("</body>");
+  if (body !== -1) {
+    return {
+      head: template.slice(0, body) + `<div id="${mountId}">`,
+      tail: `</div>` + template.slice(body)
+    };
+  }
+  return { head: template, tail: "" };
+}
+function setHtmlAttr(html, name, value) {
+  const existing = new RegExp(`(<html\\b[^>]*?)\\s${name}="[^"]*"`, "i");
+  if (existing.test(html)) return html.replace(existing, `$1 ${name}="${value}"`);
+  return html.replace(/<html\b/i, `<html ${name}="${value}"`);
+}
+function injectAppAndHead(template, rendered, mountId = "root") {
+  const { head, body } = extractHeadMarker(rendered);
+  let html = injectApp(template, body, mountId);
+  if (head) {
+    if (head.headHtml) {
+      if (/<title[\s>]/i.test(head.headHtml)) html = html.replace(/<title>[\s\S]*?<\/title>/i, "");
+      html = html.replace("</head>", `${head.headHtml}</head>`);
+    }
+    for (const [k, v] of Object.entries(head.htmlAttrs)) html = setHtmlAttr(html, k, v);
+  }
+  return html;
+}
+function guardHandler(handler, onError) {
+  return async (request) => {
+    try {
+      return await handler(request);
+    } catch (e) {
+      onError?.(e);
+      return new Response(String(e?.stack || e), {
+        status: 500,
+        headers: { "content-type": "text/plain; charset=utf-8" }
+      });
+    }
+  };
+}
+// src/internal.ts
+var SERVER_FNS_VMOD = "virtual:fluixi-server-fns";
+var I18N_VMOD = "virtual:fluixi-i18n";
+function i18nVitePlugin(opts) {
+  let root = process.cwd();
+  const id = "\0" + I18N_VMOD;
+  return {
+    name: "fluixi-i18n",
+    configResolved(config) {
+      root = config.root || root;
+    },
+    resolveId(source) {
+      return source === I18N_VMOD ? id : null;
+    },
+    load(source) {
+      if (source !== id) return null;
+      const dir = resolvePath(root, opts.dir);
+      let files = [];
+      try {
+        files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+      } catch {
+      }
+      const discovered = files.map((f) => f.replace(/\.json$/, "")).sort();
+      const locales = opts.locales?.length ? opts.locales : discovered;
+      const defaultLocale = opts.defaultLocale ?? locales[0] ?? "en";
+      const imports = locales.map((l, i) => `import _${i} from ${JSON.stringify(resolvePath(dir, l + ".json"))};`).join("\n");
+      const messages = `export const messages = {${locales.map((l, i) => `${JSON.stringify(l)}:_${i}`).join(",")}};`;
+      return `${imports}
+export const locales = ${JSON.stringify(locales)};
+export const defaultLocale = ${JSON.stringify(defaultLocale)};
+${messages}
+`;
+    }
+  };
+}
+async function loadServerEnv(root, mode) {
+  const { loadEnv } = await import("vite");
+  const env = loadEnv(mode, root, "");
+  for (const [k, v] of Object.entries(env)) {
+    if (process.env[k] === void 0) process.env[k] = v;
+  }
+}
+function i18nTypeBlock(root, i18n) {
+  const dir = resolvePath(root, i18n.dir);
+  let discovered = [];
+  try {
+    discovered = readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, "")).sort();
+  } catch {
+  }
+  const locales = i18n.locales?.length ? i18n.locales : discovered;
+  const defaultLocale = i18n.defaultLocale ?? locales[0] ?? "en";
+  const typed = locales.length > 0 && locales.every((l) => discovered.includes(l));
+  if (!typed) {
+    return [
+      `declare module 'virtual:fluixi-i18n' {`,
+      `  export const messages: Record<string, Record<string, unknown>>;`,
+      `  export const locales: string[];`,
+      `  export const defaultLocale: string;`,
+      `}`
+    ];
+  }
+  const srcDir = resolvePath(root, "src");
+  const toSpec = (l) => {
+    const rel = relativePath(srcDir, resolvePath(dir, l + ".json")).split(/[\\/]/).join("/");
+    return rel.startsWith(".") ? rel : "./" + rel;
+  };
+  const entries = locales.map((l) => `    ${JSON.stringify(l)}: (typeof import(${JSON.stringify(toSpec(l))}))['default'];`);
+  const tuple = locales.map((l) => JSON.stringify(l)).join(", ");
+  return [
+    `declare module 'virtual:fluixi-i18n' {`,
+    `  export const messages: {`,
+    ...entries,
+    `  };`,
+    `  export const locales: readonly [${tuple}];`,
+    `  export const defaultLocale: ${JSON.stringify(defaultLocale)};`,
+    `}`
+  ];
+}
+function startTypesPlugin(cfg) {
+  let root = process.cwd();
+  return {
+    name: "fluixi-start-types",
+    configResolved(config) {
+      root = config.root || root;
+    },
+    buildStart() {
+      const blocks = [];
+      if (cfg.i18n) blocks.push(...i18nTypeBlock(root, cfg.i18n));
+      if (blocks.length === 0) return;
+      const content = `// Auto-generated by @fluixi/start — do not edit.
+${blocks.join("\n")}
+`;
+      const file = resolvePath(root, "src/fluixi-start-env.d.ts");
+      try {
+        if (!existsSync(file) || readFileSync(file, "utf8") !== content) writeFileSync(file, content);
+      } catch {
+      }
+    }
+  };
+}
+async function fluixiPlugins(cfg) {
+  const { fluixi, fluixiRoutesPlugin } = await import("@fluixi/core/plugins");
+  const { serverFunctionsVitePlugin } = await import("@fluixi/compiler/integrations");
+  const plugins = [
+    serverFunctionsVitePlugin(),
+    fluixiRoutesPlugin({ routesDir: cfg.routesDir, polyfills: false }),
+    // The app's component-resolution rules reach the compiler here; without this an SSR
+    // app has no way to say where an unimported tag comes from.
+    //
+    // `fluixi()` and not `createVitePlugin()`: the latter is the bare compiler integration,
+    // and the reactive graph — agent, source marks, /__fluixi/graph — is composed on top of
+    // it by the former. A start app got no graph at all until this changed.
+    fluixi({ resolve: cfg.resolve })
+  ];
+  if (cfg.i18n) plugins.push(i18nVitePlugin(cfg.i18n));
+  const { apiRoutesVitePlugin } = await import("./api-4IYNQRKG.mjs");
+  plugins.push(apiRoutesVitePlugin({ dir: cfg.apiDir }));
+  plugins.push(startTypesPlugin(cfg));
+  return plugins;
+}
+var _guardsInstalled = false;
+function installCrashGuards() {
+  if (_guardsInstalled) return;
+  _guardsInstalled = true;
+  process.on(
+    "unhandledRejection",
+    (reason) => console.warn("[fluixi] unhandled rejection (backend likely down) —", reason?.message || reason)
+  );
+  process.on(
+    "uncaughtException",
+    (err) => console.warn("[fluixi] uncaught exception —", err?.message || err)
+  );
+}
+// src/handler.ts
+function streamDocument(head, body, tail) {
+  const enc = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      try {
+        controller.enqueue(enc.encode(head));
+        const reader = body.getReader();
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          controller.enqueue(value);
+        }
+        controller.enqueue(enc.encode(tail));
+        controller.close();
+      } catch (err) {
+        controller.error(err);
+      }
+    }
+  });
+  return new Response(stream, {
+    status: 200,
+    headers: { "content-type": "text/html; charset=utf-8" }
+  });
+}
+function nodeToRequest(req) {
+  const host = req.headers.host ?? "localhost";
+  const url = `http://${host}${req.url ?? "/"}`;
+  const headers = new Headers();
+  for (const [k, v] of Object.entries(req.headers)) {
+    if (Array.isArray(v)) v.forEach((x) => headers.append(k, x));
+    else if (v != null) headers.set(k, v);
+  }
+  const method = req.method ?? "GET";
+  const init = { method, headers };
+  if (method !== "GET" && method !== "HEAD") {
+    init.body = req;
+    init.duplex = "half";
+  }
+  return new Request(url, init);
+}
+async function sendResponse(res, response) {
+  res.statusCode = response.status;
+  response.headers.forEach((value, key) => res.setHeader(key, value));
+  const body = response.body;
+  if (!body) {
+    res.end(await response.text().catch(() => ""));
+    return;
+  }
+  const reader = body.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      res.write(value);
+    }
+  } finally {
+    res.end();
+  }
+}
+function toNodeHandler(handler) {
+  return async (req, res) => {
+    const response = await handler(nodeToRequest(req));
+    await sendResponse(res, response);
+  };
+}
+// src/middleware.ts
+function normalizeMiddleware(mod) {
+  const def = mod?.default ?? mod;
+  if (def == null) return [];
+  if (Array.isArray(def)) return def.filter((m) => typeof m === "function");
+  return typeof def === "function" ? [def] : [];
+}
+function composeMiddleware(middlewares, core) {
+  if (middlewares.length === 0) return core;
+  return (request) => {
+    let lastCalled = -1;
+    const dispatch = (i) => {
+      if (i <= lastCalled) {
+        return Promise.reject(new Error("middleware called next() more than once"));
+      }
+      lastCalled = i;
+      const mw = middlewares[i];
+      if (!mw) return Promise.resolve(core(request));
+      return Promise.resolve(mw(request, () => dispatch(i + 1)));
+    };
+    return dispatch(0);
+  };
+}
+// src/ui.ts
+import { networkInterfaces } from "node:os";
+var COLOR = process.env.NO_COLOR || process.env.FORCE_COLOR === "0" ? false : (!!process.stdout.isTTY || !!process.env.FORCE_COLOR) && process.env.TERM !== "dumb";
+var sgr = (open, close) => (s) => COLOR ? `\x1B[${open}m${s}\x1B[${close}m` : `${s}`;
+var c = {
+  bold: sgr(1, 22),
+  dim: sgr(2, 22),
+  italic: sgr(3, 23),
+  underline: sgr(4, 24),
+  red: sgr(31, 39),
+  green: sgr(32, 39),
+  yellow: sgr(33, 39),
+  blue: sgr(34, 39),
+  magenta: sgr(35, 39),
+  cyan: sgr(36, 39),
+  gray: sgr(90, 39)
+};
+var rgb = (r, g, b) => (s) => COLOR ? `\x1B[38;2;${r};${g};${b}m${s}\x1B[39m` : s;
+var BRAND = [
+  [34, 211, 238],
+  // cyan-400
+  [56, 189, 248],
+  [129, 140, 248],
+  [167, 139, 250],
+  [192, 132, 252],
+  // violet-400
+  [217, 130, 245]
+];
+function gradient(text) {
+  if (!COLOR) return text;
+  const chars = [...text];
+  return chars.map((ch, i) => {
+    const [r, g, b] = BRAND[Math.min(BRAND.length - 1, Math.floor(i / Math.max(1, chars.length - 1) * (BRAND.length - 1)))];
+    return rgb(r, g, b)(ch);
+  }).join("");
+}
+function wordmark(version) {
+  const mark = `${gradient("◆")} ${c.bold(gradient("fluixi"))}`;
+  return version ? `${mark} ${c.dim(`v${version}`)}` : mark;
+}
+var SYM = {
+  arrow: c.gray("➜"),
+  ok: c.green("✓"),
+  err: c.red("✗")
+};
+function networkAddress() {
+  for (const list of Object.values(networkInterfaces())) {
+    for (const net of list ?? []) {
+      const family = typeof net.family === "string" ? net.family : `IPv${net.family}`;
+      if (family === "IPv4" && !net.internal) return net.address;
+    }
+  }
+  return null;
+}
+function devReady(opts) {
+  const ms = Date.now() - opts.startedAt;
+  const local = `http://localhost:${opts.port}/`;
+  const net = networkAddress();
+  const link = (u) => c.cyan(c.underline(u));
+  const label = (s) => c.gray(s.padEnd(8));
+  const lines = [
+    "",
+    `  ${wordmark(opts.version)}  ${c.gray(`dev ready in ${c.bold(String(ms))} ms`)}`,
+    "",
+    `  ${SYM.arrow} ${label("Local")} ${link(local)}`,
+    net ? `  ${SYM.arrow} ${label("Network")} ${link(`http://${net}:${opts.port}/`)}` : `  ${SYM.arrow} ${label("Network")} ${c.dim("not exposed")}`,
+    ""
+  ];
+  process.stdout.write(lines.join("\n") + "\n");
+}
+// src/commands/dev.ts
+var STYLE_FILE = /\.(css|scss|sass|less|styl|stylus|pcss|postcss)(\?|$)/;
+async function renderedStyles(vite, entry) {
+  const seen = /* @__PURE__ */ new Set();
+  const found = [];
+  const visit = (mod) => {
+    if (!mod || seen.has(mod.url)) return;
+    seen.add(mod.url);
+    if (STYLE_FILE.test(mod.url)) found.push(mod.url);
+    for (const dep of mod.importedModules ?? []) visit(dep);
+  };
+  try {
+    visit(await vite.moduleGraph.getModuleByUrl("/" + entry, true));
+  } catch {
+    return [];
+  }
+  return found;
+}
+function injectStyles(html, urls) {
+  if (urls.length === 0) return html;
+  const links = urls.map((url) => `<link rel="stylesheet" href="${url}${url.includes("?") ? "&" : "?"}direct">`).join("\n    ");
+  return html.includes("</head>") ? html.replace("</head>", `  ${links}
+  </head>`) : html;
+}
+async function dev(config = {}) {
+  const startedAt = Date.now();
+  const cfg = resolveConfig(config);
+  installCrashGuards();
+  await loadServerEnv(cfg.root, "development");
+  const { createServer } = await import("vite");
+  const template = readFileSync2(resolve2(cfg.root, cfg.template), "utf-8");
+  let vite;
+  const renderHandler = guardHandler(async (request) => {
+    const url = new URL(request.url);
+    const path = url.pathname + url.search;
+    if (url.pathname === "/_server") {
+      const sf = await vite.ssrLoadModule(SERVER_FNS_VMOD);
+      if (sf.isServerFnRequest(request)) return sf.handleServerFn(request);
+    }
+    if (isApiPath(url.pathname)) {
+      const api = await vite.ssrLoadModule(API_VIRTUAL_MODULE);
+      if (api.isApiRequest(request)) return api.handleApiRequest(request);
+    }
+    if (!cfg.ssr) {
+      const html2 = await vite.transformIndexHtml(path, template);
+      return new Response(html2, { status: 200, headers: { "content-type": "text/html; charset=utf-8" } });
+    }
+    const mod = await vite.ssrLoadModule("/" + cfg.serverEntry);
+    if (typeof mod.renderStream === "function") {
+      const shell = await vite.transformIndexHtml(
+        path,
+        injectStyles(template, await renderedStyles(vite, cfg.serverEntry))
+      );
+      const { head, tail } = splitTemplate(shell, cfg.mountId);
+      return streamDocument(head, await mod.renderStream(path, request), tail);
+    }
+    const render = mod.render ?? mod.default;
+    const appHtml = await render(path, request);
+    const styled = injectStyles(
+      injectAppAndHead(template, appHtml, cfg.mountId),
+      await renderedStyles(vite, cfg.serverEntry)
+    );
+    const html = await vite.transformIndexHtml(path, styled);
+    return new Response(html, { status: 200, headers: { "content-type": "text/html; charset=utf-8" } });
+  }, (e) => vite.ssrFixStacktrace?.(e));
+  const hasMiddleware = existsSync2(resolve2(cfg.root, cfg.middleware));
+  const handler = hasMiddleware ? guardHandler(async (request) => {
+    const mwMod = await vite.ssrLoadModule("/" + cfg.middleware);
+    return composeMiddleware(normalizeMiddleware(mwMod), renderHandler)(request);
+  }, (e) => vite.ssrFixStacktrace?.(e)) : renderHandler;
+  const nodeHandler = toNodeHandler(handler);
+  const http = createHttp((req, res) => {
+    vite.middlewares(req, res, () => nodeHandler(req, res));
+  });
+  vite = await createServer({
+    root: cfg.root,
+    plugins: await fluixiPlugins(cfg),
+    // file routing + JSX/SSR transform (fluixi)
+    server: { middlewareMode: true, hmr: { server: http } },
+    appType: "custom",
+    ssr: cfg.ssrNoExternal.length ? { noExternal: cfg.ssrNoExternal } : void 0
+  });
+  http.listen(cfg.port, () => devReady({ port: cfg.port, startedAt }));
+}
+export {
+  dev
+};