@unicom-cloud/ui 0.8.109 → 0.8.110

package/types/pc/rich-text/parchment/blot/abstract/leaf.d.ts

@@ -0,0 +1,29 @@
+import Scope from '../../scope.js';
+import type { Leaf } from './blot.js';
+import ShadowBlot from './shadow.js';
+declare class LeafBlot extends ShadowBlot implements Leaf {
+    static scope: Scope;
+    /**
+     * Returns the value represented by domNode if it is this Blot's type
+     * No checking that domNode can represent this Blot type is required so
+     * applications needing it should check externally before calling.
+     */
+    static value(_domNode: Node): any;
+    /**
+     * Given location represented by node and offset from DOM Selection Range,
+     * return index to that location.
+     */
+    index(node: Node, offset: number): number;
+    /**
+     * Given index to location within blot, return node and offset representing
+     * that location, consumable by DOM Selection Range
+     */
+    position(index: number, _inclusive?: boolean): [Node, number];
+    /**
+     * Return value represented by this blot
+     * Should not change without interaction from API or
+     * user change detectable by update()
+     */
+    value(): any;
+}
+export default LeafBlot;

package/types/pc/rich-text/parchment/blot/abstract/parent.d.ts

@@ -0,0 +1,50 @@
+import LinkedList from '../../collection/linked-list.js';
+import type { Blot, BlotConstructor, Parent, Root } from './blot.js';
+import ShadowBlot from './shadow.js';
+declare class ParentBlot extends ShadowBlot implements Parent {
+    /**
+     * Whitelist array of Blots that can be direct children.
+     */
+    static allowedChildren?: BlotConstructor[];
+    /**
+     * Default child blot to be inserted if this blot becomes empty.
+     */
+    static defaultChild?: BlotConstructor;
+    static uiClass: string;
+    children: LinkedList<Blot>;
+    domNode: HTMLElement;
+    uiNode: HTMLElement | null;
+    constructor(scroll: Root, domNode: Node);
+    appendChild(other: Blot): void;
+    attach(): void;
+    attachUI(node: HTMLElement): void;
+    /**
+     * Called during construction, should fill its own children LinkedList.
+     */
+    build(): void;
+    deleteAt(index: number, length: number): void;
+    descendant<T extends Blot>(criteria: new (...args: any[]) => T, index: number): [T | null, number];
+    descendant(criteria: (blot: Blot) => boolean, index: number): [Blot | null, number];
+    descendants<T extends Blot>(criteria: new (...args: any[]) => T, index?: number, length?: number): T[];
+    descendants(criteria: (blot: Blot) => boolean, index?: number, length?: number): Blot[];
+    detach(): void;
+    enforceAllowedChildren(): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    insertAt(index: number, value: string, def?: any): void;
+    insertBefore(childBlot: Blot, refBlot?: Blot | null): void;
+    length(): number;
+    moveChildren(targetParent: Parent, refNode?: Blot | null): void;
+    optimize(context?: {
+        [key: string]: any;
+    }): void;
+    path(index: number, inclusive?: boolean): [Blot, number][];
+    removeChild(child: Blot): void;
+    replaceWith(name: string | Blot, value?: any): Blot;
+    split(index: number, force?: boolean): Blot | null;
+    splitAfter(child: Blot): Parent;
+    unwrap(): void;
+    update(mutations: MutationRecord[], _context: {
+        [key: string]: any;
+    }): void;
+}
+export default ParentBlot;

package/types/pc/rich-text/parchment/blot/abstract/shadow.d.ts

@@ -0,0 +1,37 @@
+import Scope from '../../scope.js';
+import type { Blot, BlotConstructor, Parent, Root } from './blot.js';
+declare class ShadowBlot implements Blot {
+    scroll: Root;
+    domNode: Node;
+    static blotName: string;
+    static className: string;
+    static requiredContainer: BlotConstructor;
+    static scope: Scope;
+    static tagName: string | string[];
+    static create(rawValue?: unknown): Node;
+    prev: Blot | null;
+    next: Blot | null;
+    parent: Parent;
+    get statics(): any;
+    constructor(scroll: Root, domNode: Node);
+    attach(): void;
+    clone(): Blot;
+    detach(): void;
+    deleteAt(index: number, length: number): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    insertAt(index: number, value: string, def?: any): void;
+    isolate(index: number, length: number): Blot;
+    length(): number;
+    offset(root?: Blot): number;
+    optimize(_context?: {
+        [key: string]: any;
+    }): void;
+    remove(): void;
+    replaceWith(name: string | Blot, value?: any): Blot;
+    split(index: number, _force?: boolean): Blot | null;
+    update(_mutations: MutationRecord[], _context: {
+        [key: string]: any;
+    }): void;
+    wrap(name: string | Parent, value?: any): Parent;
+}
+export default ShadowBlot;

