@qse/edu-scripts 0.0.0-beta.0

package/es/index.js

@@ -0,0 +1,7 @@
+// src/index.ts
+import { defineConfig } from "./utils/defineConfig.js";
+import { defineMock } from "./config/plugins/mock-server/defineMock.js";
+export {
+  defineConfig,
+  defineMock
+};

package/es/start.js

@@ -0,0 +1,36 @@
+// src/start.js
+import { rspack } from "@rspack/core";
+import { RspackDevServer } from "@rspack/dev-server";
+import getConfig from "./utils/getConfig.js";
+import chalk from "chalk";
+async function start(args) {
+  process.env.NODE_ENV = "development";
+  process.env.BABEL_ENV = "development";
+  process.env.BROWSERSLIST = "chrome >= 70";
+  process.env.WEBPACK_DEV_SERVER_BASE_PORT = "3000";
+  const basePort = process.env.WEBPACK_DEV_SERVER_BASE_PORT;
+  const port = await RspackDevServer.getFreePort(args.port || process.env.PORT);
+  if (!(args.port || process.env.PORT) && +port !== +basePort) {
+    console.log(chalk.bgYellow(`${basePort} 端口已被占用，现切换到 ${port} 端口运行`));
+  }
+  args.port = port;
+  process.env.PORT = port;
+  const compiler = rspack(getConfig(args));
+  const devServer = new RspackDevServer(compiler.options.devServer, compiler);
+  devServer.start();
+  [("SIGINT", "SIGTERM")].forEach(function(sig) {
+    process.on(sig, function() {
+      devServer.stop();
+      process.exit();
+    });
+  });
+  if (process.env.CI !== "true") {
+    process.stdin.on("end", function() {
+      devServer.stop();
+      process.exit();
+    });
+  }
+}
+export {
+  start as default
+};

package/es/utils/FileSizeReporter.js

@@ -0,0 +1,107 @@
+// src/utils/FileSizeReporter.js
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import filesize from "filesize";
+import recursive from "recursive-readdir";
+import stripAnsi from "strip-ansi";
+import { gzipSizeSync } from "gzip-size";
+function canReadAsset(asset) {
+  return /\.(js|css)$/.test(asset) && !/service-worker\.js/.test(asset) && !/precache-manifest\.[0-9a-f]+\.js/.test(asset);
+}
+function printFileSizesAfterBuild(webpackStats, previousSizeMap, buildFolder, maxBundleGzipSize, maxChunkGzipSize) {
+  var root = previousSizeMap.root;
+  var sizes = previousSizeMap.sizes;
+  var assets = (webpackStats.stats || [webpackStats]).map(
+    (stats) => stats.toJson({ all: false, assets: true }).assets.filter((asset) => canReadAsset(asset.name)).map((asset) => {
+      var fileContents = fs.readFileSync(path.join(root, asset.name));
+      var size = gzipSizeSync(fileContents);
+      var previousSize = sizes[removeFileNameHash(root, asset.name)];
+      var difference = getDifferenceLabel(size, previousSize);
+      return {
+        folder: path.join(path.basename(buildFolder), path.dirname(asset.name)),
+        name: path.basename(asset.name),
+        size,
+        sizeLabel: filesize(size) + (difference ? " (" + difference + ")" : "")
+      };
+    })
+  ).reduce((single, all) => all.concat(single), []);
+  if (assets.length === 0)
+    return;
+  console.log("\ngzip 后文件大小:\n");
+  assets.sort((a, b) => b.size - a.size);
+  var mainAssetIdx = assets.findIndex((asset) => /_\d+\.\d+\.\d+\./.test(asset.name));
+  assets.unshift(assets.splice(mainAssetIdx, 1)[0]);
+  var longestSizeLabelLength = Math.max.apply(
+    null,
+    assets.map((a) => stripAnsi(a.sizeLabel).length)
+  );
+  var suggestBundleSplitting = false;
+  assets.forEach((asset) => {
+    var sizeLabel = asset.sizeLabel;
+    var sizeLength = stripAnsi(sizeLabel).length;
+    if (sizeLength < longestSizeLabelLength) {
+      var rightPadding = " ".repeat(longestSizeLabelLength - sizeLength);
+      sizeLabel += rightPadding;
+    }
+    var isMainBundle = /_\d+\.\d+\.\d+\./.test(asset.name);
+    var maxRecommendedSize = isMainBundle ? maxBundleGzipSize : maxChunkGzipSize;
+    var isLarge = maxRecommendedSize && asset.size > maxRecommendedSize;
+    if (isLarge && path.extname(asset.name) === ".js") {
+      suggestBundleSplitting = true;
+    }
+    console.log(
+      "  " + (isLarge ? chalk.yellow(sizeLabel) : sizeLabel) + "  " + chalk.dim(asset.folder + path.sep) + chalk.cyan(asset.name)
+    );
+    if (isMainBundle) {
+      console.log("");
+    }
+  });
+  if (suggestBundleSplitting) {
+    console.log();
+    console.log(chalk.yellow("产物大小明显大于推荐的大小 (主文件 30k, chunk 1M, 黄色标注为偏大)"));
+    console.log(chalk.yellow("考虑下使用代码分割解决"));
+    console.log(chalk.yellow("也可以使用 npm run analyze 命令分析产物"));
+  }
+  console.log();
+}
+function removeFileNameHash(buildFolder, fileName) {
+  return fileName.replace(buildFolder, "").replace(/\\/g, "/").replace(/\/\d+\.\d+\.\d+\//, "/").replace(/\/?(.*)(\.[0-9a-f]+)(\.chunk)?(\.js|\.css)/, (match, p1, p2, p3, p4) => p1 + p4);
+}
+function getDifferenceLabel(currentSize, previousSize) {
+  var FIFTY_KILOBYTES = 1024 * 50;
+  var difference = currentSize - previousSize;
+  var fileSize = !Number.isNaN(difference) ? filesize(difference) : 0;
+  if (difference >= FIFTY_KILOBYTES) {
+    return chalk.red("+" + fileSize);
+  } else if (difference < FIFTY_KILOBYTES && difference > 0) {
+    return chalk.yellow("+" + fileSize);
+  } else if (difference < 0) {
+    return chalk.green(fileSize);
+  } else {
+    return "";
+  }
+}
+function measureFileSizesBeforeBuild(buildFolder) {
+  return new Promise((resolve) => {
+    recursive(buildFolder, (err, fileNames) => {
+      var sizes;
+      if (!err && fileNames) {
+        sizes = fileNames.filter(canReadAsset).reduce((memo, fileName) => {
+          var contents = fs.readFileSync(fileName);
+          var key = removeFileNameHash(buildFolder, fileName);
+          memo[key] = gzipSizeSync(contents);
+          return memo;
+        }, {});
+      }
+      resolve({
+        root: buildFolder,
+        sizes: sizes || {}
+      });
+    });
+  });
+}
+export {
+  measureFileSizesBeforeBuild,
+  printFileSizesAfterBuild
+};

package/es/utils/appConfig.js

@@ -0,0 +1,35 @@
+// src/utils/appConfig.js
+import paths from "../config/paths.js";
+import fs from "fs-extra";
+var appPkg = fs.readJsonSync(paths.package);
+var edu = appPkg.edu || {};
+if (edu.single || edu.mainProject) {
+  if (edu.single) {
+    edu.mode = "single";
+    delete edu.single;
+  }
+  if (edu.mainProject) {
+    edu.mode = "main";
+    delete edu.mainProject;
+  }
+  fs.writeFileSync(paths.package, JSON.stringify(appPkg, null, 2), "utf-8");
+}
+var appConfig = {
+  /** @type {'main'|'single'} */
+  get mode() {
+    return edu.mode;
+  },
+  get mainProject() {
+    return this.mode === "main";
+  },
+  get single() {
+    return this.mode === "single";
+  },
+  get grayscale() {
+    return !!edu.grayscale;
+  }
+};
+var appConfig_default = appConfig;
+export {
+  appConfig_default as default
+};

package/es/utils/beforeStart.js

@@ -0,0 +1,51 @@
+// src/utils/beforeStart.js
+import fs from "fs-extra";
+import paths from "../config/paths.js";
+import chalk from "chalk";
+import semver from "semver";
+import appConfig from "./appConfig.js";
+import { fileURLToPath } from "node:url";
+var pkg = fs.readJsonSync(fileURLToPath(import.meta.resolve("../../package.json")));
+var appPkg = fs.readJsonSync(paths.package);
+if (semver.valid(appPkg.version) === null) {
+  console.log(
+    chalk.red(`package.version 不符合 semver 规范 https://docs.npmjs.com/about-semantic-versioning`)
+  );
+  process.exit(1);
+}
+switch (appConfig.mode) {
+  case "main":
+    console.log(chalk.bgMagenta("正在使用教育主工程模式"));
+    break;
+  case "single":
+    console.log(chalk.bgMagenta("正在使用独立项目模式"));
+    break;
+  default:
+    console.log(chalk.bgMagenta("正在使用教育集成模式"));
+    break;
+}
+if (appConfig.grayscale) {
+  console.log(chalk.bgYellow("正在使用灰度测试模式"));
+}
+if (!(appConfig.single || appConfig.mainProject)) {
+  if (fs.existsSync(paths.static)) {
+    console.log(chalk.bgYellow("教育集成工程不能含有 public/static, 现已自动删除"));
+    try {
+      fs.rmSync(paths.static, { recursive: true });
+    } catch (e) {
+    }
+  }
+}
+if (!fs.existsSync(paths.public) && !process.argv.includes("auto-refactor")) {
+  console.log(chalk.red(`public 文件夹不存在，请先按文档改造项目`));
+  console.log(`文档: ${chalk.underline(pkg.homepage)}`);
+  console.log(`
+使用 ${chalk.green("npx edu-scripts auto-refactor")} 自动改造
+`);
+  process.exit(0);
+}
+if (appPkg.browserslist) {
+  console.log(chalk.yellow("已删除 package.json 中 browserslist，该值由内部自动控制\n"));
+  delete appPkg.browserslist;
+  fs.writeFileSync(paths.package, JSON.stringify(appPkg, null, 2), "utf-8");
+}

package/es/utils/changeDeployVersion.js

@@ -0,0 +1,85 @@
+// src/utils/changeDeployVersion.js
+import { parse, traverse, types as t, transformFromAstSync } from "@babel/core";
+var TARGET_IDENTIFIER_NAME = "project_apiArr";
+var MODULE_IDENTIFIER_NAME = "module";
+function changeDeployVersion(code, pkg) {
+  const { name, version, grayscale } = pkg;
+  let ast;
+  try {
+    ast = parse(code);
+  } catch (error) {
+    throw new Error(`代码解析错误: ${error.message}`);
+  }
+  const keyName = grayscale ? "grayscale" : "main";
+  function findTargetDeclarator(ast2) {
+    let res;
+    traverse(ast2, {
+      VariableDeclarator(path) {
+        if (t.isIdentifier(path.node.id, { name: TARGET_IDENTIFIER_NAME }) && t.isArrayExpression(path.node.init)) {
+          res = path;
+        }
+      }
+    });
+    return res;
+  }
+  function findModuleObject(path) {
+    let res;
+    path.traverse({
+      ObjectExpression(path2) {
+        if (path2.node.properties.some(
+          (node) => t.isIdentifier(node.key, { name: MODULE_IDENTIFIER_NAME }) && t.isLiteral(node.value, { value: name })
+        )) {
+          res = path2;
+        }
+      }
+    });
+    return res;
+  }
+  function modifyModuleVersion(path) {
+    let hasModify = false;
+    path.traverse({
+      Property(path2) {
+        if (path2.node.key.name === keyName) {
+          path2.node.value.value = version;
+          hasModify = true;
+        }
+      }
+    });
+    if (!hasModify) {
+      path.node.properties.push(t.objectProperty(t.identifier(keyName), t.stringLiteral(version)));
+    }
+  }
+  function deleteModuleComments(path) {
+    path.traverse({
+      ObjectExpression(path2) {
+        delete path2.node.leadingComments;
+      }
+    });
+  }
+  function addModuleToTarget(path) {
+    const elements = path.node.init.elements;
+    elements.splice(
+      elements.length - 2,
+      0,
+      t.objectExpression([
+        t.objectProperty(t.identifier(MODULE_IDENTIFIER_NAME), t.stringLiteral(name)),
+        t.objectProperty(t.identifier(keyName), t.stringLiteral(version))
+      ])
+    );
+  }
+  const targetPath = findTargetDeclarator(ast);
+  if (!targetPath)
+    throw new Error(`ver.js 不合规范，未找到参数 ${TARGET_IDENTIFIER_NAME}`);
+  const moduleObjPath = findModuleObject(targetPath);
+  if (moduleObjPath) {
+    modifyModuleVersion(moduleObjPath);
+  } else {
+    addModuleToTarget(targetPath);
+  }
+  deleteModuleComments(targetPath);
+  return transformFromAstSync(ast, void 0, { minified: true }).code;
+}
+var changeDeployVersion_default = changeDeployVersion;
+export {
+  changeDeployVersion_default as default
+};

package/es/utils/defineConfig.d.ts

@@ -0,0 +1,76 @@
+import type { Chalk } from 'chalk';
+import type { Compiler, Configuration } from '@rspack/core';
+import type { Configuration as DevServerConfiguration } from '@rspack/dev-server';
+type ProxyConfigArray = NonNullable<DevServerConfiguration['proxy']>;
+export type BabelImportPlugin = {
+    libraryName: string;
+    libraryDirectory: string;
+    camel2DashComponentName?: boolean;
+    style?: boolean | 'css' | ((name: string) => string);
+};
+export type Config = {
+    webpack?: (config: Configuration) => Configuration | undefined;
+    devServer?: (config: DevServerConfiguration) => DevServerConfiguration | undefined;
+    /**
+     * webpack alias 配置，会与内置 alias 合并
+     *
+     * @default
+     * { '@': './src' }
+     */
+    alias?: Record<string, string>;
+    /**
+     * webpack externals 配置，会与内置 externals 合并
+     */
+    externals?: Record<string, string>;
+    /**
+     * terser pure_funcs，esbuild pure 配置，传 [] 可以不清空 console.log
+     * @default ['console.log']
+     */
+    pure_funcs?: string[];
+    /**
+     * 是否压缩代码
+     * @default true
+     */
+    minify?: boolean;
+    /** 自定义全局参数 */
+    define?: Record<string, any>;
+    /**
+     * context 填写的顺序很重要，前面的会优先匹配。可以重复定义 /api 来覆盖默认的配置
+     *
+     * proxy 会自动删除请求头 referer，避免某些后端校验失败的问题
+     * @see https://webpack.js.org/configuration/dev-server/#devserverproxy
+     * @default /api -> /qsxxwapdev/api
+     * @example { '/api': 'http://localhost:3000' }
+     * @example [{ context: ['/api'], target: 'http://localhost:3000' }]
+     */
+    proxy?: ProxyConfigArray | Record<string, string>;
+    extraPostCSSPlugins?: any[];
+    /**
+     * 开启 mock 功能，会自动加载 mock 文件夹下的文件
+     *
+     * 默认情况下自动判断根目录是否存在 mock 文件夹，如果存在则开启 mock 功能。
+     * 如果设置 false，会关闭 mock 功能
+     */
+    mock?: boolean;
+    /**
+     * 开发模式启动后只执行一次的函数，用来展示启动后的提示信息，或者自定义的逻辑
+     */
+    startup?: (params: {
+        /** 控制台输出内容 */
+        logger: ReturnType<Compiler['getInfrastructureLogger']>;
+        /** 字体颜色相关工具 */
+        chalk: Chalk;
+        /** webpack compiler 自定义的时候会用到 */
+        compiler: Compiler;
+    }) => void;
+    /**
+     * 是否开启装饰器语法支持 只支持 legacy 版本
+     * @see https://babeljs.io/docs/en/babel-plugin-proposal-decorators
+     * @default false
+     */
+    decorators?: boolean;
+    /** babel-plugin-import */
+    import?: BabelImportPlugin[];
+};
+export declare function defineConfig(config: Config): Config;
+export {};

package/es/utils/defineConfig.js

@@ -0,0 +1,7 @@
+// src/utils/defineConfig.ts
+function defineConfig(config) {
+  return config;
+}
+export {
+  defineConfig
+};

package/es/utils/exec.js

@@ -0,0 +1,10 @@
+// src/utils/exec.js
+import cp from "child_process";
+var exec = (cmd) => {
+  console.log(`> ${cmd}`);
+  return cp.execSync(cmd, { stdio: "inherit", encoding: "utf-8" });
+};
+var exec_default = exec;
+export {
+  exec_default as default
+};

package/es/utils/getConfig.js

@@ -0,0 +1,23 @@
+// src/utils/getConfig.js
+import getWebpackConfig from "../config/webpackConfig.js";
+import getWebpackDevServerConfig from "../config/webpackDevServerConfig.js";
+import getOverride from "./getOverride.js";
+function getConfig(args) {
+  const override = getOverride();
+  let webpackConfig = getWebpackConfig(args, override);
+  if (override.webpack) {
+    webpackConfig = override.webpack(webpackConfig) || webpackConfig;
+  }
+  if (process.env.NODE_ENV === "development") {
+    let devServerConfig = getWebpackDevServerConfig(args, override);
+    if (override.devServer) {
+      devServerConfig = override.devServer(devServerConfig) || devServerConfig;
+    }
+    webpackConfig.devServer = devServerConfig;
+  }
+  return webpackConfig;
+}
+var getConfig_default = getConfig;
+export {
+  getConfig_default as default
+};

package/es/utils/getOverride.js

@@ -0,0 +1,28 @@
+// src/utils/getOverride.js
+import fs from "fs-extra";
+import paths from "../config/paths.js";
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+var defaultOverride = {
+  minify: true,
+  proxy: [],
+  extraPostCSSPlugins: [],
+  import: [],
+  pure_funcs: ["console.log"]
+};
+var override = null;
+function getOverride() {
+  if (override)
+    return override;
+  override = Object.assign({}, defaultOverride);
+  if (fs.existsSync(paths.override)) {
+    const userOverride = require2(paths.override);
+    if (typeof userOverride !== "object")
+      throw new Error("格式错误，请使用 npx edu g override 生成文件");
+    Object.assign(override, userOverride);
+  }
+  return override;
+}
+export {
+  getOverride as default
+};

package/eslint.config.mjs

@@ -0,0 +1,3 @@
+import config from 'eslint-config-qsb-react'
+
+export default config

package/jest.config.mjs

@@ -0,0 +1,199 @@
+/*
+ * For a detailed explanation regarding each configuration property, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+export default {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/private/var/folders/71/g8xbd8f97pzcxd6csv8wxw6h0000gn/T/jest_dx",
+
+  // Automatically clear mock calls, instances, contexts and results before every test
+  clearMocks: true,
+
+  // Enable ESM support for Node.js test environment
+  extensionsToTreatAsEsm: ['.ts'],
+  testEnvironment: 'node',
+
+  // Indicates whether the coverage information should be collected while executing the test
+  // collectCoverage: false,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  // coverageDirectory: undefined,
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  // coverageProvider: "babel",
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // The default configuration for fake timers
+  // fakeTimers: {
+  //   "enableGlobally": false
+  // },
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "mjs",
+  //   "cjs",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  // preset: undefined,
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state before every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state and implementation before every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  // testEnvironment: "jest-environment-node",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).[tj]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // A map from regular expressions to paths to transformers
+  // transform: undefined
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "/node_modules/",
+  //   "\\.pnp\\.[^\\/]+$"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+}