@modern-js/utils 1.3.7 → 1.5.0

package/dist/monorepo.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMonorepoPackages = exports.findMonorepoRoot = exports.isModernjsMonorepo = exports.isMonorepo = exports.isPnpmWorkspaces = exports.isYarnWorkspaces = exports.isLerna = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const compiled_1 = require("./compiled");
+const PACKAGE_MAX_DEPTH = 5;
+const WOKRSPACES_FILES = {
+    YARN: 'package.json',
+    PNPM: 'pnpm-workspaces.yaml',
+    LERNA: 'lerna.json',
+};
+const isLerna = (root) => fs_1.default.existsSync(path_1.default.join(root, WOKRSPACES_FILES.LERNA));
+exports.isLerna = isLerna;
+const isYarnWorkspaces = (root) => {
+    var _a;
+    const pkg = path_1.default.join(root, WOKRSPACES_FILES.YARN);
+    if (!fs_1.default.existsSync(pkg)) {
+        return false;
+    }
+    const json = JSON.parse(fs_1.default.readFileSync(pkg, 'utf8'));
+    return Boolean((_a = json.workspaces) === null || _a === void 0 ? void 0 : _a.packages);
+};
+exports.isYarnWorkspaces = isYarnWorkspaces;
+const isPnpmWorkspaces = (root) => fs_1.default.existsSync(path_1.default.join(root, WOKRSPACES_FILES.PNPM));
+exports.isPnpmWorkspaces = isPnpmWorkspaces;
+const isMonorepo = (root) => (0, exports.isLerna)(root) || (0, exports.isYarnWorkspaces)(root) || (0, exports.isPnpmWorkspaces)(root);
+exports.isMonorepo = isMonorepo;
+const isModernjsMonorepo = (root) => {
+    const json = JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, 'package.json'), 'utf8'));
+    const deps = Object.assign(Object.assign({}, (json.dependencies || {})), (json.devDependencies || {}));
+    return Boolean(deps['@modern-js/monorepo-tools']);
+};
+exports.isModernjsMonorepo = isModernjsMonorepo;
+const findMonorepoRoot = (appDirectory, maxDepth = PACKAGE_MAX_DEPTH) => {
+    let inMonorepo = false;
+    for (let depth = 0; depth < maxDepth; depth++) {
+        if ((0, exports.isMonorepo)(appDirectory)) {
+            inMonorepo = true;
+            break;
+        }
+        // eslint-disable-next-line no-param-reassign
+        appDirectory = path_1.default.dirname(appDirectory);
+    }
+    return inMonorepo ? appDirectory : undefined;
+};
+exports.findMonorepoRoot = findMonorepoRoot;
+const getMonorepoPackages = (root) => {
+    let packages = [];
+    if ((0, exports.isYarnWorkspaces)(root)) {
+        const json = JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, 'package.json'), 'utf8'));
+        ({ packages } = json.workspaces);
+    }
+    else if ((0, exports.isLerna)(root)) {
+        const json = JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(root, 'lerna.json'), 'utf8'));
+        ({ packages } = json);
+    }
+    else {
+        ({ packages } = compiled_1.yaml.load(fs_1.default.readFileSync(path_1.default.join(root, WOKRSPACES_FILES.PNPM), 'utf8')));
+    }
+    if (packages) {
+        return packages
+            .map(name => 
+        // The trailing / ensures only dirs are picked up
+        compiled_1.glob.sync(path_1.default.join(root, `${name}/`), {
+            ignore: ['**/node_modules/**'],
+        }))
+            .reduce((acc, val) => acc.concat(val), [])
+            .filter(filepath => fs_1.default.existsSync(path_1.default.resolve(filepath, 'package.json')))
+            .map(filepath => ({
+            path: filepath,
+            name: JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(filepath, 'package.json'), 'utf8')).name,
+        }));
+    }
+    return [];
+};
+exports.getMonorepoPackages = getMonorepoPackages;

package/dist/{types/nodeEnv.d.ts → nodeEnv.d.ts}

@@ -1,3 +1,3 @@
 export declare function canUseNpm(): Promise<boolean>;
 export declare function canUseYarn(): Promise<boolean>;
-export declare function canUsePnpm(): Promise<boolean>;
+export declare function canUsePnpm(): Promise<boolean>;

package/dist/nodeEnv.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canUsePnpm = exports.canUseYarn = exports.canUseNpm = void 0;
+const compiled_1 = require("./compiled");
+function canUseNpm() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield (0, compiled_1.execa)('npm', ['--version'], { env: process.env });
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    });
+}
+exports.canUseNpm = canUseNpm;
+function canUseYarn() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield (0, compiled_1.execa)('yarn', ['--version'], { env: process.env });
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    });
+}
+exports.canUseYarn = canUseYarn;
+function canUsePnpm() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield (0, compiled_1.execa)('pnpm', ['--version'], { env: process.env });
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    });
+}
+exports.canUsePnpm = canUsePnpm;

package/dist/{types/path.d.ts → path.d.ts}

@@ -1,3 +1,3 @@
 export declare const isRelativePath: (test: string) => boolean;
 export declare const normalizeOutputPath: (s: string) => string;
-export declare const normalizeToPosixPath: (p: string) => string;
+export declare const normalizeToPosixPath: (p: string) => string;

package/dist/path.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeToPosixPath = exports.normalizeOutputPath = exports.isRelativePath = void 0;
+const path_1 = __importDefault(require("path"));
+const compiled_1 = require("./compiled");
+const isRelativePath = (test) => /^\.\.?($|[\\/])/.test(test);
+exports.isRelativePath = isRelativePath;
+const normalizeOutputPath = (s) => s.replace(/\\/g, '\\\\');
+exports.normalizeOutputPath = normalizeOutputPath;
+const normalizeToPosixPath = (p) => compiled_1.upath.normalizeSafe(path_1.default.normalize(p));
+exports.normalizeToPosixPath = normalizeToPosixPath;

package/dist/{types/prettyInstructions.d.ts → prettyInstructions.d.ts}

@@ -1,6 +1,6 @@
 interface EntryPoint {
-  entryName: string;
+    entryName: string;
 }
 export declare const isSingleEntry: (entrypoints: EntryPoint[]) => boolean;
 export declare const prettyInstructions: (appContext: any, config: any) => string;
-export {};
+export {};

package/dist/prettyInstructions.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyInstructions = exports.isSingleEntry = void 0;
+const os_1 = __importDefault(require("os"));
+const compiled_1 = require("./compiled");
+const is_1 = require("./is");
+// TODO: remove hard code 'main'
+const isSingleEntry = (entrypoints) => entrypoints.length === 1 && entrypoints[0].entryName === 'main';
+exports.isSingleEntry = isSingleEntry;
+const normalizeUrl = (url) => url.replace(/([^:]\/)\/+/g, '$1');
+const getAddressUrls = (protocol = 'http', port) => {
+    const interfaces = os_1.default.networkInterfaces();
+    const ipv4Interfaces = [];
+    Object.keys(interfaces).forEach(key => {
+        interfaces[key].forEach(detail => {
+            if (detail.family === 'IPv4') {
+                ipv4Interfaces.push(detail);
+            }
+        });
+    });
+    return ipv4Interfaces.reduce((memo, detail) => {
+        let type = 'Network:  ';
+        let url = `${protocol}://${detail.address}:${port}`;
+        if (detail.address.includes(`localhost`)) {
+            type = 'Local:  ';
+            url = `${protocol}://localhost:${port}`;
+        }
+        memo.push({ type, url });
+        return memo;
+    }, []);
+};
+const prettyInstructions = (appContext, config) => {
+    const { entrypoints, serverRoutes, port, apiOnly, checkedEntries } = appContext;
+    const urls = getAddressUrls(config.dev.https && (0, is_1.isDev)() ? 'https' : 'http', port);
+    const routes = !apiOnly
+        ? serverRoutes.filter(route => route.entryName)
+        : serverRoutes;
+    let message = 'App running at:\n\n';
+    if ((0, exports.isSingleEntry)(entrypoints) || apiOnly) {
+        message += urls
+            .map(({ type, url }) => `  ${compiled_1.chalk.bold(`> ${type.padEnd(10)}`)}${compiled_1.chalk.cyanBright(normalizeUrl(`${url}/${routes[0].urlPath}`))}\n`)
+            .join('');
+    }
+    else {
+        const maxNameLength = Math.max(...routes.map(r => r.entryName.length));
+        urls.forEach(({ type, url }) => {
+            message += `  ${compiled_1.chalk.bold(`> ${type}`)}\n`;
+            routes.forEach(({ entryName, urlPath, isSSR }) => {
+                if (!checkedEntries.includes(entryName)) {
+                    return;
+                }
+                message += `    ${compiled_1.chalk.yellowBright(isSSR ? 'λ' : '○')}  ${compiled_1.chalk.yellowBright(entryName.padEnd(maxNameLength + 8))}${compiled_1.chalk.cyanBright(normalizeUrl(`${url}/${urlPath}`))}\n`;
+            });
+        });
+        message += '\n';
+        message += compiled_1.chalk.cyanBright('  λ (Server) server-side renders at runtime\n');
+        message += compiled_1.chalk.cyanBright('  ○ (Static) client-side rendered as static HTML\n');
+    }
+    return message;
+};
+exports.prettyInstructions = prettyInstructions;

