knight-web 2.0.0

package/frame/utility/ReflectionUtility.d.ts

@@ -0,0 +1,316 @@
+import { InterfaceUtility } from './InterfaceUtility';
+/** 反射工具 */
+export declare namespace ReflectionUtility {
+    /** 反射类 */
+    class Reflection {
+        /** 路由组件类型池 */
+        private static _typePool;
+        /** 组件装饰器(用于存储组件类型)
+         * @param _name 组件路径/路由节点
+         */
+        static Decorator<T extends object>(_name: string): Function;
+        /**
+         * 获取类型
+         * @param _name 类型名称
+         * @returns 对象类型
+         */
+        static Get<T extends object>(_name: string): InterfaceUtility.IType<T>;
+        /**
+         * 创建实例
+         * @param _name 类型名称
+         * @returns 对象实例
+         */
+        static Creat<T extends object>(_name: string, ...params: any[]): T;
+        /** 属性装饰器 */
+        static Property(_target: any, _key: string): void;
+        /**
+         * 获取对象的所有属性名称
+         * @param _target 对象实例
+         * @returns 属性名称列表
+         */
+        static GetPropertys(_target: any): Array<string>;
+    }
+    /**
+     * 以指定的对象作为this值，并以指定数组的元素作为参数调用函数
+     * @param target 要调用的函数
+     * @param thisArgument 要用作this对象的对象
+     * @param argumentsList 传递给函数的参数值数组
+     * @example
+       function sum(a, b) { return a + b }
+       const result = Reflect.apply(sum, null, [2, 3]); // result = 5
+     *
+     */
+    function Apply(target: Function, thisArgument: any, argumentsList: ArrayLike<any>): any;
+    /**
+     * 使用指定数组的元素作为参数构造目标和指定的构造函数作为new.target的值
+     * @param target 要调用的构造函数
+     * @param argumentsList 传递给构造函数的参数值数组
+     * @param newTarget 构造函数要用作new.target的对象
+     * @example
+       function Person(name) {this.name = name;}
+       const person = Reflect.construct(Person, ['Alice']); // person = { name: 'Alice' }
+     */
+    function Construct(target: Function, argumentsList: ArrayLike<any>, newTarget?: Function): any;
+    /**
+     * 获取目标的属性，当' receiver === target '时相当于' target[propertyKey] '
+     * @param target 目标对象,该对象在其自身或其原型链中包含该属性
+     * @param propertyKey 属性名
+     * @param receiver 如果' target[propertyKey] '是一个访问器属性，则在getter函数中用作' this '值的引用
+     * @example
+       const obj = { a: 1, b: 2 };
+       const value = Reflect.get(obj, 'a'); // value = 1
+     */
+    function Get<T extends object, P extends PropertyKey>(target: T, propertyKey: P, receiver?: unknown): P extends keyof T ? T[P] : any;
+    /**
+     * 设置目标的属性，当' receiver === target '时相当于' target[propertyKey] = value '
+     * @param target 目标对象，该对象在其自身或其原型链中包含该属性
+     * @param propertyKey 属性名称
+     * @param receiver 如果' target[propertyKey] '是一个访问器属性，则在setter函数中用作' this '值的引用
+     * @example
+       const obj = { a: 1 };
+       Reflect.set(obj, 'a', 2); // obj.a = 2
+     */
+    function Set(target: object, propertyKey: PropertyKey, value: any, receiver?: any): boolean;
+    /**
+     * 属性是否存在，相当于' propertyKey in target '
+     * @param target 目标对象，该对象在其自身或其原型链中包含该属性
+     * @param propertyKey 属性名称
+     * @example
+       const obj = { a: 1 };
+       const hasA = Reflect.has(obj, 'a'); // hasA = true
+     */
+    function Has(target: object, propertyKey: PropertyKey): boolean;
+    /**
+     * 向对象添加属性，或修改现有属性的属性
+     * @param target 目标对象，要在其上添加或修改属性。它可以是一个原生JavaScript对象*(即用户定义对象或内置对象)或DOM对象。
+     * @param propertyKey 属性名称
+     * @param attributes 属性的描述符。它可以用于数据属性或访问器属性
+     * @example
+       const obj = {};
+       Reflect.defineProperty(obj, 'a', { value: 1, writable: true });
+     */
+    function DefineProperty(target: object, propertyKey: PropertyKey, attributes: PropertyDescriptor & ThisType<any>): boolean;
+    /**
+     * 从对象中删除属性，相当于' delete target[propertyKey] '，除非' target[propertyKey] '不可配置，否则它不会抛出
+     * @param target 目标对象，从中删除自身属性
+     * @param propertyKey 属性名称
+     * @example
+       const obj = { a: 1 };
+       Reflect.deleteProperty(obj, 'a'); // obj = {}
+     */
+    function DeleteProperty(target: object, propertyKey: PropertyKey): boolean;
+    /**
+     * 获取指定对象的自己的属性描述符。自己的属性描述符是直接在对象上定义的，而不是从对象的原型继承的
+     * @param target 包含该属性的目标
+     * @param propertyKey 属性名称
+     * @example
+       const obj = { a: 1 };
+       const descriptor = Reflect.getOwnPropertyDescriptor(obj, 'a');
+       // descriptor = { value: 1, writable: true, enumerable: true, configurable: true }
+     */
+    function GetOwnPropertyDescriptor<T extends object, P extends PropertyKey>(target: T, propertyKey: P): TypedPropertyDescriptor<P extends keyof T ? T[P] : any> | undefined;
+    /**
+     * 返回对象的原型
+     * @param target 引用原型的对象
+     */
+    function GetPrototypeOf(target: object): object | null;
+    /**
+     * 返回对象自身属性的字符串键和符号键。对象自己的属性是那些直接在该对象上定义的属性，而不是从对象的原型继承的属性
+     * @param target 目标对象，该对象包含自己的属性
+     * @example
+       const obj = { a: 1, [Symbol('b')]: 2 };
+       const keys = Reflect.ownKeys(obj); // keys = ['a', Symbol(b)]
+     */
+    function OwnKeys(target: object): (string | symbol)[];
+    /**
+     * 返回一个值，该值指示是否可以向对象添加新属性
+     * @param target 要检测的对象
+     * @example
+       const obj = {};
+       const isExtensible = Reflect.isExtensible(obj); // isExtensible = true
+     */
+    function IsExtensible(target: object): boolean;
+    /**
+     * 防止向对象添加新属性
+     * @param target 对象使其不可扩展
+     * @return 对象是否被设置为不可扩展的
+     * @example
+       const obj = {};
+       Reflect.preventExtensions(obj);
+     */
+    function PreventExtensions(target: object): boolean;
+    /**
+     * 将指定对象的原型设置为object proto或null
+     * @param target 对象改变它的原型
+     * @param proto 新原型的值或null
+     * @return 原型设置是否成功
+     */
+    function SetPrototypeOf(target: object, proto: object | null): boolean;
+    /**
+     * 将一组装饰器应用于目标对象的属性
+     * @param decorators 一个装饰器数组
+     * @param target 目标对象
+     * @param propertyKey 属性键来装饰
+     * @param attributes 属性描述符
+     * @remarks 装饰器以相反的顺序应用
+     * @example
+     * class Example
+     * {
+     * // property declarations are not part of ES6, though they arevalid in TypeScript:
+     * // static staticProperty;
+     * // property;
+     *    static staticMethod() { }
+     *    method() { }
+     * }
+     *
+     * // property (on constructor)
+     *    Reflect.decorate(decoratorsArray, Example, "staticProperty");
+     *
+     * // property (on prototype)
+     *    Reflect.decorate(decoratorsArray, Example.prototype, "property");
+     *
+     * // method (on constructor)
+     *    Object.defineProperty(Example, "staticMethod",
+     *    Reflect.decorate(decoratorsArray, Example, "staticMethod",
+     *    Object.getOwnPropertyDescriptor(Example, "staticMethod")));
+     *
+     * // method (on prototype)
+     *    Object.defineProperty(Example.prototype, "method",
+     *    Reflect.decorate(decoratorsArray, Example.prototype, "method",
+     *    Object.getOwnPropertyDescriptor(Example.prototype,"method")));
+     */
+    function Decorate(decorators: (PropertyDecorator | MethodDecorator)[], target: Object, propertyKey: string | symbol, attributes?: PropertyDescriptor): PropertyDescriptor;
+    /**
+     * 可以在类、类成员或参数上使用的默认元数据装饰器工厂
+     * @param metadataKey 元数据条目的键
+     * @param metadataValue 元数据条目的值
+     * @returns 装饰器函数
+     * @remarks 如果' metadataKey '已经为目标和目标键定义，则该键的metadataValue将被覆盖。
+     * @example
+     * // constructor
+     *    Reflect.metadata(key, value)
+     *    class Example { }
+     * // property (on constructor, TypeScript only)
+     *    class Example
+     *    {
+     *       Reflect.metadata(key, value)
+     *       static staticProperty;
+     *    }
+     *
+     * // property (on prototype, TypeScript only)
+     *    class Example
+     *    {
+     *       Reflect.metadata(key, value)
+     *       property;
+     *    }
+     *
+     * // method (on constructor)
+     *    class Example
+     *    {
+     *       Reflect.metadata(key, value)
+     *       static staticMethod() { }
+     *    }
+     *
+     * // method (on prototype)
+     *    class Example
+     *    {
+     *       Reflect.metadata(key, value)
+     *       method() { }
+     *    }
+     */
+    function Metadata(metadataKey: any, metadataValue: any): {
+        (target: Function): void;
+        (target: Object, propertyKey: string | symbol): void;
+    };
+    /**
+     * 在目标上定义唯一的元数据项
+     * @param metadataKey 用于存储和检索元数据的键
+     * @param metadataValue 包含附加元数据的值
+     * @param target 在其上定义元数据的目标对象
+     * @example
+     *  class Example { }
+     *  // constructor
+     *     Reflect.defineMetadata("custom:annotation", options, Example);
+     *  // decorator factory as metadata-producing annotation.
+     *     function MyAnnotation(options): ClassDecorator
+     *     {
+     *         return target => Reflect.defineMetadata("custom:annotation", options, target);
+     *     }
+     */
+    function DefineMetadata(metadataKey: any, metadataValue: any, target: Object): void;
+    /**
+     * 获取一个值，该值指示目标对象或其原型链是否定义了提供的元数据键
+     * @param metadataKey 用于存储和检索元数据的键
+     * @param target 定义元数据的目标对象
+     * @returns 如果元数据键是在目标对象或其原型链上定义的，则为true;否则false
+     * @example
+     *  class Example { }
+     *  // constructor
+     *  result = Reflect.hasMetadata("custom:annotation", Example);
+     */
+    function HasMetadata(metadataKey: any, target: Object): boolean;
+    /**
+     * 获取一个值，该值指示目标对象是否定义了提供的元数据键
+     * @param metadataKey 用于存储和检索元数据的键
+     * @param target 定义元数据的目标对象
+     * @returns 如果元数据键在目标对象上定义，则为true否则false
+     * @example
+     *  class Example { }
+     *  // constructor
+     *  result = Reflect.hasOwnMetadata("custom:annotation", Example);
+     */
+    function HasOwnMetadata(metadataKey: any, target: Object): boolean;
+    /**
+     * 获取目标对象或其原型链上提供的元数据键的元数据值
+     * @param metadataKey 用于存储和检索元数据的键
+     * @param target 定义元数据的目标对象
+     * @returns 如果找到元数据键的元数据值;否则,'undefined'
+     * @example
+     *  class Example { }
+     *  // constructor
+     *  result = Reflect.getMetadata("custom:annotation", Example);
+     */
+    function GetMetadata(metadataKey: any, target: Object): any;
+    /**
+     * 获取目标对象上提供的元数据键的元数据值
+     * @param metadataKey 用于存储和检索元数据的键
+     * @param target 定义元数据的目标对象
+     * @returns 如果找到元数据键的元数据值;否则`undefined`
+     * @example
+     *  class Example { }
+     *  // constructor
+     *  result = Reflect.getOwnMetadata("custom:annotation", Example);
+     */
+    function GetOwnMetadata(metadataKey: any, target: Object): any;
+    /**
+     * 获取在目标对象或其原型链上定义的元数据键
+     * @param target 定义元数据的目标对象
+     * @returns 唯一元数据键的数组
+     * @example
+     *  class Example { }
+     *  // constructor
+     *  result = Reflect.getMetadataKeys(Example);
+     */
+    function GetMetadataKeys(target: Object): any[];
+    /**
+     * 获取在目标对象上定义的唯一元数据键
+     * @param target 定义元数据的目标对象
+     * @returns 唯一元数据键的数组
+     * @example
+     *  class Example { }
+     *  // constructor
+     *  result = Reflect.getOwnMetadataKeys(Example);
+     */
+    function GetOwnMetadataKeys(target: Object): any[];
+    /**
+     * 使用提供的键从目标对象中删除元数据项
+     * @param metadataKey 用于存储和检索元数据的键
+     * @param target 定义元数据的目标对象
+     * @returns 如果元数据条目被找到并删除，则为true否则false
+     * @example
+     *  class Example { }
+     *  // constructor
+     *  result = Reflect.deleteMetadata("custom:annotation", Example);
+     */
+    function DeleteMetadata(metadataKey: any, target: Object): boolean;
+}

package/frame/utility/StringUtility.d.ts

@@ -0,0 +1,55 @@
+/** 字符串工具 */
+export declare namespace StringUtility {
+    /** 默认空字符串 */
+    const Empty: string;
+    /** 逗号=> , */
+    const Comma = ",";
+    /** 分号=> : */
+    const Semicolon = ":";
+    /** 左斜杠=> / */
+    const LeftSlash = "/";
+    /** 右斜杠=> \ */
+    const RightSlash = "\\";
+    /** 单边双引号 => " */
+    const DoubleQuotes: string;
+    /** 单边单引号 => ' */
+    const SingleQuotes: string;
+    /** 美元符号 */
+    const Dollar: string;
+    /** 字符串拼串 */
+    function SubString(_arrString: Array<string>, _startIndex?: number): string;
+    /** 检查路径字符串 */
+    function SubPath(_paths: Array<string>, _symble: string): string;
+    /** 检测字符串两边是否是指定相同的字符 */
+    function CheckDoubleSideSameChar(_str: string, _checkChar: string): Boolean;
+    /** 检测字符串两边是否是指定不同的字符 */
+    function CheckDoubleSideDiffChar(_str: string, _char1: string, _char2: string): Boolean;
+    /** 在字符串指定位置插入指定的字符串 */
+    function Insert(_str: string, _pos: number, _newStr: string): string;
+    /** 在字符串首位添加插入字符 */
+    function InsertDoubleSide(_str: string, _char1: string, _char2: string): string;
+    /** 删除首尾指定个数个字符 */
+    function DestoryDoubleSide(_str: string, _headCount?: number, _endCount?: number): string;
+    /** 删除字符串的头部指定个数个字符 */
+    function DestoryFirstChar(_str: string, _headCount?: number): string;
+    /** 删除字符串的尾部指定个数个字符 */
+    function DestoryLastChar(_str: string, _endCount?: number): string;
+    /** 根据传入的字符串数组或列表，每个元素中间插入指定的字符，串成一个字符串 EXP:aaa,bbb,ccc,ddd */
+    function JoinString(_arrStrings: Array<string>, _symble: string): string;
+    /** 检测字符串是否是空字符串(空串则返回true 不空则返回false) */
+    function IsNullOrEmpty(_str: string): Boolean;
+    /** 数字类型转字符串类型 */
+    function ToString(_any: number | {} | any): string;
+    /**
+     *  字符串替换  搜索字符串替换为指定的替换字符串，并返回替换后的新字符串
+     * @param originalString 原始字符串
+     * @param searchString   要搜索的字符串
+     * @param replacement    要替换的字符串
+     * @returns
+     */
+    function ReplaceString(originalString: string, searchString: string, replacement: string): string;
+    /** 仅保留数字 */
+    function KeepNumeric(_value: string): number;
+    /** 仅保留除数字外字符串 */
+    function RejectNumeric(_value: string): string;
+}

package/frame/utility/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./ConfigUtility";
+export * from "./EnumUtility";
+export * from "./FileUtility";
+export * from "./BrowserUtility";
+export * from "./InterfaceUtility";
+export * from "./LogUtility";
+export * from "./MathUtility";
+export * from "./NetworkUtility";
+export * from "./ObjectUtility";
+export * from "./PromiseUtility";
+export * from "./StringUtility";
+export * from "./ProfilerUtility";
+export * from "./InputUtility";
+export * from "./CryptoUtility";
+export * from "./ReflectionUtility";

package/index.d.ts

@@ -0,0 +1 @@
+export * from './frame';