@univerjs/docs-ui 0.2.12 → 0.2.13

package/lib/types/services/doc-ime-input-manager.service.d.ts

@@ -0,0 +1,30 @@
+import { RxDisposable, DocumentDataModel, Nullable } from '@univerjs/core';
+import { IRichTextEditingMutationParams } from '@univerjs/docs';
+import { IRenderContext, IRenderModule, ITextRangeWithStyle } from '@univerjs/engine-render';
+interface ICacheParams {
+    undoCache: IRichTextEditingMutationParams[];
+    redoCache: IRichTextEditingMutationParams[];
+}
+export declare class DocIMEInputManagerService extends RxDisposable implements IRenderModule {
+    private readonly _context;
+    private _previousActiveRange;
+    private _undoMutationParamsCache;
+    private _redoMutationParamsCache;
+    constructor(_context: IRenderContext<DocumentDataModel>);
+    clearUndoRedoMutationParamsCache(): void;
+    getUndoRedoMutationParamsCache(): {
+        undoCache: IRichTextEditingMutationParams[];
+        redoCache: IRichTextEditingMutationParams[];
+    };
+    setUndoRedoMutationParamsCache({ undoCache, redoCache }: ICacheParams): void;
+    getActiveRange(): Nullable<ITextRangeWithStyle>;
+    setActiveRange(range: Nullable<ITextRangeWithStyle>): void;
+    pushUndoRedoMutationParams(undoParams: IRichTextEditingMutationParams, redoParams: IRichTextEditingMutationParams): void;
+    fetchComposedUndoRedoMutationParams(): {
+        redoMutationParams: IRichTextEditingMutationParams;
+        undoMutationParams: IRichTextEditingMutationParams;
+        previousActiveRange: ITextRangeWithStyle;
+    } | null;
+    dispose(): void;
+}
+export {};

package/lib/types/services/doc-page-layout.service.d.ts