package/dist/{types/printBuildError.d.ts → printBuildError.d.ts}

@@ -5,4 +5,4 @@
  * LICENSE file at
  * https://github.com/facebook/create-react-app/blob/master/LICENSE
  */
-export declare function printBuildError(err: Error): void;
+export declare function printBuildError(err: Error): void;

package/dist/printBuildError.js

@@ -0,0 +1,43 @@
+"use strict";
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file at
+ * https://github.com/facebook/create-react-app/blob/master/LICENSE
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printBuildError = void 0;
+// Modified by Chao Xu (xuchaobei)
+const compiled_1 = require("./compiled");
+const logger_1 = require("./logger");
+function printBuildError(err) {
+    const message = err != null && err.message;
+    const stack = err != null && err.stack;
+    // Add more helpful message for Terser error
+    if (stack &&
+        typeof message === 'string' &&
+        message.indexOf('from Terser') !== -1) {
+        try {
+            const matched = /(.+)\[(.+):(.+),(.+)\]\[.+\]/.exec(stack);
+            if (!matched) {
+                throw new Error('Using errors for control flow is bad.');
+            }
+            const problemPath = matched[2];
+            const line = matched[3];
+            const column = matched[4];
+            logger_1.logger.error(`Failed to minify the code from this file: \n\n ${compiled_1.chalk.yellow(`\t${problemPath}:${line}${column !== '0' ? ':' + column : ''}`)}\n`);
+        }
+        catch (ignored) {
+            logger_1.logger.error(`Failed to minify the bundle. ${err}\n`);
+        }
+    }
+    else {
+        logger_1.logger.error((message || err) + '\n');
+    }
+    logger_1.logger.log();
+}
+exports.printBuildError = printBuildError;
+/* eslint-enable */

package/dist/{types/readTsConfig.d.ts → readTsConfig.d.ts}

@@ -1,2 +1,2 @@
 export declare const readTsConfig: (root: string) => any;
-export declare const readTsConfigByFile: (filename: string) => any;
+export declare const readTsConfigByFile: (filename: string) => any;

package/dist/readTsConfig.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTsConfigByFile = exports.readTsConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const readTsConfig = (root) => {
+    // import typescript from 'typescript' cause eslint fromat error.
+    const typescript = require('typescript');
+    return typescript.readConfigFile(path_1.default.resolve(root, './tsconfig.json'), typescript.sys.readFile).config;
+};
+exports.readTsConfig = readTsConfig;
+const readTsConfigByFile = (filename) => {
+    // import typescript from 'typescript' cause eslint fromat error.
+    const typescript = require('typescript');
+    return typescript.readConfigFile(path_1.default.resolve(filename), typescript.sys.readFile).config;
+};
+exports.readTsConfigByFile = readTsConfigByFile;

package/dist/{types/removeSlash.d.ts → removeSlash.d.ts}

@@ -1,3 +1,3 @@
 export declare const removeLeadingSlash: (s: string) => string;
 export declare const removeTailSlash: (s: string) => string;
-export declare const removeSlash: (s: string) => string;
+export declare const removeSlash: (s: string) => string;

package/dist/removeSlash.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeSlash = exports.removeTailSlash = exports.removeLeadingSlash = void 0;
+const removeLeadingSlash = (s) => s.replace(/^\/+/, '');
+exports.removeLeadingSlash = removeLeadingSlash;
+const removeTailSlash = (s) => s.replace(/\/+$/, '');
+exports.removeTailSlash = removeTailSlash;
+const removeSlash = (s) => (0, exports.removeLeadingSlash)((0, exports.removeTailSlash)(s));
+exports.removeSlash = removeSlash;

package/dist/{types/runtimeExports.d.ts → runtimeExports.d.ts}

@@ -1,4 +1,4 @@
 export declare const createRuntimeExportsUtils: (pwd: any, namespace: string, ts?: any) => {
-  addExport: (statement: string) => void;
-  getPath: () => string;
-};
+    addExport: (statement: string) => void;
+    getPath: () => string;
+};

package/dist/runtimeExports.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuntimeExportsUtils = void 0;
+const path_1 = __importDefault(require("path"));
+const compiled_1 = require("./compiled");
+const path_2 = require("./path");
+const memo = (fn) => {
+    const cache = new Map();
+    return (...params) => {
+        const stringifiedParams = JSON.stringify(params);
+        const cachedResult = cache.get(stringifiedParams);
+        if (cachedResult) {
+            return cachedResult;
+        }
+        const res = fn(...params);
+        cache.set(stringifiedParams, res);
+        return res;
+    };
+};
+exports.createRuntimeExportsUtils = memo((pwd = '', namespace, ts = false) => {
+    const entryExportFile = path_1.default.join(pwd, `.runtime-exports/${namespace ? `${namespace}.js` : 'index.js'}`);
+    const entryExportTsFile = path_1.default.join(pwd, `.runtime-exports/${namespace ? `${namespace}.d.ts` : 'index.d.ts'}`);
+    // const ensure = () => {
+    //   if (!fs.existsSync(entryExportFile)) {
+    //     fs.outputFileSync(entryExportFile, '');
+    //   }
+    //   fs.ensureFileSync(entryExportFile);
+    // };
+    const addExport = (statement) => {
+        // eslint-disable-next-line no-param-reassign
+        statement = (0, path_2.normalizeOutputPath)(statement);
+        try {
+            compiled_1.fs.ensureFileSync(entryExportFile);
+            compiled_1.fs.ensureFileSync(entryExportTsFile);
+            if (!compiled_1.fs.readFileSync(entryExportFile, 'utf8').includes(statement)) {
+                compiled_1.fs.appendFileSync(entryExportFile, `${statement}\n`);
+                ts &&
+                    compiled_1.fs.appendFileSync(entryExportTsFile, `${statement.replace('.js', '.d')}\n`);
+            }
+        }
+        catch (_a) {
+            // FIXME:
+        }
+    };
+    const getPath = () => entryExportFile;
+    return {
+        addExport,
+        getPath,
+    };
+});

package/dist/ssrHelpers.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import type { IncomingHttpHeaders } from 'http';
+declare const run: <O>(context: IncomingHttpHeaders, cb: () => O | Promise<O>) => Promise<O>, useHeaders: () => IncomingHttpHeaders;
+export { run, useHeaders };

package/dist/ssrHelpers.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHeaders = exports.run = void 0;
+const storage_1 = require("./storage");
+const { run, useContext: useHeaders } = (0, storage_1.createStorage)();
+exports.run = run;
+exports.useHeaders = useHeaders;

