@bleedingdev/modern-js-utils 3.2.0-ultramodern.0

package/dist/esm-node/cli/is/config.mjs

@@ -0,0 +1,38 @@
+import "node:module";
+import { MAIN_ENTRY_NAME } from "../constants.mjs";
+import { isEmpty } from "./type.mjs";
+const isSSR = (config)=>{
+    const { server } = config;
+    if (server?.ssr) return true;
+    if (server?.ssrByEntries && !isEmpty(server.ssrByEntries)) {
+        for (const name of Object.keys(server.ssrByEntries))if (server.ssrByEntries[name]) return true;
+    }
+    return false;
+};
+const isUseSSRBundle = (config)=>{
+    const { output } = config;
+    if (output?.ssg || output?.ssgByEntries && Object.keys(output?.ssgByEntries).length > 0) return true;
+    return isSSR(config);
+};
+const isUseRsc = (config)=>config?.server?.rsc;
+const isServiceWorker = (config)=>{
+    const { output, deploy } = config;
+    if (deploy?.worker?.ssr && (output?.ssg || isSSR(config))) return true;
+    return false;
+};
+const isSSGEntry = (config, entryName, entrypoints)=>{
+    const { output, source } = config;
+    const single = isSingleEntry(entrypoints, source?.mainEntryName);
+    if (single) {
+        const byEntries = output?.ssgByEntries;
+        return Boolean(output?.ssg) || byEntries && !isEmpty(byEntries);
+    }
+    const byEntries = output?.ssgByEntries;
+    if (!byEntries || isEmpty(byEntries)) return false;
+    return Boolean(byEntries[entryName]);
+};
+const isSingleEntry = (entrypoints, mainEntryName = MAIN_ENTRY_NAME)=>{
+    const firstEntry = entrypoints[0];
+    return 1 === entrypoints.length && firstEntry?.entryName === mainEntryName;
+};
+export { isSSGEntry, isSSR, isServiceWorker, isSingleEntry, isUseRsc, isUseSSRBundle };

package/dist/esm-node/cli/is/env.mjs

@@ -0,0 +1,7 @@
+import "node:module";
+const getNodeEnv = ()=>process.env.NODE_ENV || 'development';
+const isDev = ()=>'development' === getNodeEnv();
+const isProd = ()=>'production' === getNodeEnv();
+const isTest = ()=>'test' === getNodeEnv();
+const isBrowser = ()=>"u" > typeof window;
+export { getNodeEnv, isBrowser, isDev, isProd, isTest };

package/dist/esm-node/cli/is/index.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+export * from "./config.mjs";
+export * from "./env.mjs";
+export * from "./project.mjs";
+export * from "./type.mjs";

package/dist/esm-node/cli/is/project.mjs

