knight-web 2.0.2 → 2.0.4

package/frame/utility/ProfilerUtility.d.ts

@@ -1,37 +1,37 @@
-/** 分析器工具 */
-export declare class ProfilerUtility {
-    private _container;
-    private _fpsPanel;
-    get FPSCanvas(): HTMLCanvasElement;
-    private _msPanel;
-    get MSCanvas(): HTMLCanvasElement;
-    private _memoryPanel;
-    get MemoryCanvas(): HTMLCanvasElement;
-    /** 构造函数 */
-    constructor(_parent: HTMLElement);
-    OnSecondUpdate(_delta: number, _fps: number): void;
-}
-export declare class Panel {
-    private name;
-    private min;
-    private max;
-    private PR;
-    private WIDTH;
-    private HEIGHT;
-    private TEXT_X;
-    private TEXT_Y;
-    private GRAPH_X;
-    private GRAPH_Y;
-    private GRAPH_WIDTH;
-    private GRAPH_HEIGHT;
-    private fg;
-    private bg;
-    private canvas;
-    get Canvas(): HTMLCanvasElement;
-    private context;
-    private result;
-    get Result(): number;
-    constructor(name: string, fg: string, bg: string);
-    Enable(_enable: boolean): void;
-    update(value: number, maxValue: number): void;
-}
+/** 分析器工具 */
+export declare class ProfilerUtility {
+    private _container;
+    private _fpsPanel;
+    get FPSCanvas(): HTMLCanvasElement;
+    private _msPanel;
+    get MSCanvas(): HTMLCanvasElement;
+    private _memoryPanel;
+    get MemoryCanvas(): HTMLCanvasElement;
+    /** 构造函数 */
+    constructor(_parent: HTMLElement);
+    OnSecondUpdate(_delta: number, _fps: number): void;
+}
+export declare class Panel {
+    private name;
+    private min;
+    private max;
+    private PR;
+    private WIDTH;
+    private HEIGHT;
+    private TEXT_X;
+    private TEXT_Y;
+    private GRAPH_X;
+    private GRAPH_Y;
+    private GRAPH_WIDTH;
+    private GRAPH_HEIGHT;
+    private fg;
+    private bg;
+    private canvas;
+    get Canvas(): HTMLCanvasElement;
+    private context;
+    private result;
+    get Result(): number;
+    constructor(name: string, fg: string, bg: string);
+    Enable(_enable: boolean): void;
+    update(value: number, maxValue: number): void;
+}

package/frame/utility/PromiseUtility.d.ts

