Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.
TypeScript boardcollaborationdocdocxexceloffce365officepdfpptpptxpresentationsdksheetslidesspreadsheetuniverwordwordprocessorworkspacexlsx
test: add unit tests (#7119)
白熱d88d528d884a
diff --git a/codecov.yml b/codecov.ymlindex fa5534cd57..a147d75ce3 100644--- a/codecov.yml+++ b/codecov.yml@@ -3,7 +3,7 @@ coverage:project:default:# basic- target: 78%+ target: 80%threshold: 0base: auto# advanced settingsdiff --git a/common/mockdata/scripts/generate-locales.mts b/common/mockdata/scripts/generate-locales.mtsindex 9a94d73db1..fae3060552 100644--- a/common/mockdata/scripts/generate-locales.mts+++ b/common/mockdata/scripts/generate-locales.mts@@ -68,14 +68,15 @@ async function generateLocales() {writeJsonFileSync(path.resolve(__dirname, '../package.json'), pkgJsonFile);discoverUniverUiLocales({ rootDir: root }).forEach((locale) => {- let statements = '/* eslint-disable */\n' + 'import { mergeLocales } from \'@univerjs/core\';\n\n';+ let statements = '/* eslint-disable */\n';packageNames.forEach((pkg) => {const pkgName = pkg.replace(/@|univerjs|\/|-/g, '');statements += `import ${pkgName}Locale from '${pkg}/locale/${locale}';\n`;});- statements += '\nexport default mergeLocales(\n';+ statements += '\nexport default Object.assign(\n';+ statements += ' {},\n';packageNames.forEach((pkg) => {const pkgName = pkg.replace(/@|univerjs|\/|-/g, '');diff --git a/common/shared/preset-build/__tests__/locale.spec.ts b/common/shared/preset-build/__tests__/locale.spec.tsdeleted file mode 100644index 002bc68876..0000000000--- a/common/shared/preset-build/__tests__/locale.spec.ts+++ /dev/null@@ -1,76 +0,0 @@-/**- * Copyright 2023-present DreamNum Co., Ltd.- *- * 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.- */--import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';-import os from 'node:os';-import path from 'node:path';-import { afterEach, describe, expect, it } from 'vitest';-import { generatePresetLocales } from '../locale';--const roots: string[] = [];--function makeRoot() {- const root = mkdtempSync(path.join(os.tmpdir(), 'univer-preset-locale-'));- roots.push(root);- return root;-}--function writeJson(filePath: string, value: unknown) {- mkdirSync(path.dirname(filePath), { recursive: true });- writeFileSync(filePath, `${JSON.stringify(value, null, 4)}\n`);-}--afterEach(() => {- for (const root of roots.splice(0)) {- rmSync(root, { force: true, recursive: true });- }-});--describe('generatePresetLocales', () => {- it('generates locale files from available dependency locales and skips missing locales', () => {- const packageDir = makeRoot();-- writeJson(path.join(packageDir, 'package.json'), {- name: '@univerjs/preset-demo',- dependencies: {- '@univerjs/alpha': 'workspace:*',- '@univerjs/beta': 'workspace:*',- '@univerjs/preset-gamma': 'workspace:*',- },- });-- mkdirSync(path.join(packageDir, 'node_modules'), { recursive: true });- writeFileSync(path.join(packageDir, 'node_modules/.keep'), '');- mkdirSync(path.join(packageDir, 'node_modules/@univerjs/alpha/lib/es/locale'), { recursive: true });- mkdirSync(path.join(packageDir, 'node_modules/@univerjs/beta/lib/es/locale'), { recursive: true });- mkdirSync(path.join(packageDir, 'node_modules/@univerjs/preset-gamma/src/locales'), { recursive: true });- writeFileSync(path.join(packageDir, 'node_modules/@univerjs/alpha/lib/es/locale/en-US.js'), 'export default {};');- writeFileSync(path.join(packageDir, 'node_modules/@univerjs/beta/lib/es/locale/en-US.js'), 'export default {};');- writeFileSync(path.join(packageDir, 'node_modules/@univerjs/preset-gamma/src/locales/en-US.ts'), 'export default {};');- writeFileSync(path.join(packageDir, 'node_modules/@univerjs/alpha/lib/es/locale/zh-CN.js'), 'export default {};');-- generatePresetLocales({ packageDir });-- const enUS = readFileSync(path.join(packageDir, 'src/locales/en-US.ts'), 'utf8');- expect(enUS).toContain("import univerjsalpha from '@univerjs/alpha/locale/en-US';");- expect(enUS).toContain("import univerjsbeta from '@univerjs/beta/locale/en-US';");- expect(enUS).toContain("import univerjspresetgamma from '@univerjs/preset-gamma/locales/en-US';");-- const zhCN = readFileSync(path.join(packageDir, 'src/locales/zh-CN.ts'), 'utf8');- expect(zhCN).toContain("import univerjsalpha from '@univerjs/alpha/locale/zh-CN';");- expect(zhCN).not.toContain('@univerjs/beta/locale/zh-CN');- });-});diff --git a/common/shared/preset-build/__tests__/umd.spec.ts b/common/shared/preset-build/__tests__/umd.spec.tsdeleted file mode 100644index 5ab15b0a72..0000000000--- a/common/shared/preset-build/__tests__/umd.spec.ts+++ /dev/null@@ -1,148 +0,0 @@-/**- * Copyright 2023-present DreamNum Co., Ltd.- *- * 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.- */--import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';-import os from 'node:os';-import path from 'node:path';-import { afterEach, describe, expect, it } from 'vitest';-import { createUmdConfig } from '../../tsdown/configs/umd';-import { prependPresetUmd } from '../umd';--const roots: string[] = [];--function makeRoot() {- const root = mkdtempSync(path.join(os.tmpdir(), 'univer-preset-umd-'));- roots.push(root);- return root;-}--afterEach(() => {- for (const root of roots.splice(0)) {- rmSync(root, { force: true, recursive: true });- }-});--describe('prependPresetUmd', () => {- it('does not externalize CSS imports as UMD globals', () => {- const config = createUmdConfig({- baseConfig: {},- enableObfuscation: false,- entry: {- key: 'index',- path: '/tmp/index.ts',- type: 'index',- },- outDir: 'lib/umd',- packageDir: '/tmp/pkg',- packageName: '@univerjs/preset-alpha',- plugins: [],- });-- const neverBundle = config.deps!.neverBundle as (source: string) => boolean;- const globals = config.outputOptions!.globals as (source: string) => string | undefined;-- expect(neverBundle('@univerjs/design/index.css')).toBe(false);- expect(globals('@univerjs/design/index.css')).toBe('UniverCssNoop');- });-- it('maps locale dependency imports to dependency UMD locale globals', () => {- const config = createUmdConfig({- baseConfig: {},- enableObfuscation: false,- entry: {- key: 'locales/en-US',- path: '/tmp/locales/en-US.ts',- type: 'locale',- },- outDir: 'lib/umd',- packageDir: '/tmp/pkg',- packageName: '@univerjs/preset-alpha',- plugins: [],- });-- const neverBundle = config.deps!.neverBundle as (source: string) => boolean;- const globals = config.outputOptions!.globals as (source: string) => string | undefined;-- expect(neverBundle('@univerjs/design/locale/en-US')).toBe(true);- expect(globals('@univerjs/design/locale/en-US')).toBe('UniverDesignEnUS');- expect(globals('@univerjs/sheets/locales/zh-CN')).toBe('UniverSheetsZhCN');- expect(globals('@univerjs-pro/exchange-client/locales/en-US')).toBe('UniverProExchangeClientEnUS');- });-- it('prepends additional files and dependency UMD outputs before the preset UMD', () => {- const packageDir = makeRoot();- const extraFile = path.join(packageDir, 'extra.js');- writeFileSync(extraFile, '/* extra */');-- mkdirSync(path.join(packageDir, 'node_modules/@univerjs/alpha/lib/umd'), { recursive: true });- mkdirSync(path.join(packageDir, 'node_modules/@univerjs/beta/lib/umd'), { recursive: true });- mkdirSync(path.join(packageDir, 'lib/umd'), { recursive: true });-- writeFileSync(path.join(packageDir, 'node_modules/@univerjs/alpha/lib/umd/index.js'), '/* alpha */');- writeFileSync(path.join(packageDir, 'node_modules/@univerjs/alpha/lib/umd/facade.js'), '/* alpha facade */');- writeFileSync(path.join(packageDir, 'node_modules/@univerjs/beta/lib/umd/index.js'), '/* beta */');- writeFileSync(path.join(packageDir, 'node_modules/@univerjs/beta/lib/umd/facade.js'), '/* beta facade */');- writeFileSync(path.join(packageDir, 'lib/umd/index.js'), '/* preset */');-- prependPresetUmd({- packageDir,- umdAdditionalFiles: [extraFile],- umdDeps: ['@univerjs/alpha', '@univerjs/beta'],- });-- const output = readFileSync(path.join(packageDir, 'lib/umd/index.js'), 'utf8');- expect(output.indexOf('/* extra */')).toBeLessThan(output.indexOf('/* alpha */'));- expect(output.indexOf('/* alpha */')).toBeLessThan(output.indexOf('/* beta */'));- expect(output.indexOf('/* beta */')).toBeLessThan(output.indexOf('/* alpha facade */'));- expect(output.indexOf('/* alpha facade */')).toBeLessThan(output.indexOf('/* beta facade */'));- expect(output.indexOf('/* beta facade */')).toBeLessThan(output.indexOf('/* preset */'));- });-- it('fails when a declared UMD dependency has not been built', () => {- const packageDir = makeRoot();- mkdirSync(path.join(packageDir, 'lib/umd'), { recursive: true });- writeFileSync(path.join(packageDir, 'lib/umd/index.js'), '/* preset */');-- expect(() => prependPresetUmd({- packageDir,- umdDeps: ['@univerjs/missing'],- })).toThrow('Missing UMD dependency @univerjs/missing');- });-- it('prepends dependency UMD locale outputs from both locale and locales directories', () => {- const packageDir = makeRoot();-- mkdirSync(path.join(packageDir, 'node_modules/@univerjs/alpha/lib/umd/locale'), { recursive: true });- mkdirSync(path.join(packageDir, 'node_modules/@univerjs/preset-beta/lib/umd/locales'), { recursive: true });- mkdirSync(path.join(packageDir, 'lib/umd/locales'), { recursive: true });-- writeFileSync(path.join(packageDir, 'node_modules/@univerjs/alpha/lib/umd/index.js'), '/* alpha */');- writeFileSync(path.join(packageDir, 'node_modules/@univerjs/alpha/lib/umd/locale/en-US.js'), '/* alpha locale */');- writeFileSync(path.join(packageDir, 'node_modules/@univerjs/preset-beta/lib/umd/index.js'), '/* beta */');- writeFileSync(path.join(packageDir, 'node_modules/@univerjs/preset-beta/lib/umd/locales/en-US.js'), '/* beta locales */');- writeFileSync(path.join(packageDir, 'lib/umd/index.js'), '/* preset */');- writeFileSync(path.join(packageDir, 'lib/umd/locales/en-US.js'), '/* preset locale */');-- prependPresetUmd({- packageDir,- umdDeps: ['@univerjs/alpha', '@univerjs/preset-beta'],- });-- const output = readFileSync(path.join(packageDir, 'lib/umd/locales/en-US.js'), 'utf8');- expect(output.indexOf('/* alpha locale */')).toBeLessThan(output.indexOf('/* beta locales */'));- expect(output.indexOf('/* beta locales */')).toBeLessThan(output.indexOf('/* preset locale */'));- });-});diff --git a/common/shared/preset-build/locale.ts b/common/shared/preset-build/locale.tsindex ddf71fc0b6..cb9c540fc2 100644--- a/common/shared/preset-build/locale.ts+++ b/common/shared/preset-build/locale.ts@@ -91,13 +91,14 @@ export function generatePresetLocales(options: IGeneratePresetLocalesOptions): scontinue;}- let content = 'import { mergeLocales } from \'@univerjs/core\';\n\n';+ let content = '';for (const { dependencyName, localeSubpath } of dependenciesWithLocale) {content += `import ${convertImportNameFromPackageName(dependencyName)} from '${dependencyName}/${localeSubpath}/${locale}';\n`;}- content += '\nexport default mergeLocales(\n';+ content += '\nexport default Object.assign(\n';+ content += ' {},\n';for (const { dependencyName } of dependenciesWithLocale) {content += ` ${convertImportNameFromPackageName(dependencyName)},\n`;diff --git a/packages/docs-drawing-ui/src/controllers/__tests__/doc-drawing-transformer-update.controller.spec.ts b/packages/docs-drawing-ui/src/controllers/__tests__/doc-drawing-transformer-update.controller.spec.tsnew file mode 100644index 0000000000..b030ca8748--- /dev/null+++ b/packages/docs-drawing-ui/src/controllers/__tests__/doc-drawing-transformer-update.controller.spec.ts@@ -0,0 +1,458 @@+/**+ * Copyright 2023-present DreamNum Co., Ltd.+ *+ * 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.+ */++import { ObjectRelativeFromH, ObjectRelativeFromV, PositionedObjectLayoutType } from '@univerjs/core';+import { Subject } from 'rxjs';+import { describe, expect, it, vi } from 'vitest';+import {+ IMoveInlineDrawingCommand,+ ITransformNonInlineDrawingCommand,+ UpdateDrawingDocTransformCommand,+} from '../../commands/commands/update-doc-drawing.command';+import { DocDrawingTransformerController, getDocsTableCellAnchorContext } from '../doc-drawing-transformer-update.controller';++function createController() {+ const controller = Object.create(DocDrawingTransformerController.prototype) as any;+ controller._commandService = { executeCommand: vi.fn() };+ controller._drawingManagerService = {+ getDrawingOKey: vi.fn((oKey: string) => ({+ unitId: 'unit-1',+ subUnitId: 'doc-1',+ drawingId: oKey.replace('object-', 'drawing-'),+ })),+ };+ controller._transformerCache = new Map();+ controller._liquid = {+ x: 0,+ y: 0,+ reset: vi.fn(),+ translatePage: vi.fn((_page: any) => {+ controller._liquid.y += 140;+ }),+ };+ controller._renderManagerService = {+ getRenderById: vi.fn(() => null),+ };+ return controller;+}++function drawing(drawingId = 'drawing-1') {+ return {+ drawingId,+ unitId: 'unit-1',+ subUnitId: 'doc-1',+ layoutType: PositionedObjectLayoutType.WRAP_SQUARE,+ docTransform: {+ size: { width: 80, height: 60 },+ angle: 0,+ positionH: {+ relativeFrom: ObjectRelativeFromH.PAGE,+ posOffset: 10,+ },+ positionV: {+ relativeFrom: ObjectRelativeFromV.PAGE,+ posOffset: 20,+ },+ },+ };+}++describe('DocDrawingTransformerController business methods', () => {+ it('builds drawing transform updates for multi-select resize, rotation, and move changes', () => {+ const controller = createController();+ const drawingData = drawing();+ controller._getPageContentSize = vi.fn(() => ({ width: 100, height: 90 }));+ controller._transformerCache.set('drawing-1', {+ drawing: drawingData,+ top: 20,+ left: 10,+ width: 80,+ height: 60,+ angle: 0,+ });++ controller._updateMultipleDrawingDocTransform(new Map([+ ['object-1', {+ oKey: 'object-1',+ left: 25,+ top: 45,+ width: 160,+ height: 120,+ angle: 30,+ }],+ ]));++ expect(controller._commandService.executeCommand).toHaveBeenCalledWith(UpdateDrawingDocTransformCommand.id, {+ unitId: 'unit-1',+ subUnitId: 'doc-1',+ drawings: [+ { drawingId: 'drawing-1', key: 'size', value: { width: 100, height: 90 } },+ { drawingId: 'drawing-1', key: 'angle', value: 30 },+ { drawingId: 'drawing-1', key: 'positionV', value: { relativeFrom: ObjectRelativeFromV.PAGE, posOffset: 45 } },+ { drawingId: 'drawing-1', key: 'positionH', value: { relativeFrom: ObjectRelativeFromH.PAGE, posOffset: 25 } },+ ],+ });+ });++ it('updates inline drawing size and angle while clamping to page content size', () => {+ const controller = createController();+ controller._getPageContentSize = vi.fn(() => ({ width: 120, height: 90 }));++ controller._updateDrawingSize({+ drawing: drawing(),+ top: 0,+ left: 0,+ width: 80,+ height: 60,+ angle: 0,+ }, {+ width: 300,+ height: 100,+ angle: 15,+ });++ expect(controller._commandService.executeCommand).toHaveBeenCalledWith(UpdateDrawingDocTransformCommand.id, {+ unitId: 'unit-1',+ subUnitId: 'doc-1',+ drawings: [+ { drawingId: 'drawing-1', key: 'size', value: { width: 120, height: 90 } },+ { drawingId: 'drawing-1', key: 'angle', value: 15 },+ ],+ });+ });++ it('moves inline drawings to the resolved anchor and refreshes when no anchor is available', () => {+ const controller = createController();+ controller._getInlineDrawingAnchor = vi.fn(() => ({+ offset: 12,+ segmentId: 'segment-1',+ segmentPage: 2,+ }));++ controller._moveInlineDrawing(drawing(), 40, 50);+ expect(controller._commandService.executeCommand).toHaveBeenCalledWith(IMoveInlineDrawingCommand.id, {+ unitId: 'unit-1',+ subUnitId: 'unit-1',+ drawing: drawing(),+ offset: 12,+ segmentId: 'segment-1',+ segmentPage: 2,+ needRefreshDrawings: false,+ });++ controller._commandService.executeCommand.mockClear();+ controller._getInlineDrawingAnchor.mockReturnValue(null);+ controller._moveInlineDrawing(drawing(), 400, 500);+ expect(controller._commandService.executeCommand).toHaveBeenCalledWith(IMoveInlineDrawingCommand.id, expect.objectContaining({+ offset: undefined,+ needRefreshDrawings: true,+ }));+ });++ it('transforms non-inline drawings through a new anchor and falls back to direct transform when no anchor is found', () => {+ const controller = createController();+ const docTransform = {+ size: { width: 90, height: 70 },+ positionH: { relativeFrom: ObjectRelativeFromH.MARGIN, posOffset: 11 },+ positionV: { relativeFrom: ObjectRelativeFromV.PARAGRAPH, posOffset: 22 },+ };+ controller._limitDrawingInPage = vi.fn((_drawing: any, object: any) => object);+ controller._getDrawingAnchor = vi.fn(() => ({+ offset: 23,+ docTransform,+ segmentId: 'body',+ segmentPage: 0,+ }));++ controller._nonInlineDrawingTransform(drawing(), { left: 8, top: 9, width: 90, height: 70 });+ expect(controller._commandService.executeCommand).toHaveBeenCalledWith(ITransformNonInlineDrawingCommand.id, {+ unitId: 'unit-1',+ subUnitId: 'unit-1',+ drawing: drawing(),+ offset: 23,+ docTransform,+ segmentId: 'body',+ segmentPage: 0,+ });++ controller._commandService.executeCommand.mockClear();+ controller._getDrawingAnchor.mockReturnValue(null);+ controller._updateMultipleDrawingDocTransform = vi.fn();+ controller._nonInlineDrawingTransform(drawing(), { left: 18, top: 19, width: 90, height: 70 });+ expect(controller._updateMultipleDrawingDocTransform).toHaveBeenCalledWith(new Map([['drawing-1', {+ left: 18,+ top: 19,+ width: 90,+ height: 70,+ }]]));+ });++ it('limits a drawing away from the gap between document pages while preserving drawings already on one page', () => {+ const controller = createController();+ controller._renderManagerService.getRenderById.mockReturnValue({+ mainComponent: {+ top: 5,+ pageLayoutType: 0,+ pageMarginLeft: 0,+ pageMarginTop: 20,+ getOffsetConfig: () => ({+ pageLayoutType: 0,+ pageMarginLeft: 0,+ pageMarginTop: 20,+ }),+ },+ with: vi.fn(() => ({+ getSkeleton: () => ({+ getSkeletonData: () => ({+ pages: [+ { pageHeight: 100, marginBottom: 10, marginTop: 10 },+ { pageHeight: 100, marginBottom: 10, marginTop: 10 },+ ],+ }),+ }),+ })),+ });++ expect(controller._limitDrawingInPage(drawing(), {+ left: 1,+ top: 85,+ width: 30,+ height: 20,+ angle: 0,+ })).toMatchObject({ top: 75 });+ expect(controller._limitDrawingInPage(drawing(), {+ left: 1,+ top: 30,+ width: 30,+ height: 20,+ angle: 0,+ })).toMatchObject({ top: 30 });+ });++ it('resolves only real table-cell anchors to their table, row, and host page context', () => {+ expect(getDocsTableCellAnchorContext('unit-1', { parent: null } as any)).toBeNull();++ const hostPage = { type: 'body' };+ const cell = { left: 1, marginLeft: 2, marginTop: 3 };+ const row = { cells: [], top: 4 };+ const table = { left: 5, top: 6, tableId: 'table-1#-#0', parent: hostPage };+ Object.assign(row, { cells: [cell], parent: table });+ Object.assign(cell, { parent: row });++ expect(getDocsTableCellAnchorContext('unit-1', cell as any)).toMatchObject({+ cell,+ row,+ table,+ hostPage,+ });+ });++ it('limits page content size by the page containing the drawing and falls back when the skeleton is unavailable', () => {+ const controller = createController();+ controller._renderManagerService.getRenderById.mockReturnValue({+ with: vi.fn(() => ({+ getSkeleton: () => ({+ getSkeletonData: () => ({+ pages: [+ {+ pageWidth: 720,+ pageHeight: 960,+ marginLeft: 40,+ marginRight: 60,+ marginTop: 50,+ marginBottom: 70,+ skeDrawings: new Map([['drawing-1', {}]]),+ },+ ],+ }),+ }),+ })),+ });++ expect(controller._getPageContentSize(drawing())).toEqual({ width: 620, height: 840 });++ controller._renderManagerService.getRenderById.mockReturnValue(null);+ expect(controller._getPageContentSize(drawing())).toEqual({ width: 500, height: 500 });+ });++ it('creates and updates the inline anchor from resolved text range points', () => {+ const controller = createController();+ const scene = { addObject: vi.fn() };+ controller._renderManagerService.getRenderById.mockReturnValue({+ mainComponent: {+ getOffsetConfig: () => ({ docsLeft: 8, docsTop: 12 }),+ },+ scene,+ });++ controller._createOrUpdateInlineAnchor('unit-1', [[+ { x: 10, y: 20 },+ { x: 10, y: 40 },+ { x: 10, y: 60 },+ ]]);++ expect(scene.addObject).toHaveBeenCalledTimes(1);+ const anchor = controller._anchorShape;+ const transformByState = vi.spyOn(anchor, 'transformByState');+ const show = vi.spyOn(anchor, 'show');++ controller._createOrUpdateInlineAnchor('unit-1', [[+ { x: 14, y: 26 },+ { x: 14, y: 50 },+ { x: 14, y: 76 },+ ]]);++ expect(transformByState).toHaveBeenCalledWith(expect.objectContaining({+ left: 22,+ top: 38,+ height: 50,+ }));+ expect(show).toHaveBeenCalled();+ });++ it('finds the scene transformer for a drawing search only when render context exists', () => {+ const controller = createController();+ const transformer = {};+ const scene = { getTransformerByCreate: vi.fn(() => transformer) };++ expect(controller._getSceneAndTransformerByDrawingSearch(null)).toBeUndefined();++ controller._renderManagerService.getRenderById.mockReturnValue({});+ expect(controller._getSceneAndTransformerByDrawingSearch('unit-1')).toBeUndefined();++ controller._renderManagerService.getRenderById.mockReturnValue({ scene });+ expect(controller._getSceneAndTransformerByDrawingSearch('unit-1')).toEqual({ scene, transformer });+ });++ it('updates the inline drawing anchor only when a single drawing is being transformed', () => {+ const controller = createController();+ const points = [[+ { x: 1, y: 2 },+ { x: 1, y: 3 },+ { x: 1, y: 4 },+ ]];+ controller._getInlineDrawingAnchor = vi.fn(() => ({ contentBoxPointGroup: points }));+ controller._createOrUpdateInlineAnchor = vi.fn();++ controller._updateInlineDrawingAnchor(drawing(), 10, 20);+ expect(controller._createOrUpdateInlineAnchor).not.toHaveBeenCalled();++ controller._transformerCache.set('drawing-1', {});+ controller._updateInlineDrawingAnchor(drawing(), 10, 20);+ expect(controller._createOrUpdateInlineAnchor).toHaveBeenCalledWith('unit-1', points);+ });++ it('converts pointer offsets from viewport coordinates into document coordinates', () => {+ const controller = createController();+ const invertedTransform = {+ applyPoint: vi.fn((point) => ({ x: point.x - 5, y: point.y - 7 })),+ };+ const documentTransform = {+ clone: vi.fn(() => ({+ invert: vi.fn(() => invertedTransform),+ })),+ };+ const document = {+ getOffsetConfig: () => ({ documentTransform }),+ };+ const viewport = {+ transformVector2SceneCoord: vi.fn(() => ({ x: 30, y: 40 })),+ };++ expect(controller._getTransformCoordForDocumentOffset(document, viewport, 12, 18)).toEqual({ x: 25, y: 33 });++ viewport.transformVector2SceneCoord.mockReturnValueOnce(undefined as never);+ expect(controller._getTransformCoordForDocumentOffset(document, viewport, 12, 18)).toBeUndefined();+ });++ it('listens to transformer changes for inline drawings and commits resize or move business actions', () => {+ const controller = createController();+ const changeStart$ = new Subject<any>();+ const changing$ = new Subject<any>();+ const changeEnd$ = new Subject<any>();+ const transformer = { changeStart$, changing$, changeEnd$ };+ const object = {+ oKey: 'object-inline',+ left: 10,+ top: 20,+ width: 80,+ height: 60,+ angle: 0,+ setOpacity: vi.fn(),+ };+ const inlineDrawing = {+ ...drawing('drawing-inline'),+ layoutType: PositionedObjectLayoutType.INLINE,+ };+ controller.disposeWithMe = vi.fn();+ controller._renderManagerService.getRenderById.mockReturnValue({+ scene: {+ getTransformerByCreate: vi.fn(() => transformer),+ },+ });+ controller._drawingManagerService.getDrawingOKey = vi.fn(() => ({+ unitId: 'unit-1',+ subUnitId: 'doc-1',+ drawingId: 'drawing-inline',+ }));+ controller._univerInstanceService = {+ getUniverDocInstance: vi.fn(() => ({+ getSnapshot: () => ({+ drawings: {+ 'drawing-inline': inlineDrawing,+ },+ }),+ })),+ };+ controller._getPageContentSize = vi.fn(() => ({ width: 500, height: 500 }));+ controller._updateInlineDrawingAnchor = vi.fn();+ controller._anchorShape = { hide: vi.fn() };++ controller._listenTransformerChange('unit-1');++ changeStart$.next({ objects: new Map([['object-inline', object]]) });+ expect(object.setOpacity).toHaveBeenCalledWith(0.2);+ expect(controller._transformerCache.get('drawing-inline')).toMatchObject({+ drawing: inlineDrawing,+ top: 20,+ left: 10,+ });++ changing$.next({+ objects: new Map([['object-inline', { ...object, left: 30 }]]),+ offsetX: 40,+ offsetY: 50,+ });+ expect(controller._updateInlineDrawingAnchor).toHaveBeenCalledWith(inlineDrawing, 40, 50);++ changeEnd$.next({+ objects: new Map([['object-inline', { ...object, width: 100 }]]),+ offsetX: 40,+ offsetY: 50,+ });++ expect(object.setOpacity).toHaveBeenLastCalledWith(1);+ expect(controller._anchorShape.hide).toHaveBeenCalled();+ expect(controller._commandService.executeCommand).toHaveBeenCalledWith(UpdateDrawingDocTransformCommand.id, {+ unitId: 'unit-1',+ subUnitId: 'doc-1',+ drawings: [+ { drawingId: 'drawing-inline', key: 'size', value: { width: 100, height: 60 } },+ ],+ });+ expect(controller._transformerCache.size).toBe(0);+ });+});diff --git a/packages/docs-drawing-ui/src/controllers/render-controllers/__tests__/doc-drawing-transform-update.controller.spec.ts b/packages/docs-drawing-ui/src/controllers/render-controllers/__tests__/doc-drawing-transform-update.controller.spec.tsindex be8d7bfa54..002e100e9a 100644--- a/packages/docs-drawing-ui/src/controllers/render-controllers/__tests__/doc-drawing-transform-update.controller.spec.ts+++ b/packages/docs-drawing-ui/src/controllers/render-controllers/__tests__/doc-drawing-transform-update.controller.spec.ts@@ -14,10 +14,11 @@* limitations under the License.*/-import { setDocsTableRenderViewportProvider } from '@univerjs/engine-render';-import { afterEach, describe, expect, it } from 'vitest';+import { BooleanNumber, PositionedObjectLayoutType } from '@univerjs/core';+import { Liquid, setDocsTableRenderViewportProvider } from '@univerjs/engine-render';+import { afterEach, describe, expect, it, vi } from 'vitest';import { getDocsTableCellAnchorContext } from '../../doc-drawing-transformer-update.controller';-import { getDocsTableCellDrawingOffset } from '../doc-drawing-transform-update.controller';+import { DocDrawingTransformUpdateController, getDocsTableCellDrawingOffset } from '../doc-drawing-transform-update.controller';describe('DocDrawingTransformUpdateController', () => {afterEach(() => {@@ -98,4 +99,170 @@ describe('DocDrawingTransformUpdateController', () => {},});});++ it('refreshes normal, table-cell, header, and multi-transform drawings into drawing notifications', () => {+ const selectedShape = {};+ const transformer = {+ getSelectedObjectMap: vi.fn(() => new Map([['multi-drawing', selectedShape]])),+ setSelectedControl: vi.fn(),+ };+ const context = {+ unitId: 'unit-1',+ mainComponent: {+ left: 5,+ top: 7,+ pageLayoutType: 0,+ pageMarginLeft: 0,+ pageMarginTop: 20,+ },+ scene: {+ getTransformerByCreate: vi.fn(() => transformer),+ getObject: vi.fn((key) => key === 'multi-drawing' ? selectedShape : null),+ },+ };+ const drawingManagerService = {+ refreshTransform: vi.fn(),+ getDrawingByParam: vi.fn((drawing) => ({ ...drawing })),+ getDrawingData: vi.fn(() => ({+ 'multi-drawing': { drawingId: 'multi-drawing', isMultiTransform: BooleanNumber.TRUE },+ 'stale-multi': { drawingId: 'stale-multi', isMultiTransform: BooleanNumber.TRUE },+ })),+ removeNotification: vi.fn(),+ addNotification: vi.fn(),+ };+ const controller = Object.create(DocDrawingTransformUpdateController.prototype) as any;+ controller._context = context;+ controller._drawingManagerService = drawingManagerService;+ controller._liquid = new Liquid();++ const normalDrawing = {+ aLeft: 10,+ aTop: 20,+ width: 30,+ height: 40,+ angle: 5,+ drawingId: 'normal-drawing',+ drawingOrigin: {+ layoutType: PositionedObjectLayoutType.WRAP_NONE,+ behindDoc: BooleanNumber.TRUE,+ },+ };+ const headerDrawing = {+ aLeft: 3,+ aTop: 4,+ width: 9,+ height: 10,+ angle: 0,+ drawingId: 'header-drawing',+ drawingOrigin: {+ layoutType: PositionedObjectLayoutType.WRAP_SQUARE,+ },+ };+ const tableCellDrawing = {+ aLeft: 1,+ aTop: 2,+ width: 11,+ height: 12,+ angle: 0,+ drawingId: 'cell-drawing',+ drawingOrigin: {+ layoutType: PositionedObjectLayoutType.WRAP_SQUARE,+ },+ };+ const multiDrawingOnPage = {+ aLeft: 6,+ aTop: 8,+ width: 13,+ height: 14,+ angle: 2,+ drawingId: 'multi-drawing',+ drawingOrigin: {+ layoutType: PositionedObjectLayoutType.WRAP_SQUARE,+ behindDoc: BooleanNumber.FALSE,+ isMultiTransform: BooleanNumber.TRUE,+ },+ };+ const multiDrawingInHeader = {+ ...multiDrawingOnPage,+ aLeft: 16,+ aTop: 18,+ };+ const cell = {+ left: 7,+ marginLeft: 2,+ marginTop: 3,+ skeDrawings: new Map([['cell-drawing', tableCellDrawing]]),+ skeTables: [],+ };+ const table = {+ left: 30,+ top: 40,+ tableId: 'table-1#-#0',+ rows: [{+ top: 4,+ cells: [cell],+ }],+ };+ const page = {+ headerId: 'header-1',+ pageWidth: 200,+ pageHeight: 300,+ marginLeft: 11,+ marginTop: 13,+ marginBottom: 17,+ skeDrawings: new Map([+ ['normal-drawing', normalDrawing],+ ['multi-drawing', multiDrawingOnPage],+ ]),+ skeTables: [table],+ };+ const headerPage = {+ marginTop: 19,+ skeDrawings: new Map([+ ['header-drawing', headerDrawing],+ ['multi-drawing', multiDrawingInHeader],+ ]),+ skeTables: [],+ };+ const skeleton = {+ getSkeletonData: () => ({+ pages: [page],+ skeHeaders: new Map([['header-1', new Map([[200, headerPage]])]]),+ skeFooters: new Map(),+ }),+ };++ controller._refreshDrawing(skeleton);++ expect(drawingManagerService.refreshTransform).toHaveBeenCalledWith([+ expect.objectContaining({+ drawingId: 'header-drawing',+ transform: { left: 19, top: 30, width: 9, height: 10, angle: 0 },+ }),+ expect.objectContaining({+ drawingId: 'normal-drawing',+ behindText: true,+ transform: { left: 26, top: 40, width: 30, height: 40, angle: 5 },+ }),+ expect.objectContaining({+ drawingId: 'cell-drawing',+ transform: { left: 56, top: 69, width: 11, height: 12, angle: 0 },+ }),+ ]);+ expect(drawingManagerService.removeNotification).toHaveBeenCalledWith([+ { drawingId: 'multi-drawing', isMultiTransform: BooleanNumber.TRUE },+ { drawingId: 'stale-multi', isMultiTransform: BooleanNumber.TRUE },+ ]);+ expect(drawingManagerService.addNotification).toHaveBeenCalledWith([+ expect.objectContaining({+ drawingId: 'multi-drawing',+ isMultiTransform: BooleanNumber.TRUE,+ transforms: [+ { left: 32, top: 44, width: 13, height: 14, angle: 2 },+ { left: 22, top: 28, width: 13, height: 14, angle: 2 },+ ],+ }),+ ]);+ expect(transformer.setSelectedControl).toHaveBeenCalledWith(selectedShape);+ });});diff --git a/packages/docs-drawing-ui/src/controllers/render-controllers/__tests__/doc-drawing-update.render-controller.spec.ts b/packages/docs-drawing-ui/src/controllers/render-controllers/__tests__/doc-drawing-update.render-controller.spec.tsnew file mode 100644index 0000000000..fb52299f61--- /dev/null+++ b/packages/docs-drawing-ui/src/controllers/render-controllers/__tests__/doc-drawing-update.render-controller.spec.ts@@ -0,0 +1,262 @@+/**+ * Copyright 2023-present DreamNum Co., Ltd.+ *+ * 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.+ */++import { BooleanNumber, FOCUSING_COMMON_DRAWINGS } from '@univerjs/core';+import { DocumentEditArea } from '@univerjs/engine-render';+import { Subject } from 'rxjs';+import { describe, expect, it, vi } from 'vitest';+import { GroupDocDrawingCommand } from '../../../commands/commands/group-doc-drawing.command';+import { SetDocDrawingArrangeCommand } from '../../../commands/commands/set-drawing-arrange.command';+import { UngroupDocDrawingCommand } from '../../../commands/commands/ungroup-doc-drawing.command';+import { DocDrawingUpdateRenderController } from '../doc-drawing-update.render-controller';++function createController(options: {+ editArea?: DocumentEditArea;+ drawings?: Record<string, unknown>;+} = {}) {+ const featurePluginOrderUpdate$ = new Subject<any>();+ const featurePluginGroupUpdate$ = new Subject<any>();+ const featurePluginUngroupUpdate$ = new Subject<any>();+ const focus$ = new Subject<any[] | null>();+ const changeEnd$ = new Subject<any>();+ const editAreaChange$ = new Subject<void>();+ const refreshDrawings$ = new Subject<unknown>();+ const commandHandlers: Array<(command: { id: string }) => void> = [];+ let editArea = options.editArea ?? DocumentEditArea.BODY;++ const transformer = {+ changeEnd$,+ resetProps: vi.fn(),+ };+ const shapeByDrawingId = new Map<string, any>();+ const scene = {+ getTransformerByCreate: vi.fn(() => transformer),+ fuzzyMathObjects: vi.fn((objectKey: string) => {+ const drawingId = objectKey.split('#-#').at(-1) ?? objectKey;+ if (!shapeByDrawingId.has(drawingId)) {+ shapeByDrawingId.set(drawingId, {+ drawingId,+ setOpacity: vi.fn(),+ });+ }+ return [shapeByDrawingId.get(drawingId)];+ }),+ attachTransformerTo: vi.fn(),+ detachTransformerFrom: vi.fn(),+ };+ const viewModel = {+ editAreaChange$,+ getEditArea: vi.fn(() => editArea),+ };+ const renderUnit = {+ with: vi.fn(() => ({+ getViewModel: () => viewModel,+ })),+ };+ const snapshot = {+ body: {+ customBlocks: [+ { blockId: 'body-drawing', startIndex: 4 },+ ],+ },+ headers: {+ 'header-1': {+ body: {+ customBlocks: [+ { blockId: 'header-drawing', startIndex: 2 },+ ],+ },+ },+ },+ footers: {+ 'footer-1': {+ body: {+ customBlocks: [+ { blockId: 'footer-drawing', startIndex: 7 },+ ],+ },+ },+ },+ drawings: options.drawings ?? {},+ };+ const context = {+ unitId: 'doc-1',+ unit: {+ getSnapshot: vi.fn(() => snapshot),+ },+ scene,+ mainComponent: {+ getOffsetConfig: () => ({ docsLeft: 12, docsTop: 18 }),+ },+ };+ const commandService = {+ executeCommand: vi.fn(),+ onCommandExecuted: vi.fn((handler) => {+ commandHandlers.push(handler);+ return { dispose: vi.fn() };+ }),+ };+ const docSelectionManagerService = {+ refreshSelection: vi.fn(),+ replaceDocRanges: vi.fn(),+ };+ const renderManagerSrv = {+ getRenderById: vi.fn(() => renderUnit),+ };+ const docDrawingService = {+ focusDrawing: vi.fn(),+ };+ const drawingManagerService = {+ featurePluginOrderUpdate$,+ featurePluginGroupUpdate$,+ featurePluginUngroupUpdate$,+ focus$,+ };+ const contextService = {+ setContextValue: vi.fn(),+ };+ const docSelectionRenderService = {+ getActiveTextRange: vi.fn(() => null),+ getSegment: vi.fn(() => ''),+ setSegment: vi.fn(),+ };++ const controller = new DocDrawingUpdateRenderController(+ context as never,+ commandService as never,+ docSelectionManagerService as never,+ renderManagerSrv as never,+ {} as never,+ docDrawingService as never,+ drawingManagerService as never,+ contextService as never,+ { show: vi.fn() } as never,+ { t: vi.fn((key: string) => key) } as never,+ docSelectionRenderService as never,+ { refreshDrawings$ } as never,+ { openFile: vi.fn() } as never+ );++ return {+ controller,+ commandHandlers,+ commandService,+ contextService,+ docDrawingService,+ docSelectionManagerService,+ docSelectionRenderService,+ drawingManagerService,+ editAreaChange$,+ focus$,+ getShape: (drawingId: string) => shapeByDrawingId.get(drawingId),+ refreshDrawings$,+ scene,+ setEditArea: (value: DocumentEditArea) => {+ editArea = value;+ },+ transformer,+ };+}++describe('DocDrawingUpdateRenderController', () => {+ it('forwards drawing order and group events to doc drawing commands', () => {+ const { commandService, drawingManagerService } = createController();++ drawingManagerService.featurePluginOrderUpdate$.next({+ unitId: 'doc-1',+ subUnitId: 'doc-1',+ drawingIds: ['drawing-1'],+ arrangeType: 'forward',+ });+ drawingManagerService.featurePluginGroupUpdate$.next({ unitId: 'doc-1', drawingIds: ['a', 'b'] });+ drawingManagerService.featurePluginUngroupUpdate$.next({ unitId: 'doc-1', drawingIds: ['group-1'] });++ expect(commandService.executeCommand).toHaveBeenNthCalledWith(1, SetDocDrawingArrangeCommand.id, {+ unitId: 'doc-1',+ subUnitId: 'doc-1',+ drawingIds: ['drawing-1'],+ arrangeType: 'forward',+ });+ expect(commandService.executeCommand).toHaveBeenNthCalledWith(2, GroupDocDrawingCommand.id, { unitId: 'doc-1', drawingIds: ['a', 'b'] });+ expect(commandService.executeCommand).toHaveBeenNthCalledWith(3, UngroupDocDrawingCommand.id, { unitId: 'doc-1', drawingIds: ['group-1'] });+ });++ it('keeps document selection and segment in sync when drawings gain or lose focus', () => {+ const {+ contextService,+ docDrawingService,+ docSelectionManagerService,+ docSelectionRenderService,+ focus$,+ transformer,+ } = createController();++ focus$.next([]);+ expect(contextService.setContextValue).toHaveBeenCalledWith(FOCUSING_COMMON_DRAWINGS, false);+ expect(docDrawingService.focusDrawing).toHaveBeenCalledWith([]);+ expect(transformer.resetProps).toHaveBeenLastCalledWith({ zeroTop: 0, zeroLeft: 0 });++ focus$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'body-drawing' }]);+ expect(contextService.setContextValue).toHaveBeenCalledWith(FOCUSING_COMMON_DRAWINGS, true);+ expect(docDrawingService.focusDrawing).toHaveBeenLastCalledWith([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'body-drawing' }]);+ expect(docSelectionManagerService.replaceDocRanges).toHaveBeenCalledWith([{ startOffset: 4, endOffset: 5 }]);+ expect(docSelectionRenderService.setSegment).not.toHaveBeenCalled();+ expect(transformer.resetProps).toHaveBeenLastCalledWith({ zeroTop: 18, zeroLeft: 12 });++ focus$.next([{ unitId: 'doc-1', subUnitId: 'doc-1', drawingId: 'header-drawing' }]);+ expect(docSelectionRenderService.setSegment).toHaveBeenCalledWith('header-1');+ });++ it('refreshes doc selection after transformer changes finish', async () => {+ vi.useFakeTimers();+ const { docSelectionManagerService, transformer } = createController();++ transformer.changeEnd$.next({});+ await vi.advanceTimersByTimeAsync(30);++ expect(docSelectionManagerService.refreshSelection).toHaveBeenCalledTimes(1);+ vi.useRealTimers();+ });++ it('toggles drawing editability between body and header/footer edit areas', () => {+ const bodyDrawing = {+ drawingId: 'body-drawing',+ isMultiTransform: BooleanNumber.FALSE,+ };+ const headerDrawing = {+ drawingId: 'header-drawing',+ isMultiTransform: BooleanNumber.TRUE,+ };+ const { editAreaChange$, getShape, scene, setEditArea } = createController({+ drawings: {+ 'body-drawing': bodyDrawing,+ 'header-drawing': headerDrawing,+ },+ });++ expect(scene.attachTransformerTo).toHaveBeenCalledWith(getShape('body-drawing'));+ expect(getShape('body-drawing').setOpacity).toHaveBeenLastCalledWith(1);+ expect(getShape('header-drawing').setOpacity).toHaveBeenLastCalledWith(0.5);++ scene.attachTransformerTo.mockClear();+ setEditArea(DocumentEditArea.HEADER);+ editAreaChange$.next();++ expect(scene.attachTransformerTo).toHaveBeenCalledWith(getShape('header-drawing'));+ expect(getShape('header-drawing').setOpacity).toHaveBeenLastCalledWith(1);+ expect(getShape('body-drawing').setOpacity).toHaveBeenLastCalledWith(0.5);+ });+});diff --git a/packages/docs-drawing-ui/src/views/__tests__/DocPrintingFloatDom.spec.tsx b/packages/docs-drawing-ui/src/views/__tests__/DocPrintingFloatDom.spec.tsxindex f4cc36ad05..7bbe359dcb 100644--- a/packages/docs-drawing-ui/src/views/__tests__/DocPrintingFloatDom.spec.tsx+++ b/packages/docs-drawing-ui/src/views/__tests__/DocPrintingFloatDom.spec.tsx@@ -166,4 +166,33 @@ describe('DocPrintingFloatDom', () => {expect(root.textContent).not.toContain('Before scrolled viewport');expect(root.textContent).not.toContain('Below scaled page');});++ it('prints floating DOM content that partially intersects the page edge', () => {+ currentTestBed = createDocUiTestBed(createDocData(), [+ [ComponentManager],+ ]);+ currentTestBed.injector.get(ComponentManager).register(PRINTING_COMPONENT_KEY, PrintingVisibleContent);++ root = document.createElement('div');+ document.body.appendChild(root);++ act(() => {+ disposePrinting = mountDocPrintingFloatDom({+ floatDomInfos: [+ createFloatDom('partially-visible-left', 'Partially visible on left edge', { left: -20, top: 10, right: 20, bottom: 40 }),+ createFloatDom('partially-visible-bottom', 'Partially visible on bottom edge', { left: 40, top: 80, right: 80, bottom: 120 }),+ createFloatDom('fully-before-page', 'Fully before printable page', { left: -60, top: 10, right: -10, bottom: 40 }),+ ],+ scene: new TestScene() as unknown as Scene,+ skeleton: {} as never,+ unitId: UNIT_ID,+ offset: { x: 0, y: 0 },+ bound: { left: 0, top: 0, right: 200, bottom: 100 },+ }, root!, currentTestBed!.injector);+ });++ expect(root.textContent).toContain('Partially visible on left edge');+ expect(root.textContent).toContain('Partially visible on bottom edge');+ expect(root.textContent).not.toContain('Fully before printable page');+ });});diff --git a/packages/docs-drawing-ui/src/views/doc-image-panel/__tests__/DocDrawingTextWrap.spec.tsx b/packages/docs-drawing-ui/src/views/doc-image-panel/__tests__/DocDrawingTextWrap.spec.tsxindex 6a13f93063..3257bf2ec7 100644--- a/packages/docs-drawing-ui/src/views/doc-image-panel/__tests__/DocDrawingTextWrap.spec.tsx+++ b/packages/docs-drawing-ui/src/views/doc-image-panel/__tests__/DocDrawingTextWrap.spec.tsx@@ -403,6 +403,24 @@ describe('DocDrawingTextWrap', () => {});});+ it('disables side distance controls when text only wraps above and below the drawing', async () => {+ currentTestBed = createPanelTestBed();+ container = document.createElement('div');+ document.body.appendChild(container);+ root = createRoot(container);+ renderPanel(root, currentTestBed);++ await act(async () => {+ inputByLabelText('Top and Bottom').click();+ await Promise.resolve();+ });++ expect(inputInField('Top(px)').disabled).toBe(false);+ expect(inputInField('Bottom(px)').disabled).toBe(false);+ expect(inputInField('Left(px)').disabled).toBe(true);+ expect(inputInField('Right(px)').disabled).toBe(true);+ });+it('persists right-only text wrapping on the focused drawing', async () => {currentTestBed = createPanelTestBed();container = document.createElement('div');diff --git a/packages/drawing-ui/src/views/__tests__/DrawingCommandBehavior.spec.tsx b/packages/drawing-ui/src/views/__tests__/DrawingCommandBehavior.spec.tsxindex 4b1f8042cb..ffd76c028a 100644--- a/packages/drawing-ui/src/views/__tests__/DrawingCommandBehavior.spec.tsx+++ b/packages/drawing-ui/src/views/__tests__/DrawingCommandBehavior.spec.tsx@@ -442,4 +442,50 @@ describe('drawing command behavior', () => {}]);expect(document.querySelector('[role="menuitem"]')).toBeNull();});++ it('keeps disabled sheet image popup menu items inert while allowing enabled actions', async () => {+ const disabledEditParams = { unitId, subUnitId, drawingId, source: 'disabled-sheet-popup' };+ const cropParams = { unitId, subUnitId, drawingId, source: 'enabled-sheet-popup' };+ const rendered = renderWithRediContext(+ univer.__getInjector(),+ <ImagePopupMenu+ popup={{+ extraProps: {+ menuItems: [+ {+ label: 'drawing-ui.image-popup.edit',+ index: 0,+ commandId: editCommandId,+ commandParams: disabledEditParams,+ disable: true,+ },+ {+ label: 'drawing-ui.image-popup.crop',+ index: 1,+ commandId: cropCommandId,+ commandParams: cropParams,+ disable: false,+ },+ ],+ },+ }}+ />+ );+ root = rendered.root;+ container = rendered.container;++ clickElement(container.firstElementChild!.firstElementChild!);+ clickElement(findByText('[role="menuitem"]', 'drawing-ui.image-popup.edit'));+ clickElement(findByText('[role="menuitem"]', 'drawing-ui.image-popup.crop'));+ await flushPendingCommands();++ expect(executedCommands).toEqual([+ {+ id: cropCommandId,+ type: CommandType.OPERATION,+ params: cropParams,+ },+ ]);+ expect(document.querySelector('[role="menuitem"]')).toBeNull();+ });});diff --git a/packages/drawing-ui/src/views/__tests__/DrawingTransformBehavior.spec.tsx b/packages/drawing-ui/src/views/__tests__/DrawingTransformBehavior.spec.tsxindex f6b3ce3282..3f8489a616 100644--- a/packages/drawing-ui/src/views/__tests__/DrawingTransformBehavior.spec.tsx+++ b/packages/drawing-ui/src/views/__tests__/DrawingTransformBehavior.spec.tsx@@ -266,6 +266,45 @@ describe('DrawingTransform behavior', () => {expect(renderManagerService.transformer.notificationCount).toBe(1);});+ it('clamps negative position inputs to the canvas origin', async () => {+ const drawing = createDrawing('image-1');+ const updates: IDrawingParam[][] = [];+ drawingManagerService.featurePluginUpdate$.subscribe((update) => updates.push(update));++ const rendered = renderWithRediContext(univer.__getInjector(), drawing);+ root = rendered.root;+ container = rendered.container;++ act(() => {+ setInputValue(inputInField(container!, 'drawing-ui.image-panel.transform.x'), '-30');+ });+ await waitForDebouncedInput();+ act(() => {+ setInputValue(inputInField(container!, 'drawing-ui.image-panel.transform.y'), '-40');+ });+ await waitForDebouncedInput();++ expect(updates).toHaveLength(2);+ expect(updates[0][0]).toMatchObject({+ unitId,+ subUnitId,+ drawingId: 'image-1',+ drawingType: DrawingTypeEnum.DRAWING_IMAGE,+ transform: {+ left: expect.closeTo(0),+ },+ });+ expect(updates[1][0]).toMatchObject({+ unitId,+ subUnitId,+ drawingId: 'image-1',+ drawingType: DrawingTypeEnum.DRAWING_IMAGE,+ transform: {+ top: expect.closeTo(0),+ },+ });+ });+it('syncs transform fields from canvas transformer updates', () => {const drawing = createDrawing('image-1');drawingManagerService.registerDrawingData(unitId, {diff --git a/packages/sheets-conditional-formatting-ui/src/views/panel/__tests__/RuleList.spec.tsx b/packages/sheets-conditional-formatting-ui/src/views/panel/__tests__/RuleList.spec.tsxindex 3686f5272a..a0db80d471 100644--- a/packages/sheets-conditional-formatting-ui/src/views/panel/__tests__/RuleList.spec.tsx+++ b/packages/sheets-conditional-formatting-ui/src/views/panel/__tests__/RuleList.spec.tsx@@ -53,12 +53,16 @@ const FAR_RANGE: IRange = {};class TestMarkSelectionService {- addShape() {+ readonly addedRanges: IRange[] = [];+ removeCount = 0;++ addShape(selection: { range: IRange }) {+ this.addedRanges.push(selection.range);return 'shape-id';}removeShape() {- // no canvas layer is created for these view tests.+ this.removeCount += 1;}}@@ -374,6 +378,46 @@ describe('RuleList', () => {).toEqual(ruleIdsBeforeOpen);});+ it('highlights the hovered conditional formatting rule range and clears it on leave', async () => {+ currentTestBed = await createRuleListTestBed();+ container = document.createElement('div');+ document.body.appendChild(container);+ root = createRoot(container);++ await act(async () => {+ root!.render(+ <RediContext.Provider value={{ injector: currentTestBed!.injector }}>+ <RuleList onClick={() => undefined} onCreate={() => undefined} />+ </RediContext.Provider>+ );+ await Promise.resolve();+ });++ const activeRangeText = Array.from(container.querySelectorAll('div'))+ .find((element) => element.textContent === 'A1');+ const activeRuleRow = activeRangeText?.parentElement?.parentElement as HTMLElement | undefined;+ const markSelectionService = currentTestBed.injector.get(IMarkSelectionService) as unknown as TestMarkSelectionService;++ if (!activeRuleRow) {+ throw new Error('Rule row was not rendered');+ }++ await act(async () => {+ activeRuleRow.dispatchEvent(new MouseEvent('mousemove', { bubbles: true }));+ await Promise.resolve();+ });++ expect(markSelectionService.addedRanges).toEqual([ACTIVE_RANGE]);++ await act(async () => {+ activeRuleRow.dispatchEvent(new MouseEvent('mouseout', { bubbles: true }));+ await Promise.resolve();+ await Promise.resolve();+ });++ expect(markSelectionService.removeCount).toBe(1);+ });+it('clears all worksheet conditional formatting rules in worksheet mode', async () => {currentTestBed = await createRuleListTestBed();container = document.createElement('div');diff --git a/packages/sheets-data-validation-ui/src/views/components/__tests__/DataValidationOptions.spec.tsx b/packages/sheets-data-validation-ui/src/views/components/__tests__/DataValidationOptions.spec.tsxindex 6a3ba7fb7d..e391356e09 100644--- a/packages/sheets-data-validation-ui/src/views/components/__tests__/DataValidationOptions.spec.tsx+++ b/packages/sheets-data-validation-ui/src/views/components/__tests__/DataValidationOptions.spec.tsx@@ -207,6 +207,47 @@ describe('DataValidationOptions', () => {expect(container.querySelector<HTMLInputElement>('[data-u-comp="input"] input')?.value).toBe('Keep this instruction');});+ it('keeps edited invalid-data options after the options section is collapsed and reopened', async () => {+ currentTestBed = createOptionsTestBed();+ const changes: IDataValidationRuleOptions[] = [];+ container = document.createElement('div');+ document.body.appendChild(container);+ root = createRoot(container);++ await act(async () => {+ root!.render(+ <RediContext.Provider value={{ injector: currentTestBed!.injector }}>+ <OptionsHarness+ initialValue={{+ errorStyle: DataValidationErrorStyle.STOP,+ showErrorMessage: true,+ error: 'Initial instruction',+ }}+ changes={changes}+ />+ </RediContext.Provider>+ );+ await Promise.resolve();+ });++ const optionsToggle = container.firstElementChild as HTMLElement;+ await clickElement(optionsToggle);++ await changeInputValue(container.querySelector<HTMLInputElement>('[data-u-comp="input"] input')!, 'Updated instruction');+ expect(changes.at(-1)).toEqual({+ errorStyle: DataValidationErrorStyle.STOP,+ showErrorMessage: true,+ error: 'Updated instruction',+ });++ await clickElement(optionsToggle);+ expect(container.querySelector<HTMLInputElement>('[data-u-comp="input"] input')).toBeNull();++ await clickElement(optionsToggle);++ expect(container.querySelector<HTMLInputElement>('[data-u-comp="input"] input')?.value).toBe('Updated instruction');+ });+it('saves list render mode changes from the registered extra options component', async () => {currentTestBed = createOptionsTestBed();currentTestBed.injectordiff --git a/packages/sheets-drawing-ui/src/controllers/__tests__/sheet-drawing-copy-paste.controller.spec.ts b/packages/sheets-drawing-ui/src/controllers/__tests__/sheet-drawing-copy-paste.controller.spec.tsnew file mode 100644index 0000000000..7b05075734--- /dev/null+++ b/packages/sheets-drawing-ui/src/controllers/__tests__/sheet-drawing-copy-paste.controller.spec.ts@@ -0,0 +1,202 @@+/**+ * Copyright 2023-present DreamNum Co., Ltd.+ *+ * 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.+ */++import { DrawingTypeEnum } from '@univerjs/core';+import { ImageSourceType } from '@univerjs/drawing';+import { RemoveSheetDrawingCommand, SheetDrawingAnchorType } from '@univerjs/sheets-drawing';+import { COPY_TYPE, PREDEFINED_HOOK_NAME_PASTE } from '@univerjs/sheets-ui';+import { describe, expect, it, vi } from 'vitest';+import { SheetsDrawingCopyPasteController } from '../sheet-drawing-copy-paste.controller';++function createSkeleton() {+ return {+ getNoMergeCellWithCoordByIndex: vi.fn((row: number, column: number) => ({+ startX: column * 10,+ endX: column * 10 + 10,+ startY: row * 20,+ endY: row * 20 + 20,+ })),+ getCellIndexAndOffsetByPosition: vi.fn((left: number, top: number) => {+ const column = Math.floor(left / 10);+ const row = Math.floor(top / 20);+ return {+ column,+ row,+ columnOffset: left - column * 10,+ rowOffset: top - row * 20,+ };+ }),+ };+}++function createImageDrawing(overrides: Record<string, unknown> = {}) {+ return {+ unitId: 'unit-1',+ subUnitId: 'sheet-1',+ drawingId: 'image-1',+ drawingType: DrawingTypeEnum.DRAWING_IMAGE,+ imageSourceType: ImageSourceType.BASE64,+ source: 'data:image/png;base64,AA==',+ anchorType: SheetDrawingAnchorType.Both,+ transform: { left: 5, top: 5, width: 10, height: 20 },+ sheetTransform: {+ from: { row: 0, column: 0, rowOffset: 5, columnOffset: 5 },+ to: { row: 1, column: 1, rowOffset: 5, columnOffset: 5 },+ },+ axisAlignSheetTransform: {+ from: { row: 0, column: 0, rowOffset: 5, columnOffset: 5 },+ to: { row: 1, column: 1, rowOffset: 5, columnOffset: 5 },+ },+ ...overrides,+ };+}++function createController(options?: { focusedDrawings?: any[]; drawingData?: Record<string, any> }) {+ let hook: any;+ const skeleton = createSkeleton();+ const drawingService = {+ getFocusDrawings: vi.fn(() => options?.focusedDrawings ?? []),+ getDrawingData: vi.fn(() => options?.drawingData ?? {}),+ getBatchAddOp: vi.fn((drawings) => ({ undo: 'add-undo', redo: 'add-redo', objects: drawings })),+ getBatchUpdateOp: vi.fn((drawings) => ({ undo: 'update-undo', redo: 'update-redo', objects: drawings })),+ };+ const commandService = {+ executeCommand: vi.fn(),+ };+ const sheetClipboardService = {+ addClipboardHook: vi.fn((config) => {+ hook = config;+ return { dispose: vi.fn() };+ }),+ };++ const controller = new SheetsDrawingCopyPasteController(+ sheetClipboardService as never,+ {} as never,+ { getSkeleton: vi.fn(() => skeleton) } as never,+ drawingService as never,+ { writeText: vi.fn() } as never,+ commandService as never+ );++ return { controller, hook, skeleton, drawingService, commandService };+}++describe('SheetsDrawingCopyPasteController', () => {+ it('copies drawings contained in a cell range and pastes them with the range offset', () => {+ const containedDrawing = createImageDrawing();+ const outsideDrawing = createImageDrawing({+ drawingId: 'outside-image',+ transform: { left: 80, top: 80, width: 10, height: 20 },+ });+ const positionOnlyDrawing = createImageDrawing({+ drawingId: 'position-only',+ anchorType: SheetDrawingAnchorType.Position,+ });+ const { controller, hook, drawingService } = createController({+ drawingData: {+ [containedDrawing.drawingId]: containedDrawing,+ [outsideDrawing.drawingId]: outsideDrawing,+ [positionOnlyDrawing.drawingId]: positionOnlyDrawing,+ chart: { drawingId: 'chart', drawingType: DrawingTypeEnum.DRAWING_CHART },+ },+ });++ hook.onBeforeCopy('unit-1', 'sheet-1', {+ startRow: 0,+ endRow: 1,+ startColumn: 0,+ endColumn: 1,+ }, COPY_TYPE.COPY);++ const mutations = hook.onPasteCells(+ {+ unitId: 'unit-1',+ subUnitId: 'sheet-1',+ range: { rows: [0, 1], cols: [0, 1] },+ },+ {+ unitId: 'unit-2',+ subUnitId: 'sheet-2',+ range: { rows: [2, 3], cols: [3, 4] },+ },+ null,+ { copyType: COPY_TYPE.COPY, pasteType: PREDEFINED_HOOK_NAME_PASTE.DEFAULT_PASTE }+ );++ expect(drawingService.getBatchAddOp).toHaveBeenCalledTimes(1);+ const pastedDrawing = drawingService.getBatchAddOp.mock.calls[0][0][0];+ expect(pastedDrawing).toMatchObject({+ unitId: 'unit-2',+ subUnitId: 'sheet-2',+ transform: { left: 35, top: 45, width: 10, height: 20 },+ sheetTransform: {+ from: { row: 2, column: 3, rowOffset: 5, columnOffset: 5 },+ to: { row: 3, column: 4, rowOffset: 5, columnOffset: 5 },+ },+ });+ expect(pastedDrawing.drawingId).not.toBe(containedDrawing.drawingId);+ expect(mutations.redos).toEqual([+ expect.objectContaining({ params: expect.objectContaining({ op: 'add-redo', objects: [pastedDrawing] }) }),+ ]);++ controller.dispose();+ });++ it('cuts a focused image drawing and pastes it as a new drawing at the target range', () => {+ const focusedDrawing = createImageDrawing({ drawingId: 'focused-image' });+ const { controller, hook, drawingService, commandService } = createController({+ focusedDrawings: [focusedDrawing],+ });++ hook.onBeforeCopy('unit-1', 'sheet-1', {+ startRow: 0,+ endRow: 0,+ startColumn: 0,+ endColumn: 0,+ }, COPY_TYPE.CUT);++ expect(commandService.executeCommand).toHaveBeenCalledWith(RemoveSheetDrawingCommand.id, {+ unitId: 'unit-1',+ drawings: [focusedDrawing],+ });++ const mutations = hook.onPasteCells(+ undefined,+ {+ unitId: 'unit-1',+ subUnitId: 'sheet-1',+ range: { rows: [3], cols: [4] },+ },+ null,+ { copyType: COPY_TYPE.CUT, pasteType: PREDEFINED_HOOK_NAME_PASTE.DEFAULT_PASTE }+ );++ expect(drawingService.getBatchAddOp).toHaveBeenCalledTimes(1);+ const pastedDrawing = drawingService.getBatchAddOp.mock.calls[0][0][0];+ expect(pastedDrawing).toMatchObject({+ unitId: 'unit-1',+ subUnitId: 'sheet-1',+ transform: { left: 40, top: 60, width: 10, height: 20 },+ });+ expect(pastedDrawing.drawingId).not.toBe(focusedDrawing.drawingId);+ expect(mutations.redos).toEqual([+ expect.objectContaining({ params: expect.objectContaining({ op: 'add-redo', objects: [pastedDrawing] }) }),+ ]);++ controller.dispose();+ });+});diff --git a/packages/sheets-drawing-ui/src/controllers/__tests__/sheet-drawing-transform-affected.controller.spec.ts b/packages/sheets-drawing-ui/src/controllers/__tests__/sheet-drawing-transform-affected.controller.spec.tsnew file mode 100644index 0000000000..da8f0b0fc1--- /dev/null+++ b/packages/sheets-drawing-ui/src/controllers/__tests__/sheet-drawing-transform-affected.controller.spec.ts@@ -0,0 +1,339 @@+/**+ * Copyright 2023-present DreamNum Co., Ltd.+ *+ * 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.+ */++import { DrawingTypeEnum } from '@univerjs/core';+import {+ ClearSheetDrawingTransformerOperation,+ DrawingApplyType,+ SetDrawingApplyMutation,+ SheetDrawingAnchorType,+} from '@univerjs/sheets-drawing';+import { describe, expect, it, vi } from 'vitest';+import { SheetDrawingTransformAffectedController } from '../sheet-drawing-transform-affected.controller';++const UNIT_ID = 'unit-1';+const SUB_UNIT_ID = 'sheet-1';++function createSkeleton(options: { rowHeights?: number[]; colWidths?: number[] } = {}) {+ const rowHeights = options.rowHeights ?? [];+ const colWidths = options.colWidths ?? [];+ const rowHeightAt = (row: number) => rowHeights[row] ?? 20;+ const colWidthAt = (column: number) => colWidths[column] ?? 10;+ const sumRows = (end: number) => Array.from({ length: Math.max(end, 0) }, (_, row) => rowHeightAt(row)).reduce((sum, height) => sum + height, 0);+ const sumCols = (end: number) => Array.from({ length: Math.max(end, 0) }, (_, column) => colWidthAt(column)).reduce((sum, width) => sum + width, 0);++ return {+ rowHeaderWidth: 0,+ columnHeaderHeight: 0,+ rowTotalHeight: 2000,+ columnTotalWidth: 1000,+ getNoMergeCellWithCoordByIndex: vi.fn((row: number, column: number) => {+ const startY = sumRows(row);+ const startX = sumCols(column);+ return {+ startX,+ endX: startX + colWidthAt(column),+ startY,+ endY: startY + rowHeightAt(row),+ };+ }),+ getCellIndexAndOffsetByPosition: vi.fn((left: number, top: number) => {+ let column = 0;+ let colStart = 0;+ while (left >= colStart + colWidthAt(column)) {+ colStart += colWidthAt(column);+ column++;+ }++ let row = 0;+ let rowStart = 0;+ while (top >= rowStart + rowHeightAt(row)) {+ rowStart += rowHeightAt(row);+ row++;+ }++ return {+ column,+ row,+ columnOffset: left - colStart,+ rowOffset: top - rowStart,+ };+ }),+ };+}++function transformFromPosition(sheetTransform: any, skeleton: any) {+ const fromCell = skeleton.getNoMergeCellWithCoordByIndex(sheetTransform.from.row, sheetTransform.from.column);+ const toCell = skeleton.getNoMergeCellWithCoordByIndex(sheetTransform.to.row, sheetTransform.to.column);+ const left = fromCell.startX + sheetTransform.from.columnOffset;+ const top = fromCell.startY + sheetTransform.from.rowOffset;++ return {+ left,+ top,+ width: toCell.startX + sheetTransform.to.columnOffset - left,+ height: toCell.startY + sheetTransform.to.rowOffset - top,+ };+}++function createDrawing(overrides: Record<string, any> = {}, skeleton = createSkeleton()) {+ const sheetTransform = overrides.sheetTransform ?? {+ from: { row: 1, column: 1, rowOffset: 2, columnOffset: 2 },+ to: { row: 3, column: 3, rowOffset: 6, columnOffset: 6 },+ };+ const transform = overrides.transform ?? transformFromPosition(sheetTransform, skeleton);++ return {+ unitId: UNIT_ID,+ subUnitId: SUB_UNIT_ID,+ drawingId: overrides.drawingId ?? 'drawing-1',+ drawingType: DrawingTypeEnum.DRAWING_IMAGE,+ anchorType: overrides.anchorType ?? SheetDrawingAnchorType.Both,+ sheetTransform,+ axisAlignSheetTransform: sheetTransform,+ transform,+ ...overrides,+ };+}++function createController(options: { drawingData?: Record<string, any>; skeleton?: any } = {}) {+ const skeleton = options.skeleton ?? createSkeleton();+ const drawingData = options.drawingData ?? {};+ const sheetSkeletonParam = { unitId: UNIT_ID, sheetId: SUB_UNIT_ID, skeleton };+ const sheetDrawingService = {+ getDrawingData: vi.fn(() => drawingData),+ getBatchUpdateOp: vi.fn((drawings) => ({ undo: 'update-undo', redo: 'update-redo', objects: drawings })),+ getBatchRemoveOp: vi.fn((drawings) => ({ undo: 'remove-undo', redo: 'remove-redo', objects: drawings })),+ refreshTransform: vi.fn(),+ };+ const drawingManagerService = {+ getDrawingData: vi.fn(() => drawingData),+ refreshTransform: vi.fn(),+ };+ const controller = Object.create(SheetDrawingTransformAffectedController.prototype) as any;++ controller._sheetSkeletonService = {+ getSkeletonParam: vi.fn(() => sheetSkeletonParam),+ getSkeleton: vi.fn(() => skeleton),+ };+ controller._sheetDrawingService = sheetDrawingService;+ controller._drawingManagerService = drawingManagerService;+ controller._commandService = { syncExecuteCommand: vi.fn() };+ controller._getUnitIdAndSubUnitId = vi.fn(() => ({ unitId: UNIT_ID, subUnitId: SUB_UNIT_ID }));++ return { controller, skeleton, sheetDrawingService, drawingManagerService };+}++describe('SheetDrawingTransformAffectedController', () => {+ it('removes drawings covered by deleted rows and shifts drawings below into undoable mutations', () => {+ const skeleton = createSkeleton();+ const deleted = createDrawing({+ drawingId: 'deleted',+ sheetTransform: {+ from: { row: 2, column: 1, rowOffset: 0, columnOffset: 0 },+ to: { row: 3, column: 2, rowOffset: 10, columnOffset: 5 },+ },+ }, skeleton);+ const shifted = createDrawing({+ drawingId: 'shifted',+ sheetTransform: {+ from: { row: 5, column: 1, rowOffset: 2, columnOffset: 2 },+ to: { row: 6, column: 2, rowOffset: 6, columnOffset: 5 },+ },+ }, skeleton);+ const { controller, sheetDrawingService } = createController({+ skeleton,+ drawingData: { deleted, shifted },+ });++ const result = controller._moveRowInterceptor({+ range: { startRow: 2, endRow: 3, startColumn: 0, endColumn: 9 },+ }, 'remove');++ expect(sheetDrawingService.getBatchUpdateOp).toHaveBeenCalledWith([+ expect.objectContaining({+ drawingId: 'shifted',+ transform: expect.objectContaining({ top: 62, height: 24 }),+ sheetTransform: expect.objectContaining({+ from: expect.objectContaining({ row: 3, rowOffset: 2 }),+ to: expect.objectContaining({ row: 4, rowOffset: 6 }),+ }),+ }),+ ]);+ expect(sheetDrawingService.getBatchRemoveOp).toHaveBeenCalledWith([+ { unitId: UNIT_ID, subUnitId: SUB_UNIT_ID, drawingId: 'deleted' },+ ]);+ expect(result.redos).toEqual([+ { id: SetDrawingApplyMutation.id, params: { unitId: UNIT_ID, subUnitId: SUB_UNIT_ID, op: 'update-redo', objects: sheetDrawingService.getBatchUpdateOp.mock.calls[0][0], type: DrawingApplyType.UPDATE } },+ { id: SetDrawingApplyMutation.id, params: { unitId: UNIT_ID, subUnitId: SUB_UNIT_ID, op: 'remove-redo', objects: sheetDrawingService.getBatchRemoveOp.mock.calls[0][0], type: DrawingApplyType.REMOVE } },+ { id: ClearSheetDrawingTransformerOperation.id, params: [UNIT_ID] },+ ]);+ expect(result.undos[1].params.type).toBe(DrawingApplyType.INSERT);+ });++ it('moves drawings to the right when columns are inserted before them', () => {+ const skeleton = createSkeleton();+ const drawing = createDrawing({+ drawingId: 'image-after-inserted-cols',+ sheetTransform: {+ from: { row: 1, column: 3, rowOffset: 2, columnOffset: 2 },+ to: { row: 2, column: 4, rowOffset: 8, columnOffset: 5 },+ },+ }, skeleton);+ const { controller, sheetDrawingService } = createController({+ skeleton,+ drawingData: { [drawing.drawingId]: drawing },+ });++ const result = controller._moveColInterceptor({+ range: { startRow: 0, endRow: 9, startColumn: 1, endColumn: 2 },+ }, 'insert');+ const updatedDrawing = sheetDrawingService.getBatchUpdateOp.mock.calls[0][0][0];++ expect(updatedDrawing).toMatchObject({+ drawingId: 'image-after-inserted-cols',+ transform: { left: 52, top: 22, width: 13, height: 26 },+ sheetTransform: {+ from: { row: 1, column: 5, rowOffset: 2, columnOffset: 2 },+ to: { row: 2, column: 6, rowOffset: 8, columnOffset: 5 },+ },+ });+ expect(result.redos).toContainEqual({ id: ClearSheetDrawingTransformerOperation.id, params: [UNIT_ID] });+ });++ it('updates both-anchored drawings when hidden rows cut through their top edge', () => {+ const skeleton = createSkeleton();+ const drawing = createDrawing({+ drawingId: 'row-hidden-top-edge',+ sheetTransform: {+ from: { row: 1, column: 1, rowOffset: 5, columnOffset: 0 },+ to: { row: 4, column: 3, rowOffset: 5, columnOffset: 0 },+ },+ }, skeleton);+ const { controller, sheetDrawingService } = createController({+ skeleton,+ drawingData: { [drawing.drawingId]: drawing },+ });++ const result = controller._getDrawingUndoForRowVisible(UNIT_ID, SUB_UNIT_ID, [+ { startRow: 1, endRow: 2, startColumn: 0, endColumn: 9 },+ ]);+ const updatedDrawing = sheetDrawingService.getBatchUpdateOp.mock.calls[0][0][0];++ expect(updatedDrawing).toMatchObject({+ drawingId: 'row-hidden-top-edge',+ transform: { left: 10, top: 20, width: 20, height: 20 },+ sheetTransform: {+ from: { row: 1, column: 1, rowOffset: 0, columnOffset: 0 },+ to: { row: 2, column: 3, rowOffset: 0, columnOffset: 0 },+ },+ });+ expect(result.redos).toEqual([+ { id: SetDrawingApplyMutation.id, params: { unitId: UNIT_ID, subUnitId: SUB_UNIT_ID, op: 'update-redo', objects: [updatedDrawing], type: DrawingApplyType.UPDATE } },+ { id: ClearSheetDrawingTransformerOperation.id, params: [UNIT_ID] },+ ]);+ });++ it('recalculates drawing transforms after row height changes without changing anchors', () => {+ const resizedSkeleton = createSkeleton({ rowHeights: [20, 20, 40, 20] });+ const sheetTransform = {+ from: { row: 1, column: 1, rowOffset: 0, columnOffset: 0 },+ to: { row: 3, column: 3, rowOffset: 0, columnOffset: 0 },+ };+ const drawing = createDrawing({+ drawingId: 'resized-by-row-height',+ sheetTransform,+ transform: { left: 10, top: 20, width: 20, height: 40 },+ }, resizedSkeleton);+ const { controller, sheetDrawingService } = createController({+ skeleton: resizedSkeleton,+ drawingData: { [drawing.drawingId]: drawing },+ });++ const result = controller._getDrawingUndoForRowAndColSize(UNIT_ID, SUB_UNIT_ID, [+ { startRow: 2, endRow: 2, startColumn: 0, endColumn: 9 },+ ]);+ const updatedDrawing = sheetDrawingService.getBatchUpdateOp.mock.calls[0][0][0];++ expect(updatedDrawing).toMatchObject({+ drawingId: 'resized-by-row-height',+ sheetTransform,+ transform: { left: 10, top: 20, width: 20, height: 60 },+ });+ expect(result.undos).toEqual([+ { id: SetDrawingApplyMutation.id, params: { unitId: UNIT_ID, subUnitId: SUB_UNIT_ID, op: 'update-undo', objects: [updatedDrawing], type: DrawingApplyType.UPDATE } },+ { id: ClearSheetDrawingTransformerOperation.id, params: [UNIT_ID] },+ ]);+ });++ it('moves only fully contained both-anchored drawings when a range is moved', () => {+ const skeleton = createSkeleton();+ const contained = createDrawing({+ drawingId: 'contained',+ sheetTransform: {+ from: { row: 1, column: 1, rowOffset: 2, columnOffset: 2 },+ to: { row: 2, column: 2, rowOffset: 6, columnOffset: 6 },+ },+ }, skeleton);+ const positionOnly = createDrawing({+ drawingId: 'position-only',+ anchorType: SheetDrawingAnchorType.Position,+ sheetTransform: {+ from: { row: 1, column: 1, rowOffset: 0, columnOffset: 0 },+ to: { row: 2, column: 2, rowOffset: 0, columnOffset: 0 },+ },+ }, skeleton);+ const partlyOutside = createDrawing({+ drawingId: 'partly-outside',+ sheetTransform: {+ from: { row: 0, column: 0, rowOffset: 0, columnOffset: 0 },+ to: { row: 3, column: 3, rowOffset: 0, columnOffset: 0 },+ },+ }, skeleton);+ const { controller, sheetDrawingService } = createController({+ skeleton,+ drawingData: {+ contained,+ [positionOnly.drawingId]: positionOnly,+ [partlyOutside.drawingId]: partlyOutside,+ },+ });++ const result = controller._moveRangeInterceptor(+ UNIT_ID,+ SUB_UNIT_ID,+ { startRow: 1, endRow: 2, startColumn: 1, endColumn: 2 },+ { startRow: 3, endRow: 4, startColumn: 4, endColumn: 5 }+ );+ const updatedDrawing = sheetDrawingService.getBatchUpdateOp.mock.calls[0][0][0];++ expect(sheetDrawingService.getBatchUpdateOp).toHaveBeenCalledTimes(1);+ expect(sheetDrawingService.getBatchUpdateOp.mock.calls[0][0]).toHaveLength(1);+ expect(updatedDrawing).toMatchObject({+ unitId: UNIT_ID,+ subUnitId: SUB_UNIT_ID,+ drawingId: 'contained',+ transform: { left: 42, top: 62, width: 14, height: 24 },+ sheetTransform: {+ from: { row: 3, column: 4, rowOffset: 2, columnOffset: 2 },+ to: { row: 4, column: 5, rowOffset: 6, columnOffset: 6 },+ },+ });+ expect(result.redos).toEqual([+ { id: SetDrawingApplyMutation.id, params: { unitId: UNIT_ID, subUnitId: SUB_UNIT_ID, op: 'update-redo', objects: [updatedDrawing], type: DrawingApplyType.UPDATE } },+ ]);+ });+});diff --git a/packages/sheets-drawing-ui/src/controllers/__tests__/sheet-drawing-update.controller.spec.ts b/packages/sheets-drawing-ui/src/controllers/__tests__/sheet-drawing-update.controller.spec.tsnew file mode 100644index 0000000000..148f0018a1--- /dev/null+++ b/packages/sheets-drawing-ui/src/controllers/__tests__/sheet-drawing-update.controller.spec.ts@@ -0,0 +1,240 @@+/**+ * Copyright 2023-present DreamNum Co., Ltd.+ *+ * 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.+ */++import { DrawingTypeEnum, FOCUSING_COMMON_DRAWINGS } from '@univerjs/core';+import { MessageType } from '@univerjs/design';+import { SetDrawingSelectedOperation } from '@univerjs/drawing';+import { SetDrawingArrangeCommand, SetSheetDrawingCommand } from '@univerjs/sheets-drawing';+import { Subject } from 'rxjs';+import { describe, expect, it, vi } from 'vitest';+import { GroupSheetDrawingCommand } from '../../commands/commands/group-sheet-drawing.command';+import { UngroupSheetDrawingCommand } from '../../commands/commands/ungroup-sheet-drawing.command';+import { SheetDrawingUpdateController } from '../sheet-drawing-update.controller';++function createSkeleton() {+ return {+ rowHeaderWidth: 0,+ columnHeaderHeight: 0,+ columnTotalWidth: 1000,+ rowTotalHeight: 1000,+ getNoMergeCellWithCoordByIndex: vi.fn((row: number, column: number) => ({+ startX: column * 10,+ endX: column * 10 + 10,+ startY: row * 20,+ endY: row * 20 + 20,+ })),+ getCellIndexAndOffsetByPosition: vi.fn((left: number, top: number) => {+ const column = Math.floor(left / 10);+ const row = Math.floor(top / 20);+ return {+ column,+ row,+ columnOffset: left - column * 10,+ rowOffset: top - row * 20,+ };+ }),+ };+}++function createController(options?: { openFiles?: unknown[] }) {+ const featurePluginOrderUpdate$ = new Subject<any>();+ const featurePluginUpdate$ = new Subject<any[]>();+ const featurePluginGroupUpdate$ = new Subject<any[]>();+ const featurePluginUngroupUpdate$ = new Subject<any[]>();+ const focus$ = new Subject<any[] | null>();+ const skeleton = createSkeleton();+ const commandService = {+ executeCommand: vi.fn(),+ syncExecuteCommand: vi.fn(() => true),+ };+ const sheetDrawingService = {+ getDrawingByParam: vi.fn(({ drawingId }) => ({+ unitId: 'unit-1',+ subUnitId: 'sheet-1',+ drawingId,+ drawingType: DrawingTypeEnum.DRAWING_IMAGE,+ transform: { left: 10, top: 20, width: 30, height: 40 },+ sheetTransform: {+ from: { row: 1, column: 1, rowOffset: 0, columnOffset: 0 },+ to: { row: 3, column: 4, rowOffset: 0, columnOffset: 0 },+ },+ })),+ focusDrawing: vi.fn(),+ };+ const selectionManagerService = {+ getWorkbookSelections: vi.fn(() => ({+ getCurrentSelections: vi.fn(() => []),+ getCurrentLastSelection: vi.fn(() => undefined),+ })),+ };+ const controller = new SheetDrawingUpdateController(+ {+ unitId: 'unit-1',+ unit: {+ getUnitId: () => 'unit-1',+ getActiveSheet: () => ({ getSheetId: () => 'sheet-1' }),+ },+ scene: { width: 400, height: 300 },+ } as never,+ commandService as never,+ { interceptAfterCommand: vi.fn(() => ({ dispose: vi.fn() })) } as never,+ { getCellWithCoordByOffset: vi.fn() } as never,+ { saveImage: vi.fn(), addImageSourceCache: vi.fn() } as never,+ { openFile: vi.fn(async () => options?.openFiles ?? []) } as never,+ sheetDrawingService as never,+ {+ featurePluginOrderUpdate$,+ featurePluginUpdate$,+ featurePluginGroupUpdate$,+ featurePluginUngroupUpdate$,+ focus$,+ } as never,+ { setContextValue: vi.fn() } as never,+ { show: vi.fn() } as never,+ { t: vi.fn((key: string, value?: string) => `${key}:${value ?? ''}`) } as never,+ selectionManagerService as never,+ {+ getSkeleton: vi.fn(() => skeleton),+ getSkeletonParam: vi.fn(() => ({ unitId: 'unit-1', sheetId: 'sheet-1', skeleton })),+ } as never,+ { get: vi.fn() } as never,+ { getImage: vi.fn() } as never+ );++ return {+ controller,+ commandService,+ sheetDrawingService,+ featurePluginOrderUpdate$,+ featurePluginUpdate$,+ featurePluginGroupUpdate$,+ featurePluginUngroupUpdate$,+ focus$,+ };+}++describe('SheetDrawingUpdateController', () => {+ it('reports empty and over-limit file selections without inserting images', async () => {+ const empty = createController({ openFiles: [] });++ await expect(empty.controller.insertFloatImage()).resolves.toBe(false);+ await expect(empty.controller.insertCellImage()).resolves.toBe(false);+ expect((empty.controller as any)._messageService.show).not.toHaveBeenCalled();+ empty.controller.dispose();++ const overLimitFiles = Array.from({ length: 30 }, (_, index) => ({ name: `image-${index}.png` }));+ const overLimit = createController({ openFiles: overLimitFiles });++ await expect(overLimit.controller.insertFloatImage()).resolves.toBe(false);++ expect((overLimit.controller as any)._messageService.show).toHaveBeenCalledWith({+ type: MessageType.Error,+ content: expect.stringContaining('sheets-drawing-ui.update-status.exceedMaxCount'),+ });+ expect(overLimit.commandService.executeCommand).not.toHaveBeenCalled();+ overLimit.controller.dispose();+ });++ it('converts drawing transform updates into sheet drawing commands', () => {+ const { controller, commandService, featurePluginUpdate$ } = createController();++ featurePluginUpdate$.next([{+ unitId: 'unit-1',+ subUnitId: 'sheet-1',+ drawingId: 'image-1',+ transform: { left: 25, top: 45 },+ }]);++ expect(commandService.executeCommand).toHaveBeenCalledWith(SetSheetDrawingCommand.id, {+ unitId: 'unit-1',+ drawings: [+ expect.objectContaining({+ drawingId: 'image-1',+ transform: expect.objectContaining({ left: 25, top: 45, width: 30, height: 40 }),+ sheetTransform: expect.objectContaining({+ from: { row: 2, column: 2, rowOffset: 5, columnOffset: 5 },+ to: { row: 4, column: 5, rowOffset: 5, columnOffset: 5 },+ }),+ }),+ ],+ });++ controller.dispose();+ });++ it('forwards arrange, group, ungroup and focus drawing events to sheet services', () => {+ const {+ controller,+ commandService,+ sheetDrawingService,+ featurePluginOrderUpdate$,+ featurePluginGroupUpdate$,+ featurePluginUngroupUpdate$,+ focus$,+ } = createController();+ const parent = {+ unitId: 'unit-1',+ subUnitId: 'sheet-1',+ drawingId: 'group-1',+ transform: { left: 0, top: 0, width: 40, height: 40 },+ };+ const child = {+ unitId: 'unit-1',+ subUnitId: 'sheet-1',+ drawingId: 'image-1',+ transform: { left: 10, top: 20, width: 30, height: 40 },+ };++ featurePluginOrderUpdate$.next({+ unitId: 'unit-1',+ subUnitId: 'sheet-1',+ drawingIds: ['image-1'],+ arrangeType: 'front',+ });+ featurePluginGroupUpdate$.next([{ parent, children: [child] }]);+ featurePluginUngroupUpdate$.next([{ parent, children: [child] }]);+ focus$.next([{ unitId: 'unit-1', subUnitId: 'sheet-1', drawingId: 'image-1' }]);+ focus$.next([]);++ expect(commandService.executeCommand).toHaveBeenCalledWith(SetDrawingArrangeCommand.id, {+ unitId: 'unit-1',+ subUnitId: 'sheet-1',+ drawingIds: ['image-1'],+ arrangeType: 'front',+ });+ expect(commandService.executeCommand).toHaveBeenCalledWith(GroupSheetDrawingCommand.id, [+ expect.objectContaining({+ parent: expect.objectContaining({ drawingId: 'group-1', sheetTransform: expect.any(Object) }),+ children: [expect.objectContaining({ drawingId: 'image-1', sheetTransform: expect.any(Object) })],+ }),+ ]);+ expect(commandService.syncExecuteCommand).toHaveBeenCalledWith(SetDrawingSelectedOperation.id, [{+ unitId: 'unit-1',+ subUnitId: 'sheet-1',+ drawingId: 'group-1',+ }]);+ expect(commandService.executeCommand).toHaveBeenCalledWith(UngroupSheetDrawingCommand.id, [+ expect.objectContaining({+ children: [expect.objectContaining({ drawingId: 'image-1', sheetTransform: expect.any(Object) })],+ }),+ ]);+ expect((controller as any)._contextService.setContextValue).toHaveBeenCalledWith(FOCUSING_COMMON_DRAWINGS, true);+ expect((controller as any)._contextService.setContextValue).toHaveBeenCalledWith(FOCUSING_COMMON_DRAWINGS, false);+ expect(sheetDrawingService.focusDrawing).toHaveBeenLastCalledWith([]);++ controller.dispose();+ });+});diff --git a/packages/sheets-drawing-ui/src/views/__tests__/PrintingFloatDom.spec.tsx b/packages/sheets-drawing-ui/src/views/__tests__/PrintingFloatDom.spec.tsxindex 3b48f308b5..c6c88f113e 100644--- a/packages/sheets-drawing-ui/src/views/__tests__/PrintingFloatDom.spec.tsx+++ b/packages/sheets-drawing-ui/src/views/__tests__/PrintingFloatDom.spec.tsx@@ -74,15 +74,15 @@ class TestPrintingWorksheet {}}-function PrintingContent() {- return <span data-testid="printed-content">printed</span>;+function PrintingContent(props: { data?: { label?: string } }) {+ return <span data-testid="printed-content">{props.data?.label}</span>;}-function createFloatDomInfo(): IFloatDomData {+function createFloatDomInfo(drawingId = 'printed-float-dom', label = 'printing'): IFloatDomData {return {unitId: 'test',subUnitId: 'sheet1',- drawingId: 'printed-float-dom',+ drawingId,drawingType: DrawingTypeEnum.DRAWING_DOM,componentKey: PRINTING_COMPONENT_KEY,transform: {@@ -97,7 +97,7 @@ function createFloatDomInfo(): IFloatDomData {skewY: 0,},data: {- label: 'printing',+ label,},axisAlignSheetTransform: {angle: 0,@@ -157,4 +157,30 @@ describe('PrintingFloatDom', () => {expect(printedFloatDom.parentElement.style.height).toBe('198px');expect(printedFloatDom.parentElement.style.transform).toBe('rotate(27deg)');});++ it('prints each floating DOM with its own component data', async () => {+ currentTestBed = createSheetsDrawingUiTestBed(undefined, [+ [ComponentManager],+ ]);+ currentTestBed.injector.get(ComponentManager).register(PRINTING_COMPONENT_KEY, PrintingContent);+ const root = document.createElement('div');+ container = root;+ document.body.appendChild(root);++ await act(async () => {+ unmountPrintingFloatDom = mountPrintingFloatDom({+ floatDomInfos: [+ createFloatDomInfo('first-printed-float-dom', 'First printed label'),+ createFloatDomInfo('second-printed-float-dom', 'Second printed label'),+ ],+ scene: new TestPrintingScene() as unknown as Scene,+ skeleton: new TestPrintingSkeleton() as unknown as SpreadsheetSkeleton,+ worksheet: new TestPrintingWorksheet() as unknown as Worksheet,+ }, root, currentTestBed!.injector);+ await Promise.resolve();+ });++ expect(root.textContent).toContain('First printed label');+ expect(root.textContent).toContain('Second printed label');+ });});diff --git a/packages/sheets-formula-ui/src/controllers/__tests__/formula-clipboard.controller.spec.ts b/packages/sheets-formula-ui/src/controllers/__tests__/formula-clipboard.controller.spec.tsindex 7d126df15a..2ad70cb936 100644--- a/packages/sheets-formula-ui/src/controllers/__tests__/formula-clipboard.controller.spec.ts+++ b/packages/sheets-formula-ui/src/controllers/__tests__/formula-clipboard.controller.spec.ts@@ -1375,3 +1375,187 @@ describe('Test paste with formula', () => {});});});++describe('getSetCellFormulaMutations matrix branches', () => {+ let univer: Univer;+ let get: Injector['get'];+ let has: Injector['has'];++ beforeEach(() => {+ const testBed = createCommandTestBed();+ univer = testBed.univer;+ get = testBed.get;+ has = testBed.has;+ });++ afterEach(() => {+ univer.dispose();+ });++ function accessor() {+ return { get, has };+ }++ it('converts pasted formula-looking text into cell formulas when there is no paste source', () => {+ const matrix = new ObjectMatrix<ICellDataWithSpanInfo>({+ 0: {+ 0: { v: '=SUM(A1)' },+ 1: { v: 'plain' },+ },+ });++ const result = getSetCellFormulaMutations(+ 'test',+ 'sheet1',+ { rows: [8], cols: [4, 5] },+ matrix,+ accessor(),+ { copyType: COPY_TYPE.COPY, pasteType: PREDEFINED_HOOK_NAME_PASTE.DEFAULT_PASTE },+ { moveFormulaRefOffset: (formula: string) => formula } as any,+ { getSheetFormulaData: () => ({}) } as any,+ false,+ null+ );++ expect(result.redos[0]).toMatchObject({+ id: SetRangeValuesMutation.id,+ params: {+ unitId: 'test',+ subUnitId: 'sheet1',+ cellValue: {+ 8: {+ 4: { v: null, f: '=SUM(A1)', si: null, p: null },+ },+ },+ },+ });+ });++ it('special-paste value removes formulas while preserving display values and rich text text', () => {+ const matrix = new ObjectMatrix<ICellDataWithSpanInfo>({+ 0: {+ 0: { v: 12, f: '=A1' },+ 1: { v: null, p: { body: { dataStream: 'rich text\r\n' } } as any },+ },+ });++ const result = getSetCellFormulaMutations(+ 'test',+ 'sheet1',+ { rows: [9], cols: [1, 2] },+ matrix,+ accessor(),+ { copyType: COPY_TYPE.COPY, pasteType: PREDEFINED_HOOK_NAME_PASTE.SPECIAL_PASTE_VALUE },+ { moveFormulaRefOffset: (formula: string) => formula } as any,+ {+ getArrayFormulaCellData: () => ({}),+ getSheetFormulaData: () => ({ 9: { 2: { f: '=OLD()' } } }),+ } as any,+ false,+ {+ unitId: 'test',+ subUnitId: 'sheet1',+ range: { rows: [0], cols: [0, 1] },+ }+ );++ expect(result.redos[0]).toMatchObject({+ params: {+ cellValue: {+ 9: {+ 1: { v: 12, f: null, si: null, p: null },+ 2: { v: 'rich text', f: null, si: null, p: null },+ },+ },+ },+ });+ });++ it('special-paste formula shifts formula refs across sheets and reuses shared ids inside the pasted block', () => {+ const moveFormulaRefOffset = (formula: string, offsetX: number, offsetY: number) => `${formula}:${offsetX}:${offsetY}`;+ const matrix = new ObjectMatrix<ICellDataWithSpanInfo>({+ 0: {+ 0: { si: 'shared-source' },+ 1: { f: '=A1' },+ },+ 1: {+ 0: { si: 'shared-source' },+ 1: { f: '=A1' },+ },+ });++ const result = getSetCellFormulaMutations(+ 'test',+ 'sheet1',+ { rows: [10, 11], cols: [5, 6] },+ matrix,+ accessor(),+ { copyType: COPY_TYPE.COPY, pasteType: PREDEFINED_HOOK_NAME_PASTE.SPECIAL_PASTE_FORMULA },+ { moveFormulaRefOffset } as any,+ {+ getFormulaStringByCell: () => '=B2',+ } as any,+ true,+ {+ unitId: 'test',+ subUnitId: 'sheet2',+ range: { rows: [0, 1], cols: [0, 1] },+ }+ );++ const cellValue = (result.redos[0].params as ISetRangeValuesMutationParams).cellValue;+ if (!cellValue) {+ throw new Error('Expected formula paste to generate cell values.');+ }+ const firstSharedCell = cellValue[10]?.[6];+ const secondSharedCell = cellValue[11]?.[6];+ if (!firstSharedCell || !secondSharedCell) {+ throw new Error('Expected formula paste to generate shared formula target cells.');+ }+ expect(cellValue[10][5]).toEqual({ v: null, si: null, f: '=B2:5:10', p: null });+ expect(cellValue[11][5]).toEqual({ v: null, si: null, f: '=B2:5:10', p: null });+ expect(cellValue[10][6]).toMatchObject({ v: null, f: '=A1:5:10', p: null });+ expect(cellValue[11][6]).toMatchObject({ v: null, f: '=A1:5:10', p: null });+ expect(firstSharedCell.si).toEqual(expect.any(String));+ expect(secondSharedCell.si).toEqual(expect.any(String));+ });++ it('default cut paste keeps cut formulas stable and expands external shared formula references into formula strings', () => {+ const matrix = new ObjectMatrix<ICellDataWithSpanInfo>({+ 0: {+ 0: { f: '=A1', si: 'shared-cut' },+ 1: { si: 'shared-cut' },+ },+ });++ const result = getSetCellFormulaMutations(+ 'test',+ 'sheet1',+ { rows: [12], cols: [3, 4] },+ matrix,+ accessor(),+ { copyType: COPY_TYPE.CUT, pasteType: PREDEFINED_HOOK_NAME_PASTE.DEFAULT_PASTE },+ { moveFormulaRefOffset: (formula: string) => formula } as any,+ {+ getFormulaStringByCell: (row: number, col: number) => `=R${row}C${col}`,+ getSheetFormulaData: () => ({+ 0: { 2: { si: 'shared-cut' } },+ }),+ } as any,+ false,+ {+ unitId: 'test',+ subUnitId: 'sheet1',+ range: { rows: [0], cols: [0, 1] },+ }+ );++ const cellValue = (result.redos[0].params as ISetRangeValuesMutationParams).cellValue;+ if (!cellValue) {+ throw new Error('Expected cut paste to generate cell values.');+ }+ expect(cellValue[12][3]).toEqual({ f: '=A1', si: 'shared-cut', v: null, p: null });+ expect(cellValue[12][4]).toEqual({ f: null, si: 'shared-cut', v: null, p: null });+ expect(cellValue[0][2]).toEqual({ f: '=R0C2', si: null, v: null, p: null });+ });+});diff --git a/packages/sheets-formula-ui/src/views/formula-editor/hooks/__tests__/formula-selection-business.spec.ts b/packages/sheets-formula-ui/src/views/formula-editor/hooks/__tests__/formula-selection-business.spec.tsnew file mode 100644index 0000000000..6eecc045d3--- /dev/null+++ b/packages/sheets-formula-ui/src/views/formula-editor/hooks/__tests__/formula-selection-business.spec.ts@@ -0,0 +1,188 @@+/**+ * Copyright 2023-present DreamNum Co., Ltd.+ *+ * 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.+ */++import { sequenceNodeType } from '@univerjs/engine-formula';+import { describe, expect, it, vi } from 'vitest';+import { shouldSkipReferenceEditingByPointer } from '../use-formula-selection';+import { buildTextRuns, calcHighlightRanges } from '../use-highlight';+import { createSelectionChangeHandler, getSelectionsForFormulaRefUpdate } from '../use-sheet-selection-change';++function range(row: number, col: number, sheetId = 'sheet1', unitId = 'unit1') {+ return {+ startRow: row,+ endRow: row,+ startColumn: col,+ endColumn: col,+ sheetId,+ unitId,+ };+}++describe('formula selection update helpers', () => {+ it('only skips reference editing when pointer-origin editing is still disabled and click editing is allowed', () => {+ expect(shouldSkipReferenceEditingByPointer(true)).toBe(true);+ expect(shouldSkipReferenceEditingByPointer(true, true)).toBe(false);+ expect(shouldSkipReferenceEditingByPointer(false)).toBe(false);+ });++ it('reorders the active selection into the formula reference being edited and keeps ctrl-added ranges separate', () => {+ const selections = [range(0, 0), range(1, 1), range(2, 2)];++ expect(getSelectionsForFormulaRefUpdate(selections, 0)).toEqual({+ orderedSelections: [range(2, 2), range(0, 0), range(1, 1)],+ });+ expect(getSelectionsForFormulaRefUpdate(selections, 1, true)).toEqual({+ orderedSelections: [range(0, 0), range(1, 1)],+ insertedSelection: range(2, 2),+ });+ expect(getSelectionsForFormulaRefUpdate(selections, -1)).toEqual({+ orderedSelections: selections,+ });+ });++ it('defers ctrl-add selection updates until move end and ignores initial selection events', () => {+ const onSelectionsChange = vi.fn();+ const handler = createSelectionChangeHandler({+ initialSelectionsCount: 1,+ onSelectionsChange,+ });++ handler([range(0, 0)], true, { initial: true });+ handler([range(0, 0), range(1, 1)], false);+ expect(onSelectionsChange).not.toHaveBeenCalled();++ handler([range(0, 0), range(1, 1)], true);+ expect(onSelectionsChange).toHaveBeenCalledWith([range(0, 0), range(1, 1)], true, true);++ handler([range(3, 3)], false);+ expect(onSelectionsChange).toHaveBeenLastCalledWith([range(3, 3)], false, false);+ });+});++describe('formula highlight helpers', () => {+ it('builds colored text runs for references, numbers, strings, arrays, defined names, and plain text', () => {+ const result = buildTextRuns(+ { hasDefinedNameDescription: vi.fn((token: string) => token === 'SalesTotal') } as any,+ {+ formulaRefColors: ['#ff0000', '#00ff00'],+ numberColor: '#0000ff',+ stringColor: '#ff00ff',+ plainTextColor: '#111111',+ },+ [+ 'SUM(',+ { token: 'A1', nodeType: sequenceNodeType.REFERENCE, startIndex: 4, endIndex: 5 },+ ',',+ { token: '42', nodeType: sequenceNodeType.NUMBER, startIndex: 7, endIndex: 8 },+ { token: '"ok"', nodeType: sequenceNodeType.STRING, startIndex: 9, endIndex: 12 },+ { token: '{1,2}', nodeType: sequenceNodeType.ARRAY, startIndex: 13, endIndex: 17 },+ { token: 'SalesTotal', nodeType: sequenceNodeType.DEFINED_NAME, startIndex: 18, endIndex: 27 },+ { token: '+', nodeType: sequenceNodeType.NORMAL, startIndex: 28, endIndex: 28 },+ { token: 'A1', nodeType: sequenceNodeType.REFERENCE, startIndex: 29, endIndex: 30 },+ ]+ );++ expect(result.refSelections).toEqual([+ expect.objectContaining({ token: 'A1', themeColor: '#ff0000', refIndex: 1, index: 0 }),+ expect.objectContaining({ token: 'A1', themeColor: '#ff0000', refIndex: 8, index: 1 }),+ ]);+ expect(result.textRuns.map((run) => run.ts?.cl?.rgb)).toEqual([+ '#111111',+ '#ff0000',+ '#111111',+ '#0000ff',+ '#ff00ff',+ '#ff00ff',+ '#111111',+ '#111111',+ '#ff0000',+ ]);+ });++ it('calculates visible formula reference selections and activates the reference under the editor cursor', () => {+ const currentSelections = [{ primary: { actualRow: 9, actualColumn: 9 } }];+ const refSelectionsService = {+ getCurrentSelections: vi.fn(() => currentSelections),+ setSelections: vi.fn(),+ };+ const refSelectionsRenderService = {+ setActiveSelectionIndex: vi.fn(),+ resetActiveSelectionIndex: vi.fn(),+ };+ const workbook = {+ getUnitId: vi.fn(() => 'unit1'),+ getActiveSheet: vi.fn(() => ({+ getSheetId: () => 'sheet1',+ getName: () => 'Sheet1',+ getRowCount: () => 100,+ getColumnCount: () => 50,+ })),+ getSheetBySheetName: vi.fn((name: string) => name === 'Sheet2'+ ? { getSheetId: () => 'sheet2' }+ : { getSheetId: () => 'sheet1' }),+ };+ const univerInstanceService = {+ getUnit: vi.fn(() => workbook),+ };+ const result = calcHighlightRanges({+ unitId: 'unit1',+ subUnitId: 'sheet1',+ currentWorkbook: workbook as any,+ refSelections: [+ { token: 'A1', themeColor: '#ff0000', refIndex: 0, startIndex: 0, endIndex: 1, index: 0 },+ { token: 'Sheet2!A1', themeColor: '#00ff00', refIndex: 1, startIndex: 3, endIndex: 11, index: 1 },+ { token: 'Book2#Sheet1!A1', themeColor: '#0000ff', refIndex: 2, startIndex: 12, endIndex: 26, index: 2 },+ ],+ editor: {+ getSelectionRanges: vi.fn(() => [{ startOffset: 3 }]),+ } as any,+ refSelectionsService: refSelectionsService as any,+ refSelectionsRenderService: refSelectionsRenderService as any,+ sheetSkeletonManagerService: {+ getSkeleton: vi.fn(() => ({})),+ } as any,+ themeService: { getColorFromTheme: vi.fn((key: string) => key === 'white' ? '#fff' : key) } as any,+ univerInstanceService: univerInstanceService as any,+ });++ expect(result).toHaveLength(2);+ expect(result?.[0].range).toMatchObject({ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0, unitId: 'unit1', sheetId: 'sheet1' });+ expect(result?.[0].primary).toBe(currentSelections[0].primary);+ expect(result?.[0].style).toMatchObject({ stroke: '#ff0000', widgetStroke: '#fff' });+ expect(refSelectionsRenderService.setActiveSelectionIndex).toHaveBeenCalledWith(0);+ });++ it('clears highlight selections when the workbook or active sheet is unavailable', () => {+ const refSelectionsService = {+ getCurrentSelections: vi.fn(() => []),+ setSelections: vi.fn(),+ };++ expect(calcHighlightRanges({+ unitId: 'missing',+ subUnitId: 'sheet1',+ currentWorkbook: { getUnitId: () => 'unit1' } as any,+ refSelections: [{ token: 'A1', themeColor: '#ff0000', refIndex: 0, startIndex: 0, endIndex: 1, index: 0 }],+ editor: undefined,+ refSelectionsService: refSelectionsService as any,+ refSelectionsRenderService: undefined,+ sheetSkeletonManagerService: undefined,+ themeService: { getColorFromTheme: vi.fn(() => '#fff') } as any,+ univerInstanceService: { getUnit: vi.fn(() => null) } as any,+ })).toBeUndefined();+ expect(refSelectionsService.setSelections).toHaveBeenCalledWith([]);+ });+});diff --git a/packages/sheets-formula-ui/src/views/formula-editor/utils/__tests__/get-formula-text.spec.ts b/packages/sheets-formula-ui/src/views/formula-editor/utils/__tests__/get-formula-text.spec.tsnew file mode 100644index 0000000000..3fcf2c453f--- /dev/null+++ b/packages/sheets-formula-ui/src/views/formula-editor/utils/__tests__/get-formula-text.spec.ts@@ -0,0 +1,28 @@+/**+ * Copyright 2023-present DreamNum Co., Ltd.+ *+ * 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.+ */++import { describe, expect, it } from 'vitest';+import { getFormulaText } from '../get-formula-text';++describe('getFormulaText', () => {+ it('removes the leading equals sign before showing formula editor content', () => {+ expect(getFormulaText('=SUM(A1:B2)')).toBe('SUM(A1:B2)');+ });++ it('keeps non-formula cell text out of the formula editor content', () => {+ expect(getFormulaText('SUM(A1:B2)')).toBe('');+ });+});diff --git a/packages/sheets-formula-ui/src/views/range-selector/__tests__/RangeSelectorDialog.spec.tsx b/packages/sheets-formula-ui/src/views/range-selector/__tests__/RangeSelectorDialog.spec.tsxindex 38a382d1e3..e25cf74e94 100644--- a/packages/sheets-formula-ui/src/views/range-selector/__tests__/RangeSelectorDialog.spec.tsx+++ b/packages/sheets-formula-ui/src/views/range-selector/__tests__/RangeSelectorDialog.spec.tsx@@ -371,6 +371,43 @@ describe('RangeSelectorDialog', () => {expect(RangeDialogState.closed).toBe(0);});+ it('does not append a duplicate range when the sheet selection matches a typed range', async () => {+ const injector = createRangeDialogTestBed();+ renderRangeDialog(root, injector);++ const firstInput = document.body.querySelector('input') as HTMLInputElement;+ expect(firstInput).toBeDefined();++ await act(async () => {+ writeInput(firstInput, 'A1:B2');+ await Promise.resolve();+ });++ await emitSelection(injector, {+ startRow: 0,+ endRow: 1,+ startColumn: 0,+ endColumn: 1,+ rangeType: RANGE_TYPE.NORMAL,+ });++ const inputs = Array.from(document.body.querySelectorAll('input')) as HTMLInputElement[];+ expect(inputs.map((input) => input.value)).toEqual(['A1:B2']);++ await clickButton('Confirm');++ expect(RangeDialogState.confirmed).toEqual([[+ expect.objectContaining({+ range: expect.objectContaining({+ startRow: 0,+ endRow: 1,+ startColumn: 0,+ endColumn: 1,+ }),+ }),+ ]]);+ });+it('confirms only the first ranges from a multi-range sheet selection when capped', async () => {const injector = createRangeDialogTestBed();act(() => {diff --git a/packages/sheets-formula-ui/src/views/range-selector/index.tsx b/packages/sheets-formula-ui/src/views/range-selector/index.tsxindex 21e131d8d1..61096b51e0 100644--- a/packages/sheets-formula-ui/src/views/range-selector/index.tsx+++ b/packages/sheets-formula-ui/src/views/range-selector/index.tsx@@ -29,8 +29,8 @@ import { useEffect, useRef, useState } from 'react';import { useStateRef } from '../formula-editor/hooks/use-state-ref';import { useRangesHighlight } from './hooks/use-ranges-highlight';import { useRangeSelectorSelectionChange } from './hooks/use-selection-change';-import { verifyRange } from './util';import { rangePreProcess } from './utils/range-pre-process';+import { verifyRange } from './utils/verify-range';export interface IRangeSelectorInstance {editor: Nullable<Editor>;diff --git a/packages/sheets-formula-ui/src/views/range-selector/util.ts b/packages/sheets-formula-ui/src/views/range-selector/util.tsdeleted file mode 100644index d8961bea0a..0000000000--- a/packages/sheets-formula-ui/src/views/range-selector/util.ts+++ /dev/null@@ -1,38 +0,0 @@-/**- * Copyright 2023-present DreamNum Co., Ltd.- *- * 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.- */--import type { ISequenceNode } from '@univerjs/engine-formula';-import { matchToken, sequenceNodeType } from '@univerjs/engine-formula';--/**- * @param {((string | ISequenceNode)[])} sequenceNodes- * @return {*}- */-export const verifyRange = (sequenceNodes: (string | ISequenceNode)[]) => {- const isFail = sequenceNodes.some((item) => {- if (typeof item === 'string') {- if (item !== matchToken.COMMA) {- return true;- }- } else {- if (item.nodeType !== sequenceNodeType.REFERENCE) {- return true;- }- }- return false;- });- return !isFail;-};diff --git a/packages/sheets-formula-ui/src/views/range-selector/utils/__tests__/range-utils.spec.ts b/packages/sheets-formula-ui/src/views/range-selector/utils/__tests__/range-utils.spec.tsindex 3605feadec..296ccd69b3 100644--- a/packages/sheets-formula-ui/src/views/range-selector/utils/__tests__/range-utils.spec.ts+++ b/packages/sheets-formula-ui/src/views/range-selector/utils/__tests__/range-utils.spec.ts@@ -18,9 +18,11 @@ import { RANGE_TYPE } from '@univerjs/core';import { matchToken, sequenceNodeType } from '@univerjs/engine-formula';import { describe, expect, it } from 'vitest';import { filterReferenceNode, isComma, isReference } from '../filter-reference-node';+import { findIndexFromSequenceNodes, findRefSequenceIndex } from '../find-index-from-sequence-nodes';+import { getOffsetFromSequenceNodes } from '../get-offset-from-sequence-nodes';import { rangePreProcess } from '../range-pre-process';import { sequenceNodeToText } from '../sequence-node-to-text';-import { unitRangesToText } from '../unit-ranges-to-text';+import { getSheetIdByName, getSheetNameById, unitRangesToText } from '../unit-ranges-to-text';import { verifyRange } from '../verify-range';const referenceNode = { nodeType: sequenceNodeType.REFERENCE, token: 'A1' };@@ -44,6 +46,12 @@ describe('range selector utils', () => {expect(verifyRange([referenceNode as never, ';'])).toBe(false);});+ it('uses the range selector guard to reject typed text that is not a range list', () => {+ expect(verifyRange([referenceNode as never, matchToken.COMMA, referenceNode as never])).toBe(true);+ expect(verifyRange([referenceNode as never, '+', referenceNode as never])).toBe(false);+ expect(verifyRange([referenceNode as never, functionNode as never])).toBe(false);+ });+it('rebuilds typed range text with separators when editing multiple references', () => {expect(sequenceNodeToText([{ nodeType: sequenceNodeType.REFERENCE, token: 'A1:B2' } as never,@@ -52,6 +60,21 @@ describe('range selector utils', () => {])).toBe("A1:B2,'Data Sheet'!D3");});+ it('maps editor cursor offsets back to the parsed range token and reference ordinal', () => {+ const nodes = [+ { nodeType: sequenceNodeType.REFERENCE, token: 'A1:B2' },+ matchToken.COMMA,+ { nodeType: sequenceNodeType.REFERENCE, token: "'Data Sheet'!D3" },+ ] as never[];++ expect(getOffsetFromSequenceNodes(nodes)).toBe("A1:B2,'Data Sheet'!D3".length);+ expect(findIndexFromSequenceNodes(nodes, 5)).toBe(0);+ expect(findIndexFromSequenceNodes(nodes, 8, false)).toBe(2);+ expect(findIndexFromSequenceNodes(nodes, 3)).toBe(-1);+ expect(findRefSequenceIndex(nodes, 2)).toBe(1);+ expect(findRefSequenceIndex(nodes, 1)).toBe(-1);+ });+it('serializes selected ranges with sheet and workbook qualifiers only when the formula needs them', () => {const ranges = [{@@ -71,6 +94,21 @@ describe('range selector utils', () => {expect(unitRangesToText(ranges, true, 'Sheet1', true)).toEqual(["'[book-1]Sheet1'!A1:B2", "'[book-1]Data Sheet'!D3"]);});+ it('resolves sheet ids and names through the current workbook when serializing references', () => {+ const workbook = {+ getSheetBySheetName: (name: string) => name === 'Data Sheet' ? { getSheetId: () => 'sheet-data' } : undefined,+ getSheetBySheetId: (sheetId: string) => sheetId === 'sheet-data' ? { getName: () => 'Data Sheet' } : undefined,+ };+ const univerInstanceService = {+ getUnit: (unitId: string) => unitId === 'book-1' ? workbook : undefined,+ };++ expect(getSheetIdByName(univerInstanceService as never, 'book-1', 'Data Sheet')).toBe('sheet-data');+ expect(getSheetNameById(univerInstanceService as never, 'book-1', 'sheet-data')).toBe('Data Sheet');+ expect(getSheetIdByName(univerInstanceService as never, 'book-1', 'Missing')).toBe('');+ expect(getSheetNameById(univerInstanceService as never, 'missing-book', 'sheet-data')).toBe('');+ });+it('normalizes a reverse-dragged range before the selector confirms it', () => {expect(rangePreProcess({startRow: 8,diff --git a/packages/sheets-numfmt-ui/src/views/__tests__/SheetNumfmtViews.spec.tsx b/packages/sheets-numfmt-ui/src/views/__tests__/SheetNumfmtViews.spec.tsxindex c3f394f333..3913586fb9 100644--- a/packages/sheets-numfmt-ui/src/views/__tests__/SheetNumfmtViews.spec.tsx+++ b/packages/sheets-numfmt-ui/src/views/__tests__/SheetNumfmtViews.spec.tsx@@ -1205,6 +1205,60 @@ describe('SheetNumfmtPanel', () => {});});+ it('uses the most recent saved currency habit when an existing number format is switched to Currency', async () => {+ currentTestBed = createNumfmtViewTestBed();+ const topHabit = currencySymbols[17];+ const previousHabit = currencySymbols[4];+ await currentTestBed.localStorageService.setItem(CURRENCY_HABIT_KEY, [topHabit, previousHabit]);+ container = document.createElement('div');+ document.body.appendChild(container);+ root = createRoot(container);+ const commandResults: Array<Promise<unknown>> = [];+ const events: Array<{ type: 'change' | 'cancel' | 'confirm'; value: string }> = [];++ await act(async () => {+ root!.render(+ <RediContext.Provider value={{ injector: currentTestBed!.injector }}>+ <SheetNumfmtPanel+ value={{+ defaultValue: 1234.5,+ defaultPattern: '#,##0.00_);(#,##0.00)',+ row: 0,+ col: 0,+ }}+ onChange={(event) => {+ events.push(event);+ if (event.type === 'confirm') {+ commandResults.push(currentTestBed!.commandService.executeCommand(SetNumfmtCommand.id, {+ values: [{+ row: 0,+ col: 0,+ pattern: event.value,+ type: getPatternType(event.value),+ }],+ }) as Promise<unknown>);+ }+ }}+ />+ </RediContext.Provider>+ );+ await Promise.resolve();+ await Promise.resolve();+ await Promise.resolve();+ });++ await selectPanelType('Currency');+ await confirmPanel();+ const results = await Promise.all(commandResults);+ const confirmedPattern = events.at(-1)?.value ?? '';++ expect(results).toEqual([true]);+ expect(getCurrencyType(confirmedPattern)).toBe(topHabit);+ expect(currentTestBed.numfmtService.getValue(UNIT_ID, SUB_UNIT_ID, 0, 0)).toEqual({+ pattern: `"${topHabit}"#,##0.00_);"${topHabit}"#,##0.00`,+ });+ });+it('uses the most recent saved currency habit when a blank cell is confirmed as Accounting', async () => {currentTestBed = createNumfmtViewTestBed();const topHabit = currencySymbols[18];diff --git a/packages/sheets-table-ui/src/views/components/__tests__/SheetTableComponents.spec.tsx b/packages/sheets-table-ui/src/views/components/__tests__/SheetTableComponents.spec.tsxindex 433f8a630f..443c15861d 100644--- a/packages/sheets-table-ui/src/views/components/__tests__/SheetTableComponents.spec.tsx+++ b/packages/sheets-table-ui/src/views/components/__tests__/SheetTableComponents.spec.tsx@@ -54,6 +54,7 @@ import {SetSheetTableMutation,SheetsTableSortStateEnum,SheetTableInsertColumnAtCommand,+ SheetTableRemoveColumnAtCommand,SheetTableService,TABLE_FILTER_EMPTY_VALUE,TableColumnFilterTypeEnum,@@ -566,6 +567,7 @@ function createTestBed(): ITestBed {AddTableThemeCommand,RemoveTableThemeCommand,SheetTableInsertColumnAtCommand,+ SheetTableRemoveColumnAtCommand,].forEach((command) => {commandService.registerCommand(command);});@@ -1214,6 +1216,35 @@ describe('sheet table view components', () => {expect(componentController.closeCount).toBe(1);});+ it('deletes the current table column from the filter panel column menu', async () => {+ testBed = createTestBed();+ const unitId = testBed.workbook.getUnitId();+ const componentController = testBed.injector.get(SheetsTableComponentController) as TestComponentController;+ componentController.setCurrentTableFilterInfo({+ unitId,+ subUnitId: 'sheet1',+ tableId: 'table-orders',+ row: 0,+ column: 1,+ });+ const rendered = renderWithRediContext(testBed, <SheetTableFilterPanel />);+ root = rendered.root;+ container = rendered.container;++ clickButtonByText(container, 'Delete table column');+ await flushCommands();++ const table = testBed.injector.get(TableManager).getTable(unitId, 'table-orders')!;+ expect(table.getRange()).toEqual({+ startRow: 0,+ endRow: 3,+ startColumn: 0,+ endColumn: 0,+ });+ expect(table.getTableInfo().columns.map((column) => column.displayName)).toEqual(['Product']);+ expect(componentController.closeCount).toBe(1);+ });+it('sorts the table body descending from the filter panel sort action', async () => {testBed = createTestBed();const componentController = testBed.injector.get(SheetsTableComponentController) as TestComponentController;diff --git a/packages/sheets-thread-comment-ui/src/views/__tests__/SheetsThreadCommentPanel.spec.tsx b/packages/sheets-thread-comment-ui/src/views/__tests__/SheetsThreadCommentPanel.spec.tsxindex e1ad77ceb9..7b831501d4 100644--- a/packages/sheets-thread-comment-ui/src/views/__tests__/SheetsThreadCommentPanel.spec.tsx+++ b/packages/sheets-thread-comment-ui/src/views/__tests__/SheetsThreadCommentPanel.spec.tsx@@ -871,6 +871,50 @@ describe('SheetsThreadCommentPanel', () => {expect(TestState.shapes).toHaveLength(0);});+ it('shows only resolved threads in the resolved filter and clears the active comment when one is clicked', async () => {+ const testBed = createTestBed();+ univer = testBed.univer;+ testBed.threadCommentModel.addComment(unitId, sheet1, createComment('open-thread', sheet1, 'B2', 'Open thread'));+ testBed.threadCommentModel.addComment(unitId, sheet1, createComment('resolved-thread', sheet1, 'C3', 'Resolved thread', true));+ testBed.panelService.setActiveComment({+ unitId,+ subUnitId: sheet1,+ commentId: 'open-thread',+ trigger: 'cell',+ });++ const rendered = renderPanel(testBed.injector);+ root = rendered.root;+ container = rendered.container;++ await act(async () => {+ container!.querySelectorAll('[data-u-comp="select"]')[1].dispatchEvent(new PointerEvent('pointerdown', { bubbles: true, button: 0 }));+ await Promise.resolve();+ });++ const resolvedOption = Array.from(document.querySelectorAll('[data-slot="dropdown-menu-radio-item"]'))+ .find((button) => button.textContent === 'Resolved');++ expect(resolvedOption).toBeDefined();++ await act(async () => {+ resolvedOption!.dispatchEvent(new MouseEvent('click', { bubbles: true }));+ await Promise.resolve();+ });++ expect(container.textContent).toContain('Resolved thread');+ expect(container.textContent).not.toContain('Open thread');++ const resolvedThread = container.querySelector(`#PANEL-${unitId}-${sheet1}-resolved-thread`);+ expect(resolvedThread).toBeInstanceOf(HTMLElement);++ act(() => {+ resolvedThread!.dispatchEvent(new MouseEvent('click', { bubbles: true }));+ });++ expect(testBed.panelService.activeCommentId).toBeUndefined();+ });+it('opens the add-comment popup at the active sheet cell from the empty panel action', () => {const testBed = createTestBed();univer = testBed.univer;