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

package/dist/helpers/extractMarkdown.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractMarkdown = void 0;
+var _utils = require("./utils");
+var _locatorHelpers = require("../common/locatorHelpers");
+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 extractMarkdown = async input => {
+  var _handle;
+  const {
+    source
+  } = input;
+  const isPageSource = (0, _locatorHelpers.isPage)(source);
+  const pageObject = isPageSource ? source : source.page();
+  await (0, _utils.ensureBrowserScripts)(pageObject);
+  let handle;
+  if (isPageSource) {
+    handle = await source.locator("body").elementHandle();
+  } else {
+    handle = await source.elementHandle();
+  }
+  const md = await pageObject.evaluate(element => {
+    return window.__INTUNED__.convertElementToMarkdown(element);
+  }, (_handle = handle) === null || _handle === void 0 ? void 0 : _handle.asElement());
+  const prettier = await Promise.resolve().then(() => _interopRequireWildcard(require("prettier/standalone")));
+  const parserMarkdown = await Promise.resolve().then(() => _interopRequireWildcard(require("prettier/parser-markdown")));
+  const formattedMarkdown = await prettier.format(md, {
+    parser: "markdown",
+    plugins: [parserMarkdown]
+  });
+  return formattedMarkdown;
+};
+exports.extractMarkdown = extractMarkdown;

package/dist/helpers/filterEmptyValues.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterEmptyValues = void 0;
+const filterEmptyValues = input => {
+  const {
+    data
+  } = input;
+  if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+    const filtered = {};
+    for (const [k, v] of Object.entries(data)) {
+      const filteredValue = filterEmptyValues({
+        data: v
+      });
+      if (isEmpty(filteredValue)) {
+        continue;
+      }
+      filtered[k] = filteredValue;
+    }
+    return filtered;
+  } else if (Array.isArray(data)) {
+    const filtered = [];
+    for (const item of data) {
+      const filteredItem = filterEmptyValues({
+        data: item
+      });
+      if (isEmpty(filteredItem)) {
+        continue;
+      }
+      filtered.push(filteredItem);
+    }
+    return filtered;
+  } else {
+    return data;
+  }
+};
+exports.filterEmptyValues = filterEmptyValues;
+function isEmpty(value) {
+  if (value == null) {
+    return true;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return true;
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return true;
+  }
+  if (typeof value === "object" && Object.keys(value).length === 0) {
+    return true;
+  }
+  return false;
+}

package/dist/helpers/gotoUrl.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.goToUrl = void 0;
+var _promises = require("timers/promises");
+var _asyncRetry = _interopRequireDefault(require("async-retry"));
+var _playwrightCore = require("playwright-core");
+var _isPageLoaded = require("../ai/isPageLoaded");
+var _Logger = require("../common/Logger");
+var _utils = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const DEFAULT_PLAYWRIGHT_TIMEOUT = 30000;
+const TIMEOUT_PADDING = 3000;
+const goToUrl = async input => {
+  const {
+    page,
+    url,
+    throwOnTimeout = true,
+    waitForLoadingStateUsingAi = false,
+    retries = 3,
+    model = "gpt-4o-2024-08-06",
+    apiKey,
+    waitForLoadState = "load"
+  } = input || {};
+  const timeoutSymbol = Symbol("page-goto-timeoutInMs");
+  const timeoutInMs = getPageGotoTimeout(page, {
+    timeoutInMs: input.timeoutInMs
+  });
+  let responseOrTimeout;
+  try {
+    await (0, _asyncRetry.default)(async () => {
+      const promises = [page.goto(url, {
+        waitUntil: waitForLoadState,
+        timeout: timeoutInMs !== undefined ? timeoutInMs : undefined
+      })];
+      if (timeoutInMs !== undefined) {
+        promises.push((0, _promises.setTimeout)(timeoutInMs + TIMEOUT_PADDING, timeoutSymbol));
+      }
+      responseOrTimeout = await Promise.race(promises);
+      if (responseOrTimeout === timeoutSymbol) {
+        throw new _playwrightCore.errors.TimeoutError("Page.goto timed out but did not throw an error. Consider using a proxy.\n" + `(URL: ${url}, timeout: ${timeoutInMs}ms)`);
+      }
+      try {
+        await page.waitForLoadState(waitForLoadState, {
+          timeout: timeoutInMs
+        });
+      } catch (error) {
+        _Logger.logger.error(`Failed to wait for ${waitForLoadState} on URL: ${url}. Error: ${error}`);
+      }
+    }, {
+      retries,
+      factor: 2,
+      minTimeout: 1000
+    });
+  } catch (error) {
+    if (!throwOnTimeout) {
+      return;
+    }
+    throw error;
+  }
+  if (!waitForLoadingStateUsingAi && !(0, _utils.isGenerateCodeMode)()) {
+    return responseOrTimeout;
+  }
+  for (let i = 0; i < retries; i++) {
+    let isLoaded = false;
+    try {
+      isLoaded = await (0, _isPageLoaded.isPageLoaded)({
+        page,
+        timeoutInMs,
+        model,
+        apiKey: apiKey ? apiKey : undefined
+      });
+      if (isLoaded === true) {
+        return;
+      }
+    } catch (error) {
+      _Logger.logger.debug(`Failed to check if page is loaded: ${url}. Error: ${error}`);
+      isLoaded = false;
+    }
+    if (i === retries - 1) {
+      throw new _playwrightCore.errors.TimeoutError("Page.goto did not load the page within the expected time.\n" + `(URL: ${url}, timeout: ${timeoutInMs}ms)`);
+    }
+    await (0, _promises.setTimeout)(5000);
+  }
+};
+exports.goToUrl = goToUrl;
+function getPageGotoTimeout(page, options) {
+  if ((options === null || options === void 0 ? void 0 : options.timeoutInMs) !== undefined) {
+    return options.timeoutInMs;
+  }
+  if (!("_timeoutSettings" in page)) {
+    return options === null || options === void 0 ? void 0 : options.timeoutInMs;
+  }
+  const timeoutSettings = page["_timeoutSettings"];
+  return (timeoutSettings === null || timeoutSettings === void 0 ? void 0 : timeoutSettings.timeout(options ?? {})) ?? DEFAULT_PLAYWRIGHT_TIMEOUT;
+}