Skip to content

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.

test: add unit tests (#7119)

白熱d88d528d884a
diff --git a/codecov.yml b/codecov.yml
index fa5534cd57..a147d75ce3 100644
--- a/codecov.yml
+++ b/codecov.yml
@@ -3,7 +3,7 @@ coverage:
project:
default:
# basic
- target: 78%
+ target: 80%
threshold: 0
base: auto
# advanced settings
diff --git a/common/mockdata/scripts/generate-locales.mts b/common/mockdata/scripts/generate-locales.mts
index 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.ts
deleted file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
index 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): s
continue;
}
- 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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.injector
diff --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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.tsx
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.tsx
index 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.tsx
index 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.ts
deleted file mode 100644
index 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.ts
index 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.tsx
index 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.tsx
index 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.tsx
index 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;