squarified 0.4.0 → 0.4.2

package/dist/index-BoUEaWVv.d.ts

@@ -0,0 +1,520 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Any = any
+
+type AnyObject = Record<keyof Any, Any>
+
+type NonNull = NonNullable<unknown>
+
+interface MatrixLoc {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+}
+declare class Matrix2D implements MatrixLoc {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+    constructor(loc?: Partial<MatrixLoc>);
+    create(loc: MatrixLoc): this;
+    transform(x: number, y: number, scaleX: number, scaleY: number, rotation: number, skewX: number, skewY: number): this;
+    translation(x: number, y: number): this;
+    scale(a: number, d: number): this;
+    private skew;
+    private roate;
+}
+
+declare const enum DisplayType {
+    Graph = "Graph",
+    Box = "Box",
+    Text = "Text",
+    RoundRect = "RoundRect",
+    Bitmap = "Bitmap"
+}
+declare abstract class Display {
+    parent: Display | null;
+    id: number;
+    matrix: Matrix2D;
+    abstract get __instanceOf__(): DisplayType;
+    constructor();
+    destory(): void;
+}
+interface GraphStyleSheet {
+    stroke: string;
+    opacity: number;
+    font: string;
+    lineWidth: number;
+}
+interface LocOptions {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+    rotation: number;
+    skewX: number;
+    skewY: number;
+}
+interface GraphOptions extends LocOptions {
+    [key: string]: unknown;
+}
+interface InstructionAssignMappings {
+    fillStyle: (arg: string) => void;
+    strokeStyle: (arg: string) => void;
+    font: (arg: string) => void;
+    lineWidth: (arg: number) => void;
+    textAlign: (arg: CanvasTextAlign) => void;
+    textBaseline: (arg: CanvasTextBaseline) => void;
+}
+interface InstructionWithFunctionCall extends CanvasDrawImage {
+    fillRect: (x: number, y: number, w: number, h: number) => void;
+    strokeRect: (x: number, y: number, w: number, h: number) => void;
+    fillText: (text: string, x: number, y: number, maxWidth?: number) => void;
+    beginPath: () => void;
+    moveTo: (x: number, y: number) => void;
+    arcTo: (x1: number, y1: number, x2: number, y2: number, radius: number) => void;
+    closePath: () => void;
+    fill: () => void;
+    stroke: () => void;
+}
+type Mod<T extends InstructionAssignMappings & InstructionWithFunctionCall = InstructionAssignMappings & InstructionWithFunctionCall, K extends keyof T = keyof T> = T[K] extends (...args: Any) => Any ? [K, Parameters<T[K]>] : never;
+interface Instruction extends InstructionAssignMappings, InstructionWithFunctionCall {
+    mods: Array<{
+        mod: Mod;
+        type: number;
+    }>;
+}
+declare function createInstruction(): Instruction;
+declare abstract class S extends Display {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+    rotation: number;
+    skewX: number;
+    skewY: number;
+    constructor(options?: Partial<LocOptions>);
+}
+declare abstract class Graph extends S {
+    instruction: ReturnType<typeof createInstruction>;
+    __options__: Partial<LocOptions>;
+    __widget__: Any;
+    abstract style: GraphStyleSheet;
+    constructor(options?: Partial<GraphOptions>);
+    abstract create(): void;
+    abstract clone(): Graph;
+    abstract get __shape__(): DisplayType;
+    render(ctx: CanvasRenderingContext2D): void;
+    get __instanceOf__(): DisplayType.Graph;
+}
+
+declare abstract class C extends Display {
+    elements: Display[];
+    constructor();
+    abstract get __instanceOf__(): DisplayType;
+    add(...elements: Display[]): void;
+    remove(...elements: Display[]): void;
+    destory(): void;
+}
+declare class Box extends C {
+    elements: Display[];
+    constructor();
+    add(...elements: Display[]): void;
+    remove(...elements: Display[]): void;
+    destory(): void;
+    get __instanceOf__(): DisplayType.Box;
+    clone(): Box;
+}
+
+interface RGBColor {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}
+interface HLSColor {
+    h: number;
+    l: number;
+    s: number;
+    a?: number;
+}
+interface ColorDecoratorResultHLS {
+    mode?: 'hsl';
+    desc: HLSColor;
+}
+interface ColorDecoratorResultRGB {
+    mode: 'rgb';
+    desc: RGBColor;
+}
+type ColorDecoratorResult = ColorDecoratorResultHLS | ColorDecoratorResultRGB;
+
+type RectStyleOptions = GraphStyleSheet & {
+    fill: ColorDecoratorResult;
+    padding?: number;
+};
+type RectOptions = GraphOptions & {
+    style: Partial<RectStyleOptions>;
+};
+type RoundRectStyleOptions = RectStyleOptions & {
+    radius: number;
+};
+type RoundRectOptions = RectOptions & {
+    style: Partial<RoundRectStyleOptions>;
+};
+declare class RoundRect extends Graph {
+    style: Required<RoundRectStyleOptions>;
+    constructor(options?: Partial<RoundRectOptions>);
+    get __shape__(): DisplayType;
+    create(): void;
+    clone(): RoundRect;
+}
+
+interface TextOptions extends Omit<GraphOptions, 'style'> {
+    text: string;
+    style: Partial<GraphStyleSheet & {
+        font: string;
+        textAlign: CanvasTextAlign;
+        baseline: CanvasTextBaseline;
+        lineWidth: number;
+        fill: string;
+    }>;
+}
+declare class Text extends Graph {
+    text: string;
+    style: Required<TextOptions['style']>;
+    constructor(options?: Partial<TextOptions>);
+    create(): void;
+    clone(): Text;
+    get __shape__(): DisplayType;
+}
+
+type EventCallback<P = Any[]> = P extends Any[] ? (...args: P) => Any : never;
+type DefaultEventDefinition = Record<string, EventCallback>;
+type BindThisParameter<T, C = unknown> = T extends (...args: infer P) => infer R ? (this: C, ...args: P) => R : never;
+interface EventCollectionData<EvtDefinition extends DefaultEventDefinition, C = unknown> {
+    name: string;
+    handler: BindThisParameter<EvtDefinition[keyof EvtDefinition], C>;
+    ctx: C;
+    silent: boolean;
+}
+type EventCollections<EvtDefinition extends DefaultEventDefinition> = Record<keyof EvtDefinition, EventCollectionData<EvtDefinition>[]>;
+declare class Event<EvtDefinition extends DefaultEventDefinition = DefaultEventDefinition> {
+    eventCollections: EventCollections<EvtDefinition>;
+    constructor();
+    on<C, Evt extends keyof EvtDefinition>(evt: Evt, handler: BindThisParameter<EvtDefinition[Evt], unknown extends C ? this : C>, c?: C): void;
+    off(evt: keyof EvtDefinition, handler?: BindThisParameter<EvtDefinition[keyof EvtDefinition], unknown>): void;
+    silent(evt: keyof EvtDefinition, handler?: BindThisParameter<EvtDefinition[keyof EvtDefinition], unknown>): void;
+    active(evt: keyof EvtDefinition, handler?: BindThisParameter<EvtDefinition[keyof EvtDefinition], unknown>): void;
+    emit(evt: keyof EvtDefinition, ...args: Parameters<EvtDefinition[keyof EvtDefinition]>): void;
+    bindWithContext<C>(c: C): (evt: keyof EvtDefinition, handler: BindThisParameter<EvtDefinition[keyof EvtDefinition], unknown extends C ? this : C>) => void;
+}
+
+interface RenderViewportOptions {
+    width: number;
+    height: number;
+    devicePixelRatio: number;
+    shaow?: boolean;
+}
+declare class Render {
+    options: RenderViewportOptions;
+    private container;
+    constructor(to: HTMLElement, options: RenderViewportOptions);
+    clear(width: number, height: number): void;
+    get canvas(): HTMLCanvasElement;
+    get ctx(): CanvasRenderingContext2D;
+    initOptions(userOptions?: Partial<RenderViewportOptions>): void;
+    destory(): void;
+}
+
+type ApplyTo = string | HTMLElement;
+declare class Schedule<D extends DefaultEventDefinition = DefaultEventDefinition> extends Box {
+    render: Render;
+    to: HTMLElement;
+    event: Event<D>;
+    constructor(to: ApplyTo, renderOptions?: Partial<RenderViewportOptions>);
+    update(): void;
+    execute(render: Render, graph?: Display): void;
+}
+
+type Series<T> = {
+    max: T;
+    min: T;
+};
+interface GraphicLayout {
+    rectRadius?: number;
+    rectGap?: number;
+    titleAreaHeight?: Series<number>;
+}
+interface GraphicFont {
+    color?: string;
+    fontSize?: Series<number>;
+    family?: string;
+}
+interface GraphicConfig {
+    layout?: GraphicLayout;
+    font?: GraphicFont;
+}
+/**
+ * @deprecated `TreemapInstanceAPI` don't provide methods anymore. (will be removed in the future versions)
+ * Keep it only for migration convenience
+ */
+interface TreemapInstanceAPI {
+    /**
+     * @deprecated don't call this method anymore.
+     */
+    zoom: () => void;
+}
+
+declare function sortChildrenByKey<T extends AnyObject, K extends keyof T = 'weight'>(data: T[], ...keys: K[]): T[];
+declare function c2m<T extends AnyObject & {
+    groups: Any[];
+}, K extends keyof T>(data: T, key: K, modifier?: (data: T) => T): T & {
+    weight: number;
+};
+declare function flatten<T extends AnyObject & {
+    groups: T[];
+}>(data: T[]): Omit<T, "groups">[];
+type Module = ReturnType<typeof c2m>;
+declare function bindParentForModule<T extends Module & {
+    parent: Module;
+}>(modules: Module[], parent?: Module): T[];
+type NativeModule = ReturnType<typeof bindParentForModule>[number] & {
+    id: string;
+    parent: NativeModule | null;
+    groups: NativeModule[];
+};
+declare function getNodeDepth(node: NativeModule): number;
+declare function visit<T extends AnyObject>(data: T[], fn: (data: T) => boolean | void): T | null;
+declare function findRelativeNode(p: {
+    x: number;
+    y: number;
+}, layoutNodes: LayoutModule[]): LayoutModule | null;
+declare function findRelativeNodeById(id: string, layoutNodes: LayoutModule[]): LayoutModule | null;
+
+type Rect = {
+    w: number;
+    h: number;
+    x: number;
+    y: number;
+};
+type SquarifiedModule = NativeModule & {
+    parent: SquarifiedModule | null;
+    groups: SquarifiedModule[];
+    isCombinedNode?: boolean;
+    originalNodeCount?: number;
+    originalNodes?: SquarifiedModule[];
+};
+interface LayoutModule {
+    node: SquarifiedModule;
+    layout: [number, number, number, number];
+    children: LayoutModule[];
+    config: {
+        titleAreaHeight: number;
+        rectGap: number;
+        rectRadius: number;
+    };
+}
+declare function squarify(data: NativeModule[], rect: Rect, config: Required<GraphicLayout>, scale?: number): LayoutModule[];
+
+declare function hashCode(str: string): number;
+declare function perferNumeric(s: string | number): boolean;
+declare function noop(): void;
+declare function createRoundBlock(x: number, y: number, width: number, height: number, style?: Partial<RoundRectStyleOptions>): RoundRect;
+declare function createTitleText(text: string, x: number, y: number, font: string, color: string): Text;
+declare const raf: ((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame;
+declare function createCanvasElement(): HTMLCanvasElement;
+declare function applyCanvasTransform(ctx: CanvasRenderingContext2D, matrix: Matrix2D, dpr: number): void;
+interface InheritedCollections<T = object> {
+    name: string;
+    fn: (instance: T) => void;
+}
+type MixinHelp<T extends InheritedCollections[]> = T extends [infer L, ...infer R] ? L extends InheritedCollections ? R extends InheritedCollections[] ? {
+    [key in L['name']]: L['fn'];
+} & MixinHelp<R> : Record<string, never> : Record<string, never> : Record<string, never>;
+declare function mixin<T extends AnyObject, const I extends InheritedCollections<T>[]>(app: T, methods: I): T & MixinHelp<I>;
+interface InheritedCollectionsWithParamter<T = Any> {
+    name: string;
+    fn: (instance: T) => (...args: Any[]) => Any;
+}
+type MixinHelpWithParamater<T extends InheritedCollectionsWithParamter[]> = T extends [infer L, ...infer R] ? L extends InheritedCollectionsWithParamter ? R extends InheritedCollectionsWithParamter[] ? {
+    [key in L['name']]: ReturnType<L['fn']>;
+} & MixinHelpWithParamater<R> : Record<string, never> : Record<string, never> : Record<string, never>;
+declare function mixinWithParams<T extends AnyObject, const M extends InheritedCollectionsWithParamter<T>[]>(app: T, methods: M): T & MixinHelpWithParamater<M>;
+type Tail<T extends string[]> = T extends readonly [infer _, ...infer Rest] ? Rest : [];
+type StrJoin<T extends string[], F extends string> = T extends readonly [] ? '' : T extends readonly [infer FF] ? FF : `${F}${StrJoin<Tail<T>, T[0]>}`;
+declare function prettyStrJoin<T extends string[]>(...s: T): StrJoin<T, T[0]>;
+declare function isMacOS(): boolean;
+declare function typedForIn<T extends NonNullable<object>>(obj: T, callback: (key: keyof T, value: T[keyof T]) => void): void;
+declare function stackMatrixTransform(graph: S, e: number, f: number, scale: number): void;
+declare function stackMatrixTransformWithGraphAndLayer(graphs: Display[], e: number, f: number, scale: number): void;
+interface EffectOptions {
+    duration: number;
+    onStop?: () => void;
+    deps?: Array<() => boolean>;
+}
+declare function smoothFrame(callback: (progress: number, cleanup: () => void) => void, opts: EffectOptions): void;
+interface DuckE {
+    which: number;
+}
+declare function isScrollWheelOrRightButtonOnMouseupAndDown<E extends DuckE = DuckE>(e: E): boolean;
+declare class DefaultMap<K, V> extends Map<K, V> {
+    private defaultFactory;
+    constructor(defaultFactory: () => V, entries?: readonly [K, V][] | null);
+    get(key: K): V;
+    getOrInsert(key: K, value?: V): V;
+}
+
+interface PluginContext {
+    resolveModuleById: (id: string) => LayoutModule | null;
+    getPluginMetadata: <M = Any>(pluginName: string) => M | null;
+    get instance(): Component;
+}
+interface OnModuleInitResult {
+    colorMappings?: ColorMappings;
+}
+interface PluginHooks {
+    onLoad?: (this: PluginContext, treemapContext: BasicTreemapInstance, domEvent: DOMEvent) => void | Record<string, Any>;
+    onModuleInit?: (this: PluginContext, modules: LayoutModule[]) => OnModuleInitResult | void;
+    onDOMEventTriggered?: <N extends DOMEventType>(this: PluginContext, name: N, event: DOMEventMetadata<N>, module: LayoutModule | null, domEvent: DOMEvent) => void;
+    onResize?: (this: PluginContext, domEvent: DOMEvent) => void;
+    onDispose?: (this: PluginContext) => void;
+}
+type BasicPluginHooks = Pick<PluginHooks, 'onLoad' | 'onDOMEventTriggered' | 'onResize' | 'onDispose'>;
+type CascadedPluginHooks = Pick<PluginHooks, 'onModuleInit'>;
+interface Plugin<T = string, M = Any> extends PluginHooks {
+    name: T;
+    meta?: M;
+}
+declare function definePlugin<T extends string = string, M = Any, P extends Plugin<T, M> = Plugin<T, M>>(plugin: P): P;
+declare class PluginDriver<T extends Component> {
+    private plugins;
+    private pluginContext;
+    constructor(component: T);
+    use(plugin: Plugin): void;
+    runHook<K extends keyof BasicPluginHooks>(hookName: K, ...args: Parameters<NonNullable<BasicPluginHooks[K]>>): void;
+    cascadeHook<K extends keyof CascadedPluginHooks>(hookName: K, ...args: Parameters<NonNullable<CascadedPluginHooks[K]>>): ReturnType<NonNullable<CascadedPluginHooks[K]>>;
+    getPluginMetadata<M = Any>(pluginName: string): M | null;
+}
+
+type ColorMappings = Record<string, ColorDecoratorResult>;
+declare class Component extends Schedule {
+    pluginDriver: PluginDriver<Component>;
+    data: NativeModule[];
+    colorMappings: ColorMappings;
+    rectLayer: Box;
+    textLayer: Box;
+    layoutNodes: LayoutModule[];
+    config: GraphicConfig;
+    caches: DefaultMap<string, number>;
+    constructor(config: GraphicConfig, ...args: ConstructorParameters<typeof Schedule>);
+    private drawBroundRect;
+    private drawText;
+    draw(flush?: boolean, update?: boolean): void;
+    cleanup(): void;
+    calculateLayoutNodes(data: NativeModule[], rect: Parameters<typeof squarify>[1], scale?: number): LayoutModule[];
+}
+
+declare const DOM_EVENTS: readonly ["click", "mousedown", "mousemove", "mouseup", "mouseover", "mouseout", "wheel", "contextmenu"];
+type DOMEventType = typeof DOM_EVENTS[number];
+interface DOMEventMetadata<T extends keyof HTMLElementEventMap = Any> {
+    native: HTMLElementEventMap[T];
+    readonly kind: T;
+}
+type DOMEventCallback<T extends DOMEventType> = (metadata: DOMEventMetadata<T>) => void;
+interface PrimitiveEventMetadata<T extends keyof HTMLElementEventMap> {
+    native: HTMLElementEventMap[T];
+    module: LayoutModule | null;
+}
+type ExposedEventCallback<T extends DOMEventType> = (metadata: PrimitiveEventMetadata<T>) => void;
+type ExposedEventDefinition = {
+    [K in DOMEventType]: BindThisParameter<ExposedEventCallback<K>, TreemapInstanceAPI>;
+};
+interface ExposedEventMethods<C = TreemapInstanceAPI, D = ExposedEventDefinition> {
+    on<Evt extends keyof D>(evt: Evt, handler: BindThisParameter<D[Evt], unknown extends C ? this : C>): void;
+    off<Evt extends keyof D>(evt: keyof D, handler?: BindThisParameter<D[Evt], unknown extends C ? this : C>): void;
+}
+type DOMEVEntDefinition<API = unknown> = {
+    [K in DOMEventType]: BindThisParameter<DOMEventCallback<K>, API>;
+} & {
+    __exposed__: (type: DOMEventType, metadata: PrimitiveEventMetadata<DOMEventType>) => void;
+};
+declare const STATE_TRANSITION: {
+    readonly IDLE: "IDLE";
+    readonly PRESSED: "PRESSED";
+    readonly DRAGGING: "DRAGGING";
+    readonly CLICK_POTENTIAL: "CLICK_POTENTIAL";
+    readonly ZOOMING: "ZOOMING";
+    readonly MOVE: "MOVE";
+    readonly SCALING: "SCALING";
+};
+type StateTransition = typeof STATE_TRANSITION[keyof typeof STATE_TRANSITION];
+declare class StateManager {
+    current: StateTransition;
+    constructor();
+    canTransition(to: StateTransition): boolean;
+    transition(to: StateTransition): boolean;
+    reset(): void;
+    isInState(state: StateTransition): boolean;
+}
+declare function isWheelEvent(metadata: DOMEventMetadata<DOMEventType>): metadata is DOMEventMetadata<'wheel'>;
+declare function isMouseEvent(metadata: DOMEventMetadata<DOMEventType>): metadata is DOMEventMetadata<'mousedown' | 'mouseup' | 'mousemove'>;
+declare function isClickEvent(metadata: DOMEventMetadata<DOMEventType>): metadata is DOMEventMetadata<'click'>;
+declare function isContextMenuEvent(metadata: DOMEventMetadata<DOMEventType>): metadata is DOMEventMetadata<'contextmenu'>;
+declare function bindDOMEvent(el: HTMLElement, evt: DOMEventType, dom: DOMEvent): {
+    evt: "click" | "mousedown" | "mousemove" | "mouseup" | "mouseover" | "mouseout" | "wheel" | "contextmenu";
+    handler: (e: unknown) => void;
+};
+declare class DOMEvent extends Event<DOMEVEntDefinition> {
+    domEvents: Array<ReturnType<typeof bindDOMEvent>>;
+    el: HTMLElement | null;
+    currentModule: LayoutModule | null;
+    component: Component;
+    matrix: Matrix2D;
+    stateManager: StateManager;
+    constructor(component: Component);
+    destory(): void;
+    private dispatch;
+    findRelativeNode(e: DOMEventMetadata): LayoutModule | null;
+}
+
+interface CreateTreemapOptions<P extends Plugin[]> {
+    plugins: P;
+    graphic?: GraphicConfig;
+}
+interface TreemapOptions {
+    data: Module[];
+}
+type UnionToIntersection<U> = (U extends Any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type PluginMixins<P extends readonly Plugin[]> = UnionToIntersection<{
+    [K in keyof P]: P[K] extends {
+        onLoad?: (ctx: Any, component: Any) => infer R;
+    } ? R extends object ? R : NonNull : NonNull;
+}[number]>;
+interface BasicTreemapInstance {
+    init: (el: HTMLElement) => void;
+    dispose: () => void;
+    resize: () => void;
+    setOptions: (options: TreemapOptions) => void;
+}
+declare function createTreemap<const P extends readonly Plugin[]>(options?: CreateTreemapOptions<P>): ({
+    init: (el: HTMLElement) => void;
+    dispose: () => void;
+    resize: () => void;
+    setOptions: (options: TreemapOptions) => void;
+} & {
+    on: () => (evt: string, handler: (this: TreemapInstanceAPI, ...args: any[]) => any) => void;
+} & {
+    off: () => (evt: string, handler?: ((this: unknown, ...args: any[]) => any) | undefined) => void;
+} & Record<string, never>) & BasicTreemapInstance & ExposedEventMethods & PluginMixins<P>;
+type TreemapInstance<P extends readonly Plugin[]> = BasicTreemapInstance & ExposedEventMethods & PluginMixins<P>;
+
+export { smoothFrame as $, perferNumeric as A, noop as F, createRoundBlock as H, createTitleText as I, raf as J, createCanvasElement as K, applyCanvasTransform as O, mixin as R, mixinWithParams as V, prettyStrJoin as W, isMacOS as X, typedForIn as Y, stackMatrixTransform as Z, stackMatrixTransformWithGraphAndLayer as _, isScrollWheelOrRightButtonOnMouseupAndDown as a0, DefaultMap as a1, DOMEvent as b, createTreemap as d, c2m as f, findRelativeNode as g, findRelativeNodeById as h, flatten as i, getNodeDepth as j, definePlugin as m, isClickEvent as q, isContextMenuEvent as r, sortChildrenByKey as s, isMouseEvent as t, isWheelEvent as u, visit as v, hashCode as z };
+export type { BasicTreemapInstance as B, ColorMappings as C, DOMEventType as D, ExposedEventCallback as E, GraphicLayout as G, LayoutModule as L, Module as M, NativeModule as N, PluginContext as P, InheritedCollections as Q, Series as S, TreemapOptions as T, InheritedCollectionsWithParamter as U, DOMEventMetadata as a, CreateTreemapOptions as c, TreemapInstance as e, Plugin as k, PluginHooks as l, ExposedEventDefinition as n, ExposedEventMethods as o, PrimitiveEventMetadata as p, GraphicFont as w, GraphicConfig as x, TreemapInstanceAPI as y };