squarified 0.3.7 → 0.4.0

package/dist/index.d.mts

@@ -3,350 +3,618 @@ 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;
-}
-
-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 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 Canvas {
-    canvas: HTMLCanvasElement;
-    ctx: CanvasRenderingContext2D;
-    constructor(options: RenderViewportOptions);
-    setOptions(options: RenderViewportOptions): void;
-}
-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;
-}
-
-declare const DOM_EVENTS: readonly ["click", "mousedown", "mousemove", "mouseup", "mouseover", "mouseout", "wheel"];
-type DOMEventType = typeof DOM_EVENTS[number];
-interface DOMLoc {
-    x: number;
-    y: number;
-}
-interface DOMEventMetadata<T extends keyof HTMLElementEventMap = Any> {
-    native: HTMLElementEventMap[T];
-    loc: DOMLoc;
-}
-type DOMEventCallback<T extends DOMEventType> = (metadata: DOMEventMetadata<T>) => void;
-type DOMEventDefinition<API = unknown> = {
-    [K in DOMEventType]: BindThisParameter<DOMEventCallback<K>, API>;
-};
-
-declare abstract class Cache {
-    abstract key: string;
-    abstract get state(): boolean;
-    abstract flush(...args: never): void;
-    abstract destroy(): void;
-}
-declare class RenderCache extends Canvas implements Cache {
-    key: string;
-    private $memory;
-    constructor(opts: RenderViewportOptions);
-    get state(): boolean;
-    flush(treemap: TreemapLayout, matrix?: Matrix2D): void;
-    destroy(): void;
-}
-declare class FontCache implements Cache {
-    key: string;
-    private fonts;
-    ellispsis: Record<string, number>;
-    constructor();
-    get state(): boolean;
-    flush(treemap: TreemapLayout, matrix?: Matrix2D): void;
-    destroy(): void;
-    queryFontById(id: string, byDefault: () => number): number;
-}
-
-type ColorMappings = Record<string, ColorDecoratorResult>;
-type Rect = {
-    w: number;
-    h: number;
-};
-type Series<T> = {
-    max: T;
-    min: T;
-};
-interface RenderColor {
-    mappings: ColorMappings;
-}
-interface RenderLayout {
-    titleAreaHeight: Series<number>;
-    rectBorderRadius: number;
-    rectBorderWidth: number;
-    rectGap: number;
-}
-interface RenderFont {
-    color: string;
-    fontSize: Series<number>;
-    fontFamily: string;
-}
-interface RenderDecorator {
-    color: RenderColor;
-    layout: RenderLayout;
-    font: RenderFont;
-}
-declare const defaultLayoutOptions: {
-    titleAreaHeight: {
-        max: number;
-        min: number;
-    };
-    rectGap: number;
-    rectBorderRadius: number;
-    rectBorderWidth: number;
-};
-declare const defaultFontOptions: {
-    color: string;
-    fontSize: {
-        max: number;
-        min: number;
-    };
-    fontFamily: string;
-};
-declare function presetDecorator(app: TreemapLayout): 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;
-    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 LayoutModule = {
-    node: NativeModule;
-    layout: [number, number, number, number];
-    children: LayoutModule[];
-    decorator: {
-        titleHeight: number;
-        rectBorderRadius: number;
-        rectGap: number;
-        rectBorderWidth: number;
-    };
-};
-
-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;
-}
-declare const INTERNAL_EVENT_MAPPINGS: {
-    readonly ON_ZOOM: 1;
-    readonly ON_CLEANUP: 3;
-};
-type InternalEventType = typeof INTERNAL_EVENT_MAPPINGS[keyof typeof INTERNAL_EVENT_MAPPINGS];
-interface InternalEventMappings {
-    [INTERNAL_EVENT_MAPPINGS.ON_ZOOM]: (node: LayoutModule) => void;
-    [INTERNAL_EVENT_MAPPINGS.ON_CLEANUP]: () => void;
-}
-type InternalEventDefinition = {
-    [key in InternalEventType]: InternalEventMappings[key];
-};
-
-interface TreemapOptions {
-    data: Module[];
-}
-type UseKind = 'decorator';
-interface App {
-    init: (el: HTMLElement) => void;
-    dispose: () => void;
-    setOptions: (options: TreemapOptions) => void;
-    resize: () => void;
-    use: (using: UseKind, register: (app: TreemapLayout) => void) => void;
-    zoom: (id: string) => void;
-}
-/**
- * This interface isn't stable it might be remove at next few versions.
- * If you want set custom decorator pls see 'presetDecorator' for details.
- */
-type unstable_use = (app: TreemapLayout) => void;
-declare class Highlight extends Schedule<DOMEventDefinition> {
-    reset(): void;
-    get canvas(): HTMLCanvasElement;
-    setZIndexForHighlight(zIndex?: string): void;
-    init(): void;
-}
-declare class TreemapLayout extends Schedule<InternalEventDefinition> {
-    data: NativeModule[];
-    layoutNodes: LayoutModule[];
-    decorator: RenderDecorator;
-    bgBox: Box;
-    fgBox: Box;
-    highlight: Highlight;
-    renderCache: RenderCache;
-    fontCache: FontCache;
-    constructor(...args: ConstructorParameters<typeof Schedule>);
-    drawBackgroundNode(node: LayoutModule): void;
-    drawForegroundNode(node: LayoutModule): void;
-    reset(refresh?: boolean): void;
-    get api(): {
-        zoom: (node: LayoutModule | null) => void;
-    };
-}
-declare function createTreemap(): App & ExposedEventMethods;
-type TreemapInstanceAPI = TreemapLayout['api'];
-
-/**
- * @deprecated compat `PrimitiveEvent` using `DOMEventType` replace it. (will be removed in the next three versions.)
- */
-type PrimitiveEvent = DOMEventType;
-/**
- * @deprecated compat `EventMethods` using `ExposedEventMethods` replace it. (will be removed in the next three versions.)
- */
-type EventMethods = ExposedEventMethods;
-/**
- * @deprecated compat `PrimitiveEventCallback` using `ExposedEventCallback` replace it. (will be removed in the next three versions.)
- */
-type PrimitiveEventCallback<T extends PrimitiveEvent> = ExposedEventCallback<T>;
-/**
- * @deprecated compat `PrimitiveEventDefinition` using `ExposedEventDefinition` replace it. (will be removed in the next three versions.)
- */
-type PrimitiveEventDefinition = ExposedEventDefinition;
-
-export { TreemapLayout, c2m, createTreemap, defaultFontOptions, defaultLayoutOptions, findRelativeNode, findRelativeNodeById, flatten as flattenModule, getNodeDepth, presetDecorator, sortChildrenByKey, visit };
-export type { App, ColorMappings, DOMEventType, EventMethods, ExposedEventCallback, ExposedEventDefinition, ExposedEventMethods, LayoutModule, Module, NativeModule, PrimitiveEvent, PrimitiveEventCallback, PrimitiveEventDefinition, PrimitiveEventMetadata, Rect, RenderColor, RenderDecorator, RenderFont, RenderLayout, Series, TreemapInstanceAPI, TreemapOptions, unstable_use };
+export declare function applyCanvasTransform(ctx: CanvasRenderingContext2D, matrix: Matrix2D, dpr: number): void;
+
+declare type ApplyTo = string | HTMLElement;
+
+declare type BasicPluginHooks = Pick<PluginHooks, 'onLoad' | 'onDOMEventTriggered' | 'onResize' | 'onDispose'>;
+
+export declare interface BasicTreemapInstance {
+    init: (el: HTMLElement) => void;
+    dispose: () => void;
+    resize: () => void;
+    setOptions: (options: TreemapOptions) => void;
+}
+
+declare function bindDOMEvent(el: HTMLElement, evt: DOMEventType, dom: DOMEvent): {
+    evt: "click" | "mousedown" | "mousemove" | "mouseup" | "mouseover" | "mouseout" | "wheel" | "contextmenu";
+    handler: (e: unknown) => void;
+};
+
+declare function bindParentForModule<T extends Module & {
+    parent: Module;
+}>(modules: Module[], parent?: Module): T[];
+
+declare type BindThisParameter<T, C = unknown> = T extends (...args: infer P) => infer R ? (this: C, ...args: P) => R : never;
+
+declare class Box extends C {
+    elements: Display[];
+    constructor();
+    add(...elements: Display[]): void;
+    remove(...elements: Display[]): void;
+    destory(): void;
+    get __instanceOf__(): DisplayType.Box;
+    clone(): Box;
+}
+
+declare abstract class C extends Display {
+    elements: Display[];
+    constructor();
+    abstract get __instanceOf__(): DisplayType;
+    add(...elements: Display[]): void;
+    remove(...elements: Display[]): void;
+    destory(): void;
+}
+
+export declare function c2m<T extends AnyObject & {
+    groups: Any[];
+}, K extends keyof T>(data: T, key: K, modifier?: (data: T) => T): T & {
+    weight: number;
+};
+
+declare type CascadedPluginHooks = Pick<PluginHooks, 'onModuleInit'>;
+
+declare type ColorDecoratorResult = ColorDecoratorResultHLS | ColorDecoratorResultRGB;
+
+declare interface ColorDecoratorResultHLS {
+    mode?: 'hsl';
+    desc: HLSColor;
+}
+
+declare interface ColorDecoratorResultRGB {
+    mode: 'rgb';
+    desc: RGBColor;
+}
+
+declare 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[];
+}
+
+export declare function createCanvasElement(): HTMLCanvasElement;
+
+declare function createInstruction(): Instruction;
+
+export declare function createRoundBlock(x: number, y: number, width: number, height: number, style?: Partial<RoundRectStyleOptions>): RoundRect;
+
+export declare function createTitleText(text: string, x: number, y: number, font: string, color: string): Text_2;
+
+export declare function createTreemap<const P extends readonly Plugin_2[]>(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>;
+
+export declare interface CreateTreemapOptions<P extends Plugin_2[]> {
+    plugins: P;
+    graphic?: GraphicConfig;
+}
+
+declare type DefaultEventDefinition = Record<string, EventCallback>;
+
+export 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;
+}
+
+export declare function definePlugin<T extends string = string, M = Any, P extends Plugin_2<T, M> = Plugin_2<T, M>>(plugin: P): P;
+
+declare abstract class Display {
+    parent: Display | null;
+    id: number;
+    matrix: Matrix2D;
+    abstract get __instanceOf__(): DisplayType;
+    constructor();
+    destory(): void;
+}
+
+declare const enum DisplayType {
+    Graph = "Graph",
+    Box = "Box",
+    Text = "Text",
+    RoundRect = "RoundRect",
+    Bitmap = "Bitmap"
+}
+
+declare const DOM_EVENTS: readonly ["click", "mousedown", "mousemove", "mouseup", "mouseover", "mouseout", "wheel", "contextmenu"];
+
+declare class DOMEvent extends Event_2<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;
+}
+
+declare type DOMEventCallback<T extends DOMEventType> = (metadata: DOMEventMetadata<T>) => void;
+
+declare type DOMEVEntDefinition<API = unknown> = {
+    [K in DOMEventType]: BindThisParameter<DOMEventCallback<K>, API>;
+} & {
+    __exposed__: (type: DOMEventType, metadata: PrimitiveEventMetadata<DOMEventType>) => void;
+};
+
+declare interface DOMEventMetadata<T extends keyof HTMLElementEventMap = Any> {
+    native: HTMLElementEventMap[T];
+    readonly kind: T;
+}
+
+export declare type DOMEventType = typeof DOM_EVENTS[number];
+
+declare interface DuckE {
+    which: number;
+}
+
+declare interface EffectOptions {
+    duration: number;
+    onStop?: () => void;
+    deps?: Array<() => boolean>;
+}
+
+declare class Event_2<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;
+}
+
+declare type EventCallback<P = Any[]> = P extends Any[] ? (...args: P) => Any : never;
+
+declare interface EventCollectionData<EvtDefinition extends DefaultEventDefinition, C = unknown> {
+    name: string;
+    handler: BindThisParameter<EvtDefinition[keyof EvtDefinition], C>;
+    ctx: C;
+    silent: boolean;
+}
+
+declare type EventCollections<EvtDefinition extends DefaultEventDefinition> = Record<keyof EvtDefinition, EventCollectionData<EvtDefinition>[]>;
+
+export declare type ExposedEventCallback<T extends DOMEventType> = (metadata: PrimitiveEventMetadata<T>) => void;
+
+export declare type ExposedEventDefinition = {
+    [K in DOMEventType]: BindThisParameter<ExposedEventCallback<K>, TreemapInstanceAPI>;
+};
+
+export declare 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;
+}
+
+export declare function findRelativeNode(p: {
+    x: number;
+    y: number;
+}, layoutNodes: LayoutModule[]): LayoutModule | null;
+
+export declare function findRelativeNodeById(id: string, layoutNodes: LayoutModule[]): LayoutModule | null;
+
+export declare function flattenModule<T extends AnyObject & {
+    groups: T[];
+}>(data: T[]): Omit<T, "groups">[];
+
+export declare function getNodeDepth(node: NativeModule): number;
+
+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;
+}
+
+export declare interface GraphicConfig {
+    layout?: GraphicLayout;
+    font?: GraphicFont;
+}
+
+export declare interface GraphicFont {
+    color?: string;
+    fontSize?: Series<number>;
+    family?: string;
+}
+
+export declare interface GraphicLayout {
+    rectRadius?: number;
+    rectGap?: number;
+    titleAreaHeight?: Series<number>;
+}
+
+declare interface GraphOptions extends LocOptions {
+    [key: string]: unknown;
+}
+
+declare interface GraphStyleSheet {
+    stroke: string;
+    opacity: number;
+    font: string;
+    lineWidth: number;
+}
+
+export declare function hashCode(str: string): number;
+
+declare interface HLSColor {
+    h: number;
+    l: number;
+    s: number;
+    a?: number;
+}
+
+export declare interface InheritedCollections<T = object> {
+    name: string;
+    fn: (instance: T) => void;
+}
+
+export declare interface InheritedCollectionsWithParamter<T = Any> {
+    name: string;
+    fn: (instance: T) => (...args: Any[]) => Any;
+}
+
+declare interface Instruction extends InstructionAssignMappings, InstructionWithFunctionCall {
+    mods: Array<{
+        mod: Mod;
+        type: number;
+    }>;
+}
+
+declare 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;
+}
+
+declare 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;
+}
+
+export declare function isClickEvent(metadata: DOMEventMetadata<DOMEventType>): metadata is DOMEventMetadata<'click'>;
+
+export declare function isContextMenuEvent(metadata: DOMEventMetadata<DOMEventType>): metadata is DOMEventMetadata<'contextmenu'>;
+
+export declare function isMacOS(): boolean;
+
+export declare function isMouseEvent(metadata: DOMEventMetadata<DOMEventType>): metadata is DOMEventMetadata<'mousedown' | 'mouseup' | 'mousemove'>;
+
+export declare function isScrollWheelOrRightButtonOnMouseupAndDown<E extends DuckE = DuckE>(e: E): boolean;
+
+export declare function isWheelEvent(metadata: DOMEventMetadata<DOMEventType>): metadata is DOMEventMetadata<'wheel'>;
+
+export declare interface LayoutModule {
+    node: SquarifiedModule;
+    layout: [number, number, number, number];
+    children: LayoutModule[];
+    config: {
+        titleAreaHeight: number;
+        rectGap: number;
+        rectRadius: number;
+    };
+}
+
+declare interface LocOptions {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+    rotation: number;
+    skewX: number;
+    skewY: 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 interface MatrixLoc {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+}
+
+export declare function mixin<T extends AnyObject, const I extends InheritedCollections<T>[]>(app: T, methods: I): T & MixinHelp<I>;
+
+declare 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 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>;
+
+export declare function mixinWithParams<T extends AnyObject, const M extends InheritedCollectionsWithParamter<T>[]>(app: T, methods: M): T & MixinHelpWithParamater<M>;
+
+declare 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;
+
+export declare type Module = ReturnType<typeof c2m>;
+
+export declare type NativeModule = ReturnType<typeof bindParentForModule>[number] & {
+    id: string;
+    parent: NativeModule | null;
+    groups: NativeModule[];
+};
+
+export declare function noop(): void;
+
+declare interface OnModuleInitResult {
+    colorMappings?: ColorMappings;
+}
+
+export declare function perferNumeric(s: string | number): boolean;
+
+declare interface Plugin_2<T = string, M = Any> extends PluginHooks {
+    name: T;
+    meta?: M;
+}
+export { Plugin_2 as Plugin }
+
+export declare interface PluginContext {
+    resolveModuleById: (id: string) => LayoutModule | null;
+    getPluginMetadata: <M = Any>(pluginName: string) => M | null;
+    get instance(): Component;
+}
+
+declare class PluginDriver<T extends Component> {
+    private plugins;
+    private pluginContext;
+    constructor(component: T);
+    use(plugin: Plugin_2): 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;
+}
+
+export declare 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;
+}
+
+declare type PluginMixins<P extends readonly Plugin_2[]> = UnionToIntersection<{
+    [K in keyof P]: P[K] extends {
+        onLoad?: (ctx: Any, component: Any) => infer R;
+    } ? R extends object ? R : NonNull : NonNull;
+}[number]>;
+
+export declare function prettyStrJoin<T extends string[]>(...s: T): StrJoin<T, T[0]>;
+
+export declare interface PrimitiveEventMetadata<T extends keyof HTMLElementEventMap> {
+    native: HTMLElementEventMap[T];
+    module: LayoutModule | null;
+}
+
+export declare const raf: ((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame;
+
+declare type Rect = {
+    w: number;
+    h: number;
+    x: number;
+    y: number;
+};
+
+declare type RectOptions = GraphOptions & {
+    style: Partial<RectStyleOptions>;
+};
+
+declare type RectStyleOptions = GraphStyleSheet & {
+    fill: ColorDecoratorResult;
+    padding?: number;
+};
+
+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;
+}
+
+declare interface RenderViewportOptions {
+    width: number;
+    height: number;
+    devicePixelRatio: number;
+    shaow?: boolean;
+}
+
+declare interface RGBColor {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}
+
+declare class RoundRect extends Graph {
+    style: Required<RoundRectStyleOptions>;
+    constructor(options?: Partial<RoundRectOptions>);
+    get __shape__(): DisplayType;
+    create(): void;
+    clone(): RoundRect;
+}
+
+declare type RoundRectOptions = RectOptions & {
+    style: Partial<RoundRectStyleOptions>;
+};
+
+declare type RoundRectStyleOptions = RectStyleOptions & {
+    radius: number;
+};
+
+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 class Schedule<D extends DefaultEventDefinition = DefaultEventDefinition> extends Box {
+    render: Render;
+    to: HTMLElement;
+    event: Event_2<D>;
+    constructor(to: ApplyTo, renderOptions?: Partial<RenderViewportOptions>);
+    update(): void;
+    execute(render: Render, graph?: Display): void;
+}
+
+export declare type Series<T> = {
+    max: T;
+    min: T;
+};
+
+export declare function smoothFrame(callback: (progress: number, cleanup: () => void) => void, opts: EffectOptions): void;
+
+export declare function sortChildrenByKey<T extends AnyObject, K extends keyof T = 'weight'>(data: T[], ...keys: K[]): T[];
+
+declare type SquarifiedModule = NativeModule & {
+    parent: SquarifiedModule | null;
+    groups: SquarifiedModule[];
+    isCombinedNode?: boolean;
+    originalNodeCount?: number;
+    originalNodes?: SquarifiedModule[];
+};
+
+declare function squarify(data: NativeModule[], rect: Rect, config: Required<GraphicLayout>, scale?: number): LayoutModule[];
+
+export declare function stackMatrixTransform(graph: S, e: number, f: number, scale: number): void;
+
+export declare function stackMatrixTransformWithGraphAndLayer(graphs: Display[], e: number, f: number, scale: number): 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";
+};
+
+declare class StateManager {
+    current: StateTransition;
+    constructor();
+    canTransition(to: StateTransition): boolean;
+    transition(to: StateTransition): boolean;
+    reset(): void;
+    isInState(state: StateTransition): boolean;
+}
+
+declare type StateTransition = typeof STATE_TRANSITION[keyof typeof STATE_TRANSITION];
+
+declare type StrJoin<T extends string[], F extends string> = T extends readonly [] ? '' : T extends readonly [infer FF] ? FF : `${F}${StrJoin<Tail<T>, T[0]>}`;
+
+declare type Tail<T extends string[]> = T extends readonly [infer _, ...infer Rest] ? Rest : [];
+
+declare class Text_2 extends Graph {
+    text: string;
+    style: Required<TextOptions['style']>;
+    constructor(options?: Partial<TextOptions>);
+    create(): void;
+    clone(): Text_2;
+    get __shape__(): DisplayType;
+}
+
+declare interface TextOptions extends Omit<GraphOptions, 'style'> {
+    text: string;
+    style: Partial<GraphStyleSheet & {
+        font: string;
+        textAlign: CanvasTextAlign;
+        baseline: CanvasTextBaseline;
+        lineWidth: number;
+        fill: string;
+    }>;
+}
+
+/**
+ * @deprecated `TreemapInstanceAPI` don't provide methods anymore. (will be removed in the future versions)
+ * Keep it only for migration convenience
+ */
+export declare interface TreemapInstanceAPI {
+    /**
+     * @deprecated don't call this method anymore.
+     */
+    zoom: () => void;
+}
+
+export declare interface TreemapOptions {
+    data: Module[];
+}
+
+export declare function typedForIn<T extends NonNullable<object>>(obj: T, callback: (key: keyof T, value: T[keyof T]) => void): void;
+
+declare type UnionToIntersection<U> = (U extends Any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+export declare function visit<T extends AnyObject>(data: T[], fn: (data: T) => boolean | void): T | null;
+
+export { }