@feng3d/task - npm Package Compare versions

Comparing version 0.0.5 to 0.0.6

out/index.d.ts

@@ -1,58 +0,62 @@
-/**
- * 任务，用于处理任务之间依赖
- */
-export declare var task: Task;
-/**
- * 任务函数
- */
-export interface TaskFunction {
-    /**
-     * 函数自身名称
-     */
-    readonly name?: string;
-    /**
-     * 函数自身
-     */
-    (callback: () => void): void;
+declare module 'task' {
+    export = feng3d;
 }
-/**
- * 任务
- *
- * 处理 异步任务(函数)串联并联执行功能
- */
-declare class Task {
+declare namespace feng3d {
     /**
-     * 并联多个异步函数为一个函数
-     *
-     * 这些异步函数同时执行
-     *
-     * @param fns 一组异步函数
-     */
-    parallel(fns: TaskFunction[]): TaskFunction;
+  * 任务，用于处理任务之间依赖
+  */
+    var task: Task;
     /**
-     * 串联多个异步函数为一个函数
-     *
-     * 这些异步函数按顺序依次执行，等待前一个异步函数执行完调用回调后才执行下一个异步函数。
-     *
-     * @param fns 一组异步函数
+     * 任务函数
      */
-    series(fns: TaskFunction[]): TaskFunction;
+    interface TaskFunction {
+        /**
+         * 函数自身名称
+         */
+        readonly name?: string;
+        /**
+         * 函数自身
+         */
+        (callback: () => void): void;
+    }
     /**
-     * 创建一组并行同类任务，例如同时加载一组资源，并在回调中返回结果数组
+     * 任务
      *
-     * @param ps 一组参数
-     * @param fn 单一任务函数
-     * @param done 完成回调
+     * 处理 异步任务(函数)串联并联执行功能
      */
-    parallelResults<P, R>(ps: P[], fn: (p: P, callback: (r: R) => void) => void, done: (rs: R[]) => void): void;
-    /**
-     * 创建一组串联同类任务，例如排序加载一组资源
-     *
-     * @param ps 一组参数
-     * @param fn 单一任务函数
-     * @param done 完成回调
-     */
-    seriesResults<P, R>(ps: P[], fn: (p: P, callback: (r: R) => void) => void, done: (rs: R[]) => void): void;
+    class Task {
+        /**
+         * 并联多个异步函数为一个函数
+         *
+         * 这些异步函数同时执行
+         *
+         * @param fns 一组异步函数
+         */
+        parallel(fns: TaskFunction[]): TaskFunction;
+        /**
+         * 串联多个异步函数为一个函数
+         *
+         * 这些异步函数按顺序依次执行，等待前一个异步函数执行完调用回调后才执行下一个异步函数。
+         *
+         * @param fns 一组异步函数
+         */
+        series(fns: TaskFunction[]): TaskFunction;
+        /**
+         * 创建一组并行同类任务，例如同时加载一组资源，并在回调中返回结果数组
+         *
+         * @param ps 一组参数
+         * @param fn 单一任务函数
+         * @param done 完成回调
+         */
+        parallelResults<P, R>(ps: P[], fn: (p: P, callback: (r: R) => void) => void, done: (rs: R[]) => void): void;
+        /**
+         * 创建一组串联同类任务，例如排序加载一组资源
+         *
+         * @param ps 一组参数
+         * @param fn 单一任务函数
+         * @param done 完成回调
+         */
+        seriesResults<P, R>(ps: P[], fn: (p: P, callback: (r: R) => void) => void, done: (rs: R[]) => void): void;
+    }
 }
-export {};
 //# sourceMappingURL=index.d.ts.map

out/index.js

@@ -1,136 +0,152 @@
-/**
- * 任务，用于处理任务之间依赖
- */
-export var task;
-/**
- * 用于临时存放函数执行结果，获取结果后会自动清除
- */
-var tempResutProperty = "__result__";
-/**
- * 任务
- *
- * 处理 异步任务(函数)串联并联执行功能
- */
-var Task = /** @class */ (function () {
-    function Task() {
-    }
+var feng3d;
+(function (feng3d) {
     /**
-     * 并联多个异步函数为一个函数
-     *
-     * 这些异步函数同时执行
-     *
-     * @param fns 一组异步函数
+     * 用于临时存放函数执行结果，获取结果后会自动清除
      */
-    Task.prototype.parallel = function (fns) {
-        var result = function (callback) {
-            if (fns.length == 0) {
-                callback();
-                return;
-            }
-            var index = 0;
-            fns.forEach(function (fn) {
-                var callbackNum = 0;
-                fn(function () {
-                    callbackNum++;
-                    if (callbackNum == 1) {
-                        index++;
-                        if (index == fns.length) {
-                            callback();
-                        }
-                    }
-                    else {
-                        console.warn((fn.name ? "函数" + fn.name : "匿名函数") + " \u591A\u6B21\u8C03\u7528\u56DE\u8C03\u51FD\u6570\uFF0C\u5F53\u524D\u6B21\u6570 " + callbackNum);
-                    }
-                });
-            });
-        };
-        return result;
-    };
+    var tempResutProperty = "__result__";
     /**
-     * 串联多个异步函数为一个函数
+     * 任务
      *
-     * 这些异步函数按顺序依次执行，等待前一个异步函数执行完调用回调后才执行下一个异步函数。
-     *
-     * @param fns 一组异步函数
+     * 处理 异步任务(函数)串联并联执行功能
      */
-    Task.prototype.series = function (fns) {
-        var result = function (callback) {
-            if (fns.length == 0) {
-                callback();
-                return;
-            }
-            var index = 0;
-            var next = function () {
-                var fn = fns[index];
-                var callbackNum = 0;
-                fn(function () {
-                    callbackNum++;
-                    if (callbackNum == 1) {
-                        index++;
-                        if (index < fns.length) {
-                            next();
+    var Task = /** @class */ (function () {
+        function Task() {
+        }
+        /**
+         * 并联多个异步函数为一个函数
+         *
+         * 这些异步函数同时执行
+         *
+         * @param fns 一组异步函数
+         */
+        Task.prototype.parallel = function (fns) {
+            var result = function (callback) {
+                if (fns.length == 0) {
+                    callback();
+                    return;
+                }
+                var index = 0;
+                fns.forEach(function (fn) {
+                    var callbackNum = 0;
+                    fn(function () {
+                        callbackNum++;
+                        if (callbackNum == 1) {
+                            index++;
+                            if (index == fns.length) {
+                                callback();
+                            }
                         }
                         else {
-                            callback && callback();
+                            console.warn((fn.name ? "函数" + fn.name : "匿名函数") + " \u591A\u6B21\u8C03\u7528\u56DE\u8C03\u51FD\u6570\uFF0C\u5F53\u524D\u6B21\u6570 " + callbackNum);
                         }
-                    }
-                    else {
-                        console.warn((fn.name ? "函数" + fn.name : "匿名函数") + " \u591A\u6B21\u8C03\u7528\u56DE\u8C03\u51FD\u6570\uFF0C\u5F53\u524D\u6B21\u6570 " + callbackNum);
-                    }
+                    });
                 });
             };
-            next();
+            return result;
         };
-        return result;
-    };
-    /**
-     * 创建一组并行同类任务，例如同时加载一组资源，并在回调中返回结果数组
-     *
-     * @param ps 一组参数
-     * @param fn 单一任务函数
-     * @param done 完成回调
-     */
-    Task.prototype.parallelResults = function (ps, fn, done) {
-        // 包装函数
-        var fns = ps.map(function (p) { return function (callback) {
-            fn(p, function (r) {
-                p[tempResutProperty] = r;
-                callback();
+        /**
+         * 串联多个异步函数为一个函数
+         *
+         * 这些异步函数按顺序依次执行，等待前一个异步函数执行完调用回调后才执行下一个异步函数。
+         *
+         * @param fns 一组异步函数
+         */
+        Task.prototype.series = function (fns) {
+            var result = function (callback) {
+                if (fns.length == 0) {
+                    callback();
+                    return;
+                }
+                var index = 0;
+                var next = function () {
+                    var fn = fns[index];
+                    var callbackNum = 0;
+                    fn(function () {
+                        callbackNum++;
+                        if (callbackNum == 1) {
+                            index++;
+                            if (index < fns.length) {
+                                next();
+                            }
+                            else {
+                                callback && callback();
+                            }
+                        }
+                        else {
+                            console.warn((fn.name ? "函数" + fn.name : "匿名函数") + " \u591A\u6B21\u8C03\u7528\u56DE\u8C03\u51FD\u6570\uFF0C\u5F53\u524D\u6B21\u6570 " + callbackNum);
+                        }
+                    });
+                };
+                next();
+            };
+            return result;
+        };
+        /**
+         * 创建一组并行同类任务，例如同时加载一组资源，并在回调中返回结果数组
+         *
+         * @param ps 一组参数
+         * @param fn 单一任务函数
+         * @param done 完成回调
+         */
+        Task.prototype.parallelResults = function (ps, fn, done) {
+            // 包装函数
+            var fns = ps.map(function (p) { return function (callback) {
+                fn(p, function (r) {
+                    p[tempResutProperty] = r;
+                    callback();
+                });
+            }; });
+            this.parallel(fns)(function () {
+                var results = ps.map(function (p) {
+                    var r = p[tempResutProperty];
+                    delete p[tempResutProperty];
+                    return r;
+                });
+                done(results);
             });
-        }; });
-        this.parallel(fns)(function () {
-            var results = ps.map(function (p) {
-                var r = p[tempResutProperty];
-                delete p[tempResutProperty];
-                return r;
+        };
+        /**
+         * 创建一组串联同类任务，例如排序加载一组资源
+         *
+         * @param ps 一组参数
+         * @param fn 单一任务函数
+         * @param done 完成回调
+         */
+        Task.prototype.seriesResults = function (ps, fn, done) {
+            // 包装函数
+            var fns = ps.map(function (p) { return function (callback) {
+                fn(p, function (r) {
+                    p[tempResutProperty] = r;
+                    callback();
+                });
+            }; });
+            this.series(fns)(function () {
+                var results = ps.map(function (p) {
+                    var r = p[tempResutProperty];
+                    delete p[tempResutProperty];
+                    return r;
+                });
+                done(results);
             });
-            done(results);
-        });
-    };
-    /**
-     * 创建一组串联同类任务，例如排序加载一组资源
-     *
-     * @param ps 一组参数
-     * @param fn 单一任务函数
-     * @param done 完成回调
-     */
-    Task.prototype.seriesResults = function (ps, fn, done) {
-        // 包装函数
-        var fns = ps.map(function (p) { return function (callback) {
-            fn(p, function (r) {
-                p[tempResutProperty] = r;
-                callback();
-            });
-        }; });
-        this.series(fns)(function () {
-            var results = ps.map(function (p) {
-                var r = p[tempResutProperty];
-                delete p[tempResutProperty];
-                return r;
-            });
-            done(results);
-        });
-    };
-    return Task;
-}());
-task = new Task();
+        };
+        return Task;
+    }());
+    feng3d.task = new Task();
+})(feng3d || (feng3d = {}));
+//# sourceMappingURL=index.js.map
+(function universalModuleDefinition(root, factory)
+{
+    if (typeof exports === 'object' && typeof module === 'object')
+        module.exports = factory();
+    else if (typeof define === 'function' && define.amd)
+        define([], factory);
+    else if (typeof exports === 'object')
+        exports["task"] = factory();
+    else
+        root["task"] = factory();
+    var globalObject = (typeof global !== 'undefined') ? global : ((typeof window !== 'undefined') ? window : this);
+    globalObject["task"] = factory();
+})(this, function ()
+{
+    return feng3d;
+});

package.json

 {
   "name": "@feng3d/task",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "串联或并联一组异步函数为一个异步函数",
@@ -5,0 +5,0 @@ "main": "out/index.js",

tsconfig.json

 {
   "compilerOptions": {
     "target": "es5",
-    "module": "es2015",
-    "moduleResolution": "node",
+    "noImplicitAny": false,
+    "sourceMap": true,
+    "declarationMap": true,
     "declaration": true,
-    "declarationMap": true,
-    "outDir": "./out",
+    "experimentalDecorators": true,
+    // "lib": ["es2015"],
+    "outFile": "out/index.js"
+    // "outDir": "debug"
   },
@@ -10,0 +13,0 @@ "include": [

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

18999

increased by5.84%

Worsened metrics

Number of package files

10

decreased by-23.08%

Lines of code

390

decreased by-20.73%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes