@shuvi/utils 0.0.1-rc.33

package/lib/chalk.d.ts

@@ -0,0 +1,2 @@
+import chalk from 'chalk';
+export default chalk;

package/lib/chalk.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+exports.default = chalk_1.default;

package/lib/deepmerge.d.ts

@@ -0,0 +1 @@
+export declare function deepmerge(...args: any[]): any;

package/lib/deepmerge.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function mergeTwoObject(origin, target) {
+    if (target === null || typeof target === 'undefined') {
+        return origin;
+    }
+    Object.keys(target).forEach((key) => {
+        const originValue = origin[key];
+        const targetValue = target[key];
+        if (Array.isArray(originValue) || Array.isArray(targetValue)) {
+            origin[key] = targetValue;
+        }
+        else if (typeof originValue === 'object' &&
+            typeof targetValue === 'object') {
+            origin[key] = mergeTwoObject(originValue, targetValue);
+        }
+        else {
+            origin[key] = targetValue;
+        }
+    });
+    return origin;
+}
+function deepmerge(...args) {
+    return args.reduce(mergeTwoObject, {});
+}
+exports.deepmerge = deepmerge;

package/lib/defer.d.ts

@@ -0,0 +1,6 @@
+export interface Defer<T = void> {
+    resolve(T?: T | PromiseLike<T>): void;
+    reject(err: any): void;
+    promise: Promise<T>;
+}
+export declare function Defer<T>(): Defer<T>;

package/lib/defer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function Defer() {
+    let defer = {
+        resolve: null,
+        reject: null
+    };
+    defer.promise = new Promise((resolve, reject) => {
+        defer.resolve = resolve;
+        defer.reject = reject;
+    });
+    return defer;
+}
+exports.Defer = Defer;

package/lib/detectTypescript.d.ts

@@ -0,0 +1,7 @@
+interface TypeScriptInfo {
+    useTypeScript: boolean;
+    typeScriptPath?: string;
+    tsConfigPath?: string;
+}
+export declare function getTypeScriptInfo(projectRoot: string): TypeScriptInfo;
+export {};

