@fluixi/core 1.0.0-alpha.100

package/dist/src/lib/plugins/fluixi-routes-plugin.cjs

@@ -0,0 +1,302 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/plugins/fluixi-routes-plugin.ts
+var fluixi_routes_plugin_exports = {};
+__export(fluixi_routes_plugin_exports, {
+  fluixiRoutesPlugin: () => fluixiRoutesPlugin
+});
+module.exports = __toCommonJS(fluixi_routes_plugin_exports);
+var path2 = __toESM(require("path"), 1);
+var import_vite_plugin_node_polyfills = require("vite-plugin-node-polyfills");
+
+// src/lib/plugins/route-scanner.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var DEFAULT_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+function scanRoutes(routesDir, options = {}) {
+  const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+  const absDir = path.resolve(routesDir);
+  if (!fs.existsSync(absDir)) {
+    return [];
+  }
+  return scanDirectory(absDir, absDir, "", extensions);
+}
+function scanDirectory(dir, rootDir, parentUrlPath, extensions) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const routes = [];
+  const layoutRoute = null;
+  const files = [];
+  const dirs = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      dirs.push(entry);
+    } else if (entry.isFile() && hasValidExtension(entry.name, extensions)) {
+      files.push(entry);
+    }
+  }
+  let layout;
+  const nonLayoutFiles = [];
+  for (const file of files) {
+    const baseName = stripExtension(file.name);
+    if (baseName === "layout") {
+      layout = buildFileRoute(file.name, dir, rootDir, parentUrlPath, true);
+    } else {
+      nonLayoutFiles.push(file);
+    }
+  }
+  const fileRoutes = [];
+  for (const file of nonLayoutFiles) {
+    fileRoutes.push(
+      buildFileRoute(file.name, dir, rootDir, parentUrlPath, false)
+    );
+  }
+  const dirRoutes = [];
+  for (const d of dirs) {
+    const dirName = d.name;
+    const isGroup = isRouteGroup(dirName);
+    const segment = isGroup ? "" : dirNameToSegment(dirName);
+    const childUrlPath = segment ? joinUrlPath(parentUrlPath, segment) : parentUrlPath;
+    const children = scanDirectory(
+      path.join(dir, dirName),
+      rootDir,
+      childUrlPath,
+      extensions
+    );
+    if (isGroup) {
+      dirRoutes.push(...children);
+    } else {
+      const childLayout = children.find((c) => c.isLayout && c.urlPath === childUrlPath);
+      const childNonLayout = children.filter((c) => !c.isLayout || c.urlPath !== childUrlPath);
+      if (childLayout) {
+        childLayout.children = [...childLayout.children, ...childNonLayout];
+        dirRoutes.push(childLayout);
+      } else if (childNonLayout.length > 0) {
+        dirRoutes.push(...childNonLayout);
+      }
+    }
+  }
+  if (layout) {
+    layout.children = [...fileRoutes, ...dirRoutes];
+    routes.push(layout);
+  } else {
+    routes.push(...fileRoutes, ...dirRoutes);
+  }
+  return sortRoutes(routes);
+}
+function buildFileRoute(fileName, dir, rootDir, parentUrlPath, isLayout) {
+  const baseName = stripExtension(fileName);
+  const filePath = path.relative(rootDir, path.join(dir, fileName));
+  const isIndex = baseName === "index";
+  const isCatchAll = baseName.startsWith("[...");
+  const isDynamic = !isCatchAll && baseName.startsWith("[") && baseName.endsWith("]");
+  let urlSegment;
+  if (isLayout) {
+    urlSegment = "";
+  } else if (isIndex) {
+    urlSegment = "/";
+  } else if (isCatchAll) {
+    const paramName = baseName.slice(4, -1);
+    urlSegment = `*${paramName}`;
+  } else if (isDynamic) {
+    const paramName = baseName.slice(1, -1);
+    urlSegment = `:${paramName}`;
+  } else {
+    urlSegment = baseName;
+  }
+  const urlPath = isLayout ? parentUrlPath || "/" : isIndex ? parentUrlPath || "/" : joinUrlPath(parentUrlPath, urlSegment);
+  const absoluteFilePath = path.join(dir, fileName);
+  let hasRouteData = false;
+  try {
+    const content = fs.readFileSync(absoluteFilePath, "utf-8");
+    hasRouteData = /export\s+(const|function|async\s+function)\s+routeData\b/.test(content);
+  } catch {
+  }
+  return {
+    filePath: filePath.replace(/\\/g, "/"),
+    // normalize to forward slashes
+    urlSegment,
+    urlPath,
+    isLayout,
+    isIndex,
+    isDynamic,
+    isCatchAll,
+    isGroup: false,
+    children: [],
+    parentUrlPath,
+    hasRouteData,
+    rootDir,
+    dir
+  };
+}
+function hasValidExtension(fileName, extensions) {
+  return extensions.some((ext) => fileName.endsWith(ext));
+}
+function stripExtension(fileName) {
+  const lastDot = fileName.lastIndexOf(".");
+  return lastDot > 0 ? fileName.slice(0, lastDot) : fileName;
+}
+function isRouteGroup(dirName) {
+  return dirName.startsWith("(") && dirName.endsWith(")");
+}
+function dirNameToSegment(dirName) {
+  if (dirName.startsWith("[...") && dirName.endsWith("]")) {
+    return "*" + dirName.slice(4, -1);
+  }
+  if (dirName.startsWith("[") && dirName.endsWith("]")) {
+    return ":" + dirName.slice(1, -1);
+  }
+  return dirName;
+}
+function joinUrlPath(parent, segment) {
+  const base = parent.endsWith("/") ? parent : parent + "/";
+  return base + segment;
+}
+function sortRoutes(routes) {
+  return routes.sort((a, b) => {
+    if (a.isLayout && !b.isLayout) return -1;
+    if (!a.isLayout && b.isLayout) return 1;
+    if (a.isIndex && !b.isIndex) return -1;
+    if (!a.isIndex && b.isIndex) return 1;
+    if (!a.isDynamic && !a.isCatchAll && (b.isDynamic || b.isCatchAll)) return -1;
+    if ((a.isDynamic || a.isCatchAll) && !b.isDynamic && !b.isCatchAll) return 1;
+    if (a.isDynamic && b.isCatchAll) return -1;
+    if (a.isCatchAll && b.isDynamic) return 1;
+    return a.urlSegment.localeCompare(b.urlSegment);
+  });
+}
+
+// src/lib/plugins/route-codegen.ts
+function generateRouteModule(routes, routesDir) {
+  const lines = [];
+  lines.push(`// Auto-generated by fluixi route plugin`);
+  lines.push(`// Do not edit manually`);
+  lines.push(``);
+  lines.push(`import { lazy } from '@fluixi/core/router';`);
+  lines.push(``);
+  lines.push(`export const routes = ${generateRouteArray(routes, routesDir, 0)};`);
+  lines.push(``);
+  return lines.join("\n");
+}
+function generateRouteArray(routes, routesDir, depth) {
+  if (routes.length === 0) return "[]";
+  const indent = "  ".repeat(depth);
+  const items = routes.map((route) => generateRouteObject(route, routesDir, depth + 1));
+  return `[
+${items.join(",\n")}
+${indent}]`;
+}
+function generateRouteObject(route, routesDir, depth) {
+  const indent = "  ".repeat(depth);
+  const props = [];
+  const importPath = buildImportPath(route.filePath, routesDir);
+  const routePath = computeRoutePath(route);
+  props.push(`${indent}  path: ${JSON.stringify(routePath)}`);
+  props.push(`${indent}  component: lazy(() => import(${JSON.stringify(importPath)}))`);
+  if (route.hasRouteData) {
+    props.push(
+      `${indent}  data: (args, __owner, __isCancelled, __deps) => import(${JSON.stringify(
+        importPath
+      )}).then(m => { if (typeof __isCancelled === 'function' && __isCancelled()) return undefined; if (!m.routeData) return undefined; if (typeof m.routeDeps === 'function') { if (typeof __deps === 'function') __deps(m.routeDeps); args = { ...args, deps: m.routeDeps() }; } return m.routeData(args); })`
+    );
+  }
+  if (route.children.length > 0) {
+    const childArray = generateRouteArray(route.children, routesDir, depth + 1);
+    props.push(`${indent}  children: ${childArray}`);
+  }
+  return `${indent}{
+${props.join(",\n")}
+${indent}}`;
+}
+function computeRoutePath(route) {
+  return route.urlPath;
+}
+function buildImportPath(filePath, routesDir) {
+  const base = routesDir.replace(/\\/g, "/").replace(/\/$/, "");
+  return `${base}/${filePath}`;
+}
+
+// src/lib/plugins/fluixi-routes-plugin.ts
+var VIRTUAL_MODULE_ID = "virtual:fluixi-routes";
+var RESOLVED_VIRTUAL_ID = "\0" + VIRTUAL_MODULE_ID;
+var PUBLIC_MODULE_ID = "@fluixi/core/routes";
+function fluixiRoutesPlugin(options = {}) {
+  const routesDir = options.routesDir ?? "src/routes";
+  const extensions = options.extensions ?? [".tsx", ".ts", ".jsx", ".js"];
+  let projectRoot = "";
+  let lastGenerated = null;
+  function generateModule(root) {
+    const absRoutesDir = path2.resolve(root, routesDir);
+    const scanOpts = { extensions };
+    const routes = scanRoutes(absRoutesDir, scanOpts);
+    return generateRouteModule(routes, "./" + routesDir);
+  }
+  const usePolyfills = options.polyfills !== false;
+  const polyfillsPlugin = usePolyfills ? Object.assign({}, (0, import_vite_plugin_node_polyfills.nodePolyfills)({ include: ["fs", "path"] }), { apply: "serve" }) : null;
+  const routesPlugin = {
+    name: "fluixi-routes",
+    enforce: "pre",
+    configResolved(config) {
+      projectRoot = config.root || process.cwd();
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_MODULE_ID || id === PUBLIC_MODULE_ID) {
+        return RESOLVED_VIRTUAL_ID;
+      }
+      return null;
+    },
+    load(id) {
+      if (id !== RESOLVED_VIRTUAL_ID) return null;
+      lastGenerated = generateModule(projectRoot || process.cwd());
+      return lastGenerated;
+    },
+    // Vite dev server: watch routes directory for changes
+    configureServer(server) {
+      const root = projectRoot || process.cwd();
+      const absRoutesDir = path2.resolve(root, routesDir);
+      server.watcher.add(absRoutesDir);
+      server.watcher.on("all", (event, filePath) => {
+        if (!filePath.startsWith(absRoutesDir)) return;
+        if (!["add", "unlink", "addDir", "unlinkDir", "change"].includes(event)) return;
+        if (event !== "addDir" && event !== "unlinkDir" && !extensions.some((ext) => filePath.endsWith(ext))) {
+          return;
+        }
+        const next = generateModule(root);
+        if (next === lastGenerated) return;
+        lastGenerated = next;
+        const mod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ID);
+        if (mod) {
+          server.moduleGraph.invalidateModule(mod);
+          server.ws.send({ type: "full-reload" });
+        }
+      });
+    }
+  };
+  return polyfillsPlugin ? [polyfillsPlugin, routesPlugin] : [routesPlugin];
+}

