[Discover] Tab duplication naming refactor (#230538)

## Summary

Closes #223899 

This PR unifies and simplifies getting next tab number and next copy
number.
I moved the function to `kbn-unified-tabs` package, so Discover is only
consuming it, instead of introducing its own logic.

### Checklist

Check the PR satisfies following conditions. 

Reviewers should verify this PR satisfies this list as well.

- [ ] Any text added follows [EUI's writing
guidelines](https://elastic.github.io/eui/#/guidelines/writing), uses
sentence case text and includes [i18n
support](https://github.com/elastic/kibana/blob/main/src/platform/packages/shared/kbn-i18n/README.md)
- [ ]
[Documentation](https://www.elastic.co/guide/en/kibana/master/development-documentation.html)
was added for features that require explanation or tutorials
- [x] [Unit or functional
tests](https://www.elastic.co/guide/en/kibana/master/development-tests.html)
were updated or added to match the most common scenarios
- [ ] If a plugin configuration key changed, check if it needs to be
allowlisted in the cloud and added to the [docker
list](https://github.com/elastic/kibana/blob/main/src/dev/build/tasks/os_packages/docker_generator/resources/base/bin/kibana-docker)
- [ ] This was checked for breaking HTTP API changes, and any breaking
changes have been approved by the breaking-change committee. The
`release_note:breaking` label should be applied in these situations.
- [ ] [Flaky Test
Runner](https://ci-stats.kibana.dev/trigger_flaky_test_runner/1) was
used on any tests changed
- [x] The PR description includes the appropriate Release Notes section,
and the correct `release_note:*` label is applied per the
[guidelines](https://www.elastic.co/guide/en/kibana/master/contributing.html#kibana-release-notes-process)
- [x] Review the [backport
guidelines](https://docs.google.com/document/d/1VyN5k91e5OVumlc0Gb9RPa3h1ewuPE705nRtioPiTvY/edit?usp=sharing)
and apply applicable `backport:*` labels.

### Identify risks

Does this PR introduce any risks? For example, consider risks like hard
to test bugs, performance regression, potential of data loss.

Describe the risk, its severity, and mitigation for each identified
risk. Invite stakeholders and evaluate how to proceed before merging.

- [ ] [See some risk
examples](https://github.com/elastic/kibana/blob/main/RISK_MATRIX.mdx)
- [ ] ...

---------

Co-authored-by: kibanamachine <[email protected]>

Author: akowalska622

src/platform/packages/shared/kbn-unified-tabs/index.ts

@@ -14,3 +14,4 @@ export {
   type TabbedContentProps as UnifiedTabsProps,
 } from './src/components/tabbed_content';
 export { useNewTabProps } from './src/hooks/use_new_tab_props';
+export { getNextTabNumber } from './src/utils/get_next_tab_number';

src/platform/packages/shared/kbn-unified-tabs/src/components/tabbed_content/tabbed_content.tsx

@@ -25,6 +25,7 @@ import {
   closeTabsToTheRight,
 } from '../../utils/manage_tabs';
 import type { TabItem, TabsServices, TabPreviewData } from '../../types';
+import { getNextTabNumber } from '../../utils/get_next_tab_number';
 
 export interface TabbedContentProps extends Pick<TabsBarProps, 'maxItemsCount'> {
   items: TabItem[];
@@ -136,27 +137,16 @@ export const TabbedContent: React.FC<TabbedContentProps> = ({
       newItem.duplicatedFromId = item.id;
 
       const copyLabel = i18n.translate('unifiedTabs.copyLabel', { defaultMessage: 'copy' });
-      const escapedCopyLabel = escapeRegExp(copyLabel);
-      const baseRegex = new RegExp(`\\s*\\(${escapedCopyLabel}\\)( \\d+)?$`);
-      const baseLabel = item.label.replace(baseRegex, '');
-      const escapedBaseLabel = escapeRegExp(baseLabel);
-
-      // Find all existing copies to determine next number
-      const copyRegex = new RegExp(`^${escapedBaseLabel}\\s*\\(${escapedCopyLabel}\\)( \\d+)?$`);
-      const copyNumberRegex = new RegExp(`\\(${escapedCopyLabel}\\) (\\d+)$`);
-      const copies = state.items
-        .filter((tab) => copyRegex.test(tab.label))
-        .map((tab) => {
-          const match = tab.label.match(copyNumberRegex);
-          return match && match[1] ? Number(match[1]) : 1; // match[1] is the number after (copy)
-        });
-
-      // Determine the next copy number
-      const nextNumber = copies.length > 0 ? Math.max(...copies) + 1 : null;
-
-      newItem.label = nextNumber
-        ? `${baseLabel} (${copyLabel}) ${nextNumber}`
-        : `${baseLabel} (${copyLabel})`;
+
+      // Remove existing (copy) or (copy N) suffix to get base label
+      const copyPattern = `\\s*\\(${escapeRegExp(copyLabel)}\\)(?:\\s+\\d+)?$`;
+      const baseLabel = item.label.replace(new RegExp(copyPattern), '');
+
+      // Create the copy base pattern: "Original Label (copy)"
+      const copyBaseLabel = `${baseLabel} (${copyLabel})`;
+
+      const nextNumber = getNextTabNumber(state.items, copyBaseLabel);
+      newItem.label = nextNumber ? `${copyBaseLabel} ${nextNumber}` : copyBaseLabel;
 
       tabsBarApi.current?.moveFocusToNextSelectedItem(newItem);
       changeState((prevState) => insertTabAfter(prevState, newItem, item, maxItemsCount));

src/platform/packages/shared/kbn-unified-tabs/src/utils/get_next_tab_number.test.ts

@@ -0,0 +1,134 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import { getNextTabNumber } from './get_next_tab_number';
+import type { TabItem } from '../types';
+
+const DEFAULT_TAB_LABEL = 'Untitled';
+const DEFAULT_TAB_COPY_LABEL = 'Untitled (copy)';
+
+describe('getNextNumber', () => {
+  it('should return null when no tabs match the base label pattern', () => {
+    const tabs: TabItem[] = [
+      { id: '1', label: 'Some tab' },
+      { id: '2', label: 'Another tab' },
+      { id: '3', label: 'Different label' },
+    ];
+
+    const result = getNextTabNumber(tabs, DEFAULT_TAB_LABEL);
+
+    expect(result).toBeNull();
+  });
+
+  it('should work with regular numbered tabs (non-copy scenario)', () => {
+    const tabs: TabItem[] = [
+      { id: '1', label: 'Untitled' },
+      { id: '2', label: 'Untitled 2' },
+      { id: '3', label: 'Untitled 4' },
+      { id: '4', label: 'Some other tab' },
+    ];
+
+    const result = getNextTabNumber(tabs, DEFAULT_TAB_LABEL);
+
+    expect(result).toBe(5); // Should be max(1, 2, 4) + 1 = 5
+  });
+
+  it('should return 2 when there is one copy tab without a number', () => {
+    const tabs: TabItem[] = [
+      { id: '1', label: 'Untitled' },
+      { id: '2', label: 'Untitled (copy)' },
+      { id: '3', label: 'Some other tab' },
+    ];
+
+    const result = getNextTabNumber(tabs, DEFAULT_TAB_COPY_LABEL);
+
+    expect(result).toBe(2); // "Untitled (copy)" is treated as number 1
+  });
+
+  it('should return the next number when multiple numbered copy tabs exist', () => {
+    const tabs: TabItem[] = [
+      { id: '1', label: 'Untitled' },
+      { id: '2', label: 'Untitled (copy)' },
+      { id: '3', label: 'Untitled (copy) 2' },
+      { id: '4', label: 'Untitled (copy) 5' },
+      { id: '5', label: 'Some other tab' },
+    ];
+
+    const result = getNextTabNumber(tabs, DEFAULT_TAB_COPY_LABEL);
+
+    expect(result).toBe(6); // Should be max(1, 2, 5) + 1 = 6
+  });
+
+  it('should count copy and regular tabs separately', () => {
+    const tabs: TabItem[] = [
+      { id: '1', label: 'Untitled 3' },
+      { id: '2', label: 'Untitled (copy) 2' },
+      { id: '3', label: 'Some other tab' },
+    ];
+
+    const nextCopyNumber = getNextTabNumber(tabs, DEFAULT_TAB_COPY_LABEL);
+    expect(nextCopyNumber).toBe(3);
+
+    const nextTabNumber = getNextTabNumber(tabs, DEFAULT_TAB_LABEL);
+    expect(nextTabNumber).toBe(4);
+  });
+
+  it('should handle tabs with whitespace correctly', () => {
+    const tabs: TabItem[] = [
+      { id: '1', label: '  Untitled  ' },
+      { id: '2', label: 'Untitled 2  ' },
+      { id: '3', label: '  Untitled 3' },
+    ];
+
+    const result = getNextTabNumber(tabs, DEFAULT_TAB_LABEL);
+
+    expect(result).toBe(4); // Should be max(1, 2, 3) + 1 = 4
+  });
+
+  it('should handle case with only base label', () => {
+    const tabs: TabItem[] = [{ id: '1', label: 'Untitled' }];
+
+    const result = getNextTabNumber(tabs, DEFAULT_TAB_LABEL);
+
+    expect(result).toBe(2); // "Untitled" is treated as number 1, so next is 2
+  });
+
+  it('should ignore differently named tabs', () => {
+    const tabs: TabItem[] = [
+      { id: '1', label: 'Untitled' },
+      { id: '2', label: 'Untitled abc 4' }, // Invalid - should be ignored
+      { id: '3', label: 'Untitled 2' },
+      { id: '4', label: 'Untitled extra text 2' }, // Invalid - should be ignored
+    ];
+
+    const result = getNextTabNumber(tabs, DEFAULT_TAB_LABEL);
+
+    expect(result).toBe(3); // Should be max(1, 2) + 1 = 3
+  });
+
+  it('should work with complex base labels containing special characters', () => {
+    const tabs: TabItem[] = [
+      { id: '1', label: 'My Tab (special/?)' },
+      { id: '2', label: 'My Tab (special*) 2' },
+      { id: '3', label: 'My Tab (^special) 5' },
+    ];
+
+    const result = getNextTabNumber(tabs, 'My Tab (special/?)');
+
+    expect(result).toBe(2);
+  });
+
+  it('should handle empty tabs array', () => {
+    const tabs: TabItem[] = [];
+
+    const result = getNextTabNumber(tabs, DEFAULT_TAB_LABEL);
+
+    expect(result).toBeNull();
+  });
+});

src/platform/packages/shared/kbn-unified-tabs/src/utils/get_next_tab_number.ts

@@ -0,0 +1,40 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+import type { TabItem } from '../types';
+
+export const getNextTabNumber = (allTabs: TabItem[], baseLabel: string) => {
+  // Find the highest number among tabs with the base label
+  const maxNumber = allTabs.reduce((max, tab) => {
+    const label = tab.label.trim();
+
+    // Check if this is the base label without a number (implicit "1")
+    if (label === baseLabel) {
+      return Math.max(max, 1);
+    }
+
+    // Check if this is a numbered variant like "Base Label 2"
+    if (label.startsWith(`${baseLabel} `)) {
+      // Extract the number part after "Base Label "
+      const suffix = label.slice(baseLabel.length + 1);
+      const num = Number(suffix);
+
+      // Only consider valid numbers
+      if (!isNaN(num)) {
+        return Math.max(max, num);
+      }
+    }
+
+    // Tab doesn't match our pattern, keep current max
+    return max;
+  }, 0); // Start with 0 as initial max
+
+  // Return next number if we found any matching tabs, otherwise null
+  return maxNumber > 0 ? maxNumber + 1 : null;
+};

src/platform/plugins/shared/discover/public/application/main/state_management/redux/utils.ts

@@ -8,9 +8,8 @@
  */
 
 import { v4 as uuid } from 'uuid';
-import { escapeRegExp } from 'lodash';
 import { i18n } from '@kbn/i18n';
-import type { TabItem } from '@kbn/unified-tabs';
+import { getNextTabNumber, type TabItem } from '@kbn/unified-tabs';
 import { createAsyncThunk } from '@reduxjs/toolkit';
 import type { DiscoverInternalState, TabState } from './types';
 import type {
@@ -47,23 +46,13 @@ export type TabActionInjector = ReturnType<typeof createTabActionInjector>;
 const DEFAULT_TAB_LABEL = i18n.translate('discover.defaultTabLabel', {
   defaultMessage: 'Untitled',
 });
-const ESCAPED_DEFAULT_TAB_LABEL = escapeRegExp(DEFAULT_TAB_LABEL);
-const DEFAULT_TAB_REGEX = new RegExp(`^${ESCAPED_DEFAULT_TAB_LABEL}( \\d+)?$`); // any default tab
-const DEFAULT_TAB_NUMBER_REGEX = new RegExp(`^${ESCAPED_DEFAULT_TAB_LABEL} (?<tabNumber>\\d+)$`); // tab with a number
 
 export const createTabItem = (allTabs: TabState[]): TabItem => {
   const id = uuid();
+  const baseLabel = DEFAULT_TAB_LABEL;
 
-  const existingNumbers = allTabs
-    .filter((tab) => DEFAULT_TAB_REGEX.test(tab.label.trim()))
-    .map((tab) => {
-      const match = tab.label.trim().match(DEFAULT_TAB_NUMBER_REGEX);
-      const tabNumber = match?.groups?.tabNumber;
-      return tabNumber ? Number(tabNumber) : 1;
-    });
-
-  const nextNumber = existingNumbers.length > 0 ? Math.max(...existingNumbers) + 1 : null;
-  const label = nextNumber ? `${DEFAULT_TAB_LABEL} ${nextNumber}` : DEFAULT_TAB_LABEL;
+  const nextNumber = getNextTabNumber(allTabs, baseLabel);
+  const label = nextNumber ? `${baseLabel} ${nextNumber}` : baseLabel;
 
   return { id, label };
 };