package/lib/detectTypescript.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const resolve_1 = __importDefault(require("resolve"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const cache = Object.create(null);
+function getTypeScriptInfo(projectRoot) {
+    let info = cache[projectRoot];
+    if (!info) {
+        let typeScriptPath;
+        try {
+            typeScriptPath = resolve_1.default.sync('typescript', {
+                basedir: projectRoot,
+            });
+        }
+        catch (_) { }
+        const tsConfigPath = path_1.default.join(projectRoot, 'tsconfig.json');
+        const useTypeScript = Boolean(typeScriptPath && fs_1.default.existsSync(tsConfigPath));
+        info = Object.assign({ useTypeScript }, (useTypeScript === true && { typeScriptPath, tsConfigPath }));
+    }
+    return info;
+}
+exports.getTypeScriptInfo = getTypeScriptInfo;

package/lib/escapeRegExp.d.ts

@@ -0,0 +1 @@
+export declare function escapeRegExp(s: string): string;

package/lib/escapeRegExp.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function escapeRegExp(s) {
+    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+exports.escapeRegExp = escapeRegExp;

package/lib/eventEmitter.d.ts

@@ -0,0 +1,8 @@
+declare type Handler = (...evts: any[]) => void;
+export declare type EventEmitter<F extends Function = Handler> = {
+    on(type: string, handler: F): void;
+    off(type: string, handler: F): void;
+    emit(type: string, ...evts: any[]): void;
+};
+export default function emitter<F extends Function = Handler>(): EventEmitter<F>;
+export {};

package/lib/eventEmitter.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function emitter() {
+    const all = Object.create(null);
+    return {
+        on(type, handler) {
+            (all[type] || (all[type] = [])).push(handler);
+        },
+        off(type, handler) {
+            if (all[type]) {
+                const index = all[type].indexOf(handler);
+                if (index >= 0) {
+                    all[type].splice(index, 1);
+                }
+            }
+        },
+        emit(type, ...evts) {
+            (all[type] || []).slice().forEach((handler) => {
+                handler(...evts);
+            });
+        }
+    };
+}
+exports.default = emitter;

package/lib/fileWatcher.d.ts

@@ -0,0 +1,13 @@
+import { TimeInfo } from "watchpack";
+export { TimeInfo };
+export interface WatchEvent {
+    changes: string[];
+    removals: string[];
+    getAllFiles: () => string[];
+}
+export interface WatchOptions {
+    files?: string[];
+    directories?: string[];
+}
+export declare type WatchCallback = (event: WatchEvent) => void;
+export declare function watch({ files, directories }: WatchOptions, cb: WatchCallback): () => void;

package/lib/fileWatcher.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const watchpack_1 = __importDefault(require("watchpack"));
+const options = {
+    // options:
+    aggregateTimeout: 300,
+    // fire "aggregated" event when after a change for 1000ms no additional change occurred
+    // aggregated defaults to undefined, which doesn't fire an "aggregated" event
+    ignored: ["**/.git"]
+    // ignored: "string" - a glob pattern for files or folders that should not be watched
+    // ignored: ["string", "string"] - multiple glob patterns that should be ignored
+    // ignored: /regexp/ - a regular expression for files or folders that should not be watched
+    // All subdirectories are ignored too
+};
+function watch({ files, directories }, cb) {
+    const wp = new watchpack_1.default(options);
+    wp.on("aggregated", (changes, removals) => {
+        const knownFiles = wp.getTimeInfoEntries();
+        cb({
+            changes: Array.from(changes),
+            removals: Array.from(removals),
+            getAllFiles() {
+                const res = [];
+                for (const [file, timeinfo] of knownFiles.entries()) {
+                    if (timeinfo && timeinfo.accuracy !== undefined) {
+                        res.push(file);
+                    }
+                }
+                return res;
+            }
+        });
+    });
+    wp.watch({ files, directories });
+    return () => {
+        wp.close();
+    };
+}
+exports.watch = watch;

package/lib/htmlescape.d.ts

@@ -0,0 +1,2 @@
+export declare function htmlEscapeJsonString(str: string): string;
+export declare function htmlEscapeContent(str: string): string;

package/lib/htmlescape.js

@@ -0,0 +1,28 @@
+"use strict";
+// This utility is based on https://github.com/zertosh/htmlescape
+// License: https://github.com/zertosh/htmlescape/blob/0527ca7156a524d256101bb310a9f970f63078ad/LICENSE
+Object.defineProperty(exports, "__esModule", { value: true });
+const JSON_ESCAPE_LOOKUP = {
+    '&': '\\u0026',
+    '>': '\\u003e',
+    '<': '\\u003c',
+    '\u2028': '\\u2028',
+    '\u2029': '\\u2029',
+};
+const JSON_ESCAPE_REGEX = /[&><\u2028\u2029]/g;
+function htmlEscapeJsonString(str) {
+    return str.replace(JSON_ESCAPE_REGEX, (match) => JSON_ESCAPE_LOOKUP[match]);
+}
+exports.htmlEscapeJsonString = htmlEscapeJsonString;
+const CONTENT_ESCAPE_LOOKUP = {
+    '&': '&amp;',
+    '"': '&quot;',
+    "'": '&#39;',
+    '>': '&gt;',
+    '<': '&lt;',
+};
+const CONTENT_ESCAPE_REGEX = /[&><\'\"]/g;
+function htmlEscapeContent(str) {
+    return str.replace(CONTENT_ESCAPE_REGEX, (match) => CONTENT_ESCAPE_LOOKUP[match]);
+}
+exports.htmlEscapeContent = htmlEscapeContent;

package/lib/index.d.ts

@@ -0,0 +1,14 @@
+export { default as NOOP } from './noopFn';
+export * from './defer';
+export declare const EMPTY_OBJ: {};
+export declare const extend: {
+    <T, U>(target: T, source: U): T & U;
+    <T_1, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+};
+export declare const isArray: (arg: any) => arg is any[];
+export declare const isObject: (val: unknown) => val is Record<any, any>;
+export declare const isFunction: (val: unknown) => val is Function;
+export declare const hasOwn: (val: object, key: string | symbol) => key is never;
+export declare function getType(obj: any): string;

package/lib/index.js

@@ -0,0 +1,26 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+var noopFn_1 = require("./noopFn");
+exports.NOOP = noopFn_1.default;
+__export(require("./defer"));
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const toString = Object.prototype.toString;
+exports.EMPTY_OBJ = {};
+exports.extend = Object.assign;
+exports.isArray = Array.isArray;
+exports.isObject = (val) => val !== null && typeof val === 'object';
+exports.isFunction = (val) => typeof val === 'function';
+exports.hasOwn = (val, key) => hasOwnProperty.call(val, key);
+const objectRegExp = /^\[object (\S+)\]$/;
+function getType(obj) {
+    var type = typeof obj;
+    if (type !== 'object') {
+        return type;
+    }
+    // inspect [[Class]] for objects
+    return toString.call(obj).replace(objectRegExp, '$1');
+}
+exports.getType = getType;

package/lib/invariant.d.ts

@@ -0,0 +1,2 @@
+import invariant from "tiny-invariant";
+export default invariant;

package/lib/invariant.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+exports.default = tiny_invariant_1.default;

package/lib/logger.d.ts

@@ -0,0 +1,7 @@
+export interface Logger {
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+}
+export default function logger(namespace: string): Logger;

package/lib/logger.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = __importDefault(require("debug"));
+class LoggerImpl {
+    constructor(namespace) {
+        this._debug = debug_1.default(namespace);
+    }
+    debug(formatter, ...args) {
+        this._debug(formatter, ...args);
+    }
+    info(...args) {
+        console.log("INFO:", ...args);
+    }
+    warn(...args) {
+        console.warn("WARN:", ...args);
+    }
+    error(...args) {
+        console.error("ERROR:", ...args);
+    }
+}
+function logger(namespace) {
+    return new LoggerImpl(namespace);
+}
+exports.default = logger;

package/lib/noop.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/noop.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/noopFn.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/lib/noopFn.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = () => { };

package/lib/nullish.d.ts

@@ -0,0 +1,2 @@
+declare const _default: null;
+export default _default;

package/lib/nullish.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = null;

package/lib/once.d.ts

@@ -0,0 +1 @@
+export declare function once<T extends Function>(fn: T): T;

package/lib/once.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function once(fn) {
+    let hasRun = false;
+    let result;
+    function wrapped(...args) {
+        if (!hasRun) {
+            hasRun = true;
+            result = fn.apply(this, args);
+        }
+        return result;
+    }
+    return wrapped;
+}
+exports.once = once;

package/lib/recursiveCopy.d.ts

@@ -0,0 +1,4 @@
+export declare function recursiveCopy(source: string, dest: string, { concurrency, filter, }?: {
+    concurrency?: number;
+    filter?(path: string): boolean;
+}): Promise<void>;

package/lib/recursiveCopy.js

@@ -0,0 +1,61 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const util_1 = require("util");
+const async_sema_1 = require("async-sema");
+const fsMkdir = util_1.promisify(fs_1.default.mkdir);
+const fsStat = util_1.promisify(fs_1.default.stat);
+const fsReaddir = util_1.promisify(fs_1.default.readdir);
+const fsCopyFile = util_1.promisify(fs_1.default.copyFile);
+const COPYFILE_EXCL = fs_1.default.constants.COPYFILE_EXCL;
+function recursiveCopy(source, dest, { concurrency = 255, filter = () => true, } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cwdPath = process.cwd();
+        const from = path_1.default.resolve(cwdPath, source);
+        const to = path_1.default.resolve(cwdPath, dest);
+        const sema = new async_sema_1.Sema(concurrency);
+        function _copy(item) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const target = item.replace(from, to);
+                const stats = yield fsStat(item);
+                yield sema.acquire();
+                if (stats.isDirectory()) {
+                    try {
+                        yield fsMkdir(target);
+                    }
+                    catch (err) {
+                        // do not throw `folder already exists` errors
+                        if (err.code !== 'EEXIST') {
+                            throw err;
+                        }
+                    }
+                    const files = yield fsReaddir(item);
+                    yield Promise.all(files.map(file => _copy(path_1.default.join(item, file))));
+                }
+                else if (stats.isFile() &&
+                    // before we send the path to filter
+                    // we remove the base path (from) and replace \ by / (windows)
+                    filter(item.replace(from, '').replace(/\\/g, '/'))) {
+                    yield fsCopyFile(item, target, COPYFILE_EXCL);
+                }
+                sema.release();
+                return;
+            });
+        }
+        yield _copy(from);
+    });
+}
+exports.recursiveCopy = recursiveCopy;

