@modern-js/module-tools 1.5.8 → 1.6.1

package/dist/js/node/features/build/bundleless/style.js

@@ -0,0 +1,299 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.styleFileSuffix = exports.runBuild = exports.haveNotAnyStyles = exports.buildStyle = exports.StyleBuildError = void 0;
+
+var path = _interopRequireWildcard(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+var _error = require("../error");
+
+var _utils2 = require("../utils");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const compiler = _utils.Import.lazy('@modern-js/style-compiler', require);
+
+class StyleBuildError extends Error {
+  constructor(message, opts) {
+    super(message);
+
+    _defineProperty(this, "summary", void 0);
+
+    _defineProperty(this, "details", void 0);
+
+    Error.captureStackTrace(this, this.constructor);
+    this.summary = opts === null || opts === void 0 ? void 0 : opts.summary;
+    this.details = opts === null || opts === void 0 ? void 0 : opts.details;
+  }
+
+  toString() {
+    return this.formatError().join('\n');
+  }
+
+  formatError() {
+    const msgs = [];
+    const {
+      summary,
+      details = []
+    } = this;
+    msgs.push(_utils.chalk.red.bold(summary));
+
+    for (const detail of details) {
+      if (detail.error) {
+        msgs.push(detail.error);
+        msgs.push('\n');
+      }
+    }
+
+    return msgs;
+  }
+
+}
+/**
+ * when modern build, only throw Error or silent
+ * @param result
+ * @param context
+ */
+
+
+exports.StyleBuildError = StyleBuildError;
+
+const generatorFileOrLogError = (result, context) => {
+  if (result.code === 0) {
+    for (const file of result.dists) {
+      _utils.fs.ensureFileSync(file.filename);
+
+      _utils.fs.writeFileSync(file.filename, file.content);
+    }
+  } else {
+    // for (const file of result.errors) {
+    //   console.error(file.error);
+    // }
+    const styleError = new StyleBuildError('bundleless failed', {
+      summary: 'Style Compiler Failed',
+      details: result.errors
+    });
+    throw new _error.InternalBuildError(styleError, _objectSpread({
+      buildType: 'bundleless'
+    }, context));
+  }
+};
+
+const generatorFileAndLog = (result, titleText) => {
+  if (result.code === 0) {
+    for (const file of result.dists) {
+      _utils.fs.ensureFileSync(file.filename);
+
+      _utils.fs.writeFileSync(file.filename, file.content);
+    }
+
+    console.info((0, _utils2.watchSectionTitle)(titleText, _utils2.SectionTitleStatus.Success));
+  } else {
+    console.info((0, _utils2.watchSectionTitle)(titleText, _utils2.SectionTitleStatus.Fail));
+
+    for (const file of result.errors) {
+      console.error(file.error);
+    }
+  }
+};
+
+const copyOriginStyleFiles = ({
+  targetDir,
+  outputDir
+}) => {
+  const styleFiles = _utils.glob.sync(`${targetDir}/**/*.{css,sass,scss,less}`);
+
+  if (styleFiles.length > 0) {
+    _utils.fs.ensureDirSync(outputDir);
+  }
+
+  for (const styleFile of styleFiles) {
+    const file = path.relative(targetDir, styleFile);
+
+    _utils.fs.ensureDirSync(path.dirname(path.join(outputDir, file)));
+
+    _utils.fs.copyFileSync(styleFile, path.join(outputDir, file));
+  }
+};
+
+const runBuild = async option => {
+  const {
+    watch,
+    appDirectory,
+    srcDir,
+    outDir,
+    lessOption,
+    sassOption,
+    postcssOption
+  } = option;
+
+  if (watch) {
+    const srcStyleEmitter = compiler.styleCompiler({
+      watch: true,
+      projectDir: appDirectory,
+      stylesDir: srcDir,
+      outDir,
+      enableVirtualDist: true,
+      compilerOption: {
+        less: lessOption,
+        sass: sassOption,
+        postcss: postcssOption
+      }
+    });
+    return srcStyleEmitter;
+  } else {
+    const srcStyleResult = await compiler.styleCompiler({
+      projectDir: appDirectory,
+      stylesDir: srcDir,
+      outDir,
+      enableVirtualDist: true,
+      compilerOption: {
+        less: lessOption,
+        sass: sassOption,
+        postcss: postcssOption
+      }
+    });
+    return srcStyleResult;
+  }
+};
+
+exports.runBuild = runBuild;
+const styleFileSuffix = ['css', 'less', 'sass', 'scss'];
+exports.styleFileSuffix = styleFileSuffix;
+
+const haveNotAnyStyles = async sourceDir => {
+  const files = await (0, _utils.globby)((0, _utils.slash)(`${sourceDir}/**/*.{${styleFileSuffix.join(',')}}`));
+  return files.length === 0;
+};
+
+exports.haveNotAnyStyles = haveNotAnyStyles;
+
+const buildStyle = async (api, config) => {
+  var _style$path;
+
+  const modernConfig = api.useResolvedConfigContext();
+  const {
+    appDirectory
+  } = api.useAppContext();
+  const {
+    watch = false,
+    outputPath,
+    bundlelessOptions
+  } = config;
+  const {
+    style,
+    sourceDir
+  } = bundlelessOptions;
+  const {
+    output: {
+      path: distPath = 'dist'
+    }
+  } = modernConfig;
+  const titleText = `[Bundleless:Style:${sourceDir}]`;
+
+  if ((await haveNotAnyStyles(sourceDir)) || style.compileMode === false) {
+    return;
+  }
+
+  const runner = api.useHookRunners();
+  const lessOption = await runner.moduleLessConfig({
+    modernConfig
+  }, {
+    onLast: async _ => undefined
+  });
+  const sassOption = await runner.moduleSassConfig({
+    modernConfig
+  }, {
+    onLast: async _ => undefined
+  });
+  const tailwindPlugin = await runner.moduleTailwindConfig({
+    modernConfig
+  }, {
+    onLast: async _ => undefined
+  });
+  const postcssOption = (0, _utils2.getPostcssOption)(appDirectory, modernConfig);
+
+  if (tailwindPlugin) {
+    var _postcssOption$plugin;
+
+    (_postcssOption$plugin = postcssOption.plugins) === null || _postcssOption$plugin === void 0 ? void 0 : _postcssOption$plugin.push(tailwindPlugin);
+  }
+
+  const srcDir = path.resolve(appDirectory, sourceDir);
+  const outputDirToSrc = path.join(appDirectory, distPath, outputPath, (_style$path = style.path) !== null && _style$path !== void 0 ? _style$path : './');
+
+  if (style.compileMode === 'all' || style.compileMode === 'only-compiled-code') {
+    const result = await runBuild({
+      appDirectory,
+      srcDir,
+      watch,
+      outDir: outputDirToSrc,
+      lessOption,
+      sassOption,
+      postcssOption
+    });
+
+    if (watch) {
+      const emitter = result;
+      emitter.on(compiler.BuildWatchEvent.firstCompiler, result => {
+        generatorFileAndLog(result, titleText);
+      });
+      emitter.on(compiler.BuildWatchEvent.watchingCompiler, srcStyleResult => {
+        generatorFileAndLog(srcStyleResult, titleText);
+      });
+      await emitter.watch();
+    } else {
+      const srcStyleResult = result;
+      generatorFileOrLogError(srcStyleResult, {
+        target: config.target,
+        format: config.format
+      });
+    }
+  }
+
+  if (style.compileMode === 'all' || style.compileMode === 'only-source-code') {
+    if (watch) {
+      copyOriginStyleFiles({
+        targetDir: srcDir,
+        outputDir: outputDirToSrc
+      });
+      console.info((0, _utils2.watchSectionTitle)(titleText, _utils2.SectionTitleStatus.Success));
+      (0, _utils.watch)(`${srcDir}/**/*.{css,less,sass,scss}`, ({
+        changeType,
+        changedFilePath
+      }) => {
+        if (changeType === _utils.WatchChangeType.UNLINK) {
+          const removeFile = path.normalize(`${outputDirToSrc}/${path.relative(srcDir, changedFilePath)}`);
+
+          _utils.fs.removeSync(removeFile);
+        } else {
+          copyOriginStyleFiles({
+            targetDir: srcDir,
+            outputDir: outputDirToSrc
+          });
+        }
+
+        console.info((0, _utils2.watchSectionTitle)(titleText, _utils2.SectionTitleStatus.Success));
+      });
+    } else {
+      copyOriginStyleFiles({
+        targetDir: srcDir,
+        outputDir: outputDirToSrc
+      });
+    }
+  }
+};
+
+exports.buildStyle = buildStyle;

package/dist/js/node/features/build/constants.js

@@ -3,77 +3,125 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.runTscWatchTitle = exports.runTscTitle = exports.runStyleCompilerTitle = exports.runBabelCompilerTitle = exports.clearFlag = exports.PACKAGE_MODES = exports.DEFAULT_PACKAGE_MODE = void 0;
-// Universal JS 的默认选择，三份构建产物，支持 Node.js，对现代浏览器有优化
-const universalJs = [{
-  type: 'module',
-  syntax: 'es5',
-  outDir: 'treeshaking'
-}, {
-  type: 'commonjs',
-  syntax: 'es6+',
-  outDir: 'node'
-}, {
-  type: 'module',
-  syntax: 'es6+',
-  outDir: 'modern'
-}]; // Universal JS 的优化选择，两份构建产物，对现代浏览器无优化
+exports.unPresets = exports.unPresetWithTargetConfigs = exports.unPresetConfigs = exports.targets = exports.npmLibraryWithUmdPresetConfig = exports.npmLibraryPresetConfig = exports.npmComponentWithUmdPresetConfig = exports.npmComponentPresetConfig = exports.clearFlag = exports.buildingText = exports.buildSuccessText = exports.buildFailText = void 0;
 
-const universalJsLite = [{
-  type: 'module',
-  syntax: 'es5',
-  outDir: 'treeshaking'
-}, {
-  type: 'commonjs',
-  syntax: 'es6+',
-  outDir: 'node',
-  copyDirs: ['modern']
-}]; // 纯前端代码的默认选择，两份构建产物
+var _utils = require("@modern-js/utils");
 
-const browserJs = [{
-  type: 'module',
-  syntax: 'es5',
-  outDir: 'treeshaking',
-  copyDirs: ['node']
-}, {
-  type: 'module',
-  syntax: 'es6+',
-  outDir: 'modern'
-}]; // 纯前端代码的优化选择，单份构建产物，对现代浏览器无优化
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-const browserJsLite = [{
-  type: 'module',
-  syntax: 'es5',
-  outDir: 'treeshaking',
-  copyDirs: ['modern', 'node']
-}]; // 纯 Node.js 代码的默认选择，两份构建产物
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const clearFlag = '\x1Bc';
+exports.clearFlag = clearFlag;
 
-const nodeJs = [{
-  type: 'commonjs',
-  syntax: 'es6+',
-  outDir: 'node'
+const buildingText = _utils.chalk.blue('Building...');
+
+exports.buildingText = buildingText;
+
+const buildSuccessText = _utils.chalk.green('Build succeed');
+
+exports.buildSuccessText = buildSuccessText;
+
+const buildFailText = _utils.chalk.red('Build Failed:');
+
+exports.buildFailText = buildFailText;
+const targets = ['es5', 'es6', 'es2015', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'esnext'];
+exports.targets = targets;
+const npmLibraryPresetConfig = [{
+  format: 'cjs',
+  target: 'es6',
+  buildType: 'bundle',
+  outputPath: './lib'
+}, {
+  format: 'esm',
+  target: 'es6',
+  buildType: 'bundle',
+  outputPath: './es'
 }, {
-  type: 'module',
-  syntax: 'es6+',
-  outDir: 'modern'
+  buildType: 'bundle',
+  outputPath: './types',
+  enableDts: true,
+  dtsOnly: true
 }];
-const DEFAULT_PACKAGE_MODE = 'universal-js';
-exports.DEFAULT_PACKAGE_MODE = DEFAULT_PACKAGE_MODE;
-const PACKAGE_MODES = {
-  'universal-js': universalJs,
-  'universal-js-lite': universalJsLite,
-  'browser-js': browserJs,
-  'browser-js-lite': browserJsLite,
-  'node-js': nodeJs
+exports.npmLibraryPresetConfig = npmLibraryPresetConfig;
+const npmLibraryWithUmdPresetConfig = [{
+  format: 'cjs',
+  target: 'es6',
+  buildType: 'bundle',
+  outputPath: './lib'
+}, {
+  format: 'esm',
+  target: 'es6',
+  buildType: 'bundle',
+  outputPath: './es'
+}, {
+  format: 'umd',
+  target: 'es6',
+  buildType: 'bundle',
+  outputPath: './umd'
+}, {
+  buildType: 'bundle',
+  outputPath: './types',
+  enableDts: true,
+  dtsOnly: true
+}];
+exports.npmLibraryWithUmdPresetConfig = npmLibraryWithUmdPresetConfig;
+const npmComponentPresetConfig = [{
+  format: 'cjs',
+  target: 'es6',
+  buildType: 'bundleless',
+  outputPath: './lib'
+}, {
+  format: 'esm',
+  target: 'es6',
+  buildType: 'bundleless',
+  outputPath: './es'
+}, {
+  buildType: 'bundleless',
+  outputPath: './types',
+  enableDts: true,
+  dtsOnly: true
+}];
+exports.npmComponentPresetConfig = npmComponentPresetConfig;
+const npmComponentWithUmdPresetConfig = [{
+  format: 'cjs',
+  target: 'es6',
+  buildType: 'bundleless',
+  outputPath: './lib'
+}, {
+  format: 'esm',
+  target: 'es6',
+  buildType: 'bundleless',
+  outputPath: './es'
+}, {
+  format: 'umd',
+  target: 'es6',
+  buildType: 'bundle',
+  outputPath: './umd'
+}, {
+  buildType: 'bundleless',
+  outputPath: './types',
+  enableDts: true,
+  dtsOnly: true
+}];
+exports.npmComponentWithUmdPresetConfig = npmComponentWithUmdPresetConfig;
+const unPresetConfigs = {
+  'npm-library': npmLibraryPresetConfig,
+  'npm-library-with-umd': npmLibraryWithUmdPresetConfig,
+  'npm-component': npmComponentPresetConfig,
+  'npm-component-with-umd': npmComponentWithUmdPresetConfig
 };
-exports.PACKAGE_MODES = PACKAGE_MODES;
-const runBabelCompilerTitle = 'Run babel compiler code log';
-exports.runBabelCompilerTitle = runBabelCompilerTitle;
-const runTscWatchTitle = 'Run `tsc -w` log';
-exports.runTscWatchTitle = runTscWatchTitle;
-const runTscTitle = 'Run `tsc` log';
-exports.runTscTitle = runTscTitle;
-const runStyleCompilerTitle = 'Run style compiler code log';
-exports.runStyleCompilerTitle = runStyleCompilerTitle;
-const clearFlag = '\x1Bc';
-exports.clearFlag = clearFlag;
+exports.unPresetConfigs = unPresetConfigs;
+const unPresets = Object.keys(unPresetConfigs);
+exports.unPresets = unPresets;
+const unPresetWithTargetConfigs = unPresets.reduce((o, presetStr) => {
+  const rets = targets.map(target => [`${presetStr}-${target}`.toLowerCase(), unPresetConfigs[presetStr].map(config => {
+    return _objectSpread(_objectSpread({}, config), {}, {
+      target
+    });
+  })]);
+  return _objectSpread(_objectSpread({}, o), Object.fromEntries(rets));
+}, {});
+exports.unPresetWithTargetConfigs = unPresetWithTargetConfigs;

package/dist/js/node/features/build/error.js

@@ -0,0 +1,175 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.padSpaceWith = exports.isInternalError = exports.isExecaError = exports.ModuleBuildError = exports.InternalDTSError = exports.InternalBuildError = void 0;
+
+var _utils = require("@modern-js/utils");
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+const padSpaceWith = (str, targetL, opts = {}) => {
+  const {
+    endStr = '|',
+    style
+  } = opts;
+  const l = str.length;
+  const endStrL = endStr.length;
+  const resetL = targetL - l - endStrL; // str is 'aaa', targetL is 4, result is 'aaa|'
+
+  if (resetL === 0) {
+    return (style ? style(str) : str) + endStr;
+  } // str is 'aaa', targetL is 5, result is 'aaa |'
+
+
+  if (resetL > 0) {
+    const padStr = str.padEnd(targetL - 1, ' ');
+
+    if (style) {
+      return style(str) + padStr.replace(str, '') + endStr;
+    }
+
+    return padStr + endStr;
+  }
+
+  return str;
+};
+
+exports.padSpaceWith = padSpaceWith;
+
+class InternalBuildError extends Error {
+  constructor(e, opts) {
+    super(e.message);
+
+    _defineProperty(this, "buildType", void 0);
+
+    _defineProperty(this, "target", void 0);
+
+    _defineProperty(this, "format", void 0);
+
+    _defineProperty(this, "e", void 0);
+
+    Error.captureStackTrace(this, this.constructor);
+    this.e = e;
+    this.buildType = opts.buildType;
+    this.target = opts.target;
+    this.format = opts.format;
+  }
+
+  toString() {
+    return this.formatError().join('\n');
+  }
+
+  formatError() {
+    const msgs = [];
+    const {
+      e,
+      buildType,
+      target,
+      format
+    } = this;
+    const textL = 25;
+    const title = `│ ${padSpaceWith(`${buildType} failed:`, textL - 2, {
+      style: _utils.chalk.red.underline,
+      endStr: '│'
+    })}`;
+    const formatMsg = padSpaceWith(`│  - format is "${format}"`, textL, {
+      endStr: '│'
+    });
+    const targetMsg = padSpaceWith(`│  - target is "${target}"`, textL, {
+      endStr: '│'
+    });
+    const startLine = padSpaceWith('╭'.padEnd(textL - 1, '─'), textL, {
+      endStr: '╮'
+    });
+    const endLine = padSpaceWith('╰'.padEnd(textL - 1, '─'), textL, {
+      endStr: '╯'
+    });
+    msgs.push(startLine, title, formatMsg, targetMsg, endLine, _utils.chalk.blue.bold.underline(`\nDetailed Information: `));
+    msgs.push(e.toString());
+    msgs.push(e.stack || '');
+    return msgs;
+  }
+
+}
+
+exports.InternalBuildError = InternalBuildError;
+
+class InternalDTSError extends Error {
+  constructor(e, opts) {
+    super(e.message);
+
+    _defineProperty(this, "buildType", void 0);
+
+    _defineProperty(this, "e", void 0);
+
+    Error.captureStackTrace(this, this.constructor);
+    this.e = e;
+    this.buildType = opts.buildType;
+  }
+
+  toString() {
+    return this.formatError().join('\n');
+  }
+
+  formatError() {
+    const msgs = [];
+    const {
+      e,
+      buildType
+    } = this;
+    msgs.push(_utils.chalk.red.bold(`${buildType} DTS failed:`));
+
+    if (isExecaError(e)) {
+      /**
+       * `shortMeessage` content like:
+       * 'Command failed with exit code 2: /Users/github/modern.js/playground/module/node_modules/.bin/tsc -p /Users/github/modern.js/playground/module/node_modules/tsconfig.temp.json --pretty'
+       * Don`t need it.
+       */
+      if (e.stack) {
+        var _e$stack;
+
+        msgs.push((_e$stack = e.stack) === null || _e$stack === void 0 ? void 0 : _e$stack.replace(`${e.name}: ${e.shortMessage}`, ''));
+      }
+    } else {
+      msgs.push(e.stack);
+    }
+
+    return msgs;
+  }
+
+}
+
+exports.InternalDTSError = InternalDTSError;
+
+class ModuleBuildError extends Error {
+  constructor(e) {
+    super(`\n\n${e}`);
+    Error.captureStackTrace(this, this.constructor);
+    this.name = 'ModuleBuildError';
+  }
+
+}
+
+exports.ModuleBuildError = ModuleBuildError;
+
+const isInternalError = e => {
+  if (e instanceof InternalBuildError || e instanceof InternalDTSError) {
+    return true;
+  }
+
+  return false;
+};
+
+exports.isInternalError = isInternalError;
+
+const isExecaError = e => {
+  if (e.stdout) {
+    return true;
+  }
+
+  return false;
+};
+
+exports.isExecaError = isExecaError;