• Version 3.3.7
  • Published
  • 903 kB
  • 3 dependencies
  • MIT license


npm i @antv/util
yarn add @antv/util
pnpm add @antv/util


> AntV 底层依赖的工具库,不建议在自己业务中使用。






Type Aliases


variable toRGB

const toRGB: {
(...args: any[]): any;
cache: {
clear: (isPartial?: number) => void;
has: (key: any) => boolean;
get: (key: any) => any;
set: (key: any, value: any) => void;
  • export with memoize.

    Parameter color



function angleTo

angleTo: (
v1: [number, number],
v2: [number, number],
direct?: boolean
) => number;
  • 二维向量 v1 到 v2 的夹角

    Parameter v1

    Parameter v2

    Parameter direct

function arcToCubic

arcToCubic: (
X1: number,
Y1: number,
RX: number,
RY: number,
angle: number,
LAF: number,
SF: number,
X2: number,
Y2: number,
recursive: number[]
) => any[];
  • Converts A (arc-to) segments to C (cubic-bezier-to).

    For more information of where this math came from visit: http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes

function assign

assign: <Base, A, B, C>(
dist: Base & A & B & C,
src1?: A,
src2?: B,
src3?: C
) => Base & A & B & C;

    function augment

    augment: (...args: any[]) => void;

      function clamp

      clamp: (a: number, min: number, max: number) => number;

        function clearAnimationFrame

        clearAnimationFrame: (handler: number) => void;

          function clone

          clone: (obj: any) => any;

            function clonePath

            clonePath: (path: PathArray | PathSegment) => PathArray;

              function contains

              contains: (arr: any[], value: any) => boolean;

                function createDOM

                createDOM: (str: string) => HTMLElement;
                • Create DOM from a html string.

                  Parameter str


                function debounce

                debounce: (func: Function, wait?: number, immediate?: boolean) => () => void;

                  function deepMix

                  deepMix: (rst: any, ...args: any[]) => any;

                    function difference

                    difference: <T>(arr: T[], values?: T[]) => T[];
                    • Flattens array a single level deep.

                      Parameter arr

                      The array to inspect.

                      Parameter values

                      The values to exclude. {Array} Returns the new array of filtered values.

                      Example 1

                      difference([2, 1], [2, 3]); // => [1]

                    function direction

                    direction: (v1: number[], v2: number[]) => number;
                    • 向量 v1 到 向量 v2 夹角的方向

                      Parameter v1


                      Parameter v2

                      向量 {Boolean} >= 0 顺时针 < 0 逆时针

                    function distanceSquareRoot

                    distanceSquareRoot: (a: [number, number], b: [number, number]) => number;

                      function each

                      each: (elements: any[] | object, func: (v: any, k: any) => any) => void;

                        function endsWith

                        endsWith: { (arr: string, e: string): boolean; <T>(arr: T[], e: T): boolean };

                          function equalizeSegments

                          equalizeSegments: (
                          path1: PathArray,
                          path2: PathArray,
                          TL?: number
                          ) => CurveArray[];

                            function every

                            every: <T>(arr: T[], func: (v: T, idx?: number) => any) => boolean;
                            • 只要有一个不满足条件就返回 false

                              Parameter arr

                              Parameter func

                            function extend

                            extend: (
                            subclass: any,
                            superclass: any,
                            overrides?: any,
                            staticOverrides?: any
                            ) => any;

                              function filter

                              filter: <T>(arr: T[], func: (v: T, idx: number) => boolean) => T[];

                                function find

                                find: {
                                <T>(arr: T[], predicate: Function): T;
                                <T>(arr: T[], predicate: object): T;

                                  function findIndex

                                  findIndex: <T>(
                                  arr: T[],
                                  predicate: (item: T, idx?: number) => boolean,
                                  fromIndex?: number
                                  ) => number;

                                    function firstValue

                                    firstValue: (data: object[], name: string) => any;

                                      function fixedBase

                                      fixedBase: (v: number, base: number | string) => number;

                                        function flatten

                                        flatten: <T>(arr: T[]) => T[];
                                        • Flattens array a single level deep.

                                          Parameter arr

                                          The array to flatten. {Array} Returns the new flattened array.

                                          Example 1

                                          flatten([1, [2, [3, [4]], 5]]); // => [1, 2, [3, [4]], 5]

                                        function flattenDeep

                                        flattenDeep: (arr: any[], result?: any[]) => any[];
                                        • Flattens array a single level deep.

                                          Parameter arr

                                          The array to flatten.

                                          Parameter result

                                          The array to return. {Array} Returns the new flattened array.

                                          Example 1

                                          flattenDeep([1, [2, [3, [4]], 5]]); // => [1, 2, 3, 4, 5]

                                        function forIn

                                        forIn: (elements: any[] | object, func: (v: any, k: any) => any) => void;

                                          function get

                                          get: (obj: any, key: string | any[], defaultValue?: any) => any;

                                            function getDrawDirection

                                            getDrawDirection: (pathArray: PathArray) => boolean;

                                              function getPathArea

                                              getPathArea: (path: PathArray) => number;
                                              • Returns the area of a shape. Jürg Lehni & Jonathan Puckey

                                                See Also

                                                • https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js

                                              function getPathBBox

                                              getPathBBox: (
                                              path: string | PathArray,
                                              options?: Partial<PathLengthFactoryOptions>
                                              ) => PathBBox;
                                              • Returns the bounding box of a shape.

                                              function getPathBBoxTotalLength

                                              getPathBBoxTotalLength: (
                                              path: PathArray,
                                              options?: Partial<PathLengthFactoryOptions>
                                              ) => PathBBoxTotalLength;
                                              • Returns the bounding box of a shape.

                                              function getPointAtLength

                                              getPointAtLength: (
                                              pathInput: string | PathArray,
                                              distance: number,
                                              options?: Partial<PathLengthFactoryOptions>
                                              ) => import('../types').Point;
                                              • Returns [x,y] coordinates of a point at a given length of a shape.

                                              function getRange

                                              getRange: (values: number[]) => RangeType;

                                                function getRotatedCurve

                                                getRotatedCurve: (
                                                a: CurveArray,
                                                b: CurveArray
                                                ) => (string[] | import('../types').MSegment | import('../types').CSegment)[];

                                                  function getTotalLength

                                                  getTotalLength: (
                                                  pathInput: string | PathArray,
                                                  options?: Partial<PathLengthFactoryOptions>
                                                  ) => number;
                                                  • Returns the shape total length, or the equivalent to shape.getTotalLength().

                                                    The normalizePath version is lighter, faster, more efficient and more accurate with paths that are not curveArray.

                                                  function getType

                                                  getType: (value: any) => string;

                                                    function getWrapBehavior

                                                    getWrapBehavior: (obj: object, action: string) => Function;
                                                    • 获取封装的事件

                                                      Parameter obj


                                                      Parameter action

                                                      事件名称 {Function} 返回事件处理函数

                                                    function gradient

                                                    gradient: (colors: string | string[]) => (percent: number) => string;
                                                    • 获取渐变函数

                                                      Parameter colors

                                                      多个颜色 颜色值

                                                    function group

                                                    group: <T>(
                                                    data: T[],
                                                    condition: string | string[] | ((v: T) => string)
                                                    ) => T[][];

                                                      function groupBy

                                                      groupBy: {
                                                      <T>(data: T[], condition: (item: T) => string): ObjectType<T>;
                                                      <T>(data: T[], condition: string): ObjectType<T>;

                                                        function groupToMap

                                                        groupToMap: (
                                                        data: any,
                                                        condition: string | string[] | ((row: any) => string)
                                                        ) => import('./group-by').ObjectType<any> | { 0: any };
                                                        • 将数据分组成 map

                                                          Parameter data

                                                          Parameter condition

                                                        function has

                                                        has: (obj: object, key: any) => boolean;

                                                          function hasKey

                                                          hasKey: (obj: object, key: any) => boolean;

                                                            function hasValue

                                                            hasValue: (obj: object, value: any) => boolean;
                                                              head: (o: unknown) => any;

                                                                function identity

                                                                identity: <T>(v: T) => T;

                                                                  function includes

                                                                  includes: (arr: any[], value: any) => boolean;

                                                                    function indexOf

                                                                    indexOf: <T>(arr: T[], obj: T) => number;

                                                                      function isArguments

                                                                      isArguments: (value: any) => boolean;

                                                                        function isArray

                                                                        isArray: (value: any) => value is any[];

                                                                          function isArrayLike

                                                                          isArrayLike: (value: any) => boolean;

                                                                            function isBoolean

                                                                            isBoolean: (value: any) => value is boolean;

                                                                              function isDate

                                                                              isDate: (value: any) => value is Date;

                                                                                function isDecimal

                                                                                isDecimal: (num: any) => boolean;

                                                                                  function isElement

                                                                                  isElement: (o: any) => boolean;
                                                                                  • 判断是否HTML元素 {Boolean} 是否HTML元素

                                                                                  function isEmpty

                                                                                  isEmpty: (value: any) => boolean;

                                                                                    function isEqual

                                                                                    isEqual: (value: any, other: any) => boolean;

                                                                                      function isEqualWith

                                                                                      isEqualWith: <T>(value: T, other: T, fn: (v1: T, v2: T) => boolean) => boolean;

                                                                                        function isError

                                                                                        isError: (value: any) => value is Error;

                                                                                          function isEven

                                                                                          isEven: (num: any) => boolean;

                                                                                            function isFinite

                                                                                            isFinite: (value: any) => value is number;

                                                                                              function isFunction

                                                                                              isFunction: (value: any) => value is Function;

                                                                                                function isInteger

                                                                                                isInteger: (number: unknown) => boolean;

                                                                                                  function isMatch

                                                                                                  isMatch: (obj: any, attrs: any) => boolean;

                                                                                                    function isNegative

                                                                                                    isNegative: (num: any) => boolean;

                                                                                                      function isNil

                                                                                                      isNil: (value: any) => value is null;

                                                                                                        function isNull

                                                                                                        isNull: (value: any) => value is null;

                                                                                                          function isNumber

                                                                                                          isNumber: (value: any) => value is number;

                                                                                                            function isNumberEqual

                                                                                                            isNumberEqual: (a: number, b: number, precision?: number) => boolean;

                                                                                                              function isObject

                                                                                                              isObject: <T = object>(value: any) => value is T;

                                                                                                                function isObjectLike

                                                                                                                isObjectLike: (value: any) => value is object;

                                                                                                                  function isOdd

                                                                                                                  isOdd: (num: any) => boolean;

                                                                                                                    function isPlainObject

                                                                                                                    isPlainObject: (value: any) => value is object;

                                                                                                                      function isPointInPolygon

                                                                                                                      isPointInPolygon: (points: number[][], x: number, y: number) => boolean;

                                                                                                                        function isPointInStroke

                                                                                                                        isPointInStroke: (pathInput: string | PathArray, point: Point) => boolean;
                                                                                                                        • Checks if a given point is in the stroke of a path.

                                                                                                                        function isPolygonsIntersect

                                                                                                                        isPolygonsIntersect: (points1: number[][], points2: number[][]) => boolean;
                                                                                                                        • See Also

                                                                                                                          • https://stackoverflow.com/questions/753140/how-do-i-determine-if-two-convex-polygons-intersect

                                                                                                                        function isPositive

                                                                                                                        isPositive: (num: any) => boolean;

                                                                                                                          function isPrototype

                                                                                                                          isPrototype: (value: any) => boolean;

                                                                                                                            function isRegExp

                                                                                                                            isRegExp: (str: any) => str is RegExp;

                                                                                                                              function isString

                                                                                                                              isString: (str: any) => str is string;

                                                                                                                                function isType

                                                                                                                                isType: (value: any, type: string) => boolean;

                                                                                                                                  function isUndefined

                                                                                                                                  isUndefined: (value: any) => value is undefined;

                                                                                                                                    function keys

                                                                                                                                    keys: (obj: any) => any[];

                                                                                                                                      function last

                                                                                                                                      last: (o: unknown) => any;

                                                                                                                                        function lowerCase

                                                                                                                                        lowerCase: (str: string) => string;

                                                                                                                                          function lowerFirst

                                                                                                                                          lowerFirst: (value: string) => string;

                                                                                                                                            function map

                                                                                                                                            map: <T, G>(arr: T[], func: (v: T, idx: number) => G) => G[];

                                                                                                                                              function mapValues

                                                                                                                                              mapValues: <T>(
                                                                                                                                              object: { [key: string]: T },
                                                                                                                                              func?: (value: T, key: string) => any
                                                                                                                                              ) => { [key: string]: any };

                                                                                                                                                function max

                                                                                                                                                max: (arr: number[]) => number | undefined;

                                                                                                                                                  function maxBy

                                                                                                                                                  maxBy: <T>(arr: T[], fn: string | ((v: T) => number)) => T;

                                                                                                                                                    function memoize

                                                                                                                                                    memoize: (
                                                                                                                                                    f: Function,
                                                                                                                                                    resolver?: (...args: any[]) => string,
                                                                                                                                                    maxSize?: number
                                                                                                                                                    ) => {
                                                                                                                                                    (...args: any[]): any;
                                                                                                                                                    cache: {
                                                                                                                                                    clear: (isPartial?: number) => void;
                                                                                                                                                    has: (key: any) => boolean;
                                                                                                                                                    get: (key: any) => any;
                                                                                                                                                    set: (key: any, value: any) => void;

                                                                                                                                                      function min

                                                                                                                                                      min: (arr: number[]) => number | undefined;

                                                                                                                                                        function minBy

                                                                                                                                                        minBy: <T>(arr: T[], fn: string | ((v: T) => number)) => T;

                                                                                                                                                          function mix

                                                                                                                                                          mix: <Base, A, B, C>(
                                                                                                                                                          dist: Base & A & B & C,
                                                                                                                                                          src1?: A,
                                                                                                                                                          src2?: B,
                                                                                                                                                          src3?: C
                                                                                                                                                          ) => Base & A & B & C;

                                                                                                                                                            function mod

                                                                                                                                                            mod: (n: number, m: number) => number;

                                                                                                                                                              function modifyCSS

                                                                                                                                                              modifyCSS: (
                                                                                                                                                              dom: HTMLElement | null | undefined,
                                                                                                                                                              css: { [key: string]: any }
                                                                                                                                                              ) => HTMLElement;
                                                                                                                                                              • Modify the CSS of a DOM.

                                                                                                                                                                Parameter dom

                                                                                                                                                                Parameter css


                                                                                                                                                              function noop

                                                                                                                                                              noop: () => void;

                                                                                                                                                                function normalizePath

                                                                                                                                                                normalizePath: (pathInput: string | PathArray) => NormalArray;
                                                                                                                                                                • Example 1

                                                                                                                                                                  const path = 'M0 0 H50'; const normalizedPath = SVGPathCommander.normalizePath(path); // result => [['M', 0, 0], ['L', 50, 0]]

                                                                                                                                                                function number2color

                                                                                                                                                                number2color: (num: number) => string;

                                                                                                                                                                  function omit

                                                                                                                                                                  omit: <T>(obj: ObjectType<T>, keys: string[]) => ObjectType<T>;

                                                                                                                                                                    function parseRadius

                                                                                                                                                                    parseRadius: { (radius: number): RadiusType; (radius: number[]): RadiusType };

                                                                                                                                                                      function path2Absolute

                                                                                                                                                                      path2Absolute: (pathInput: string | PathArray) => AbsoluteArray;

                                                                                                                                                                        function path2Array

                                                                                                                                                                        path2Array: (pathInput: string) => PathArray;

                                                                                                                                                                          function path2Curve

                                                                                                                                                                          path2Curve: (
                                                                                                                                                                          pathInput: string | PathArray,
                                                                                                                                                                          needZCommandIndexes?: boolean
                                                                                                                                                                          ) => CurveArray | [CurveArray, number[]];

                                                                                                                                                                            function path2String

                                                                                                                                                                            path2String: (path: PathArray, round?: number | 'off') => string;
                                                                                                                                                                            • Returns a valid d attribute string value created by rounding values and concatenating the pathArray segments.

                                                                                                                                                                            function pick

                                                                                                                                                                            pick: <T>(object: ObjectType<T>, keys: string[]) => ObjectType<T>;

                                                                                                                                                                              function pull

                                                                                                                                                                              pull: <T>(arr: T[], ...values: any[]) => T[];

                                                                                                                                                                                function pullAt

                                                                                                                                                                                pullAt: <T>(arr: T[], indexes: number[]) => T[];

                                                                                                                                                                                  function reduce

                                                                                                                                                                                  reduce: <T, G>(
                                                                                                                                                                                  arr: ObjectType<T> | G[],
                                                                                                                                                                                  fn: (result: T, data: G, idx: string | number) => T,
                                                                                                                                                                                  init: T
                                                                                                                                                                                  ) => T;

                                                                                                                                                                                    function remove

                                                                                                                                                                                    remove: <T>(
                                                                                                                                                                                    arr: T[],
                                                                                                                                                                                    predicate: (value: T, idx: number, arr?: T[]) => boolean
                                                                                                                                                                                    ) => T[];

                                                                                                                                                                                      function requestAnimationFrame

                                                                                                                                                                                      requestAnimationFrame: (fn: FrameRequestCallback) => any;

                                                                                                                                                                                        function reverseCurve

                                                                                                                                                                                        reverseCurve: (pathArray: CurveArray) => CurveArray;

                                                                                                                                                                                          function rgb2arr

                                                                                                                                                                                          rgb2arr: (str: string) => number[];
                                                                                                                                                                                          • rgb 颜色转换成数组

                                                                                                                                                                                            Parameter str


                                                                                                                                                                                          function set

                                                                                                                                                                                          set: (obj: any, path: string | any[], value: any) => any;

                                                                                                                                                                                            function size

                                                                                                                                                                                            size: (o: unknown) => number;

                                                                                                                                                                                              function some

                                                                                                                                                                                              some: <T>(arr: T[], func: (v: T, idx?: number) => any) => boolean;
                                                                                                                                                                                              • 只要有一个满足条件就返回 true

                                                                                                                                                                                                Parameter arr

                                                                                                                                                                                                Parameter func

                                                                                                                                                                                              function sortBy

                                                                                                                                                                                              sortBy: {
                                                                                                                                                                                              <T>(arr: ObjectType<T>[], key: Function): ObjectType<T>[];
                                                                                                                                                                                              <T>(arr: ObjectType<T>[], key: string): ObjectType<T>[];
                                                                                                                                                                                              <T>(arr: ObjectType<T>[], key: string[]): ObjectType<T>[];

                                                                                                                                                                                                function startsWith

                                                                                                                                                                                                startsWith: { (arr: string, e: string): boolean; <T>(arr: T[], e: T): boolean };

                                                                                                                                                                                                  function substitute

                                                                                                                                                                                                  substitute: <T>(str: string, o: ObjectType<T>) => string;

                                                                                                                                                                                                    function throttle

                                                                                                                                                                                                    throttle: (func: Function, wait: number, options: OptionsType) => Function;

                                                                                                                                                                                                      function toArray

                                                                                                                                                                                                      toArray: (value: any) => any[];

                                                                                                                                                                                                        function toCSSGradient

                                                                                                                                                                                                        toCSSGradient: (gradientColor: any) => any;

                                                                                                                                                                                                          function toDegree

                                                                                                                                                                                                          toDegree: (radian: number) => number;

                                                                                                                                                                                                            function toInteger

                                                                                                                                                                                                            toInteger: (string: string, radix?: number) => number;

                                                                                                                                                                                                              function toRadian

                                                                                                                                                                                                              toRadian: (degree: number) => number;

                                                                                                                                                                                                                function toString

                                                                                                                                                                                                                toString: (value: any) => string;

                                                                                                                                                                                                                  function transform

                                                                                                                                                                                                                  transform: (m: number[], actions: any[][]) => any[];
                                                                                                                                                                                                                  • 根据 actions 来做 transform

                                                                                                                                                                                                                    Parameter m

                                                                                                                                                                                                                    Parameter actions

                                                                                                                                                                                                                  function union

                                                                                                                                                                                                                  union: (...sources: any[]) => any[];

                                                                                                                                                                                                                    function uniq

                                                                                                                                                                                                                    uniq: (arr: any[], cache?: Map<any, any>) => any[];

                                                                                                                                                                                                                      function uniqueId

                                                                                                                                                                                                                      uniqueId: (prefix?: string) => string;

                                                                                                                                                                                                                        function upperCase

                                                                                                                                                                                                                        upperCase: (str: string) => string;

                                                                                                                                                                                                                          function upperFirst

                                                                                                                                                                                                                          upperFirst: (value: string) => string;

                                                                                                                                                                                                                            function values

                                                                                                                                                                                                                            values: (obj: any) => unknown[];

                                                                                                                                                                                                                              function valuesOfKey

                                                                                                                                                                                                                              valuesOfKey: (data: any[], name: string) => any[];

                                                                                                                                                                                                                                function vertical

                                                                                                                                                                                                                                vertical: (out: number[], v: number[], flag: boolean) => number[];
                                                                                                                                                                                                                                • 计算二维向量的垂直向量

                                                                                                                                                                                                                                  Parameter out

                                                                                                                                                                                                                                  Parameter v

                                                                                                                                                                                                                                  Parameter flag

                                                                                                                                                                                                                                function wrapBehavior

                                                                                                                                                                                                                                wrapBehavior: (obj: object, action: string) => Function;
                                                                                                                                                                                                                                • 封装事件,便于使用上下文this,和便于解除事件时使用

                                                                                                                                                                                                                                  Parameter obj


                                                                                                                                                                                                                                  Parameter action

                                                                                                                                                                                                                                  事件名称 {Function} 返回事件处理函数


                                                                                                                                                                                                                                class Cache

                                                                                                                                                                                                                                class<T> {}
                                                                                                                                                                                                                                • k-v 存储

                                                                                                                                                                                                                                property map

                                                                                                                                                                                                                                map: { [key: string]: T };

                                                                                                                                                                                                                                  method clear

                                                                                                                                                                                                                                  clear: () => void;

                                                                                                                                                                                                                                    method delete

                                                                                                                                                                                                                                    delete: (key: string) => void;

                                                                                                                                                                                                                                      method get

                                                                                                                                                                                                                                      get: (key: string, def?: T) => T | undefined;

                                                                                                                                                                                                                                        method has

                                                                                                                                                                                                                                        has: (key: string) => boolean;

                                                                                                                                                                                                                                          method set

                                                                                                                                                                                                                                          set: (key: string, value: T) => void;

                                                                                                                                                                                                                                            method size

                                                                                                                                                                                                                                            size: () => number;


                                                                                                                                                                                                                                              interface LengthFactory

                                                                                                                                                                                                                                              interface LengthFactory {}

                                                                                                                                                                                                                                                property length

                                                                                                                                                                                                                                                length: number;

                                                                                                                                                                                                                                                  property max

                                                                                                                                                                                                                                                  max: Point;

                                                                                                                                                                                                                                                    property min

                                                                                                                                                                                                                                                    min: Point;

                                                                                                                                                                                                                                                      property point

                                                                                                                                                                                                                                                      point: Point;

                                                                                                                                                                                                                                                        interface ParserParams

                                                                                                                                                                                                                                                        interface ParserParams {}

                                                                                                                                                                                                                                                          property qx

                                                                                                                                                                                                                                                          qx: number | null;

                                                                                                                                                                                                                                                            property qy

                                                                                                                                                                                                                                                            qy: number | null;

                                                                                                                                                                                                                                                              property x

                                                                                                                                                                                                                                                              x: number;

                                                                                                                                                                                                                                                                property x1

                                                                                                                                                                                                                                                                x1: number;

                                                                                                                                                                                                                                                                  property x2

                                                                                                                                                                                                                                                                  x2: number;

                                                                                                                                                                                                                                                                    property y

                                                                                                                                                                                                                                                                    y: number;

                                                                                                                                                                                                                                                                      property y1

                                                                                                                                                                                                                                                                      y1: number;

                                                                                                                                                                                                                                                                        property y2

                                                                                                                                                                                                                                                                        y2: number;

                                                                                                                                                                                                                                                                          interface PathBBox

                                                                                                                                                                                                                                                                          interface PathBBox {}

                                                                                                                                                                                                                                                                            property cx

                                                                                                                                                                                                                                                                            cx: number;

                                                                                                                                                                                                                                                                              property cy

                                                                                                                                                                                                                                                                              cy: number;

                                                                                                                                                                                                                                                                                property cz

                                                                                                                                                                                                                                                                                cz: number;

                                                                                                                                                                                                                                                                                  property height

                                                                                                                                                                                                                                                                                  height: number;

                                                                                                                                                                                                                                                                                    property width

                                                                                                                                                                                                                                                                                    width: number;

                                                                                                                                                                                                                                                                                      property x

                                                                                                                                                                                                                                                                                      x: number;

                                                                                                                                                                                                                                                                                        property x2

                                                                                                                                                                                                                                                                                        x2: number;

                                                                                                                                                                                                                                                                                          property y

                                                                                                                                                                                                                                                                                          y: number;

                                                                                                                                                                                                                                                                                            property y2

                                                                                                                                                                                                                                                                                            y2: number;

                                                                                                                                                                                                                                                                                              interface PathBBoxTotalLength

                                                                                                                                                                                                                                                                                              interface PathBBoxTotalLength extends PathBBox {}

                                                                                                                                                                                                                                                                                                property length

                                                                                                                                                                                                                                                                                                length: number;

                                                                                                                                                                                                                                                                                                  interface PathLengthFactoryOptions

                                                                                                                                                                                                                                                                                                  interface PathLengthFactoryOptions {}

                                                                                                                                                                                                                                                                                                    property bbox

                                                                                                                                                                                                                                                                                                    bbox: boolean;

                                                                                                                                                                                                                                                                                                      property length

                                                                                                                                                                                                                                                                                                      length: boolean;

                                                                                                                                                                                                                                                                                                        property sampleSize

                                                                                                                                                                                                                                                                                                        sampleSize: number;

                                                                                                                                                                                                                                                                                                          interface PointProperties

                                                                                                                                                                                                                                                                                                          interface PointProperties {}

                                                                                                                                                                                                                                                                                                            property closest

                                                                                                                                                                                                                                                                                                            closest: {
                                                                                                                                                                                                                                                                                                            x: number;
                                                                                                                                                                                                                                                                                                            y: number;

                                                                                                                                                                                                                                                                                                              property distance

                                                                                                                                                                                                                                                                                                              distance: number;

                                                                                                                                                                                                                                                                                                                property segment

                                                                                                                                                                                                                                                                                                                segment?: SegmentProperties;

                                                                                                                                                                                                                                                                                                                  interface SegmentLimits

                                                                                                                                                                                                                                                                                                                  interface SegmentLimits {}

                                                                                                                                                                                                                                                                                                                    property max

                                                                                                                                                                                                                                                                                                                    max: Point;

                                                                                                                                                                                                                                                                                                                      property min

                                                                                                                                                                                                                                                                                                                      min: Point;

                                                                                                                                                                                                                                                                                                                        interface SegmentProperties

                                                                                                                                                                                                                                                                                                                        interface SegmentProperties {}

                                                                                                                                                                                                                                                                                                                          property index

                                                                                                                                                                                                                                                                                                                          index: number;
                                                                                                                                                                                                                                                                                                                          • the segment index

                                                                                                                                                                                                                                                                                                                          property length

                                                                                                                                                                                                                                                                                                                          length: number;
                                                                                                                                                                                                                                                                                                                          • the segment length

                                                                                                                                                                                                                                                                                                                          property lengthAtSegment

                                                                                                                                                                                                                                                                                                                          lengthAtSegment: number;
                                                                                                                                                                                                                                                                                                                          • the length including the segment length

                                                                                                                                                                                                                                                                                                                          property segment

                                                                                                                                                                                                                                                                                                                          segment: PathSegment;
                                                                                                                                                                                                                                                                                                                          • the segment

                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                          [key: string]: any;

                                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                                            type AbsoluteArray

                                                                                                                                                                                                                                                                                                                            type AbsoluteArray = [MSegment, ...AbsoluteSegment[]];

                                                                                                                                                                                                                                                                                                                              type AbsoluteCommand

                                                                                                                                                                                                                                                                                                                              type AbsoluteCommand =
                                                                                                                                                                                                                                                                                                                              | MCommand
                                                                                                                                                                                                                                                                                                                              | LCommand
                                                                                                                                                                                                                                                                                                                              | VCommand
                                                                                                                                                                                                                                                                                                                              | HCommand
                                                                                                                                                                                                                                                                                                                              | ZCommand
                                                                                                                                                                                                                                                                                                                              | CCommand
                                                                                                                                                                                                                                                                                                                              | SCommand
                                                                                                                                                                                                                                                                                                                              | QCommand
                                                                                                                                                                                                                                                                                                                              | TCommand
                                                                                                                                                                                                                                                                                                                              | ACommand;

                                                                                                                                                                                                                                                                                                                                type AbsoluteSegment

                                                                                                                                                                                                                                                                                                                                type AbsoluteSegment =
                                                                                                                                                                                                                                                                                                                                | MSegment
                                                                                                                                                                                                                                                                                                                                | LSegment
                                                                                                                                                                                                                                                                                                                                | VSegment
                                                                                                                                                                                                                                                                                                                                | HSegment
                                                                                                                                                                                                                                                                                                                                | CSegment
                                                                                                                                                                                                                                                                                                                                | SSegment
                                                                                                                                                                                                                                                                                                                                | QSegment
                                                                                                                                                                                                                                                                                                                                | TSegment
                                                                                                                                                                                                                                                                                                                                | ASegment
                                                                                                                                                                                                                                                                                                                                | ZSegment;

                                                                                                                                                                                                                                                                                                                                  type aCommand

                                                                                                                                                                                                                                                                                                                                  type aCommand = 'a';

                                                                                                                                                                                                                                                                                                                                    type ACommand

                                                                                                                                                                                                                                                                                                                                    type ACommand = 'A';

                                                                                                                                                                                                                                                                                                                                      type ArcSegment

                                                                                                                                                                                                                                                                                                                                      type ArcSegment = ASegment | aSegment;

                                                                                                                                                                                                                                                                                                                                        type aSegment

                                                                                                                                                                                                                                                                                                                                        type aSegment = [aCommand, number, number, number, number, number, number, number];

                                                                                                                                                                                                                                                                                                                                          type ASegment

                                                                                                                                                                                                                                                                                                                                          type ASegment = [ACommand, number, number, number, number, number, number, number];

                                                                                                                                                                                                                                                                                                                                            type cCommand

                                                                                                                                                                                                                                                                                                                                            type cCommand = 'c';

                                                                                                                                                                                                                                                                                                                                              type CCommand

                                                                                                                                                                                                                                                                                                                                              type CCommand = 'C';

                                                                                                                                                                                                                                                                                                                                                type CloseSegment

                                                                                                                                                                                                                                                                                                                                                type CloseSegment = ZSegment | zSegment;

                                                                                                                                                                                                                                                                                                                                                  type cSegment

                                                                                                                                                                                                                                                                                                                                                  type cSegment = [cCommand, number, number, number, number, number, number];

                                                                                                                                                                                                                                                                                                                                                    type CSegment

                                                                                                                                                                                                                                                                                                                                                    type CSegment = [CCommand, number, number, number, number, number, number];

                                                                                                                                                                                                                                                                                                                                                      type CubicSegment

                                                                                                                                                                                                                                                                                                                                                      type CubicSegment = CSegment | cSegment;

                                                                                                                                                                                                                                                                                                                                                        type CurveArray

                                                                                                                                                                                                                                                                                                                                                        type CurveArray = [MSegment, ...CSegment[]];

                                                                                                                                                                                                                                                                                                                                                          type hCommand

                                                                                                                                                                                                                                                                                                                                                          type hCommand = 'h';

                                                                                                                                                                                                                                                                                                                                                            type HCommand

                                                                                                                                                                                                                                                                                                                                                            type HCommand = 'H';

                                                                                                                                                                                                                                                                                                                                                              type HorLineSegment

                                                                                                                                                                                                                                                                                                                                                              type HorLineSegment = HSegment | hSegment;

                                                                                                                                                                                                                                                                                                                                                                type hSegment

                                                                                                                                                                                                                                                                                                                                                                type hSegment = [hCommand, number];

                                                                                                                                                                                                                                                                                                                                                                  type HSegment

                                                                                                                                                                                                                                                                                                                                                                  type HSegment = [HCommand, number];

                                                                                                                                                                                                                                                                                                                                                                    type lCommand

                                                                                                                                                                                                                                                                                                                                                                    type lCommand = 'l';

                                                                                                                                                                                                                                                                                                                                                                      type LCommand

                                                                                                                                                                                                                                                                                                                                                                      type LCommand = 'L';

                                                                                                                                                                                                                                                                                                                                                                        type LineSegment

                                                                                                                                                                                                                                                                                                                                                                        type LineSegment = LSegment | lSegment;

                                                                                                                                                                                                                                                                                                                                                                          type lSegment

                                                                                                                                                                                                                                                                                                                                                                          type lSegment = [lCommand, number, number];

                                                                                                                                                                                                                                                                                                                                                                            type LSegment

                                                                                                                                                                                                                                                                                                                                                                            type LSegment = [LCommand, number, number];

                                                                                                                                                                                                                                                                                                                                                                              type mCommand

                                                                                                                                                                                                                                                                                                                                                                              type mCommand = 'm';

                                                                                                                                                                                                                                                                                                                                                                                type MCommand

                                                                                                                                                                                                                                                                                                                                                                                type MCommand = 'M';

                                                                                                                                                                                                                                                                                                                                                                                  type MoveSegment

                                                                                                                                                                                                                                                                                                                                                                                  type MoveSegment = MSegment | mSegment;

                                                                                                                                                                                                                                                                                                                                                                                    type mSegment

                                                                                                                                                                                                                                                                                                                                                                                    type mSegment = [mCommand, number, number];

                                                                                                                                                                                                                                                                                                                                                                                      type MSegment

                                                                                                                                                                                                                                                                                                                                                                                      type MSegment = [MCommand, number, number];

                                                                                                                                                                                                                                                                                                                                                                                        type NormalArray

                                                                                                                                                                                                                                                                                                                                                                                        type NormalArray = [MSegment, ...NormalSegment[]];

                                                                                                                                                                                                                                                                                                                                                                                          type NormalSegment

                                                                                                                                                                                                                                                                                                                                                                                          type NormalSegment = MSegment | LSegment | CSegment | QSegment | ASegment | ZSegment;

                                                                                                                                                                                                                                                                                                                                                                                            type PathArray

                                                                                                                                                                                                                                                                                                                                                                                            type PathArray = [MSegment | mSegment, ...PathSegment[]];

                                                                                                                                                                                                                                                                                                                                                                                              type PathCommand

                                                                                                                                                                                                                                                                                                                                                                                              type PathCommand = AbsoluteCommand | RelativeCommand;

                                                                                                                                                                                                                                                                                                                                                                                                type PathSegment

                                                                                                                                                                                                                                                                                                                                                                                                type PathSegment =
                                                                                                                                                                                                                                                                                                                                                                                                | MoveSegment
                                                                                                                                                                                                                                                                                                                                                                                                | LineSegment
                                                                                                                                                                                                                                                                                                                                                                                                | VertLineSegment
                                                                                                                                                                                                                                                                                                                                                                                                | HorLineSegment
                                                                                                                                                                                                                                                                                                                                                                                                | CloseSegment
                                                                                                                                                                                                                                                                                                                                                                                                | CubicSegment
                                                                                                                                                                                                                                                                                                                                                                                                | ShortCubicSegment
                                                                                                                                                                                                                                                                                                                                                                                                | QuadSegment
                                                                                                                                                                                                                                                                                                                                                                                                | ShortQuadSegment
                                                                                                                                                                                                                                                                                                                                                                                                | ArcSegment;

                                                                                                                                                                                                                                                                                                                                                                                                  type Point

                                                                                                                                                                                                                                                                                                                                                                                                  type Point = {
                                                                                                                                                                                                                                                                                                                                                                                                  x: number;
                                                                                                                                                                                                                                                                                                                                                                                                  y: number;

                                                                                                                                                                                                                                                                                                                                                                                                    type PolygonArray

                                                                                                                                                                                                                                                                                                                                                                                                    type PolygonArray = [MSegment, ...LSegment[], ZSegment];

                                                                                                                                                                                                                                                                                                                                                                                                      type PolylineArray

                                                                                                                                                                                                                                                                                                                                                                                                      type PolylineArray = [MSegment, ...LSegment[]];

                                                                                                                                                                                                                                                                                                                                                                                                        type qCommand

                                                                                                                                                                                                                                                                                                                                                                                                        type qCommand = 'q';

                                                                                                                                                                                                                                                                                                                                                                                                          type QCommand

                                                                                                                                                                                                                                                                                                                                                                                                          type QCommand = 'Q';

                                                                                                                                                                                                                                                                                                                                                                                                            type qSegment

                                                                                                                                                                                                                                                                                                                                                                                                            type qSegment = [qCommand, number, number, number, number];

                                                                                                                                                                                                                                                                                                                                                                                                              type QSegment

                                                                                                                                                                                                                                                                                                                                                                                                              type QSegment = [QCommand, number, number, number, number];

                                                                                                                                                                                                                                                                                                                                                                                                                type QuadSegment

                                                                                                                                                                                                                                                                                                                                                                                                                type QuadSegment = QSegment | qSegment;

                                                                                                                                                                                                                                                                                                                                                                                                                  type RelativeArray

                                                                                                                                                                                                                                                                                                                                                                                                                  type RelativeArray = [MSegment, ...RelativeSegment[]];

                                                                                                                                                                                                                                                                                                                                                                                                                    type RelativeCommand

                                                                                                                                                                                                                                                                                                                                                                                                                    type RelativeCommand =
                                                                                                                                                                                                                                                                                                                                                                                                                    | mCommand
                                                                                                                                                                                                                                                                                                                                                                                                                    | lCommand
                                                                                                                                                                                                                                                                                                                                                                                                                    | vCommand
                                                                                                                                                                                                                                                                                                                                                                                                                    | hCommand
                                                                                                                                                                                                                                                                                                                                                                                                                    | zCommand
                                                                                                                                                                                                                                                                                                                                                                                                                    | cCommand
                                                                                                                                                                                                                                                                                                                                                                                                                    | sCommand
                                                                                                                                                                                                                                                                                                                                                                                                                    | qCommand
                                                                                                                                                                                                                                                                                                                                                                                                                    | tCommand
                                                                                                                                                                                                                                                                                                                                                                                                                    | aCommand;

                                                                                                                                                                                                                                                                                                                                                                                                                      type RelativeSegment

                                                                                                                                                                                                                                                                                                                                                                                                                      type RelativeSegment =
                                                                                                                                                                                                                                                                                                                                                                                                                      | mSegment
                                                                                                                                                                                                                                                                                                                                                                                                                      | lSegment
                                                                                                                                                                                                                                                                                                                                                                                                                      | vSegment
                                                                                                                                                                                                                                                                                                                                                                                                                      | hSegment
                                                                                                                                                                                                                                                                                                                                                                                                                      | cSegment
                                                                                                                                                                                                                                                                                                                                                                                                                      | sSegment
                                                                                                                                                                                                                                                                                                                                                                                                                      | qSegment
                                                                                                                                                                                                                                                                                                                                                                                                                      | tSegment
                                                                                                                                                                                                                                                                                                                                                                                                                      | aSegment
                                                                                                                                                                                                                                                                                                                                                                                                                      | zSegment;

                                                                                                                                                                                                                                                                                                                                                                                                                        type sCommand

                                                                                                                                                                                                                                                                                                                                                                                                                        type sCommand = 's';

                                                                                                                                                                                                                                                                                                                                                                                                                          type SCommand

                                                                                                                                                                                                                                                                                                                                                                                                                          type SCommand = 'S';

                                                                                                                                                                                                                                                                                                                                                                                                                            type ShortCubicSegment

                                                                                                                                                                                                                                                                                                                                                                                                                            type ShortCubicSegment = SSegment | sSegment;

                                                                                                                                                                                                                                                                                                                                                                                                                              type ShortQuadSegment

                                                                                                                                                                                                                                                                                                                                                                                                                              type ShortQuadSegment = TSegment | tSegment;

                                                                                                                                                                                                                                                                                                                                                                                                                                type ShortSegment

                                                                                                                                                                                                                                                                                                                                                                                                                                type ShortSegment =
                                                                                                                                                                                                                                                                                                                                                                                                                                | VertLineSegment
                                                                                                                                                                                                                                                                                                                                                                                                                                | HorLineSegment
                                                                                                                                                                                                                                                                                                                                                                                                                                | ShortCubicSegment
                                                                                                                                                                                                                                                                                                                                                                                                                                | ShortQuadSegment
                                                                                                                                                                                                                                                                                                                                                                                                                                | CloseSegment;

                                                                                                                                                                                                                                                                                                                                                                                                                                  type sSegment

                                                                                                                                                                                                                                                                                                                                                                                                                                  type sSegment = [sCommand, number, number, number, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                    type SSegment

                                                                                                                                                                                                                                                                                                                                                                                                                                    type SSegment = [SCommand, number, number, number, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                      type tCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                      type tCommand = 't';

                                                                                                                                                                                                                                                                                                                                                                                                                                        type TCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                        type TCommand = 'T';

                                                                                                                                                                                                                                                                                                                                                                                                                                          type tSegment

                                                                                                                                                                                                                                                                                                                                                                                                                                          type tSegment = [tCommand, number, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSegment

                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSegment = [TCommand, number, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                              type vCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                              type vCommand = 'v';

                                                                                                                                                                                                                                                                                                                                                                                                                                                type VCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                type VCommand = 'V';

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type VertLineSegment

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type VertLineSegment = vSegment | VSegment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type vSegment

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type vSegment = [vCommand, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VSegment

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VSegment = [VCommand, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type zCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type zCommand = 'z';

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ZCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ZCommand = 'Z';

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type zSegment

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type zSegment = [zCommand];

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ZSegment

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ZSegment = [ZCommand];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Package Files (138)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dependencies (3)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dev Dependencies (21)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                No peer dependencies.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@antv/util.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <a href="https://www.jsdocs.io/package/@antv/util"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>