@shuvi/utils 1.0.0-rc.2 → 1.0.0-rc.20

package/lib/async.d.ts

@@ -0,0 +1,19 @@
+export declare type Results<T = any> = T[] & {
+    first: T;
+    _firstFlag: boolean;
+};
+export declare type SimpleCallback = () => any;
+export interface AsyncParallelIteratorCallback<T = unknown, E = unknown> {
+    (err?: E | null, value?: T): void;
+}
+export interface AsyncParallelIterator<T, E> {
+    (item: T, callback: AsyncParallelIteratorCallback<T, E>): void;
+}
+export interface AsyncIterator<T, E> {
+    (item: T, callback: ErrorCallback<E>): void;
+}
+export interface ErrorCallback<T> {
+    (err?: T | null): void;
+}
+export declare type AsyncParallelCallback<T, E> = (finishedNum: number, values: Results<T>, errors: Results<E>, done: SimpleCallback) => any;
+export declare function each<T = unknown, E = unknown>(targets: T[], handler: AsyncIterator<T, E>, cb?: ErrorCallback<E>): void;

package/lib/async.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.each = void 0;
+function runParallel(targets, handler, cb) {
+    const values = [];
+    const errors = [];
+    let finishedNum = 0;
+    let abort = false;
+    const done = () => {
+        abort = true;
+    };
+    if (targets.length <= 0) {
+        return cb(finishedNum, values, errors, done);
+    }
+    const handlerCallback = (index) => {
+        let called = false;
+        return (err, value) => {
+            if (called) {
+                return;
+            }
+            called = true;
+            if (abort) {
+                return;
+            }
+            finishedNum++;
+            if (err) {
+                if (!errors.first) {
+                    errors.first = err;
+                }
+                errors[index] = err;
+                return cb(finishedNum, values, errors, done);
+            }
+            if (!values._firstFlag) {
+                values._firstFlag = true;
+                values[index] = value;
+            }
+            cb(finishedNum, values, errors, done);
+        };
+    };
+    targets.forEach((t, index) => {
+        handler(t, handlerCallback(index));
+    });
+}
+function each(targets, handler, cb) {
+    runParallel(targets, handler, (finishedNum, values, errors, done) => {
+        if (errors.first) {
+            done();
+            return cb && cb(errors.first);
+        }
+        if (finishedNum === targets.length) {
+            done();
+            cb && cb(null);
+        }
+    });
+}
+exports.each = each;

package/lib/defer.d.ts

@@ -2,5 +2,6 @@ export interface Defer<T = void> {
     resolve(T?: T | PromiseLike<T>): void;
     reject(err: any): void;
     promise: Promise<T>;
+    status: 'pending' | 'fulfilled' | 'rejected';
 }
 export declare function createDefer<T>(): Defer<T>;

package/lib/defer.js

@@ -4,11 +4,18 @@ exports.createDefer = void 0;
 function createDefer() {
     let defer = {
         resolve: null,
-        reject: null
+        reject: null,
+        status: 'pending'
     };
     defer.promise = new Promise((resolve, reject) => {
-        defer.resolve = resolve;
-        defer.reject = reject;
+        defer.resolve = (value) => {
+            resolve(value);
+            defer.status = 'fulfilled';
+        };
+        defer.reject = (value) => {
+            reject(value);
+            defer.status = 'rejected';
+        };
     });
     return defer;
 }

package/lib/events.d.ts

@@ -0,0 +1,18 @@
+declare type AnyHandler = (...args: any) => void;
+export declare type RemoveListenerCallback = () => void | undefined;
+export declare type Event<F extends AnyHandler> = {
+    toArray: () => F[];
+    length: number;
+    on: (fn: F) => RemoveListenerCallback;
+    emit: (...arg: Parameters<F>) => void;
+};
+export interface EventMap {
+    [key: string]: AnyHandler;
+}
+export declare type Events<EM extends EventMap = EventMap> = {
+    on<Name extends keyof EM, Handler = EM[Name]>(type: Name, handler: Handler): RemoveListenerCallback;
+    emit<Name extends keyof EM, Handler extends AnyHandler = EM[Name]>(type: string, ...args: Parameters<Handler>): void;
+};
+export declare function createEvent<F extends AnyHandler>(): Event<F>;
+export declare function createEvents<EM extends EventMap = EventMap>(): Events<EM>;
+export {};