@@ -0,0 +1,76 @@
+import "node:module";
+import path from "path";
+import pkg_up from "../../../compiled/pkg-up/index.js";
+import { fs, minimist, semver } from "../../compiled.mjs";
+import { getArgv } from "../commands.mjs";
+import { createDebugger } from "../common.mjs";
+import { ensureArray } from "../ensure.mjs";
+import { tryResolve } from "../require.mjs";
+const debug = createDebugger('judge-depExists');
+const isDepExists = (appDirectory, name)=>{
+    const pkgPath = path.resolve(appDirectory, './package.json');
+    if (!fs.existsSync(pkgPath)) {
+        debug("can't find package.json under: %s", appDirectory);
+        return false;
+    }
+    const json = fs.readJSONSync(pkgPath);
+    const { dependencies = {}, devDependencies = {} } = json;
+    return dependencies.hasOwnProperty(name) || devDependencies.hasOwnProperty(name);
+};
+const isPackageInstalled = (name, resolvePaths)=>{
+    try {
+        tryResolve(name, ...ensureArray(resolvePaths));
+        return true;
+    } catch (err) {
+        return false;
+    }
+};
+const isApiOnly = async (appDirectory, entryDir, apiDir)=>{
+    const existApi = await fs.pathExists(apiDir ?? path.join(appDirectory, 'api'));
+    const existSrc = await fs.pathExists(path.join(appDirectory, entryDir ?? 'src'));
+    const options = minimist(getArgv());
+    if (options['api-only']) return true;
+    return existApi && !existSrc;
+};
+const isWebOnly = async ()=>{
+    const options = minimist(getArgv());
+    return Boolean(options['web-only']);
+};
+const isVersionBeyond17 = (version)=>semver.gte(semver.minVersion(version), '17.0.0');
+const getReactVersion = (cwd)=>{
+    const pkgPath = pkg_up.sync({
+        cwd
+    });
+    if (!pkgPath) return false;
+    const pkgInfo = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const deps = {
+        ...pkgInfo.devDependencies,
+        ...pkgInfo.dependencies
+    };
+    if ('string' != typeof deps.react) return false;
+    try {
+        const reactPath = tryResolve('react/package.json', cwd);
+        const reactVersion = JSON.parse(fs.readFileSync(reactPath, 'utf8')).version;
+        return reactVersion;
+    } catch (error) {
+        console.error('Failed to resolve React version:', error);
+        return false;
+    }
+};
+const isBeyondReact17 = (cwd)=>{
+    const reactVersion = getReactVersion(cwd);
+    if (!reactVersion) return false;
+    return isVersionBeyond17(reactVersion);
+};
+const isSupportAutomaticJsx = (cwd)=>{
+    const reactVersion = getReactVersion(cwd);
+    if (!reactVersion) return false;
+    return semver.satisfies(semver.minVersion(reactVersion), '>=16.14.0');
+};
+const isReact18 = (cwd = process.cwd())=>{
+    const reactVersion = getReactVersion(cwd);
+    if (!reactVersion) return false;
+    return semver.gte(semver.minVersion(reactVersion), '18.0.0');
+};
+const isTypescript = (root)=>fs.existsSync(path.resolve(root, './tsconfig.json'));
+export { getReactVersion, isApiOnly, isBeyondReact17, isDepExists, isPackageInstalled, isReact18, isSupportAutomaticJsx, isTypescript, isVersionBeyond17, isWebOnly };

package/dist/esm-node/cli/is/type.mjs

@@ -0,0 +1,27 @@
+import "node:module";
+function isString(str) {
+    return 'string' == typeof str;
+}
+function isUndefined(obj) {
+    return void 0 === obj;
+}
+function isArray(obj) {
+    return Array.isArray(obj);
+}
+function isFunction(func) {
+    return 'function' == typeof func;
+}
+function isObject(obj) {
+    return null !== obj && 'object' == typeof obj;
+}
+function isPlainObject(obj) {
+    return isObject(obj) && '[object Object]' === Object.prototype.toString.call(obj);
+}
+function isPromise(obj) {
+    return Boolean(obj) && ('object' == typeof obj || 'function' == typeof obj) && 'function' == typeof obj.then;
+}
+function isRegExp(obj) {
+    return '[object RegExp]' === Object.prototype.toString.call(obj);
+}
+const isEmpty = (o)=>0 === Object.entries(o).length && o.constructor === Object;
+export { isArray, isEmpty, isFunction, isObject, isPlainObject, isPromise, isRegExp, isString, isUndefined };

package/dist/esm-node/cli/logger.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { createLogger, logger } from "rslog";

package/dist/esm-node/cli/modulePath.mjs

