knight-web 2.0.0

package/frame/utility/NetworkUtility.d.ts

@@ -0,0 +1,155 @@
+/** 网络工具 */
+export declare namespace NetworkUtility {
+    /** 网络类 */
+    class NetWork {
+        /** HTTP网络协议 */
+        private _http;
+        /** HTTP网络协议 */
+        get HTTP(): HttpNetwork;
+        /** WebSocket网络协议 */
+        private _webSokcet;
+        /** WebSocket网络协议 */
+        get WebSokcet(): WebSocketNetWork;
+        /** 构造函数 */
+        constructor();
+    }
+    /** HTTP网络协议 */
+    class HttpNetwork {
+        /** 构造函数 */
+        constructor();
+        /**
+         * 网络请求
+         * @param _type 请求类型
+         * @param _url 格式: "http://192.168.1.1/aaa/bbb"或"https://192.168.1.1/aaa/bbb"
+         * @param _data 传递的数据
+         * @param _header 请求头
+         * @returns 返回请求的数据
+         */
+        Request(_url: string, _option?: IRequest): Promise<IResponse>;
+        /** 网络请求执行器 */
+        private OnRequestExecutor;
+        /** 尝试解析响应数据 */
+        private OnTryParseResponse;
+    }
+    /** WebSocket网络协议 */
+    class WebSocketNetWork {
+        /** WebSocket套接字 */
+        private _websocket;
+        /** 心跳计数器 */
+        private _heartbeatCounter;
+        /** 心跳间隔 */
+        private _heartbeatInterval;
+        /** 心跳响应计数器 */
+        private _heartbeatResponseCounter;
+        /** 心跳超时次数 */
+        private _heartbeatTimeoutCount;
+        /** 心跳开关 */
+        private _heartbeatSwitch;
+        /** 打开回调事件 */
+        Evt_OnOpen: (_ws: WebSocketNetWork, _event?: Event) => void;
+        /** 关闭回调事件 */
+        Evt_OnClosed: (_ws: WebSocketNetWork, _event?: CloseEvent) => void;
+        /** 报错回调事件 */
+        Evt_OnError: (_ws: WebSocketNetWork, _event?: Event) => void;
+        /** 接收回调事件 */
+        Evt_OnReceive: (_ws: WebSocketNetWork, _event?: MessageEvent<any>) => void;
+        /** 心跳超时回调事件 */
+        Evt_OnHeartbeatTimeout: () => void;
+        /** 构造函数 */
+        constructor();
+        /** 开启连接 */
+        OnConnect(_url: string): void;
+        /** 客户端断开连接 */
+        OnDisConnect(): void;
+        /** 启动心跳 */
+        private OnStartHeartbeat;
+        /** 心跳逻辑 */
+        private OnHeartbeat;
+        /** 客户端打开连接 */
+        private OnOpen;
+        /** 客户端断开连接 */
+        OnClose(_event?: CloseEvent): void;
+        /** 客户端报错 */
+        private OnError;
+        /** 发送消息 */
+        OnSend(_data: string | Blob | ArrayBufferView | ArrayBufferLike): void;
+        /** 接收消息 */
+        private OnReceive;
+    }
+    /** 请求参数接口 */
+    interface IRequest {
+        /** 请求协议类型 */
+        method?: string | E_RequestType;
+        /** URL链接中的参数 */
+        params?: {
+            [key: string]: string;
+        };
+        /** 请求头 */
+        headers?: HeadersInit;
+        /** 请求体 */
+        body?: XMLHttpRequestBodyInit;
+        /** 设置请求的凭证 */
+        credentials?: RequestCredentials;
+        /** 设置请求的keepalive */
+        keepalive?: boolean;
+        /** 请求模式 */
+        mode?: RequestMode;
+        /** A string indicating how the request will interact with the browser's cache to set request's cache. */
+        cache?: RequestCache;
+        /** A cryptographic hash of the resource to be fetched by request. Sets request's integrity. */
+        integrity?: string;
+        priority?: "auto" | "high" | "low";
+        /** A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect. */
+        redirect?: RequestRedirect;
+        /** A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer. */
+        referrer?: string;
+        /** A referrer policy to set request's referrerPolicy. */
+        referrerPolicy?: ReferrerPolicy;
+        /** An AbortSignal to set request's signal. */
+        signal?: AbortSignal | null;
+        /** Can only be null. Used to disassociate request from any Window. */
+        window?: null;
+    }
+    /** 响应参数接口 */
+    interface IResponse {
+        /** 响应地址 */
+        responseURL?: string;
+        /** 相应数据类型(数据格式) */
+        responseType?: XMLHttpRequestResponseType;
+        /** 准备状态 */
+        readyState?: number;
+        /** 响应码 */
+        status?: number;
+        /** 响应码(字符串格式) */
+        statusText?: string;
+        /** 响应信息 */
+        /** 是否携带Cookie */
+        withCredentials?: boolean;
+        /** 超时时间(ms) */
+        timeout?: number;
+        /** 响应数据 */
+        response?: any;
+        /** 响应数据(字符串格式) */
+        responseText?: string;
+        /** 响应数据(文档格式) */
+        responseXML?: Document | null;
+        /** 准备状态变更事件 */
+        onreadystatechange?: ((this: XMLHttpRequest, ev: Event) => any) | null;
+        /** 获取所有响应请求头 */
+        getAllResponseHeaders?(): string;
+        /** 响应数据转换 */
+        ParseResponse?<T>(): T;
+    }
+    /** 请求类型 */
+    enum E_RequestType {
+        All = "all",
+        Get = "get",
+        Post = "post",
+        Put = "put",
+        Delete = "delete",
+        Patch = "patch",
+        Options = "options",
+        Head = "head",
+        Search = "search"
+    }
+}

package/frame/utility/ObjectUtility.d.ts

@@ -0,0 +1,308 @@
+/*********************************************************************************
+  * FileName     : ObjectPool
+  * FileBasename : ObjectPool.ts
+  * Author       : Seven_9t
+  * Date         : Sat Mar 25 2023 15:05:05 GMT+0800 (中国标准时间)
+  * Description  : db://assets/frame/script/base/ObjectPool.ts
+  * Version      : v3.6
+  * Others       : 修改默认TS脚本模板路径 D:\Cocos\CocosDashboard\resources\.editors\Creator\<Version>\resources\resources\3d\engine\editor\assets\default_file_content\ts
+  * ManualUrl    : <指南手册>    https://docs.cocos.com/creator/3.6/manual/zh/
+  *              : <脚本手册>    https://docs.cocos.com/creator/3.6/manual/zh/scripting/
+  *              : <接口手册>    https://docs.cocos.com/creator/api/zh/#/docs/3.6/zh/README
+  *              : <生命周期手册>https://docs.cocos.com/creator/3.6/manual/zh/scripting/life-cycle-callbacks.html
+
+**********************************************************************************/
+import { InterfaceUtility } from "./InterfaceUtility";
+/** 对象工具 */
+export declare namespace ObjectUtility {
+    /** 空对象类 */
+    export class EmptyObject {
+    }
+    /** 获取对象所有属性 */
+    export function GetPropertys<T>(_object: T): Array<string>;
+    /** 检测对象属性是否存在 */
+    export function HasProperty(_object: object, _propertyKey: string): boolean;
+    /** 是否是对象 */
+    export function IsObject(_target: any): boolean;
+    /** 是否是数组 */
+    export function IsArray(_target: any): boolean;
+    /** 是否是函数 */
+    export function IsFunction(_target: any): boolean;
+    /**
+     * 判断是否继承自基类
+     * @param _target 目标对象实例
+     * @param _className 基类类名
+     * @returns 匹配结果
+     */
+    export function InstanceOf(_target: object, _className: string): boolean;
+    /** 克隆对象 */
+    export function Clone<T>(_target: T, ...params: any[]): T;
+    /** 克隆并赋值 */
+    export function CloneAssign<T>(_target: T, ...params: any[]): T;
+    /** 数据赋值 */
+    export function Assign<T extends object>(_target: T, _source: Partial<object>): T;
+    /**
+     * 将对象序列化为Json字符串
+     * @param _object 一个JavaScript值，通常是要转换的对象或数组。
+     * @param _replacer 转换结果的函数。
+     * @param _space 在返回值JSON文本中添加缩进、空白和换行字符，使其更易于阅读。
+     * @returns 序列化后对象(需要自行转JSON.stringify)
+     */
+    export function Encode(_object: object, _replacer?: (this: any, key: string, value: any) => any, _space?: string | number): Record<string, any>;
+    /** 将Json字符串反序列化为对象(对象带有函数则无效,需要执行浅拷贝或深拷贝) */
+    export function Decode<T extends object>(_target: InterfaceUtility.IType<T>, _source: T, ...params: any[]): T;
+    /** 浅拷贝 */
+    export function ShallowCopy<T extends object>(_target: InterfaceUtility.IType<T>, _source: T, ...params: any[]): T;
+    /** 深拷贝 */
+    export function DeepCopy<T extends object>(_target: InterfaceUtility.IType<T>, _source: T, ...params: any[]): T;
+    /** 深拷贝 TODO */
+    export function Deep(_target: any, _bitmask: boolean): any;
+    /** 深拷贝数组 */
+    export function DeepCopyArray(_target: any): any;
+    /** 对象操作泛型接口 */
+    interface IObjectOperation<T> {
+        /** 获取数量 */
+        get Count(): number;
+        /** 获取对象 */
+        Get(_key: number | string): T;
+        /** 获取对象组 */
+        Gets(_keys: Array<number | string>): Array<T>;
+        /** 获取所有对象 */
+        GetAll(): Array<T> | Map<string, T>;
+        /** 添加对象实例 */
+        Add(..._param: any[]): boolean;
+        /** 移除对象实例 */
+        Remove(_t: number | string | T): boolean;
+        /** 移除所有对象实例 */
+        RemoveAll(): void;
+        /** 对象实例是否存在 */
+        Exist(_t: number | string | T): boolean;
+    }
+    /** 对象池<数组> */
+    export class ArrayPool<T extends object | any> implements IObjectOperation<T> {
+        /** 对象池 */
+        private _tPools;
+        /** 构造函数 */
+        constructor();
+        /** 获取数量 */
+        get Count(): number;
+        /** 获取对象 */
+        Get<K extends T>(_index: number): K;
+        /** 获取对象组 */
+        Gets<K extends T>(_indexs: Array<number>): Array<K>;
+        /** 获取所有对象 */
+        GetAll(): Array<T>;
+        /** 添加对象实例 */
+        Add(_t: T): boolean;
+        /** 移除对象实例 */
+        Remove(_t: T | number): boolean;
+        /** 移除所有对象实例 */
+        RemoveAll(): void;
+        /** 对象实例是否存在 */
+        Exist(_t: T | number): boolean;
+    }
+    /** 对象池<字典> */
+    export class MapPool<T extends object> implements IObjectOperation<T> {
+        /** 对象池 */
+        private _tPools;
+        /** 构造函数 */
+        constructor(_map?: Map<string, T>);
+        /** 获取数量 */
+        get Count(): number;
+        /** 获取对象 */
+        Get<K extends T>(_key: string): K;
+        /** 获取对象组 */
+        Gets<K extends T>(_keys: Array<string>): Array<K>;
+        /** 获取所有对象 */
+        GetAll(): Map<string, T>;
+        /** 添加对象实例 */
+        Add(_key: string, _t: T): boolean;
+        /** 设置对象 */
+        Set<K extends T>(_key: string, _t: T): K;
+        /** 移除对象实例 */
+        Remove(_key: string): boolean;
+        /** 移除所有对象实例 */
+        RemoveAll(): void;
+        /** 对象实例是否存在 */
+        Exist(_t: string): boolean;
+        /** 所有键转数组 */
+        KeysToArray(): Array<string>;
+        /** 所有值转数组 */
+        ValuesToArray(): Array<T>;
+    }
+    /** 队列池<队列> */
+    export class QueuePool<T extends object> {
+        /** 队列数组 */
+        private _tPools;
+        constructor();
+        /** 入队 */
+        Enqueue(_t: T): void;
+        /** 出队 */
+        Dequeue(): T | undefined;
+        /** 查看队首元素 */
+        Peek(): T | undefined;
+        /** 判断队列是否为空 */
+        IsEmpty(): boolean;
+        /** 获取队列大小 */
+        Size(): number;
+        /** 清空队列 */
+        Clear(): void;
+        /** 克隆 */
+        Clone(): Array<T>;
+    }
+    /** 管线 */
+    export class PipeLine<T extends object> {
+        /** 事件管线 */
+        private _tPools;
+        /** 管线是否已启动 */
+        private _isStarted;
+        /** 管线是否已启动 */
+        private _isEnded;
+        /** 开关 */
+        private _switch;
+        constructor();
+        /** 获取数量 */
+        get Count(): number;
+        /** 注册事件 */
+        Register(_pipeline: ((_params: T) => Promise<T>) | PipeLine<T>): boolean;
+        /** 注销事件 */
+        Degister(_pipeline: ((_params: T) => Promise<T>) | PipeLine<T>): boolean;
+        /** 启动事件 */
+        Start(_params: T): Promise<T>;
+        /** 停止事件 */
+        Stop(): void;
+    }
+    /** 委托接口 */
+    export interface IDelegate {
+        /** 注册 */
+        Register(_key: string, _callback: InterfaceUtility.IEvent, _target: any, _times: number): boolean;
+        /** 注销 */
+        Degister(_key: string, _callback: InterfaceUtility.IEvent, _target: any): boolean;
+        /** 通知 */
+        Invoke(_key: string, ...params: Array<any>): Promise<void>;
+        /** 清除 */
+        Clear(): void;
+    }
+    /** 委托池(多绑定) */
+    export class DelegateMultiplePool implements IDelegate {
+        /** 对象池 */
+        private _tPools;
+        /** 构造函数 */
+        constructor();
+        /**
+         * 注册监听事件
+         * @param _key 事件名称
+         * @param _event 回调函数
+         * @param _target 绑定对象
+         * @param _times 执行次数
+         */
+        Register(_key: string, _event: InterfaceUtility.IEvent, _times?: number): boolean;
+        /**
+        * 移除监听事件
+        * @param _key 事件名称
+        * @param _event 回调函数
+        * @param _target 绑定对象
+        */
+        Degister(_key: string, _event: InterfaceUtility.IEvent): boolean;
+        /**
+        * 派发监听事件
+        * @param _key 事件名称
+        * @param _params 回调参数
+        */
+        Invoke<T>(_key: string, ..._params: Array<any>): Promise<void>;
+        /** 清空所有事件 */
+        Clear(): void;
+    }
+    /** 委托池(单绑定) */
+    export class DelegateSinglePool implements IDelegate {
+        /** 对象池 */
+        private _tPools;
+        /** 构造函数 */
+        constructor();
+        /**
+        * 注册监听事件
+        * @param _key 事件名称
+        * @param _event 回调函数
+        * @param _target 绑定对象
+        * @param _times 执行次数
+        */
+        Register(_key: string, _event: InterfaceUtility.IEvent, _target: any, _times?: number): boolean;
+        /**
+        * 移除监听事件
+        * @param _key 事件名称
+        * @param _target 绑定对象
+        * @param _event 回调函数
+        */
+        Degister(_key: string, _event: InterfaceUtility.IEvent, _target: any): boolean;
+        /**
+        * 派发监听事件
+        * @param _key 事件名称
+        * @param _params 回调函数参数
+        */
+        Invoke<T>(_key: string, ..._params: Array<any>): Promise<void>;
+        /** 清空所有事件 */
+        Clear(): void;
+    }
+    /** 反射池<字典> */
+    export class ReflectionPool<T> {
+        /** 反射池 */
+        private _reflectionPool;
+        /** 构造函数 */
+        constructor();
+        /** 获取数量 */
+        get Count(): number;
+        /** 获取反射类型 */
+        GetObject(_key: string): InterfaceUtility.IType<T>;
+        /** 获取类型 */
+        GetType(_key: string): InterfaceUtility.IType<T>;
+        /** 获取所有反射类型 */
+        GetObjects(): Map<string, InterfaceUtility.IType<T>>;
+        /** 创建反射实例 */
+        CreatInstance<K extends T>(_key: string, ...params: any[]): K;
+        /** 添加反射类型 */
+        Add(_key: string, _t: InterfaceUtility.IType<T>): boolean;
+        /** 移除反射类型 */
+        Remove(_key: string): boolean;
+        /** 移除所有反射类型 */
+        RemoveAll(): void;
+        /** 反射类型是否存在 */
+        Exist(_key: string): boolean;
+    }
+    /** 事件系统 */
+    export class EventSystem {
+        /** 目标对象管理池 */
+        private _objects;
+        constructor(_objects: ObjectUtility.MapPool<object>);
+        /** 事务映射池 */
+        private static _delegateMappingPool;
+        /**
+         * 添加事件装饰器
+         * @param _key 触发主键
+         * @param _times 触发次数
+         * @params 提示：绑定的函数回参:OnName(sender:object,...params[])
+         */
+        static Decorator(_key: string, _times?: number): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+        /**
+         * 派发(广播)事件
+         * @param _sender 派发者
+         * @param _key 事件Key
+         * @param params 透传参数
+         * @returns 触发结果
+         */
+        Invoke(_sender: object, _key: string, ...params: Array<any>): void;
+        /** 获取所有事件 */
+        GetAll(): ObjectUtility.ArrayPool<IDelegateEvent>;
+    }
+    /** 委托事件接口 */
+    export interface IDelegateEvent {
+        /** 派发键 */
+        key: string;
+        /** 派发类名 */
+        className: string;
+        /** 派发事件名 */
+        eventName: string;
+        /** 派发次数 */
+        times: number;
+    }
+    export {};
+}

package/frame/utility/ProfilerUtility.d.ts

@@ -0,0 +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;
+}

package/frame/utility/PromiseUtility.d.ts

@@ -0,0 +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;
+    }
+}