@intuned/browser-dev 2.2.3-test-build.0

package/dist/helpers/index.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AttachmentValidator", {
+  enumerable: true,
+  get: function () {
+    return _types.AttachmentValidator;
+  }
+});
+Object.defineProperty(exports, "CustomTypeRegistry", {
+  enumerable: true,
+  get: function () {
+    return _types.CustomTypeRegistry;
+  }
+});
+Object.defineProperty(exports, "CustomTypeValidator", {
+  enumerable: true,
+  get: function () {
+    return _types.CustomTypeValidator;
+  }
+});
+Object.defineProperty(exports, "clickButtonAndWait", {
+  enumerable: true,
+  get: function () {
+    return _clickUntilExhausted.clickButtonAndWait;
+  }
+});
+Object.defineProperty(exports, "clickButtonUntilNoChange", {
+  enumerable: true,
+  get: function () {
+    return _clickUntilExhausted.clickButtonUntilNoChange;
+  }
+});
+Object.defineProperty(exports, "downloadFile", {
+  enumerable: true,
+  get: function () {
+    return _downloadFile.downloadFile;
+  }
+});
+Object.defineProperty(exports, "extractMarkdown", {
+  enumerable: true,
+  get: function () {
+    return _extractMarkdown.extractMarkdown;
+  }
+});
+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, "scrollToLoadContent", {
+  enumerable: true,
+  get: function () {
+    return _scrollToLoadContent.scrollToLoadContent;
+  }
+});
+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, "withNetworkSettledWait", {
+  enumerable: true,
+  get: function () {
+    return _withNetworkSettledWait.withNetworkSettledWait;
+  }
+});
+var _gotoUrl = require("./gotoUrl");
+var _uploadFileToS = require("./uploadFileToS3");
+var _withNetworkSettledWait = require("./withNetworkSettledWait");
+var _validateDataUsingSchema = require("./validateDataUsingSchema");
+var _types = require("./types");
+var _downloadFile = require("./downloadFile");
+var _filterEmptyValues = require("./filterEmptyValues");
+var _processDate = require("./processDate");
+var _extractMarkdown = require("./extractMarkdown");
+var _sanitizeHtml = require("./sanitizeHtml");
+var _saveFileToS = require("./saveFileToS3");
+var _resolveUrl = require("./resolveUrl");
+var _waitForDomSettled = require("./waitForDomSettled");
+var _scrollToLoadContent = require("./scrollToLoadContent");
+var _clickUntilExhausted = require("./clickUntilExhausted");

