@intuned/browser-dev 2.2.3-unify-sdks.20

package/dist/helpers/utils/index.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "GatewayFactory", {
+  enumerable: true,
+  get: function () {
+    return _factory.GatewayFactory;
+  }
+});
+Object.defineProperty(exports, "compressStringSpaces", {
+  enumerable: true,
+  get: function () {
+    return _extractionHelpers.compressStringSpaces;
+  }
+});
+Object.defineProperty(exports, "ensureBrowserScripts", {
+  enumerable: true,
+  get: function () {
+    return _ensureBrowserScripts.ensureBrowserScripts;
+  }
+});
+Object.defineProperty(exports, "getS3Client", {
+  enumerable: true,
+  get: function () {
+    return _getS3Client.getS3Client;
+  }
+});
+Object.defineProperty(exports, "getSimplifiedHtml", {
+  enumerable: true,
+  get: function () {
+    return _getSimplifiedHtml.getSimplifiedHtml;
+  }
+});
+Object.defineProperty(exports, "isDownload", {
+  enumerable: true,
+  get: function () {
+    return _isDownload.isDownload;
+  }
+});
+Object.defineProperty(exports, "isGenerateCodeMode", {
+  enumerable: true,
+  get: function () {
+    return _isGenerateCodeMode.isGenerateCodeMode;
+  }
+});
+Object.defineProperty(exports, "isLocator", {
+  enumerable: true,
+  get: function () {
+    return _isLocator.isLocator;
+  }
+});
+Object.defineProperty(exports, "selectLocatorsUsingXpath", {
+  enumerable: true,
+  get: function () {
+    return _extractionHelpers.selectLocatorsUsingXpath;
+  }
+});
+Object.defineProperty(exports, "splitContainerIntoListLocators", {
+  enumerable: true,
+  get: function () {
+    return _extractionHelpers.splitContainerIntoListLocators;
+  }
+});
+var _isLocator = require("./isLocator");
+var _isGenerateCodeMode = require("./isGenerateCodeMode");
+var _factory = require("../../intunedServices/ApiGateway/factory");
+var _getS3Client = require("./getS3Client");
+var _isDownload = require("./isDownload");
+var _ensureBrowserScripts = require("../../common/ensureBrowserScripts");
+var _extractionHelpers = require("../../common/extractionHelpers");
+var _getSimplifiedHtml = require("../../common/getSimplifiedHtml");

package/dist/helpers/utils/isDownload.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDownload = isDownload;
+function isDownload(value) {
+  const anyValue = value;
+  return anyValue && typeof anyValue.delete === "function" && typeof anyValue.path === "function" && typeof anyValue.suggestedFilename === "function";
+}

package/dist/helpers/utils/isGenerateCodeMode.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isGenerateCodeMode = isGenerateCodeMode;
+function isGenerateCodeMode() {
+  return process.env.MODE === "generate_code";
+}

package/dist/helpers/utils/isLocator.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isLocator = isLocator;
+function isLocator(locator) {
+  return "count" in locator && typeof locator.count === "function";
+}

package/dist/helpers/utils/jwtTokenManager.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "backendFunctionsTokenManager", {
+  enumerable: true,
+  get: function () {
+    return _jwtTokenManager.backendFunctionsTokenManager;
+  }
+});
+Object.defineProperty(exports, "callBackendFunctionWithToken", {
+  enumerable: true,
+  get: function () {
+    return _jwtTokenManager.callBackendFunctionWithToken;
+  }
+});
+var _jwtTokenManager = require("@intuned/runtime/dist/common/jwtTokenManager");