package/dist/storage.d.ts

@@ -0,0 +1,5 @@
+declare const createStorage: <T>() => {
+    run: <O>(context: T, cb: () => O | Promise<O>) => Promise<O>;
+    useContext: () => T;
+};
+export { createStorage };

package/dist/storage.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStorage = void 0;
+const ah = __importStar(require("async_hooks"));
+const createStorage = () => {
+    let storage;
+    if (typeof ah.AsyncLocalStorage !== 'undefined') {
+        storage = new ah.AsyncLocalStorage();
+    }
+    const run = (context, cb) => {
+        if (!storage) {
+            throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        }
+        return new Promise((resolve, reject) => {
+            storage.run(context, () => {
+                try {
+                    return resolve(cb());
+                }
+                catch (error) {
+                    return reject(error);
+                }
+            });
+        });
+    };
+    const useContext = () => {
+        if (!storage) {
+            throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        }
+        const context = storage.getStore();
+        if (!context) {
+            throw new Error(`Can't call useContext out of scope, make sure @modern-js/utils is a single version in node_modules`);
+        }
+        return context;
+    };
+    return {
+        run,
+        useContext,
+    };
+};
+exports.createStorage = createStorage;

package/dist/{types/wait.d.ts → wait.d.ts}

@@ -1,2 +1,2 @@
 declare const wait: (time?: number) => Promise<unknown>;
-export { wait };
+export { wait };

package/dist/wait.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wait = void 0;
+const wait = (time = 0) => new Promise(resolve => {
+    setTimeout(resolve, time);
+});
+exports.wait = wait;

package/dist/{types/watch.d.ts → watch.d.ts}

@@ -1,8 +1,8 @@
 export declare type WatchChangeTypeValueT = 'add' | 'unlink' | 'change';
 export declare const WatchChangeType: Record<'ADD' | 'UNLINK' | 'CHANGE', WatchChangeTypeValueT>;
 declare type RunTaskType = (option: {
-  changedFilePath: string;
-  changeType: WatchChangeTypeValueT;
+    changedFilePath: string;
+    changeType: WatchChangeTypeValueT;
 }) => void | Promise<void>;
-export declare const watch: (watchDir: string | string[], runTask: RunTaskType, ignored?: string[]) => import("chokidar").FSWatcher;
-export {};
+export declare const watch: (watchDir: string | string[], runTask: RunTaskType, ignored?: string[]) => import("./compiled").FSWatcher;
+export {};

package/dist/watch.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watch = exports.WatchChangeType = void 0;
+const path = __importStar(require("path"));
+const compiled_1 = require("./compiled");
+exports.WatchChangeType = {
+    ADD: 'add',
+    UNLINK: 'unlink',
+    CHANGE: 'change',
+};
+const watch = (watchDir, runTask, ignored = []) => {
+    let ready = false;
+    const watcher = compiled_1.chokidar.watch(watchDir, {
+        ignored,
+    });
+    watcher.on('ready', () => (ready = true));
+    watcher.on('change', (filePath) => __awaiter(void 0, void 0, void 0, function* () {
+        const changedFilePath = path.resolve(filePath);
+        yield runTask({ changedFilePath, changeType: exports.WatchChangeType.CHANGE });
+    }));
+    watcher.on('add', (filePath) => __awaiter(void 0, void 0, void 0, function* () {
+        const changedFilePath = path.resolve(filePath);
+        if (ready) {
+            yield runTask({ changedFilePath, changeType: exports.WatchChangeType.ADD });
+        }
+    }));
+    watcher.on('unlink', (filePath) => __awaiter(void 0, void 0, void 0, function* () {
+        const changedFilePath = path.resolve(filePath);
+        yield runTask({ changedFilePath, changeType: exports.WatchChangeType.UNLINK });
+    }));
+    watcher.on('error', err => {
+        throw err;
+    });
+    return watcher;
+};
+exports.watch = watch;