@pacem/pacem-foundation 1.0.0-abel

package/typings/index.d.ts

@@ -0,0 +1,458 @@
+export declare interface Angle {
+    vertex: Point;
+    start: Point;
+    end: Point;
+}
+
+export declare class Angle {
+    static isAngle(obj: any): obj is Angle;
+    /**
+     * Returns the angle span in radians.
+     * Clockwise angles are positive, counterclockwise angles are negative.
+     */
+    static value(angle: Angle): number;
+    /**
+     * Returns the angle (in radians) given the angle vertex and two points belonging to the rays that combine to build the angle sides.
+     * Clockwise angles are positive, counterclockwise angles are negative.
+     * @param vertex Angle vertex
+     * @param start Point belonging to the start side
+     * @param end Point belonging to the end side
+     * @returns Angle span in radians [-pi, pi]
+     */
+    static angleBetween(vertex: Point, start: Point, end: Point): number;
+}
+
+export declare class Arrays {
+    static range(items: number): number[];
+    static range(min: number, max: number, items?: number): number[];
+    static chunkify(source: any[], size: number): any[][];
+}
+
+export declare class Blobs {
+    static blobToDataURL(blob: Blob): Promise<string>;
+    private static _b64ToUint8Array;
+    static base64ToBlob(bstr: string, options?: BlobPropertyBag): Blob;
+    static dataURLToBlob(dataurl: string): Blob;
+    static blobToText(blob: Blob, encoding?: string): Promise<string>;
+    static textToBlob(content: string): Blob;
+    static textToBlob(content: string, type: string): Blob;
+    static textToBlob(content: string, type: string, charset: BlobTextEncoding): Blob;
+    static textToBlob(content: string, type: string, charset: BlobTextEncoding, bom: boolean): Blob;
+    static textToBlob(content: string, type: string, charset: BlobTextEncoding, bom: boolean, lossyChar: number): Blob;
+}
+
+declare type BlobTextEncoding = 'utf-8' | 'utf-16' | 'utf-16be' | 'utf-16le' | 'iso-8859-1' | 'ascii';
+
+export declare interface CieXYZ {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    a?: number;
+}
+
+export declare class Colors {
+    static WCAG_MINIMUM_CONTRAST: number;
+    static WCAG_NORMAL_TEXT_CONTRAST: number;
+    static WCAG_SAFE_CONTRAST: number;
+    private static _clampRGB;
+    private static _normalize;
+    static parse(clr: string): Rgba;
+    static hsl(rgb: Rgba): Hsla;
+    static cieXYZ(rgb: Rgba): CieXYZ;
+    static cieXYZ(hsl: Hsla): CieXYZ;
+    static rgb(hsl: Hsla): Rgba;
+    static rgb(cieXYZ: CieXYZ): Rgba;
+    static stringify(hsl: Hsla, precision?: number): string;
+    static stringify(rgb: Rgba, hex?: boolean): string;
+    /**
+     * Contrast ratio betwen two colors (useful for accessibility assessments). Output range: 1 (no-contrast) to 21 (maximum contrast)
+     */
+    static contrastRatio(clr1: Rgba | Hsla, clr2: Rgba | Hsla): number;
+    /**
+     * Returns the relative luminance as of WCAG specs.
+     */
+    static luminance(clr: Rgba | Hsla): number;
+    static lighten(rgb: Rgba, amount?: number): Rgba;
+    static lighten(rgb: Hsla, amount?: number): Hsla;
+    static darken(rgb: Rgba, amount?: number): Rgba;
+    static darken(rgb: Hsla, amount?: number): Hsla;
+    static saturate(rgb: Rgba, amount?: number): Rgba;
+    static saturate(rgb: Hsla, amount?: number): Hsla;
+    static desaturate(rgb: Rgba, amount?: number): Rgba;
+    static desaturate(rgb: Hsla, amount?: number): Hsla;
+    static interpolate(rgb1: Rgba, rgb2: Rgba, weight1?: number, weight2?: number): Rgba;
+    static interpolate(hsl1: Hsla, hsl2: Hsla, weight1?: number, weight2?: number): Hsla;
+    static interpolate(cieXYZ1: CieXYZ, cieXYZ2: CieXYZ, weight1?: number, weight2?: number): CieXYZ;
+}
+
+export declare namespace Compile {
+    export {
+        Markdown,
+        Rule,
+        Token,
+        Lexer,
+        Renderer,
+        Parser
+    }
+}
+
+declare namespace Compile_2 {
+    export {
+        Rule,
+        Token,
+        Lexer,
+        Renderer,
+        Parser
+    }
+}
+
+export declare class Dates {
+    static parse(input: string | Date | number): Date;
+    static isLeapYear(year: number): boolean;
+    static daysInMonth(year: number, month: number): number;
+    /**
+     * Gets whether a date is an `Invalid Date` or not.
+     * @param date
+     */
+    static isDate(date: any): date is Date;
+    /**
+     * Returns the date-only equaivalent of a provided datetime.
+     * @param datetime
+     */
+    static dateOnly(datetime: Date): Date;
+    static addMonths(input: Date, value: number): Date;
+    static addDays(input: Date, value: number): Date;
+    static daysBetween(start: Date, end: Date): number;
+}
+
+export declare class DeepMerger {
+    private constructor();
+    static merge<S extends PlainObject, T extends PlainObject>(source: S, target?: T): T & S;
+}
+
+export declare function detect(userAgent?: string): {
+    name: string;
+    version: any;
+};
+
+export declare type DiffMode = 'char' | 'word' | 'line';
+
+export declare type DiffToken = {
+    type: DiffTokenType;
+    value: string;
+};
+
+export declare type DiffTokenType = '=' | '-' | '+';
+
+declare type ExtraRule = (Compile_2.Rule | {
+    rule: Compile_2.Rule;
+    type: 'block' | 'inline';
+} | {
+    rule: Compile_2.Rule;
+    type: 'code';
+    lang: string;
+});
+
+/** Grants undo/redo functionalities for given state. */
+export declare class HistoryService<TState = any> {
+    #private;
+    constructor(state: TState, maxlength?: number);
+    /**
+     * Gets the current state.
+     */
+    get current(): TState;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    /** Sets the maximum number of stored states, queue + stack.
+     */
+    set maxlength(v: number);
+    undo(): void;
+    redo(): void;
+    push(state: TState): void;
+    reset(): void;
+}
+
+export declare interface Hsla {
+    readonly h: number;
+    readonly s: number;
+    readonly l: number;
+    a?: number;
+}
+
+export declare class Imaging {
+    static loadImage(url: string): Promise<Blob>;
+    static resizeImage(img: Blob, width: number, height: number, options?: ImagingResizeOptions): Promise<Blob>;
+    static resizeImage(img: string, width: number, height: number, options?: ImagingResizeOptions): Promise<Blob>;
+}
+
+export declare type ImagingResizeOptions = {
+    mode?: 'contain' | 'cover' | 'stretch';
+    align?: 'left' | 'center' | 'right';
+    valign?: 'top' | 'middle' | 'bottom';
+    quality?: number;
+    type?: string;
+    background?: string;
+};
+
+export declare class Keys {
+    #private;
+    static uniqueId(): number;
+    static uniqueCode(): string;
+    static randomString(length: number): string;
+}
+
+declare interface Lexer {
+    tokenize(input: string, grammar: Rule[]): Token[];
+}
+
+export declare namespace Markdown {
+    export {
+        ExtraRule,
+        Parser_2 as Parser
+    }
+}
+
+/** Represents the typical matrix for 2D graphics (css, svg, ...) */
+export declare interface Matrix2D {
+    readonly a: number;
+    readonly b: number;
+    readonly c: number;
+    readonly d: number;
+    readonly e: number;
+    readonly f: number;
+}
+
+export declare class Matrix2D {
+    static isIdentity(m: Matrix2D): boolean;
+    static get identity(): Matrix2D;
+    static copy(m: Matrix2D): Matrix2D;
+    static scale(m: Matrix2D, s: number): Matrix2D;
+    static scale(m: Matrix2D, sx: number, sy: number): Matrix2D;
+    static translate(m: Matrix2D, t: Point): Matrix2D;
+    static rotate(m: Matrix2D, rad: number): Matrix2D;
+    static multiply(m: Matrix2D, f: number): Matrix2D;
+    static multiply(p: Point, m: Matrix2D): Point;
+    static multiply(m1: Matrix2D, m2: Matrix2D): Matrix2D;
+    static det(m: Matrix2D): number;
+    static invert(m: Matrix2D): Matrix2D;
+    static toComponents(m: Matrix2D, transformOrigin?: Point): {
+        scaleX: number;
+        scaleY: number;
+        rotation: number;
+        translation: Point;
+    };
+    /**
+     * Returns the matrix that transforms the triangle defined by the points p0, p1, p2 into the triangle defined by the points q0, q1, q2.
+     * @param param0 Triangle defined by the points p0, p1, p2 (before transformation).
+     * @param param1 Triangle defined by the points q0, q1, q2 (after transformation).
+     * @returns Transformation matrix.
+     */
+    static fromTransform([p0, p1, p2]: [Point, Point, Point], [q0, q1, q2]: [Point, Point, Point]): Matrix2D;
+    /**
+     * Returns whether two matrices are equal to each other, within a certain precision (number of decimal digits).
+     * @param m1
+     * @param m2
+     * @param precision
+     * @returns
+     */
+    static areClose(m1: Matrix2D, m2: Matrix2D, precision?: number): boolean;
+}
+
+export declare class NullChecker {
+    static isNull(o: any): o is null | undefined;
+    static isEmpty(o: any): boolean;
+    static isNullOrEmpty(o: any): boolean;
+}
+
+export declare class Numbers {
+    static round(x: number, step?: number): number;
+    static log(x: number, base: number): number;
+    static rebase(v: number | string, from: number, to: number): string;
+}
+
+export declare function parseAsNumericalArray(input: string): number[];
+
+declare class Parser {
+    private _lexer;
+    constructor(_lexer?: Lexer);
+    parse(input: string, grammar: Rule[], renderer: Renderer): string;
+}
+
+declare class Parser_2 extends Compile_2.Parser {
+    toHtml(input: string, extraGrammar?: ExtraRule[], extraItemRenderer?: (token: Compile_2.Token, allTokens: Compile_2.Token[]) => string): string;
+    tokenize(input: string, extraGrammar?: ExtraRule[]): any[];
+    parse(input: string): string;
+    parse(input: string, renderer: Compile_2.Renderer): string;
+    parse(input: string, grammar: Compile_2.Rule[]): string;
+    parse(input: string, grammar: Compile_2.Rule[], renderer: Compile_2.Renderer): string;
+}
+
+declare type PlainObject = Record<string, unknown>;
+
+export declare interface Point {
+    x: number;
+    y: number;
+}
+
+export declare class Point {
+    static parse(pt: string): Point;
+    static isPoint(obj: any): obj is Point;
+    /**
+     * Computes the distance between two points.
+     * @param p1 Point 1
+     * @param p2 Point 2
+     */
+    static distance(p1: Point, p2: Point): number;
+    /**
+     * Subtracts a point p from another and returns the resulting vector.
+     * @param p Point to subtract
+     * @param from Point to be subtracted from
+     */
+    static subtract(p: Point, from: Point): Point;
+    /**
+     * Adds a set of points together and returns the resulting vector.
+     * @param points Points to add
+     */
+    static add(...points: Point[]): Point;
+    /**
+     * Memberwise multiplication.
+     * @param p Original Point object
+     * @param f Factor
+     * @returns New Point object.
+     */
+    static multiply(p: Point, f: number): Point;
+}
+
+export declare interface Rect extends Point, Size {
+}
+
+export declare class Rect {
+    static parse(rect: string): Rect;
+    static isRect(obj: any): obj is Rect;
+    private static _stretch;
+    private static _contain;
+    private static _cover;
+    private static _align;
+    /**
+     * Computes the 2D matrix that transforms one rect into another.
+     * @param a Rect from
+     * @param b Rect to
+     * @param mode Transformation mode
+     * @param align Horizontal alignment
+     * @param valign Vertical alignment
+     */
+    static findTransform(a: Rect, b: Rect, mode?: 'contain' | 'cover' | 'stretch', align?: 'left' | 'center' | 'right', valign?: 'top' | 'middle' | 'bottom'): Matrix2D;
+    /**
+     * Computes the intersection rect among a set of provided rects.
+     * @param rects Rects to intersect
+     */
+    static intersect(...rects: Rect[]): Rect;
+    /**
+     * Returns the minimum rect that contains all the provided points.
+     * @param points Points to contain
+     */
+    static expand(...points: Point[]): Rect;
+    /**
+     * Returns the minimum rect that contains all the provided points.
+     * @param rect Starting rect
+     * @param points Points to contain
+     */
+    static expand(rect: Rect, ...points: Point[]): Rect;
+}
+
+declare interface Renderer {
+    render: (tree: Token[]) => string;
+}
+
+export declare interface Rgba {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    a?: number;
+}
+
+declare interface Rule {
+    exec: (input: string, lexer?: Lexer) => Token[];
+}
+
+export declare interface Size {
+    width: number;
+    height: number;
+}
+
+export declare class Size {
+    static parse(sz: string): Size;
+    static isSize(obj: any): obj is Size;
+}
+
+export declare class Strings {
+    /** @deprecated Use String.prototype.padStart() instead. */
+    static leftPad(v: any, targetLength: number, padChar: string): string;
+    static format(template: string, ...args: any[]): string;
+    static diff(a: string, b: string, mode?: DiffMode): DiffToken[];
+    static hash(input: string, algo?: HashAlgorithmIdentifier): Promise<string>;
+}
+
+declare interface Token {
+    readonly index?: number;
+    readonly type: string;
+    readonly raw: string;
+    readonly text: string;
+    readonly tokens?: Token[];
+}
+
+declare global {
+    interface Number {
+        isCloseTo(other: number, precision?: number): boolean;
+        roundoff(precision?: number): number;
+        clamp(min: number, max: number): any;
+        toBase62(): string;
+        toBase36(): string;
+    }
+}
+
+declare global {
+    interface Array<T> {
+        moveWithin(from: number, to: number): void;
+        /** Checks content equality between arrays. */
+        equalsContent(other: T[]): boolean;
+        cloneFrom(other: T[]): void;
+        union(other: T[]): T[];
+        distinct(): T[];
+    }
+}
+
+
+declare global {
+    namespace Pacem {
+        export {
+            Angle,
+            Arrays,
+            Blobs,
+            CieXYZ,
+            Colors,
+            Compile,
+            Dates,
+            DeepMerger,
+            detect,
+            DiffMode,
+            DiffToken,
+            DiffTokenType,
+            HistoryService,
+            Hsla,
+            Imaging,
+            ImagingResizeOptions,
+            Keys,
+            Markdown,
+            Matrix2D,
+            NullChecker,
+            Numbers,
+            parseAsNumericalArray,
+            Point,
+            Rect,
+            Rgba,
+            Size,
+            Strings
+        };
+    }
+}