pw-core 1.3.0 → 1.3.1

package/dist/codegen/key-utils.d.ts

@@ -21,3 +21,19 @@
 export declare function toRegistryKey(str: string, options?: {
     roleSuffix?: string;
 }): string;
+/**
+ * Formats a worker fixture prefix for page keys.
+ *
+ * @example
+ * toWorkerKey('loginPage') => 'workerLoginPage'
+ * toWorkerKey('workerLoginPage') => 'workerLoginPage'
+ */
+export declare function toWorkerKey(key: string): string;
+/**
+ * Strips the worker prefix and lowercases the initial character.
+ *
+ * @example
+ * toUnprefixedPageKey('workerLoginPage') => 'loginPage'
+ * toUnprefixedPageKey('loginPage') => 'loginPage'
+ */
+export declare function toUnprefixedPageKey(key: string): string;

package/dist/codegen/key-utils.js

@@ -11,6 +11,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toRegistryKey = toRegistryKey;
+exports.toWorkerKey = toWorkerKey;
+exports.toUnprefixedPageKey = toUnprefixedPageKey;
 /**
  * Convert an arbitrary string into a clean camelCase registry key.
  *
@@ -49,10 +51,11 @@ function toRegistryKey(str, options) {
         return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
     })
         .join('');
-    // Trim leading digits
+    // Trim leading digits and ensure first char is lowercase
     let result = camel.replace(/^\d+/, '');
     if (!result)
         return 'element';
+    result = result.charAt(0).toLowerCase() + result.slice(1);
     // Append role suffix if requested (e.g. 'Btn' for buttons)
     if (options?.roleSuffix) {
         const lowerResult = result.toLowerCase();
@@ -66,3 +69,28 @@ function toRegistryKey(str, options) {
         result = result.slice(0, 40);
     return result;
 }
+/**
+ * Formats a worker fixture prefix for page keys.
+ *
+ * @example
+ * toWorkerKey('loginPage') => 'workerLoginPage'
+ * toWorkerKey('workerLoginPage') => 'workerLoginPage'
+ */
+function toWorkerKey(key) {
+    if (key.startsWith('worker'))
+        return key;
+    return `worker${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+}
+/**
+ * Strips the worker prefix and lowercases the initial character.
+ *
+ * @example
+ * toUnprefixedPageKey('workerLoginPage') => 'loginPage'
+ * toUnprefixedPageKey('loginPage') => 'loginPage'
+ */
+function toUnprefixedPageKey(key) {
+    if (key.startsWith('worker') && key.length > 6) {
+        return key.slice(6).charAt(0).toLowerCase() + key.slice(7);
+    }
+    return key;
+}

package/dist/codegen/project-finder.d.ts

@@ -0,0 +1,29 @@
+export { toWorkerKey } from './key-utils';
+/**
+ * Recursively searches for registry.ts / registry.js containing `createPageRegistry(`.
+ */
+export declare function findRegistryFile(dir: string): string | null;
+/**
+ * Searches upwards or downwards for playwright.config.ts / playwright.config.js.
+ */
+export declare function findPlaywrightConfig(dir: string): string | null;
+/**
+ * Parses key-value pairs from a `.env` file in the given directory.
+ */
+export declare function parseDotEnv(cwd: string): Record<string, string>;
+/**
+ * Resolves the base URL from .env, playwright.config, or env utility files.
+ */
+export declare function getBaseUrl(cwd: string): string;
+/**
+ * Resolves test directory from playwright.config or defaults to cwd.
+ */
+export declare function getTestDir(cwd: string): string;
+/**
+ * Finds the next incremental test index in the codegen output directory.
+ */
+export declare function getNextTestIndex(testDir: string): number;
+/**
+ * Formats a recording date for comments in generated test files.
+ */
+export declare function formatRecordingDate(date: Date): string;

package/dist/codegen/project-finder.js

@@ -0,0 +1,283 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toWorkerKey = void 0;
+exports.findRegistryFile = findRegistryFile;
+exports.findPlaywrightConfig = findPlaywrightConfig;
+exports.parseDotEnv = parseDotEnv;
+exports.getBaseUrl = getBaseUrl;
+exports.getTestDir = getTestDir;
+exports.getNextTestIndex = getNextTestIndex;
+exports.formatRecordingDate = formatRecordingDate;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+var key_utils_1 = require("./key-utils");
+Object.defineProperty(exports, "toWorkerKey", { enumerable: true, get: function () { return key_utils_1.toWorkerKey; } });
+/**
+ * Recursively searches for registry.ts / registry.js containing `createPageRegistry(`.
+ */
+function findRegistryFile(dir) {
+    const queue = [dir];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        try {
+            const files = fs.readdirSync(current);
+            for (const file of files) {
+                const fullPath = path.join(current, file);
+                if (file === 'node_modules' || file === '.git' || file === 'dist')
+                    continue;
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    queue.push(fullPath);
+                }
+                else if (file === 'registry.ts' || file === 'registry.js') {
+                    try {
+                        const content = fs.readFileSync(fullPath, 'utf8');
+                        if (content.includes('createPageRegistry(')) {
+                            return fullPath;
+                        }
+                    }
+                    catch {
+                        // Ignore unreadable individual files during traversal
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore inaccessible directories during traversal
+        }
+    }
+    let parent = path.dirname(dir);
+    while (parent !== dir) {
+        const checkPath = path.join(parent, 'registry.ts');
+        if (fs.existsSync(checkPath)) {
+            try {
+                const content = fs.readFileSync(checkPath, 'utf8');
+                if (content.includes('createPageRegistry('))
+                    return checkPath;
+            }
+            catch {
+                // Ignore unreadable registry candidate
+            }
+        }
+        const checkPathSrc = path.join(parent, 'src', 'pages', 'registry.ts');
+        if (fs.existsSync(checkPathSrc)) {
+            try {
+                const content = fs.readFileSync(checkPathSrc, 'utf8');
+                if (content.includes('createPageRegistry('))
+                    return checkPathSrc;
+            }
+            catch {
+                // Ignore unreadable registry candidate in src/pages
+            }
+        }
+        dir = parent;
+        parent = path.dirname(dir);
+    }
+    return null;
+}
+/**
+ * Searches upwards or downwards for playwright.config.ts / playwright.config.js.
+ */
+function findPlaywrightConfig(dir) {
+    const queue = [dir];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        try {
+            const files = fs.readdirSync(current);
+            for (const file of files) {
+                if (file === 'node_modules' || file === '.git' || file === 'dist')
+                    continue;
+                const fullPath = path.join(current, file);
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    queue.push(fullPath);
+                }
+                else if (file === 'playwright.config.ts' || file === 'playwright.config.js') {
+                    return fullPath;
+                }
+            }
+        }
+        catch {
+            // Ignore inaccessible directories during traversal
+        }
+    }
+    let parent = path.dirname(dir);
+    while (parent !== dir) {
+        const tsPath = path.join(parent, 'playwright.config.ts');
+        const jsPath = path.join(parent, 'playwright.config.js');
+        if (fs.existsSync(tsPath))
+            return tsPath;
+        if (fs.existsSync(jsPath))
+            return jsPath;
+        dir = parent;
+        parent = path.dirname(dir);
+    }
+    return null;
+}
+/**
+ * Parses key-value pairs from a `.env` file in the given directory.
+ */
+function parseDotEnv(cwd) {
+    const env = {};
+    const envPath = path.join(cwd, '.env');
+    if (fs.existsSync(envPath)) {
+        try {
+            const content = fs.readFileSync(envPath, 'utf8');
+            const lines = content.split(/\r?\n/);
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#'))
+                    continue;
+                const index = trimmed.indexOf('=');
+                if (index > 0) {
+                    const key = trimmed.slice(0, index).trim();
+                    let val = trimmed.slice(index + 1).trim();
+                    if ((val.startsWith("'") && val.endsWith("'")) || (val.startsWith('"') && val.endsWith('"'))) {
+                        val = val.slice(1, -1);
+                    }
+                    env[key] = val;
+                }
+            }
+        }
+        catch {
+            // Return partial or empty env map if file reading is interrupted
+        }
+    }
+    return env;
+}
+/**
+ * Resolves the base URL from .env, playwright.config, or env utility files.
+ */
+function getBaseUrl(cwd) {
+    const env = parseDotEnv(cwd);
+    const envUrl = process.env.URL || env['URL'];
+    if (envUrl) {
+        return envUrl;
+    }
+    let configPath = path.join(cwd, 'playwright.config.ts');
+    if (!fs.existsSync(configPath)) {
+        configPath = path.join(cwd, 'playwright.config.js');
+    }
+    if (fs.existsSync(configPath)) {
+        try {
+            const content = fs.readFileSync(configPath, 'utf8');
+            const stringMatch = content.match(/baseURL:\s*['"`](.*?)['"`]/);
+            if (stringMatch && stringMatch[1]) {
+                return stringMatch[1];
+            }
+            if (/baseURL:\s*(?:env|ENV)\.url/.test(content)) {
+                let envFilePath = path.join(cwd, 'src', 'utils', 'env.ts');
+                if (!fs.existsSync(envFilePath)) {
+                    envFilePath = path.join(cwd, 'src', 'utils', 'env.js');
+                }
+                if (fs.existsSync(envFilePath)) {
+                    const envContent = fs.readFileSync(envFilePath, 'utf8');
+                    const stringMatches = [...envContent.matchAll(/['"`](https?:\/\/.*?)['"`]/g)];
+                    if (stringMatches.length > 0) {
+                        return stringMatches[0][1];
+                    }
+                }
+            }
+        }
+        catch {
+            // Fall back to empty string if playwright config is invalid or unreadable
+        }
+    }
+    return '';
+}
+/**
+ * Resolves test directory from playwright.config or defaults to cwd.
+ */
+function getTestDir(cwd) {
+    let configPath = path.join(cwd, 'playwright.config.ts');
+    if (!fs.existsSync(configPath)) {
+        configPath = path.join(cwd, 'playwright.config.js');
+    }
+    if (fs.existsSync(configPath)) {
+        try {
+            const content = fs.readFileSync(configPath, 'utf8');
+            const testDirMatch = content.match(/testDir:\s*['"`](.*?)['"`]/);
+            if (testDirMatch && testDirMatch[1]) {
+                return path.resolve(cwd, testDirMatch[1]);
+            }
+        }
+        catch {
+            // Fall back to cwd if testDir parsing fails
+        }
+    }
+    return cwd;
+}
+/**
+ * Finds the next incremental test index in the codegen output directory.
+ */
+function getNextTestIndex(testDir) {
+    if (!fs.existsSync(testDir))
+        return 1;
+    try {
+        const files = fs.readdirSync(testDir);
+        let max = 0;
+        for (const file of files) {
+            const match = file.match(/^(\d+)\.recorded\.test\.(ts|js)$/);
+            if (match) {
+                const num = parseInt(match[1], 10);
+                if (num > max) {
+                    max = num;
+                }
+            }
+        }
+        return max + 1;
+    }
+    catch {
+        // Default to index 1 if test directory is unreadable
+        return 1;
+    }
+}
+/**
+ * Formats a recording date for comments in generated test files.
+ */
+function formatRecordingDate(date) {
+    const day = date.getDate();
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    const month = months[date.getMonth()];
+    const year = date.getFullYear();
+    let hours = date.getHours();
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    const ampm = hours >= 12 ? 'PM' : 'AM';
+    hours = hours % 12;
+    hours = hours ? hours : 12;
+    return `${day} ${month} ${year}, ${hours}:${minutes}:${seconds} ${ampm}`;
+}

package/dist/codegen/registry-matcher.d.ts

@@ -0,0 +1,27 @@
+import { type RegistryRoot } from './registry-store';
+import type { SelectorStrategyType } from './types';
+export interface MatchResult {
+    pageKey: string;
+    elementKey: string;
+    val: string;
+    type: string;
+    isNew: boolean;
+}
+export declare function toCamelCase(str: string): string;
+/**
+ * Determines the page key from a URL or title, checking existing registry configs first.
+ */
+export declare function findPageKey(url: string, title: string, registryObj: RegistryRoot, overrideMode?: boolean): string;
+/**
+ * Searches a registry dictionary or array for a matching value.
+ */
+export declare function findMatchInDict(val: string, strategyType: string, pageKey: string, registryObj: RegistryRoot, overrideMode?: boolean): MatchResult | null;
+/**
+ * Resolves a selector to an element key and page key in the registry.
+ */
+export declare function findElementKey(selector: string, pageKey: string, registryObj: RegistryRoot, overrideMode?: boolean, extra?: {
+    targetTestId?: string;
+    targetId?: string;
+    targetParentId?: string;
+    overrideType?: SelectorStrategyType;
+}): MatchResult;

package/dist/codegen/registry-matcher.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCamelCase = toCamelCase;
+exports.findPageKey = findPageKey;
+exports.findMatchInDict = findMatchInDict;
+exports.findElementKey = findElementKey;
+const key_utils_1 = require("./key-utils");
+const selector_parser_1 = require("./selector-parser");
+const registry_store_1 = require("./registry-store");
+function toCamelCase(str) {
+    return (0, key_utils_1.toRegistryKey)(str);
+}
+const normalizePageKey = key_utils_1.toUnprefixedPageKey;
+/**
+ * Determines the page key from a URL or title, checking existing registry configs first.
+ */
+function findPageKey(url, title, registryObj, overrideMode) {
+    let pathname = '';
+    let hashPath = '';
+    try {
+        const u = new URL(url);
+        pathname = u.pathname;
+        if (u.hash && u.hash.startsWith('#/')) {
+            hashPath = u.hash.slice(1);
+        }
+    }
+    catch {
+        // Fall back to raw url string if not a standard absolute URL
+        pathname = url || '';
+    }
+    const cleanPath = (p) => {
+        let result = p.split('?')[0].split('#')[0];
+        if (result.startsWith('/'))
+            result = result.substring(1);
+        if (result.endsWith('/'))
+            result = result.slice(0, -1);
+        return result;
+    };
+    const effectivePath = hashPath && hashPath !== '/' && hashPath !== '' ? cleanPath(hashPath) : cleanPath(pathname);
+    for (const key of Object.keys(registryObj)) {
+        const pageConfig = registryObj[key];
+        if (pageConfig && pageConfig.url) {
+            let configUrl = pageConfig.url;
+            if (configUrl.startsWith('/'))
+                configUrl = configUrl.substring(1);
+            if (configUrl.endsWith('/'))
+                configUrl = configUrl.slice(0, -1);
+            if (configUrl === effectivePath) {
+                const isCodegen = key.startsWith('codegen_') || key === 'codegenPage';
+                if (!overrideMode && !isCodegen)
+                    continue;
+                if (!effectivePath && isCodegen)
+                    continue;
+                return key;
+            }
+        }
+    }
+    let keyBase = '';
+    if (effectivePath) {
+        const segments = effectivePath.split('/').filter(Boolean);
+        keyBase = segments
+            .map((seg, idx) => {
+            const parts = seg.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+            if (parts.length === 0)
+                return '';
+            return parts
+                .map((part, partIdx) => {
+                if (idx === 0 && partIdx === 0) {
+                    return part.charAt(0).toLowerCase() + part.slice(1);
+                }
+                return part.charAt(0).toUpperCase() + part.slice(1);
+            })
+                .join('');
+        })
+            .join('');
+    }
+    if (!keyBase && title) {
+        const firstSegment = title.split(/[|\u2014\-:]/)[0].trim();
+        const cleanTitle = (firstSegment || title).replace(/[^a-zA-Z0-9\s]/g, '').trim();
+        const words = cleanTitle.split(/\s+/).filter(Boolean);
+        keyBase = words
+            .map((w, idx) => {
+            const clean = w.replace(/[^a-zA-Z0-9]/g, '');
+            if (idx === 0)
+                return clean.charAt(0).toLowerCase() + clean.slice(1);
+            return clean.charAt(0).toUpperCase() + clean.slice(1);
+        })
+            .join('');
+    }
+    if (!keyBase) {
+        keyBase = 'home';
+    }
+    if (overrideMode) {
+        return keyBase;
+    }
+    return `codegen_${keyBase}`;
+}
+/**
+ * Searches a registry dictionary or array for a matching value.
+ */
+function findMatchInDict(val, strategyType, pageKey, registryObj, overrideMode) {
+    const getExpandedKey = (dynamicKey, placeholder, value) => {
+        const isPurePlaceholder = dynamicKey === `{${placeholder}}`;
+        let capValue = '';
+        if (isPurePlaceholder) {
+            capValue = value;
+        }
+        else {
+            const words = value.split(/[^a-zA-Z0-9]/).filter(Boolean);
+            capValue = words.map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join('');
+        }
+        return dynamicKey.replace(`{${placeholder}}`, capValue);
+    };
+    let targetPageKey = pageKey;
+    for (const k of Object.keys(registryObj)) {
+        if (normalizePageKey(k) === normalizePageKey(pageKey)) {
+            targetPageKey = k;
+            break;
+        }
+    }
+    const pageConfig = registryObj[targetPageKey] || {};
+    const searchConfig = (config, pk) => {
+        if (strategyType === 'testId') {
+            const dict = config.testId || config.testIds || {};
+            for (const k of Object.keys(dict)) {
+                const entry = dict[k];
+                if (typeof entry === 'object' && entry !== null) {
+                    const { matches, matchedValue, placeholderName } = (0, registry_store_1.matchDynamicEntry)(val, entry, true);
+                    if (matches && matchedValue && placeholderName) {
+                        const arr = entry[placeholderName] || [];
+                        if (!arr.includes(matchedValue)) {
+                            entry[placeholderName] = [...arr, matchedValue];
+                        }
+                        const expandedKey = getExpandedKey(k, placeholderName, matchedValue);
+                        return { pageKey: pk, elementKey: expandedKey, val, type: 'testId', isNew: false };
+                    }
+                }
+                else if (entry === val) {
+                    return { pageKey: pk, elementKey: k, val, type: 'testId', isNew: false };
+                }
+            }
+        }
+        else if (strategyType === 'selector') {
+            const dict = config.selector || config.selectors || {};
+            for (const k of Object.keys(dict)) {
+                const entry = dict[k];
+                if (typeof entry === 'object' && entry !== null) {
+                    const { matches, matchedValue, placeholderName } = (0, registry_store_1.matchDynamicEntry)(val, entry, false);
+                    if (matches && matchedValue && placeholderName) {
+                        const arr = entry[placeholderName] || [];
+                        if (!arr.includes(matchedValue)) {
+                            entry[placeholderName] = [...arr, matchedValue];
+                        }
+                        const expandedKey = getExpandedKey(k, placeholderName, matchedValue);
+                        return { pageKey: pk, elementKey: expandedKey, val, type: 'selector', isNew: false };
+                    }
+                }
+                else if (entry === val) {
+                    return { pageKey: pk, elementKey: k, val, type: 'selector', isNew: false };
+                }
+            }
+        }
+        else {
+            const arr = config[strategyType];
+            if (Array.isArray(arr)) {
+                if (arr.includes(val)) {
+                    const elementKey = val;
+                    return { pageKey: pk, elementKey, val, type: strategyType, isNew: false };
+                }
+            }
+        }
+        return null;
+    };
+    const targetMatch = searchConfig(pageConfig, targetPageKey);
+    if (targetMatch)
+        return targetMatch;
+    for (const pk of Object.keys(registryObj)) {
+        if (normalizePageKey(pk) === normalizePageKey(pageKey))
+            continue;
+        const isCurrentCodegen = pageKey.startsWith('codegen_') || pageKey === 'codegenPage';
+        const isOtherCodegen = pk.startsWith('codegen_') || pk === 'codegenPage';
+        if (isCurrentCodegen && isOtherCodegen)
+            continue;
+        const config = registryObj[pk] || {};
+        const match = searchConfig(config, pk);
+        if (match)
+            return match;
+    }
+    return null;
+}
+/**
+ * Resolves a selector to an element key and page key in the registry.
+ */
+function findElementKey(selector, pageKey, registryObj, overrideMode, extra) {
+    let { type, val } = (0, selector_parser_1.getSelectorValue)(selector);
+    if (extra?.overrideType) {
+        type = extra.overrideType;
+    }
+    // 1. Try matching with the selector itself first
+    const selectorMatch = findMatchInDict(val, type, pageKey, registryObj, overrideMode);
+    if (selectorMatch)
+        return selectorMatch;
+    // 1.5. Check if the value exists in ANY other strategy array/object under the page config to avoid duplicates and recreation
+    const pageConfig = registryObj[pageKey] || {};
+    for (const k of Object.keys(pageConfig)) {
+        if (k === 'url')
+            continue;
+        const match = findMatchInDict(val, k, pageKey, registryObj, overrideMode);
+        if (match) {
+            return match;
+        }
+    }
+    // 2. Try matching targetTestId (if any) against testIds in registry
+    if (extra?.targetTestId) {
+        const testIdMatch = findMatchInDict(extra.targetTestId, 'testId', pageKey, registryObj, overrideMode);
+        if (testIdMatch)
+            return testIdMatch;
+    }
+    // 3. Try matching targetId (if any) against selectors/testIds
+    if (extra?.targetId) {
+        const idSelectorMatch = findMatchInDict(extra.targetId, 'selector', pageKey, registryObj, overrideMode);
+        if (idSelectorMatch)
+            return idSelectorMatch;
+        const idTestIdMatch = findMatchInDict(extra.targetId, 'testId', pageKey, registryObj, overrideMode);
+        if (idTestIdMatch)
+            return idTestIdMatch;
+    }
+    // 4. Try matching targetParentId (if any) against selectors/testIds
+    if (extra?.targetParentId) {
+        const pIdSelectorMatch = findMatchInDict(extra.targetParentId, 'selector', pageKey, registryObj, overrideMode);
+        if (pIdSelectorMatch)
+            return pIdSelectorMatch;
+    }
+    let baseKey = type === 'testId' || type === 'selector' ? toCamelCase(val) : val;
+    if (!baseKey)
+        baseKey = 'element';
+    let finalKey = baseKey;
+    let counter = 1;
+    const existingKeys = new Set();
+    for (const key of Object.keys(pageConfig)) {
+        const entry = pageConfig[key];
+        if (Array.isArray(entry)) {
+            entry.forEach((v) => existingKeys.add(v));
+        }
+        else if (typeof entry === 'object' && entry !== null) {
+            Object.keys(entry).forEach((k) => existingKeys.add(k));
+        }
+    }
+    while (existingKeys.has(finalKey)) {
+        finalKey = baseKey + counter;
+        counter++;
+    }
+    return { pageKey, elementKey: finalKey, val, type, isNew: true };
+}