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.

feat(sheets-hyper-link): improve hyperlink facade APIs (#6950)

wpxp123456c0f2cc00642e
diff --git a/packages/sheets-hyper-link/src/facade/__tests__/f-range.spec.ts b/packages/sheets-hyper-link/src/facade/__tests__/f-range.spec.ts
new file mode 100644
index 0000000000..08c44045ad
--- /dev/null
+++ b/packages/sheets-hyper-link/src/facade/__tests__/f-range.spec.ts
@@ -0,0 +1,114 @@
+/**
+ * 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 { IWorkbookData, UnitModel } from '@univerjs/core';
+import type { FUniver } from '@univerjs/core/facade';
+import { ILogService, IUniverInstanceService, LocaleType, LogLevel, Univer, UniverInstanceType } from '@univerjs/core';
+import { FUniver as FUniverFactory } from '@univerjs/core/facade';
+import { DocSelectionManagerService } from '@univerjs/docs';
+import { UniverSheetsHyperLinkPlugin } from '@univerjs/sheets-hyper-link';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import '@univerjs/sheets/facade';
+import '../f-range';
+import '../f-workbook';
+import '../f-worksheet';
+
+function createWorkbookData(): IWorkbookData {
+ return {
+ id: 'test',
+ appVersion: '3.0.0-alpha',
+ locale: LocaleType.EN_US,
+ name: 'Workbook',
+ sheetOrder: ['sheet1'],
+ styles: {},
+ sheets: {
+ sheet1: {
+ id: 'sheet1',
+ name: 'Sheet1',
+ cellData: {},
+ rowCount: 20,
+ columnCount: 20,
+ },
+ },
+ };
+}
+
+describe('FRangeSheetsHyperlinkMixin', () => {
+ let univer: Univer;
+ let univerAPI: FUniver;
+
+ beforeEach(() => {
+ univer = new Univer();
+ univer.registerPlugin(UniverSheetsHyperLinkPlugin);
+
+ const injector = univer.__getInjector();
+ injector.add([DocSelectionManagerService]);
+
+ const workbook = univer.createUnit<IWorkbookData, UnitModel<IWorkbookData>>(UniverInstanceType.UNIVER_SHEET, createWorkbookData());
+
+ injector.get(IUniverInstanceService).focusUnit(workbook.getUnitId());
+ injector.get(ILogService).setLogLevel(LogLevel.SILENT);
+ univerAPI = FUniverFactory.newAPI(injector);
+ });
+
+ afterEach(() => {
+ univer.dispose();
+ });
+
+ it('should set, read, update and cancel hyperlinks through the real facade API', async () => {
+ const worksheet = univerAPI.getActiveWorkbook()!.getActiveSheet();
+ const a1 = worksheet.getRange('A1');
+ const b2 = worksheet.getRange('B2');
+
+ await expect(a1.setHyperLink('https://univer.ai', 'Univer')).resolves.toBe(true);
+ await expect(b2.setHyperLink('https://docs.univer.ai', 'Docs')).resolves.toBe(true);
+
+ expect(worksheet.getRange('A1:B2').getHyperLinks()).toEqual([
+ {
+ id: expect.any(String),
+ row: 0,
+ column: 0,
+ url: 'https://univer.ai',
+ label: 'Univer',
+ },
+ {
+ id: expect.any(String),
+ row: 1,
+ column: 1,
+ url: 'https://docs.univer.ai',
+ label: 'Docs',
+ },
+ ]);
+
+ await expect(a1.updateHyperLink('https://univer.ai/docs', 'Univer Docs')).resolves.toBe(true);
+ expect(a1.getHyperLinks()).toEqual([{
+ id: expect.any(String),
+ row: 0,
+ column: 0,
+ url: 'https://univer.ai/docs',
+ label: 'Univer Docs',
+ }]);
+
+ expect(worksheet.getRange('A1:B2').cancelHyperLink()).toBe(true);
+ expect(worksheet.getRange('A1:B2').getHyperLinks()).toEqual([]);
+ });
+
+ it('should create hyperlink urls from sheet ranges', () => {
+ const worksheet = univerAPI.getActiveWorkbook()!.getActiveSheet();
+
+ expect(worksheet.getRange('A1:B2').getUrl()).toBe('#gid=sheet1&range=A1:B2');
+ });
+});
diff --git a/packages/sheets-hyper-link/src/facade/f-range.ts b/packages/sheets-hyper-link/src/facade/f-range.ts
index a99238c225..bcbffe8010 100644
--- a/packages/sheets-hyper-link/src/facade/f-range.ts
+++ b/packages/sheets-hyper-link/src/facade/f-range.ts
@@ -21,8 +21,8 @@ import { FRange } from '@univerjs/sheets/facade';
export interface ICellHyperLink {
id: string;
- startIndex: number;
- endIndex: number;
+ row: number;
+ column: number;
url: string;
label: string;
}
@@ -32,7 +32,13 @@ export interface ICellHyperLink {
*/
export interface IFRangeSheetsHyperlinkMixin {
/**
- * @deprecated use `range.setRichTextValueForCell(univerAPI.newRichText().insertLink(label, url))` instead
+ * Set a hyperlink for this range top left cell.
+ * The hyperlink can be a URL, a range link, or a sheet link.
+ * When the hyperlink is a range link or a sheet link, the url should be the url of the target range or sheet.
+ * @param {string} url - The hyperlink url, can be a URL, a range link, or a sheet link.
+ * @param {string} [label] - The display text of the hyperlink. If not provided, the url will be used as the display text.
+ * @return {Promise<boolean>} A promise that resolves to true if the hyperlink is set successfully, otherwise false.
+ *
* @example
* ```ts
* const fWorkbook = univerAPI.getActiveWorkbook();
@@ -40,78 +46,97 @@ export interface IFRangeSheetsHyperlinkMixin {
*
* // Create a hyperlink to Univer on cell A1
* const fRange = fWorksheet.getRange('A1');
- * const richText = univerAPI.newRichText().insertLink('Univer', 'https://univer.ai/');
- * fRange.setRichTextValueForCell(richText);
+ * await fRange.setHyperLink('https://univer.ai/', 'Univer');
+ *
+ * // Create a hyperlink to active sheet range B2:D4 on cell A2
+ * const fRange2 = fWorksheet.getRange('A2');
+ * const rangeUrl = fWorksheet.getRange('B2:D4').getUrl();
+ * await fRange2.setHyperLink(rangeUrl, 'Link to B2:D4');
+ *
+ * // Create a hyperlink to another sheet range on cell A3
+ * const anotherSheet = fWorkbook.getSheetByName('Another Sheet');
+ * if (anotherSheet) {
+ * const anotherSheetUrl = anotherSheet.getUrl();
+ * const fRange3 = fWorksheet.getRange('A3');
+ * await fRange3.setHyperLink(anotherSheetUrl, 'Link to Another Sheet');
+ * }
+ *
+ * // Create a hyperlink to a defined name on cell A4
+ * const fRange4 = fWorksheet.getRange('A4');
+ * const definedNameHyperlinkUrl = fWorkbook.getUrlOfDefineName('MyDefinedName');
+ * await fRange4.setHyperLink(definedNameHyperlinkUrl, 'Link to MyDefinedName');
* ```
*/
setHyperLink(url: string, label?: string): Promise<boolean>;
/**
- * @deprecated use `range.setRichTextValueForCell(range.getValue(true).getLinks())` instead
+ * Get all hyperlinks in this range.
+ * @return {ICellHyperLink[]} An array of hyperlinks in this range.
+ *
* @example
* ```ts
* const fWorkbook = univerAPI.getActiveWorkbook();
* const fWorksheet = fWorkbook.getActiveSheet();
- *
- * // Create a hyperlink to Univer on cell A1
- * const fRange = fWorksheet.getRange('A1');
- * const richText = univerAPI.newRichText().insertLink('Univer', 'https://univer.ai/');
- * fRange.setRichTextValueForCell(richText);
- *
- * // Get hyperlinks from cell A1
- * console.log(fRange.getValue(true).getLinks());
+ * console.log(fWorksheet.getRange('A1:T100').getHyperLinks());
* ```
*/
getHyperLinks(): ICellHyperLink[];
/**
- * @deprecated use `range.setRichTextValueForCell(range.getValue(true).copy().updateLink(id, url))` instead
+ * Update the hyperlink of this range top left cell.
+ * @param {string} url - The new hyperlink url, can be a URL, a range link, or a sheet link.
+ * @param {string} [label] - The new display text of the hyperlink. If not provided, the url will be used as the display text.
+ *
* @example
* ```ts
* const fWorkbook = univerAPI.getActiveWorkbook();
* const fWorksheet = fWorkbook.getActiveSheet();
+ *
+ * // Create a hyperlink to Univer on cell A1
* const fRange = fWorksheet.getRange('A1');
- * const richText = univerAPI.newRichText().insertLink('Univer', 'https://univer.ai/');
- * fRange.setRichTextValueForCell(richText);
+ * await fRange.setHyperLink('https://univer.ai/', 'Univer');
*
* // Update hyperlink after 3 seconds
- * setTimeout(() => {
- * const cellValue = fRange.getValue(true);
- * const hyperlinks = cellValue.getLinks();
- * const id = hyperlinks[0].rangeId;
- * const newUrl = 'https://insight.univer.ai/';
- * const newRichText = cellValue.copy().updateLink(id, newUrl);
- * fRange.setRichTextValueForCell(newRichText);
- * }, 3000);
+ * await new Promise((resolve) => setTimeout(resolve, 3000));
+ *
+ * const rangeUrl = fWorksheet.getRange('B2:D4').getUrl();
+ * await fRange.updateHyperLink(rangeUrl, 'Link to B2:D4');
* ```
*/
- updateHyperLink(id: string, url: string, label?: string): Promise<boolean>;
+ updateHyperLink(url: string, label?: string): Promise<boolean>;
/**
- * @deprecated use `range.setRichTextValueForCell(range.getValue(true).copy().cancelLink(id))` instead
+ * Cancel all hyperlinks in this range. If a hyperlink is provided, only cancel the specified hyperlink.
+ * @param {ICellHyperLink} [hyperlink] - The hyperlink to be cancelled. If not provided, all hyperlinks in this range will be cancelled.
+ * @return {boolean} True if the hyperlink(s) is cancelled successfully, otherwise false.
+ *
* @example
* ```ts
* const fWorkbook = univerAPI.getActiveWorkbook();
* const fWorksheet = fWorkbook.getActiveSheet();
+ *
+ * // Cancel the hyperlink in cell A1
* const fRange = fWorksheet.getRange('A1');
- * const richText = univerAPI.newRichText().insertLink('Univer', 'https://univer.ai/');
- * fRange.setRichTextValueForCell(richText);
+ * fRange.cancelHyperLink();
*
- * // Cancel hyperlink after 3 seconds
- * setTimeout(() => {
- * const cellValue = fRange.getValue(true);
- * const hyperlinks = cellValue.getLinks();
- * const id = hyperlinks[0].rangeId;
- * const newRichText = cellValue.copy().cancelLink(id);
- * fRange.setRichTextValueForCell(newRichText);
- * }, 3000);
+ * // Cancel all hyperlinks in range A2:B4
+ * const fRange2 = fWorksheet.getRange('A2:B4');
+ * fRange2.cancelHyperLink();
+ *
+ * // Cancel a specific hyperlink in range A1:T100
+ * const fRange3 = fWorksheet.getRange('A1:T100');
+ * const hyperlinks = fRange3.getHyperLinks();
+ * if (hyperlinks.length > 1) {
+ * fRange3.cancelHyperLink(hyperlinks[1]);
+ * }
* ```
*/
- cancelHyperLink(id: string): boolean;
+ cancelHyperLink(hyperlink?: ICellHyperLink): boolean;
/**
* Create a hyperlink url to this range
- * @returns {string} The url of this range
+ * @returns {string} The hyperlink url of this range
+ *
* @example
* ```ts
* const fWorkbook = univerAPI.getActiveWorkbook();
@@ -125,75 +150,107 @@ export interface IFRangeSheetsHyperlinkMixin {
}
export class FRangeSheetsHyperlinkMixin extends FRange implements IFRangeSheetsHyperlinkMixin {
- // #region hyperlink
-
override setHyperLink(url: string, label?: string): Promise<boolean> {
- const params: IAddHyperLinkCommandParams = {
+ return this._commandService.executeCommand<IAddHyperLinkCommandParams>(AddHyperLinkCommand.id, {
unitId: this.getUnitId(),
subUnitId: this._worksheet.getSheetId(),
link: {
+ id: generateRandomId(),
row: this._range.startRow,
column: this._range.startColumn,
payload: url,
display: label,
- id: generateRandomId(),
},
- };
-
- return this._commandService.executeCommand(AddHyperLinkCommand.id, params);
+ });
}
override getHyperLinks(): ICellHyperLink[] {
- const cellValue = this._worksheet.getCellRaw(this._range.startRow, this._range.startColumn);
- if (!cellValue?.p) {
- return [];
- }
+ const hyperlinks: ICellHyperLink[] = [];
+
+ this.forEach((row, column, cell) => {
+ if (!cell.p) {
+ return;
+ }
+
+ const ranges = cell.p.body?.customRanges?.filter((range) => range.rangeType === CustomRangeType.HYPERLINK) ?? [];
+
+ if (ranges.length > 0) {
+ const dataStream = cell.p?.body?.dataStream;
+ const { rangeId, properties, startIndex, endIndex } = ranges[0];
+ const url = properties?.url ?? '';
+ const label = dataStream?.slice(startIndex, endIndex + 1).replaceAll(DataStreamTreeTokenType.CUSTOM_RANGE_START, '').replaceAll(DataStreamTreeTokenType.CUSTOM_RANGE_END, '') ?? '';
- return cellValue.p.body?.customRanges
- ?.filter((range) => range.rangeType === CustomRangeType.HYPERLINK)
- .map((range) => ({
- id: `${range.rangeId}`,
- startIndex: range.startIndex,
- endIndex: range.endIndex,
- url: range.properties?.url ?? '',
- label: cellValue.p?.body?.dataStream.slice(range.startIndex, range.endIndex + 1).replaceAll(DataStreamTreeTokenType.CUSTOM_RANGE_START, '').replaceAll(DataStreamTreeTokenType.CUSTOM_RANGE_END, '') ?? '',
- })) ?? [];
+ hyperlinks.push({
+ id: `${rangeId}`,
+ row,
+ column,
+ url,
+ label,
+ });
+ }
+ });
+
+ return hyperlinks;
}
- override updateHyperLink(id: string, url: string, label?: string): Promise<boolean> {
- const params: IUpdateHyperLinkCommandParams = {
+ override updateHyperLink(url: string, label?: string): Promise<boolean> {
+ const hyperlink = this.getHyperLinks().find((link) => link.row === this._range.startRow && link.column === this._range.startColumn);
+
+ if (!hyperlink) {
+ return Promise.reject(new Error('No hyperlink found in the top left cell of the range'));
+ }
+
+ const { id, row, column } = hyperlink;
+
+ return this._commandService.executeCommand<IUpdateHyperLinkCommandParams>(UpdateHyperLinkCommand.id, {
unitId: this.getUnitId(),
subUnitId: this._worksheet.getSheetId(),
- row: this._range.startRow,
- column: this._range.startColumn,
id,
+ row,
+ column,
payload: {
payload: url,
display: label,
},
- };
-
- return this._commandService.executeCommand(UpdateHyperLinkCommand.id, params);
+ });
}
- override cancelHyperLink(id: string): boolean {
- const params: ICancelHyperLinkCommandParams = {
- unitId: this.getUnitId(),
- subUnitId: this._worksheet.getSheetId(),
- row: this._range.startRow,
- column: this._range.startColumn,
- id,
- };
+ override cancelHyperLink(hyperlink?: ICellHyperLink): boolean {
+ if (hyperlink) {
+ const { id, row, column } = hyperlink;
+
+ return this._commandService.syncExecuteCommand<ICancelHyperLinkCommandParams>(CancelHyperLinkCommand.id, {
+ unitId: this.getUnitId(),
+ subUnitId: this._worksheet.getSheetId(),
+ id,
+ row,
+ column,
+ });
+ } else {
+ const hyperlinks = this.getHyperLinks();
- return this._commandService.syncExecuteCommand(CancelHyperLinkCommand.id, params);
+ if (hyperlinks.length === 0) {
+ return true;
+ }
+
+ return hyperlinks.every((link) => {
+ const { id, row, column } = link;
+
+ return this._commandService.syncExecuteCommand<ICancelHyperLinkCommandParams>(CancelHyperLinkCommand.id, {
+ unitId: this.getUnitId(),
+ subUnitId: this._worksheet.getSheetId(),
+ id,
+ row,
+ column,
+ });
+ });
+ }
}
override getUrl(): string {
const parserService = this._injector.get(SheetsHyperLinkParserService);
- return parserService.buildHyperLink(this.getUnitId(), this.getSheetId(), this.getRange());
+ return parserService.buildHyperLink(this.getRange(), this.getSheetId());
}
-
- // #endregion
}
FRange.extend(FRangeSheetsHyperlinkMixin);
diff --git a/packages/sheets-hyper-link/src/facade/f-workbook.ts b/packages/sheets-hyper-link/src/facade/f-workbook.ts
index 7684f99c68..d4ba4504ec 100644
--- a/packages/sheets-hyper-link/src/facade/f-workbook.ts
+++ b/packages/sheets-hyper-link/src/facade/f-workbook.ts
@@ -15,34 +15,54 @@
*/
import type { ISheetHyperLinkInfo } from '@univerjs/sheets-hyper-link';
-import type { FRange } from '@univerjs/sheets/facade';
-import { Inject } from '@univerjs/core';
+import { IDefinedNamesService, operatorToken } from '@univerjs/engine-formula';
import { SheetsHyperLinkParserService } from '@univerjs/sheets-hyper-link';
import { FWorkbook } from '@univerjs/sheets/facade';
-/**
- * @hideconstructor
- */
-export class SheetHyperLinkBuilder {
- constructor(
- private _workbook: FWorkbook,
- @Inject(SheetsHyperLinkParserService) private readonly _parserService: SheetsHyperLinkParserService
- ) {}
-
- getRangeUrl(range: FRange): this {
- this._parserService.buildHyperLink(this._workbook.getId(), range.getSheetId(), range.getRange());
- return this;
- }
-}
-
/**
* @ignore
*/
export interface IFWorkbookHyperlinkMixin {
+ /**
+ * Create a hyperlink url for the defined name.
+ * The defined name must exist in the current workbook and must be a reference to a range, otherwise an error will be thrown.
+ * @param {string} name - The name of the defined name.
+ * @returns {string} The hyperlink url of the defined name.
+ *
+ * @example
+ * ```ts
+ * const fWorkbook = univerAPI.getActiveWorkbook();
+ * const fWorksheet = fWorkbook.getActiveSheet();
+ *
+ * // Create a defined name "TestRange" for the range A1:B10 of the active sheet
+ * const definedNameParam = fWorkbook.newDefinedNameBuilder()
+ * .setName('TestRange')
+ * .setRef('Sheet1!$A$1:$B$10')
+ * .build();
+ * fWorkbook.insertDefinedNameBuilder(definedNameParam);
+ *
+ * // Create a hyperlink to the defined name "TestRange" on cell C1
+ * const url = fWorkbook.getUrlOfDefineName('TestRange');
+ * console.log(url);
+ * const fRange = fWorksheet.getRange('C1');
+ * fRange.setHyperLink(url, 'Link to TestRange');
+ *
+ * // Create a hyperlink to the exiting defined name on cell C2
+ * const definedNames = fWorkbook.getDefinedNames();
+ * console.log(definedNames);
+ * const exitsDefinedNameUrl = fWorkbook.getUrlOfDefineName(definedNames[0].getName());
+ * console.log(exitsDefinedNameUrl);
+ * const fRange2 = fWorksheet.getRange('C2');
+ * fRange2.setHyperLink(exitsDefinedNameUrl, `Link to ${definedNames[0].getName()}`);
+ * ```
+ */
+ getUrlOfDefineName(name: string): string;
+
/**
* Parse the hyperlink string to get the hyperlink info.
* @param {string} hyperlink - The hyperlink string.
* @returns {ISheetHyperLinkInfo} The hyperlink info.
+ *
* @example
* ``` ts
* // Create a hyperlink to the range A1:D10 of the current sheet
@@ -56,18 +76,29 @@ export interface IFWorkbookHyperlinkMixin {
* console.log(hyperlinkInfo);
* ```
*/
- parseSheetHyperlink(this: FWorkbook, hyperlink: string): ISheetHyperLinkInfo;
+ parseSheetHyperlink(hyperlink: string): ISheetHyperLinkInfo;
}
export class FWorkbookHyperlinkMixin extends FWorkbook implements IFWorkbookHyperlinkMixin {
- /**
- * Parse the hyperlink string to get the hyperlink info.
- * @param {string} hyperlink the hyperlink string
- * @returns {ISheetHyperLinkInfo} the hyperlink info
- */
+ override getUrlOfDefineName(name: string): string {
+ const definedNameService = this._injector.get(IDefinedNamesService);
+ const parserService = this._injector.get(SheetsHyperLinkParserService);
+
+ const definedName = definedNameService.getValueByName(this._workbook.getUnitId(), name);
+ if (!definedName) {
+ throw new Error(`Defined name "${name}" does not exist.`);
+ }
+
+ if (definedName.formulaOrRefString.startsWith(operatorToken.EQUALS)) {
+ throw new Error(`Defined name "${name}" is not a reference range, cannot be converted to hyperlink.`);
+ }
+
+ return parserService.buildHyperLink(definedName.id);
+ }
+
override parseSheetHyperlink(hyperlink: string): ISheetHyperLinkInfo {
- const resolverService = this._injector.get(SheetsHyperLinkParserService);
- return resolverService.parseHyperLink(hyperlink);
+ const parserService = this._injector.get(SheetsHyperLinkParserService);
+ return parserService.parseHyperLink(hyperlink);
}
}
diff --git a/packages/sheets-hyper-link/src/facade/f-worksheet.ts b/packages/sheets-hyper-link/src/facade/f-worksheet.ts
index c4fe20cd80..7fffd772be 100644
--- a/packages/sheets-hyper-link/src/facade/f-worksheet.ts
+++ b/packages/sheets-hyper-link/src/facade/f-worksheet.ts
@@ -23,7 +23,7 @@ import { FWorksheet } from '@univerjs/sheets/facade';
export interface IFWorksheetHyperlinkMixin {
/**
* Create a hyperlink url to this sheet
- * @returns {string} The url of this sheet
+ * @returns {string} The hyperlink url of this sheet
* @example
* ```ts
* const fWorkbook = univerAPI.getActiveWorkbook();
@@ -38,7 +38,7 @@ export interface IFWorksheetHyperlinkMixin {
export class FWorksheetHyperlinkMixin extends FWorksheet implements IFWorksheetHyperlinkMixin {
override getUrl(): string {
const parserService = this._injector.get(SheetsHyperLinkParserService);
- return parserService.buildHyperLink(this._workbook.getUnitId(), this._worksheet.getSheetId());
+ return parserService.buildHyperLink(this._worksheet.getSheetId());
}
}
diff --git a/packages/sheets-hyper-link/src/services/__tests__/parser.service.spec.ts b/packages/sheets-hyper-link/src/services/__tests__/parser.service.spec.ts
index 23178e15e5..706879acfd 100644
--- a/packages/sheets-hyper-link/src/services/__tests__/parser.service.spec.ts
+++ b/packages/sheets-hyper-link/src/services/__tests__/parser.service.spec.ts
@@ -83,7 +83,7 @@ describe('SheetsHyperLinkParserService', () => {
univer.dispose();
});
- it('should build hyperlinks for sheet, named range and range object', () => {
+ it('should build hyperlinks for sheet, defined name and range object', () => {
const range: IRange = {
startRow: 0,
endRow: 1,
@@ -91,9 +91,9 @@ describe('SheetsHyperLinkParserService', () => {
endColumn: 1,
};
- expect(service.buildHyperLink('book-1', 'sheet-1')).toBe('#gid=sheet-1');
- expect(service.buildHyperLink('book-1', 'sheet-1', 'name-1')).toBe('#gid=sheet-1&rangeid=name-1');
- expect(service.buildHyperLink('book-1', 'sheet-1', range)).toBe('#gid=sheet-1&range=A1:B2');
+ expect(service.buildHyperLink(null, 'sheet-1')).toBe('#gid=sheet-1');
+ expect(service.buildHyperLink('name-1')).toBe('#rangeid=name-1');
+ expect(service.buildHyperLink(range, 'sheet-1')).toBe('#gid=sheet-1&range=A1:B2');
});
it('should parse external URLs as url links', () => {
@@ -150,6 +150,32 @@ describe('SheetsHyperLinkParserService', () => {
});
});
+ it('should parse defined name links from the focused workbook when unitid is absent', () => {
+ const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, createWorkbookData());
+ const univerInstanceService = univer.__getInjector().get(IUniverInstanceService);
+ const definedNamesService = univer.__getInjector().get(IDefinedNamesService);
+
+ univerInstanceService.focusUnit(workbook.getUnitId());
+ definedNamesService.registerDefinedName(workbook.getUnitId(), {
+ id: 'name-1',
+ name: 'Total',
+ formulaOrRefString: 'Sheet1!A1:B2',
+ });
+
+ const url = service.buildHyperLink('name-1');
+ expect(service.parseHyperLink(url)).toEqual({
+ type: SheetHyperLinkType.DEFINE_NAME,
+ name: 'Sheet1!A1:B2',
+ url,
+ searchObj: {
+ gid: '',
+ range: '',
+ rangeid: 'name-1',
+ unitid: '',
+ },
+ });
+ });
+
it('should parse sheet links by sheet id', () => {
const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, createWorkbookData());
diff --git a/packages/sheets-hyper-link/src/services/parser.service.ts b/packages/sheets-hyper-link/src/services/parser.service.ts
index 9162310bab..adbd061d68 100644
--- a/packages/sheets-hyper-link/src/services/parser.service.ts
+++ b/packages/sheets-hyper-link/src/services/parser.service.ts
@@ -41,8 +41,20 @@ export class SheetsHyperLinkParserService {
@IDefinedNamesService private _definedNamesService: IDefinedNamesService
) {}
- buildHyperLink(unitId: string, sheetId: string, range?: string | IRange): string {
- return `#${SheetHyperLinkType.SHEET}=${sheetId}${range ? `&${typeof range === 'string' ? SheetHyperLinkType.DEFINE_NAME : SheetHyperLinkType.RANGE}=${typeof range === 'string' ? range : serializeRange(range)}` : ''}`;
+ buildHyperLink(defineNameId: string): string;
+ buildHyperLink(range: IRange | null, sheetId: string): string;
+ buildHyperLink(defineNameIdOrRange: string | IRange | null, sheetId?: string): string {
+ if (typeof defineNameIdOrRange === 'string') {
+ return `#${SheetHyperLinkType.DEFINE_NAME}=${defineNameIdOrRange}`;
+ }
+
+ let result = `#${SheetHyperLinkType.SHEET}=${sheetId}`;
+
+ if (defineNameIdOrRange) {
+ result += `&${SheetHyperLinkType.RANGE}=${serializeRange(defineNameIdOrRange)}`;
+ }
+
+ return result;
}
parseHyperLink(urlStr: string): ISheetHyperLinkInfo {