@modern-js/app-tools 2.39.1 → 2.39.2-alpha.1

package/dist/cjs/analyze/getBundleEntry.js

@@ -42,12 +42,20 @@ const ensureExtensions = (file) => {
   return file;
 };
 const isDirectory = (file) => !import_path.default.extname(file);
+const isSubDirOrEqual = (parent, child) => {
+  if (parent === child) {
+    return true;
+  }
+  const relative = import_path.default.relative(parent, child);
+  const isSubdir = relative && !relative.startsWith("..") && !import_path.default.isAbsolute(relative);
+  return Boolean(isSubdir);
+};
 const ifAlreadyExists = (entrypoints, checked) => entrypoints.some((entrypoint) => {
   if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
     checked.entryName = entrypoint.entryName;
     return true;
   }
-  if (entrypoint.entry.startsWith(checked.entry) || checked.entry.startsWith(entrypoint.entry)) {
+  if (isSubDirOrEqual(entrypoint.entry, checked.entry) || isSubDirOrEqual(checked.entry, entrypoint.entry)) {
     throw new Error(`Entry configuration conflicts
  Your configuration: ${checked.entry}.
  Default entrypoint: ${entrypoint.entry}

package/dist/cjs/config/initialize/inits.js

@@ -28,6 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var inits_exports = {};
 __export(inits_exports, {
+  createBuilderModuleScope: () => createBuilderModuleScope,
   initHtmlConfig: () => initHtmlConfig,
   initSourceConfig: () => initSourceConfig
 });
@@ -62,57 +63,52 @@ function initSourceConfig(config, appContext, bundler) {
   if (bundler === "webpack") {
     config.source.moduleScopes = createBuilderModuleScope(config);
   }
-  function createBuilderInclude(config2, appContext2) {
-    const { include } = config2.source;
-    const defaultInclude = [
-      appContext2.internalDirectory
-    ];
-    const transformInclude = (include || []).map((include2) => {
-      if (typeof include2 === "string") {
-        if ((0, import_path.isAbsolute)(include2)) {
-          return include2;
-        }
-        return new RegExp(include2);
+}
+function createBuilderInclude(config, appContext) {
+  const { include } = config.source;
+  const defaultInclude = [
+    appContext.internalDirectory
+  ];
+  const transformInclude = (include || []).map((include2) => {
+    if (typeof include2 === "string") {
+      if ((0, import_path.isAbsolute)(include2)) {
+        return include2;
       }
-      return include2;
-    }).concat(defaultInclude);
-    return transformInclude;
+      return new RegExp(include2);
+    }
+    return include2;
+  }).concat(defaultInclude);
+  return transformInclude;
+}
+function createBuilderModuleScope(config) {
+  const { moduleScopes } = config.source;
+  if (moduleScopes) {
+    const DEFAULT_SCOPES = [
+      "./src",
+      "./shared",
+      /node_modules/
+    ];
+    const builderModuleScope = applyScopeOptions(DEFAULT_SCOPES, moduleScopes);
+    return builderModuleScope;
+  } else {
+    return void 0;
   }
-  function createBuilderModuleScope(config2) {
-    const { moduleScopes } = config2.source;
-    if (moduleScopes) {
-      let builderModuleScope = [];
-      const DEFAULT_SCOPES = [
-        "./src",
-        "./shared",
-        /node_modules/
-      ];
-      if (Array.isArray(moduleScopes)) {
-        if (isPrimitiveScope(moduleScopes)) {
-          builderModuleScope = DEFAULT_SCOPES.concat(moduleScopes);
-        } else {
-          builderModuleScope = [
-            DEFAULT_SCOPES,
-            ...moduleScopes
-          ];
-        }
-      } else {
-        builderModuleScope = [
-          DEFAULT_SCOPES,
-          moduleScopes
-        ];
+  function isPrimitiveScope(items) {
+    return items.every((item) => typeof item === "string" || Object.prototype.toString.call(item) === "[object RegExp]");
+  }
+  function applyScopeOptions(defaults, options) {
+    if (Array.isArray(options)) {
+      if (isPrimitiveScope(options)) {
+        return defaults.concat(options);
       }
-      return builderModuleScope;
-    } else {
-      return void 0;
-    }
-    function isPrimitiveScope(items) {
-      return items.every((item) => typeof item === "string" || Object.prototype.toString.call(item) === "[object RegExp]");
+      return options.reduce(applyScopeOptions, defaults);
     }
+    return options(defaults) || defaults;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  createBuilderModuleScope,
   initHtmlConfig,
   initSourceConfig
 });

package/dist/esm/analyze/getBundleEntry.js

@@ -13,13 +13,21 @@ var ensureExtensions = function(file) {
 var isDirectory = function(file) {
   return !path.extname(file);
 };
+var isSubDirOrEqual = function(parent, child) {
+  if (parent === child) {
+    return true;
+  }
+  var relative = path.relative(parent, child);
+  var isSubdir = relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+  return Boolean(isSubdir);
+};
 var ifAlreadyExists = function(entrypoints, checked) {
   return entrypoints.some(function(entrypoint) {
     if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
       checked.entryName = entrypoint.entryName;
       return true;
     }
-    if (entrypoint.entry.startsWith(checked.entry) || checked.entry.startsWith(entrypoint.entry)) {
+    if (isSubDirOrEqual(entrypoint.entry, checked.entry) || isSubDirOrEqual(checked.entry, entrypoint.entry)) {
       throw new Error("Entry configuration conflicts\n Your configuration: ".concat(checked.entry, ".\n Default entrypoint: ").concat(entrypoint.entry, "\n Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules."));
     }
     return false;

package/dist/esm/config/initialize/inits.js

@@ -1,4 +1,3 @@
-import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import path, { isAbsolute } from "path";
 import { findExists } from "@modern-js/utils";
 function initHtmlConfig(config, appContext) {
@@ -29,61 +28,57 @@ function initHtmlConfig(config, appContext) {
   return config.html;
 }
 function initSourceConfig(config, appContext, bundler) {
-  var createBuilderInclude = function createBuilderInclude2(config2, appContext2) {
-    var include = config2.source.include;
-    var defaultInclude = [
-      appContext2.internalDirectory
-    ];
-    var transformInclude = (include || []).map(function(include2) {
-      if (typeof include2 === "string") {
-        if (isAbsolute(include2)) {
-          return include2;
-        }
-        return new RegExp(include2);
+  config.source.include = createBuilderInclude(config, appContext);
+  if (bundler === "webpack") {
+    config.source.moduleScopes = createBuilderModuleScope(config);
+  }
+}
+function createBuilderInclude(config, appContext) {
+  var include = config.source.include;
+  var defaultInclude = [
+    appContext.internalDirectory
+  ];
+  var transformInclude = (include || []).map(function(include2) {
+    if (typeof include2 === "string") {
+      if (isAbsolute(include2)) {
+        return include2;
       }
-      return include2;
-    }).concat(defaultInclude);
-    return transformInclude;
+      return new RegExp(include2);
+    }
+    return include2;
+  }).concat(defaultInclude);
+  return transformInclude;
+}
+function createBuilderModuleScope(config) {
+  var isPrimitiveScope = function isPrimitiveScope2(items) {
+    return items.every(function(item) {
+      return typeof item === "string" || Object.prototype.toString.call(item) === "[object RegExp]";
+    });
   };
-  var createBuilderModuleScope = function createBuilderModuleScope2(config2) {
-    var moduleScopes = config2.source.moduleScopes;
-    if (moduleScopes) {
-      var builderModuleScope = [];
-      var DEFAULT_SCOPES = [
-        "./src",
-        "./shared",
-        /node_modules/
-      ];
-      if (Array.isArray(moduleScopes)) {
-        if (isPrimitiveScope(moduleScopes)) {
-          builderModuleScope = DEFAULT_SCOPES.concat(moduleScopes);
-        } else {
-          builderModuleScope = [
-            DEFAULT_SCOPES
-          ].concat(_to_consumable_array(moduleScopes));
-        }
-      } else {
-        builderModuleScope = [
-          DEFAULT_SCOPES,
-          moduleScopes
-        ];
+  var moduleScopes = config.source.moduleScopes;
+  if (moduleScopes) {
+    var DEFAULT_SCOPES = [
+      "./src",
+      "./shared",
+      /node_modules/
+    ];
+    var builderModuleScope = applyScopeOptions(DEFAULT_SCOPES, moduleScopes);
+    return builderModuleScope;
+  } else {
+    return void 0;
+  }
+  function applyScopeOptions(defaults, options) {
+    if (Array.isArray(options)) {
+      if (isPrimitiveScope(options)) {
+        return defaults.concat(options);
       }
-      return builderModuleScope;
-    } else {
-      return void 0;
-    }
-    function isPrimitiveScope(items) {
-      return items.every(function(item) {
-        return typeof item === "string" || Object.prototype.toString.call(item) === "[object RegExp]";
-      });
+      return options.reduce(applyScopeOptions, defaults);
     }
-  };
-  config.source.include = createBuilderInclude(config, appContext);
-  if (bundler === "webpack") {
-    config.source.moduleScopes = createBuilderModuleScope(config);
+    return options(defaults) || defaults;
   }
 }
 export {
+  createBuilderModuleScope,
   initHtmlConfig,
   initSourceConfig
 };

package/dist/esm-node/analyze/getBundleEntry.js

@@ -9,12 +9,20 @@ const ensureExtensions = (file) => {
   return file;
 };
 const isDirectory = (file) => !path.extname(file);
+const isSubDirOrEqual = (parent, child) => {
+  if (parent === child) {
+    return true;
+  }
+  const relative = path.relative(parent, child);
+  const isSubdir = relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+  return Boolean(isSubdir);
+};
 const ifAlreadyExists = (entrypoints, checked) => entrypoints.some((entrypoint) => {
   if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
     checked.entryName = entrypoint.entryName;
     return true;
   }
-  if (entrypoint.entry.startsWith(checked.entry) || checked.entry.startsWith(entrypoint.entry)) {
+  if (isSubDirOrEqual(entrypoint.entry, checked.entry) || isSubDirOrEqual(checked.entry, entrypoint.entry)) {
     throw new Error(`Entry configuration conflicts
  Your configuration: ${checked.entry}.
  Default entrypoint: ${entrypoint.entry}

package/dist/esm-node/config/initialize/inits.js

@@ -28,56 +28,51 @@ function initSourceConfig(config, appContext, bundler) {
   if (bundler === "webpack") {
     config.source.moduleScopes = createBuilderModuleScope(config);
   }
-  function createBuilderInclude(config2, appContext2) {
-    const { include } = config2.source;
-    const defaultInclude = [
-      appContext2.internalDirectory
-    ];
-    const transformInclude = (include || []).map((include2) => {
-      if (typeof include2 === "string") {
-        if (isAbsolute(include2)) {
-          return include2;
-        }
-        return new RegExp(include2);
+}
+function createBuilderInclude(config, appContext) {
+  const { include } = config.source;
+  const defaultInclude = [
+    appContext.internalDirectory
+  ];
+  const transformInclude = (include || []).map((include2) => {
+    if (typeof include2 === "string") {
+      if (isAbsolute(include2)) {
+        return include2;
       }
-      return include2;
-    }).concat(defaultInclude);
-    return transformInclude;
+      return new RegExp(include2);
+    }
+    return include2;
+  }).concat(defaultInclude);
+  return transformInclude;
+}
+function createBuilderModuleScope(config) {
+  const { moduleScopes } = config.source;
+  if (moduleScopes) {
+    const DEFAULT_SCOPES = [
+      "./src",
+      "./shared",
+      /node_modules/
+    ];
+    const builderModuleScope = applyScopeOptions(DEFAULT_SCOPES, moduleScopes);
+    return builderModuleScope;
+  } else {
+    return void 0;
   }
-  function createBuilderModuleScope(config2) {
-    const { moduleScopes } = config2.source;
-    if (moduleScopes) {
-      let builderModuleScope = [];
-      const DEFAULT_SCOPES = [
-        "./src",
-        "./shared",
-        /node_modules/
-      ];
-      if (Array.isArray(moduleScopes)) {
-        if (isPrimitiveScope(moduleScopes)) {
-          builderModuleScope = DEFAULT_SCOPES.concat(moduleScopes);
-        } else {
-          builderModuleScope = [
-            DEFAULT_SCOPES,
-            ...moduleScopes
-          ];
-        }
-      } else {
-        builderModuleScope = [
-          DEFAULT_SCOPES,
-          moduleScopes
-        ];
+  function isPrimitiveScope(items) {
+    return items.every((item) => typeof item === "string" || Object.prototype.toString.call(item) === "[object RegExp]");
+  }
+  function applyScopeOptions(defaults, options) {
+    if (Array.isArray(options)) {
+      if (isPrimitiveScope(options)) {
+        return defaults.concat(options);
       }
-      return builderModuleScope;
-    } else {
-      return void 0;
-    }
-    function isPrimitiveScope(items) {
-      return items.every((item) => typeof item === "string" || Object.prototype.toString.call(item) === "[object RegExp]");
+      return options.reduce(applyScopeOptions, defaults);
     }
+    return options(defaults) || defaults;
   }
 }
 export {
+  createBuilderModuleScope,
   initHtmlConfig,
   initSourceConfig
 };

package/dist/js/modern/analyze/constants.js

@@ -0,0 +1,15 @@
+export const JS_EXTENSIONS = ['.js', '.ts', '.jsx', '.tsx'];
+export const INDEX_FILE_NAME = 'index';
+export const APP_FILE_NAME = 'App';
+export const PAGES_DIR_NAME = 'pages';
+export const FILE_SYSTEM_ROUTES_FILE_NAME = 'routes.js';
+export const ENTRY_POINT_FILE_NAME = 'index.js';
+export const ENTRY_BOOTSTRAP_FILE_NAME = 'bootstrap.js';
+export const FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = /^\[(\S+)\]([*+?]?)$/;
+export const FILE_SYSTEM_ROUTES_LAYOUT = '_layout';
+export const FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT = '_app';
+export const FILE_SYSTEM_ROUTES_INDEX = 'index';
+export const FILE_SYSTEM_ROUTES_IGNORED_REGEX = /\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/;
+export const HTML_PARTIALS_FOLDER = 'html';
+export const HTML_PARTIALS_EXTENSIONS = ['.htm', '.html', '.ejs'];
+export const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = 'internal_components';

package/dist/js/modern/analyze/generateCode.js

@@ -0,0 +1,179 @@
+import path from 'path';
+import { fs } from '@modern-js/utils';
+import * as templates from "./templates";
+import { getClientRoutes } from "./getClientRoutes";
+import { FILE_SYSTEM_ROUTES_FILE_NAME, ENTRY_POINT_FILE_NAME, ENTRY_BOOTSTRAP_FILE_NAME } from "./constants";
+import { getDefaultImports } from "./utils";
+
+const createImportSpecifier = specifiers => {
+  let defaults = '';
+  const named = [];
+
+  for (const {
+    local,
+    imported
+  } of specifiers) {
+    if (local && imported) {
+      named.push(`${imported} as ${local}`);
+    } else if (local) {
+      defaults = local;
+    } else {
+      named.push(imported);
+    }
+  }
+
+  if (defaults && named.length) {
+    return `${defaults}, { ${named.join(', ')} }`;
+  } else if (defaults) {
+    return defaults;
+  } else {
+    return `{ ${named.join(', ')} }`;
+  }
+};
+
+export const createImportStatements = statements => {
+  // merge import statements with the same value.
+  const deDuplicated = [];
+  const seen = new Map();
+
+  for (const {
+    value,
+    specifiers,
+    initialize
+  } of statements) {
+    if (!seen.has(value)) {
+      deDuplicated.push({
+        value,
+        specifiers,
+        initialize
+      });
+      seen.set(value, specifiers);
+    } else {
+      var _deDuplicated$modifyI, _deDuplicated$modifyI2;
+
+      seen.get(value).push(...specifiers); // make "initialize" param can be connected when multiple plugins were imported from same package
+
+      const modifyIndex = deDuplicated.findIndex(v => v.value === value);
+      const originInitialize = (_deDuplicated$modifyI = (_deDuplicated$modifyI2 = deDuplicated[modifyIndex]) === null || _deDuplicated$modifyI2 === void 0 ? void 0 : _deDuplicated$modifyI2.initialize) !== null && _deDuplicated$modifyI !== void 0 ? _deDuplicated$modifyI : '';
+      deDuplicated[modifyIndex].initialize = originInitialize.concat(`\n${initialize || ''}`);
+    }
+  }
+
+  return deDuplicated.map(({
+    value,
+    specifiers,
+    initialize
+  }) => `import ${createImportSpecifier(specifiers)} from '${value}';\n${initialize || ''}`).join('\n');
+};
+export const generateCode = async (appContext, config, entrypoints, api) => {
+  const {
+    internalDirectory,
+    srcDirectory,
+    internalDirAlias,
+    internalSrcAlias
+  } = appContext;
+  const hookRunners = api.useHookRunners();
+  const {
+    output: {
+      mountId
+    }
+  } = config;
+
+  for (const entrypoint of entrypoints) {
+    const {
+      entryName,
+      isAutoMount,
+      customBootstrap,
+      fileSystemRoutes
+    } = entrypoint;
+
+    if (isAutoMount) {
+      // generate routes file for file system routes entrypoint.
+      if (fileSystemRoutes) {
+        const initialRoutes = getClientRoutes({
+          entrypoint,
+          srcDirectory,
+          srcAlias: internalSrcAlias,
+          internalDirectory,
+          internalDirAlias
+        });
+        const {
+          routes
+        } = await hookRunners.modifyFileSystemRoutes({
+          entrypoint,
+          routes: initialRoutes
+        });
+        const {
+          code
+        } = await hookRunners.beforeGenerateRoutes({
+          entrypoint,
+          code: templates.fileSystemRoutes({
+            routes
+          })
+        });
+        fs.outputFileSync(path.resolve(internalDirectory, `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`), code, 'utf8');
+      } // call modifyEntryImports hook
+
+
+      const {
+        imports: importStatements
+      } = await hookRunners.modifyEntryImports({
+        entrypoint,
+        imports: getDefaultImports({
+          entrypoint,
+          srcDirectory,
+          internalSrcAlias,
+          internalDirAlias,
+          internalDirectory
+        })
+      }); // call modifyEntryRuntimePlugins hook
+
+      const {
+        plugins
+      } = await hookRunners.modifyEntryRuntimePlugins({
+        entrypoint,
+        plugins: []
+      }); // call modifyEntryRenderFunction hook
+
+      const {
+        code: renderFunction
+      } = await hookRunners.modifyEntryRenderFunction({
+        entrypoint,
+        code: templates.renderFunction({
+          plugins,
+          customBootstrap,
+          fileSystemRoutes
+        })
+      }); // call modifyEntryExport hook
+
+      const {
+        exportStatement
+      } = await hookRunners.modifyEntryExport({
+        entrypoint,
+        exportStatement: 'export default AppWrapper;'
+      });
+      const code = templates.index({
+        mountId: mountId,
+        imports: createImportStatements(importStatements),
+        renderFunction,
+        exportStatement
+      });
+      const entryFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_FILE_NAME}`);
+      entrypoint.entry = entryFile; // generate entry file.
+
+      if (config.source.enableAsyncEntry) {
+        const {
+          code: asyncEntryCode
+        } = await hookRunners.modifyAsyncEntry({
+          entrypoint,
+          code: `import('./${ENTRY_BOOTSTRAP_FILE_NAME}');`
+        });
+        fs.outputFileSync(entryFile, asyncEntryCode, 'utf8');
+        const bootstrapFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_BOOTSTRAP_FILE_NAME}`);
+        fs.outputFileSync(bootstrapFile, code, 'utf8');
+      } else {
+        fs.outputFileSync(entryFile, code, 'utf8');
+      }
+    }
+  }
+};

package/dist/js/modern/analyze/getBundleEntry.js

@@ -0,0 +1,75 @@
+import path from 'path';
+import { ensureAbsolutePath, fs, findExists, MAIN_ENTRY_NAME } from '@modern-js/utils';
+import { getFileSystemEntry } from "./getFileSystemEntry";
+import { JS_EXTENSIONS } from "./constants";
+
+const ensureExtensions = file => {
+  if (!path.extname(file)) {
+    return findExists(JS_EXTENSIONS.map(ext => `${file}${ext}`)) || file;
+  }
+
+  return file;
+};
+
+const ifAlreadyExists = (entrypoints, checked) => entrypoints.some(entrypoint => {
+  if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
+    // reset entryName
+    checked.entryName = entrypoint.entryName;
+    return true;
+  } // filesystem routes entrypoint conflict with normal entrypoint.
+
+
+  if (entrypoint.entry.startsWith(checked.entry) || checked.entry.startsWith(entrypoint.entry)) {
+    throw new Error(`Entry configuration conflicts\n Your configuration: ${checked.entry}.\n Default entrypoint: ${entrypoint.entry}\n Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules.`);
+  }
+
+  return false;
+});
+
+export const getBundleEntry = (appContext, config) => {
+  const {
+    appDirectory,
+    packageName
+  } = appContext;
+  const {
+    source: {
+      disableDefaultEntries,
+      entries,
+      entriesDir
+    }
+  } = config;
+  const defaults = disableDefaultEntries ? [] : getFileSystemEntry(appContext, config); // merge entrypoints from user config with directory convention.
+
+  if (entries) {
+    Object.keys(entries).forEach(name => {
+      const value = entries[name];
+      const entrypoint = typeof value === 'string' ? {
+        entryName: name,
+        entry: ensureAbsolutePath(appDirectory, value),
+        isAutoMount: true,
+        fileSystemRoutes: fs.statSync(ensureAbsolutePath(appDirectory, value)).isDirectory() ? {} : undefined
+      } : {
+        entryName: name,
+        entry: ensureAbsolutePath(appDirectory, value.entry),
+        isAutoMount: !value.disableMount,
+        fileSystemRoutes: value.enableFileSystemRoutes ? {} : undefined
+      };
+
+      if (!ifAlreadyExists(defaults, entrypoint)) {
+        defaults.push(entrypoint);
+      }
+    });
+  }
+
+  if (!disableDefaultEntries) {
+    // find main entry point which server route is '/'.
+    const entriesDirAbs = ensureAbsolutePath(appDirectory, entriesDir);
+    const found = defaults.find(({
+      entryName,
+      entry
+    }) => entryName === packageName || path.dirname(entry) === entriesDirAbs);
+    found && (found.entryName = MAIN_ENTRY_NAME);
+  }
+
+  return defaults;
+};