package/dist/helpers/validateDataUsingSchema.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanData = cleanData;
+exports.validateDataUsingSchema = void 0;
+var _ajv = _interopRequireDefault(require("ajv"));
+var _types = require("./types");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const ajv = new _ajv.default({
+  strict: false,
+  removeAdditional: false
+});
+ajv.addKeyword({
+  keyword: "x-custom-type",
+  schemaType: "string",
+  compile: () => () => true
+});
+const customTypeRegistry = new _types.CustomTypeRegistry();
+function preprocessSchema(schema) {
+  if (typeof schema !== "object" || schema === null) {
+    return schema;
+  }
+  if (Array.isArray(schema)) {
+    return schema.map(item => preprocessSchema(item));
+  }
+  const processedSchema = {
+    ...schema
+  };
+  if (processedSchema.type && typeof processedSchema.type === "string") {
+    if (customTypeRegistry.isCustomType(processedSchema.type)) {
+      return {
+        type: "object",
+        additionalProperties: true,
+        "x-custom-type": processedSchema.type
+      };
+    }
+  }
+  for (const key in processedSchema) {
+    if (key === "properties" && typeof processedSchema[key] === "object") {
+      const newProperties = {};
+      for (const propKey in processedSchema[key]) {
+        newProperties[propKey] = preprocessSchema(processedSchema[key][propKey]);
+      }
+      processedSchema[key] = newProperties;
+    } else if (key === "items") {
+      processedSchema[key] = preprocessSchema(processedSchema[key]);
+    } else if (typeof processedSchema[key] === "object") {
+      processedSchema[key] = preprocessSchema(processedSchema[key]);
+    }
+  }
+  return processedSchema;
+}
+function validateCustomTypes(data, schema, path = "root") {
+  const errors = [];
+  if (typeof schema !== "object" || schema === null) {
+    return errors;
+  }
+  if (schema["x-custom-type"]) {
+    const customType = schema["x-custom-type"];
+    if (!customTypeRegistry.validate(customType, data)) {
+      errors.push(`${path} does not match custom type '${customType}'`);
+    }
+    return errors;
+  }
+  if (schema.type === "object" && schema.properties && typeof data === "object" && data !== null && !Array.isArray(data)) {
+    for (const [propKey, propSchema] of Object.entries(schema.properties)) {
+      if (Object.prototype.hasOwnProperty.call(data, propKey)) {
+        const propPath = path === "root" ? propKey : `${path}.${propKey}`;
+        errors.push(...validateCustomTypes(data[propKey], propSchema, propPath));
+      }
+    }
+  }
+  if (schema.type === "array" && schema.items && Array.isArray(data)) {
+    data.forEach((item, index) => {
+      const itemPath = `${path}[${index}]`;
+      errors.push(...validateCustomTypes(item, schema.items, itemPath));
+    });
+  }
+  return errors;
+}
+function cleanData(data) {
+  if (Array.isArray(data)) {
+    return data.map(item => cleanData(item));
+  } else if (data !== null && typeof data === "object") {
+    const cleaned = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (value !== "" && value !== null && value !== undefined) {
+        cleaned[key] = cleanData(value);
+      }
+    }
+    return cleaned;
+  }
+  return data;
+}
+const validateDataUsingSchema = async input => {
+  const {
+    data,
+    schema
+  } = input;
+  const cleanedData = cleanData(data);
+  const processedSchema = preprocessSchema(schema);
+  const validate = ajv.compile(processedSchema);
+  const valid = validate(cleanedData);
+  const errors = [];
+  if (!valid) {
+    var _validate$errors;
+    const schemaErrors = ((_validate$errors = validate.errors) === null || _validate$errors === void 0 ? void 0 : _validate$errors.map(err => `${err.instancePath || "root"} ${err.message}`).filter(error => !error.includes("x-custom-type"))) || [];
+    errors.push(...schemaErrors);
+  }
+  const customTypeErrors = validateCustomTypes(cleanedData, processedSchema);
+  errors.push(...customTypeErrors);
+  if (errors.length > 0) {
+    const errorMessage = errors.join(", ") || "Unknown validation error";
+    throw new _types.ValidationError(`Data validation failed: ${errorMessage}`, data);
+  }
+};
+exports.validateDataUsingSchema = validateDataUsingSchema;

package/dist/helpers/waitForDomSettled.js