package/lib/events.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEvents = exports.createEvent = void 0;
+function createEvent() {
+    let handlers = [];
+    return {
+        get length() {
+            return handlers.length;
+        },
+        toArray() {
+            return handlers;
+        },
+        on(fn) {
+            handlers.push(fn);
+            return function () {
+                handlers = handlers.filter(handler => handler !== fn);
+            };
+        },
+        emit(...arg) {
+            // @ts-ignore
+            handlers.forEach(fn => fn && fn(...arg));
+        }
+    };
+}
+exports.createEvent = createEvent;
+function createEvents() {
+    const all = Object.create(null);
+    return {
+        on(type, handler) {
+            (all[type] || (all[type] = [])).push(handler);
+            return () => {
+                const index = all[type].indexOf(handler);
+                if (index > -1) {
+                    all[type].splice(index, 1);
+                }
+            };
+        },
+        emit(type, ...args) {
+            (all[type] || []).slice().forEach(handler => {
+                // @ts-ignore
+                handler(...args);
+            });
+        }
+    };
+}
+exports.createEvents = createEvents;

package/lib/fileWatcher.d.ts

@@ -1,5 +1,5 @@
-import { TimeInfo } from 'watchpack';
-export { TimeInfo };
+import Watchpack, { TimeInfo } from 'watchpack';
+export { Watchpack, TimeInfo };
 export interface WatchEvent {
     changes: string[];
     removals: string[];
@@ -9,7 +9,10 @@ export interface WatchOptions {
     files?: string[];
     directories?: string[];
     missing?: string[];
+    aggregateTimeout?: number;
     startTime?: number;
+    ignoreFileContentUpdate?: boolean;
 }
 export declare type WatchCallback = (event: WatchEvent) => void;
-export declare function watch({ files, directories, missing, startTime }: WatchOptions, cb: WatchCallback): () => void;
+export declare type ChangeCallback = (file: string, time: number) => void;
+export declare function watch({ files, directories, missing, aggregateTimeout, startTime, ignoreFileContentUpdate }: WatchOptions, callback: WatchCallback, callbackUndelayed?: ChangeCallback): () => void;

package/lib/fileWatcher.js

@@ -3,8 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.watch = void 0;
+exports.watch = exports.Watchpack = void 0;
 const watchpack_1 = __importDefault(require("watchpack"));
+exports.Watchpack = watchpack_1.default;
+const watchpackExplanationType = {
+    change: 'change',
+    rename: 'rename'
+};
 const options = {
     // options:
     aggregateTimeout: 300,
@@ -16,17 +21,30 @@ const options = {
     // ignored: /regexp/ - a regular expression for files or folders that should not be watched
     // All subdirectories are ignored too
 };
-function watch({ files, directories, missing, startTime = Date.now() }, cb) {
-    const wp = new watchpack_1.default(options);
-    wp.on('aggregated', (changes, removals) => {
+function watch({ files, directories, missing, aggregateTimeout, startTime = Date.now(), ignoreFileContentUpdate }, callback, callbackUndelayed) {
+    const watchPackOptions = Object.assign({}, options);
+    if (aggregateTimeout !== undefined) {
+        watchPackOptions.aggregateTimeout = aggregateTimeout;
+    }
+    const wp = new watchpack_1.default(watchPackOptions);
+    let aggregatedChanges = new Set();
+    let aggregatedRemovals = new Set();
+    wp.on('aggregated', () => {
+        if (!aggregatedChanges.size && !aggregatedRemovals.size) {
+            return;
+        }
         const knownFiles = wp.getTimeInfoEntries();
-        cb({
-            changes: Array.from(changes),
-            removals: Array.from(removals),
+        const changes = Array.from(aggregatedChanges);
+        const removals = Array.from(aggregatedRemovals);
+        aggregatedChanges = new Set();
+        aggregatedRemovals = new Set();
+        callback({
+            changes,
+            removals,
             getAllFiles() {
                 const res = [];
-                for (const [file, timeinfo] of knownFiles.entries()) {
-                    if (timeinfo && timeinfo.accuracy !== undefined) {
+                for (const [file, timeInfo] of knownFiles.entries()) {
+                    if (timeInfo && timeInfo.accuracy !== undefined) {
                         res.push(file);
                     }
                 }
@@ -34,8 +52,28 @@ function watch({ files, directories, missing, startTime = Date.now() }, cb) {
             }
         });
     });
+    wp.on('change', (file, time, explanation) => {
+        if (ignoreFileContentUpdate &&
+            explanation === watchpackExplanationType.change) {
+            return;
+        }
+        aggregatedRemovals.delete(file);
+        aggregatedChanges.add(file);
+        callbackUndelayed === null || callbackUndelayed === void 0 ? void 0 : callbackUndelayed(file, time);
+    });
+    wp.on('remove', (file, time, explanation) => {
+        if (ignoreFileContentUpdate &&
+            explanation === watchpackExplanationType.change) {
+            return;
+        }
+        aggregatedChanges.delete(file);
+        aggregatedRemovals.add(file);
+        callbackUndelayed === null || callbackUndelayed === void 0 ? void 0 : callbackUndelayed(file, time);
+    });
     wp.watch({ files, directories, missing, startTime });
     return () => {
+        aggregatedChanges.clear();
+        aggregatedRemovals.clear();
         wp.close();
     };
 }

package/lib/logger.d.ts

@@ -4,4 +4,17 @@ export interface Logger {
     warn(...args: any[]): void;
     error(...args: any[]): void;
 }
-export default function logger(namespace: string): Logger;
+export declare const colorize: {
+    error: (...message: any[]) => string;
+    warn: (...message: any[]) => string;
+};
+declare class LoggerImpl implements Logger {
+    private _debug;
+    constructor(namespace: string);
+    debug(formatter: any, ...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+}
+declare const _default: LoggerImpl;
+export default _default;

package/lib/logger.js

@@ -3,7 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorize = void 0;
 const debug_1 = __importDefault(require("debug"));
+const chalk_1 = __importDefault(require("chalk"));
+exports.colorize = {
+    error: (...message) => chalk_1.default.red(...message),
+    warn: (...message) => chalk_1.default.yellow(...message)
+};
 class LoggerImpl {
     constructor(namespace) {
         this._debug = (0, debug_1.default)(namespace);
@@ -12,16 +18,13 @@ class LoggerImpl {
         this._debug(formatter, ...args);
     }
     info(...args) {
-        console.log("INFO:", ...args);
+        console.log(...args);
     }
     warn(...args) {
-        console.warn("WARN:", ...args);
+        console.warn(exports.colorize.warn(...args));
     }
     error(...args) {
-        console.error("ERROR:", ...args);
+        console.error(exports.colorize.error(...args));
     }
 }
-function logger(namespace) {
-    return new LoggerImpl(namespace);
-}
-exports.default = logger;
+exports.default = new LoggerImpl('shuvi');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shuvi/utils",
-  "version": "1.0.0-rc.2",
+  "version": "1.0.0-rc.20",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shuvijs/shuvi.git",
@@ -28,7 +28,7 @@
     "resolve": "1.22.1",
     "schema-utils": "^3.0.0",
     "tiny-invariant": "1.1.0",
-    "watchpack": "2.1.0"
+    "watchpack": "^2.4.0"
   },
   "devDependencies": {
     "@types/debug": "^4.1.5",

package/lib/eventEmitter.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1,24 +0,0 @@
-"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;