package/dist/src/lib/plugins/fluixi-routes-plugin.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @module @fluixi/core/plugins/fluixi-routes-plugin
+ *
+ * Scans a routes directory at build time and generates a virtual module
+ * (virtual:fluixi-routes) containing the route tree. Replaces import.meta.glob.
+ */
+export interface FluixiRoutesPluginOptions {
+    /** Path to routes directory, relative to project root. Default: 'src/routes' */
+    routesDir?: string;
+    /** File extensions to scan. Default: ['.tsx', '.ts', '.jsx', '.js'] */
+    extensions?: string[];
+    /**
+     * Inject browser polyfills for Node built-ins (Buffer/process/global/fs/path) via
+     * vite-plugin-node-polyfills. Default `true` (back-compat). Set `false` for SSR
+     * (the injected shims break server rendering); `@fluixi/start` passes `false`.
+     */
+    polyfills?: boolean;
+}
+/**
+ * The Vite plugin that turns a routes directory into a route tree.
+ *
+ * Scans `routesDir` and serves the result as `@fluixi/core/routes`, so an app imports a
+ * real module from this package and needs no generated `declare module` of its own. The
+ * shipped file is a typed empty array, which is what the plugin replaces.
+ *
+ * Without it that import resolves to the empty array and an app has no routes, which is
+ * the error `routes.ts` raises rather than rendering a blank page.
+ *
+ * @example
+ * ```ts
+ * export default defineConfig({ plugins: [fluixiRoutesPlugin({ routesDir: 'src/routes' })] });
+ * ```
+ */
+export declare function fluixiRoutesPlugin(options?: FluixiRoutesPluginOptions): any[];
+//# sourceMappingURL=fluixi-routes-plugin.d.ts.map

