@shuvi/utils 1.0.0-rc.4 → 1.0.0-rc.7

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/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

@@ -13,4 +13,5 @@ export interface WatchOptions {
     startTime?: number;
 }
 export declare type WatchCallback = (event: WatchEvent) => void;
-export declare function watch({ files, directories, missing, aggregateTimeout, startTime }: WatchOptions, cb: WatchCallback): () => void;
+export declare type ChangeCallback = (file: string, time: number) => void;
+export declare function watch({ files, directories, missing, aggregateTimeout, startTime }: WatchOptions, callback: WatchCallback, callbackUndelayed?: ChangeCallback): () => void;

package/lib/fileWatcher.js

@@ -16,7 +16,7 @@ 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, aggregateTimeout, startTime = Date.now() }, cb) {
+function watch({ files, directories, missing, aggregateTimeout, startTime = Date.now() }, callback, callbackUndelayed) {
     const watchPackOptions = Object.assign({}, options);
     if (aggregateTimeout !== undefined) {
         watchPackOptions.aggregateTimeout = aggregateTimeout;
@@ -24,7 +24,7 @@ function watch({ files, directories, missing, aggregateTimeout, startTime = Date
     const wp = new watchpack_1.default(watchPackOptions);
     wp.on('aggregated', (changes, removals) => {
         const knownFiles = wp.getTimeInfoEntries();
-        cb({
+        callback({
             changes: Array.from(changes),
             removals: Array.from(removals),
             getAllFiles() {
@@ -38,6 +38,10 @@ function watch({ files, directories, missing, aggregateTimeout, startTime = Date
             }
         });
     });
+    if (callbackUndelayed) {
+        wp.on('change', callbackUndelayed);
+        wp.on('remove', callbackUndelayed);
+    }
     wp.watch({ files, directories, missing, startTime });
     return () => {
         wp.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shuvi/utils",
-  "version": "1.0.0-rc.4",
+  "version": "1.0.0-rc.7",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shuvijs/shuvi.git",

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;