@@ -0,0 +1,182 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.waitForDomSettled = waitForDomSettled;
+var _locatorHelpers = require("../common/locatorHelpers");
+function waitForDomSettled(funcOrOptions) {
+  if (funcOrOptions && typeof funcOrOptions === "object" && "source" in funcOrOptions) {
+    const {
+      source,
+      func,
+      settleDuration = 0.5,
+      timeoutS = 30.0
+    } = funcOrOptions;
+    if (func && source) {
+      return waitForDomSettledCore({
+        source,
+        func,
+        settleDuration,
+        timeoutS
+      });
+    } else if (source) {
+      return waitForDomSettledOriginal({
+        source,
+        settleDuration,
+        timeoutS
+      });
+    }
+  }
+  if (funcOrOptions && typeof funcOrOptions === "function") {
+    const func = funcOrOptions;
+    const wrapper = async (...args) => {
+      let sourceObj = null;
+      for (const arg of args) {
+        if ((0, _locatorHelpers.isPage)(arg) || arg && typeof arg === "object" && "page" in arg) {
+          sourceObj = arg;
+          break;
+        }
+      }
+      if (!sourceObj) {
+        throw new Error("No Page or Locator object found in function arguments");
+      }
+      const funcWithArgs = async () => {
+        return await func(...args);
+      };
+      return await waitForDomSettledCore({
+        source: sourceObj,
+        func: funcWithArgs,
+        settleDuration: 0.5,
+        timeoutS: 30.0
+      });
+    };
+    return wrapper;
+  }
+  const options = funcOrOptions || {};
+  const {
+    settleDuration = 0.5,
+    timeoutS = 30.0
+  } = options;
+  return func => {
+    const wrapper = async (...args) => {
+      let sourceObj = null;
+      for (const arg of args) {
+        if ((0, _locatorHelpers.isPage)(arg) || arg && typeof arg === "object" && "page" in arg) {
+          sourceObj = arg;
+          break;
+        }
+      }
+      if (!sourceObj) {
+        throw new Error("No Page or Locator object found in function arguments");
+      }
+      const funcWithArgs = async () => {
+        return await func(...args);
+      };
+      return await waitForDomSettledCore({
+        source: sourceObj,
+        func: funcWithArgs,
+        settleDuration,
+        timeoutS
+      });
+    };
+    return wrapper;
+  };
+}
+async function waitForDomSettledCore(options) {
+  const {
+    source,
+    func,
+    settleDuration = 0.5,
+    timeoutS = 30.0
+  } = options;
+  console.debug(`Source object: ${source}`);
+  const result = await func();
+  await waitForDomSettledOriginal({
+    source,
+    settleDuration,
+    timeoutS
+  });
+  return result;
+}
+async function waitForDomSettledOriginal(options) {
+  const {
+    source,
+    settleDuration = 0.5,
+    timeoutS = 30.0
+  } = options;
+  const settleDurationMs = Math.floor(settleDuration * 1000);
+  const timeoutMs = Math.floor(timeoutS * 1000);
+  let pageObj;
+  let elementHandle;
+  if (!(0, _locatorHelpers.isPage)(source)) {
+    pageObj = source.page();
+    const handle = await source.elementHandle();
+    if (!handle) {
+      console.warn("Could not get element handle from locator");
+      return false;
+    }
+    elementHandle = handle;
+  } else if ((0, _locatorHelpers.isPage)(source)) {
+    pageObj = source;
+    elementHandle = await pageObj.evaluateHandle("document.documentElement");
+  } else {
+    throw new Error("Invalid state");
+  }
+  try {
+    const result = await pageObj.evaluate(({
+      target,
+      settleDurationMs,
+      timeoutMs
+    }) => {
+      return new Promise((resolve, reject) => {
+        if (!target) {
+          reject(new Error("Target element not found"));
+          return;
+        }
+        let mutationTimer;
+        let settled = false;
+        const observer = new MutationObserver(() => {
+          if (settled) return;
+          clearTimeout(mutationTimer);
+          mutationTimer = window.setTimeout(() => {
+            settled = true;
+            observer.disconnect();
+            clearTimeout(timeoutTimer);
+            resolve(true);
+          }, settleDurationMs);
+        });
+        const timeoutTimer = window.setTimeout(() => {
+          settled = true;
+          observer.disconnect();
+          clearTimeout(mutationTimer);
+          reject(new Error(`DOM timed out settling after ${timeoutMs} ms`));
+        }, timeoutMs);
+        observer.observe(target, {
+          childList: true,
+          subtree: true,
+          attributes: true,
+          characterData: true
+        });
+        mutationTimer = window.setTimeout(() => {
+          settled = true;
+          observer.disconnect();
+          clearTimeout(timeoutTimer);
+          resolve(true);
+        }, settleDurationMs);
+      });
+    }, {
+      target: elementHandle,
+      settleDurationMs,
+      timeoutMs
+    });
+    return result;
+  } catch (error) {
+    console.warn(`DOM settlement detection failed: ${error}`);
+    return false;
+  } finally {
+    if ((0, _locatorHelpers.isPage)(source) && elementHandle) {
+      await elementHandle.dispose();
+    }
+  }
+}

package/dist/helpers/waitForNetworkIdle.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.waitForNetworkIdle = waitForNetworkIdle;
+var _locatorHelpers = require("../common/locatorHelpers");
+function waitForNetworkIdle(funcOrOptions) {
+  if (funcOrOptions && typeof funcOrOptions === "object" && "page" in funcOrOptions) {
+    const {
+      page,
+      func,
+      timeoutInMs = 30000,
+      maxInflightRequests = 0
+    } = funcOrOptions;
+    if (!func) {
+      throw new Error("func parameter is required when page is provided");
+    }
+    if (!page) {
+      throw new Error("page parameter is required");
+    }
+    return waitForNetworkIdleCore({
+      page,
+      func,
+      timeoutInMs,
+      maxInflightRequests
+    });
+  }
+  if (funcOrOptions && typeof funcOrOptions === "function" && funcOrOptions.__self__ && funcOrOptions.__self__.page) {
+    const extractedPage = funcOrOptions.__self__.page;
+    if ((0, _locatorHelpers.isPage)(extractedPage)) {
+      return waitForNetworkIdleCore({
+        page: extractedPage,
+        func: funcOrOptions,
+        timeoutInMs: 30000,
+        maxInflightRequests: 0
+      });
+    }
+  }
+  if (funcOrOptions && typeof funcOrOptions === "function") {
+    const func = funcOrOptions;
+    const wrapper = async (...args) => {
+      let pageObj = null;
+      for (const arg of args) {
+        if ((0, _locatorHelpers.isPage)(arg)) {
+          pageObj = arg;
+          break;
+        }
+      }
+      if (!pageObj && args.length > 0 && typeof args[args.length - 1] === "object") {
+        const lastArg = args[args.length - 1];
+        if (lastArg && "page" in lastArg && (0, _locatorHelpers.isPage)(lastArg.page)) {
+          pageObj = lastArg.page;
+        }
+      }
+      if (!pageObj) {
+        console.error("No Page object found in function arguments");
+        throw new Error("No Page object found in function arguments");
+      }
+      const funcWithArgs = async () => {
+        return await func(...args);
+      };
+      return await waitForNetworkIdleCore({
+        page: pageObj,
+        func: funcWithArgs,
+        timeoutInMs: 30000,
+        maxInflightRequests: 0
+      });
+    };
+    return wrapper;
+  }
+  const options = funcOrOptions || {};
+  const {
+    timeoutInMs = 30000,
+    maxInflightRequests = 0
+  } = options;
+  return func => {
+    const wrapper = async (...args) => {
+      let pageObj = null;
+      for (const arg of args) {
+        if ((0, _locatorHelpers.isPage)(arg)) {
+          pageObj = arg;
+          break;
+        }
+      }
+      if (!pageObj && args.length > 0 && typeof args[args.length - 1] === "object") {
+        const lastArg = args[args.length - 1];
+        if (lastArg && "page" in lastArg && (0, _locatorHelpers.isPage)(lastArg.page)) {
+          pageObj = lastArg.page;
+        }
+      }
+      if (!pageObj) {
+        console.error("No Page object found in function arguments");
+        throw new Error("No Page object found in function arguments");
+      }
+      const funcWithArgs = async () => {
+        return await func(...args);
+      };
+      return await waitForNetworkIdleCore({
+        page: pageObj,
+        func: funcWithArgs,
+        timeoutInMs,
+        maxInflightRequests
+      });
+    };
+    return wrapper;
+  };
+}
+async function waitForNetworkIdleCore({
+  page,
+  func,
+  timeoutInMs = 30000,
+  maxInflightRequests = 0
+}) {
+  console.debug(`Page object: ${page}`);
+  let networkSettledResolve = null;
+  let networkSettledPromise = new Promise(resolve => {
+    networkSettledResolve = resolve;
+  });
+  let isTimeout = false;
+  let requestCounter = 0;
+  let actionDone = false;
+  const pendingRequests = new Set();
+  const maybeSettle = async () => {
+    if (actionDone && requestCounter <= maxInflightRequests) {
+      var _networkSettledResolv;
+      (_networkSettledResolv = networkSettledResolve) === null || _networkSettledResolv === void 0 || _networkSettledResolv();
+    }
+  };
+  const onRequest = request => {
+    requestCounter++;
+    pendingRequests.add(request);
+  };
+  const onRequestDone = async request => {
+    await new Promise(resolve => setTimeout(resolve, 0));
+    if (pendingRequests.has(request)) {
+      requestCounter--;
+      pendingRequests.delete(request);
+      await maybeSettle();
+    }
+  };
+  const handleRequestFinished = async req => {
+    await onRequestDone(req);
+  };
+  const handleRequestFailed = async req => {
+    await onRequestDone(req);
+  };
+  page.on("request", onRequest);
+  page.on("requestfinished", handleRequestFinished);
+  page.on("requestfailed", handleRequestFailed);
+  const timeoutPromise = new Promise(resolve => {
+    setTimeout(() => {
+      var _networkSettledResolv2;
+      console.log("waiting for network to settle timed out");
+      isTimeout = true;
+      (_networkSettledResolv2 = networkSettledResolve) === null || _networkSettledResolv2 === void 0 || _networkSettledResolv2();
+      resolve();
+    }, timeoutInMs);
+  });
+  try {
+    const result = await func();
+    actionDone = true;
+    await new Promise(resolve => setTimeout(resolve, 500));
+    await maybeSettle();
+    console.log("-- Start waiting for network to settle... --");
+    let shouldContinue = true;
+    while (shouldContinue) {
+      console.log(`waiting for network to settle, ${requestCounter} requests pending`);
+      await Promise.race([networkSettledPromise, timeoutPromise]);
+      await new Promise(resolve => setTimeout(resolve, 500));
+      if (actionDone && requestCounter <= maxInflightRequests || isTimeout) {
+        if (isTimeout) {
+          console.log("Exiting due to timeout, network did not settle");
+        } else {
+          console.log("network settled, no pending requests");
+        }
+        shouldContinue = false;
+      } else {
+        networkSettledPromise = new Promise(resolve => {
+          networkSettledResolve = resolve;
+        });
+      }
+    }
+    console.log("-- Finished waiting for network to settle --");
+    return result;
+  } finally {
+    page.off("request", onRequest);
+    page.off("requestfinished", handleRequestFinished);
+    page.off("requestfailed", handleRequestFailed);
+  }
+}