package/dist/src/lib/plugins/fluixi-routes-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluixi-routes-plugin.d.ts","sourceRoot":"","sources":["../../../../src/lib/plugins/fluixi-routes-plugin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,MAAM,WAAW,yBAAyB;IACxC,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAcD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,GAAE,yBAA8B,GACtC,GAAG,EAAE,CA+FP"}

package/dist/src/lib/plugins/fluixi-routes-plugin.js

@@ -0,0 +1,118 @@
+/**
+ * @module @fluixi/core/plugins/fluixi-routes-plugin
+ *
+ * Scans a routes directory at build time and generates a virtual module
+ * (virtual:fluixi-routes) containing the route tree. Replaces import.meta.glob.
+ */
+import * as path from 'path';
+import { nodePolyfills } from 'vite-plugin-node-polyfills';
+import { scanRoutes } from './route-scanner.js';
+import { generateRouteModule } from './route-codegen.js';
+const VIRTUAL_MODULE_ID = 'virtual:fluixi-routes';
+const RESOLVED_VIRTUAL_ID = '\0' + VIRTUAL_MODULE_ID;
+/**
+ * The public specifier. A real module in this package, so its types come from here and an
+ * app needs no generated `declare module` in its own `src/`. The plugin swaps in the
+ * scanned tree; the shipped file is a typed empty array.
+ *
+ * `virtual:fluixi-routes` stays resolvable so existing apps keep working.
+ */
+const PUBLIC_MODULE_ID = '@fluixi/core/routes';
+/**
+ * The Vite plugin that turns a routes directory into a route tree.
+ *
+ * Scans `routesDir` and serves the result as `@fluixi/core/routes`, so an app imports a
+ * real module from this package and needs no generated `declare module` of its own. The
+ * shipped file is a typed empty array, which is what the plugin replaces.
+ *
+ * Without it that import resolves to the empty array and an app has no routes, which is
+ * the error `routes.ts` raises rather than rendering a blank page.
+ *
+ * @example
+ * ```ts
+ * export default defineConfig({ plugins: [fluixiRoutesPlugin({ routesDir: 'src/routes' })] });
+ * ```
+ */
+export function fluixiRoutesPlugin(options = {}) {
+    const routesDir = options.routesDir ?? 'src/routes';
+    const extensions = options.extensions ?? ['.tsx', '.ts', '.jsx', '.js'];
+    let projectRoot = '';
+    /** The module body most recently served, so the watcher can tell a real change from a save. */
+    let lastGenerated = null;
+    function generateModule(root) {
+        const absRoutesDir = path.resolve(root, routesDir);
+        const scanOpts = { extensions };
+        const routes = scanRoutes(absRoutesDir, scanOpts);
+        // Import paths are relative to project root, prefixed with ./
+        return generateRouteModule(routes, './' + routesDir);
+    }
+    // nodePolyfills injects `vite-plugin-node-polyfills/shims/*` (browser polyfills for
+    // Buffer/process/global/fs/path) into transformed modules. It's needed by some apps
+    // for the BROWSER, but it BREAKS SSR. Node already has those globals, and the
+    // injected CJS shim can't be ESM-evaluated (and often can't be resolved at all:
+    // "Cannot find module .../shims/buffer"). So it's opt-out: on by default for
+    // back-compat, but SSR-first setups (e.g. @fluixi/start) pass `polyfills: false`.
+    const usePolyfills = options.polyfills !== false;
+    const polyfillsPlugin = usePolyfills
+        ? Object.assign({}, nodePolyfills({ include: ['fs', 'path'] }), { apply: 'serve' })
+        : null;
+    const routesPlugin = {
+        name: 'fluixi-routes',
+        enforce: 'pre',
+        configResolved(config) {
+            projectRoot = config.root || process.cwd();
+        },
+        resolveId(id) {
+            if (id === VIRTUAL_MODULE_ID || id === PUBLIC_MODULE_ID) {
+                return RESOLVED_VIRTUAL_ID;
+            }
+            return null;
+        },
+        load(id) {
+            if (id !== RESOLVED_VIRTUAL_ID)
+                return null;
+            lastGenerated = generateModule(projectRoot || process.cwd());
+            return lastGenerated;
+        },
+        // Vite dev server: watch routes directory for changes
+        configureServer(server) {
+            const root = projectRoot || process.cwd();
+            const absRoutesDir = path.resolve(root, routesDir);
+            // Watch the routes directory
+            server.watcher.add(absRoutesDir);
+            server.watcher.on('all', (event, filePath) => {
+                if (!filePath.startsWith(absRoutesDir))
+                    return;
+                // `change` matters as much as add/unlink. The route tree is not only a list of
+                // files: `routeData` is detected by reading each file at scan time, so EDITING a
+                // route, adding a `routeData` export, or changing one, changes the generated
+                // module even though no file appeared or vanished. Leaving `change` out meant
+                // those edits needed a dev-server restart to take effect.
+                if (!['add', 'unlink', 'addDir', 'unlinkDir', 'change'].includes(event))
+                    return;
+                // Check if the file has a valid extension
+                if (event !== 'addDir' &&
+                    event !== 'unlinkDir' &&
+                    !extensions.some((ext) => filePath.endsWith(ext))) {
+                    return;
+                }
+                // Regenerate and compare before invalidating. Every save of a route component now
+                // reaches this handler, and most change nothing about the tree: reloading the
+                // page on each of them would undo the point of HMR. A full reload is only correct
+                // when the generated module actually differs.
+                const next = generateModule(root);
+                if (next === lastGenerated)
+                    return;
+                lastGenerated = next;
+                const mod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ID);
+                if (mod) {
+                    server.moduleGraph.invalidateModule(mod);
+                    server.ws.send({ type: 'full-reload' });
+                }
+            });
+        },
+    };
+    // Vite flattens plugin arrays automatically: consumers just use:
+    //   plugins: [fluixiRoutesPlugin({ routesDir: 'src/routes' })]
+    return polyfillsPlugin ? [polyfillsPlugin, routesPlugin] : [routesPlugin];
+}