package/lib/recursiveDelete.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Recursively read directory
+ * @param {string} dir Directory to delete
+ * @param {Object} options
+ * @param {RegExp} options.filter Filter for the file name, only the relative file path is considered, not the full path
+ * @param {RegExp} options.ignore Ignore certain files, only the relative file path is considered, not the full path
+ * @param {string} options.rootDir Used to replace the initial path, only the relative path is left, it's faster than path.relative.
+ */
+export declare function recursiveDelete(dir: string, { filter, ignore, rootDir, }?: {
+    filter?: RegExp;
+    ignore?: RegExp;
+    rootDir?: string;
+}): Promise<void>;

package/lib/recursiveDelete.js

@@ -0,0 +1,90 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const util_1 = require("util");
+const fsReaddir = util_1.promisify(fs_1.default.readdir);
+const fsStat = util_1.promisify(fs_1.default.stat);
+const fsRmdir = util_1.promisify(fs_1.default.rmdir);
+const fsUnlink = util_1.promisify(fs_1.default.unlink);
+const sleep = util_1.promisify(setTimeout);
+const unlinkFile = (p, t = 1) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield fsUnlink(p);
+    }
+    catch (e) {
+        if ((e.code === 'EBUSY' ||
+            e.code === 'ENOTEMPTY' ||
+            e.code === 'EPERM' ||
+            e.code === 'EMFILE') &&
+            t < 3) {
+            yield sleep(t * 100);
+            return unlinkFile(p, t++);
+        }
+        if (e.code === 'ENOENT') {
+            return;
+        }
+        throw e;
+    }
+});
+/**
+ * Recursively read directory
+ * @param {string} dir Directory to delete
+ * @param {Object} options
+ * @param {RegExp} options.filter Filter for the file name, only the relative file path is considered, not the full path
+ * @param {RegExp} options.ignore Ignore certain files, only the relative file path is considered, not the full path
+ * @param {string} options.rootDir Used to replace the initial path, only the relative path is left, it's faster than path.relative.
+ */
+function recursiveDelete(dir, { filter, ignore, rootDir = dir, } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let result;
+        try {
+            result = yield fsReaddir(dir);
+        }
+        catch (e) {
+            if (e.code === 'ENOENT') {
+                return;
+            }
+            throw e;
+        }
+        yield Promise.all(result.map((part) => __awaiter(this, void 0, void 0, function* () {
+            const absolutePath = path_1.join(dir, part);
+            const pathStat = yield fsStat(absolutePath).catch((e) => {
+                if (e.code !== 'ENOENT')
+                    throw e;
+            });
+            if (!pathStat) {
+                return;
+            }
+            const pp = absolutePath.replace(rootDir, '');
+            if (ignore && ignore.test(pp)) {
+                return;
+            }
+            if (filter && !filter.test(part)) {
+                return;
+            }
+            if (pathStat.isDirectory()) {
+                yield recursiveDelete(absolutePath, {
+                    filter,
+                    ignore,
+                    rootDir: pp,
+                });
+                return fsRmdir(absolutePath);
+            }
+            return unlinkFile(absolutePath);
+        })));
+    });
+}
+exports.recursiveDelete = recursiveDelete;