@@ -1,89 +1,89 @@
-/** 异步工具 */
-export declare namespace PromiseUtility {
-    /** 异步拓展类 */
-    class PromiseEx {
-        /** 自定义Promise带参异步函数 */
-        static Promise<T>(_executor: IExecutor<T>, ..._params: any[]): Promise<MyPromise<T>>;
-        /** 原生Promise带参异步函数 */
-        static OrigionPromise<T>(_executor: IExecutor<T>, ..._params: any[]): Promise<T>;
-        /** 等待时间 */
-        static WaitTime(_time: number): Promise<void>;
-    }
-    /** Primise异步工具
-     * 一、Pomise解决的问题:
-     * 1:解决回调地狱，可读性变好
-     * 2:promise可以支持多个并发的请求，获取并发请求中的数据
-     * 3:可以处理异常
-     * 4:使用发布/订阅模式处理异步问题，全局变量难以维护，变量名冲突的问题
-     * 二、Promise规范
-     * 1:promise是一个拥有then方法的对象或者函数
-     *   then方法相当于观察者模式中的订阅，所以这就是为什么then需要传入函数
-     * 2:promise有三种状态，只能从等待状态到成功或者失败()
-     *   为什么要有三种状态？防止多次调用，因为你如果调用两次resolve，那么只能以第一次的为准，第一次resolve后，状态直接就变为SUCCESS，那么也就不会在执行后面的reslove了
-     * 3:then方法返回一个新的promise对象
-     *   为什么要返回promise，为了支持链式调用
-     * 4:promise初始化传入一个函数，函数上有两个参数，resolve，reject，他们也都是函数
-     *   promise中的resolve，reject也就相当于观察者模式中的notify
-     */
-    class MyPromise<T> {
-        /** 状态 */
-        private _state;
-        /** 成功时的回调函数 */
-        private _onSuccessedCbs;
-        /** 失败时的回调函数 */
-        private _onFailedCbs;
-        /** Promise传递的值 */
-        private _value;
-        /** 表示Promise失败原因的值 */
-        private _reason;
-        /** 构造函数 */
-        constructor(_executor: IExecutor<T>, ..._params: any[]);
-        /** 解决 */
-        private resolve;
-        /** 拒绝 */
-        private reject;
-        /** 然后 */
-        then<TResult1 = T, TResult2 = never>(_onSuccessed?: ((_value: T | IPromiseLike<T>) => TResult1 | IPromiseLike<TResult1>) | undefined | null, _onFailed?: ((_reason: any) => TResult2 | IPromiseLike<TResult2>) | undefined | null): MyPromise<TResult1 | TResult2>;
-        private resolvePromise;
-    }
-    /** Promise状态枚举 */
-    enum E_PromiseState {
-        /** 等待状态
-         * 此时该 Promise 的结果是悬而未决的，不知道会被 resolve，或是被 reject。
-         * 只有当 Promise 的状态为 PENDING 时，resolve 和 reject 函数才可以执行一系列操作，否则只会抛出一个错误。
-         */
-        Pending = "pending",
-        /** 成功状态
-         * 说明此时 Promise 已经被 resolve，“承诺实现了”。
-         * 当 Promise 的状态为 FULFILLED 时，then 方法传入的 onFullfilled 函数才能直接加入微任务队列；
-         * 若当前 Promise 的状态为 PENDING，onFullfilled 函数只能加入成功时的回调函数队列。
-         */
-        Success = "success",
-        /** 失败状态
-         * 说明此时 Promise 已经被 reject，
-         * 当 Promise 的状态为 REJECTED 时，then 方法传入的 onRejected 函数才能直接加入微任务队列；
-         * 若当前 Promise 的状态为 PENDING，onRejected 函数只能加入失败时的回调函数队列。
-         */
-        Fail = "fail"
-    }
-    /**
-     * Promises/A+ 只是一份规范，任何能通过测试的 Promise 实现都会被这份规范认可，而一些库和框架会实现自己的 Promise，而不是使用原生 ES6 Promise，这就导致了无法直接使用 p instanceof Promise 来识别 Promise类型。
-     * 因此识别 Promise 是基于鸭子类型（duck typing）检测的，只要是一个 thenable 对象（即定义了 then 方法的对象），即会被识别为 Promise。
-     * 同理，下文中 resolvePromise 函数的参数 x 是 PromiseLike 类型而不是 Promise 类型。
-     */
-    interface IPromiseLike<T> {
-        then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T | PromiseLike<T>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
-    }
-    /** 同步执行的执行器回调函数接口(Promise异步相关) */
-    interface IExecutor<T> {
-        (_resolve: IResolve<T>, _reject: IReject, ..._params: any[]): void;
-    }
-    /** 同步执行的成功时回调函数接口(Promise异步相关) */
-    interface IResolve<T> {
-        (_value?: T | IPromiseLike<T>): void;
-    }
-    /** 同步执行的失败时回调函数接口(Promise异步相关) */
-    interface IReject {
-        (_reason?: any): void;
-    }
-}
+/** 异步工具 */
+export declare namespace PromiseUtility {
+    /** 异步拓展类 */
+    class PromiseEx {
+        /** 自定义Promise带参异步函数 */
+        static Promise<T>(_executor: IExecutor<T>, ..._params: any[]): Promise<MyPromise<T>>;
+        /** 原生Promise带参异步函数 */
+        static OrigionPromise<T>(_executor: IExecutor<T>, ..._params: any[]): Promise<T>;
+        /** 等待时间 */
+        static WaitTime(_time: number): Promise<void>;
+    }
+    /** Primise异步工具
+     * 一、Pomise解决的问题:
+     * 1:解决回调地狱，可读性变好
+     * 2:promise可以支持多个并发的请求，获取并发请求中的数据
+     * 3:可以处理异常
+     * 4:使用发布/订阅模式处理异步问题，全局变量难以维护，变量名冲突的问题
+     * 二、Promise规范
+     * 1:promise是一个拥有then方法的对象或者函数
+     *   then方法相当于观察者模式中的订阅，所以这就是为什么then需要传入函数
+     * 2:promise有三种状态，只能从等待状态到成功或者失败()
+     *   为什么要有三种状态？防止多次调用，因为你如果调用两次resolve，那么只能以第一次的为准，第一次resolve后，状态直接就变为SUCCESS，那么也就不会在执行后面的reslove了
+     * 3:then方法返回一个新的promise对象
+     *   为什么要返回promise，为了支持链式调用
+     * 4:promise初始化传入一个函数，函数上有两个参数，resolve，reject，他们也都是函数
+     *   promise中的resolve，reject也就相当于观察者模式中的notify
+     */
+    class MyPromise<T> {
+        /** 状态 */
+        private _state;
+        /** 成功时的回调函数 */
+        private _onSuccessedCbs;
+        /** 失败时的回调函数 */
+        private _onFailedCbs;
+        /** Promise传递的值 */
+        private _value;
+        /** 表示Promise失败原因的值 */
+        private _reason;
+        /** 构造函数 */
+        constructor(_executor: IExecutor<T>, ..._params: any[]);
+        /** 解决 */
+        private resolve;
+        /** 拒绝 */
+        private reject;
+        /** 然后 */
+        then<TResult1 = T, TResult2 = never>(_onSuccessed?: ((_value: T | IPromiseLike<T>) => TResult1 | IPromiseLike<TResult1>) | undefined | null, _onFailed?: ((_reason: any) => TResult2 | IPromiseLike<TResult2>) | undefined | null): MyPromise<TResult1 | TResult2>;
+        private resolvePromise;
+    }
+    /** Promise状态枚举 */
+    enum E_PromiseState {
+        /** 等待状态
+         * 此时该 Promise 的结果是悬而未决的，不知道会被 resolve，或是被 reject。
+         * 只有当 Promise 的状态为 PENDING 时，resolve 和 reject 函数才可以执行一系列操作，否则只会抛出一个错误。
+         */
+        Pending = "pending",
+        /** 成功状态
+         * 说明此时 Promise 已经被 resolve，“承诺实现了”。
+         * 当 Promise 的状态为 FULFILLED 时，then 方法传入的 onFullfilled 函数才能直接加入微任务队列；
+         * 若当前 Promise 的状态为 PENDING，onFullfilled 函数只能加入成功时的回调函数队列。
+         */
+        Success = "success",
+        /** 失败状态
+         * 说明此时 Promise 已经被 reject，
+         * 当 Promise 的状态为 REJECTED 时，then 方法传入的 onRejected 函数才能直接加入微任务队列；
+         * 若当前 Promise 的状态为 PENDING，onRejected 函数只能加入失败时的回调函数队列。
+         */
+        Fail = "fail"
+    }
+    /**
+     * Promises/A+ 只是一份规范，任何能通过测试的 Promise 实现都会被这份规范认可，而一些库和框架会实现自己的 Promise，而不是使用原生 ES6 Promise，这就导致了无法直接使用 p instanceof Promise 来识别 Promise类型。
+     * 因此识别 Promise 是基于鸭子类型（duck typing）检测的，只要是一个 thenable 对象（即定义了 then 方法的对象），即会被识别为 Promise。
+     * 同理，下文中 resolvePromise 函数的参数 x 是 PromiseLike 类型而不是 Promise 类型。
+     */
+    interface IPromiseLike<T> {
+        then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T | PromiseLike<T>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
+    }
+    /** 同步执行的执行器回调函数接口(Promise异步相关) */
+    interface IExecutor<T> {
+        (_resolve: IResolve<T>, _reject: IReject, ..._params: any[]): void;
+    }
+    /** 同步执行的成功时回调函数接口(Promise异步相关) */
+    interface IResolve<T> {
+        (_value?: T | IPromiseLike<T>): void;
+    }
+    /** 同步执行的失败时回调函数接口(Promise异步相关) */
+    interface IReject {
+        (_reason?: any): void;
+    }
+}