pomwright 0.0.3

package/dist/index.mjs

@@ -0,0 +1,1002 @@
+// src/basePage.ts
+import { selectors } from "@playwright/test";
+
+// src/helpers/playwrightReportLogger.ts
+var PlaywrightReportLogger = class _PlaywrightReportLogger {
+  constructor(sharedLogLevel, sharedLogEntry, contextName) {
+    this.sharedLogLevel = sharedLogLevel;
+    this.sharedLogEntry = sharedLogEntry;
+    this.contextName = contextName;
+  }
+  contextName;
+  logLevels = ["debug", "info", "warn", "error"];
+  /**
+   * Creates a new logger instance with a new contextual name which includes a reference to the parent logger.
+   *
+   * The root loggers log "level" is referenced by all child loggers and their child loggers and so on...
+   * Changing the log "level" of one, will change it for all.
+   *
+   * @param prefix - The prefix to add to the new logger instance.
+   * @returns - A new logger instance with the updated prefix.
+   */
+  getNewChildLogger(prefix) {
+    return new _PlaywrightReportLogger(this.sharedLogLevel, this.sharedLogEntry, `${this.contextName} -> ${prefix}`);
+  }
+  /**
+   * Logs a message with the specified log level, prefix, and arguments.
+   * The message will only be recorded if the current log level allows it.
+   *
+   * @param level - The log level for the message.
+   * @param message - The log message.
+   * @param args - Additional arguments to log.
+   */
+  log(level, message, ...args) {
+    const logLevelIndex = this.logLevels.indexOf(level);
+    if (logLevelIndex < this.getCurrentLogLevelIndex()) {
+      return;
+    }
+    this.sharedLogEntry.push({
+      timestamp: /* @__PURE__ */ new Date(),
+      logLevel: level,
+      prefix: this.contextName,
+      message: `${message}
+
+${args.join("\n\n")}`
+    });
+  }
+  /**
+   * Logs a debug-level message with the specified message and arguments.
+   *
+   * @param message - The log message.
+   * @param args - Additional arguments to log.
+   */
+  debug(message, ...args) {
+    this.log("debug", message, ...args);
+  }
+  /**
+   * Logs a info-level message with the specified message and arguments.
+   *
+   * @param message - The log message.
+   * @param args - Additional arguments to log.
+   */
+  info(message, ...args) {
+    this.log("info", message, ...args);
+  }
+  /**
+   * Logs a warn-level message with the specified message and arguments.
+   *
+   * @param message - The log message.
+   * @param args - Additional arguments to log.
+   */
+  warn(message, ...args) {
+    this.log("warn", message, ...args);
+  }
+  /**
+   * Logs a error-level message with the specified message and arguments.
+   *
+   * @param message - The log message.
+   * @param args - Additional arguments to log.
+   */
+  error(message, ...args) {
+    this.log("error", message, ...args);
+  }
+  /**
+   * Set logLevel during runtime.
+   *
+   * @param level - The logLevel ("debug" | "info" | "warn" | "error").
+   */
+  setLogLevel(level) {
+    this.sharedLogLevel.current = level;
+  }
+  /**
+   * Returns the current logLevel during runtime.
+   *
+   * @returns LogLevel ("debug" | "info" | "warn" | "error")
+   */
+  getCurrentLogLevel() {
+    return this.sharedLogLevel.current;
+  }
+  /**
+   * Returns the index of the current logLevel during runtime.
+   */
+  getCurrentLogLevelIndex() {
+    return this.logLevels.indexOf(this.sharedLogLevel.current);
+  }
+  /**
+   * Sets logLevel back to the initial logLevel during runtime.
+   */
+  resetLogLevel() {
+    this.sharedLogLevel.current = this.sharedLogLevel.initial;
+  }
+  /**
+   * isCurrentLogLevel is a method that checks if the input log level is equal to the current log level of the PlaywrightReportLogger instance.
+   * @param level The log level to check if it is equal to the current log level.
+   * @returns A boolean indicating whether the input log level is equal to the current log level.
+   */
+  isCurrentLogLevel(level) {
+    return this.sharedLogLevel.current === level;
+  }
+  /**
+   * isLogLevelEnabled returns 'true' if the "level" parameter provided has an equal or greater index than the current logLevel.
+   * @param level
+   * @returns
+   */
+  isLogLevelEnabled(level) {
+    const logLevelIndex = this.logLevels.indexOf(level);
+    if (logLevelIndex < this.getCurrentLogLevelIndex()) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Attaches the recorded logs to the Playwright HTML report.
+   *
+   * @param testInfo - The test information object from Playwright.
+   */
+  attachLogsToTest(testInfo) {
+    this.sharedLogEntry.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    for (const log of this.sharedLogEntry) {
+      const printTime = log.timestamp.toLocaleTimeString("nb-NO", {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      });
+      const printDate = log.timestamp.toLocaleDateString("nb-NO", {
+        day: "2-digit",
+        month: "2-digit",
+        year: "numeric"
+      });
+      const printLogLevel = `${log.logLevel.toUpperCase()}`;
+      const printPrefix = log.prefix ? `: [${log.prefix}]` : "";
+      let messageBody;
+      let messageContentType;
+      try {
+        const parsedMessage = JSON.parse(log.message);
+        messageContentType = "application/json";
+        messageBody = JSON.stringify(parsedMessage, null, 2);
+      } catch (error) {
+        messageContentType = "text/plain";
+        messageBody = log.message;
+      }
+      testInfo.attach(`${printTime} ${printDate} - ${printLogLevel} ${printPrefix}`, {
+        contentType: messageContentType,
+        body: Buffer.from(messageBody)
+      });
+    }
+  }
+};
+
+// src/helpers/sessionStorage.actions.ts
+import { test } from "@playwright/test";
+var SessionStorage = class {
+  constructor(page, pocName) {
+    this.page = page;
+    this.pocName = pocName;
+  }
+  queuedStates = {};
+  isInitiated = false;
+  /**
+   * Writes states to the sessionStorage. Private utility function.
+   *
+   * @param states An object representing the states (key/value pairs) to set.
+   */
+  async writeToSessionStorage(states) {
+    await this.page.evaluate((storage) => {
+      for (const [key, value] of Object.entries(storage)) {
+        window.sessionStorage.setItem(key, JSON.stringify(value));
+      }
+    }, states);
+  }
+  /**
+   * Reads all states from the sessionStorage. Private utility function.
+   *
+   * @returns An object containing all states from the sessionStorage.
+   */
+  async readFromSessionStorage() {
+    return await this.page.evaluate(() => {
+      const storage = {};
+      for (let i = 0; i < sessionStorage.length; i++) {
+        const key = sessionStorage.key(i);
+        if (key !== null) {
+          const item = sessionStorage.getItem(key);
+          try {
+            storage[key] = item ? JSON.parse(item) : null;
+          } catch (e) {
+            storage[key] = item;
+          }
+        }
+      }
+      return storage;
+    });
+  }
+  /**
+   * Sets the specified states in the sessionStorage.
+   *
+   * @param states An object representing the states (key/value pairs) to set in sessionStorage.
+   * @param reload If true, reloads the page after setting the sessionStorage data.
+   *
+   * Usage:
+   * await set({ user: 'John Doe', token: 'abc123' }, true);
+   */
+  async set(states, reload) {
+    await test.step(`${this.pocName}: setSessionStorage`, async () => {
+      await this.writeToSessionStorage(states);
+      if (reload) {
+        await this.page.reload();
+      }
+    });
+  }
+  /**
+   * Queues states to be set in the sessionStorage before the next navigation occurs.
+   * This handles multiple scenarios:
+   *
+   * 1. No Context, Single Call: Queues and sets states upon the next navigation.
+   * 2. No Context, Multiple Calls: Merges states from multiple calls and sets them upon the next navigation.
+   * 3. With Context: Directly sets states in sessionStorage if the context already exists.
+   *
+   * @param states An object representing the states (key/value pairs) to set.
+   *
+   * Usage:
+   * await setOnNextNavigation({ key: 'value' });
+   */
+  async setOnNextNavigation(states) {
+    this.queuedStates = { ...this.queuedStates, ...states };
+    const populateStorage = async () => {
+      await test.step(`${this.pocName}: setSessionStorageBeforeNavigation`, async () => {
+        await this.writeToSessionStorage(this.queuedStates);
+      });
+      this.queuedStates = {};
+    };
+    let contextExists = false;
+    try {
+      contextExists = await this.page.evaluate(() => {
+        return typeof window !== "undefined" && window.sessionStorage !== void 0;
+      });
+    } catch (e) {
+      contextExists = false;
+    }
+    if (contextExists) {
+      await populateStorage();
+      return;
+    }
+    if (!this.isInitiated) {
+      this.isInitiated = true;
+      this.page.once("framenavigated", async () => {
+        await populateStorage();
+      });
+    }
+  }
+  /**
+   * Fetches all or selected states from sessionStorage.
+   *
+   * @param keys Optional array of keys to fetch from sessionStorage.
+   * @returns An object containing the fetched states.
+   *
+   * Usage:
+   * 1. To fetch all states: await get();
+   * 2. To fetch selected states: await get(['key1', 'key2']);
+   */
+  async get(keys) {
+    let result = {};
+    await test.step(`${this.pocName}: getSessionStorage`, async () => {
+      const allData = await this.readFromSessionStorage();
+      if (keys && keys.length > 0) {
+        for (const key of keys) {
+          if (Object.prototype.hasOwnProperty.call(allData, key)) {
+            result[key] = allData[key];
+          }
+        }
+      } else {
+        result = allData;
+      }
+    });
+    return result;
+  }
+  /**
+   * Clears all states in sessionStorage.
+   *
+   * Usage:
+   * await clear();
+   */
+  async clear() {
+    await test.step(`${this.pocName}: clear SessionStorage`, async () => {
+      await this.page.evaluate(() => sessionStorage.clear());
+    });
+  }
+};
+
+// src/utils/selectorEngines.ts
+function createCypressIdEngine() {
+  return {
+    query(document, selector) {
+      const attr = `[data-cy="${selector}"]`;
+      const el = document.querySelector(attr);
+      return el;
+    },
+    queryAll(document, selector) {
+      const attr = `[data-cy="${selector}"]`;
+      const els = Array.from(document.querySelectorAll(attr));
+      return els;
+    }
+  };
+}
+
+// src/helpers/getLocatorBase.ts
+import { test as test2 } from "@playwright/test";
+
+// src/helpers/locatorSchema.interface.ts
+var GetByMethod = /* @__PURE__ */ ((GetByMethod2) => {
+  GetByMethod2["role"] = "role";
+  GetByMethod2["text"] = "text";
+  GetByMethod2["label"] = "label";
+  GetByMethod2["placeholder"] = "placeholder";
+  GetByMethod2["altText"] = "altText";
+  GetByMethod2["title"] = "title";
+  GetByMethod2["locator"] = "locator";
+  GetByMethod2["frameLocator"] = "frameLocator";
+  GetByMethod2["testId"] = "testId";
+  GetByMethod2["dataCy"] = "dataCy";
+  GetByMethod2["id"] = "id";
+  return GetByMethod2;
+})(GetByMethod || {});
+var locatorSchemaDummy = {
+  role: void 0,
+  roleOptions: {
+    checked: void 0,
+    disabled: void 0,
+    exact: void 0,
+    expanded: void 0,
+    includeHidden: void 0,
+    level: void 0,
+    name: void 0,
+    pressed: void 0,
+    selected: void 0
+  },
+  text: void 0,
+  textOptions: {
+    exact: void 0
+  },
+  label: void 0,
+  labelOptions: {
+    exact: void 0
+  },
+  placeholder: void 0,
+  placeholderOptions: {
+    exact: void 0
+  },
+  altText: void 0,
+  altTextOptions: {
+    exact: void 0
+  },
+  title: void 0,
+  titleOptions: {
+    exact: void 0
+  },
+  locator: void 0,
+  locatorOptions: {
+    has: void 0,
+    hasNot: void 0,
+    hasNotText: void 0,
+    hasText: void 0
+  },
+  frameLocator: void 0,
+  testId: void 0,
+  dataCy: void 0,
+  id: void 0,
+  locatorMethod: void 0,
+  locatorSchemaPath: void 0
+};
+function getLocatorSchemaDummy() {
+  return locatorSchemaDummy;
+}
+
+// src/helpers/getBy.locator.ts
+import "@playwright/test";
+var GetBy = class {
+  constructor(page, pwrl) {
+    this.page = page;
+    this.log = pwrl.getNewChildLogger(this.constructor.name);
+    this.methodMap = {
+      ["role" /* role */]: this.role,
+      ["text" /* text */]: this.text,
+      ["label" /* label */]: this.label,
+      ["placeholder" /* placeholder */]: this.placeholder,
+      ["altText" /* altText */]: this.altText,
+      ["title" /* title */]: this.title,
+      ["locator" /* locator */]: this.locator,
+      ["frameLocator" /* frameLocator */]: this.frameLocator,
+      ["testId" /* testId */]: this.testId,
+      ["dataCy" /* dataCy */]: this.dataCy,
+      ["id" /* id */]: this.id
+    };
+    this.subMethodMap = {
+      ["role" /* role */]: this.page.getByRole,
+      ["text" /* text */]: this.page.getByText,
+      ["label" /* label */]: this.page.getByLabel,
+      ["placeholder" /* placeholder */]: this.page.getByPlaceholder,
+      ["altText" /* altText */]: this.page.getByAltText,
+      ["title" /* title */]: this.page.getByTitle,
+      ["locator" /* locator */]: this.page.locator
+    };
+  }
+  log;
+  methodMap;
+  subMethodMap;
+  /**
+   * Retrieves a Playwright Locator based on the method specified in the LocatorSchema.
+   *
+   * @param locatorSchema The LocatorSchema object specifying the locator method and its parameters.
+   * @returns A promise that resolves to the appropriate Playwright Locator.
+   */
+  getLocator = (locatorSchema) => {
+    const methodName = locatorSchema.locatorMethod;
+    const method = this.methodMap[methodName];
+    if (method) {
+      return method(locatorSchema);
+    }
+    throw new Error(`Unsupported locator method: ${methodName}`);
+  };
+  getBy = (caller, locator) => {
+    const method = this.subMethodMap[caller];
+    if (!method) {
+      const errorText = "Error: unknown caller of method getBy(caller, locator) in getBy.locators.ts";
+      this.log.error(errorText);
+      throw new Error(errorText);
+    }
+    const initialPWLocator = locator[caller] ? method.call(this.page, locator[caller], locator?.[`${caller}Options`]) : null;
+    if (!initialPWLocator) {
+      const errorText = `Locator "${locator.locatorSchemaPath}" .${caller} is undefined.`;
+      this.log.warn(errorText);
+      throw new Error(errorText);
+    }
+    return initialPWLocator;
+  };
+  /**
+   * Creates a new method that returns a Playwright Locator using the specified method name.
+   *
+   * @param methodName The name of the method to use for getting the element.
+   * @returns An async function that takes a locator and returns a Playwright Locator.
+   */
+  createByMethod = (methodName) => {
+    return (locator) => {
+      return this.getBy(methodName, locator);
+    };
+  };
+  /**
+   *  Returns a {@link Locator} using the selectors 'role' (required) and 'roleOptions' (optional), from a {@link LocatorSchema} Object.
+   *
+   * @param locator - The locator.
+   * @returns - A promise that resolves to the {@link Locator}.
+   */
+  role = this.createByMethod("role" /* role */);
+  /**
+   * Returns a {@link Locator} using the selectors 'text' (required) and 'textOptions' (optional), from a {@link LocatorSchema} Object.
+   *
+   * @param locator - The locator.
+   * @returns - A promise that resolves to the {@link Locator}.
+   */
+  text = this.createByMethod("text" /* text */);
+  /**
+   * Returns a {@link Locator} using the selectors 'label' (required) and 'labelOptions' (optional), from a {@link LocatorSchema} Object.
+   *
+   * @param locator - The locator.
+   * @returns - A promise that resolves to the {@link Locator}.
+   */
+  label = this.createByMethod("label" /* label */);
+  /**
+   *  Returns a {@link Locator} using the selectors 'placeholder' (required) and 'placeholderOptions' (optional), from a {@link LocatorSchema} Object.
+   *
+   * @param locator - The locator.
+   * @returns - A promise that resolves to the {@link Locator}.
+   */
+  placeholder = this.createByMethod("placeholder" /* placeholder */);
+  /**
+   *  Returns a {@link Locator} using the selectors 'altText' (required) and 'altTextOptions' (optional), from a {@link LocatorSchema} Object.
+   *
+   * @param locator - The locator.
+   * @returns - A promise that resolves to the {@link Locator}.
+   */
+  altText = this.createByMethod("altText" /* altText */);
+  /**
+   *  Returns a {@link Locator} using the selectors 'title' (required) and 'titleOptions' (optional), from a {@link LocatorSchema} Object.
+   *
+   * @param locator - The locator.
+   * @returns - A promise that resolves to the {@link Locator}.
+   */
+  title = this.createByMethod("title" /* title */);
+  /**
+   *  Returns a {@link Locator} using the selectors 'locator' (required), from a {@link LocatorSchema} Object.
+   *
+   * @param locator - The locator.
+   * @returns - A promise that resolves to the {@link Locator}.
+   */
+  locator = this.createByMethod("locator" /* locator */);
+  /**
+   *  Returns a {@link FrameLocator} using the selector string 'frameLocator' (required), from a {@link LocatorSchema} Object.
+   *
+   * @param locatorSchema - Which contains the frameLocator selector.
+   * @returns A promise that resolves to the {@link FrameLocator}.
+   */
+  frameLocator = (locatorSchema) => {
+    const initialFrameLocator = locatorSchema.frameLocator ? this.page.frameLocator(locatorSchema.frameLocator) : null;
+    if (!initialFrameLocator) {
+      const errorText = `Locator "${locatorSchema.locatorSchemaPath}" .frameLocator is not defined.`;
+      this.log.warn(errorText);
+      throw new Error(errorText);
+    }
+    return initialFrameLocator;
+  };
+  /**
+   *  Returns a {@link Locator} using the selectors 'testId' (required), from a {@link LocatorSchema} Object.
+   *
+   * @param locator - The locator.
+   * @returns - A promise that resolves to the {@link Locator}.
+   */
+  testId = (locator) => {
+    const initialPWLocator = locator.testId ? this.page.getByTestId(locator.testId) : null;
+    if (!initialPWLocator) {
+      const errorText = `Locator "${locator.locatorSchemaPath}" .testId is not defined.`;
+      this.log.warn(`Locator "${locator.locatorSchemaPath}" .testId is not defined.`);
+      throw new Error(errorText);
+    }
+    return initialPWLocator;
+  };
+  /**
+   *  Returns a {@link Locator} using the selectors 'dataCy' (required), from a {@link LocatorSchema} Object.
+   *
+   * @param locator - The locator.
+   * @returns - A promise that resolves to the {@link Locator}.
+   */
+  dataCy = (locator) => {
+    let initialPWLocator = null;
+    if (locator.dataCy) {
+      initialPWLocator = locator.dataCy.startsWith("data-cy=") ? this.page.locator(locator.dataCy) : this.page.locator(`data-cy=${locator.dataCy}`);
+    } else {
+      const errorText = `Locator "${locator.locatorSchemaPath}" .dataCy is undefined.`;
+      this.log.warn(errorText);
+      throw new Error(errorText);
+    }
+    return initialPWLocator;
+  };
+  /**
+   *  Returns a {@link Locator} using the selectors 'id' (required), from a {@link LocatorSchema} Object.
+   *
+   * @param locator - The locator.
+   * @returns - A promise that resolves to the {@link Locator}.
+   */
+  id = (locator) => {
+    let initialPWLocator = null;
+    let selector;
+    let regexPattern;
+    if (!locator.id) {
+      const errorText = `Locator "${locator.locatorSchemaPath}" .id is not defined.`;
+      this.log.warn(errorText);
+      throw new Error(errorText);
+    }
+    if (typeof locator.id === "string") {
+      if (locator.id.startsWith("#")) {
+        selector = locator.id;
+      } else if (locator.id.startsWith("id=")) {
+        selector = `#${locator.id.slice("id=".length)}`;
+      } else {
+        selector = `#${locator.id}`;
+      }
+    } else if (locator.id instanceof RegExp) {
+      regexPattern = locator.id.source;
+      selector = `*[id^="${regexPattern}"]`;
+    } else {
+      const errorText = `Unsupported id type: ${typeof locator.id}`;
+      this.log.error(errorText);
+      throw new Error(errorText);
+    }
+    initialPWLocator = this.page.locator(selector);
+    return initialPWLocator;
+  };
+};
+
+// src/helpers/getLocatorBase.ts
+var GetLocatorBase = class {
+  /**
+   * Constructor for the GetLocatorBaseClass.
+   *
+   * @param {BasePage} pageObjectClass - The page object class to which the locator pertains.
+   * @param {PlaywrightReportLogger} log - The PlaywrightReportLogger child of the page object class.
+   */
+  constructor(pageObjectClass, log) {
+    this.pageObjectClass = pageObjectClass;
+    this.log = log;
+    this.locatorSchemas = /* @__PURE__ */ new Map();
+    this.getBy = new GetBy(this.pageObjectClass.page, this.log.getNewChildLogger("GetBy"));
+  }
+  getBy;
+  locatorSchemas;
+  /**
+   * test
+   * @param locatorSchemaPath
+   * @returns
+   */
+  getLocatorSchema(locatorSchemaPath) {
+    const pathIndexPairs = this.extractPathsFromSchema(locatorSchemaPath);
+    const schemasMap = this.collectDeepCopies(locatorSchemaPath, pathIndexPairs);
+    const locatorSchemaCopy = schemasMap.get(locatorSchemaPath);
+    locatorSchemaCopy.schemasMap = schemasMap;
+    const self = this;
+    locatorSchemaCopy.update = function(updates) {
+      self.applyUpdate(schemasMap, locatorSchemaPath, updates);
+      return this;
+    };
+    locatorSchemaCopy.updates = function(indexedUpdates) {
+      self.applyUpdates(schemasMap, pathIndexPairs, indexedUpdates);
+      return this;
+    };
+    locatorSchemaCopy.getNestedLocator = async (indices) => {
+      return await this.buildNestedLocator(locatorSchemaPath, indices, schemasMap);
+    };
+    locatorSchemaCopy.getLocator = async () => {
+      return this.getBy.getLocator(locatorSchemaCopy);
+    };
+    return locatorSchemaCopy;
+  }
+  collectDeepCopies(locatorSchemaPath, pathIndexPairs) {
+    const schemasMap = /* @__PURE__ */ new Map();
+    const fullSchemaFunc = this.safeGetLocatorSchema(locatorSchemaPath);
+    if (!fullSchemaFunc) {
+      const errorMessage = `LocatorSchema not found for path: '${locatorSchemaPath}'`;
+      this.log.error(errorMessage);
+      throw new Error(`[${this.pageObjectClass.pocName}] ${errorMessage}`);
+    }
+    schemasMap.set(locatorSchemaPath, structuredClone(fullSchemaFunc()));
+    for (const { path } of pathIndexPairs) {
+      if (path !== locatorSchemaPath) {
+        const schemaFunc = this.safeGetLocatorSchema(path);
+        if (schemaFunc) {
+          schemasMap.set(path, structuredClone(schemaFunc()));
+        }
+      }
+    }
+    return schemasMap;
+  }
+  applyUpdate(schemasMap, locatorSchemaPath, updateData) {
+    const schema = schemasMap.get(locatorSchemaPath);
+    if (schema) {
+      schemasMap.set(locatorSchemaPath, this.deepMerge(schema, updateData));
+    }
+  }
+  applyUpdates(schemasMap, pathIndexPairs, updatesData) {
+    Object.entries(updatesData).forEach(([index, updateAtIndex]) => {
+      const path = pathIndexPairs[parseInt(index)]?.path;
+      if (path && updateAtIndex) {
+        const schema = schemasMap.get(path);
+        if (schema) {
+          schemasMap.set(path, this.deepMerge(schema, updateAtIndex));
+        }
+      }
+    });
+  }
+  createLocatorSchema(schemaDetails, locatorSchemaPath) {
+    const schema = { ...schemaDetails, locatorSchemaPath };
+    return schema;
+  }
+  addSchema(locatorSchemaPath, schemaDetails) {
+    const newLocatorSchema = this.createLocatorSchema(schemaDetails, locatorSchemaPath);
+    const existingSchemaFunc = this.safeGetLocatorSchema(locatorSchemaPath);
+    if (existingSchemaFunc) {
+      const existingLocatorSchema = existingSchemaFunc();
+      throw new Error(
+        `[${this.pageObjectClass.pocName}] A LocatorSchema with the path '${locatorSchemaPath}' already exists. 
+Existing Schema: ${JSON.stringify(existingLocatorSchema, null, 2)} 
+Attempted to Add Schema: ${JSON.stringify(newLocatorSchema, null, 2)}`
+      );
+    }
+    this.locatorSchemas.set(locatorSchemaPath, () => newLocatorSchema);
+  }
+  safeGetLocatorSchema(path) {
+    return this.locatorSchemas.get(path);
+  }
+  extractPathsFromSchema = (paths, indices = {}) => {
+    const schemaParts = paths.split(".");
+    let cumulativePath = "";
+    return schemaParts.map((part, index) => {
+      cumulativePath = cumulativePath ? `${cumulativePath}.${part}` : part;
+      return {
+        path: cumulativePath,
+        index: indices[index] ?? void 0
+      };
+    });
+  };
+  /**
+   * logError is a utility function for logging errors with detailed debug information
+   * It re-throws the error after logging to ensure the test will fail.
+   */
+  logError = (error, locatorSchemaPath, currentLocator, currentPath, pathIndexPairs, nestedLocatorResults) => {
+    const errorDetails = {
+      error: error.message,
+      locatorSchemaPath,
+      currentPath,
+      pathIndexPairs: JSON.stringify(pathIndexPairs, null, 2),
+      currentLocatorDetails: currentLocator ? {
+        locatorString: currentLocator,
+        isNotNull: true
+      } : { isNotNull: false },
+      nestedLocatorResults
+    };
+    this.log.error(
+      "An error occurred during nested locator construction.\n",
+      "Error details:\n",
+      JSON.stringify(errorDetails, null, 2)
+    );
+    throw error;
+  };
+  // Merges 'source' into 'target', combining their properties into a new isolated object.
+  deepMerge(target, source) {
+    const merged = { ...target };
+    const dummySchema = getLocatorSchemaDummy();
+    if (typeof source === "object" && source !== null) {
+      Object.keys(source).filter((key) => key !== "locatorSchemaPath").forEach((key) => {
+        const targetKey = key;
+        const sourceKey = key;
+        if (!(key in dummySchema)) {
+          throw new Error(`Invalid property: '${key}' is not a valid property of LocatorSchema`);
+        }
+        const targetValue = merged[targetKey];
+        const sourceValue = source[sourceKey];
+        if (sourceValue !== void 0) {
+          if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+            merged[targetKey] = [...targetValue, ...sourceValue];
+          } else if (sourceValue instanceof RegExp) {
+            merged[targetKey] = new RegExp(sourceValue.source, sourceValue.flags);
+          } else if (typeof sourceValue === "object" && sourceValue !== null) {
+            merged[targetKey] = targetValue ? this.deepMerge(targetValue, sourceValue) : structuredClone(sourceValue);
+          } else {
+            merged[targetKey] = sourceValue;
+          }
+        }
+      });
+    }
+    return merged;
+  }
+  buildNestedLocator = async (locatorSchemaPath, indices = {}, schemasMap) => {
+    return await test2.step(`${this.pageObjectClass.pocName}: Build Nested Locator`, async () => {
+      const pathIndexPairs = this.extractPathsFromSchema(locatorSchemaPath, indices);
+      let currentLocator = null;
+      let currentIFrame = null;
+      const nestedLocatorResults = {
+        LocatorSchema: null,
+        // Initialize as an empty object
+        NestingSteps: []
+      };
+      for (const { path, index } of pathIndexPairs) {
+        const currentSchema = schemasMap.get(path);
+        if (!currentSchema)
+          continue;
+        try {
+          const nextLocator = this.getBy.getLocator(currentSchema);
+          if (currentLocator) {
+            currentLocator = currentLocator.locator(nextLocator);
+            if (index != null) {
+              currentLocator = currentLocator.nth(index);
+            }
+          } else {
+            currentLocator = nextLocator;
+            if (index != null) {
+              currentLocator = currentLocator.nth(index);
+            }
+          }
+          if (this.log.isLogLevelEnabled("debug")) {
+            if (!nestedLocatorResults.LocatorSchema) {
+              const safeGetLocatorSchema = this.safeGetLocatorSchema(locatorSchemaPath);
+              if (safeGetLocatorSchema !== void 0) {
+                nestedLocatorResults.LocatorSchema = safeGetLocatorSchema();
+              }
+            }
+            if (currentSchema.locatorMethod === "frameLocator" /* frameLocator */) {
+              if (!currentIFrame) {
+                currentIFrame = currentSchema.frameLocator;
+              }
+              if (currentIFrame != null && currentSchema.frameLocator != null) {
+                if (currentIFrame.endsWith(currentSchema.frameLocator)) {
+                  currentIFrame += ` -> ${currentSchema.frameLocator}`;
+                }
+              }
+            }
+            if (currentIFrame !== void 0) {
+              await this.evaluateCurrentLocator(currentLocator, nestedLocatorResults.NestingSteps, currentIFrame);
+            } else {
+              await this.evaluateCurrentLocator(currentLocator, nestedLocatorResults.NestingSteps, null);
+            }
+          }
+        } catch (error) {
+          this.logError(error, locatorSchemaPath, currentLocator, path, pathIndexPairs, nestedLocatorResults);
+          break;
+        }
+      }
+      if (!currentLocator) {
+        this.logError(
+          new Error(`Failed to build nested locator for path: ${locatorSchemaPath}`),
+          locatorSchemaPath,
+          currentLocator,
+          locatorSchemaPath,
+          pathIndexPairs
+        );
+      }
+      if (this.log.isLogLevelEnabled("debug")) {
+        this.log.debug("Nested locator evaluation results:", JSON.stringify(nestedLocatorResults, null, 2));
+      }
+      if (currentLocator != null) {
+        currentLocator.scrollIntoViewIfNeeded().catch(() => {
+        });
+        return currentLocator;
+      } else {
+        throw new Error(
+          `"currentLocator" is null or undefined. Failed to build nested locator for path: ${locatorSchemaPath}`
+        );
+      }
+    });
+  };
+  evaluateCurrentLocator = async (currentLocator, resultsArray, currentIFrame) => {
+    if (currentIFrame) {
+      resultsArray.push({
+        currentLocatorString: currentLocator,
+        currentIFrame,
+        Note: "iFrame locators evaluation not implemented"
+      });
+    } else {
+      const elementsData = await this.evaluateAndGetAttributes(currentLocator);
+      resultsArray.push({
+        currentLocatorString: currentLocator,
+        resolved: elementsData.length > 0,
+        elementCount: elementsData.length,
+        elementsResolvedTo: elementsData
+      });
+    }
+  };
+  /**
+   * Evaluates the Playwright locator, checking if it resolves to any elements, and retrieves element attributes.
+   *
+   * @param pwLocator - The Playwright locator to evaluate.
+   * @returns - A promise that resolves to an object containing the Playwright locator and an array of element attributes for each element located, or null if no elements are found.
+   */
+  evaluateAndGetAttributes = async (pwLocator) => {
+    return await pwLocator.evaluateAll(
+      (objects) => objects.map((el) => {
+        const elementAttributes = el.hasAttributes() ? Object.fromEntries(Array.from(el.attributes).map(({ name, value }) => [name, value])) : {};
+        return { tagName: el.tagName, attributes: elementAttributes };
+      })
+    );
+  };
+};
+
+// src/basePage.ts
+var selectorRegistered = false;
+var BasePage2 = class {
+  /** Provides Playwright page methods */
+  page;
+  /** Playwright TestInfo contains information about currently running test, available to any test function */
+  testInfo;
+  /** Selectors can be used to install custom selector engines.*/
+  selector;
+  /** The base URL of the Page Object Class */
+  baseUrl;
+  /** The URL path of the Page Object Class */
+  urlPath;
+  fullUrl;
+  /** The name of the Page Object Class */
+  pocName;
+  /** The Page Object Class' PlaywrightReportLogger instance, prefixed with its name. Log levels: debug, info, warn, and error.  */
+  log;
+  /** The SessionStorage class provides methods for setting and getting session storage data in Playwright.*/
+  sessionStorage;
+  locators;
+  constructor(page, testInfo, baseUrl, urlPath, pocName, pwrl) {
+    this.page = page;
+    this.testInfo = testInfo;
+    this.selector = selectors;
+    this.baseUrl = baseUrl;
+    this.urlPath = urlPath;
+    this.fullUrl = `${this.baseUrl}${this.urlPath}`;
+    this.pocName = pocName;
+    this.log = pwrl.getNewChildLogger(pocName);
+    this.locators = new GetLocatorBase(this, this.log.getNewChildLogger("GetLocator"));
+    this.initLocatorSchemas();
+    this.sessionStorage = new SessionStorage(this.page, this.pocName);
+    if (!selectorRegistered) {
+      selectors.register("data-cy", createCypressIdEngine);
+      selectorRegistered = true;
+    }
+  }
+  /**
+   * Asynchronously retrieves a nested locator based on the provided LocatorSchemaPath and optional indices per nested locator.
+   * Useful for interacting with elements in a structured or hierarchical manner, reducing the number of possible elements we can resolve to.
+   *
+   * The update and updates methods cannot be used with this method. Use the getLocatorSchema method instead.
+   *
+   * @param LocatorSchemaPathType locatorSchemaPath - The unique path identifier for the locator schema.
+   * @param indices - An optional object to specify the nth occurrence of each nested locator.
+   * @returns Promise<Locator> - A promise that resolves to the nested locator.
+   */
+  getNestedLocator = async (locatorSchemaPath, indices) => {
+    return await this.getLocatorSchema(locatorSchemaPath).getNestedLocator(indices);
+  };
+  /**
+   * Asynchronously retrieves the locator based on the current LocatorSchemaPath. This method does not perform nesting.
+   * Useful for directly interacting with an element based on its LocatorSchema.
+   *
+   * The update and updates methods cannot be used with this method. Use the getLocatorSchema method instead.
+   *
+   * @param LocatorSchemaPathType locatorSchemaPath - The unique path identifier for the locator schema.
+   * @returns Promise<Locator> - A promise that resolves to the nested locator.
+   */
+  getLocator = async (locatorSchemaPath) => {
+    return await this.getLocatorSchema(locatorSchemaPath).getLocator();
+  };
+  /**
+   * The "getLocatorSchema" method is used to retrieve a deep copy of a locator schema defined in the GetLocatorBase class.
+   * It enriches the returned schema with additional methods to handle updates and retrieval of deep copy locators.
+   *
+   * @param LocatorSchemaPathType locatorSchemaPath - The unique path identifier for the locator schema.
+   * @returns LocatorSchemaWithMethods - A deep copy of the locator schema with additional methods.
+   *
+   * Methods added to the returned LocatorSchemaWithMethods object:
+   *
+   * - update(updates: Partial<UpdatableLocatorSchemaProperties>):
+   *      Allows updating properties of the locator schema.
+   *      This method is used for modifying the current schema without affecting the original schema.
+   *      @param updates - An object with properties to be updated in the locator schema, omits the locatorSchemaPath parameter.
+   *      @returns LocatorSchemaWithMethods - The updated locator schema object.
+   *
+   * - updates(indexedUpdates: { [index: number]: Partial<UpdatableLocatorSchemaProperties> | null }):
+   *      Similar to update, but allows for indexed updates of any locator to be nested within the path.
+   *      This method is used for modifying the current schema without affecting the original schema
+   *      @param indexedUpdates - An object where keys represent index levels, and values are the updates at each level.
+   *      @returns LocatorSchemaWithMethods - The locator schema object with indexed updates.
+   *
+   * - getNestedLocator(indices?: { [key: number]: number | null }):
+   *      Asynchronously retrieves a nested locator based on the current schema and optional indices per nested locator.
+   *      Useful for interacting with elements in a structured or hierarchical manner.
+   *      @param indices - An optional object to specify the nth occurrence of each nested locator.
+   *      @returns Promise<Locator> - A promise that resolves to the nested locator.
+   *
+   * - getLocator():
+   *      Asynchronously retrieves the locator based on the current schema. This method does not consider nesting.
+   *      Useful for directly interacting with an element based on its schema.
+   *      @returns Promise<Locator> - A promise that resolves to the locator.
+   */
+  getLocatorSchema(locatorSchemaPath) {
+    return this.locators.getLocatorSchema(locatorSchemaPath);
+  }
+};
+
+// src/fixture/base.fixtures.ts
+import { test as base } from "@playwright/test";
+var test3 = base.extend({
+  log: async ({}, use, testInfo) => {
+    const contextName = "TestCase";
+    const sharedLogEntry = [];
+    let sharedLogLevel = testInfo.retry === 0 ? { current: "warn", initial: "warn" } : { current: "debug", initial: "debug" };
+    const log = new PlaywrightReportLogger(sharedLogLevel, sharedLogEntry, contextName);
+    await use(log);
+    log.attachLogsToTest(testInfo);
+  }
+});
+
+// src/api/baseApi.ts
+var BaseApi = class {
+  baseUrl;
+  apiName;
+  log;
+  request;
+  constructor(baseUrl, apiName, context, pwrl) {
+    this.baseUrl = baseUrl;
+    this.apiName = apiName;
+    this.log = pwrl.getNewChildLogger(apiName);
+    this.request = context;
+  }
+};
+export {
+  GetByMethod,
+  BasePage2 as POMWright,
+  BaseApi as POMWrightApi,
+  GetLocatorBase as POMWrightGetLocatorBase,
+  PlaywrightReportLogger as POMWrightLogger,
+  test3 as POMWrightTestFixture
+};