package/lib/recursiveReaddir.d.ts

@@ -0,0 +1,34 @@
+declare type Test = RegExp | ((v: string) => boolean);
+/**
+ * Recursively read directory
+ * @param {string} dir Directory to read
+ * @param {Object} options
+ * @param {RegExp} options.filter Filter for the file name, only the name part is considered, not the full path
+ * @param {RegExp} options.ignore Ignore certain files, only the name part is considered, not the full path
+ * @param {string} options.rootDir Used to replace the initial path, only the relative path is left, it's faster than path.relative.
+ * @param {string} options.arr This doesn't have to be provided, it's used for the recursion
+ * @returns {Promise<string[]>} Promise array holding all relative paths
+ */
+export declare function recursiveReadDir(dir: string, { filter, ignore, rootDir, arr }?: {
+    filter?: Test;
+    ignore?: RegExp;
+    rootDir?: string;
+    arr?: string[];
+}): Promise<string[]>;
+/**
+ * Recursively read directory
+ * @param {string} dir Directory to read
+ * @param {Object} options
+ * @param {RegExp} options.filter Filter for the file name, only the name part is considered, not the full path
+ * @param {RegExp} options.ignore Ignore certain files, only the name part is considered, not the full path
+ * @param {string} options.rootDir Used to replace the initial path, only the relative path is left, it's faster than path.relative.
+ * @param {string} options.arr This doesn't have to be provided, it's used for the recursion
+ * @returns {string[]} Promise array holding all relative paths
+ */
+export declare function recursiveReadDirSync(dir: string, { filter, ignore, rootDir, arr }?: {
+    filter?: RegExp;
+    ignore?: RegExp;
+    rootDir?: string;
+    arr?: string[];
+}): string[];
+export {};

package/lib/recursiveReaddir.js

