ados-rcm 1.1.512 → 1.1.514

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>;

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

@@ -0,0 +1,149 @@
+import { default as Quill } from 'quill';
+import { default as BaseTheme } from 'quill/themes/base';
+import { default as Picker } from 'quill/ui/picker';
+import { TableCellInnerFormat } from '../formats';
+import { MenuTooltipInstance } from '../modules';
+import { TableUp } from '../table-up';
+import { blotName, tableUpEvent, tableUpInternal, tableUpSize } from './constants';
+export type QuillThemePicker = Picker & {
+    options: HTMLElement;
+};
+export interface QuillTheme extends BaseTheme {
+    pickers: QuillThemePicker[];
+}
+export interface ToolOption {
+    handle: (tableModule: TableUp, selectedTds: TableCellInnerFormat[], e: Event | string | null) => void;
+    icon: string | ((tableModule: TableUp) => HTMLElement);
+    isColorChoose?: boolean;
+    key?: string;
+    name: string;
+    tip?: string;
+}
+export interface ToolOptionBreak {
+    name: 'break';
+}
+export type Tool = ToolOption | ToolOptionBreak;
+export interface TableMenuOptions {
+    defaultColorMap: string[];
+    localstorageKey: string;
+    tipText: boolean;
+    tools: Tool[];
+}
+export interface TableSelectionOptions {
+    selectColor: string;
+    tableMenu?: Constructor<InternalTableMenuModule, [TableUp, Quill, Partial<TableMenuOptions>]>;
+    tableMenuOptions: TableMenuOptions;
+}
+export interface TableResizeScaleOptions {
+    blockSize: number;
+}
+export interface TableCreatorTextOptions {
+    cancelText: string;
+    colText: string;
+    confirmText: string;
+    customBtnText: string;
+    fullCheckboxText: string;
+    notPositiveNumberError: string;
+    perWidthInsufficient: string;
+    rowText: string;
+}
+export type TableMenuTexts = Record<string, string>;
+export interface TableTextOptions extends TableCreatorTextOptions, TableMenuTexts {
+    clear: string;
+    custom: string;
+    perWidthInsufficient: string;
+    transparent: string;
+}
+export interface TableUpOptions {
+    align?: Constructor<InternalModule, [TableUp, HTMLElement, Quill, any]>;
+    alignOptions: any;
+    customBtn: boolean;
+    customSelect?: (tableModule: TableUp, picker: QuillThemePicker) => Promise<HTMLElement> | HTMLElement;
+    full: boolean;
+    fullSwitch: boolean;
+    icon: string;
+    resize?: Constructor<InternalModule, [TableUp, HTMLElement, Quill, any]>;
+    resizeOptions: any;
+    resizeScale?: Constructor<InternalModule, [TableUp, HTMLElement, Quill, Partial<TableResizeScaleOptions>]>;
+    resizeScaleOptions: Partial<TableResizeScaleOptions>;
+    scrollbar?: Constructor<InternalModule, [TableUp, HTMLElement, Quill, any]>;
+    scrollbarOptions: any;
+    selection?: Constructor<InternalTableSelectionModule, [TableUp, Quill, Partial<TableSelectionOptions>]>;
+    selectionOptions: Partial<TableSelectionOptions>;
+    texts: TableTextOptions;
+}
+export interface TableColValue {
+    align?: string;
+    colId: string;
+    full?: boolean;
+    tableId: string;
+    width: number;
+}
+export interface TableCellValue {
+    colId: string;
+    colspan: number;
+    rowId: string;
+    rowspan: number;
+    style?: string;
+    tableId: string;
+}
+export interface TableRowValue {
+    rowId: string;
+    tableId: string;
+}
+export interface TableCaptionValue {
+    side: 'top' | 'bottom';
+    tableId: string;
+}
+export interface TableValue {
+    align?: string;
+    full?: boolean;
+    tableId: string;
+}
+export interface RelactiveRect {
+    height: number;
+    width: number;
+    x: number;
+    x1: number;
+    y: number;
+    y1: number;
+}
+export interface InternalModule {
+    destroy: () => void;
+    hide: () => void;
+    show: () => void;
+    update: () => void;
+}
+export type Constructor<T = any, U extends Array<any> = any[]> = new (...args: U) => T;
+export interface InternalTableSelectionModule extends InternalModule {
+    boundary: RelactiveRect | null;
+    cellSelect: HTMLElement;
+    computeSelectedTds: (startPoint: {
+        x: number;
+        y: number;
+    }, endPoint: {
+        x: number;
+        y: number;
+    }) => TableCellInnerFormat[];
+    dragging: boolean;
+    hideDisplay: () => void;
+    isDisplaySelection: boolean;
+    selectedTds: TableCellInnerFormat[];
+    showDisplay: () => void;
+    table?: HTMLElement;
+    tableMenu?: InternalModule;
+    updateWithSelectedTds: () => void;
+}
+export interface InternalTableMenuModule extends InternalModule {
+    activeTooltip: MenuTooltipInstance | null;
+    isMenuDisplay: boolean;
+}
+export type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export interface TableConstantsData {
+    blotName: Partial<Record<keyof Writable<typeof blotName>, string>>;
+    tableUpEvent: Partial<typeof tableUpEvent>;
+    tableUpInternal: Partial<typeof tableUpInternal>;
+    tableUpSize: Partial<typeof tableUpSize>;
+}

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

@@ -0,0 +1,2 @@
+export declare const randomId: () => string;
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, delay: number): (this: any, ...args: Parameters<T>) => void;

package/dist/AModule/AComponents/AResource/AResource.d.ts

@@ -55,6 +55,16 @@ export declare const Resources: {
         'Select(Placeholder)': string;
     };
     AEditor: {
+        'Insert Full Width Table': string;
+        Custom: string;
+        Confirm: string;
+        Cancel: string;
+        Row: string;
+        Column: string;
+        'Not Positive Number Error': string;
+        perWidthInsufficient: string;
+        Transparent: string;
+        Clear: string;
         'Insert Column Right': string;
         'Insert Column Left': string;
         'Insert Row Top': string;
@@ -62,12 +72,12 @@ export declare const Resources: {
         'Delete Column': string;
         'Delete Row': string;
         'Delete Table': string;
-        'Image size adjust': string;
-        Center: string;
-        floatLeft: string;
-        floatRight: string;
-        'Input on mouse down': string;
-        Restore: string;
+        'Set Background Color': string;
+        'Set Border Color': string;
+        'Switch Table Width': string;
+        'Insert Table Caption': string;
+        'Merge Cell': string;
+        'Split Cell': string;
         'Right click to open properties': string;
         Default: string;
         'Enter link:': string;

package/dist/AModule/AComponents/ATree/ATreeItem.d.ts

@@ -24,6 +24,7 @@ export interface IATreeItemProps<T> {
         expanded?: TIcons | Exclude<React.ReactNode, string>;
         noChild?: TIcons | Exclude<React.ReactNode, string>;
     };
+    id: string;
     indents: EIndentState[];
     isDraggable?: boolean;
     isEqual: (a: T, b: T) => boolean;