package/types/pc/rich-text/parchment/blot/block.d.ts

@@ -0,0 +1,25 @@
+import AttributorStore from '../attributor/store.js';
+import Scope from '../scope.js';
+import type { Blot, BlotConstructor, Formattable, Root } from './abstract/blot.js';
+import ParentBlot from './abstract/parent.js';
+declare class BlockBlot extends ParentBlot implements Formattable {
+    static blotName: string;
+    static scope: Scope;
+    static tagName: string | string[];
+    static allowedChildren: BlotConstructor[];
+    static create(value?: unknown): HTMLElement;
+    static formats(domNode: HTMLElement, scroll: Root): any;
+    protected attributes: AttributorStore;
+    constructor(scroll: Root, domNode: Node);
+    format(name: string, value: any): void;
+    formats(): {
+        [index: string]: any;
+    };
+    formatAt(index: number, length: number, name: string, value: any): void;
+    insertAt(index: number, value: string, def?: any): void;
+    replaceWith(name: string | Blot, value?: any): Blot;
+    update(mutations: MutationRecord[], context: {
+        [key: string]: any;
+    }): void;
+}
+export default BlockBlot;

package/types/pc/rich-text/parchment/blot/embed.d.ts

@@ -0,0 +1,11 @@
+import type { Formattable, Root } from './abstract/blot.js';
+import LeafBlot from './abstract/leaf.js';
+declare class EmbedBlot extends LeafBlot implements Formattable {
+    static formats(_domNode: HTMLElement, _scroll: Root): any;
+    format(name: string, value: any): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    formats(): {
+        [index: string]: any;
+    };
+}
+export default EmbedBlot;

package/types/pc/rich-text/parchment/blot/inline.d.ts

@@ -0,0 +1,28 @@
+import AttributorStore from '../attributor/store.js';
+import Scope from '../scope.js';
+import type { Blot, BlotConstructor, Formattable, Parent, Root } from './abstract/blot.js';
+import ParentBlot from './abstract/parent.js';
+declare class InlineBlot extends ParentBlot implements Formattable {
+    static allowedChildren: BlotConstructor[];
+    static blotName: string;
+    static scope: Scope;
+    static tagName: string | string[];
+    static create(value?: unknown): HTMLElement;
+    static formats(domNode: HTMLElement, scroll: Root): any;
+    protected attributes: AttributorStore;
+    constructor(scroll: Root, domNode: Node);
+    format(name: string, value: any): void;
+    formats(): {
+        [index: string]: any;
+    };
+    formatAt(index: number, length: number, name: string, value: any): void;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+    replaceWith(name: string | Blot, value?: any): Blot;
+    update(mutations: MutationRecord[], context: {
+        [key: string]: any;
+    }): void;
+    wrap(name: string | Parent, value?: any): Parent;
+}
+export default InlineBlot;

package/types/pc/rich-text/parchment/blot/scroll.d.ts

@@ -0,0 +1,34 @@
+import Registry, { type RegistryDefinition } from '../registry.js';
+import Scope from '../scope.js';
+import type { Blot, BlotConstructor, Root } from './abstract/blot.js';
+import ParentBlot from './abstract/parent.js';
+import BlockBlot from './block.js';
+declare class ScrollBlot extends ParentBlot implements Root {
+    registry: Registry;
+    static blotName: string;
+    static defaultChild: typeof BlockBlot;
+    static allowedChildren: BlotConstructor[];
+    static scope: Scope;
+    static tagName: string;
+    observer: MutationObserver;
+    constructor(registry: Registry, node: HTMLDivElement);
+    create(input: Node | string | Scope, value?: any): Blot;
+    find(node: Node | null, bubble?: boolean): Blot | null;
+    query(query: string | Node | Scope, scope?: Scope): RegistryDefinition | null;
+    register(...definitions: RegistryDefinition[]): RegistryDefinition[];
+    build(): void;
+    detach(): void;
+    deleteAt(index: number, length: number): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    insertAt(index: number, value: string, def?: any): void;
+    optimize(context?: {
+        [key: string]: any;
+    }): void;
+    optimize(mutations: MutationRecord[], context: {
+        [key: string]: any;
+    }): void;
+    update(mutations?: MutationRecord[], context?: {
+        [key: string]: any;
+    }): void;
+}
+export default ScrollBlot;