@@ -0,0 +1,87 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
+const fsReaddir = util_1.promisify(fs_1.default.readdir);
+const fsStat = util_1.promisify(fs_1.default.stat);
+function runTest(test, v) {
+    if (typeof test === "function") {
+        return test(v);
+    }
+    return test.test(v);
+}
+/**
+ * Recursively read directory
+ * @param {string} dir Directory to read
+ * @param {Object} options
+ * @param {RegExp} options.filter Filter for the file name, only the name part is considered, not the full path
+ * @param {RegExp} options.ignore Ignore certain files, only the name part is considered, not the full path
+ * @param {string} options.rootDir Used to replace the initial path, only the relative path is left, it's faster than path.relative.
+ * @param {string} options.arr This doesn't have to be provided, it's used for the recursion
+ * @returns {Promise<string[]>} Promise array holding all relative paths
+ */
+function recursiveReadDir(dir, { filter, ignore, rootDir = dir, arr = [] } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield fsReaddir(dir);
+        yield Promise.all(result.map((part) => __awaiter(this, void 0, void 0, function* () {
+            const absolutePath = path_1.default.join(dir, part);
+            const pp = absolutePath.replace(rootDir, "");
+            if (ignore && ignore.test(pp)) {
+                return;
+            }
+            const pathStat = yield fsStat(absolutePath);
+            if (pathStat.isDirectory()) {
+                yield recursiveReadDir(absolutePath, { filter, ignore, arr, rootDir });
+                return;
+            }
+            if (filter && !runTest(filter, part)) {
+                return;
+            }
+            arr.push(pp);
+        })));
+        return arr.sort();
+    });
+}
+exports.recursiveReadDir = recursiveReadDir;
+/**
+ * Recursively read directory
+ * @param {string} dir Directory to read
+ * @param {Object} options
+ * @param {RegExp} options.filter Filter for the file name, only the name part is considered, not the full path
+ * @param {RegExp} options.ignore Ignore certain files, only the name part is considered, not the full path
+ * @param {string} options.rootDir Used to replace the initial path, only the relative path is left, it's faster than path.relative.
+ * @param {string} options.arr This doesn't have to be provided, it's used for the recursion
+ * @returns {string[]} Promise array holding all relative paths
+ */
+function recursiveReadDirSync(dir, { filter, ignore, rootDir = dir, arr = [] } = {}) {
+    const result = fs_1.default.readdirSync(dir);
+    result.forEach((part) => {
+        const absolutePath = path_1.default.join(dir, part);
+        if (ignore && ignore.test(part))
+            return;
+        const pathStat = fs_1.default.statSync(absolutePath);
+        if (pathStat.isDirectory()) {
+            recursiveReadDirSync(absolutePath, { filter, ignore, arr, rootDir });
+            return;
+        }
+        if (filter && !filter.test(part)) {
+            return;
+        }
+        arr.push(absolutePath.replace(rootDir, ""));
+    });
+    return arr.sort();
+}
+exports.recursiveReadDirSync = recursiveReadDirSync;

package/lib/resolve.d.ts

@@ -0,0 +1,2 @@
+import resolve from 'resolve';
+export default resolve;

package/lib/resolve.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const resolve_1 = __importDefault(require("resolve"));
+exports.default = resolve_1.default;

package/lib/schemaUtils.d.ts

@@ -0,0 +1,2 @@
+import { validate } from 'schema-utils';
+export { validate };

package/lib/schemaUtils.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_utils_1 = require("schema-utils");
+exports.validate = schema_utils_1.validate;

package/lib/string.d.ts

@@ -0,0 +1 @@
+export declare function joinPath(lead: string, ...paths: string[]): string;

package/lib/string.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function joinPath(lead, ...paths) {
+    if (paths.length < 1) {
+        return lead;
+    }
+    return (lead.replace(/\/+$/, '') +
+        '/' +
+        paths.join('/').replace(/\\/g, '/').replace(/\/+/g, '/').replace(/^\/+/, ''));
+}
+exports.joinPath = joinPath;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@shuvi/utils",
+  "version": "0.0.1-rc.33",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shuvijs/shuvi.git",
+    "directory": "packages/utils"
+  },
+  "author": "liximomo",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "files": [
+    "lib"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "dev": "tsc -p tsconfig.build.json -w",
+    "prebuild": "rimraf lib",
+    "build": "tsc -p tsconfig.build.json"
+  },
+  "engines": {
+    "node": ">= 12.0.0"
+  },
+  "dependencies": {
+    "async-sema": "3.1.0",
+    "chalk": "4.1.0",
+    "debug": "4.3.1",
+    "resolve": "1.19.0",
+    "schema-utils": "^3.0.0",
+    "tiny-invariant": "1.1.0",
+    "watchpack": "2.1.0"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.5",
+    "@types/resolve": "^1.14.0"
+  },
+  "gitHead": "e698d54691f08c02150b9ff8a41125e6b0db2898"
+}