@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.0

package/dist/cjs/runtime/utils.js

@@ -0,0 +1,142 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createRouteObjectsFromConfig: ()=>createRouteObjectsFromConfig,
+    getRouteObjects: ()=>getRouteObjects,
+    standardSlash: ()=>standardSlash,
+    urlJoin: ()=>urlJoin
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const external_DefaultNotFound_js_namespaceObject = require("./DefaultNotFound.js");
+function getRouteObjects(routes, { globalApp, ssrMode, props }) {
+    const createLayoutElement = (Component)=>{
+        const GlobalLayout = globalApp;
+        if (!GlobalLayout) return Component;
+        const LayoutWrapper = (props)=>{
+            const LayoutComponent = GlobalLayout;
+            return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(LayoutComponent, {
+                Component: Component,
+                ...props
+            });
+        };
+        return LayoutWrapper;
+    };
+    const routeObjects = [];
+    for (const route of routes)if ('nested' === route.type) {
+        const nestedRouteObject = {
+            path: route.path,
+            id: route.id,
+            loader: route.loader,
+            action: route.action,
+            hasErrorBoundary: route.hasErrorBoundary,
+            shouldRevalidate: route.shouldRevalidate,
+            handle: {
+                ...route.handle,
+                ...'object' == typeof route.config ? route.config?.handle : {}
+            },
+            index: route.index,
+            hasLoader: Boolean(route.loader),
+            hasClientLoader: Boolean(route.clientData),
+            hasAction: Boolean(route.action),
+            ...route.isClientComponent ? {
+                isClientComponent: true
+            } : {},
+            ...route.inValidSSRRoute ? {
+                inValidSSRRoute: true
+            } : {},
+            lazyImport: route.lazyImport,
+            Component: route.component ? route.component : void 0,
+            errorElement: route.error ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(route.error, {}) : void 0,
+            children: route.children ? route.children.map((child)=>getRouteObjects([
+                    child
+                ], {
+                    globalApp,
+                    ssrMode,
+                    props
+                })[0]) : void 0
+        };
+        routeObjects.push(nestedRouteObject);
+    } else if ('function' == typeof route.component || 'object' == typeof route.component) {
+        const LayoutComponent = createLayoutElement(route.component);
+        const routeObject = {
+            path: route.path,
+            element: /*#__PURE__*/ external_react_default().createElement(LayoutComponent)
+        };
+        routeObjects.push(routeObject);
+    }
+    routeObjects.push({
+        path: '*',
+        element: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_DefaultNotFound_js_namespaceObject.DefaultNotFound, {})
+    });
+    return routeObjects;
+}
+function createRouteObjectsFromConfig({ routesConfig, props, ssrMode }) {
+    if (!routesConfig) return null;
+    const { routes, globalApp } = routesConfig;
+    if (!routes) return null;
+    return getRouteObjects(routes, {
+        globalApp,
+        ssrMode,
+        props
+    });
+}
+const urlJoin = (...parts)=>{
+    const separator = '/';
+    const replace = new RegExp(`${separator}{1,}`, 'g');
+    return standardSlash(parts.join(separator).replace(replace, separator));
+};
+function standardSlash(str) {
+    let addr = str;
+    if (!addr || 'string' != typeof addr) return addr;
+    if (addr.startsWith('.')) addr = addr.slice(1);
+    if (!addr.startsWith('/')) addr = `/${addr}`;
+    if (addr.endsWith('/') && '/' !== addr) addr = addr.slice(0, addr.length - 1);
+    return addr;
+}
+exports.createRouteObjectsFromConfig = __webpack_exports__.createRouteObjectsFromConfig;
+exports.getRouteObjects = __webpack_exports__.getRouteObjects;
+exports.standardSlash = __webpack_exports__.standardSlash;
+exports.urlJoin = __webpack_exports__.urlJoin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRouteObjectsFromConfig",
+    "getRouteObjects",
+    "standardSlash",
+    "urlJoin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime.js

