ados-rcm 1.1.513 → 1.1.515

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-resize/table-resize-scale.d.ts

@@ -0,0 +1,40 @@
+import { TableUp } from '../../table-up';
+import { TableResizeScaleOptions } from '../../utils';
+import { default as Quill } from 'quill';
+import { TableMainFormat, TableWrapperFormat } from '../../formats';
+export declare class TableResizeScale {
+    tableModule: TableUp;
+    table: HTMLElement;
+    quill: Quill;
+    scrollHandler: [HTMLElement, (e: Event) => void][];
+    tableMainBlot: TableMainFormat | null;
+    tableWrapperBlot: TableWrapperFormat | null;
+    bem: {
+        b: () => string;
+        be: (e?: string) => string;
+        bm: (m?: string) => string;
+        bem: (e?: string, m?: string) => string;
+        ns: (s?: string) => string;
+        bs: (s?: string) => string;
+        cv: (v?: string) => string;
+        is: (n: string) => string;
+    };
+    startX: number;
+    startY: number;
+    offset: number;
+    options: TableResizeScaleOptions;
+    root?: HTMLElement;
+    block?: HTMLElement;
+    resizeobserver: ResizeObserver;
+    constructor(tableModule: TableUp, table: HTMLElement, quill: Quill, options: Partial<TableResizeScaleOptions>);
+    updateWhenTextChange: () => void;
+    resolveOptions(options: Partial<TableResizeScaleOptions>): {
+        blockSize: number;
+    } & Partial<TableResizeScaleOptions>;
+    buildResizer(): void;
+    isTableOutofEditor(): boolean;
+    update(): void;
+    show(): void;
+    hide(): void;
+    destroy(): void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-resize/utils.d.ts

@@ -0,0 +1,2 @@
+import { TableMainFormat } from '../../formats';
+export declare const isTableAlignRight: (tableMainBlot: TableMainFormat) => boolean;

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-scrollbar.d.ts

@@ -0,0 +1,89 @@
+import { default as Quill } from 'quill';
+import { TableMainFormat } from '../formats';
+import { TableUp } from '../table-up';
+export declare class Scrollbar {
+    quill: Quill;
+    isVertical: boolean;
+    table: HTMLElement;
+    scrollbarContainer: HTMLElement;
+    minSize: number;
+    gap: number;
+    move: number;
+    cursorDown: boolean;
+    cursorLeave: boolean;
+    ratioY: number;
+    ratioX: number;
+    sizeWidth: string;
+    sizeHeight: string;
+    size: string;
+    thumbState: {
+        X: number;
+        Y: number;
+    };
+    ob: ResizeObserver;
+    container: HTMLElement;
+    scrollbar: HTMLElement;
+    thumb: HTMLElement;
+    scrollHandler: [HTMLElement, (e: Event) => void][];
+    propertyMap: {
+        readonly axis: 'Y';
+        readonly client: 'clientY';
+        readonly direction: 'top';
+        readonly offset: 'offsetHeight';
+        readonly scrollDirection: 'scrollTop';
+        readonly scrollSize: 'scrollHeight';
+        readonly size: 'height';
+    } | {
+        readonly axis: 'X';
+        readonly client: 'clientX';
+        readonly direction: 'left';
+        readonly offset: 'offsetWidth';
+        readonly scrollDirection: 'scrollLeft';
+        readonly scrollSize: 'scrollWidth';
+        readonly size: 'width';
+    };
+    bem: {
+        b: () => string;
+        be: (e?: string) => string;
+        bm: (m?: string) => string;
+        bem: (e?: string, m?: string) => string;
+        ns: (s?: string) => string;
+        bs: (s?: string) => string;
+        cv: (v?: string) => string;
+        is: (n: string) => string;
+    };
+    tableMainBlot: TableMainFormat;
+    constructor(quill: Quill, isVertical: boolean, table: HTMLElement, scrollbarContainer: HTMLElement);
+    update(): void;
+    setScrollbarPosition(): void;
+    calculateSize(): void;
+    createScrollbar(): HTMLDivElement;
+    containerScrollHandler(wrap: HTMLElement): void;
+    showScrollbar: (this: any) => void;
+    hideScrollbar: (this: any) => void;
+    hideScrollbarTransitionend: () => void;
+    destroy(): void;
+}
+export declare class TableVirtualScrollbar {
+    tableModule: TableUp;
+    table: HTMLElement;
+    quill: Quill;
+    scrollbarContainer: HTMLElement;
+    scrollbar: Scrollbar[];
+    bem: {
+        b: () => string;
+        be: (e?: string) => string;
+        bm: (m?: string) => string;
+        bem: (e?: string, m?: string) => string;
+        ns: (s?: string) => string;
+        bs: (s?: string) => string;
+        cv: (v?: string) => string;
+        is: (n: string) => string;
+    };
+    constructor(tableModule: TableUp, table: HTMLElement, quill: Quill);
+    updateWhenTextChange: () => void;
+    hide(): void;
+    show(): void;
+    update(): void;
+    destroy(): void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/modules/table-selection.d.ts

@@ -0,0 +1,87 @@
+import { EmitterSource, Range as TypeRange, default as Quill } from 'quill';
+import { TableUp } from '../table-up';
+import { InternalTableMenuModule, RelactiveRect, TableSelectionOptions } from '../utils';
+import { TableCellInnerFormat } from '../formats';
+export interface SelectionData {
+    anchorNode: Node | null;
+    anchorOffset: number;
+    focusNode: Node | null;
+    focusOffset: number;
+}
+export declare class TableSelection {
+    tableModule: TableUp;
+    quill: Quill;
+    options: TableSelectionOptions;
+    boundary: RelactiveRect | null;
+    startScrollX: number;
+    startScrollY: number;
+    selectedTableScrollX: number;
+    selectedTableScrollY: number;
+    selectedEditorScrollX: number;
+    selectedEditorScrollY: number;
+    selectedTds: TableCellInnerFormat[];
+    cellSelectWrap: HTMLElement;
+    cellSelect: HTMLElement;
+    dragging: boolean;
+    scrollHandler: [HTMLElement, (...args: any[]) => void][];
+    tableMenu?: InternalTableMenuModule;
+    resizeObserver: ResizeObserver;
+    table?: HTMLTableElement;
+    isDisplaySelection: boolean;
+    bem: {
+        b: () => string;
+        be: (e?: string) => string;
+        bm: (m?: string) => string;
+        bem: (e?: string, m?: string) => string;
+        ns: (s?: string) => string;
+        bs: (s?: string) => string;
+        cv: (v?: string) => string;
+        is: (n: string) => string;
+    };
+    lastSelection: SelectionData;
+    constructor(tableModule: TableUp, quill: Quill, options?: Partial<TableSelectionOptions>);
+    updateAfterEvent: () => void;
+    getFirstTextNode(dom: HTMLElement | Node): Node;
+    getLastTextNode(dom: HTMLElement | Node): Node;
+    getNodeTailOffset(node: Node): number;
+    quillSelectionChangeHandler: (range: TypeRange | null, _oldRange: TypeRange | null, source: EmitterSource) => void;
+    setSelectionData(selection: Selection, selectionData: SelectionData): void;
+    selectionDirectionUp(selection: SelectionData): boolean;
+    findWrapSelection(points: {
+        node: Node | null;
+        offset: number;
+    }[]): {
+        startNode: Node | null;
+        startOffset: number;
+        endNode: Node | null;
+        endOffset: number;
+    };
+    resolveOptions(options: Partial<TableSelectionOptions>): TableSelectionOptions;
+    selectionChangeHandler: () => void;
+    helpLinesInitial(): HTMLDivElement;
+    computeSelectedTds(startPoint: {
+        x: number;
+        y: number;
+    }, endPoint: {
+        x: number;
+        y: number;
+    }): TableCellInnerFormat[];
+    mouseDownHandler: (mousedownEvent: MouseEvent) => void;
+    updateWithSelectedTds(): void;
+    update(): void;
+    getQuillViewScroll(): {
+        x: number;
+        y: number;
+    };
+    getTableViewScroll(): {
+        x: number;
+        y: number;
+    };
+    setSelectionTable(table: HTMLTableElement | undefined): void;
+    removeCell: (e: KeyboardEvent) => void;
+    showDisplay(): void;
+    show(): void;
+    hideDisplay(): void;
+    hide(): void;
+    destroy(): void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/table-up.d.ts

@@ -0,0 +1,119 @@
+import { Range as TypeRange, default as Quill } from 'quill';
+import { Context } from 'quill/modules/keyboard';
+import { TableCellInnerFormat, TableMainFormat } from './formats';
+import { InternalModule, InternalTableSelectionModule, QuillThemePicker, TableConstantsData, TableTextOptions, TableUpOptions } from './utils';
+export declare function updateTableConstants(data: Partial<TableConstantsData>): void;
+export declare function defaultCustomSelect(tableModule: TableUp, picker: QuillThemePicker): HTMLDivElement;
+export declare class TableUp {
+    static moduleName: string;
+    static toolName: string;
+    static keyboradHandler: {
+        'forbid remove table by backspace': {
+            bindInHead: boolean;
+            key: string;
+            collapsed: boolean;
+            offset: number;
+            handler(this: {
+                quill: Quill;
+            }, range: TypeRange, context: Context): boolean;
+        };
+        'forbid remove table by delete': {
+            bindInHead: boolean;
+            key: string;
+            collapsed: boolean;
+            handler(this: {
+                quill: Quill;
+            }, range: TypeRange, context: Context): boolean;
+        };
+        'table up': {
+            bindInHead: boolean;
+            key: string;
+            collapsed: boolean;
+            format: "table-up-cell-inner"[];
+            handler(this: {
+                quill: Quill;
+            }, range: TypeRange, context: Context): boolean;
+        };
+        'table down': {
+            bindInHead: boolean;
+            key: string;
+            collapsed: boolean;
+            format: "table-up-cell-inner"[];
+            handler(this: {
+                quill: Quill;
+            }, range: TypeRange, context: Context): boolean;
+        };
+        'table caption break': {
+            bindInHead: boolean;
+            key: string;
+            shiftKey: null;
+            format: "table-up-caption"[];
+            handler(this: {
+                quill: Quill;
+            }, _range: TypeRange, _context: Context): boolean;
+        };
+    };
+    static register(): void;
+    quill: Quill;
+    options: TableUpOptions;
+    toolBox: HTMLDivElement;
+    selector?: HTMLElement;
+    table?: HTMLElement;
+    tableSelection?: InternalTableSelectionModule;
+    tableResize?: InternalModule;
+    tableScrollbar?: InternalModule;
+    tableAlign?: InternalModule;
+    tableResizeScale?: InternalModule;
+    get statics(): any;
+    constructor(quill: Quill, options: Partial<TableUpOptions>);
+    initialContainer(): HTMLDivElement;
+    addContainer(classes: string | HTMLElement): HTMLElement;
+    resolveOptions(options: Partial<TableUpOptions>): TableUpOptions;
+    resolveTexts(options: Partial<TableTextOptions>): {
+        fullCheckboxText: string;
+        customBtnText: string;
+        confirmText: string;
+        cancelText: string;
+        rowText: string;
+        colText: string;
+        notPositiveNumberError: string;
+        custom: string;
+        clear: string;
+        transparent: string;
+        perWidthInsufficient: string;
+        CopyCell: string;
+        CutCell: string;
+        InsertTop: string;
+        InsertRight: string;
+        InsertBottom: string;
+        InsertLeft: string;
+        MergeCell: string;
+        SplitCell: string;
+        DeleteRow: string;
+        DeleteColumn: string;
+        DeleteTable: string;
+        BackgroundColor: string;
+        BorderColor: string;
+    } & Partial<TableTextOptions>;
+    quillHack(): void;
+    showTableTools(table: HTMLElement): void;
+    hideTableTools(): void;
+    buildCustomSelect(customSelect: ((module: TableUp, picker: QuillThemePicker) => HTMLElement | Promise<HTMLElement>) | undefined, picker: QuillThemePicker): Promise<void>;
+    setCellAttrs(selectedTds: TableCellInnerFormat[], attr: string, value?: any, isStyle?: boolean): void;
+    getTextByCell(tds: TableCellInnerFormat[]): string;
+    getHTMLByCell(tds: TableCellInnerFormat[], isCut?: boolean): string;
+    insertTable(rows: number, columns: number): void;
+    calculateTableCellBorderWidth(): number;
+    fixUnusuaDeletelTable(tableBlot: TableMainFormat): void;
+    deleteTable(selectedTds: TableCellInnerFormat[]): void;
+    appendRow(selectedTds: TableCellInnerFormat[], isDown: boolean): void;
+    appendCol(selectedTds: TableCellInnerFormat[], isRight: boolean): void;
+    /**
+     * after insert or remove cell. handle cell colspan and rowspan merge
+     */
+    fixTableByRemove(tableBlot: TableMainFormat): void;
+    removeRow(selectedTds: TableCellInnerFormat[]): void;
+    removeCol(selectedTds: TableCellInnerFormat[]): void;
+    mergeCells(selectedTds: TableCellInnerFormat[]): void;
+    splitCell(selectedTds: TableCellInnerFormat[]): void;
+}

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/bem.d.ts

@@ -0,0 +1,18 @@
+export declare function createBEM(b: string, n?: string): {
+    /** n-b */
+    b: () => string;
+    /** n-b__e */
+    be: (e?: string) => string;
+    /** n-b--m */
+    bm: (m?: string) => string;
+    /** n-b__e--m */
+    bem: (e?: string, m?: string) => string;
+    /** n-s */
+    ns: (s?: string) => string;
+    /** n-b-s */
+    bs: (s?: string) => string;
+    /** --n-v */
+    cv: (v?: string) => string;
+    /** is-n */
+    is: (n: string) => string;
+};

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/blot-helper.d.ts

@@ -0,0 +1,25 @@
+import { Parchment as TypeParchment } from 'quill';
+import { TableBodyFormat, TableCellFormat, TableCellInnerFormat, TableColFormat, TableColgroupFormat, TableMainFormat, TableRowFormat, TableWrapperFormat } from '../formats';
+import { blotName } from './constants';
+import { Constructor } from './types';
+interface ParentBlotReturnMap {
+    [blotName.tableWrapper]: TableWrapperFormat;
+    [blotName.tableMain]: TableMainFormat;
+    [blotName.tableCol]: TableColFormat;
+    [blotName.tableColgroup]: TableColgroupFormat;
+    [blotName.tableBody]: TableBodyFormat;
+    [blotName.tableRow]: TableRowFormat;
+    [blotName.tableCell]: TableCellFormat;
+    [blotName.tableCellInner]: TableCellInnerFormat;
+}
+type ParentBlotReturn = {
+    [key: string]: TypeParchment.Parent;
+} & ParentBlotReturnMap;
+export declare function findParentBlot<T extends TypeParchment.Parent, U extends string = string>(blot: TypeParchment.Blot, targetBlotName: U): U extends keyof ParentBlotReturn ? ParentBlotReturn[U] : T;
+export declare function findParentBlots<T extends (keyof ParentBlotReturnMap | string)[]>(blot: TypeParchment.Blot, targetBlotNames: T): {
+    [K in keyof T]: ParentBlotReturn[T[K]];
+};
+export declare function findAllParentBlot(Blot: TypeParchment.Blot): Map<string, TypeParchment.Blot>;
+export declare function findChildBlot<T extends TypeParchment.BlotConstructor>(parent: TypeParchment.Parent, blot: T): InstanceType<T>[];
+export declare function mixinClass<T extends Constructor, U extends Constructor[]>(base: T, mixins: U): T & Omit<U[number], 'constructor' | keyof InstanceType<T>>;
+export {};

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/color.d.ts

@@ -0,0 +1,18 @@
+export interface HSB {
+    a: number;
+    b: number;
+    h: number;
+    s: number;
+}
+export interface RGB {
+    a: number;
+    b: number;
+    g: number;
+    r: number;
+}
+export declare function validateHSB(hsb: HSB): HSB;
+export declare function HEXtoRGB(hex: string): RGB;
+export declare function RGBtoHSB(rgb: RGB): HSB;
+export declare function HSBtoRGB(hsb: HSB): RGB;
+export declare function RGBtoHEX(rgb: RGB): string;
+export declare const HSBtoHEX: (hsb: HSB) => string;

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/components/button.d.ts

@@ -0,0 +1,6 @@
+interface ButtonOptions {
+    content: HTMLElement | string;
+    type: 'confirm' | 'default';
+}
+export declare function createButton(options?: Partial<ButtonOptions>): HTMLButtonElement;
+export {};

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/components/color-picker.d.ts

@@ -0,0 +1,6 @@
+interface ColorPickerOptions {
+    color: string;
+    onChange: (color: string) => void;
+}
+export declare function createColorPicker(options?: Partial<ColorPickerOptions>): HTMLDivElement;
+export {};

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/components/dialog.d.ts

@@ -0,0 +1,10 @@
+interface DialogOptions {
+    beforeClose?: () => void;
+    child?: HTMLElement;
+    target?: HTMLElement;
+}
+export declare function createDialog({ child, target, beforeClose }?: DialogOptions): {
+    dialog: HTMLDivElement;
+    close: () => void;
+};
+export {};

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/components/index.d.ts

@@ -0,0 +1,6 @@
+export * from './button';
+export * from './color-picker';
+export * from './dialog';
+export * from './input';
+export * from './table';
+export * from './tooltip';

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/components/input.d.ts

@@ -0,0 +1,15 @@
+interface InputOptions {
+    [key: string]: any;
+    max?: number;
+    min?: number;
+    type?: string;
+    value?: string;
+}
+export declare function createInputItem(label: string, options: InputOptions): {
+    item: HTMLDivElement;
+    input: HTMLInputElement;
+    errorTip: (msg: string) => {
+        removeError: () => void;
+    };
+};
+export {};

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/components/table/creator.d.ts

@@ -0,0 +1,10 @@
+import { TableCreatorTextOptions } from '../../types';
+interface TableCreatorOptions extends Omit<TableCreatorTextOptions, 'customBtnText'> {
+    col: number;
+    row: number;
+}
+export declare function showTableCreator(options?: Partial<TableCreatorOptions>): Promise<{
+    col: number;
+    row: number;
+}>;
+export {};

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/components/table/index.d.ts

@@ -0,0 +1,2 @@
+export * from './creator';
+export * from './select-box';

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/components/table/select-box.d.ts

@@ -0,0 +1,10 @@
+import { TableCreatorTextOptions } from '../../types';
+interface TableSelectOptions {
+    col: number;
+    customBtn: boolean;
+    onSelect: (row: number, col: number) => void;
+    row: number;
+    texts: Partial<TableCreatorTextOptions>;
+}
+export declare function createSelectBox(options?: Partial<TableSelectOptions>): HTMLDivElement;
+export {};

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/components/tooltip.d.ts

@@ -0,0 +1,18 @@
+export interface ToolTipOptions {
+    closed?: () => void;
+    container?: HTMLElement;
+    content?: HTMLElement;
+    delay?: number;
+    direction?: 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'right' | 'right-start' | 'right-end' | 'left' | 'left-start' | 'left-end';
+    msg?: string;
+    onClose?: (force?: boolean) => boolean;
+    onDestroy?: () => void;
+    onOpen?: (force?: boolean) => boolean;
+    type?: 'hover' | 'click';
+}
+export interface TooltipInstance {
+    destroy: () => void;
+    hide: (force?: boolean) => void;
+    show: (force?: boolean) => void;
+}
+export declare function createTooltip(target: HTMLElement, options?: ToolTipOptions): TooltipInstance | null;

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/constants.d.ts

@@ -0,0 +1,30 @@
+import { Parchment as TypeParchment } from 'quill';
+export declare const blotName: {
+    readonly container: "table-up-container";
+    readonly tableCaption: "table-up-caption";
+    readonly tableWrapper: "table-up";
+    readonly tableMain: "table-up-main";
+    readonly tableColgroup: "table-up-colgroup";
+    readonly tableCol: "table-up-col";
+    readonly tableBody: "table-up-body";
+    readonly tableRow: "table-up-row";
+    readonly tableCell: "table-up-cell";
+    readonly tableCellInner: "table-up-cell-inner";
+};
+export declare const tableUpSize: {
+    colMinWidthPre: number;
+    colMinWidthPx: number;
+    colDefaultWidth: number;
+    rowMinHeightPx: number;
+};
+export declare const tableUpEvent: {
+    AFTER_TABLE_RESIZE: string;
+};
+export declare const tableUpInternal: {
+    moduleName: string;
+};
+export declare const defaultColorMap: string[][];
+export declare const cssNamespace = "table-up";
+export declare const tableCantInsert: Set<string>;
+export declare const isForbidInTableBlot: (blot: TypeParchment.Blot) => boolean;
+export declare function isForbidInTable(current: TypeParchment.Blot): boolean;

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/index.d.ts

@@ -0,0 +1,13 @@
+export * from './bem';
+export * from './blot-helper';
+export * from './color';
+export * from './components';
+export * from './constants';
+export * from './is';
+export * from './position';
+export * from './resize-observer-helper';
+export * from './scroll-event-handle';
+export * from './transformer';
+export * from './transition-event-helper';
+export * from './types';
+export * from './utils';

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/is.d.ts

@@ -0,0 +1,7 @@
+export declare const isFunction: (val: unknown) => val is (...args: unknown[]) => unknown;
+export declare const isBoolean: (val: unknown) => val is boolean;
+export declare const isArray: (arg: any) => arg is any[];
+export declare const isString: (val: unknown) => val is string;
+export declare const isNumber: (val: unknown) => val is number;
+export declare const isObject: (val: unknown) => val is Record<any, any>;
+export declare const isValidCellspan: (val: unknown) => boolean;

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/position.d.ts

@@ -0,0 +1,14 @@
+import { RelactiveRect } from './types';
+export declare function isRectanglesIntersect<T extends Omit<RelactiveRect, 'width' | 'height'>>(a: T, b: T, tolerance?: number, edgeJudge?: boolean): boolean;
+export declare function getRelativeRect(targetRect: Omit<RelactiveRect, 'x1' | 'y1'>, container: HTMLElement): RelactiveRect;
+export declare function limitDomInViewPort(rect: {
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+}): {
+    left: number;
+    top: number;
+    leftLimited: boolean;
+    topLimited: boolean;
+};

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/resize-observer-helper.d.ts

@@ -0,0 +1,4 @@
+export interface CreateResizeObserverOptions {
+    ignoreFirstBind: boolean;
+}
+export declare function createResizeObserver(callback: (entries: ResizeObserverEntry[]) => void, options?: Partial<CreateResizeObserverOptions>): ResizeObserver;

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/scroll-event-handle.d.ts

@@ -0,0 +1,6 @@
+interface ScrollHandle {
+    scrollHandler: [HTMLElement, (e: Event) => void][];
+}
+export declare function addScrollEvent(this: ScrollHandle, dom: HTMLElement, handle: (e: Event) => void): void;
+export declare function clearScrollEvent(this: ScrollHandle): void;
+export {};

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/transformer.d.ts

@@ -0,0 +1,2 @@
+export declare function cssTextToObject(cssText: string): Record<string, string>;
+export declare function objectToCssText(obj: Record<string, any>): string;

package/dist/AModule/AComponents/AEditor/modules/tableUp/utils/transition-event-helper.d.ts

@@ -0,0 +1 @@
+export declare function handleIfTransitionend(domNode: HTMLElement, duration: number, handler: () => void, options?: boolean | AddEventListenerOptions, lastTimer?: ReturnType<typeof setTimeout>): ReturnType<typeof setTimeout>;