@dxyl/utils 1.2.1 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxyl/utils",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Collected many useful mathematical tools",
   "publishConfig": {
     "access": "public"
@@ -19,6 +19,11 @@
       "import":"./dist/index.es.js",
       "default":"./dist/index.umd.js"
     },
+    "./opentype":{
+      "types":"./lib/opentype/index.d.ts",
+      "import":"./lib/opentype/index.js",
+      "default":"./lib/opentype/index.umd.js"
+    },
     "./lib/*":"./lib/*"
   },
   "files": [

package/types/PluginService.d.ts

@@ -0,0 +1,61 @@
+export type PluginObject = {};
+export type PluginServiceOPtions = {
+    plugins?: IPlugin[];
+    presets?: IPreset[];
+};
+export type PluginContext = {
+    pluginName: string;
+    register(hook: IHook): void;
+    registerMethod(name: string, fn?: IMethod): void;
+};
+export type IPlugin = {
+    name: string;
+    config?: any;
+    apply: (api: PluginContext, config?: any) => void;
+};
+export type IPreset = Omit<IPlugin, 'apply'> & {
+    apply: (api: PluginContext, config?: any) => ({
+        presets?: IPreset[];
+        plugins?: IPlugin[];
+    });
+};
+export type IHook = {
+    name: string;
+    order?: number;
+    fn: Function;
+};
+export declare enum HookType {
+    create = "create",
+    add = "add",
+    modify = "modify",
+    event = "event"
+}
+export type HookOpts = {
+    name: string;
+    type?: HookType;
+    initalValue?: any;
+    args?: any;
+    sync?: boolean;
+};
+export type IMethod = (...args: any[]) => void;
+export declare class PluginService {
+    config?: PluginServiceOPtions;
+    private hooks;
+    private methods;
+    private plugins;
+    private extraPresets;
+    private extraPlugins;
+    constructor(config?: PluginServiceOPtions);
+    initPresetsAndPlugins(config: PluginServiceOPtions): void;
+    private resolvePresets;
+    private resolvePlugins;
+    private applyMethods;
+    private initPluginContext;
+    private initPreset;
+    private initPlugin;
+    registerPlugin(plugin: IPlugin | IPreset): void;
+    register(hook: IHook): void;
+    registerMethod(name: string, fn?: IMethod): void;
+    applyPlugins<T = any>(opts: HookOpts): Promise<T | void>;
+    destroy(): void;
+}

package/types/antv-util/matrix/index.d.ts

@@ -3,7 +3,7 @@
  * @param m
  * @param actions
  */
-export declare function transform(m: number[], actions: any[][]): number[];
+export declare function transform(m: number[], actions: any[][]): any[];
 /**
  * 向量 v1 到 向量 v2 夹角的方向
  * @param  {Array} v1 向量

package/types/antv-util/path/parser/params-parser.d.ts

@@ -5,6 +5,6 @@ export declare const paramsParser: {
     y2: number;
     x: number;
     y: number;
-    qx: null;
-    qy: null;
+    qx: any;
+    qy: any;
 };

package/types/data/reactivity.d.ts

@@ -1,4 +1,5 @@
 export type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+
 export declare enum TrackOpTypes {
     GET = "get",
     HAS = "has",
@@ -751,5 +752,5 @@ export declare function getCurrentWatcher(): ReactiveEffect<any> | undefined;
  */
 export declare function onWatcherCleanup(cleanupFn: () => void, failSilently?: boolean, owner?: ReactiveEffect | undefined): void;
 export declare function watch(source: WatchSource | WatchSource[] | WatchEffect | object, cb?: WatchCallback | null, options?: WatchOptions): WatchHandle;
-export declare function traverse(value: unknown, depth?: number, seen?: Set<unknown>): unknown;
+export declare function traverse(value: unknown, depth?: number, seen?: Map<unknown, number>): unknown;
 

package/types/events/eventTarget.d.ts

@@ -17,7 +17,7 @@ export declare const BUBBLING_PHASE: 3;
 export declare class Event<T = any, E extends Extract<keyof Record<string, any>, string> = ''> {
     static create<T = any, E extends Extract<keyof Record<string, any>, string> = ''>(type: E, bubbles?: boolean, cancelable?: boolean): Event<T, E>;
     type: E;
-    parentNode: null;
+    parentNode: any;
     target: EventTarget | null;
     currentTarget: EventTarget | null;
     data: T | null;

package/types/fast/fast-deep-equal.d.ts

@@ -0,0 +1 @@
+export default function equal(a: any, b: any): boolean;

package/types/fast/fast-diff.d.ts

@@ -0,0 +1,21 @@
+declare function diff(
+    text1: string,
+    text2: string,
+    cursorPos?: number | diff.CursorInfo,
+    cleanup?: boolean
+  ): diff.Diff[];
+  
+  declare namespace diff {
+    type Diff = [-1 | 0 | 1, string];
+  
+    const DELETE: -1;
+    const INSERT: 1;
+    const EQUAL: 0;
+  
+    interface CursorInfo {
+      oldRange: { index: number; length: number };
+      newRange: { index: number; length: number };
+    }
+  }
+  
+  export default diff;

package/types/fast/fast-json-patch/core.d.ts

@@ -0,0 +1,111 @@
+import { PatchError, _deepClone } from './helpers.js';
+export declare const JsonPatchError: typeof PatchError;
+export declare const deepClone: typeof _deepClone;
+export type Operation = AddOperation<any> | RemoveOperation | ReplaceOperation<any> | MoveOperation | CopyOperation | TestOperation<any> | GetOperation<any>;
+export interface Validator<T> {
+    (operation: Operation, index: number, document: T, existingPathFragment: string): void;
+}
+export interface OperationResult<T> {
+    removed?: any;
+    test?: boolean;
+    newDocument: T;
+}
+export interface BaseOperation {
+    path: string;
+}
+export interface AddOperation<T> extends BaseOperation {
+    op: 'add';
+    value: T;
+}
+export interface RemoveOperation extends BaseOperation {
+    op: 'remove';
+}
+export interface ReplaceOperation<T> extends BaseOperation {
+    op: 'replace';
+    value: T;
+}
+export interface MoveOperation extends BaseOperation {
+    op: 'move';
+    from: string;
+}
+export interface CopyOperation extends BaseOperation {
+    op: 'copy';
+    from: string;
+}
+export interface TestOperation<T> extends BaseOperation {
+    op: 'test';
+    value: T;
+}
+export interface GetOperation<T> extends BaseOperation {
+    op: '_get';
+    value: T;
+}
+export interface PatchResult<T> extends Array<OperationResult<T>> {
+    newDocument: T;
+}
+/**
+ * Retrieves a value from a JSON document by a JSON pointer.
+ * Returns the value.
+ *
+ * @param document The document to get the value from
+ * @param pointer an escaped JSON pointer
+ * @return The retrieved value
+ */
+export declare function getValueByPointer(document: any, pointer: string): any;
+/**
+ * Apply a single JSON Patch Operation on a JSON document.
+ * Returns the {newDocument, result} of the operation.
+ * It modifies the `document` and `operation` objects - it gets the values by reference.
+ * If you would like to avoid touching your values, clone them:
+ * `jsonpatch.applyOperation(document, jsonpatch._deepClone(operation))`.
+ *
+ * @param document The document to patch
+ * @param operation The operation to apply
+ * @param validateOperation `false` is without validation, `true` to use default jsonpatch's validation, or you can pass a `validateOperation` callback to be used for validation.
+ * @param mutateDocument Whether to mutate the original document or clone it before applying
+ * @param banPrototypeModifications Whether to ban modifications to `__proto__`, defaults to `true`.
+ * @return `{newDocument, result}` after the operation
+ */
+export declare function applyOperation<T>(document: T, operation: Operation, validateOperation?: boolean | Validator<T>, mutateDocument?: boolean, banPrototypeModifications?: boolean, index?: number): OperationResult<T>;
+/**
+ * Apply a full JSON Patch array on a JSON document.
+ * Returns the {newDocument, result} of the patch.
+ * It modifies the `document` object and `patch` - it gets the values by reference.
+ * If you would like to avoid touching your values, clone them:
+ * `jsonpatch.applyPatch(document, jsonpatch._deepClone(patch))`.
+ *
+ * @param document The document to patch
+ * @param patch The patch to apply
+ * @param validateOperation `false` is without validation, `true` to use default jsonpatch's validation, or you can pass a `validateOperation` callback to be used for validation.
+ * @param mutateDocument Whether to mutate the original document or clone it before applying
+ * @param banPrototypeModifications Whether to ban modifications to `__proto__`, defaults to `true`.
+ * @return An array of `{newDocument, result}` after the patch
+ */
+export declare function applyPatch<T>(document: T, patch: ReadonlyArray<Operation>, validateOperation?: boolean | Validator<T>, mutateDocument?: boolean, banPrototypeModifications?: boolean): PatchResult<T>;
+/**
+ * Apply a single JSON Patch Operation on a JSON document.
+ * Returns the updated document.
+ * Suitable as a reducer.
+ *
+ * @param document The document to patch
+ * @param operation The operation to apply
+ * @return The updated document
+ */
+export declare function applyReducer<T>(document: T, operation: Operation, index: number): T;
+/**
+ * Validates a single operation. Called from `jsonpatch.validate`. Throws `JsonPatchError` in case of an error.
+ * @param {object} operation - operation object (patch)
+ * @param {number} index - index of operation in the sequence
+ * @param {object} [document] - object where the operation is supposed to be applied
+ * @param {string} [existingPathFragment] - comes along with `document`
+ */
+export declare function validator(operation: Operation, index: number, document?: any, existingPathFragment?: string): void;
+/**
+ * Validates a sequence of operations. If `document` parameter is provided, the sequence is additionally validated against the object document.
+ * If error is encountered, returns a JsonPatchError object
+ * @param sequence
+ * @param document
+ * @returns {JsonPatchError|undefined}
+ */
+export declare function validate<T>(sequence: ReadonlyArray<Operation>, document?: T, externalValidator?: Validator<T>): PatchError;
+export declare function _areEquals(a: any, b: any): boolean;

package/types/fast/fast-json-patch/duplex.d.ts

@@ -0,0 +1,23 @@
+import { Operation } from './core.js';
+export interface Observer<T> {
+    object: T;
+    patches: Operation[];
+    unobserve: () => void;
+    callback: (patches: Operation[]) => void;
+}
+/**
+ * Detach an observer from an object
+ */
+export declare function unobserve<T>(root: T, observer: Observer<T>): void;
+/**
+ * Observes changes made to an object, which can then be retrieved using generate
+ */
+export declare function observe<T>(obj: Object | Array<T>, callback?: (patches: Operation[]) => void): Observer<T>;
+/**
+ * Generate an array of patches from an observer
+ */
+export declare function generate<T>(observer: Observer<Object>, invertible?: boolean): Operation[];
+/**
+ * Create an array of patches from the differences in two objects
+ */
+export declare function compare(tree1: Object | Array<any>, tree2: Object | Array<any>, invertible?: boolean): Operation[];

package/types/fast/fast-json-patch/helpers.d.ts

@@ -0,0 +1,41 @@
+/*!
+ * https://github.com/Starcounter-Jack/JSON-Patch
+ * (c) 2017-2022 Joachim Wester
+ * MIT licensed
+ */
+export declare function hasOwnProperty(obj: any, key: string): boolean;
+export declare function _objectKeys(obj: any): any[];
+/**
+* Deeply clone the object.
+* https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25 (recursiveDeepCopy)
+* @param  {any} obj value to clone
+* @return {any} cloned obj
+*/
+export declare function _deepClone(obj: any): any;
+export declare function isInteger(str: string): boolean;
+/**
+* Escapes a json pointer path
+* @param path The raw pointer
+* @return the Escaped path
+*/
+export declare function escapePathComponent(path: string): string;
+/**
+ * Unescapes a json pointer path
+ * @param path The escaped pointer
+ * @return The unescaped path
+ */
+export declare function unescapePathComponent(path: string): string;
+export declare function _getPathRecursive(root: any, obj: any): string;
+export declare function getPath(root: Object, obj: Object): string;
+/**
+* Recursively checks whether an object has any undefined values inside.
+*/
+export declare function hasUndefined(obj: any): boolean;
+export type JsonPatchErrorName = 'SEQUENCE_NOT_AN_ARRAY' | 'OPERATION_NOT_AN_OBJECT' | 'OPERATION_OP_INVALID' | 'OPERATION_PATH_INVALID' | 'OPERATION_FROM_REQUIRED' | 'OPERATION_VALUE_REQUIRED' | 'OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED' | 'OPERATION_PATH_CANNOT_ADD' | 'OPERATION_PATH_UNRESOLVABLE' | 'OPERATION_FROM_UNRESOLVABLE' | 'OPERATION_PATH_ILLEGAL_ARRAY_INDEX' | 'OPERATION_VALUE_OUT_OF_BOUNDS' | 'TEST_OPERATION_FAILED';
+export declare class PatchError extends Error {
+    name: JsonPatchErrorName;
+    index?: number;
+    operation?: any;
+    tree?: any;
+    constructor(message: string, name: JsonPatchErrorName, index?: number, operation?: any, tree?: any);
+}

package/types/index.d.ts

@@ -24,6 +24,10 @@ export { Options } from './Options';
 export { default as compose } from './compose';
 export type { OptionsProperties, OptionConfig } from './Options';
 export { default as deepmerge } from './deepmerge';
-export { default as fastDeepEqual } from './fast-deep-equal';
 export * from './Color';
 export * as colord from './color/colord/src';
+export * from './PluginService';
+export { default as fastDeepEqual } from './fast/fast-deep-equal';
+export { default as fastDiff } from './fast/fast-diff';
+export * as fastJsonPatch from './fast/fast-json-patch/core';
+export * as QuillDelta from './text/quill-delta/Delta';

package/types/laxer.d.ts

@@ -19,4 +19,28 @@
        *
        * sourceCode -> Lexer analysis or Tokenizer(token[]) -> ast parse (tree<astNode>) -> (code generate) | (ast interpreter)
       */
-export {};
+declare const token: (type: string, value: any, start: number) => {
+    type: string;
+    value: any;
+    start: number;
+};
+type Token = ReturnType<typeof token>;
+/**
+ * 词法分析
+ * @param {string} source 源码
+ * @returns {Token[]}
+*/
+declare const lexer: (source: string) => {
+    type: string;
+    value: any;
+    start: number;
+}[];
+declare const parse: (tokens: Token[]) => {
+    type: string;
+    body: any[];
+    start?: number;
+    end?: number;
+};
+declare const codeGen: (ast: any) => string;
+declare const interpreter: (program: any) => any;
+export { parse, codeGen, lexer, interpreter, token };

package/types/lodash/_freeGlobal.d.ts

@@ -1,3 +1,3 @@
 export default freeGlobal;
 /** Detect free variable `global` from Node.js. */
-declare var freeGlobal: false | typeof globalThis;
+declare var freeGlobal: typeof globalThis;

package/types/lodash/_stackSet.d.ts

@@ -24,5 +24,5 @@ declare class stackSet {
      */
     private constructor();
     size: any;
-    __data__: MapCache | undefined;
+    __data__: MapCache;
 }

package/types/priority_queue.d.ts

@@ -14,7 +14,7 @@ export declare class PriorityQueue<T> {
      * 判断队列是否为空
      */
     isEmpty(): boolean;
-    top(): T | null;
+    top(): T;
     /**
      * 查看队首元素
      */
@@ -25,7 +25,7 @@ export declare class PriorityQueue<T> {
      */
     enqueue(value: T): void;
     push(value: T): void;
-    pop(): T | null;
+    pop(): T;
     /**
      * 出队
      * @returns 队首元素或null（空队列时）

package/types/radash/array.d.ts

@@ -30,7 +30,7 @@ export declare function zipToObject<K extends string | number | symbol, V>(keys:
  *
  * Ex. const greatest = () => boil(numbers, (a, b) => a > b)
  */
-export declare const boil: <T>(array: readonly T[], compareFunc: (a: T, b: T) => T) => T | null;
+export declare const boil: <T>(array: readonly T[], compareFunc: (a: T, b: T) => T) => T;
 /**
  * Sum all numbers in an array. Optionally provide a function
  * to convert objects in the array to number values.
@@ -40,11 +40,11 @@ export declare function sum<T extends object>(array: readonly T[], fn: (item: T)
 /**
  * Get the first item in an array or a default value
  */
-export declare const first: <T>(array: readonly T[], defaultValue?: T | null | undefined) => T | null | undefined;
+export declare const first: <T>(array: readonly T[], defaultValue?: T | null | undefined) => T;
 /**
  * Get the last item in an array or a default value
  */
-export declare const last: <T>(array: readonly T[], defaultValue?: T | null | undefined) => T | null | undefined;
+export declare const last: <T>(array: readonly T[], defaultValue?: T | null | undefined) => T;
 /**
  * Sort an array without modifying it and return
  * the newly sorted value

package/types/text/quill-delta/AttributeMap.d.ts

@@ -0,0 +1,10 @@
+interface AttributeMap {
+    [key: string]: unknown;
+}
+declare namespace AttributeMap {
+    function compose(a?: AttributeMap, b?: AttributeMap, keepNull?: boolean): AttributeMap | undefined;
+    function diff(a?: AttributeMap, b?: AttributeMap): AttributeMap | undefined;
+    function invert(attr?: AttributeMap, base?: AttributeMap): AttributeMap;
+    function transform(a: AttributeMap | undefined, b: AttributeMap | undefined, priority?: boolean): AttributeMap | undefined;
+}
+export default AttributeMap;

package/types/text/quill-delta/Delta.d.ts

@@ -0,0 +1,45 @@
+import { default as diff } from '../../fast/fast-diff';
+import { default as AttributeMap } from './AttributeMap';
+import { default as Op } from './Op';
+import { default as OpIterator } from './OpIterator';
+interface EmbedHandler<T> {
+    compose(a: T, b: T, keepNull: boolean): T;
+    invert(a: T, b: T): T;
+    transform(a: T, b: T, priority: boolean): T;
+}
+declare class Delta {
+    static Op: typeof Op;
+    static OpIterator: typeof OpIterator;
+    static AttributeMap: typeof AttributeMap;
+    private static handlers;
+    static registerEmbed<T>(embedType: string, handler: EmbedHandler<T>): void;
+    static unregisterEmbed(embedType: string): void;
+    private static getHandler;
+    ops: Op[];
+    constructor(ops?: Op[] | {
+        ops: Op[];
+    });
+    insert(arg: string | Record<string, unknown>, attributes?: AttributeMap | null): this;
+    delete(length: number): this;
+    retain(length: number | Record<string, unknown>, attributes?: AttributeMap | null): this;
+    push(newOp: Op): this;
+    chop(): this;
+    filter(predicate: (op: Op, index: number) => boolean): Op[];
+    forEach(predicate: (op: Op, index: number) => void): void;
+    map<T>(predicate: (op: Op, index: number) => T): T[];
+    partition(predicate: (op: Op) => boolean): [Op[], Op[]];
+    reduce<T>(predicate: (accum: T, curr: Op, index: number) => T, initialValue: T): T;
+    changeLength(): number;
+    length(): number;
+    slice(start?: number, end?: number): Delta;
+    compose(other: Delta): Delta;
+    concat(other: Delta): Delta;
+    diff(other: Delta, cursor?: number | diff.CursorInfo): Delta;
+    eachLine(predicate: (line: Delta, attributes: AttributeMap, index: number) => boolean | void, newline?: string): void;
+    invert(base: Delta): Delta;
+    transform(index: number, priority?: boolean): number;
+    transform(other: Delta, priority?: boolean): Delta;
+    transformPosition(index: number, priority?: boolean): number;
+}
+export default Delta;
+export { Op, OpIterator, AttributeMap, Delta };

package/types/text/quill-delta/Op.d.ts

@@ -0,0 +1,11 @@
+import { default as AttributeMap } from './AttributeMap';
+interface Op {
+    insert?: string | Record<string, unknown>;
+    delete?: number;
+    retain?: number | Record<string, unknown>;
+    attributes?: AttributeMap;
+}
+declare namespace Op {
+    function length(op: Op): number;
+}
+export default Op;

package/types/text/quill-delta/OpIterator.d.ts

@@ -0,0 +1,13 @@
+import { default as Op } from './Op';
+export default class Iterator {
+    ops: Op[];
+    index: number;
+    offset: number;
+    constructor(ops: Op[]);
+    hasNext(): boolean;
+    next(length?: number): Op;
+    peek(): Op;
+    peekLength(): number;
+    peekType(): string;
+    rest(): Op[];
+}