package/types/pc/rich-text/parchment/blot/text.d.ts

@@ -0,0 +1,26 @@
+import Scope from '../scope.js';
+import type { Blot, Leaf, Root } from './abstract/blot.js';
+import LeafBlot from './abstract/leaf.js';
+declare class TextBlot extends LeafBlot implements Leaf {
+    static readonly blotName = "text";
+    static scope: Scope;
+    static create(value: string): Text;
+    static value(domNode: Text): string;
+    domNode: Text;
+    protected text: string;
+    constructor(scroll: Root, node: Node);
+    deleteAt(index: number, length: number): void;
+    index(node: Node, offset: number): number;
+    insertAt(index: number, value: string, def?: any): void;
+    length(): number;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+    position(index: number, _inclusive?: boolean): [Node, number];
+    split(index: number, force?: boolean): Blot | null;
+    update(mutations: MutationRecord[], _context: {
+        [key: string]: any;
+    }): void;
+    value(): string;
+}
+export default TextBlot;

package/types/pc/rich-text/parchment/collection/linked-list.d.ts

@@ -0,0 +1,21 @@
+import type LinkedNode from './linked-node.js';
+declare class LinkedList<T extends LinkedNode> {
+    head: T | null;
+    tail: T | null;
+    length: number;
+    constructor();
+    append(...nodes: T[]): void;
+    at(index: number): T | null;
+    contains(node: T): boolean;
+    indexOf(node: T): number;
+    insertBefore(node: T | null, refNode: T | null): void;
+    offset(target: T): number;
+    remove(node: T): void;
+    iterator(curNode?: T | null): () => T | null;
+    find(index: number, inclusive?: boolean): [T | null, number];
+    forEach(callback: (cur: T) => void): void;
+    forEachAt(index: number, length: number, callback: (cur: T, offset: number, length: number) => void): void;
+    map(callback: (cur: T) => any): any[];
+    reduce<M>(callback: (memo: M, cur: T) => M, memo: M): M;
+}
+export default LinkedList;

package/types/pc/rich-text/parchment/collection/linked-node.d.ts

@@ -0,0 +1,6 @@
+interface LinkedNode {
+    prev: LinkedNode | null;
+    next: LinkedNode | null;
+    length(): number;
+}
+export type { LinkedNode as default };

package/types/pc/rich-text/parchment/error.d.ts

@@ -0,0 +1,6 @@
+export default class ParchmentError extends Error {
+    message: string;
+    name: string;
+    stack: string;
+    constructor(message: string);
+}

package/types/pc/rich-text/parchment/index.d.ts

@@ -0,0 +1,21 @@
+import ContainerBlot from './blot/abstract/container.js';
+import LeafBlot from './blot/abstract/leaf.js';
+import ParentBlot from './blot/abstract/parent.js';
+import BlockBlot from './blot/block.js';
+import EmbedBlot from './blot/embed.js';
+import InlineBlot from './blot/inline.js';
+import ScrollBlot from './blot/scroll.js';
+import TextBlot from './blot/text.js';
+import Attributor from './attributor/attributor.js';
+import ClassAttributor from './attributor/class.js';
+import AttributorStore from './attributor/store.js';
+import StyleAttributor from './attributor/style.js';
+import Registry from './registry.js';
+import Scope from './scope.js';
+export { Attributor, AttributorStore, BlockBlot, ClassAttributor, ContainerBlot, EmbedBlot, InlineBlot, LeafBlot, ParentBlot, Registry, Scope, ScrollBlot, StyleAttributor, TextBlot, };
+export type { AttributorOptions } from './attributor/attributor.js';
+export type { Blot, BlotConstructor, Formattable, Leaf, Parent, Root, } from './blot/abstract/blot.js';
+export type { default as ShadowBlot } from './blot/abstract/shadow.js';
+export type { default as LinkedList } from './collection/linked-list.js';
+export type { default as LinkedNode } from './collection/linked-node.js';
+export type { RegistryDefinition, RegistryInterface } from './registry.js';

package/types/pc/rich-text/parchment/registry.d.ts