@@ -0,0 +1,34 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+const SOURCE_EXTENSIONS = [
+    '.ts',
+    '.js'
+];
+const JS_LIKE_EXTENSION_RE = /\.(?:c|m)?js$/;
+const isFile = (filepath)=>node_fs.existsSync(filepath) && node_fs.statSync(filepath).isFile();
+const findSourceEntry = (resolvedPath)=>{
+    const ext = node_path.extname(resolvedPath);
+    if (ext) {
+        if (isFile(resolvedPath)) return resolvedPath;
+        if (JS_LIKE_EXTENSION_RE.test(resolvedPath)) {
+            const tsPath = `${resolvedPath.slice(0, -ext.length)}.ts`;
+            if (isFile(tsPath)) return tsPath;
+        }
+        return;
+    }
+    for (const candidateExt of SOURCE_EXTENSIONS){
+        const filePath = `${resolvedPath}${candidateExt}`;
+        if (isFile(filePath)) return filePath;
+    }
+    for (const candidateExt of SOURCE_EXTENSIONS){
+        const indexPath = node_path.join(resolvedPath, `index${candidateExt}`);
+        if (isFile(indexPath)) return indexPath;
+    }
+};
+const findMatchedSourcePath = (matchPath, specifier)=>{
+    let matchedPath = matchPath(specifier, void 0, void 0, SOURCE_EXTENSIONS);
+    if (!matchedPath && JS_LIKE_EXTENSION_RE.test(specifier)) matchedPath = matchPath(specifier.replace(JS_LIKE_EXTENSION_RE, ''), void 0, void 0, SOURCE_EXTENSIONS);
+    return matchedPath;
+};
+export { JS_LIKE_EXTENSION_RE, SOURCE_EXTENSIONS, findMatchedSourcePath, findSourceEntry };

package/dist/esm-node/cli/monorepo.mjs

@@ -0,0 +1,51 @@
+import "node:module";
+import fs from "fs";
+import path from "path";
+import { glob, yaml } from "../compiled.mjs";
+const PACKAGE_MAX_DEPTH = 5;
+const WORKSPACE_FILES = {
+    YARN: 'package.json',
+    PNPM: 'pnpm-workspace.yaml',
+    LERNA: 'lerna.json'
+};
+const isLerna = (root)=>fs.existsSync(path.join(root, WORKSPACE_FILES.LERNA));
+const isYarnWorkspaces = (root)=>{
+    const pkg = path.join(root, WORKSPACE_FILES.YARN);
+    if (!fs.existsSync(pkg)) return false;
+    const json = JSON.parse(fs.readFileSync(pkg, 'utf8'));
+    return Boolean(json.workspaces?.packages);
+};
+const isPnpmWorkspaces = (root)=>fs.existsSync(path.join(root, WORKSPACE_FILES.PNPM));
+const isMonorepo = (root)=>isLerna(root) || isYarnWorkspaces(root) || isPnpmWorkspaces(root);
+const findMonorepoRoot = (appDirectory, maxDepth = PACKAGE_MAX_DEPTH)=>{
+    let inMonorepo = false;
+    let monorepoRoot = appDirectory;
+    for(let depth = 0; depth < maxDepth; depth++){
+        if (isMonorepo(appDirectory)) {
+            inMonorepo = true;
+            break;
+        }
+        monorepoRoot = path.dirname(appDirectory);
+    }
+    return inMonorepo ? monorepoRoot : void 0;
+};
+const getMonorepoPackages = (root)=>{
+    let packages = [];
+    if (isYarnWorkspaces(root)) {
+        const json = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+        ({ packages } = json.workspaces);
+    } else if (isLerna(root)) {
+        const json = JSON.parse(fs.readFileSync(path.resolve(root, 'lerna.json'), 'utf8'));
+        ({ packages } = json);
+    } else ({ packages } = yaml.load(fs.readFileSync(path.join(root, WORKSPACE_FILES.PNPM), 'utf8')));
+    if (packages) return packages.map((name)=>glob.sync(path.join(root, `${name}/`), {
+            ignore: [
+                '**/node_modules/**'
+            ]
+        })).reduce((acc, val)=>acc.concat(val), []).filter((filepath)=>fs.existsSync(path.resolve(filepath, 'package.json'))).map((filepath)=>({
+            path: filepath,
+            name: JSON.parse(fs.readFileSync(path.resolve(filepath, 'package.json'), 'utf8')).name
+        }));
+    return [];
+};
+export { findMonorepoRoot, getMonorepoPackages, isLerna, isMonorepo, isPnpmWorkspaces, isYarnWorkspaces };

package/dist/esm-node/cli/package.mjs

@@ -0,0 +1,52 @@
+import "node:module";
+import { execa } from "../compiled.mjs";
+async function getPnpmVersion() {
+    const { stdout } = await execa('pnpm', [
+        '--version'
+    ]);
+    return stdout;
+}
+async function canUseNpm() {
+    try {
+        await execa('npm', [
+            '--version'
+        ], {
+            env: process.env
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+async function canUseYarn() {
+    try {
+        await execa('yarn', [
+            '--version'
+        ], {
+            env: process.env
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+async function canUsePnpm() {
+    try {
+        await execa('pnpm', [
+            '--version'
+        ], {
+            env: process.env
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function removeModuleSyncFromExports(exports) {
+    if ('object' != typeof exports || null === exports) return exports;
+    if (Array.isArray(exports)) return exports.map(removeModuleSyncFromExports);
+    const result = {};
+    for (const [key, value] of Object.entries(exports))if ('module-sync' !== key) result[key] = removeModuleSyncFromExports(value);
+    return result;
+}
+export { canUseNpm, canUsePnpm, canUseYarn, getPnpmVersion, removeModuleSyncFromExports };

package/dist/esm-node/cli/path.mjs

@@ -0,0 +1,36 @@
+import "node:module";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { nanoid, upath } from "../compiled.mjs";
+const isPathString = (test)=>path.posix.basename(test) !== test || path.win32.basename(test) !== test;
+const isRelativePath = (test)=>/^\.\.?($|[\\/])/.test(test);
+const normalizeOutputPath = (s)=>s.replace(/\\/g, '\\\\');
+const normalizeToPosixPath = (p)=>upath.normalizeSafe(path.normalize(p || '')).replace(/^([a-zA-Z]+):/, (_, m)=>`/${m.toLowerCase()}`);
+const getTemplatePath = (prefix)=>{
+    const tmpRoot = fs.realpathSync(os.tmpdir());
+    const parts = [
+        tmpRoot
+    ];
+    prefix && parts.push(prefix);
+    parts.push(nanoid());
+    return path.resolve(...parts);
+};
+function getRealTemporaryDirectory() {
+    let ret = null;
+    try {
+        ret = os.tmpdir();
+        ret = fs.realpathSync(ret);
+    } catch  {}
+    return ret;
+}
+function splitPathString(str) {
+    return str.split(/[\\/]/);
+}
+const removeLeadingSlash = (s)=>s.replace(/^\/+/, '');
+const removeTailSlash = (s)=>s.replace(/\/+$/, '');
+const removeSlash = (s)=>removeLeadingSlash(removeTailSlash(s));
+function formatImportPath(str) {
+    return str.replace(/\\/g, '/');
+}
+export { formatImportPath, getRealTemporaryDirectory, getTemplatePath, isPathString, isRelativePath, normalizeOutputPath, normalizeToPosixPath, removeLeadingSlash, removeSlash, removeTailSlash, splitPathString };

package/dist/esm-node/cli/port.mjs

@@ -0,0 +1,36 @@
+import "node:module";
+import net from "net";
+import { chalk } from "../compiled.mjs";
+import { logger } from "./logger.mjs";
+const getPort = async (expectPort, { tryLimits = 20, strictPort = false, slient = false } = {})=>{
+    let port = expectPort;
+    if ('string' == typeof port) port = parseInt(port, 10);
+    if (strictPort) tryLimits = 1;
+    const original = port;
+    let found = false;
+    let attempts = 0;
+    while(!found && attempts <= tryLimits)try {
+        await new Promise((resolve, reject)=>{
+            const server = net.createServer();
+            server.unref();
+            server.on('error', reject);
+            server.listen({
+                port,
+                host: '0.0.0.0'
+            }, ()=>{
+                found = true;
+                server.close(resolve);
+            });
+        });
+    } catch (e) {
+        if ('EADDRINUSE' !== e.code) throw e;
+        port++;
+        attempts++;
+    }
+    if (port !== original) {
+        if (strictPort) throw new Error(`Port "${original}" is occupied, please choose another one.`);
+        else if (!slient) logger.info(`Port ${original} is in use. ${chalk.yellow(`using port ${port}.`)}`);
+    }
+    return port;
+};
+export { getPort };

package/dist/esm-node/cli/prettyInstructions.mjs

@@ -0,0 +1,71 @@
+import "node:module";
+import { isIPv6 } from "net";
+import os from "os";
+import { chalk } from "../compiled.mjs";
+import { DEFAULT_DEV_HOST } from "./constants.mjs";
+import { isDev, isSingleEntry } from "./is/index.mjs";
+const normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1');
+const getIpv4Interfaces = ()=>{
+    const interfaces = os.networkInterfaces();
+    const ipv4Interfaces = [];
+    Object.keys(interfaces).forEach((key)=>{
+        interfaces[key].forEach((detail)=>{
+            const familyV4Value = 'string' == typeof detail.family ? 'IPv4' : 4;
+            if (detail.family === familyV4Value) ipv4Interfaces.push(detail);
+        });
+    });
+    return ipv4Interfaces;
+};
+const getHostInUrl = (host)=>{
+    if (isIPv6(host)) return '::' === host ? '[::1]' : `[${host}]`;
+    return host;
+};
+const getAddressUrls = (protocol = 'http', port, host)=>{
+    const LOCAL_LABEL = 'Local:  ';
+    const NETWORK_LABEL = 'Network:  ';
+    const isLocalhost = (url)=>url?.includes('localhost');
+    if (host && host !== DEFAULT_DEV_HOST) return [
+        {
+            label: isLocalhost(host) ? LOCAL_LABEL : NETWORK_LABEL,
+            url: `${protocol}://${getHostInUrl(host)}:${port}`
+        }
+    ];
+    const ipv4Interfaces = getIpv4Interfaces();
+    return ipv4Interfaces.reduce((memo, detail)=>{
+        if (isLocalhost(detail.address) || detail.internal) memo.push({
+            label: LOCAL_LABEL,
+            url: `${protocol}://localhost:${port}`
+        });
+        else memo.push({
+            label: NETWORK_LABEL,
+            url: `${protocol}://${detail.address}:${port}`
+        });
+        return memo;
+    }, []);
+};
+const prettyInstructions = (appContext, config)=>{
+    const { entrypoints, serverRoutes, port, apiOnly, checkedEntries } = appContext;
+    const isHttps = isDev() && (config?.dev?.https || config?.tools?.devServer?.https);
+    const urls = getAddressUrls(isHttps ? 'https' : 'http', port, config.dev?.host);
+    const routes = apiOnly ? serverRoutes : serverRoutes.filter((route)=>route.entryName);
+    let message = '\n';
+    if (isSingleEntry(entrypoints, config.source?.mainEntryName) || apiOnly) {
+        const defaultRoutePath = routes[0]?.urlPath ?? '';
+        message += urls.map(({ label, url })=>`  ${chalk.bold(`> ${label.padEnd(10)}`)}${chalk.cyanBright(normalizeUrl(`${url}/${defaultRoutePath}`))}\n`).join('');
+    } else {
+        const maxNameLength = Math.max(...routes.map((r)=>r.entryName.length));
+        urls.forEach(({ label, url })=>{
+            message += `  ${chalk.bold(`> ${label}`)}${0 === routes.length ? chalk.cyanBright(url) : ''}\n`;
+            routes.forEach(({ entryName, urlPath, isSSR })=>{
+                if (!checkedEntries.includes(entryName)) return;
+                message += `    ${chalk.yellowBright(isSSR ? 'λ' : '○')}  ${chalk.yellowBright(entryName.padEnd(maxNameLength + 8))}${chalk.cyanBright(normalizeUrl(`${url}/${urlPath}`))}\n`;
+            });
+        });
+        message += '\n';
+        message += chalk.cyanBright('  λ (Server) server-side renders at runtime\n');
+        message += chalk.cyanBright('  ○ (Static) client-side renders as static HTML\n');
+    }
+    if (config.dev?.cliShortcuts) message += `  ${chalk.dim('> press')} ${chalk.bold('h + enter')} ${chalk.dim('to show shortcuts')}\n`;
+    return message;
+};
+export { getAddressUrls, prettyInstructions };

package/dist/esm-node/cli/require.mjs

@@ -0,0 +1,80 @@
+import "node:module";
+import { readFile } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
+import { moduleResolve } from "import-meta-resolve";
+import { findExists } from "./fs.mjs";
+async function importPath(path) {
+    const modulePath = isAbsolute(path) ? pathToFileURL(path).href : path;
+    if ('development' !== process.env.NODE_ENV) return await import(modulePath);
+    {
+        const timestamp = Date.now();
+        return await import(`${modulePath}?t=${timestamp}`);
+    }
+}
+async function compatibleRequireESM(path, interop = true) {
+    if (path.endsWith('.json')) return JSON.parse(await readFile(path, 'utf8'));
+    const requiredModule = await importPath(path);
+    return interop ? requiredModule.default : requiredModule;
+}
+async function compatibleRequire(path, interop = true) {
+    return await compatibleRequireESM(path, interop);
+}
+async function loadFromProject(moduleName, appDir) {
+    let requiredModule;
+    const paths = [
+        appDir,
+        process.cwd()
+    ];
+    try {
+        const modulePath = tryResolve(moduleName, ...paths);
+        {
+            const moduleUrl = pathToFileURL(modulePath).href;
+            requiredModule = await import(moduleUrl);
+        }
+        return requiredModule.default || requiredModule;
+    } catch (error) {
+        if ('MODULE_NOT_FOUND' === error.code) throw new Error(`Cannot find module ${moduleName}.`);
+        throw error;
+    }
+}
+const dynamicImport = new Function('modulePath', 'return import(modulePath)');
+const requireExistModule = async (filename, opt)=>{
+    const final = {
+        extensions: [
+            '.ts',
+            '.js'
+        ],
+        interop: true,
+        ...opt
+    };
+    const exist = findExists(final.extensions.map((ext)=>`${filename}${ext}`));
+    if (!exist) return null;
+    return compatibleRequire(exist, final.interop);
+};
+const cleanRequireCache = (filelist)=>{};
+const tryResolveESM = (name, ...resolvePath)=>{
+    const conditions = new Set([
+        'node',
+        'import',
+        'module',
+        'default'
+    ]);
+    for (const p of resolvePath)try {
+        return moduleResolve(name, pathToFileURL(`${p}/`), conditions, false).pathname.replace(/^\/(\w):/, '$1:');
+    } catch (err) {}
+    const err = new Error(`Can not find module ${name}.`);
+    err.code = 'MODULE_NOT_FOUND';
+    throw err;
+};
+const tryResolve = (name, ...resolvePath)=>{
+    let filePath = '';
+    try {
+        filePath = tryResolveESM(name, ...resolvePath);
+    } catch (err) {
+        if ('MODULE_NOT_FOUND' === err.code) throw new Error(`Can not find module ${name}.`);
+        throw err;
+    }
+    return filePath;
+};
+export { cleanRequireCache, compatibleRequire, dynamicImport, loadFromProject, requireExistModule, tryResolve };

package/dist/esm-node/cli/route.mjs

@@ -0,0 +1,37 @@
+import "node:module";
+import { lodash } from "../compiled.mjs";
+const { cloneDeep: cloneDeep } = lodash;
+function filterRoutesForServer(routes) {
+    const clonedRoutes = cloneDeep(routes);
+    const newRoutes = clonedRoutes.map((route)=>{
+        if ('nested' !== route.type) return route;
+        if (route.children && route.children.length > 0) route.children = filterRoutesForServer(route.children);
+        if (route.inValidSSRRoute) return null;
+        return route;
+    }).filter((route)=>null !== route);
+    return newRoutes;
+}
+function filterRoutesLoader(routes) {
+    const clonedRoutes = cloneDeep(routes);
+    const newRoutes = clonedRoutes.map((route)=>{
+        if ('nested' !== route.type) return route;
+        if (route.children && route.children.length > 0) route.children = filterRoutesLoader(route.children);
+        if (route.inValidSSRRoute) {
+            delete route.loader;
+            delete route.data;
+            delete route.action;
+        }
+        return route;
+    }).filter((route)=>null !== route);
+    return newRoutes;
+}
+function markRoutes(routes, routeIds) {
+    return routes.map((route)=>{
+        if ('nested' !== route.type) return route;
+        if (route.children && route.children.length > 0) route.children = markRoutes(route.children, routeIds);
+        if (route.children && route.children.length > 0) route.inValidSSRRoute = route.children.every((child)=>child.inValidSSRRoute ?? false);
+        else if (route.id) route.inValidSSRRoute = !routeIds.includes(route.id);
+        return route;
+    });
+}
+export { filterRoutesForServer, filterRoutesLoader, markRoutes };

package/dist/esm-node/cli/runtimeExports.mjs

@@ -0,0 +1,43 @@
+import "node:module";
+import path from "path";
+import { fs } from "../compiled.mjs";
+import { normalizeOutputPath } from "./path.mjs";
+const memo = (fn)=>{
+    const cache = new Map();
+    return (...params)=>{
+        const stringifiedParams = JSON.stringify(params);
+        const cachedResult = cache.get(stringifiedParams);
+        if (cachedResult) return cachedResult;
+        const res = fn(...params);
+        cache.set(stringifiedParams, res);
+        return res;
+    };
+};
+const ensureRuntimeExportsFile = (filepath)=>{
+    fs.ensureDirSync(path.dirname(filepath));
+    if (!fs.existsSync(filepath)) fs.writeFileSync(filepath, 'export {};\n');
+};
+const formatRuntimeExports = (exportsList)=>{
+    if (0 === exportsList.length) return 'export {};\n';
+    return `${exportsList.join('\n')}\n`;
+};
+const flushRuntimeExports = (filepath, exportsSet)=>{
+    fs.writeFileSync(filepath, formatRuntimeExports(Array.from(exportsSet)));
+};
+const createRuntimeExportsUtils = memo((internalDirectory, filename)=>{
+    const filepath = path.resolve(internalDirectory, `${filename}.ts`);
+    const exportsSet = new Set();
+    ensureRuntimeExportsFile(filepath);
+    return {
+        addExport (exportStatement) {
+            const normalized = exportStatement?.trim();
+            if (!normalized) return;
+            exportsSet.add(normalized);
+            flushRuntimeExports(filepath, exportsSet);
+        },
+        getPath () {
+            return normalizeOutputPath(filepath);
+        }
+    };
+});
+export { createRuntimeExportsUtils };

package/dist/esm-node/cli/tsconfig.mjs

@@ -0,0 +1,8 @@
+import "node:module";
+import path from "path";
+import { TS_CONFIG_FILENAME } from "./constants.mjs";
+const resolveServerTsconfig = (appDirectory, configuredPath)=>{
+    if (configuredPath) return path.isAbsolute(configuredPath) ? configuredPath : path.resolve(appDirectory, configuredPath);
+    return path.resolve(appDirectory, TS_CONFIG_FILENAME);
+};
+export { resolveServerTsconfig };

package/dist/esm-node/cli/version.mjs

@@ -0,0 +1,25 @@
+import "node:module";
+const parseNodeVersion = ()=>{
+    const [major = 0, minor = 0] = process.versions.node.split('.').map(Number);
+    return {
+        major,
+        minor
+    };
+};
+function isVersionAtLeast1819() {
+    const { major, minor } = parseNodeVersion();
+    return major > 18 || 18 === major && minor >= 19;
+}
+function isVersionAtLeast18() {
+    const { major } = parseNodeVersion();
+    return major >= 18;
+}
+function isVersionAtLeast22() {
+    const { major } = parseNodeVersion();
+    return major >= 22;
+}
+function isVersionAtLeast20() {
+    const { major } = parseNodeVersion();
+    return major >= 20;
+}
+export { isVersionAtLeast18, isVersionAtLeast1819, isVersionAtLeast20, isVersionAtLeast22 };