@@ -1,4 +1,4 @@
-import { DocumentDataModel, Disposable } from '@univerjs/core';
+import { Disposable, DocumentDataModel } from '@univerjs/core';
 import { IRenderContext, IRenderModule } from '@univerjs/engine-render';
 export declare class DocPageLayoutService extends Disposable implements IRenderModule {
     private _context;

package/lib/types/services/doc-popup-manager.service.d.ts

@@ -1,6 +1,6 @@
-import { IDisposable, ITextRangeParam, Disposable, ICommandService, IUniverInstanceService } from '@univerjs/core';
+import { Disposable, ICommandService, IUniverInstanceService, IDisposable, INeedCheckDisposable, ITextRangeParam } from '@univerjs/core';
 import { IRenderManagerService, BaseObject, IBoundRectNoAngle, IRender, Scene } from '@univerjs/engine-render';
-import { IPopup, ICanvasPopupService } from '@univerjs/ui';
+import { ICanvasPopupService, IPopup } from '@univerjs/ui';
 export declare function transformBound2OffsetBound(originBound: IBoundRectNoAngle, scene: Scene): IBoundRectNoAngle;
 export declare function transformPosition2Offset(x: number, y: number, scene: Scene): {
     x: number;
@@ -10,7 +10,7 @@ export declare function transformOffset2Bound(offsetX: number, offsetY: number,
     x: number;
     y: number;
 };
-export interface IDocCanvasPopup extends Pick<IPopup, 'direction' | 'excludeOutside' | 'closeOnSelfTarget' | 'componentKey' | 'offset' | 'onClickOutside' | 'hideOnInvisible'> {
+export interface IDocCanvasPopup extends Pick<IPopup, 'direction' | 'excludeOutside' | 'componentKey' | 'offset' | 'onClickOutside' | 'hideOnInvisible'> {
     mask?: boolean;
     extraProps?: Record<string, any>;
     multipleDirection?: IPopup['direction'];
@@ -38,5 +38,5 @@ export declare class DocCanvasPopManagerService extends Disposable {
      * @param unitId unit id
      * @returns disposable
      */
-    attachPopupToRange(range: ITextRangeParam, popup: IDocCanvasPopup, unitId: string): IDisposable;
+    attachPopupToRange(range: ITextRangeParam, popup: IDocCanvasPopup, unitId: string): INeedCheckDisposable;
 }

package/lib/types/services/doc-state-change-manager.service.d.ts

@@ -0,0 +1,23 @@
+import { ICommandService, IUndoRedoService, IUniverInstanceService, RxDisposable, Nullable } from '@univerjs/core';
+import { DocStateEmitService, IDocStateChangeParams } from '@univerjs/docs';
+import { IRenderManagerService } from '@univerjs/engine-render';
+export declare class DocStateChangeManagerService extends RxDisposable {
+    private _undoRedoService;
+    private readonly _commandService;
+    private readonly _univerInstanceService;
+    private readonly _docStateEmitService;
+    private readonly _renderManagerService;
+    private readonly _docStateChange$;
+    readonly docStateChange$: import('rxjs').Observable<Nullable<IDocStateChangeParams>>;
+    private _historyStateCache;
+    private _changeStateCache;
+    private _historyTimer;
+    private _changeStateCacheTimer;
+    constructor(_undoRedoService: IUndoRedoService, _commandService: ICommandService, _univerInstanceService: IUniverInstanceService, _docStateEmitService: DocStateEmitService, _renderManagerService: IRenderManagerService);
+    private _setChangeState;
+    private _initialize;
+    private _listenDocStateChange;
+    private _cacheChangeState;
+    private _pushHistory;
+    private _emitChangeState;
+}

package/lib/types/services/selection/convert-rect-range.d.ts

@@ -0,0 +1,27 @@
+import { Nullable } from '@univerjs/core';
+import { DocumentSkeleton, IDocumentOffsetConfig, INodePosition, IPoint } from '@univerjs/engine-render';
+export declare function isValidRectRange(anchorNodePosition: INodePosition, focusNodePosition: INodePosition): boolean;
+export declare function isInSameTableCell(anchorNodePosition: INodePosition, focusNodePosition: INodePosition): boolean;
+export declare function compareNodePositionInTable(a: INodePosition, b: INodePosition): boolean;
+interface IRectRangeNodePositions {
+    anchor: INodePosition;
+    focus: INodePosition;
+}
+export declare class NodePositionConvertToRectRange {
+    private _documentOffsetConfig;
+    private _docSkeleton;
+    private _liquid;
+    constructor(_documentOffsetConfig: IDocumentOffsetConfig, _docSkeleton: DocumentSkeleton);
+    getRangePointData(startNodePosition: INodePosition, endNodePosition: INodePosition): {
+        pointGroup: IPoint[][];
+        startRow: number;
+        startColumn: number;
+        endRow: number;
+        endColumn: number;
+        tableId: string;
+    } | undefined;
+    getNodePositionGroup(anchorNodePosition: INodePosition, focusNodePosition: INodePosition): Nullable<IRectRangeNodePositions[]>;
+    private _collectPositionGroup;
+    private _getTableRectRangeInfo;
+}
+export {};

package/lib/types/services/selection/convert-text-range.d.ts

@@ -0,0 +1,60 @@
+import { IPosition, ITextRange, Nullable } from '@univerjs/core';
+import { DocumentSkeleton, IDocumentOffsetConfig, INodePosition, IPoint } from '@univerjs/engine-render';
+export declare enum NodePositionStateType {
+    NORMAL = 0,
+    START = 1,
+    END = 2
+}
+export declare enum NodePositionType {
+    page = 0,
+    section = 1,
+    column = 2,
+    line = 3,
+    divide = 4,
+    glyph = 5
+}
+export interface ICurrentNodePositionState {
+    page: NodePositionStateType;
+    section: NodePositionStateType;
+    column: NodePositionStateType;
+    line: NodePositionStateType;
+    divide: NodePositionStateType;
+    glyph: NodePositionStateType;
+}
+export declare const NodePositionMap: {
+    page: number;
+    section: number;
+    column: number;
+    line: number;
+    divide: number;
+    glyph: number;
+};
+export declare function compareNodePositionLogic(pos1: INodePosition, pos2: INodePosition): boolean;
+export declare function compareNodePosition(pos1: INodePosition, pos2: INodePosition): {
+    start: INodePosition;
+    end: INodePosition;
+};
+export declare function getOneTextSelectionRange(rangeList: ITextRange[]): Nullable<ITextRange>;
+export declare function pushToPoints(position: IPosition): {
+    x: number;
+    y: number;
+}[];
+export declare class NodePositionConvertToCursor {
+    private _documentOffsetConfig;
+    private _docSkeleton;
+    private _liquid;
+    private _currentStartState;
+    private _currentEndState;
+    constructor(_documentOffsetConfig: IDocumentOffsetConfig, _docSkeleton: DocumentSkeleton);
+    getRangePointData(startOrigin: Nullable<INodePosition>, endOrigin: Nullable<INodePosition>): {
+        borderBoxPointGroup: IPoint[][];
+        contentBoxPointGroup: IPoint[][];
+        cursorList: ITextRange[];
+    };
+    private _isValidPosition;
+    private _resetCurrentNodePositionState;
+    private _setNodePositionState;
+    private _checkPreviousNodePositionState;
+    private _getSelectionRuler;
+    private _selectionIterator;
+}

package/lib/types/services/selection/doc-selection-render.service.d.ts

@@ -0,0 +1,121 @@
+import { ILogService, RxDisposable, DocumentDataModel, Nullable } from '@univerjs/core';
+import { DocSkeletonManagerService } from '@univerjs/docs';
+import { ILayoutService } from '@univerjs/ui';
+import { IDocSelectionInnerParam, IMouseEvent, INodePosition, IPointerEvent, IRenderContext, IRenderModule, ISuccinctDocRangeParam, ITextRangeWithStyle, ITextSelectionStyle, Viewport } from '@univerjs/engine-render';
+import { TextRange } from './text-range';
+export interface IEditorInputConfig {
+    event: Event | CompositionEvent | KeyboardEvent;
+    content?: string;
+    activeRange?: Nullable<ITextRangeWithStyle>;
+    rangeList?: ITextRangeWithStyle[];
+}
+export declare class DocSelectionRenderService extends RxDisposable implements IRenderModule {
+    private readonly _context;
+    private readonly _layoutService;
+    private readonly _logService;
+    private readonly _docSkeletonManagerService;
+    private readonly _onInputBefore$;
+    readonly onInputBefore$: import('rxjs').Observable<Nullable<IEditorInputConfig>>;
+    private readonly _onKeydown$;
+    readonly onKeydown$: import('rxjs').Observable<Nullable<IEditorInputConfig>>;
+    private readonly _onInput$;
+    readonly onInput$: import('rxjs').Observable<Nullable<IEditorInputConfig>>;
+    private readonly _onCompositionstart$;
+    readonly onCompositionstart$: import('rxjs').Observable<Nullable<IEditorInputConfig>>;
+    private readonly _onCompositionupdate$;
+    readonly onCompositionupdate$: import('rxjs').Observable<Nullable<IEditorInputConfig>>;
+    private readonly _onCompositionend$;
+    readonly onCompositionend$: import('rxjs').Observable<Nullable<IEditorInputConfig>>;
+    private readonly _onSelectionStart$;
+    readonly onSelectionStart$: import('rxjs').Observable<Nullable<INodePosition>>;
+    private readonly _onPaste$;
+    readonly onPaste$: import('rxjs').Observable<Nullable<IEditorInputConfig>>;
+    private readonly _textSelectionInner$;
+    readonly textSelectionInner$: import('rxjs').Observable<Nullable<IDocSelectionInnerParam>>;
+    private readonly _onFocus$;
+    readonly onFocus$: import('rxjs').Observable<Nullable<IEditorInputConfig>>;
+    private readonly _onBlur$;
+    readonly onBlur$: import('rxjs').Observable<Nullable<IEditorInputConfig>>;
+    private readonly _onPointerDown$;
+    readonly onPointerDown$: import('rxjs').Observable<void>;
+    private _container;
+    private _inputParent;
+    private _input;
+    private _scrollTimers;
+    private _rangeList;
+    private _rangeListCache;
+    private _rectRangeList;
+    private _rectRangeListCache;
+    private _anchorNodePosition;
+    private _focusNodePosition;
+    private _currentSegmentId;
+    private _currentSegmentPage;
+    private _selectionStyle;
+    private _isSelectionEnabled;
+    private _viewPortObserverMap;
+    private _isIMEInputApply;
+    private _scenePointerMoveSubs;
+    private _scenePointerUpSubs;
+    private _editorFocusing;
+    constructor(_context: IRenderContext<DocumentDataModel>, _layoutService: ILayoutService, _logService: ILogService, _docSkeletonManagerService: DocSkeletonManagerService);
+    get activeViewPort(): Viewport;
+    setSegment(id: string): void;
+    getSegment(): string;
+    setSegmentPage(pageIndex: number): void;
+    getSegmentPage(): number;
+    setStyle(style?: ITextSelectionStyle): void;
+    resetStyle(): void;
+    enableSelection(): void;
+    disableSelection(): void;
+    addDocRanges(ranges: ISuccinctDocRangeParam[], isEditing?: boolean, options?: {
+        [key: string]: boolean;
+    }): void;
+    setCursorManually(evtOffsetX: number, evtOffsetY: number): void;
+    sync(): void;
+    activate(x: number, y: number, force?: boolean): void;
+    hasFocus(): boolean;
+    focus(): void;
+    blur(): void;
+    focusEditor(): void;
+    blurEditor(): void;
+    deactivate(): void;
+    handleDblClick(evt: IPointerEvent | IMouseEvent): void;
+    handleTripleClick(evt: IPointerEvent | IMouseEvent): void;
+    onPointDown(evt: IPointerEvent | IMouseEvent): void;
+    removeAllRanges(): void;
+    getActiveTextRange(): TextRange | undefined;
+    private _setSystemHighlightColorToStyle;
+    private _getAllTextRanges;
+    private _getAllRectRanges;
+    private _getActiveRange;
+    private _getActiveRangeInstance;
+    dispose(): void;
+    private _initDOM;
+    private _registerContainer;
+    private _initInput;
+    private _getNodePosition;
+    private _interactTextRanges;
+    private _interactRectRanges;
+    private _removeAllRanges;
+    private _removeAllCacheRanges;
+    private _removeAllTextRanges;
+    private _removeAllRectRanges;
+    private _deactivateAllTextRanges;
+    private _deactivateAllRectRanges;
+    private _addTextRangesToCache;
+    private _addTextRange;
+    private _addRectRangesToCache;
+    private _addRectRanges;
+    private _createTextRangeByAnchorPosition;
+    private _updateActiveRangePosition;
+    private _isEmpty;
+    private _getCanvasOffset;
+    private _updateInputPosition;
+    private _moving;
+    attachScrollEvent(viewport: Nullable<Viewport>): void;
+    private _initInputEvents;
+    private _eventHandle;
+    private _getTransformCoordForDocumentOffset;
+    private _findNodeByCoord;
+    private _detachEvent;
+}

package/lib/types/services/selection/range-interface.d.ts

@@ -0,0 +1,19 @@
+import { DOC_RANGE_TYPE, Nullable, RANGE_DIRECTION } from '@univerjs/core';
+import { INodePosition, ITextSelectionStyle } from '@univerjs/engine-render';
+export interface IDocRange {
+    rangeType: DOC_RANGE_TYPE;
+    anchorNodePosition?: Nullable<INodePosition>;
+    focusNodePosition?: Nullable<INodePosition>;
+    style: ITextSelectionStyle;
+    get startOffset(): Nullable<number>;
+    get endOffset(): Nullable<number>;
+    get collapsed(): boolean;
+    get startNodePosition(): Nullable<INodePosition>;
+    get endNodePosition(): Nullable<INodePosition>;
+    get direction(): RANGE_DIRECTION;
+    get segmentId(): string;
+    get segmentPage(): number;
+    isActive(): boolean;
+    dispose(): void;
+    refresh(): void;
+}

package/lib/types/services/selection/rect-range.d.ts

@@ -0,0 +1,47 @@
+import { DOC_RANGE_TYPE, Nullable, RANGE_DIRECTION } from '@univerjs/core';
+import { Documents, DocumentSkeleton, INodePosition, ITextSelectionStyle, ThinScene } from '@univerjs/engine-render';
+import { IDocRange } from './range-interface';
+export declare function convertPositionsToRectRanges(scene: ThinScene, document: Documents, docSkeleton: DocumentSkeleton, anchorNodePosition: INodePosition, focusNodePosition: INodePosition, style?: ITextSelectionStyle, segmentId?: string, segmentPage?: number): RectRange[];
+export declare class RectRange implements IDocRange {
+    private _scene;
+    private _document;
+    private _docSkeleton;
+    anchorNodePosition: INodePosition;
+    focusNodePosition: INodePosition;
+    style: ITextSelectionStyle;
+    private _segmentId;
+    private _segmentPage;
+    rangeType: DOC_RANGE_TYPE;
+    private _rangeShape;
+    private _current;
+    private _startRow;
+    private _startCol;
+    private _endRow;
+    private _endCol;
+    private _tableId;
+    constructor(_scene: ThinScene, _document: Documents, _docSkeleton: DocumentSkeleton, anchorNodePosition: INodePosition, focusNodePosition: INodePosition, style?: ITextSelectionStyle, _segmentId?: string, _segmentPage?: number);
+    get startOffset(): Nullable<number>;
+    get endOffset(): Nullable<number>;
+    get collapsed(): boolean;
+    get startRow(): number;
+    get startColumn(): number;
+    get endRow(): number;
+    get endColumn(): number;
+    get tableId(): string;
+    get segmentId(): string;
+    get segmentPage(): number;
+    get spanEntireRow(): boolean;
+    get spanEntireColumn(): boolean;
+    get spanEntireTable(): boolean;
+    get startNodePosition(): INodePosition;
+    get endNodePosition(): INodePosition;
+    get direction(): RANGE_DIRECTION;
+    isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+    dispose(): void;
+    isIntersection(compareRange: RectRange): boolean;
+    refresh(): void;
+    private _updateTableInfo;
+    private _createOrUpdateRange;
+}

package/lib/types/services/selection/selection-utils.d.ts

@@ -0,0 +1,26 @@
+import { Nullable } from '@univerjs/core';
+import { Documents, DocumentSkeleton, Engine, IDocumentSkeletonGlyph, INodePosition, IRectRangeWithStyle, ITextRangeWithStyle, ITextSelectionStyle, Scene } from '@univerjs/engine-render';
+import { RectRange } from './rect-range';
+import { TextRange } from './text-range';
+import { IDocRange } from './range-interface';
+interface IDocRangeList {
+    textRanges: TextRange[];
+    rectRanges: RectRange[];
+}
+export declare function getTextRangeFromCharIndex(startOffset: number, endOffset: number, scene: Scene, document: Documents, skeleton: DocumentSkeleton, style: ITextSelectionStyle, segmentId: string, segmentPage: number): Nullable<TextRange>;
+export declare function getRectRangeFromCharIndex(startOffset: number, endOffset: number, scene: Scene, document: Documents, skeleton: DocumentSkeleton, style: ITextSelectionStyle, segmentId: string, segmentPage: number): Nullable<RectRange>;
+export declare function getRangeListFromCharIndex(startOffset: number, endOffset: number, scene: Scene, document: Documents, skeleton: DocumentSkeleton, style: ITextSelectionStyle, segmentId: string, segmentPage: number): Nullable<IDocRangeList>;
+export declare function getRangeListFromSelection(anchorPosition: INodePosition, focusPosition: INodePosition, scene: Scene, document: Documents, skeleton: DocumentSkeleton, style: ITextSelectionStyle, segmentId: string, segmentPage: number): Nullable<IDocRangeList>;
+export declare function getCanvasOffsetByEngine(engine: Nullable<Engine>): {
+    left: number;
+    top: number;
+};
+export declare function getParagraphInfoByGlyph(node: IDocumentSkeletonGlyph): {
+    st: number;
+    ed: number;
+    content: string;
+    nodeIndex: number;
+} | undefined;
+export declare function serializeTextRange(textRange: IDocRange): ITextRangeWithStyle;
+export declare function serializeRectRange(rectRange: RectRange): IRectRangeWithStyle;
+export {};

package/lib/types/services/selection/text-range.d.ts

@@ -0,0 +1,63 @@
+import { DOC_RANGE_TYPE, RANGE_DIRECTION, Nullable } from '@univerjs/core';
+import { Rect, Documents, DocumentSkeleton, INodePosition, IPoint, ISuccinctDocRangeParam, ITextSelectionStyle, Scene, ThinScene } from '@univerjs/engine-render';
+import { IDocRange } from './range-interface';
+export declare const TEXT_RANGE_LAYER_INDEX = 3;
+export declare function cursorConvertToTextRange(scene: Scene, range: ISuccinctDocRangeParam, docSkeleton: DocumentSkeleton, document: Documents): Nullable<TextRange>;
+export declare function getAnchorBounding(pointsGroup: IPoint[][]): {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export declare function getLineBounding(pointsGroup: IPoint[][]): {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}[];
+export declare class TextRange implements IDocRange {
+    private _scene;
+    private _document;
+    private _docSkeleton;
+    anchorNodePosition?: Nullable<INodePosition>;
+    focusNodePosition?: Nullable<INodePosition>;
+    style: ITextSelectionStyle;
+    private _segmentId;
+    private _segmentPage;
+    rangeType: DOC_RANGE_TYPE;
+    private _current;
+    private _rangeShape;
+    private _anchorShape;
+    private _cursorList;
+    private _anchorBlinkTimer;
+    constructor(_scene: ThinScene, _document: Documents, _docSkeleton: DocumentSkeleton, anchorNodePosition?: Nullable<INodePosition>, focusNodePosition?: Nullable<INodePosition>, style?: ITextSelectionStyle, _segmentId?: string, _segmentPage?: number);
+    private _anchorBlink;
+    get startOffset(): number | undefined;
+    get endOffset(): number | undefined;
+    get collapsed(): boolean;
+    get startNodePosition(): INodePosition | null;
+    get endNodePosition(): Nullable<INodePosition>;
+    get direction(): RANGE_DIRECTION;
+    get segmentId(): string;
+    get segmentPage(): number;
+    getAbsolutePosition(): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    } | undefined;
+    getAnchor(): Nullable<Rect<import('@univerjs/engine-render').IRectProps>>;
+    activeStatic(): void;
+    deactivateStatic(): void;
+    isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+    dispose(): void;
+    isIntersection(compareRange: TextRange): boolean;
+    refresh(): void;
+    private _isEmpty;
+    private _isCollapsed;
+    private _createOrUpdateRange;
+    private _createOrUpdateAnchor;
+    private _setCursorList;
+}

package/lib/types/types/const/padding.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare const DOC_VERTICAL_PADDING = 4;

package/lib/types/types/delete-direction.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare enum DeleteDirection {
+    LEFT = 0,
+    RIGHT = 1
+}

package/lib/types/views/paragraph-setting/hook/utils.d.ts

@@ -1,4 +1,4 @@
-import { IParagraph, ISectionBreak, SpacingRule } from '@univerjs/core';
+import { SpacingRule, IParagraph, ISectionBreak } from '@univerjs/core';
 export declare const useCurrentParagraph: () => IParagraph[];
 export declare const useCurrentSections: (currentParagraphs: IParagraph[]) => ISectionBreak[];
 export declare const useFirstParagraphHorizontalAlign: (paragraph: IParagraph[], defaultValue: string) => readonly [string, (v: string) => Promise<boolean>];