package/dist/helpers/processDate.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.processDate = void 0;
+var _dateFns = require("date-fns");
+var chrono = _interopRequireWildcard(require("chrono-node"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const processDate = input => {
+  const {
+    date
+  } = input;
+  try {
+    const cleaned = date.replace(" - ", " ");
+    const results = chrono.parse(cleaned);
+    if (results.length > 0) {
+      return (0, _dateFns.startOfDay)(results[0].start.date());
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+};
+exports.processDate = processDate;

package/dist/helpers/resolveUrl.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveUrl = void 0;
+const resolveUrl = async options => {
+  if (typeof options.url === "object" && options.url !== null && "evaluate" in options.url) {
+    if (options.baseUrl !== undefined || options.page !== undefined) {
+      throw new Error("baseUrl and page parameters are not needed when url is Locator");
+    }
+    const elementName = await options.url.evaluate(element => element.tagName);
+    if (elementName !== "A") {
+      throw new Error(`Expected an anchor element, got ${elementName}`);
+    }
+    return await options.url.evaluate(element => element.href);
+  } else if (typeof options.url === "string") {
+    if (options.baseUrl !== undefined && options.page !== undefined) {
+      throw new Error("Cannot provide both 'baseUrl' and 'page' parameters. Please provide only one.");
+    }
+    if (options.baseUrl === undefined && options.page === undefined) {
+      throw new Error("Must provide either 'baseUrl' or 'page' parameter when url is a string.");
+    }
+    const relativeUrl = options.url;
+    let baseUrl;
+    if (options.page !== undefined) {
+      const parsedUrl = new URL(options.page.url());
+      baseUrl = `${parsedUrl.protocol}//${parsedUrl.host}`;
+    } else {
+      baseUrl = options.baseUrl;
+    }
+    try {
+      new URL(relativeUrl);
+      return relativeUrl;
+    } catch {}
+    const fullUrl = new URL(relativeUrl, baseUrl);
+    const {
+      protocol,
+      hostname,
+      port,
+      pathname,
+      search,
+      hash
+    } = fullUrl;
+    const encodedPath = encodeURI(decodeURI(pathname));
+    let encodedQuery = "";
+    if (search) {
+      const queryString = search.substring(1);
+      const params = queryString.split("&").map(param => {
+        const [key, value = ""] = param.split("=");
+        const encodedKey = encodeURIComponent(decodeURIComponent(key));
+        const encodedValue = value ? encodeURIComponent(decodeURIComponent(value)) : "";
+        return encodedValue ? `${encodedKey}=${encodedValue}` : encodedKey;
+      });
+      encodedQuery = params.length > 0 ? `?${params.join("&")}` : "";
+    }
+    const portStr = port ? `:${port}` : "";
+    const encodedFullUrl = `${protocol}//${hostname}${portStr}${encodedPath}${encodedQuery}${hash}`;
+    return encodedFullUrl;
+  } else {
+    throw new TypeError(`url must be string, Locator, got ${typeof options.url}`);
+  }
+};
+exports.resolveUrl = resolveUrl;

package/dist/helpers/sanitizeHtml.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sanitizeHtml = void 0;
+var _nodeHtmlParser = require("node-html-parser");
+var _isGenerateCodeMode = require("./utils/isGenerateCodeMode");
+const sanitizeHtml = (options = {
+  html: ""
+}) => {
+  const {
+    html,
+    removeScripts = true,
+    removeStyles = true,
+    removeSvgs = true,
+    removeComments = true,
+    removeLongAttributes = true,
+    maxAttributeLength = 500,
+    preserveAttributes = ["class", "src"],
+    removeEmptyTags = true,
+    preserveEmptyTags = ["img"],
+    minifyWhitespace = true
+  } = options;
+  const root = (0, _nodeHtmlParser.parse)(html, {
+    comment: !removeComments
+  });
+  const elementsToRemove = [];
+  if (removeScripts) elementsToRemove.push("script");
+  if (removeStyles) elementsToRemove.push("style");
+  if (removeSvgs) elementsToRemove.push("svg");
+  if (elementsToRemove.length > 0) {
+    root.querySelectorAll(elementsToRemove.join(", ")).forEach(el => el.remove());
+  }
+  if (removeComments) {}
+  if (removeLongAttributes) {
+    root.querySelectorAll("*").forEach(element => {
+      if (element instanceof _nodeHtmlParser.HTMLElement) {
+        const attributes = element.attributes;
+        Object.keys(attributes).forEach(attr => {
+          if (preserveAttributes.includes(attr)) {
+            return;
+          }
+          if (attr === "style" || attributes[attr].length > maxAttributeLength) {
+            element.removeAttribute(attr);
+          }
+        });
+      }
+    });
+  }
+  if (removeEmptyTags && !(0, _isGenerateCodeMode.isGenerateCodeMode)()) {
+    root.querySelectorAll("*").forEach(element => {
+      if (element instanceof _nodeHtmlParser.HTMLElement) {
+        const tagName = element.tagName.toLowerCase();
+        if (preserveEmptyTags.includes(tagName)) {
+          return;
+        }
+        const textContent = element.text.trim();
+        const hasChildElements = element.childNodes.length > 0;
+        if (textContent.length === 0 && !hasChildElements) {
+          element.remove();
+        }
+      }
+    });
+  }
+  let sanitizedHtml = root.toString();
+  if (minifyWhitespace) {
+    sanitizedHtml = sanitizedHtml.replace(/>\s*</g, "><");
+    sanitizedHtml = sanitizedHtml.replace(/\n\s*\n/g, "\n");
+    sanitizedHtml = sanitizedHtml.replace(/\s+/g, " ");
+  }
+  return sanitizedHtml;
+};
+exports.sanitizeHtml = sanitizeHtml;

package/dist/helpers/saveFileToS3.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.saveFileToS3 = void 0;
+var _downloadFile = require("./downloadFile");
+var _uploadFileToS = require("./uploadFileToS3");
+var _isGenerateCodeMode = require("./utils/isGenerateCodeMode");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const loadRuntime = async () => {
+  try {
+    const runtime = await Promise.resolve().then(() => _interopRequireWildcard(require("@intuned/runtime")));
+    return runtime.extendTimeout;
+  } catch {
+    return () => {
+      return;
+    };
+  }
+};
+const saveFileToS3 = async input => {
+  const {
+    page,
+    trigger,
+    timeoutInMs,
+    configs,
+    fileNameOverride,
+    contentType
+  } = input;
+  if (!page || typeof page.goto !== "function") {
+    throw new Error("page must be a playwright Page object");
+  }
+  const download = await (0, _downloadFile.downloadFile)({
+    page,
+    trigger,
+    timeoutInMs
+  });
+  if (!(0, _isGenerateCodeMode.isGenerateCodeMode)()) {
+    const extendTimeout = await loadRuntime();
+    extendTimeout();
+  }
+  const uploaded = await (0, _uploadFileToS.uploadFileToS3)({
+    file: download,
+    configs,
+    fileNameOverride,
+    contentType
+  });
+  return uploaded;
+};
+exports.saveFileToS3 = saveFileToS3;

package/dist/helpers/scrollToLoadContent.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scrollToLoadContent = exports.scrollToBottom = void 0;
+var _locatorHelpers = require("../common/locatorHelpers");
+var _withNetworkSettledWait = require("./withNetworkSettledWait");
+const scrollToBottomInternal = async (page, scrollable) => {
+  if ((0, _locatorHelpers.isPage)(scrollable)) {
+    const newHeight = await scrollable.evaluate(() => {
+      window.scrollTo(0, document.body.scrollHeight);
+      return document.body.scrollHeight;
+    });
+    return newHeight;
+  } else {
+    const newHeight = await scrollable.evaluate(element => {
+      element.scrollTop = element.scrollHeight;
+      return element.scrollHeight;
+    });
+    return newHeight;
+  }
+};
+const scrollToBottom = async scrollable => {
+  const page = (0, _locatorHelpers.isPage)(scrollable) ? scrollable : scrollable.page();
+  return await (0, _withNetworkSettledWait.withNetworkSettledWait)(async () => scrollToBottomInternal(page, scrollable), {
+    page,
+    maxInflightRequests: 0,
+    timeoutInMs: 10000
+  });
+};
+exports.scrollToBottom = scrollToBottom;
+const scrollToLoadContent = async input => {
+  const {
+    onScrollProgress = undefined,
+    maxScrolls = 50,
+    delayInMs = 100,
+    minHeightChange = 100
+  } = input || {};
+  const scrollable = input.source;
+  if (!scrollable) {
+    throw new Error("scrollable is required");
+  }
+  let previousHeight = -1;
+  let scrollCount = 0;
+  while (scrollCount < maxScrolls) {
+    onScrollProgress === null || onScrollProgress === void 0 || onScrollProgress();
+    const currentHeight = await scrollToBottom(scrollable);
+    if (Math.abs(currentHeight - previousHeight) < minHeightChange) {
+      break;
+    }
+    previousHeight = currentHeight;
+    scrollCount++;
+    await new Promise(resolve => setTimeout(resolve, delayInMs));
+  }
+};
+exports.scrollToLoadContent = scrollToLoadContent;

package/dist/helpers/tests/extendedTest.js

@@ -0,0 +1,130 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "afterAll", {
+  enumerable: true,
+  get: function () {
+    return _vitest.afterAll;
+  }
+});
+Object.defineProperty(exports, "afterEach", {
+  enumerable: true,
+  get: function () {
+    return _vitest.afterEach;
+  }
+});
+Object.defineProperty(exports, "beforeAll", {
+  enumerable: true,
+  get: function () {
+    return _vitest.beforeAll;
+  }
+});
+Object.defineProperty(exports, "beforeEach", {
+  enumerable: true,
+  get: function () {
+    return _vitest.beforeEach;
+  }
+});
+Object.defineProperty(exports, "describe", {
+  enumerable: true,
+  get: function () {
+    return _vitest.describe;
+  }
+});
+exports.expect = void 0;
+Object.defineProperty(exports, "it", {
+  enumerable: true,
+  get: function () {
+    return _vitest.it;
+  }
+});
+exports.test = void 0;
+var dotenv = _interopRequireWildcard(require("dotenv"));
+var _vitest = require("vitest");
+var _runtime = require("@intuned/runtime");
+var _utils = require("../utils");
+var _fsExtra = require("fs-extra");
+var _types = require("../types");
+var _nanoid = require("nanoid");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+dotenv.config();
+const withPlaywright = (name, testFn, {
+  headless,
+  trace,
+  runId,
+  jobId,
+  jobRunId,
+  queueId
+}) => {
+  return async () => {
+    return (0, _runtime.runWithContext)({
+      runId: runId ?? (0, _nanoid.nanoid)(),
+      extendedPayloads: [],
+      runEnvironment: _types.RunEnvironment.IDE,
+      jobId,
+      jobRunId,
+      queueId
+    }, async () => {
+      const downloadsPath = (0, _runtime.getDownloadDirectoryPath)();
+      const {
+        page,
+        context
+      } = await (0, _runtime.getProductionPlaywrightConstructs)({
+        headless: headless ?? true,
+        downloadsPath
+      });
+      context.setDefaultTimeout(10000);
+      try {
+        if (trace) {
+          await context.tracing.start({
+            screenshots: true
+          });
+        }
+        await testFn({
+          context,
+          page
+        });
+        if (trace) {
+          await context.tracing.stop({
+            path: `./reports/traces/${name}.zip`
+          });
+        }
+      } finally {
+        await page.close();
+        await context.close();
+        await (0, _fsExtra.remove)(downloadsPath);
+      }
+    });
+  };
+};
+const test = (name, fn, options = {}) => {
+  if (process.env.CI) {
+    options.headless = true;
+  } else {
+    options.timeout = 1000000;
+  }
+  return (0, _vitest.test)(name, withPlaywright(name, fn, options), options);
+};
+exports.test = test;
+_vitest.expect.extend({
+  async toHaveText(locator, expectedText) {
+    const textContent = await locator.textContent();
+    const pass = !!textContent && (0, _utils.compressStringSpaces)(textContent) === expectedText;
+    return {
+      pass,
+      message: () => `Expected locator with selector "${locator}" to have text "${expectedText}", but it has "${textContent}"`
+    };
+  }
+});
+test.skip = _vitest.test.skip;
+test.only = (name, fn, options = {}) => {
+  if (process.env.CI) {
+    options.headless = true;
+  } else {
+    options.timeout = 1000000;
+  }
+  return _vitest.test.only(name, withPlaywright(name, fn, options), options);
+};
+const expect = exports.expect = _vitest.expect;