@@ -0,0 +1,21 @@
+import Attributor from './attributor/attributor.js';
+import { type Blot, type BlotConstructor, type Root } from './blot/abstract/blot.js';
+import Scope from './scope.js';
+export type RegistryDefinition = Attributor | BlotConstructor;
+export interface RegistryInterface {
+    create(scroll: Root, input: Node | string | Scope, value?: any): Blot;
+    query(query: string | Node | Scope, scope: Scope): RegistryDefinition | null;
+    register(...definitions: any[]): any;
+}
+export default class Registry implements RegistryInterface {
+    static blots: WeakMap<Node, Blot>;
+    static find(node?: Node | null, bubble?: boolean): Blot | null;
+    private attributes;
+    private classes;
+    private tags;
+    private types;
+    create(scroll: Root, input: Node | string | Scope, value?: any): Blot;
+    find(node: Node | null, bubble?: boolean): Blot | null;
+    query(query: string | Node | Scope, scope?: Scope): RegistryDefinition | null;
+    register(...definitions: RegistryDefinition[]): RegistryDefinition[];
+}

package/types/pc/rich-text/parchment/scope.d.ts

@@ -0,0 +1,14 @@
+declare enum Scope {
+    TYPE = 3,// 0011 Lower two bits
+    LEVEL = 12,// 1100 Higher two bits
+    ATTRIBUTE = 13,// 1101
+    BLOT = 14,// 1110
+    INLINE = 7,// 0111
+    BLOCK = 11,// 1011
+    BLOCK_BLOT = 10,// 1010
+    INLINE_BLOT = 6,// 0110
+    BLOCK_ATTRIBUTE = 9,// 1001
+    INLINE_ATTRIBUTE = 5,// 0101
+    ANY = 15
+}
+export default Scope;

package/types/pc/rich-text/rich.d.ts

@@ -0,0 +1,5 @@
+import type { Bounds, DebugLevel, EmitterSource, ExpandedRichOptions, RichOptions } from './core.js';
+import Rich from './core.js';
+export { AttributeMap, Delta, Module, Op, OpIterator, Parchment, Range, } from './core.js';
+export type { Bounds, DebugLevel, EmitterSource, ExpandedRichOptions, RichOptions, };
+export default Rich;

package/types/pc/rich-text/themes/base.d.ts

@@ -0,0 +1,35 @@
+import type Rich from '../core/rich.js';
+import type Selection from '../core/selection.js';
+import type { Range } from '../core/selection.js';
+import type { ThemeOptions } from '../core/theme.js';
+import Theme from '../core/theme.js';
+import type Clipboard from '../modules/clipboard.js';
+import type History from '../modules/history.js';
+import type Keyboard from '../modules/keyboard.js';
+import type Uploader from '../modules/uploader.js';
+import Picker from '../ui/picker.js';
+import Tooltip from '../ui/tooltip.js';
+declare class BaseTheme extends Theme {
+    pickers: Picker[];
+    tooltip?: Tooltip;
+    constructor(rich: Rich, options: ThemeOptions);
+    addModule(name: 'clipboard'): Clipboard;
+    addModule(name: 'keyboard'): Keyboard;
+    addModule(name: 'uploader'): Uploader;
+    addModule(name: 'history'): History;
+    addModule(name: 'selection'): Selection;
+    addModule(name: string): unknown;
+    buildButtons(buttons: NodeListOf<HTMLElement>, icons: Record<string, Record<string, string> | string>): void;
+    buildPickers(selects: NodeListOf<HTMLSelectElement>, icons: Record<string, string | Record<string, string>>): void;
+}
+declare class BaseTooltip extends Tooltip {
+    textbox: HTMLInputElement | null;
+    linkRange?: Range;
+    constructor(rich: Rich, boundsContainer?: HTMLElement);
+    listen(): void;
+    cancel(): void;
+    edit(mode?: string, preview?: string | null): void;
+    restoreFocus(): void;
+    save(): void;
+}
+export { BaseTooltip, BaseTheme as default };

package/types/pc/rich-text/themes/bubble.d.ts

@@ -0,0 +1,18 @@
+import Rich from '../core/rich.js';
+import type { Bounds } from '../core/selection.js';
+import type { ThemeOptions } from '../core/theme.js';
+import type Toolbar from '../modules/toolbar.js';
+import BaseTheme, { BaseTooltip } from './base.js';
+declare class BubbleTooltip extends BaseTooltip {
+    static TEMPLATE: string;
+    constructor(rich: Rich, bounds?: HTMLElement);
+    listen(): void;
+    cancel(): void;
+    position(reference: Bounds): number;
+}
+declare class BubbleTheme extends BaseTheme {
+    tooltip: BubbleTooltip;
+    constructor(rich: Rich, options: ThemeOptions);
+    extendToolbar(toolbar: Toolbar): void;
+}
+export { BubbleTooltip, BubbleTheme as default };

package/types/pc/rich-text/themes/snow.d.ts