@@ -0,0 +1,58 @@
+"use strict";
+var __webpack_modules__ = {
+    "./runtime/index" (module) {
+        module.exports = require("./runtime/index.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _runtime_index__rspack_import_0 = __webpack_require__("./runtime/index");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _runtime_index__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_runtime_index__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/cli/index.mjs

@@ -0,0 +1,201 @@
+import node_path from "node:path";
+import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer, fs } from "@modern-js/utils";
+import { generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled } from "./tanstackTypes.mjs";
+import { __webpack_require__ } from "../rslib-runtime.mjs";
+import * as __rspack_external__modern_js_runtime_cli_401ee077 from "@modern-js/runtime/cli";
+__webpack_require__.add({
+    "@modern-js/runtime/cli" (module) {
+        module.exports = __rspack_external__modern_js_runtime_cli_401ee077;
+    }
+});
+const DEFAULT_ROUTES_DIR = 'routes';
+const DEFAULT_GENERATED_DIR_NAME = 'modern-tanstack';
+const ENTRYPOINTS_KEY = '@modern-js/plugin-tanstack';
+let runtimeRouterCli;
+function getRuntimeRouterCli() {
+    if (runtimeRouterCli) return runtimeRouterCli;
+    const cli = __webpack_require__("@modern-js/runtime/cli");
+    if (cli.handleGeneratorEntryCode && cli.getEntrypointRoutesDir) {
+        runtimeRouterCli = cli;
+        return runtimeRouterCli;
+    }
+    throw new Error('@modern-js/plugin-tanstack requires @modern-js/runtime/cli router helper exports.');
+}
+async function writeFileIfChanged(filePath, content) {
+    try {
+        const previous = await fs.pathExists(filePath) ? await fs.readFile(filePath, 'utf-8') : null;
+        if (previous === content) return;
+    } catch  {}
+    await fs.outputFile(filePath, content, 'utf-8');
+}
+function createRegisterDtsContent(opts) {
+    const importStatements = opts.entries.map((entryName, index)=>`import type { router as router${index} } from './${entryName}/router.gen';`).join('\n');
+    const routerUnionType = opts.entries.map((_, index)=>`typeof router${index}`).join(' | ');
+    return `// This file is auto-generated by Modern.js. Do not edit manually.
+
+${importStatements}
+
+declare module '${opts.runtimeModule}' {
+  interface Register {
+    router: ${routerUnionType};
+  }
+}
+`;
+}
+async function writeTanstackRegisterFile(opts) {
+    const { entries, generatedDirName = DEFAULT_GENERATED_DIR_NAME, runtimeModule = '@modern-js/plugin-tanstack/runtime', srcDirectory } = opts;
+    if (0 === entries.length) return;
+    const registerDtsPath = node_path.join(srcDirectory, generatedDirName, 'register.gen.d.ts');
+    await writeFileIfChanged(registerDtsPath, createRegisterDtsContent({
+        entries,
+        runtimeModule
+    }));
+}
+async function writeTanstackRouterTypesForEntries(opts) {
+    const { appContext, generatedDirName = DEFAULT_GENERATED_DIR_NAME, routesByEntry } = opts;
+    const entryNames = Object.keys(routesByEntry);
+    await Promise.all(entryNames.map(async (entryName)=>{
+        const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
+            appContext,
+            entryName,
+            generatedDirName,
+            routes: routesByEntry[entryName]
+        });
+        await writeFileIfChanged(node_path.join(appContext.srcDirectory, generatedDirName, entryName, 'router.gen.ts'), routerGenTs);
+    }));
+    const mainEntryName = appContext.entrypoints?.find((entrypoint)=>entrypoint.isMainEntry)?.entryName;
+    const registerEntries = entryNames.sort((a, b)=>{
+        if (mainEntryName && a === mainEntryName) return -1;
+        if (mainEntryName && b === mainEntryName) return 1;
+        return a.localeCompare(b);
+    });
+    await writeTanstackRegisterFile({
+        entries: registerEntries,
+        generatedDirName,
+        srcDirectory: appContext.srcDirectory
+    });
+}
+function tanstackRouterPlugin(options = {}) {
+    const routesDir = options.routesDir || DEFAULT_ROUTES_DIR;
+    const generatedDirName = options.generatedDirName || DEFAULT_GENERATED_DIR_NAME;
+    return {
+        name: '@modern-js/plugin-tanstack',
+        required: [
+            '@modern-js/runtime'
+        ],
+        setup: (api)=>{
+            const nestedRoutesForServer = {};
+            const isTanstackEntrypoint = (entrypoint)=>{
+                const { getEntrypointRoutesDir } = getRuntimeRouterCli();
+                return getEntrypointRoutesDir(entrypoint) === routesDir;
+            };
+            api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+                if (!isTanstackEntrypoint(entrypoint)) return {
+                    entrypoint,
+                    plugins
+                };
+                const { metaName, serverRoutes } = api.getAppContext();
+                const serverBase = serverRoutes.filter((route)=>route.entryName === entrypoint.entryName).map((route)=>route.urlPath).sort((a, b)=>a.length - b.length > 0 ? -1 : 1);
+                plugins.push({
+                    name: 'tanstackRouter',
+                    path: `@${metaName}/plugin-tanstack/runtime`,
+                    config: {
+                        serverBase
+                    }
+                });
+                return {
+                    entrypoint,
+                    plugins
+                };
+            });
+            api.checkEntryPoint(({ path: entryPath, entry })=>{
+                const { isRouteEntry } = getRuntimeRouterCli();
+                return {
+                    path: entryPath,
+                    entry: entry || isRouteEntry(entryPath, routesDir)
+                };
+            });
+            api.config(()=>({
+                    source: {
+                        include: [
+                            /[\\/]node_modules[\\/]@tanstack[\\/]react-router[\\/]/,
+                            node_path.resolve(__dirname, '../runtime').replace('cjs', 'esm')
+                        ]
+                    }
+                }));
+            api.modifyEntrypoints(async ({ entrypoints })=>{
+                const { handleModifyEntrypoints } = getRuntimeRouterCli();
+                return {
+                    entrypoints: await handleModifyEntrypoints(entrypoints, routesDir, {
+                        routesOwner: ENTRYPOINTS_KEY
+                    })
+                };
+            });
+            api.generateEntryCode(async ({ entrypoints })=>{
+                const tanstackEntrypoints = entrypoints.filter(isTanstackEntrypoint);
+                if (0 === tanstackEntrypoints.length) return;
+                const { handleGeneratorEntryCode } = getRuntimeRouterCli();
+                const routesByEntry = await handleGeneratorEntryCode(api, tanstackEntrypoints, {
+                    entrypointsKey: ENTRYPOINTS_KEY,
+                    generateCodeOptions: {
+                        enableTanstackTypes: false
+                    }
+                });
+                await writeTanstackRouterTypesForEntries({
+                    appContext: api.getAppContext(),
+                    generatedDirName,
+                    routesByEntry
+                });
+            });
+            api.onFileChanged(async (event)=>{
+                const { handleFileChange } = getRuntimeRouterCli();
+                await handleFileChange(api, event, {
+                    entrypointsKey: ENTRYPOINTS_KEY,
+                    includeEntry: (entrypoint)=>{
+                        const { getEntrypointRoutesDir } = getRuntimeRouterCli();
+                        return getEntrypointRoutesDir(entrypoint) === routesDir;
+                    },
+                    regenerate: async ({ api, entrypoints })=>{
+                        const { handleGeneratorEntryCode } = getRuntimeRouterCli();
+                        const routesByEntry = await handleGeneratorEntryCode(api, entrypoints, {
+                            entrypointsKey: ENTRYPOINTS_KEY,
+                            generateCodeOptions: {
+                                enableTanstackTypes: false
+                            }
+                        });
+                        await writeTanstackRouterTypesForEntries({
+                            appContext: api.getAppContext(),
+                            generatedDirName,
+                            routesByEntry
+                        });
+                    }
+                });
+            });
+            api.modifyFileSystemRoutes(async ({ entrypoint, routes })=>{
+                if (isTanstackEntrypoint(entrypoint)) nestedRoutesForServer[entrypoint.entryName] = filterRoutesForServer(routes);
+                return {
+                    entrypoint,
+                    routes
+                };
+            });
+            api.onBeforeGenerateRoutes(async ({ entrypoint, code })=>{
+                if (isTanstackEntrypoint(entrypoint)) {
+                    const { distDirectory } = api.getAppContext();
+                    const nestedRoutesSpecPath = node_path.resolve(distDirectory, NESTED_ROUTE_SPEC_FILE);
+                    const existingNestedRoutes = await fs.pathExists(nestedRoutesSpecPath) ? await fs.readJSON(nestedRoutesSpecPath) : {};
+                    await fs.outputJSON(nestedRoutesSpecPath, {
+                        ...existingNestedRoutes,
+                        ...nestedRoutesForServer
+                    });
+                }
+                return {
+                    entrypoint,
+                    code
+                };
+            });
+        }
+    };
+}
+const src_cli = tanstackRouterPlugin;
+export default src_cli;
+export { generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };