@modern-js/app-tools 2.69.4 → 3.0.0-alpha.0

package/dist/cjs/esm/register-esm.js

@@ -0,0 +1,85 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    registerEsm: ()=>registerEsm
+});
+const external_node_assert_namespaceObject = require("node:assert");
+const external_node_path_namespaceObject = require("node:path");
+const utils_namespaceObject = require("@modern-js/utils");
+const checkDep = async (dep)=>{
+    try {
+        await import(dep);
+        return true;
+    } catch (error) {
+        return false;
+    }
+};
+const registerEsm = async ({ appDir, distDir, alias })=>{
+    const nodeVersion = process.versions.node;
+    nodeVersion.split('.').map(Number);
+    external_node_assert_namespaceObject((0, utils_namespaceObject.isVersionAtLeast1819)(nodeVersion), `The node version of the esm project must be greater than 18.19.0, current version is ${nodeVersion}`);
+    const hasTsNode = await checkDep('ts-node');
+    const TS_CONFIG_FILENAME = "tsconfig.json";
+    const tsconfigPath = external_node_path_namespaceObject.resolve(appDir, TS_CONFIG_FILENAME);
+    const hasTsconfig = await utils_namespaceObject.fs.pathExists(tsconfigPath);
+    const { register } = await import("node:module");
+    if (hasTsNode && hasTsconfig) {
+        process.env.TS_NODE_TRANSPILE_ONLY = true;
+        process.env.TS_NODE_PROJECT = tsconfigPath;
+        process.env.TS_NODE_SCOPE = true;
+        process.env.TS_NODE_FILES = true;
+        process.env.TS_NODE_IGNORE = `(?:^|/)node_modules/,(?:^|/)${external_node_path_namespaceObject.relative(appDir, distDir)}/`;
+        register('./ts-node-loader.mjs', __rslib_import_meta_url__, {
+            data: {
+                appDir,
+                distDir,
+                alias,
+                tsconfigPath
+            }
+        });
+    } else {
+        process.env.MODERN_NODE_LOADER = 'esbuild';
+        if (hasTsconfig) (0, utils_namespaceObject.readTsConfigByFile)(tsconfigPath);
+        register('./esbuild-loader.mjs', __rslib_import_meta_url__, {
+            data: {
+                appDir,
+                distDir,
+                alias,
+                tsconfigPath
+            }
+        });
+    }
+};
+exports.registerEsm = __webpack_exports__.registerEsm;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "registerEsm"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/esm/register-esm.mjs

@@ -1,60 +1,47 @@
 import assert from 'node:assert';
 import path from 'node:path';
 import { fs, isVersionAtLeast1819, readTsConfigByFile } from '@modern-js/utils';
-
-const checkDep = async dep => {
-  try {
-    await import(dep);
-    return true;
-  } catch (error) {
-    return false;
-  }
+const checkDep = async (dep)=>{
+    try {
+        await import(dep);
+        return true;
+    } catch (error) {
+        return false;
+    }
 };
-
-export const registerEsm = async ({ appDir, distDir, alias }) => {
-  const nodeVersion = process.versions.node;
-  const versionArr = nodeVersion.split('.').map(Number);
-
-  assert(
-    isVersionAtLeast1819(nodeVersion),
-    `The node version of the esm project must be greater than 18.19.0, current version is ${nodeVersion}`,
-  );
-  const hasTsNode = await checkDep('ts-node');
-  const TS_CONFIG_FILENAME = `tsconfig.json`;
-  const tsconfigPath = path.resolve(appDir, TS_CONFIG_FILENAME);
-  const hasTsconfig = await fs.pathExists(tsconfigPath);
-  const { register } = await import('node:module');
-  if (hasTsNode && hasTsconfig) {
-    // These can be overridden by ts-node options in tsconfig.json
-    process.env.TS_NODE_TRANSPILE_ONLY = true;
-    process.env.TS_NODE_PROJECT = tsconfigPath;
-    process.env.TS_NODE_SCOPE = true;
-    process.env.TS_NODE_FILES = true;
-    process.env.TS_NODE_IGNORE = `(?:^|/)node_modules/,(?:^|/)${path.relative(
-      appDir,
-      distDir,
-    )}/`;
-    register('./ts-node-loader.mjs', import.meta.url, {
-      data: {
-        appDir,
-        distDir,
-        alias,
-        tsconfigPath,
-      },
-    });
-  } else {
-    process.env.MODERN_NODE_LOADER = 'esbuild';
-    let tsConfig = {};
-    if (hasTsconfig) {
-      tsConfig = readTsConfigByFile(tsconfigPath);
+export const registerEsm = async ({ appDir, distDir, alias })=>{
+    const nodeVersion = process.versions.node;
+    nodeVersion.split('.').map(Number);
+    assert(isVersionAtLeast1819(nodeVersion), `The node version of the esm project must be greater than 18.19.0, current version is ${nodeVersion}`);
+    const hasTsNode = await checkDep('ts-node');
+    const TS_CONFIG_FILENAME = "tsconfig.json";
+    const tsconfigPath = path.resolve(appDir, TS_CONFIG_FILENAME);
+    const hasTsconfig = await fs.pathExists(tsconfigPath);
+    const { register } = await import('node:module');
+    if (hasTsNode && hasTsconfig) {
+        process.env.TS_NODE_TRANSPILE_ONLY = true;
+        process.env.TS_NODE_PROJECT = tsconfigPath;
+        process.env.TS_NODE_SCOPE = true;
+        process.env.TS_NODE_FILES = true;
+        process.env.TS_NODE_IGNORE = `(?:^|/)node_modules/,(?:^|/)${path.relative(appDir, distDir)}/`;
+        register('./ts-node-loader.mjs', import.meta.url, {
+            data: {
+                appDir,
+                distDir,
+                alias,
+                tsconfigPath
+            }
+        });
+    } else {
+        process.env.MODERN_NODE_LOADER = 'esbuild';
+        if (hasTsconfig) readTsConfigByFile(tsconfigPath);
+        register('./esbuild-loader.mjs', import.meta.url, {
+            data: {
+                appDir,
+                distDir,
+                alias,
+                tsconfigPath
+            }
+        });
     }
-    register('./esbuild-loader.mjs', import.meta.url, {
-      data: {
-        appDir,
-        distDir,
-        alias,
-        tsconfigPath,
-      },
-    });
-  }
 };

package/dist/cjs/esm/ts-node-loader.js

@@ -0,0 +1,62 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    load: ()=>load,
+    initialize: ()=>initialize,
+    resolve: ()=>resolve
+});
+const external_url_namespaceObject = require("url");
+const esm_namespaceObject = require("ts-node/esm");
+const external_utils_js_namespaceObject = require("./utils.js");
+let matchPath;
+async function initialize({ appDir, alias, tsconfigPath }) {
+    matchPath = (0, external_utils_js_namespaceObject.createMatchPath)({
+        alias,
+        appDir,
+        tsconfigPath
+    });
+}
+function resolve(specifier, context, defaultResolve) {
+    const match = matchPath(specifier);
+    return match ? (0, esm_namespaceObject.resolve)((0, external_url_namespaceObject.pathToFileURL)(match).href, context, defaultResolve) : (0, esm_namespaceObject.resolve)(specifier, context, defaultResolve);
+}
+function load(url, context, defaultLoad) {
+    const filePath = new URL(url).pathname;
+    if (url.startsWith('node:')) return defaultLoad(url, context);
+    if (filePath.includes('node_modules')) return defaultLoad(url, context);
+    return (0, esm_namespaceObject.load)(url, context, defaultLoad);
+}
+exports.initialize = __webpack_exports__.initialize;
+exports.load = __webpack_exports__.load;
+exports.resolve = __webpack_exports__.resolve;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "initialize",
+    "load",
+    "resolve"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/esm/ts-node-loader.mjs

@@ -2,33 +2,21 @@ import { pathToFileURL } from 'url';
 import { resolve as tsNodeResolve } from 'ts-node/esm';
 import { load as tsNodeLoad } from 'ts-node/esm';
 import { createMatchPath } from './utils.mjs';
-
 let matchPath;
 export async function initialize({ appDir, alias, tsconfigPath }) {
-  matchPath = createMatchPath({
-    alias,
-    appDir,
-    tsconfigPath,
-  });
+    matchPath = createMatchPath({
+        alias,
+        appDir,
+        tsconfigPath
+    });
 }
-
 export function resolve(specifier, context, defaultResolve) {
-  const match = matchPath(specifier);
-  return match
-    ? tsNodeResolve(pathToFileURL(match).href, context, defaultResolve)
-    : tsNodeResolve(specifier, context, defaultResolve);
+    const match = matchPath(specifier);
+    return match ? tsNodeResolve(pathToFileURL(match).href, context, defaultResolve) : tsNodeResolve(specifier, context, defaultResolve);
 }
-
 export function load(url, context, defaultLoad) {
-  const filePath = new URL(url).pathname;
-
-  if (url.startsWith('node:')) {
-    return defaultLoad(url, context);
-  }
-
-  if (filePath.includes('node_modules')) {
-    return defaultLoad(url, context);
-  }
-
-  return tsNodeLoad(url, context, defaultLoad);
+    const filePath = new URL(url).pathname;
+    if (url.startsWith('node:')) return defaultLoad(url, context);
+    if (filePath.includes('node_modules')) return defaultLoad(url, context);
+    return tsNodeLoad(url, context, defaultLoad);
 }

package/dist/cjs/esm/utils.js

@@ -0,0 +1,69 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    createMatchPath: ()=>createMatchPath
+});
+const external_module_namespaceObject = require("module");
+const external_path_namespaceObject = require("path");
+const utils_namespaceObject = require("@modern-js/utils");
+const tsconfig_paths_namespaceObject = require("@modern-js/utils/tsconfig-paths");
+const utils_require = (0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+function createMatchPath({ alias, appDir, tsconfigPath }) {
+    const aliasConfig = (0, utils_namespaceObject.getAliasConfig)(alias, {
+        appDirectory: appDir,
+        tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = './' } = aliasConfig;
+    const tsPaths = Object.keys(paths).reduce((o, key)=>{
+        let tsPath = paths[key];
+        if ('string' == typeof tsPath && key.startsWith('@') && tsPath.startsWith('@')) try {
+            tsPath = utils_require.resolve(tsPath, {
+                paths: [
+                    appDir
+                ]
+            });
+        } catch  {}
+        if ('string' == typeof tsPath && external_path_namespaceObject.isAbsolute(tsPath)) tsPath = external_path_namespaceObject.relative(absoluteBaseUrl, tsPath);
+        if ('string' == typeof tsPath) tsPath = [
+            tsPath
+        ];
+        return {
+            ...o,
+            [`${key}`]: tsPath
+        };
+    }, {});
+    return tsconfig_paths_namespaceObject.createMatchPath(absoluteBaseUrl, tsPaths);
+}
+exports.createMatchPath = __webpack_exports__.createMatchPath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createMatchPath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/esm/utils.mjs

@@ -2,42 +2,30 @@ import { createRequire } from 'module';
 import path from 'path';
 import { getAliasConfig } from '@modern-js/utils';
 import tsConfigPaths from '@modern-js/utils/tsconfig-paths';
-
 const require = createRequire(import.meta.url);
 export function createMatchPath({ alias, appDir, tsconfigPath }) {
-  const aliasConfig = getAliasConfig(alias, {
-    appDirectory: appDir,
-    tsconfigPath,
-  });
-
-  const { paths = {}, absoluteBaseUrl = './' } = aliasConfig;
-
-  const tsPaths = Object.keys(paths).reduce((o, key) => {
-    let tsPath = paths[key];
-    // Do some special handling for Modern.js's internal alias, we can drop it in the next version
-    if (
-      typeof tsPath === 'string' &&
-      key.startsWith('@') &&
-      tsPath.startsWith('@')
-    ) {
-      try {
-        tsPath = require.resolve(tsPath, {
-          paths: [appDir],
-        });
-      } catch {}
-    }
-
-    if (typeof tsPath === 'string' && path.isAbsolute(tsPath)) {
-      tsPath = path.relative(absoluteBaseUrl, tsPath);
-    }
-    if (typeof tsPath === 'string') {
-      tsPath = [tsPath];
-    }
-    return {
-      ...o,
-      [`${key}`]: tsPath,
-    };
-  }, {});
-
-  return tsConfigPaths.createMatchPath(absoluteBaseUrl, tsPaths);
+    const aliasConfig = getAliasConfig(alias, {
+        appDirectory: appDir,
+        tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = './' } = aliasConfig;
+    const tsPaths = Object.keys(paths).reduce((o, key)=>{
+        let tsPath = paths[key];
+        if ('string' == typeof tsPath && key.startsWith('@') && tsPath.startsWith('@')) try {
+            tsPath = require.resolve(tsPath, {
+                paths: [
+                    appDir
+                ]
+            });
+        } catch  {}
+        if ('string' == typeof tsPath && path.isAbsolute(tsPath)) tsPath = path.relative(absoluteBaseUrl, tsPath);
+        if ('string' == typeof tsPath) tsPath = [
+            tsPath
+        ];
+        return {
+            ...o,
+            [`${key}`]: tsPath
+        };
+    }, {});
+    return tsConfigPaths.createMatchPath(absoluteBaseUrl, tsPaths);
 }

package/dist/cjs/exports/server.js

@@ -1,28 +1,18 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var server_exports = {};
-__export(server_exports, {
-  defineConfig: () => import_config.defineServerConfig
-});
-module.exports = __toCommonJS(server_exports);
-var import_config = require("../utils/config");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  defineConfig
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });