@nocobase/build 0.7.0-alpha.56

package/src/babel.ts

@@ -0,0 +1,257 @@
+import { join, extname, relative } from "path";
+import { existsSync, readFileSync, statSync } from "fs";
+import vfs from "vinyl-fs";
+import signale from "signale";
+import lodash from "lodash";
+import rimraf from "rimraf";
+import through from "through2";
+import slash from "slash2";
+import * as chokidar from "chokidar";
+import * as babel from "@babel/core";
+import gulpTs from "gulp-typescript";
+import gulpLess from "gulp-less";
+import gulpPlumber from "gulp-plumber";
+import gulpIf from "gulp-if";
+import chalk from "chalk";
+import getBabelConfig from "./getBabelConfig";
+import { Dispose, IBundleOptions } from "./types";
+import * as ts from "typescript";
+
+interface IBabelOpts {
+  cwd: string;
+  rootPath?: string;
+  type: "esm" | "cjs";
+  target?: "browser" | "node";
+  log?: (string) => void;
+  watch?: boolean;
+  dispose?: Dispose[];
+  importLibToEs?: boolean;
+  bundleOpts: IBundleOptions;
+}
+
+interface ITransformOpts {
+  file: {
+    contents: string;
+    path: string;
+  };
+  type: "esm" | "cjs";
+}
+
+export default async function (opts: IBabelOpts) {
+  const {
+    cwd,
+    rootPath,
+    type,
+    watch,
+    dispose,
+    importLibToEs,
+    log,
+    bundleOpts: {
+      target = "browser",
+      runtimeHelpers,
+      extraBabelPresets = [],
+      extraBabelPlugins = [],
+      browserFiles = [],
+      nodeFiles = [],
+      nodeVersion,
+      disableTypeCheck,
+      cjs,
+      lessInBabelMode,
+    },
+  } = opts;
+  const srcPath = join(cwd, "src");
+  const targetDir = type === "esm" ? "es" : "lib";
+  const targetPath = join(cwd, targetDir);
+
+  log(chalk.gray(`Clean ${targetDir} directory`));
+  rimraf.sync(targetPath);
+
+  function transform(opts: ITransformOpts) {
+    const { file, type } = opts;
+    const { opts: babelOpts, isBrowser } = getBabelConfig({
+      target,
+      type,
+      typescript: true,
+      runtimeHelpers,
+      filePath: slash(relative(cwd, file.path)),
+      browserFiles,
+      nodeFiles,
+      nodeVersion,
+      lazy: cjs && cjs.lazy,
+      lessInBabelMode,
+    });
+    if (importLibToEs && type === "esm") {
+      babelOpts.plugins.push(require.resolve("../lib/importLibToEs"));
+    }
+    babelOpts.presets.push(...extraBabelPresets);
+    babelOpts.plugins.push(...extraBabelPlugins);
+
+    const relFile = slash(file.path).replace(`${cwd}/`, "");
+    log(
+      `Transform to ${type} for ${chalk[isBrowser ? "yellow" : "blue"](
+        relFile
+      )}`
+    );
+
+    return babel.transform(file.contents, {
+      ...babelOpts,
+      filename: file.path,
+      // 不读取外部的babel.config.js配置文件，全采用babelOpts中的babel配置来构建
+      configFile: false,
+    }).code;
+  }
+
+  /**
+   * tsconfig.json is not valid json file
+   * https://github.com/Microsoft/TypeScript/issues/20384
+   */
+  function parseTsconfig(path: string) {
+    const readFile = (path: string) => readFileSync(path, "utf-8");
+    const result = ts.readConfigFile(path, readFile);
+    if (result.error) {
+      return;
+    }
+    const pkgTsConfig = result.config;
+    if (pkgTsConfig.extends) {
+      const rootTsConfigPath = slash(relative(cwd, pkgTsConfig.extends));
+      const rootTsConfig = parseTsconfig(rootTsConfigPath);
+      if (rootTsConfig) {
+        const mergedConfig = {
+          ...rootTsConfig,
+          ...pkgTsConfig,
+          compilerOptions: {
+            ...rootTsConfig.compilerOptions,
+            ...pkgTsConfig.compilerOptions,
+          },
+        };
+        return mergedConfig;
+      }
+    }
+    return pkgTsConfig;
+  }
+
+  function getTsconfigCompilerOptions(path: string) {
+    const config = parseTsconfig(path);
+    return config ? config.compilerOptions : undefined;
+  }
+
+  function getTSConfig() {
+    const tsconfigPath = join(cwd, "tsconfig.json");
+    const templateTsconfigPath = join(__dirname, "../template/tsconfig.json");
+
+    if (existsSync(tsconfigPath)) {
+      return getTsconfigCompilerOptions(tsconfigPath) || {};
+    }
+    if (rootPath && existsSync(join(rootPath, "tsconfig.json"))) {
+      return getTsconfigCompilerOptions(join(rootPath, "tsconfig.json")) || {};
+    }
+    return getTsconfigCompilerOptions(templateTsconfigPath) || {};
+  }
+
+  function createStream(src) {
+    const tsConfig = getTSConfig();
+    const babelTransformRegexp = disableTypeCheck ? /\.(t|j)sx?$/ : /\.jsx?$/;
+
+    function isTsFile(path) {
+      return /\.tsx?$/.test(path) && !path.endsWith(".d.ts");
+    }
+
+    function isTransform(path) {
+      return babelTransformRegexp.test(path) && !path.endsWith(".d.ts");
+    }
+
+    return vfs
+      .src(src, {
+        allowEmpty: true,
+        base: srcPath,
+      })
+      .pipe(watch ? gulpPlumber() : through.obj())
+      .pipe(
+        gulpIf((f) => !disableTypeCheck && isTsFile(f.path), gulpTs(tsConfig))
+      )
+      .pipe(
+        gulpIf(
+          (f) => lessInBabelMode && /\.less$/.test(f.path),
+          gulpLess(lessInBabelMode || {})
+        )
+      )
+      .pipe(
+        gulpIf(
+          (f) => isTransform(f.path),
+          through.obj((file, env, cb) => {
+            try {
+              file.contents = Buffer.from(
+                transform({
+                  file,
+                  type,
+                })
+              );
+              // .jsx -> .js
+              file.path = file.path.replace(extname(file.path), ".js");
+              cb(null, file);
+            } catch (e) {
+              signale.error(`Compiled faild: ${file.path}`);
+              console.log(e);
+              cb(null);
+            }
+          })
+        )
+      )
+      .pipe(vfs.dest(targetPath));
+  }
+
+  return new Promise((resolve) => {
+    const patterns = [
+      join(srcPath, "**/*"),
+      `!${join(srcPath, "**/fixtures{,/**}")}`,
+      `!${join(srcPath, "**/demos{,/**}")}`,
+      `!${join(srcPath, "**/__test__{,/**}")}`,
+      `!${join(srcPath, "**/__tests__{,/**}")}`,
+      `!${join(srcPath, "**/*.mdx")}`,
+      `!${join(srcPath, "**/*.md")}`,
+      `!${join(srcPath, "**/*.+(test|e2e|spec).+(js|jsx|ts|tsx)")}`,
+      `!${join(srcPath, "**/tsconfig{,.*}.json")}`,
+      `!${join(srcPath, ".umi{,-production,-test}{,/**}")}`,
+    ];
+    createStream(patterns).on("end", () => {
+      if (watch) {
+        log(
+          chalk.magenta(
+            `Start watching ${slash(srcPath).replace(
+              `${cwd}/`,
+              ""
+            )} directory...`
+          )
+        );
+        const watcher = chokidar.watch(patterns, {
+          ignoreInitial: true,
+        });
+
+        const files = [];
+        function compileFiles() {
+          while (files.length) {
+            createStream(files.pop());
+          }
+        }
+
+        const debouncedCompileFiles = lodash.debounce(compileFiles, 1000);
+        watcher.on("all", (event, fullPath) => {
+          const relPath = fullPath.replace(srcPath, "");
+          log(
+            `[${event}] ${slash(join(srcPath, relPath)).replace(`${cwd}/`, "")}`
+          );
+          if (!existsSync(fullPath)) return;
+          if (statSync(fullPath).isFile()) {
+            if (!files.includes(fullPath)) files.push(fullPath);
+            debouncedCompileFiles();
+          }
+        });
+        process.once("SIGINT", () => {
+          watcher.close();
+        });
+        dispose?.push(() => watcher.close());
+      }
+      resolve();
+    });
+  });
+}

package/src/build.ts

@@ -0,0 +1,260 @@
+import * as assert from 'assert';
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import { merge } from 'lodash';
+import { isAbsolute, join, sep } from 'path';
+import rimraf from 'rimraf';
+import signale from 'signale';
+import babel from './babel';
+import getUserConfig, { CONFIG_FILES } from './getUserConfig';
+import randomColor from './randomColor';
+import registerBabel from './registerBabel';
+import rollup from './rollup';
+import { Dispose, IBundleOptions, IBundleTypeOutput, ICjs, IEsm, IOpts } from './types';
+import { getExistFile, getLernaPackages } from './utils';
+
+export function getBundleOpts(opts: IOpts): IBundleOptions[] {
+  const { cwd, buildArgs = {}, rootConfig = {} } = opts;
+  const entry = getExistFile({
+    cwd,
+    files: ['src/index.tsx', 'src/index.ts', 'src/index.jsx', 'src/index.js'],
+    returnRelative: true,
+  });
+  const userConfig = getUserConfig({ cwd, customPath: buildArgs.config });
+  const userConfigs = Array.isArray(userConfig) ? userConfig : [userConfig];
+  return (userConfigs as any).map((userConfig) => {
+    const bundleOpts = merge(
+      {
+        entry,
+      },
+      rootConfig,
+      userConfig,
+      buildArgs
+    );
+
+    // Support config esm: 'rollup' and cjs: 'rollup'
+    if (typeof bundleOpts.esm === 'string') {
+      bundleOpts.esm = { type: bundleOpts.esm };
+    }
+    if (typeof bundleOpts.cjs === 'string') {
+      bundleOpts.cjs = { type: bundleOpts.cjs };
+    }
+
+    return bundleOpts;
+  });
+}
+
+function validateBundleOpts(bundleOpts: IBundleOptions, { cwd, rootPath }) {
+  if (bundleOpts.runtimeHelpers) {
+    const pkgPath = join(cwd, 'package.json');
+    assert.ok(existsSync(pkgPath), `@babel/runtime dependency is required to use runtimeHelpers`);
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    assert.ok(
+      (pkg.dependencies || {})['@babel/runtime'],
+      `@babel/runtime dependency is required to use runtimeHelpers`
+    );
+  }
+  if (
+    bundleOpts.cjs &&
+    (bundleOpts.cjs as ICjs).lazy &&
+    (bundleOpts.cjs as ICjs).type === 'rollup'
+  ) {
+    throw new Error(
+      `
+cjs.lazy don't support rollup.
+    `.trim()
+    );
+  }
+  if (!bundleOpts.esm && !bundleOpts.cjs && !bundleOpts.umd) {
+    throw new Error(
+      `
+None format of ${chalk.cyan(
+        'cjs | esm | umd'
+      )} is configured, checkout https://github.com/umijs/father for usage details.
+`.trim()
+    );
+  }
+  if (bundleOpts.entry) {
+    const tsConfigPath = join(cwd, 'tsconfig.json');
+    const tsConfig =
+      existsSync(tsConfigPath) || (rootPath && existsSync(join(rootPath, 'tsconfig.json')));
+    if (
+      !tsConfig &&
+      ((Array.isArray(bundleOpts.entry) && bundleOpts.entry.some(isTypescriptFile)) ||
+        (!Array.isArray(bundleOpts.entry) && isTypescriptFile(bundleOpts.entry)))
+    ) {
+      signale.info(
+        `Project using ${chalk.cyan(
+          'typescript'
+        )} but tsconfig.json not exists. Use default config.`
+      );
+    }
+  }
+}
+
+function isTypescriptFile(filePath) {
+  return filePath.endsWith('.ts') || filePath.endsWith('.tsx');
+}
+
+interface IExtraBuildOpts {
+  pkg?: string | { name?: string };
+}
+
+export async function build(opts: IOpts, extraOpts: IExtraBuildOpts = {}) {
+  const { cwd, rootPath, watch, buildArgs = {}, clean = true } = opts;
+  const { pkg } = extraOpts;
+
+  const dispose: Dispose[] = [];
+
+  const customConfigPath =
+    buildArgs.config &&
+    (isAbsolute(buildArgs.config) ? buildArgs.config : join(process.cwd(), buildArgs.config));
+
+  // register babel for config files
+  registerBabel({
+    cwd,
+    only: customConfigPath ? CONFIG_FILES.concat(customConfigPath) : CONFIG_FILES,
+  });
+
+  const pkgName = (typeof pkg === 'string' ? pkg : pkg?.name) || 'unknown';
+
+  function log(msg) {
+    console.log(`${pkg ? `${randomColor(`${pkgName}`)}: ` : ''}${msg}`);
+  }
+
+  // Get user config
+  const bundleOptsArray = getBundleOpts(opts);
+
+  for (const bundleOpts of bundleOptsArray) {
+    validateBundleOpts(bundleOpts, { cwd, rootPath });
+
+    // Clean dist
+    if (clean) {
+      log(chalk.gray(`Clean dist directory`));
+      rimraf.sync(join(cwd, 'dist'));
+    }
+
+
+    // Build umd
+    if (bundleOpts.umd) {
+      log(`Build umd`);
+      await rollup({
+        cwd,
+        rootPath,
+        log,
+        type: 'umd',
+        entry: bundleOpts.entry,
+        watch,
+        dispose,
+        bundleOpts,
+      });
+    }
+
+    // Build cjs
+    if (bundleOpts.cjs) {
+      const cjs = bundleOpts.cjs as IBundleTypeOutput;
+      log(`Build cjs with ${cjs.type}`);
+      if (cjs.type === 'babel') {
+        await babel({ cwd, rootPath, watch, dispose, type: 'cjs', log, bundleOpts });
+      } else {
+        await rollup({
+          cwd,
+          rootPath,
+          log,
+          type: 'cjs',
+          entry: bundleOpts.entry,
+          watch,
+          dispose,
+          bundleOpts,
+        });
+      }
+    }
+
+    // Build esm
+    if (bundleOpts.esm) {
+      const esm = bundleOpts.esm as IEsm;
+      log(`Build esm with ${esm.type}`);
+      const importLibToEs = esm && esm.importLibToEs;
+      if (esm && esm.type === 'babel') {
+        await babel({ cwd, rootPath, watch, dispose, type: 'esm', importLibToEs, log, bundleOpts });
+      } else {
+        await rollup({
+          cwd,
+          rootPath,
+          log,
+          type: 'esm',
+          entry: bundleOpts.entry,
+          importLibToEs,
+          watch,
+          dispose,
+          bundleOpts,
+        });
+      }
+    }
+  }
+
+  return dispose;
+}
+
+function getPkgRelativePath(cwd, pkg) {
+  const basePath = cwd.split(sep).join('/') + '/packages/';
+  const dir = pkg.contents.split(sep).join('/');
+  return dir.substring(basePath.length);
+}
+
+export async function buildForLerna(opts: IOpts) {
+  const { cwd, rootConfig = {}, buildArgs = {}, packages = [] } = opts;
+
+  // register babel for config files
+  registerBabel({
+    cwd,
+    only: CONFIG_FILES,
+  });
+
+  const userConfig = merge(getUserConfig({ cwd }), rootConfig, buildArgs);
+
+  let pkgs = await getLernaPackages(cwd, userConfig.pkgFilter);
+  // support define pkgs in lerna
+  if (userConfig.pkgs) {
+    pkgs = pkgs.filter(pkg => userConfig.pkgs.includes(getPkgRelativePath(cwd, pkg)));
+  }
+  const dispose: Dispose[] = [];
+  for (const pkg of pkgs) {
+    const pkgName = getPkgRelativePath(cwd, pkg);
+    if (userConfig.excludePkgs && userConfig.excludePkgs.includes(pkgName)) {
+      continue;
+    }
+    if (packages.length && !packages.includes(pkgName)) continue;
+    // build error when .DS_Store includes in packages root
+    const pkgPath = pkg.contents;
+    assert.ok(
+      existsSync(join(pkgPath, 'package.json')),
+      `package.json not found in packages/${pkg}`
+    );
+    process.chdir(pkgPath);
+    dispose.push(
+      ...(await build(
+        {
+          // eslint-disable-line
+          ...opts,
+          buildArgs: opts.buildArgs,
+          rootConfig: userConfig,
+          cwd: pkgPath,
+          rootPath: cwd,
+        },
+        {
+          pkg,
+        }
+      ))
+    );
+  }
+  return dispose;
+}
+
+export default async function (opts: IOpts) {
+  const useLerna = existsSync(join(opts.cwd, 'lerna.json'));
+  const isLerna = useLerna && process.env.LERNA !== 'none';
+
+  const dispose = isLerna ? await buildForLerna(opts) : await build(opts);
+  return () => dispose.forEach((e) => e());
+}

package/src/es5ImcompatibleVersions.ts

@@ -0,0 +1,33 @@
+// 参考：
+// https://github.com/umijs/umi/blob/2.x/packages/af-webpack/src/getWebpackConfig/es5ImcompatibleVersions.js
+import { dirname } from 'path';
+import pkgUp from 'pkg-up';
+import { satisfies } from 'semver';
+
+const pkgPathCache = {};
+const pkgCache = {};
+const {
+  config: { 'es5-imcompatible-versions': config },
+} = require('es5-imcompatible-versions/package.json');
+
+export function getPkgPath(filePath: string) {
+  const dir = dirname(filePath);
+  if (dir in pkgPathCache) return pkgPathCache[dir];
+  pkgPathCache[dir] = pkgUp.sync({ cwd: filePath });
+  return pkgPathCache[dir];
+}
+
+export function shouldTransform(pkgPath: string) {
+  if (pkgPath in pkgCache) return pkgCache[pkgPath];
+  const { name, version } = require(pkgPath);
+  pkgCache[pkgPath] = isMatch(name, version);
+  return pkgCache[pkgPath];
+}
+
+function isMatch(name, version) {
+  if (config[name]) {
+    return Object.keys(config[name]).some((sv) => satisfies(version, sv));
+  } else {
+    return false;
+  }
+}

package/src/getBabelConfig.ts

@@ -0,0 +1,95 @@
+import { extname } from 'path';
+import { ModuleFormat } from 'rollup';
+
+interface IGetBabelConfigOpts {
+  target: 'browser' | 'node';
+  type?: ModuleFormat;
+  typescript?: boolean;
+  runtimeHelpers?: boolean;
+  filePath?: string;
+  browserFiles?: {
+    [value: string]: any;
+  };
+  nodeVersion?: number;
+  nodeFiles?: {
+    [value: string]: any;
+  };
+  lazy?: boolean;
+  lessInBabelMode?: boolean|{
+    paths?: any[];
+    plugins?: any[];
+  };
+}
+
+function transformImportLess2Css() {
+  return {
+      name: 'transform-import-less-to-css',
+      visitor: {
+          ImportDeclaration(path, source) {
+              const re = /\.less$/;
+              if(re.test(path.node.source.value)){
+                path.node.source.value = path.node.source.value.replace(re, '.css');
+              }
+          }
+      }
+  }
+}
+
+export default function(opts: IGetBabelConfigOpts) {
+  const { target, typescript, type, runtimeHelpers, filePath, browserFiles, nodeFiles, nodeVersion, lazy, lessInBabelMode } = opts;
+  let isBrowser = target === 'browser';
+  // rollup 场景下不会传入 filePath
+  if (filePath) {
+    if (extname(filePath) === '.tsx' || extname(filePath) === '.jsx') {
+      isBrowser = true;
+    } else {
+      if (isBrowser) {
+        if (nodeFiles.includes(filePath)) isBrowser = false;
+      } else {
+        if (browserFiles.includes(filePath)) isBrowser = true;
+      }
+    }
+  }
+  const targets = isBrowser ? { browsers: ['last 2 versions', 'IE 10'] } : { node: nodeVersion || 6 };
+
+  return {
+    opts: {
+      presets: [
+        ...(typescript ? [require.resolve('@babel/preset-typescript')] : []),
+        [require.resolve('@babel/preset-env'), {
+          targets,
+          modules: type === 'esm' ? false : 'auto'
+        }],
+        ...(isBrowser ? [require.resolve('@babel/preset-react')] : []),
+      ],
+      plugins: [
+        ...((type === 'cjs' && lazy && !isBrowser)
+          ? [[require.resolve('@babel/plugin-transform-modules-commonjs'), {
+            lazy: true,
+          }]]
+          : []),
+        ...(lessInBabelMode ? [transformImportLess2Css] : []),
+        ...(isBrowser ? [require.resolve('babel-plugin-react-require')] : []),
+        require.resolve('@babel/plugin-syntax-dynamic-import'),
+        require.resolve('@babel/plugin-proposal-export-default-from'),
+        require.resolve('@babel/plugin-proposal-export-namespace-from'),
+        require.resolve('@babel/plugin-proposal-do-expressions'),
+        require.resolve('@babel/plugin-proposal-nullish-coalescing-operator'),
+        require.resolve('@babel/plugin-proposal-optional-chaining'),
+        [require.resolve('@babel/plugin-proposal-decorators'), { legacy: true }],
+        [require.resolve('@babel/plugin-proposal-class-properties'), { loose: true }],
+        ...(runtimeHelpers
+          ? [[require.resolve('@babel/plugin-transform-runtime'), {
+            useESModules: isBrowser && (type === 'esm'),
+            version: require('@babel/runtime/package.json').version,
+          }]]
+          : []),
+        ...(process.env.COVERAGE
+            ? [require.resolve('babel-plugin-istanbul')]
+            : []
+        )
+      ],
+    },
+    isBrowser,
+  };
+}