@@ -0,0 +1,9 @@
+import Rich from '../core/rich.js';
+import type { ThemeOptions } from '../core/theme.js';
+import type Toolbar from '../modules/toolbar.js';
+import BaseTheme from './base.js';
+declare class SnowTheme extends BaseTheme {
+    constructor(rich: Rich, options: ThemeOptions);
+    extendToolbar(toolbar: Toolbar): void;
+}
+export default SnowTheme;

package/types/pc/rich-text/ui/color-picker.d.ts

@@ -0,0 +1,7 @@
+import Picker from './picker.js';
+declare class ColorPicker extends Picker {
+    constructor(select: HTMLSelectElement, label: string);
+    buildItem(option: HTMLOptionElement): HTMLSpanElement;
+    selectItem(item: HTMLElement | null, trigger?: boolean): void;
+}
+export default ColorPicker;

package/types/pc/rich-text/ui/icon-picker.d.ts

@@ -0,0 +1,7 @@
+import Picker from './picker.js';
+declare class IconPicker extends Picker {
+    defaultItem: HTMLElement | null;
+    constructor(select: HTMLSelectElement, icons: Record<string, string>);
+    selectItem(target: HTMLElement | null, trigger?: boolean): void;
+}
+export default IconPicker;

package/types/pc/rich-text/ui/icons.d.ts

@@ -0,0 +1,51 @@
+declare const _default: {
+    align: {
+        '': any;
+        center: any;
+        right: any;
+        justify: any;
+    };
+    background: any;
+    blockquote: any;
+    bold: any;
+    clean: any;
+    code: any;
+    'code-block': any;
+    color: any;
+    direction: {
+        '': any;
+        rtl: any;
+    };
+    formula: any;
+    header: {
+        1: any;
+        2: any;
+        3: any;
+        4: any;
+        5: any;
+        6: any;
+    };
+    italic: any;
+    image: any;
+    indent: {
+        '+1': any;
+        '-1': any;
+    };
+    link: any;
+    list: {
+        bullet: any;
+        check: any;
+        ordered: any;
+    };
+    script: {
+        sub: any;
+        super: any;
+    };
+    strike: any;
+    table: any;
+    underline: any;
+    video: any;
+    redo: any;
+    undo: any;
+};
+export default _default;

package/types/pc/rich-text/ui/picker.d.ts

@@ -0,0 +1,16 @@
+declare class Picker {
+    select: HTMLSelectElement;
+    container: HTMLElement;
+    label: HTMLElement;
+    constructor(select: HTMLSelectElement);
+    togglePicker(): void;
+    buildItem(option: HTMLOptionElement): HTMLSpanElement;
+    buildLabel(): HTMLSpanElement;
+    buildOptions(): void;
+    buildPicker(): void;
+    escape(): void;
+    close(): void;
+    selectItem(item: HTMLElement | null, trigger?: boolean): void;
+    update(): void;
+}
+export default Picker;

package/types/pc/rich-text/ui/tooltip.d.ts

@@ -0,0 +1,12 @@
+import type Rich from '../core.js';
+import type { Bounds } from '../core/selection.js';
+declare class Tooltip {
+    rich: Rich;
+    boundsContainer: HTMLElement;
+    root: HTMLDivElement;
+    constructor(rich: Rich, boundsContainer?: HTMLElement);
+    hide(): void;
+    position(reference: Bounds): number;
+    show(): void;
+}
+export default Tooltip;

package/types/pc/select/interface.d.ts

@@ -156,6 +156,10 @@ export interface SelectProps extends SelectViewCommonProps {
      * @en Pass properties used by VirtualList.
      */
     virtualListProps?: AvailableVirtualListProps;
+    /**
+     * @zh 是否立即触发一次 onChange 回调。仅在 (value || defaultValue) 条件满足的情况下才会触发。
+     */
+    immediateTriggerChangeOnMount?: boolean;
     /**
      * @zh 点击选择框的回调
      * @en Callback when select an option or input value change.

package/types/pc/utils/index.d.ts

@@ -19,11 +19,13 @@ export * from './lodash';
 export * from './math';
 export * from './mergedToString';
 export * from './mergeProps';
+export * from './mitt';
 export * from './mutationObserver';
 export * from './names';
 export * from './omit';
 export * from './pad';
 export * from './pick';
+export * from './pinyin';
 export * from './PqbCSSTransition';
 export * from './reactDOM';
 export * from './reactTransitionGroup';

package/types/pc/utils/mitt.d.ts

@@ -0,0 +1 @@
+export { default, default as mitt } from '../../common/utils/mitt';