package/dist/index.d.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "downloadFile", {
+  enumerable: true,
+  get: function () {
+    return _downloadFile.downloadFile;
+  }
+});
+Object.defineProperty(exports, "filterEmptyValues", {
+  enumerable: true,
+  get: function () {
+    return _filterEmptyValues.filterEmptyValues;
+  }
+});
+Object.defineProperty(exports, "goToUrl", {
+  enumerable: true,
+  get: function () {
+    return _gotoUrl.goToUrl;
+  }
+});
+Object.defineProperty(exports, "processDate", {
+  enumerable: true,
+  get: function () {
+    return _processDate.processDate;
+  }
+});
+Object.defineProperty(exports, "resolveUrl", {
+  enumerable: true,
+  get: function () {
+    return _resolveUrl.resolveUrl;
+  }
+});
+Object.defineProperty(exports, "sanitizeHtml", {
+  enumerable: true,
+  get: function () {
+    return _sanitizeHtml.sanitizeHtml;
+  }
+});
+Object.defineProperty(exports, "saveFileToS3", {
+  enumerable: true,
+  get: function () {
+    return _saveFileToS.saveFileToS3;
+  }
+});
+Object.defineProperty(exports, "uploadFileToS3", {
+  enumerable: true,
+  get: function () {
+    return _uploadFileToS.uploadFileToS3;
+  }
+});
+Object.defineProperty(exports, "validateDataUsingSchema", {
+  enumerable: true,
+  get: function () {
+    return _validateDataUsingSchema.validateDataUsingSchema;
+  }
+});
+Object.defineProperty(exports, "waitForDomSettled", {
+  enumerable: true,
+  get: function () {
+    return _waitForDomSettled.waitForDomSettled;
+  }
+});
+Object.defineProperty(exports, "waitForNetworkIdle", {
+  enumerable: true,
+  get: function () {
+    return _waitForNetworkIdle.waitForNetworkIdle;
+  }
+});
+var _sanitizeHtml = require("./helpers/sanitizeHtml");
+var _downloadFile = require("./helpers/downloadFile");
+var _saveFileToS = require("./helpers/saveFileToS3");
+var _filterEmptyValues = require("./helpers/filterEmptyValues");
+var _gotoUrl = require("./helpers/gotoUrl");
+var _processDate = require("./helpers/processDate");
+var _resolveUrl = require("./helpers/resolveUrl");
+var _uploadFileToS = require("./helpers/uploadFileToS3");
+var _validateDataUsingSchema = require("./helpers/validateDataUsingSchema");
+var _waitForDomSettled = require("./helpers/waitForDomSettled");
+var _waitForNetworkIdle = require("./helpers/waitForNetworkIdle");