@univerjs-pro/slides-table-ui 1.0.0-alpha.2 → 1.0.0-alpha.3

package/lib/types/index.d.ts

@@ -1,11 +1,31 @@
 import './global.css';
-export { SLIDES_TABLE_UI_PLUGIN_CONFIG_KEY } from './config/config';
-export type { IUniverSlidesTableUIConfig } from './config/config';
-export { SlideTableInteractionRenderController } from './controllers/slide-table-interaction.render-controller';
 export { UniverSlidesTableUIPlugin } from './plugin';
-export type { ISlideTableKeyboardCommandParams, SlideTableKeyboardAction, } from './services/slide-table-keyboard.service';
-export { FOCUSING_SLIDE_TABLE, SlideTableKeyboardService } from './services/slide-table-keyboard.service';
-export type { ISelectSlideTableCellParams, ISelectSlideTableColumnsParams, ISelectSlideTableParams, ISelectSlideTableRangeParams, ISelectSlideTableRowsParams, ISlideTableSelection, ISlideTableSelectionBase, SlideTableSelectionKind, } from './services/slide-table-selection.service';
+export type { ISlideTableObjectControlState, ISlideTableObjectProps, } from './render-objects/slide-table-object';
+export { SlideTableObject } from './render-objects/slide-table-object';
+export type { ISlideTableCellEditorSession } from './services/slide-table-cell-editor.service';
+export { SlideTableCellEditorService } from './services/slide-table-cell-editor.service';
+export type { ISlideTableSelection } from './services/slide-table-selection.service';
 export { SlideTableSelectionService } from './services/slide-table-selection.service';
-export type { SlideTableHit } from './views/slide-table-hit-test';
-export { hitTestSlideTable } from './views/slide-table-hit-test';
+export { TableKeyboardServiceBase } from './services/table-keyboard.service-base';
+export { buildSlideTableClearTextPatch, buildSlideTablePasteTextPatch, serializeSlideTableSelectionToText, } from './utils/slide-table-clipboard-model';
+export { SLIDE_TABLE_CONTEXT_MENU_ACTIONS } from './utils/slide-table-contextmenu-model';
+export type { ISlideTableContextMenuAction, ISlideTableContextMenuCommand, SlideTableContextMenuActionId, } from './utils/slide-table-contextmenu-model';
+export { buildSlideTableBackgroundColorPatch, buildSlideTableBackgroundFillPatch, buildSlideTableBorderPresetPatch, buildSlideTableBorderStylePatch, buildSlideTableFontFamilyPatch, buildSlideTableFontSizePatch, buildSlideTableTextAlignPatch, buildSlideTableTextColorPatch, buildSlideTableTextFillPatch, buildSlideTableTextStylePatch, getSlideTableSelectionContext, } from './utils/slide-table-contextmenu-model';
+export type { ISlideTableContextMenuCommandIds, SlideTableTextAlignPreset, } from './utils/slide-table-contextmenu-model';
+export { buildSlideTableContextMenuCommand, resolveSlideTableContextMenuActions, } from './utils/slide-table-contextmenu-model';
+export { buildSlideTableCellEditorCommitCommand, normalizeSlideTableCellDocumentData, replaceSlideTableCellDocumentText, resolveSlideTableCellEditorLayout, resolveSlideTableCellEditorTarget, } from './utils/slide-table-editor-model';
+export type { ISlideTableCellEditorLayout, } from './utils/slide-table-editor-model';
+export { isSlideTableDocumentEditorTarget, isSlideTableEditableTarget, } from './utils/slide-table-keyboard-input';
+export type { SlideTableKeyboardInput, } from './utils/slide-table-keyboard-input';
+export type { SlideTableKeyboardAction } from './utils/slide-table-keyboard-model';
+export { buildSlideTableKeyboardShortcutBindings, resolveNextSlideTableKeyboardCell, resolveSlideTableKeyboardMovement, SLIDE_TABLE_KEYBOARD_SHORTCUT_DESCRIPTORS, } from './utils/slide-table-keyboard-model';
+export type { SlideTableKeyboardShortcutKey, } from './utils/slide-table-keyboard-model';
+export { resolveFirstSlideTableSelectionCell, resolveSlideTableObjectSelection, } from './utils/slide-table-object-selection-model';
+export { buildSlideTableInsertDotControlState, isSlideTableInsertDotTrigger, } from './utils/slide-table-structural-insert.util';
+export type { ISlideTableInsertDotTrigger, } from './utils/slide-table-structural-insert.util';
+export { buildSlideTableBorderPresetCommandParams, buildSlideTableCellStyleCommandParams, buildSlideTableMergeCellsCommandParams, buildSlideTableUnmergeCellsCommandParams, resolveSlideTableMergeToolbarAction, SLIDE_TABLE_TOOLBAR_ACTIONS, } from './utils/slide-table-toolbar-shared-model';
+export type { ISlideTableMergeToolbarState, ISlideTableToolbarAction, SlideTableToolbarActionId, } from './utils/slide-table-toolbar-shared-model';
+export { buildSlideTableDeleteToolbarCommand, buildSlideTableMergeToolbarCommand, resolveSlideTableToolbarActions, } from './utils/slide-table-toolbar-shared-model';
+export { getSlideTableFillType, resolveSlideTableDocumentHorizontalAlign, resolveSlideTableSelectionValues, SLIDE_TABLE_DEFAULT_BACKGROUND_COLOR, toCoreVerticalAlign, } from './utils/slide-table-toolbar-values';
+export type { ISlideTableToolbarCellValues, SlideTableFillType, } from './utils/slide-table-toolbar-values';
+export { TableThemeGallery } from './views/TableThemeGallery';

package/lib/types/locale/en-US.d.ts

@@ -3,6 +3,11 @@ declare const locale: {
         editorToolbar: {
             fontFamily: string;
             fontSize: string;
+            textFormat: string;
+            bold: string;
+            italic: string;
+            underline: string;
+            strikethrough: string;
             textColor: string;
             textBackgroundColor: string;
             tableBackgroundColor: string;
@@ -36,6 +41,18 @@ declare const locale: {
             alignBottom: string;
             mergeCells: string;
             unmergeCells: string;
+            tableTheme: string;
+            tableLook: string;
+            headerRow: string;
+            footerRow: string;
+            bandedRows: string;
+            bandedColumns: string;
+            firstColumn: string;
+            lastColumn: string;
+            bestMatch: string;
+            light: string;
+            medium: string;
+            minimal: string;
         };
         shapePanel: {
             fill: {

package/lib/types/menu/contextmenu.menu.d.ts

@@ -1,6 +1,5 @@
 import type { IAccessor } from '@univerjs/core';
 import type { IMenuButtonItem, IMenuSelectorItem } from '@univerjs/ui';
-import type { SlideTablePresetOperation } from '../commands/operations/table-contextmenu.operation';
 import type { LocaleKey } from '../locale/types';
 export declare const SLIDE_TABLE_INSERT_MENU_ID = "slide-table.menu.insert";
 export declare const SLIDE_TABLE_DELETE_MENU_ID = "slide-table.menu.delete";
@@ -37,8 +36,6 @@ export declare function SlideTableBorderAllFactory(): IMenuButtonItem<LocaleKey>
 export declare function SlideTableBorderOuterFactory(): IMenuButtonItem<LocaleKey>;
 export declare function SlideTableBorderInnerFactory(): IMenuButtonItem<LocaleKey>;
 export declare function SlideTableBorderNoneFactory(): IMenuButtonItem<LocaleKey>;
-export declare function getSlideTableBackgroundColorMenuItems(): SlideTablePresetOperation[];
-export declare function getSlideTableTextColorMenuItems(): SlideTablePresetOperation[];
 export declare function SlideTableAlignLeftFactory(): IMenuButtonItem<LocaleKey>;
 export declare function SlideTableAlignCenterFactory(): IMenuButtonItem<LocaleKey>;
 export declare function SlideTableAlignRightFactory(): IMenuButtonItem<LocaleKey>;

package/lib/types/render-objects/slide-table-document-render-resources.util.d.ts

@@ -0,0 +1,42 @@
+import type { BooleanNumber, HorizontalAlign, IDocumentData, LocaleService } from '@univerjs/core';
+import type { UniverRenderingContext } from '@univerjs/engine-render';
+import { DocumentDataModel, VerticalAlign, WrapStrategy } from '@univerjs/core';
+import { Documents, DocumentSkeleton, DocumentViewModel } from '@univerjs/engine-render';
+export interface ICreateSlideTableDocumentRenderResourcesOptions {
+    documentData: IDocumentData;
+    id?: string;
+    isHorizontal?: boolean;
+    horizontalAlign?: HorizontalAlign;
+    verticalAlign?: VerticalAlign;
+    localeService: LocaleService;
+    shapeTextOpticalVerticalAlign?: BooleanNumber | boolean;
+    size: {
+        width: number;
+        height: number;
+    };
+    wrapStrategy?: WrapStrategy;
+}
+export interface ISlideTableDocumentRenderResources {
+    actualHeight: number;
+    contentHeight: number;
+    dispose: () => void;
+    documents: Documents;
+    docModel: DocumentDataModel;
+    docViewModel: DocumentViewModel;
+    marginTop: number;
+    minHeight: number;
+    opticalVerticalOffset: number;
+    skeleton: DocumentSkeleton;
+    width: number;
+}
+export declare function getSlideTableTextOpticalVerticalOffset(skeleton: DocumentSkeleton, targetHeight: number, verticalAlign?: VerticalAlign): number;
+export declare function prepareSlideTableDocumentRenderData(documentData: IDocumentData, options: {
+    height: number;
+    horizontalAlign?: HorizontalAlign;
+    isHorizontal?: boolean;
+    verticalAlign?: VerticalAlign;
+    width: number;
+    wrapStrategy?: WrapStrategy;
+}): IDocumentData;
+export declare function createSlideTableDocumentRenderResources(options: ICreateSlideTableDocumentRenderResourcesOptions): ISlideTableDocumentRenderResources;
+export declare function drawSlideTableDocumentRenderResources(context: UniverRenderingContext, resources: ISlideTableDocumentRenderResources, left: number, top: number, clip: boolean): void;

package/lib/types/render-objects/slide-table-document-text-render.util.d.ts

@@ -0,0 +1,26 @@
+import type { BooleanNumber, HorizontalAlign, IDocumentData, LocaleService, VerticalAlign } from '@univerjs/core';
+import type { UniverRenderingContext } from '@univerjs/engine-render';
+import type { ISlideTableDocumentRenderResources } from './slide-table-document-render-resources.util';
+import { WrapStrategy } from '@univerjs/core';
+export interface IRenderSlideTableDocumentTextOptions {
+    clip?: boolean;
+    documentData?: IDocumentData;
+    height: number;
+    horizontalAlign?: HorizontalAlign;
+    isHorizontal?: boolean;
+    key: string;
+    left: number;
+    localeService?: LocaleService;
+    shapeTextOpticalVerticalAlign?: BooleanNumber | boolean;
+    text?: string;
+    top: number;
+    verticalAlign?: VerticalAlign;
+    width: number;
+    wrapStrategy?: WrapStrategy;
+}
+export interface ISlideTableDocumentTextRenderCache {
+    resources?: ISlideTableDocumentRenderResources;
+    signature?: string;
+}
+export declare function disposeSlideTableDocumentTextRenderCache(cache?: ISlideTableDocumentTextRenderCache): void;
+export declare function renderSlideTableTextWithDocumentModel(ctx: UniverRenderingContext, options: IRenderSlideTableDocumentTextOptions, cache?: ISlideTableDocumentTextRenderCache): boolean;

package/lib/types/render-objects/slide-table-object.d.ts

@@ -0,0 +1,127 @@
+import type { ISlideTableCellRange, ISlideTableControl, ISlideTableResolvedCell, ISlideTableSnapshot, ISlideTableThemePalette, ISlideTableTrigger } from '@univerjs-pro/slides-table';
+import type { LocaleService } from '@univerjs/core';
+import type { IRectProps, IViewportInfo, UniverRenderingContext, Vector2 } from '@univerjs/engine-render';
+import type { SlideTableHit } from '../utils/slide-table-hit-test';
+import { Rect } from '@univerjs/engine-render';
+export interface ISlideTableObjectProps extends IRectProps {
+    controlButtonMode?: 'all' | 'table-handle';
+    localeService?: LocaleService;
+    table?: ISlideTableSnapshot | null;
+    tableThemePalette?: ISlideTableThemePalette;
+}
+export interface ISlideTableCellTextRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    row: number;
+    column: number;
+}
+export interface ISlideTableObjectSelection {
+    kind?: 'table' | 'cell' | 'range' | 'row' | 'column' | 'text';
+    ranges: ISlideTableCellRange[];
+    active?: {
+        row: number;
+        column: number;
+    };
+}
+export interface ISlideTableObjectControlHover {
+    kind?: ISlideTableControl['kind'];
+    row?: number | null;
+    column?: number | null;
+}
+export interface ISlideTableObjectCellHover {
+    row: number;
+    column: number;
+}
+export interface ISlideTableObjectEditingCell {
+    row: number;
+    column: number;
+}
+export interface ISlideTableObjectStructuralRange {
+    kind: 'row' | 'column';
+    start: number;
+    end: number;
+}
+export interface ISlideTableObjectStructuralGuide {
+    kind: 'row' | 'column';
+    index: number;
+}
+export interface ISlideTableObjectControlState {
+    visible?: boolean;
+    hoveredTrigger?: ISlideTableTrigger | null;
+    selectedStructuralRange?: ISlideTableObjectStructuralRange | null;
+    insertGuide?: ISlideTableObjectStructuralGuide | null;
+    reorderGuide?: ISlideTableObjectStructuralGuide | null;
+}
+export declare function isSlideTableRenderCellIntersectingSelection(cell: Pick<ISlideTableResolvedCell, 'row' | 'column' | 'rowSpan' | 'columnSpan'>, ranges: ISlideTableCellRange[]): boolean;
+export declare class SlideTableObject extends Rect<ISlideTableObjectProps> {
+    isDrawingObject: boolean;
+    private readonly _controlButtonMode;
+    private _table;
+    private _previewTable;
+    private _selection;
+    private _cellHover;
+    private _editingCell;
+    private _controlHover;
+    private _controlState;
+    private _localeService?;
+    private _tableThemePalette?;
+    private _textRenderCaches;
+    constructor(key: string, props: ISlideTableObjectProps);
+    setTable(table: ISlideTableSnapshot | null | undefined): void;
+    getTable(): ISlideTableSnapshot | null;
+    setPreviewTable(table: ISlideTableSnapshot | null): void;
+    setLocaleService(localeService: LocaleService | undefined): void;
+    setTableThemePalette(palette: ISlideTableThemePalette | undefined): void;
+    setTableSelection(selection: ISlideTableObjectSelection | null): void;
+    getTableSelection(): ISlideTableObjectSelection | null;
+    setEditingCell(cell: ISlideTableObjectEditingCell | null): void;
+    getEditingCell(): ISlideTableObjectEditingCell | null;
+    setTableControlHover(hover: ISlideTableObjectControlHover | null): boolean;
+    setTableCellHover(hover: ISlideTableObjectCellHover | null): boolean;
+    setTableControlState(state: ISlideTableObjectControlState | null): boolean;
+    getInverseCoord(coord: Vector2): Vector2;
+    isHit(coord: Vector2): boolean;
+    getCellTextRect(row: number, column: number, width?: number, height?: number): ISlideTableCellTextRect | null;
+    hitTestCellAtScenePoint(scenePoint: Vector2, width?: number, height?: number): SlideTableHit | null;
+    hitTestControlAtScenePoint(scenePoint: Vector2, width?: number, height?: number): ISlideTableControl | null;
+    hitTestStructuralTriggerAtScenePoint(scenePoint: Vector2, width?: number, height?: number): ISlideTableTrigger | null;
+    hitTestFloatingStructuralTriggerAtScenePoint(scenePoint: Vector2, width?: number, height?: number): ISlideTableTrigger | null;
+    render(mainCtx: UniverRenderingContext, bounds: IViewportInfo): this;
+    _draw(ctx: UniverRenderingContext, _bounds?: IViewportInfo, renderWidth?: number, renderHeight?: number): void;
+    private _getRenderTable;
+    private _resolveRenderModel;
+    private _drawRowFills;
+    private _drawCellFills;
+    private _drawCellTexts;
+    private _isEditingCell;
+    private _getTextRenderCache;
+    private _disposeTextRenderCaches;
+    private _drawCellBorders;
+    private _drawGrid;
+    private _drawTableOutline;
+    private _drawSelection;
+    private _drawCellHover;
+    private _drawControls;
+    private _drawStructuralHeaders;
+    private _drawStructuralHeaderRect;
+    private _drawInsertDots;
+    private _drawInsertGuide;
+    private _drawReorderGuide;
+    private _drawGuideLine;
+    private _drawTableHandle;
+    private _shouldDrawControls;
+    private _shouldDrawStructuralHeaders;
+    private _shouldDrawInsertDots;
+    private _isActiveOuterChromeHit;
+    private _buildControlButtons;
+    private _isPointInStructuralTriggerEnvelope;
+    private _isControlHovered;
+    private _isControlSelected;
+    private _isStructuralHeaderHovered;
+    private _isHoveredStructuralTrigger;
+    private _isStructuralRangeSelected;
+    private _buildStructuralTriggers;
+    private _getStructuralControlZoom;
+}

package/lib/types/services/slide-table-cell-editor.service.d.ts

@@ -0,0 +1,50 @@
+import type { HorizontalAlign, IDisposable, IDocumentData, ITransformState, VerticalAlign } from '@univerjs/core';
+import { Disposable } from '@univerjs/core';
+export interface ISlideTableCellEditorRect {
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+}
+export interface ISlideTableCellEditorMeasurement {
+    width: number;
+    minHeight: number;
+    actualHeight: number;
+    contentHeight: number;
+    marginTop: number;
+}
+export interface ISlideTableCellEditorSession {
+    column: number;
+    documentData: IDocumentData;
+    elementId: string;
+    horizontalAlign?: HorizontalAlign;
+    isHorizontal?: boolean;
+    measurement?: ISlideTableCellEditorMeasurement;
+    rect: ISlideTableCellEditorRect;
+    row: number;
+    subUnitId: string;
+    tableId: string;
+    tableTransform: ITransformState;
+    unitId: string;
+    verticalAlign?: VerticalAlign;
+    onCancel?: (session: ISlideTableCellEditorSession) => void;
+    onChange?: (session: ISlideTableCellEditorSession) => void;
+    onComplete?: (session: ISlideTableCellEditorSession) => void;
+}
+export type IOpenSlideTableCellEditorSession = Omit<ISlideTableCellEditorSession, 'onCancel' | 'onChange' | 'onComplete'> & {
+    onCancel?: (session: ISlideTableCellEditorSession) => void;
+    onChange?: (session: ISlideTableCellEditorSession) => void;
+    onComplete?: (session: ISlideTableCellEditorSession) => void;
+};
+export declare class SlideTableCellEditorService extends Disposable {
+    private readonly _session$;
+    readonly session$: import("rxjs").Observable<ISlideTableCellEditorSession | null>;
+    open(session: IOpenSlideTableCellEditorSession): IDisposable;
+    update(params: Partial<Pick<ISlideTableCellEditorSession, 'documentData' | 'measurement' | 'rect' | 'tableTransform'>>): void;
+    complete(documentData?: IDocumentData): void;
+    cancel(): void;
+    close(): void;
+    getSession(): ISlideTableCellEditorSession | null;
+    subscribe(listener: (session: ISlideTableCellEditorSession | null) => void): IDisposable;
+    dispose(): void;
+}

package/lib/types/services/slide-table-keyboard.service.d.ts

@@ -1,28 +1,14 @@
-import type { IDisposable } from '@univerjs/core';
-import { Disposable, IContextService } from '@univerjs/core';
+import type { SlideTableKeyboardAction } from '../utils/slide-table-keyboard-model';
+import { IContextService } from '@univerjs/core';
+import { TableKeyboardServiceBase } from './table-keyboard.service-base';
 export declare const FOCUSING_SLIDE_TABLE = "FOCUSING_SLIDE_TABLE";
-export type SlideTableKeyboardAction = 'move-left' | 'move-right' | 'move-up' | 'move-down' | 'extend-left' | 'extend-right' | 'extend-up' | 'extend-down' | 'tab-forward' | 'tab-backward' | 'edit-cell' | 'clear-cells';
-export type SlideTableKeyboardInput = {
-    kind: 'text';
-    text: string;
-} | {
-    kind: 'composition-start';
-} | {
-    kind: 'composition';
-    text?: string;
-};
 export interface ISlideTableKeyboardCommandParams {
     action: SlideTableKeyboardAction;
 }
-export declare class SlideTableKeyboardService extends Disposable {
+export declare class SlideTableKeyboardService extends TableKeyboardServiceBase {
     private readonly _contextService?;
-    private _handler;
-    private _inputHandler;
     constructor(_contextService?: IContextService | undefined);
-    setHandler(handler: (action: SlideTableKeyboardAction) => boolean): IDisposable;
-    setInputHandler(handler: (input: SlideTableKeyboardInput) => boolean): IDisposable;
-    handle(action: SlideTableKeyboardAction): boolean;
-    handleInput(input: SlideTableKeyboardInput): boolean;
-    private _initNativeInputListeners;
-    private _canHandleNativeInput;
+    protected canHandleNativeInput(event: Event, options?: {
+        allowDocsEditor?: boolean;
+    }): boolean;
 }

package/lib/types/services/table-keyboard.service-base.d.ts

@@ -0,0 +1,18 @@
+import type { IDisposable } from '@univerjs/core';
+import type { SlideTableKeyboardInput } from '../utils/slide-table-keyboard-input';
+import type { SlideTableKeyboardAction } from '../utils/slide-table-keyboard-model';
+import { Disposable } from '@univerjs/core';
+export type TableKeyboardHandlerResult = boolean | Promise<boolean>;
+export declare abstract class TableKeyboardServiceBase extends Disposable {
+    private _handler;
+    private _inputHandler;
+    constructor();
+    setHandler(handler: (action: SlideTableKeyboardAction) => TableKeyboardHandlerResult): IDisposable;
+    setInputHandler(handler: (input: SlideTableKeyboardInput) => boolean): IDisposable;
+    handle(action: SlideTableKeyboardAction): TableKeyboardHandlerResult;
+    handleInput(input: SlideTableKeyboardInput): boolean;
+    protected abstract canHandleNativeInput(event: Event, options?: {
+        allowDocsEditor?: boolean;
+    }): boolean;
+    private _initNativeInputListeners;
+}

package/lib/types/utils/slide-table-clipboard-model.d.ts

@@ -0,0 +1,7 @@
+import type { ISlideTableSnapshot } from '@univerjs-pro/slides-table';
+import type { IDocumentData } from '@univerjs/core';
+import type { ISlideTableSelection } from '../services/slide-table-selection.service';
+export declare function serializeSlideTableSelectionToText(table: ISlideTableSnapshot | null | undefined, selection: ISlideTableSelection | null | undefined): string;
+export declare function buildSlideTablePasteTextPatch(table: ISlideTableSnapshot | null | undefined, selection: ISlideTableSelection | null | undefined, text: string): Partial<ISlideTableSnapshot> | null;
+export declare function buildSlideTableClearTextPatch(table: ISlideTableSnapshot | null | undefined, selection: ISlideTableSelection | null | undefined): Partial<ISlideTableSnapshot> | null;
+export declare function extractSlideTableCellPlainText(documentData: IDocumentData | undefined): string;

package/lib/types/utils/slide-table-contextmenu-model.d.ts

@@ -0,0 +1,69 @@
+import type { ISlideTableBorder, ISlideTableCellRange, ISlideTableFill, ISlideTableSnapshot, SlideTableBorderPresetEnum } from '@univerjs-pro/slides-table';
+import type { HorizontalAlign, IDocTextFill } from '@univerjs/core';
+import type { ISlideTableSelection } from '../services/slide-table-selection.service';
+import { VerticalAlign } from '@univerjs/core';
+export type SlideTableDistributeAxis = 'row' | 'column';
+export type SlideTableTextAlignPreset = {
+    axis: 'horizontal';
+    value: HorizontalAlign;
+} | {
+    axis: 'vertical';
+    value: VerticalAlign;
+};
+export declare const SLIDE_TABLE_CONTEXT_MENU_ACTIONS: {
+    readonly InsertRowAbove: "insert-row-above";
+    readonly InsertRowBelow: "insert-row-below";
+    readonly InsertColumnLeft: "insert-column-left";
+    readonly InsertColumnRight: "insert-column-right";
+    readonly DeleteRows: "delete-rows";
+    readonly DeleteColumns: "delete-columns";
+    readonly MergeCells: "merge-cells";
+    readonly UnmergeCells: "unmerge-cells";
+    readonly DistributeRows: "distribute-rows";
+    readonly DistributeColumns: "distribute-columns";
+};
+export type SlideTableContextMenuActionId = typeof SLIDE_TABLE_CONTEXT_MENU_ACTIONS[keyof typeof SLIDE_TABLE_CONTEXT_MENU_ACTIONS];
+export interface ISlideTableContextMenuCommandIds {
+    insertRows: string;
+    insertColumns: string;
+    deleteRows: string;
+    deleteColumns: string;
+    mergeCells: string;
+    unmergeCells: string;
+    updateTable: string;
+}
+export interface ISlideTableContextMenuAction {
+    id: SlideTableContextMenuActionId;
+    commandId: string;
+    enabled: boolean;
+}
+export interface ISlideTableContextMenuCommand {
+    commandId: string;
+    params: object;
+}
+export declare function getSlideTableSelectionContext(selection: ISlideTableSelection | null): {
+    elementId: string;
+    range: ISlideTableCellRange;
+    subUnitId: string;
+    tableId: string;
+    unitId: string;
+} | null;
+export declare function resolveSlideTableContextMenuActions(table: ISlideTableSnapshot | null | undefined, selection: ISlideTableSelection | null, commandIds: ISlideTableContextMenuCommandIds): ISlideTableContextMenuAction[];
+export declare function buildSlideTableContextMenuCommand(table: ISlideTableSnapshot | null | undefined, selection: ISlideTableSelection | null, actionId: SlideTableContextMenuActionId, commandIds: ISlideTableContextMenuCommandIds): ISlideTableContextMenuCommand | null;
+export declare function buildSlideTableDistributePatch(table: ISlideTableSnapshot, axis: SlideTableDistributeAxis, sourceRange?: ISlideTableCellRange): Partial<ISlideTableSnapshot>;
+export declare function buildSlideTableTextAlignPatch(table: ISlideTableSnapshot, sourceRange: ISlideTableCellRange, preset: SlideTableTextAlignPreset): Partial<ISlideTableSnapshot>;
+export declare function buildSlideTableBackgroundColorPatch(table: ISlideTableSnapshot, sourceRange: ISlideTableCellRange, color: string | undefined): Partial<ISlideTableSnapshot>;
+export declare function buildSlideTableBackgroundFillPatch(table: ISlideTableSnapshot, sourceRange: ISlideTableCellRange, fill: ISlideTableFill | undefined): Partial<ISlideTableSnapshot>;
+export declare function buildSlideTableTextColorPatch(table: ISlideTableSnapshot, sourceRange: ISlideTableCellRange, color: string | undefined): Partial<ISlideTableSnapshot>;
+export declare function buildSlideTableTextFillPatch(table: ISlideTableSnapshot, sourceRange: ISlideTableCellRange, fill: IDocTextFill | undefined): Partial<ISlideTableSnapshot>;
+export declare function buildSlideTableBorderStylePatch(table: ISlideTableSnapshot, sourceRange: ISlideTableCellRange, borderPatch: Partial<ISlideTableBorder>): Partial<ISlideTableSnapshot>;
+export declare function buildSlideTableBorderPresetPatch(table: ISlideTableSnapshot, sourceRange: ISlideTableCellRange, preset: SlideTableBorderPresetEnum, border?: ISlideTableBorder): Partial<ISlideTableSnapshot>;
+export declare function buildSlideTableFontFamilyPatch(table: ISlideTableSnapshot, sourceRange: ISlideTableCellRange, fontFamily: string): Partial<ISlideTableSnapshot>;
+export declare function buildSlideTableFontSizePatch(table: ISlideTableSnapshot, sourceRange: ISlideTableCellRange, fontSize: number): Partial<ISlideTableSnapshot>;
+export declare function canMergeSlideTableSelection(selection: ISlideTableSelection | null): boolean;
+export declare function canUnmergeSlideTableSelection(table: ISlideTableSnapshot | null | undefined, selection: ISlideTableSelection | null): boolean;
+export declare function canDeleteSlideTableRows(table: ISlideTableSnapshot | null | undefined, selection: ISlideTableSelection | null): boolean;
+export declare function canDeleteSlideTableColumns(table: ISlideTableSnapshot | null | undefined, selection: ISlideTableSelection | null): boolean;
+export declare function canDistributeSlideTableRows(table: ISlideTableSnapshot | null | undefined, selection: ISlideTableSelection | null): boolean;
+export declare function canDistributeSlideTableColumns(table: ISlideTableSnapshot | null | undefined, selection: ISlideTableSelection | null): boolean;
+export declare function buildSlideTableTextStylePatch(table: ISlideTableSnapshot, sourceRange: ISlideTableCellRange, textStylePatch: Record<string, unknown>): Partial<ISlideTableSnapshot>;

package/lib/types/utils/slide-table-editor-model.d.ts

@@ -0,0 +1,78 @@
+import type { ISlideTableCellStyle, ISlideTableSnapshot } from '@univerjs-pro/slides-table';
+import type { HorizontalAlign, IDocumentData, ITransformState, VerticalAlign } from '@univerjs/core';
+import type { ISlideTableCellEditorSession } from '../services/slide-table-cell-editor.service';
+import type { ISlideTableSelection } from '../services/slide-table-selection.service';
+export interface IResolveSlideTableCellEditorTargetParams {
+    selection: ISlideTableSelection | null;
+    table: ISlideTableSnapshot | null | undefined;
+    tableHeight: number;
+    tableWidth: number;
+}
+export interface ISlideTableCellEditorTarget {
+    column: number;
+    documentData: IDocumentData;
+    cellStyle?: ISlideTableCellStyle;
+    rect: {
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+    };
+    row: number;
+}
+export interface ISlideTableCellEditorLayout {
+    rect: {
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+    };
+    scale: {
+        scaleX: number;
+        scaleY: number;
+    };
+    transform: {
+        angle: number;
+        flipX: boolean;
+        flipY?: boolean;
+    };
+    horizontalAlign?: HorizontalAlign;
+    verticalAlign?: VerticalAlign;
+    isHorizontal?: boolean;
+}
+export interface IResolveSlideTableCellEditorLayoutParams {
+    rect: {
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+    };
+    scale?: {
+        scaleX?: number;
+        scaleY?: number;
+    };
+    scenePointToViewportPoint: (point: {
+        x: number;
+        y: number;
+    }) => {
+        x: number;
+        y: number;
+    };
+    tableTransform: ITransformState;
+}
+export interface ISlideTableCellEditorCommitCommand {
+    commandId: string;
+    params: {
+        column: number;
+        row: number;
+        tableId: string;
+        textData: IDocumentData;
+        unitId: string;
+    };
+}
+export declare function resolveSlideTableCellEditorTarget(params: IResolveSlideTableCellEditorTargetParams): ISlideTableCellEditorTarget | null;
+export declare function createSlideTableCellDocumentData(tableId: string, row: number, column: number, text?: string): IDocumentData;
+export declare function replaceSlideTableCellDocumentText(documentData: IDocumentData, text: string): IDocumentData;
+export declare function resolveSlideTableCellEditorLayout(params: IResolveSlideTableCellEditorLayoutParams): ISlideTableCellEditorLayout;
+export declare function buildSlideTableCellEditorCommitCommand(session: ISlideTableCellEditorSession | null, documentData: IDocumentData, commandId: string): ISlideTableCellEditorCommitCommand | null;
+export declare function normalizeSlideTableCellDocumentData(documentData: IDocumentData | undefined, fallbackId: string): IDocumentData;

package/lib/types/utils/slide-table-keyboard-input.d.ts

@@ -0,0 +1,13 @@
+export type SlideTableKeyboardInput = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'composition-start';
+} | {
+    kind: 'composition';
+    text?: string;
+};
+export declare function isSlideTablePlainTextKeyEvent(event: Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'key' | 'metaKey'>): boolean;
+export declare function isSlideTableInsertTextInputType(inputType: string): boolean;
+export declare function isSlideTableEditableTarget(target: EventTarget | null): boolean;
+export declare function isSlideTableDocumentEditorTarget(target: EventTarget | null): boolean;

package/lib/types/utils/slide-table-keyboard-model.d.ts

@@ -0,0 +1,43 @@
+export type SlideTableKeyboardAction = 'move-left' | 'move-right' | 'move-up' | 'move-down' | 'extend-left' | 'extend-right' | 'extend-up' | 'extend-down' | 'tab-forward' | 'tab-backward' | 'edit-cell' | 'clear-cells' | 'copy-cells' | 'paste-cells';
+export type SlideTableKeyboardShortcutKey = 'arrow-left' | 'arrow-right' | 'arrow-up' | 'arrow-down' | 'shift-arrow-left' | 'shift-arrow-right' | 'shift-arrow-up' | 'shift-arrow-down' | 'tab' | 'shift-tab' | 'enter' | 'f2' | 'delete' | 'backspace' | 'copy' | 'paste';
+export interface ISlideTableKeyboardMovement {
+    rowDelta: number;
+    columnDelta: number;
+    extend: boolean;
+    wrap?: boolean;
+}
+export interface ISlideTableKeyboardShortcutDescriptor {
+    action: SlideTableKeyboardAction;
+    key: SlideTableKeyboardShortcutKey;
+}
+export interface ISlideTableKeyboardShortcutBinding {
+    action: SlideTableKeyboardAction;
+    binding: number;
+}
+export type SlideTableKeyboardCellMovement = Pick<ISlideTableKeyboardMovement, 'rowDelta' | 'columnDelta' | 'wrap'> & {
+    extend?: boolean;
+};
+export declare const SLIDE_TABLE_KEYBOARD_SHORTCUT_DESCRIPTORS: readonly ISlideTableKeyboardShortcutDescriptor[];
+export declare function buildSlideTableKeyboardShortcutBindings(bindings: Record<SlideTableKeyboardShortcutKey, number>): ISlideTableKeyboardShortcutBinding[];
+export declare function resolveSlideTableKeyboardMovement(action: SlideTableKeyboardAction): ISlideTableKeyboardMovement | null;
+export declare function resolveNextSlideTableKeyboardCell(focus: {
+    row: number;
+    column: number;
+}, movement: SlideTableKeyboardCellMovement, rowCount: number, columnCount: number): {
+    row: number;
+    column: number;
+};
+export declare function clampSlideTableCellPosition(position: {
+    row: number;
+    column: number;
+}, rowCount: number, columnCount: number): {
+    row: number;
+    column: number;
+};
+export declare function wrapSlideTableCellPosition(focus: {
+    row: number;
+    column: number;
+}, movement: Pick<SlideTableKeyboardCellMovement, 'rowDelta' | 'columnDelta'>, rowCount: number, columnCount: number): {
+    row: number;
+    column: number;
+};

package/lib/types/utils/slide-table-object-selection-model.d.ts

@@ -0,0 +1,7 @@
+import type { ISlideTableObjectSelection } from '../render-objects/slide-table-object';
+import type { ISlideTableSelection } from '../services/slide-table-selection.service';
+export declare function resolveSlideTableObjectSelection(selection: ISlideTableSelection | null): ISlideTableObjectSelection | null;
+export declare function resolveFirstSlideTableSelectionCell(selection: Pick<ISlideTableSelection, 'ranges'>): {
+    row: number;
+    column: number;
+} | undefined;

package/lib/types/utils/slide-table-structural-insert.util.d.ts

@@ -0,0 +1,15 @@
+import type { ISlideTableTrigger } from '@univerjs-pro/slides-table';
+import type { ISlideTableObjectControlState } from '../render-objects/slide-table-object';
+export type ISlideTableInsertDotTrigger = ISlideTableTrigger & ({
+    kind: 'row-insert-dot';
+    row: number;
+} | {
+    kind: 'column-insert-dot';
+    column: number;
+});
+export declare function isSlideTableInsertDotTrigger(trigger: {
+    kind?: string;
+    row?: number;
+    column?: number;
+} | null | undefined): trigger is ISlideTableInsertDotTrigger;
+export declare function buildSlideTableInsertDotControlState(trigger: ISlideTableInsertDotTrigger): ISlideTableObjectControlState;