xiaodao-spreader 0.1.4 → 0.1.6

package/dist/types/components/spreader/{colorPicker.vue.d.ts → components/pickers/colorPicker.vue.d.ts}

@@ -3,6 +3,7 @@ type __VLS_Props = {
     colorKey?: string;
     currentColor?: string;
     locale?: string;
+    triggerEl?: HTMLElement | null;
 };
 declare function openMenu(): void;
 declare function close(): void;
@@ -10,16 +11,17 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {
     open: import("vue").Ref<boolean, boolean>;
     openMenu: typeof openMenu;
     close: typeof close;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    "update:modelValue": (v: string) => any;
-    change: (v: string) => any;
-    "update:modelOpen": (v: boolean) => any;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (v: string) => void;
+    change: (v: string) => void;
+    "update:modelOpen": (v: boolean) => void;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((v: string) => any) | undefined;
     onChange?: ((v: string) => any) | undefined;
     "onUpdate:modelOpen"?: ((v: boolean) => any) | undefined;
 }>, {
     modelOpen: boolean;
+    triggerEl: HTMLElement | null;
     currentColor: string;
     colorKey: string;
     locale: string;

package/dist/types/components/spreader/components/pickers/mergePicker.vue.d.ts

@@ -0,0 +1,27 @@
+import { type MergeType } from '../../core/constants';
+type __VLS_Props = {
+    modelOpen?: boolean;
+    locale?: string;
+    triggerEl?: HTMLElement | null;
+};
+declare function openMenu(): void;
+declare function close(): void;
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    open: import("vue").Ref<boolean, boolean>;
+    openMenu: typeof openMenu;
+    close: typeof close;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    change: (v: MergeType) => any;
+    "update:modelOpen": (v: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((v: MergeType) => any) | undefined;
+    "onUpdate:modelOpen"?: ((v: boolean) => any) | undefined;
+}>, {
+    modelOpen: boolean;
+    triggerEl: HTMLElement | null;
+    locale: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    rootRef: HTMLDivElement;
+    menuRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/types/components/spreader/{spreader.vue.d.ts → components/spreadsheet.vue.d.ts}

@@ -1,4 +1,4 @@
-import type { SheetModelData } from './types';
+import type { SheetModelData } from '../core/types';
 type __VLS_Props = {
     rowCount?: number;
     colCount?: number;
@@ -19,11 +19,5 @@ declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {},
     rowCount: number;
     colCount: number;
     theme: "light" | "dark";
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
-    formulaBarRef: HTMLInputElement;
-    wrapperRef: HTMLDivElement;
-    canvasRef: HTMLCanvasElement;
-    editInputRef: HTMLTextAreaElement;
-    dimInputRef: HTMLInputElement;
-}, HTMLDivElement>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/dist/types/components/spreader/{tabbar.vue.d.ts → components/tabbar.vue.d.ts}

@@ -1,4 +1,4 @@
-import type { SheetState } from './types';
+import type { SheetState } from '../core/types';
 type __VLS_Props = {
     locale: string;
     sheets: SheetState[];
@@ -6,18 +6,18 @@ type __VLS_Props = {
     renTab: number | null;
     renTabVal: string;
 };
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    "tab-click": (i: number) => any;
-    "tab-dblclick": (i: number) => any;
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "tab-click": (i: number) => void;
+    "tab-dblclick": (i: number) => void;
     "tab-contextmenu": (payload: {
         ev: MouseEvent;
         i: number;
-    }) => any;
-    "tab-rename-input": (v: string) => any;
-    "tab-rename-keydown": (ev: KeyboardEvent) => any;
-    "tab-rename-commit": () => any;
-    "tabbar-contextmenu": (ev: MouseEvent) => any;
-    "add-sheet": () => any;
+    }) => void;
+    "tab-rename-input": (v: string) => void;
+    "tab-rename-keydown": (ev: KeyboardEvent) => void;
+    "tab-rename-commit": () => void;
+    "add-sheet": () => void;
+    "tabbar-contextmenu": (ev: MouseEvent) => void;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onTab-click"?: ((i: number) => any) | undefined;
     "onTab-dblclick"?: ((i: number) => any) | undefined;
@@ -28,7 +28,7 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
     "onTab-rename-input"?: ((v: string) => any) | undefined;
     "onTab-rename-keydown"?: ((ev: KeyboardEvent) => any) | undefined;
     "onTab-rename-commit"?: (() => any) | undefined;
-    "onTabbar-contextmenu"?: ((ev: MouseEvent) => any) | undefined;
     "onAdd-sheet"?: (() => any) | undefined;
+    "onTabbar-contextmenu"?: ((ev: MouseEvent) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

package/dist/types/components/spreader/components/toolbar.vue.d.ts

@@ -0,0 +1,111 @@
+import type { FontOption, MergeType } from '../core/constants';
+import { type BorderType } from './pickers/borderPicker.vue';
+type __VLS_Props = {
+    locale: string;
+    canUndo: boolean;
+    canRedo: boolean;
+    paintFmtActive: boolean;
+    hasSelection: boolean;
+    fontFamilyOptions: FontOption[];
+    fontSizeOptions: FontOption[];
+    selFontFamily: string | number;
+    selFontSize: number;
+    fontSizeInput: string;
+    fontSizeMenuOpen: boolean;
+    selFontWeight: boolean;
+    selFontStyle: boolean;
+    selUnderline: boolean;
+    selStrikethrough: boolean;
+    selTextColor: string;
+    textColorMenuOpen: boolean;
+    selFillColor: string;
+    fillColorMenuOpen: boolean;
+    cachedTextColor: string;
+    cachedFillColor: string;
+    borderMenuOpen: boolean;
+    cachedBorder: BorderType;
+    selHAlign: string;
+    selVAlign: string;
+    selWrap: boolean;
+    hAlignOptions: FontOption[];
+    vAlignOptions: FontOption[];
+    mergeMenuOpen: boolean;
+    themeVars?: Record<string, string>;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    undo: () => void;
+    redo: () => void;
+    "paint-format": () => void;
+    "clear-format": () => void;
+    "font-size-blur": () => void;
+    "font-size-toggle": () => void;
+    "font-size-step-up": () => void;
+    "font-size-step-down": () => void;
+    "bold-toggle": () => void;
+    "italic-toggle": () => void;
+    "underline-toggle": () => void;
+    "strikethrough-toggle": () => void;
+    "apply-text-color": () => void;
+    "apply-fill-color": () => void;
+    "apply-border": () => void;
+    "wrap-toggle": () => void;
+    "apply-merge": () => void;
+    "font-family-change": (v: string | number) => void;
+    "font-size-change": (v: string | number) => void;
+    "h-align-change": (v: string | number) => void;
+    "v-align-change": (v: string | number) => void;
+    "font-size-input": (v: string) => void;
+    "text-color-change": (v: string) => void;
+    "fill-color-change": (v: string) => void;
+    "font-size-keydown": (ev: KeyboardEvent) => void;
+    "update:font-size-menu-open": (v: boolean) => void;
+    "update:text-color-menu-open": (v: boolean) => void;
+    "update:fill-color-menu-open": (v: boolean) => void;
+    "update:border-menu-open": (v: boolean) => void;
+    "update:merge-menu-open": (v: boolean) => void;
+    "border-change": (v: BorderType) => void;
+    "merge-change": (v: MergeType) => void;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onUndo?: (() => any) | undefined;
+    onRedo?: (() => any) | undefined;
+    "onPaint-format"?: (() => any) | undefined;
+    "onClear-format"?: (() => any) | undefined;
+    "onFont-size-blur"?: (() => any) | undefined;
+    "onFont-size-toggle"?: (() => any) | undefined;
+    "onFont-size-step-up"?: (() => any) | undefined;
+    "onFont-size-step-down"?: (() => any) | undefined;
+    "onBold-toggle"?: (() => any) | undefined;
+    "onItalic-toggle"?: (() => any) | undefined;
+    "onUnderline-toggle"?: (() => any) | undefined;
+    "onStrikethrough-toggle"?: (() => any) | undefined;
+    "onApply-text-color"?: (() => any) | undefined;
+    "onApply-fill-color"?: (() => any) | undefined;
+    "onApply-border"?: (() => any) | undefined;
+    "onWrap-toggle"?: (() => any) | undefined;
+    "onApply-merge"?: (() => any) | undefined;
+    "onFont-family-change"?: ((v: string | number) => any) | undefined;
+    "onFont-size-change"?: ((v: string | number) => any) | undefined;
+    "onH-align-change"?: ((v: string | number) => any) | undefined;
+    "onV-align-change"?: ((v: string | number) => any) | undefined;
+    "onFont-size-input"?: ((v: string) => any) | undefined;
+    "onText-color-change"?: ((v: string) => any) | undefined;
+    "onFill-color-change"?: ((v: string) => any) | undefined;
+    "onFont-size-keydown"?: ((ev: KeyboardEvent) => any) | undefined;
+    "onUpdate:font-size-menu-open"?: ((v: boolean) => any) | undefined;
+    "onUpdate:text-color-menu-open"?: ((v: boolean) => any) | undefined;
+    "onUpdate:fill-color-menu-open"?: ((v: boolean) => any) | undefined;
+    "onUpdate:border-menu-open"?: ((v: boolean) => any) | undefined;
+    "onUpdate:merge-menu-open"?: ((v: boolean) => any) | undefined;
+    "onBorder-change"?: ((v: BorderType) => any) | undefined;
+    "onMerge-change"?: ((v: MergeType) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    rootEl: HTMLDivElement;
+    fontSizeArrowRef: HTMLButtonElement;
+    textColorArrowRef: HTMLButtonElement;
+    fillColorArrowRef: HTMLButtonElement;
+    borderArrowRef: HTMLButtonElement;
+    mergeArrowRef: HTMLButtonElement;
+    moreBtnEl: HTMLButtonElement;
+    overflowMenuEl: HTMLDivElement;
+}, any>;
+export default _default;

package/dist/types/components/spreader/composables/borders-merge.d.ts

@@ -0,0 +1,48 @@
+import { type Ref } from 'vue';
+import type { CoreState } from './core-state';
+import type { UndoStylesState } from './undo-styles';
+import type { BorderType } from '../components/pickers/borderPicker.vue';
+import type { MergeType } from '../core/constants';
+import type { SelectionRange } from '../core/types';
+export interface BordersMergeState {
+    cachedBorder: Ref<BorderType>;
+    borderMenuOpen: Ref<boolean>;
+    BORDER_COLOR: string;
+    borderTypeToWidths: (bt: BorderType, col: number, row: number, sel: SelectionRange) => {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    onBorderChange: (bt: BorderType) => void;
+    setCellBorderSide: (col: number, row: number, side: 'Top' | 'Bottom' | 'Left' | 'Right', width: number, clearZero: boolean) => void;
+    syncCellBorders: (col: number, row: number) => void;
+    applyBorderToCell: (col: number, row: number, w: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    }, clearZero?: boolean) => void;
+    applyCachedBorder: () => void;
+    cellBorderWidth: (col: number, row: number, side: 'Top' | 'Bottom' | 'Left' | 'Right') => number;
+    mergeMenuOpen: Ref<boolean>;
+    onMergeMenuToggle: (v: boolean) => void;
+    removeOverlappingMerges: (sC: number, sR: number, eC: number, eR: number) => void;
+    mergeAndCenter: () => void;
+    mergeAcross: () => void;
+    mergeCells: () => void;
+    unmergeCells: () => void;
+    onApplyMerge: () => void;
+    onMergeChange: (v: MergeType) => void;
+    copySourceRange: SelectionRange | null;
+    copySourceStyles: (Record<string, unknown> | null)[][];
+    captureStyles: (cS: number, cE: number, rS: number, rE: number) => void;
+    setCellWithStyle: (c: number, r: number, val: string, style: Record<string, unknown> | null) => void;
+    copyToClipboard: () => void;
+    copyRowCol: () => void;
+    pasteFromClipboard: () => Promise<void>;
+    cutSelected: () => void;
+    clearSelected: () => void;
+    sumSelected: () => void;
+}
+export declare function createBordersMerge(s: CoreState, us: UndoStylesState): BordersMergeState;

package/dist/types/components/spreader/composables/core-state.d.ts

@@ -0,0 +1,98 @@
+import { type ComputedRef, type Ref } from 'vue';
+import { FormulaDeps } from '../core/formula';
+import type { CellCoord, CellData, SelectionRange } from '../core/types';
+export interface CoreState {
+    props: {
+        rowCount: number;
+        colCount: number;
+        width?: number | string;
+        height?: number | string;
+        theme?: 'light' | 'dark';
+        locale?: string;
+    };
+    locale: ComputedRef<string>;
+    colCount: number;
+    rowCount: number;
+    cells: Record<string, CellData>;
+    merges: Record<string, SelectionRange>;
+    formulaDeps: FormulaDeps;
+    selection: Ref<SelectionRange | null>;
+    activeCell: Ref<CellCoord>;
+    editingCell: Ref<CellCoord | null>;
+    editValue: Ref<string>;
+    colWidths: Ref<number[]>;
+    rowHeights: Ref<(number | undefined)[]>;
+    scrollX: Ref<number>;
+    scrollY: Ref<number>;
+    BASE_CELL_VPAD: number;
+    fontMetricsCache: Map<string, {
+        ascent: number;
+        descent: number;
+    }>;
+    fontMetricsCanvas: HTMLCanvasElement | null;
+    measureFontMetrics: (family: string, size: number, weight: string, style: string) => {
+        ascent: number;
+        descent: number;
+    };
+    _getFontMetricsForCell: (c: number, r: number) => {
+        ascent: number;
+        descent: number;
+    };
+    getWrappedLines: (ctx: CanvasRenderingContext2D, text: string, maxWidth: number, wrap: boolean) => string[];
+    cellFontSize: (c: number, r: number) => number;
+    colPositions: ComputedRef<number[]>;
+    getRowHeight: (r: number) => number;
+    _isAutoRow: (r: number) => boolean;
+    rowPositions: ComputedRef<number[]>;
+    totalWidth: ComputedRef<number>;
+    totalHeight: ComputedRef<number>;
+    selectCell: (c: number, r: number) => void;
+    selectRange: (sC: number, sR: number, eC: number, eR: number) => void;
+    selectAll: () => void;
+    isSelected: (c: number, r: number) => boolean;
+    cellKey: (c: number, r: number) => string;
+    delCell: (k: string) => void;
+    findMerge: (c: number, r: number) => {
+        range: SelectionRange;
+        anchor: string;
+    } | null;
+    _isMergeAnchor: (c: number, r: number) => boolean;
+    _mergedSpan: (c: number, r: number) => {
+        w: number;
+        h: number;
+    };
+    expandSelectionForMerges: (sC: number, sR: number, eC: number, eR: number) => SelectionRange;
+    getCellRaw: (c: number, r: number) => string;
+    getCellValue: (c: number, r: number) => string;
+    setCellValue: (c: number, r: number, v: string | null | undefined) => void;
+    clearCellsInRange: (cS: number, cE: number, rS: number, rE: number) => void;
+    startEdit: (initialValue?: string) => void;
+    commitEdit: () => void;
+    cancelEdit: () => void;
+    moveActive: (dC: number, dR: number) => void;
+    ensureVisible: (c: number, r: number) => void;
+    hitCol: (x: number) => number;
+    hitRow: (y: number) => number;
+    saveUndo?: () => void;
+    scheduleRender?: () => void;
+    emitModelData?: () => void;
+    syncCellBorders?: (col: number, row: number) => void;
+    viewSize?: {
+        w: number;
+        h: number;
+    };
+    clampScroll?: (sx: number | null, sy: number | null) => void;
+}
+export declare function createCoreState(rawProps: {
+    rowCount?: number;
+    colCount?: number;
+    width?: number | string;
+    height?: number | string;
+    theme?: 'light' | 'dark';
+    locale?: string;
+}, defaults: {
+    rowCount: number;
+    colCount: number;
+    theme: 'light' | 'dark';
+    locale: string;
+}): CoreState;

package/dist/types/components/spreader/composables/interactions.d.ts

@@ -0,0 +1,87 @@
+import { type Ref, type ComputedRef } from 'vue';
+import type { CoreState } from './core-state';
+import type { UndoStylesState } from './undo-styles';
+import type { BordersMergeState } from './borders-merge';
+import type { SheetsOpsState } from './sheets-ops';
+import type { ContextMenuItem } from '../core/types';
+export interface InteractionsState {
+    scheduleRender: () => void;
+    render: () => void;
+    activeCellLabel: ComputedRef<string>;
+    formulaBarDisplay: ComputedRef<string>;
+    onFormulaBarFocus: () => void;
+    onFormulaBarInput: (e: Event) => void;
+    onFormulaBarKeydown: (e: KeyboardEvent) => void;
+    onFormulaBarBlur: () => void;
+    renTab: Ref<number | null>;
+    renTabVal: Ref<string>;
+    onTabClick: (i: number) => void;
+    onTabDblClick: (i: number) => void;
+    commitTabRename: () => void;
+    cclTabRename: () => void;
+    onTabRenameKd: (e: KeyboardEvent) => void;
+    ctxMenu: Ref<{
+        x: number;
+        y: number;
+        items: ContextMenuItem[];
+    } | null>;
+    ctxSubmenuLeft: Ref<boolean>;
+    onCtxItemEnter: (e: MouseEvent, item: ContextMenuItem) => void;
+    onTabCtxMenu: (e: MouseEvent, i: number) => void;
+    onTabBarCtx: (e: MouseEvent) => void;
+    onCornerCtx: (e: MouseEvent) => void;
+    onRowHdrCtx: (e: MouseEvent, row: number) => void;
+    onColHdrCtx: (e: MouseEvent, col: number) => void;
+    onCellCtx: (e: MouseEvent, c: number, r: number) => void;
+    dimInputRef: Ref<HTMLInputElement | null>;
+    dimPanel: Ref<{
+        type: 'row' | 'col';
+        x: number;
+        y: number;
+        value: string;
+        error: string;
+    } | null>;
+    openDimPanel: (type: 'row' | 'col', x: number, y: number) => void;
+    onDimInput: (e: Event) => void;
+    onDimKeydown: (e: KeyboardEvent) => void;
+    onDimBlur: () => void;
+    applyDimPanel: () => void;
+    closeDimPanel: () => void;
+    editInputStyle: ComputedRef<Record<string, string | number | undefined>>;
+    hScrollbarW: ComputedRef<number>;
+    vScrollbarH: ComputedRef<number>;
+    hTrackW: ComputedRef<number>;
+    vTrackH: ComputedRef<number>;
+    hThumbW: ComputedRef<number>;
+    hThumbL: ComputedRef<number>;
+    vThumbH: ComputedRef<number>;
+    vThumbT: ComputedRef<number>;
+    onVStart: (e: MouseEvent) => void;
+    onHStart: (e: MouseEvent) => void;
+    onSbMove: (e: MouseEvent) => void;
+    onSbUp: () => void;
+    onVTrk: (e: MouseEvent) => void;
+    onHTrk: (e: MouseEvent) => void;
+    onMouseDown: (e: MouseEvent) => void;
+    onMouseMove: (e: MouseEvent) => void;
+    onMouseUp: (e: MouseEvent) => void;
+    onMouseLeave: () => void;
+    onCanvasCtx: (e: MouseEvent) => void;
+    onDblClick: (e: MouseEvent) => void;
+    onWheel: (e: WheelEvent) => void;
+    onTouchStart: (e: TouchEvent) => void;
+    onTouchMove: (e: TouchEvent) => void;
+    onTouchEnd: () => void;
+    onKeydown: (e: KeyboardEvent) => void;
+    onEditInput: (e: Event) => void;
+    onEditCompositionStart: () => void;
+    onEditCompositionEnd: (e: CompositionEvent) => void;
+    onEditKd: (e: KeyboardEvent) => void;
+    onEditPaste: (e: ClipboardEvent) => void;
+    onEditBlur: () => void;
+    applySize: () => void;
+    setupLifecycle: () => void;
+}
+export declare function createInteractions(s: CoreState, us: UndoStylesState, bm: BordersMergeState, so: SheetsOpsState, lastEmittedDataRef: {
+    value: string;
+}): InteractionsState;

package/dist/types/components/spreader/composables/sheets-ops.d.ts

@@ -0,0 +1,45 @@
+import { type Ref, type ComputedRef } from 'vue';
+import type { ThemeColors, SheetState, SheetModelData } from '../core/types';
+import type { CoreState } from './core-state';
+import type { UndoStylesState } from './undo-styles';
+export interface SheetsOpsState {
+    deleteRows: (rS: number, rE: number) => void;
+    insertRows: (rS: number, rE: number) => void;
+    insertCols: (cS: number, cE: number) => void;
+    deleteCols: (cS: number, cE: number) => void;
+    sheets: Ref<SheetState[]>;
+    activeSheetIndex: Ref<number>;
+    saveSheet: () => void;
+    loadSheet: (i: number) => void;
+    switchSheet: (i: number) => void;
+    addSheet: (n?: string) => number;
+    removeSheet: (i: number) => number;
+    renameSheet: (i: number, n: string) => void;
+    dupSheet: (i: number) => number;
+    moveSheet: (i: number, d: number) => void;
+    sheetCount: ComputedRef<number>;
+    mkSheet: (name: string) => SheetState;
+    emitModelData: () => void;
+    scheduleOptEmit: () => void;
+    themeColors: ComputedRef<ThemeColors>;
+    outerStyle: ComputedRef<Record<string, string>>;
+    toolbarThemeVars: ComputedRef<Record<string, string>>;
+    wrapperRef: Ref<HTMLDivElement | null>;
+    canvasRef: Ref<HTMLCanvasElement | null>;
+    editInputRef: Ref<HTMLTextAreaElement | null>;
+    formulaBarRef: Ref<HTMLInputElement | null>;
+    viewSize: {
+        w: number;
+        h: number;
+    };
+    maxScrollX: ComputedRef<number>;
+    maxScrollY: ComputedRef<number>;
+    clampScroll: (sx: number | null, sy: number | null) => void;
+    canFocusHiddenEditor: () => boolean;
+    focusEditInput: (selectAllText?: boolean) => void;
+    onCanvasFocus: () => void;
+    resetRowHeight: () => void;
+    resetColWidth: () => void;
+    modelData: Ref<SheetModelData[]>;
+}
+export declare function createSheetsOps(s: CoreState, us: UndoStylesState, rawModelData: Ref<SheetModelData[]>, _applySizeCallback?: () => void): SheetsOpsState;

package/dist/types/components/spreader/composables/undo-styles.d.ts

@@ -0,0 +1,86 @@
+import { type ComputedRef, type Ref } from 'vue';
+import type { FontOption } from '../core/constants';
+import type { CoreState } from './core-state';
+import type { CellData, SheetState } from '../core/types';
+export interface UndoStylesState {
+    undoStack: Ref<UndoSnap[]>;
+    redoStack: Ref<UndoSnap[]>;
+    cloneCells: (src: Record<string, CellData>) => Record<string, CellData>;
+    takeSnap: () => UndoSnap;
+    restoreSnap: (s: UndoSnap) => void;
+    saveUndo: () => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: ComputedRef<boolean>;
+    canRedo: ComputedRef<boolean>;
+    hasSelection: ComputedRef<boolean>;
+    paintFmt: Ref<{
+        styles: Record<string, Record<string, unknown> | null>;
+    } | null>;
+    onPaintFormat: () => void;
+    applyPaintFormat: () => void;
+    clearFormat: () => void;
+    fontFamilyOptions: ComputedRef<FontOption[]>;
+    fontSizeOptions: ComputedRef<FontOption[]>;
+    FONT_FAMILY_MIXED: string;
+    selFontFamily: ComputedRef<string>;
+    selFontSize: ComputedRef<number>;
+    applyStyleToSelection: (prop: string, value: unknown) => void;
+    onFontFamilyChange: (v: string | number) => void;
+    onFontSizeChange: (v: string | number) => void;
+    hAlignOptions: ComputedRef<FontOption[]>;
+    vAlignOptions: ComputedRef<FontOption[]>;
+    selHAlign: ComputedRef<string>;
+    selVAlign: ComputedRef<string>;
+    selWrap: ComputedRef<boolean>;
+    onHAlignChange: (v: string | number) => void;
+    onVAlignChange: (v: string | number) => void;
+    onWrapToggle: () => void;
+    fontSizeInput: Ref<string>;
+    fontSizeMenuOpen: Ref<boolean>;
+    onFontSizeInput: (raw: string) => void;
+    onFontSizeBlur: () => void;
+    onFontSizeKeydown: (e: KeyboardEvent) => void;
+    toggleFontSizeMenu: (e?: MouseEvent) => void;
+    onFontSizeStepUp: () => void;
+    onFontSizeStepDown: () => void;
+    selFontWeight: ComputedRef<boolean>;
+    selFontStyle: ComputedRef<boolean>;
+    selUnderline: ComputedRef<boolean>;
+    selStrikethrough: ComputedRef<boolean>;
+    toggleFontWeight: () => void;
+    toggleFontStyle: () => void;
+    toggleUnderline: () => void;
+    toggleStrikethrough: () => void;
+    cachedTextColor: Ref<string>;
+    cachedFillColor: Ref<string>;
+    textColorMenuOpen: Ref<boolean>;
+    fillColorMenuOpen: Ref<boolean>;
+    _toggleTextColorMenu: () => void;
+    _toggleFillColorMenu: () => void;
+    onBorderMenuToggle: (v: boolean) => void;
+    onTextColorChange: (v: string) => void;
+    onFillColorChange: (v: string) => void;
+    applyCachedTextColor: () => void;
+    applyCachedFillColor: () => void;
+    selTextColor: ComputedRef<string>;
+    selFillColor: ComputedRef<string>;
+    borderMenuOpen?: Ref<boolean>;
+    mergeMenuOpen?: Ref<boolean>;
+}
+interface UndoSnap {
+    sheets: SheetState[];
+    activeSheetIndex: number;
+}
+export declare function createUndoStyles(s: CoreState, sheetsCtx: {
+    sheets: Ref<SheetState[]>;
+    activeSheetIndex: Ref<number>;
+    saveSheet: () => void;
+    loadSheet: (i: number) => void;
+    mkSheet: (name: string) => SheetState;
+}): UndoStylesState;
+export declare function bindMenuRefs(us: UndoStylesState, refs: {
+    borderMenuOpen?: Ref<boolean>;
+    mergeMenuOpen?: Ref<boolean>;
+}): void;
+export {};

package/dist/types/components/spreader/{constants.d.ts → core/constants.d.ts}

@@ -31,5 +31,12 @@ export interface AlignOption {
 export declare const H_ALIGN_OPTIONS: AlignOption[];
 export declare const V_ALIGN_OPTIONS: AlignOption[];
 export declare const WRAP_ICON = "<svg viewBox=\"0 0 1024 1024\" fill=\"currentColor\"><path d=\"M896 179.2a38.4 38.4 0 0 0-76.8 0v665.6a38.4 38.4 0 0 0 76.8 0v-665.6zM204.8 281.6A38.4 38.4 0 0 0 204.8 358.4h179.2a38.4 38.4 0 0 0 0-76.8H204.8zM550.4 281.6a38.4 38.4 0 0 0 0 76.8h51.2c35.328 0 64 28.672 64 64v179.2c0 35.328-28.672 64-64 64H246.272l36.864-36.864a38.4 38.4 0 1 0-54.272-54.272l-102.4 102.4a38.4 38.4 0 0 0 0 54.272l102.4 102.4a38.4 38.4 0 0 0 54.272-54.272l-36.864-36.864h355.328a140.8 140.8 0 0 0 140.8-140.8v-179.2a140.8 140.8 0 0 0-140.8-140.8h-51.2z\" /></svg>";
+export type MergeType = 'mergeCenter' | 'mergeAcross' | 'mergeCells' | 'unmergeCells';
+export interface MergeOption {
+    key: MergeType;
+    labelKey: string;
+    icon: string;
+}
+export declare const MERGE_OPTIONS: MergeOption[];
 export declare const lightTheme: ThemeColors;
 export declare const darkTheme: ThemeColors;

package/dist/types/components/spreader/{types.d.ts → core/types.d.ts}

@@ -34,6 +34,7 @@ export interface SheetModelData {
         value: string;
         style?: Record<string, unknown>;
     }>;
+    merges?: Record<string, SelectionRange>;
     colWidths?: Record<number, number>;
     rowHeights?: Record<number, number>;
 }
@@ -41,6 +42,7 @@ export interface SheetState {
     id: string;
     name: string;
     cells: Record<string, CellData>;
+    merges: Record<string, SelectionRange>;
     selection: SelectionRange | null;
     activeCell: CellCoord;
     scrollX: number;

package/dist/types/components/spreader/index.d.ts

@@ -0,0 +1,8 @@
+export { default } from './components/spreadsheet.vue';
+export { default as Spreader } from './components/spreadsheet.vue';
+export * from './core/types';
+export * from './core/constants';
+export * from './core/utils';
+export * from './core/formula';
+export * from './core/theme';
+export type { BorderType } from './components/pickers/borderPicker.vue';

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-import Spreader from './components/spreader/spreader.vue';
+import Spreader from './components/spreader';
 export default Spreader;
 export { Spreader };
-export type { CellCoord, SelectionRange, CellData, Range, SpreadsheetOptions, SpreadsheetData, SheetModelData, SheetState, UndoSnapshot, ContextMenuItem, ThemeColors, Point, } from './components/spreader/types';
+export type { CellCoord, SelectionRange, CellData, Range, SpreadsheetOptions, SpreadsheetData, SheetModelData, SheetState, UndoSnapshot, ContextMenuItem, ThemeColors, Point, } from './components/spreader';