scordi-extension 1.16.3 → 1.16.4

package/dist/src/blocks/GetElementDataBlock.ts.js

@@ -1,114 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--34285d49.js";
-import { BaseBlockSchema } from "/src/blocks/types.ts.js";
-import { findElement } from "/src/content/elements/index.ts.js";
-import { CSSSelectorGenerator } from "/src/content/elements/utils/CSSSelectorGenerator.ts.js";
-import { XPathGenerator } from "/src/content/elements/utils/XPathGenerator.ts.js";
-export const GetElementDataBlockSchema = BaseBlockSchema.extend({
-  name: z.literal("get-element-data"),
-  includeText: z.boolean().optional(),
-  includeTags: z.boolean().optional(),
-  useTextContent: z.boolean().optional(),
-  regex: z.string().optional(),
-  prefixText: z.string().optional(),
-  suffixText: z.string().optional(),
-  attributes: z.array(z.string()).optional(),
-  includeSelector: z.boolean().optional(),
-  includeXPath: z.boolean().optional()
-});
-export function validateGetElementDataBlock(data) {
-  return GetElementDataBlockSchema.parse(data);
-}
-export async function handlerGetElementData(data) {
-  try {
-    const {
-      selector = "",
-      includeText = true,
-      includeTags = false,
-      useTextContent = false,
-      regex,
-      prefixText = "",
-      suffixText = "",
-      attributes = [],
-      includeSelector = false,
-      includeXPath = false,
-      findBy = "cssSelector",
-      option
-    } = data;
-    if (!selector) {
-      throw new Error("Selector is required for get-element-data block");
-    }
-    if (!includeText && attributes.length === 0) {
-      throw new Error("Either includeText must be true or attributes must be provided");
-    }
-    const elements = await findElement({ selector, findBy, option });
-    if (!elements) {
-      return { data: Array.isArray(elements) ? [] : {} };
-    }
-    const extractElementData = createElementDataExtractor(
-      includeText,
-      includeTags,
-      useTextContent,
-      regex,
-      prefixText,
-      suffixText,
-      attributes,
-      includeSelector,
-      includeXPath
-    );
-    if (Array.isArray(elements)) {
-      const elementsData = elements.map(extractElementData);
-      return { data: elementsData };
-    } else {
-      const elementData = extractElementData(elements);
-      return { data: elementData };
-    }
-  } catch (error) {
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in get-element-data handler",
-      data: {}
-    };
-  }
-}
-function createElementDataExtractor(includeText, includeTags, useTextContent, regex, prefixText = "", suffixText = "", attributes = [], includeSelector = false, includeXPath = false) {
-  return (element) => {
-    const result = {};
-    if (includeText) {
-      let text = "";
-      if (includeTags) {
-        text = element.innerHTML;
-      } else {
-        text = useTextContent ? element.textContent || "" : element.innerText || "";
-      }
-      if (regex) {
-        const regexPattern = new RegExp(regex, "g");
-        const matches = text.match(regexPattern);
-        text = matches ? matches.join(" ") : "";
-      }
-      if (text.trim()) {
-        text = prefixText + text.trim() + suffixText;
-      }
-      result.text = text;
-    }
-    if (attributes.length > 0) {
-      result.attributes = {};
-      attributes.forEach((attrName) => {
-        let attrValue = element.getAttribute(attrName);
-        if (attrValue === null) {
-          const childWithAttr = element.querySelector(`[${attrName}]`);
-          if (childWithAttr) {
-            attrValue = childWithAttr.getAttribute(attrName);
-          }
-        }
-        result.attributes[attrName] = attrValue;
-      });
-    }
-    if (includeSelector) {
-      result.selector = CSSSelectorGenerator.generate(element);
-    }
-    if (includeXPath) {
-      result.xpath = XPathGenerator.generate(element);
-    }
-    return result;
-  };
-}

package/dist/src/blocks/GetTextBlock.ts.js

@@ -1,152 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--34285d49.js";
-import { BaseBlockSchema } from "/src/blocks/types.ts.js";
-import { findElement } from "/src/content/elements/index.ts.js";
-export const GetTextBlockSchema = BaseBlockSchema.extend({
-  name: z.literal("get-text"),
-  includeTags: z.boolean().optional(),
-  useTextContent: z.boolean().optional(),
-  regex: z.string().optional(),
-  prefixText: z.string().optional(),
-  suffixText: z.string().optional(),
-  filterEmpty: z.boolean().optional(),
-  scrollToCollect: z.boolean().optional(),
-  scrollDistance: z.number().optional(),
-  scrollWaitMs: z.number().optional(),
-  maxScrollAttempts: z.number().optional()
-});
-export function validateGetTextBlock(data) {
-  return GetTextBlockSchema.parse(data);
-}
-export async function handlerGetText(data) {
-  try {
-    const {
-      selector = "",
-      includeTags = false,
-      useTextContent = false,
-      regex,
-      prefixText = "",
-      suffixText = "",
-      findBy = "cssSelector",
-      option,
-      filterEmpty = true,
-      scrollToCollect = false,
-      scrollDistance = 500,
-      scrollWaitMs = 300,
-      maxScrollAttempts = 100
-    } = data;
-    if (!selector) {
-      throw new Error("Selector is required for get-text block");
-    }
-    if (scrollToCollect && option?.multiple) {
-      return await collectWithScroll({
-        selector,
-        findBy,
-        option,
-        includeTags,
-        useTextContent,
-        regex,
-        prefixText,
-        suffixText,
-        filterEmpty,
-        scrollDistance,
-        scrollWaitMs,
-        maxScrollAttempts
-      });
-    }
-    const elements = await findElement({ selector, findBy, option });
-    if (!elements) {
-      return { data: "" };
-    }
-    const extractText = createTextExtractor(
-      includeTags,
-      useTextContent,
-      regex,
-      prefixText,
-      suffixText
-    );
-    if (Array.isArray(elements)) {
-      const texts = elements.map(extractText);
-      const filteredTexts = filterEmpty ? texts.filter((text) => text.trim() !== "") : texts;
-      return { data: filteredTexts };
-    } else {
-      const text = extractText(elements);
-      return { data: text };
-    }
-  } catch (error) {
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in get-text handler",
-      data: ""
-    };
-  }
-}
-async function collectWithScroll(params) {
-  const {
-    selector,
-    findBy,
-    option,
-    includeTags,
-    useTextContent,
-    regex,
-    prefixText,
-    suffixText,
-    filterEmpty,
-    scrollDistance,
-    scrollWaitMs,
-    maxScrollAttempts
-  } = params;
-  const extractText = createTextExtractor(includeTags, useTextContent, regex, prefixText, suffixText);
-  const collectedTexts = /* @__PURE__ */ new Set();
-  let scrollAttempts = 0;
-  let consecutiveNoNewData = 0;
-  const maxConsecutiveNoNewData = 5;
-  while (scrollAttempts < maxScrollAttempts) {
-    const elements = await findElement({ selector, findBy, option });
-    if (elements && Array.isArray(elements)) {
-      const beforeSize = collectedTexts.size;
-      elements.forEach((element) => {
-        const text = extractText(element);
-        if (!filterEmpty || text.trim() !== "") {
-          collectedTexts.add(text);
-        }
-      });
-      const afterSize = collectedTexts.size;
-      if (afterSize === beforeSize) {
-        consecutiveNoNewData++;
-        if (consecutiveNoNewData >= maxConsecutiveNoNewData) {
-          break;
-        }
-      } else {
-        consecutiveNoNewData = 0;
-      }
-    }
-    const currentScrollTop = window.pageYOffset || document.documentElement.scrollTop;
-    window.scrollBy({ top: scrollDistance, behavior: "auto" });
-    await new Promise((resolve) => setTimeout(resolve, scrollWaitMs));
-    const newScrollTop = window.pageYOffset || document.documentElement.scrollTop;
-    if (newScrollTop === currentScrollTop) {
-      break;
-    }
-    scrollAttempts++;
-  }
-  return { data: Array.from(collectedTexts) };
-}
-function createTextExtractor(includeTags, useTextContent, regex, prefixText = "", suffixText = "") {
-  return (element) => {
-    let text = "";
-    if (includeTags) {
-      text = element.innerHTML;
-    } else {
-      text = useTextContent ? element.textContent || "" : element.innerText || "";
-    }
-    if (regex) {
-      const regexPattern = new RegExp(regex, "g");
-      const matches = text.match(regexPattern);
-      text = matches ? matches.join(" ") : "";
-    }
-    if (text.trim()) {
-      text = prefixText + text.trim() + suffixText;
-    }
-    return text;
-  };
-}

package/dist/src/blocks/GetValueFormBlock.ts.js

@@ -1,52 +0,0 @@
-import { findElement } from "/src/content/elements/index.ts.js";
-import { BaseBlockSchema } from "/src/blocks/types.ts.js";
-import z from "/vendor/.vite-deps-zod.js__v--34285d49.js";
-export const GetValueFormsBlockSchema = BaseBlockSchema.extend({
-  name: z.literal("get-value-form"),
-  type: z.enum(["text-field", "select", "checkbox"]).optional()
-});
-export function validateGetValueFormsBlock(data) {
-  return GetValueFormsBlockSchema.parse(data);
-}
-export async function handlerGetValueForm(data) {
-  try {
-    const { selector = "", type = "text-field", findBy = "cssSelector" } = data;
-    if (!selector) {
-      throw new Error("Selector is required for get-value-form block");
-    }
-    const element = await findElement({ selector, findBy, option: data.option });
-    if (!element) {
-      throw new Error("Form element not found");
-    }
-    const value = getFormValue(element, type);
-    return { data: value };
-  } catch (error) {
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in get-value-form handler",
-      data: null
-    };
-  }
-}
-function getFormValue(element, type) {
-  switch (type) {
-    case "text-field":
-      if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
-        return element.value;
-      }
-      break;
-    case "select":
-      if (element instanceof HTMLSelectElement) {
-        return element.value;
-      }
-      break;
-    case "checkbox":
-      if (element instanceof HTMLInputElement && element.type === "checkbox") {
-        return element.checked;
-      }
-      break;
-    default:
-      throw new Error(`Unsupported form element type: ${type}`);
-  }
-  throw new Error(`Invalid element type for ${type}`);
-}

package/dist/src/blocks/KeypressBlock.ts.js

@@ -1,89 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--34285d49.js";
-export const KeypressBlockSchema = z.object({
-  name: z.literal("keypress"),
-  key: z.string(),
-  code: z.string().optional(),
-  keyCode: z.number().optional(),
-  modifiers: z.array(z.enum(["Alt", "Control", "Meta", "Shift"])).optional()
-});
-export function validateKeypressBlock(data) {
-  return KeypressBlockSchema.parse(data);
-}
-export async function handlerKeypress(data) {
-  try {
-    const { key, code, keyCode, modifiers = [] } = data;
-    await simulateKeypress(key, code, keyCode, modifiers);
-    return { data: true };
-  } catch (error) {
-    console.log(error);
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in keypress handler",
-      data: false
-    };
-  }
-}
-async function simulateKeypress(key, code, keyCode, modifiers = []) {
-  try {
-    const response = await chrome.runtime.sendMessage({
-      type: "CDP_KEYPRESS",
-      data: {
-        key,
-        code: code || key,
-        keyCode: keyCode || getKeyCodeFromKey(key),
-        modifiers
-      }
-    });
-    if (response && !response.$isError) {
-      console.log("[Keypress] CDP keypress successful:", response);
-    } else {
-      throw new Error(response?.message || "CDP keypress failed");
-    }
-  } catch (error) {
-    console.error("[Keypress] CDP keypress failed, falling back to native dispatch:", error);
-    const keydownEvent = new KeyboardEvent("keydown", {
-      key,
-      code: code || key,
-      keyCode: keyCode || getKeyCodeFromKey(key),
-      bubbles: true,
-      cancelable: true,
-      ...getModifierStates(modifiers)
-    });
-    const keyupEvent = new KeyboardEvent("keyup", {
-      key,
-      code: code || key,
-      keyCode: keyCode || getKeyCodeFromKey(key),
-      bubbles: true,
-      cancelable: true,
-      ...getModifierStates(modifiers)
-    });
-    document.dispatchEvent(keydownEvent);
-    await new Promise((resolve) => setTimeout(resolve, 10));
-    document.dispatchEvent(keyupEvent);
-  }
-  await new Promise((resolve) => setTimeout(resolve, 50));
-}
-function getKeyCodeFromKey(key) {
-  const keyCodeMap = {
-    "Escape": 27,
-    "Enter": 13,
-    "Tab": 9,
-    "Backspace": 8,
-    "Delete": 46,
-    "ArrowUp": 38,
-    "ArrowDown": 40,
-    "ArrowLeft": 37,
-    "ArrowRight": 39,
-    "Space": 32,
-    " ": 32
-  };
-  return keyCodeMap[key] || 0;
-}
-function getModifierStates(modifiers) {
-  return {
-    altKey: modifiers.includes("Alt"),
-    ctrlKey: modifiers.includes("Control"),
-    metaKey: modifiers.includes("Meta"),
-    shiftKey: modifiers.includes("Shift")
-  };
-}

package/dist/src/blocks/NavigateBlock.ts.js

@@ -1,48 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--34285d49.js";
-export const NavigateBlockSchema = z.object({
-  name: z.literal("navigate"),
-  url: z.string().url("Valid URL is required"),
-  waitForLoad: z.boolean().optional(),
-  timeout: z.number().min(0).optional()
-});
-export function validateNavigateBlock(data) {
-  return NavigateBlockSchema.parse(data);
-}
-export async function handlerNavigate(data) {
-  try {
-    const { url, waitForLoad = true, timeout = 3e4 } = data;
-    console.log(`[Navigate] Navigating to: ${url}`);
-    if (waitForLoad) {
-      return new Promise((resolve, reject) => {
-        const timeoutId = setTimeout(() => {
-          reject(new Error(`Navigation timeout after ${timeout}ms`));
-        }, timeout);
-        const handleLoad = () => {
-          clearTimeout(timeoutId);
-          window.removeEventListener("load", handleLoad);
-          console.log(`[Navigate] Page loaded: ${url}`);
-          resolve({ data: true });
-        };
-        if (document.readyState === "complete") {
-          clearTimeout(timeoutId);
-          console.log(`[Navigate] Page already loaded: ${url}`);
-          resolve({ data: true });
-        } else {
-          window.addEventListener("load", handleLoad);
-        }
-        window.location.href = url;
-      });
-    } else {
-      window.location.href = url;
-      console.log(`[Navigate] Navigation initiated (no wait): ${url}`);
-      return { data: true };
-    }
-  } catch (error) {
-    console.error("[Navigate] Error:", error);
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in navigate handler",
-      data: false
-    };
-  }
-}

package/dist/src/blocks/NetworkCatchBlock.ts.js

@@ -1,61 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--34285d49.js";
-export const NetworkCatchBlockSchema = z.object({
-  name: z.literal("network-catch"),
-  urlPattern: z.string().optional(),
-  method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional(),
-  status: z.union([
-    z.number(),
-    z.object({
-      min: z.number().optional(),
-      max: z.number().optional()
-    })
-  ]).optional(),
-  mimeType: z.string().optional(),
-  requestBodyPattern: z.union([
-    z.string(),
-    z.record(z.any())
-  ]).optional(),
-  waitForRequest: z.boolean().optional(),
-  waitTimeout: z.number().min(0).optional(),
-  returnAll: z.boolean().optional(),
-  includeHeaders: z.boolean().optional()
-});
-export function validateNetworkCatchBlock(data) {
-  return NetworkCatchBlockSchema.parse(data);
-}
-export async function handlerNetworkCatch(data) {
-  try {
-    console.log("[NetworkCatchBlock] Fetching network requests with pattern:", data.urlPattern);
-    const response = await chrome.runtime.sendMessage({
-      type: "NETWORK_CATCH",
-      data: {
-        urlPattern: data.urlPattern,
-        method: data.method,
-        status: data.status,
-        mimeType: data.mimeType,
-        requestBodyPattern: data.requestBodyPattern,
-        waitForRequest: data.waitForRequest || false,
-        waitTimeout: data.waitTimeout || 5e3,
-        returnAll: data.returnAll || false,
-        includeHeaders: data.includeHeaders || false
-      }
-    });
-    if (response.$isError) {
-      return {
-        hasError: true,
-        message: response.message || "Failed to fetch network data",
-        data: void 0
-      };
-    }
-    console.log("[NetworkCatchBlock] Retrieved network data:", response.data);
-    return {
-      data: response.data
-    };
-  } catch (error) {
-    console.error("[NetworkCatchBlock] Error:", error);
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Failed to fetch network data"
-    };
-  }
-}

package/dist/src/blocks/SaveAssetsBlock.ts.js

@@ -1,35 +0,0 @@
-import { findElement } from "/src/content/elements/index.ts.js";
-import { BaseBlockSchema } from "/src/blocks/types.ts.js";
-import z from "/vendor/.vite-deps-zod.js__v--34285d49.js";
-export const SaveAssetsBlockSchema = BaseBlockSchema.extend({
-  name: z.literal("save-assets")
-});
-export function validateSaveAssetsBlock(data) {
-  return SaveAssetsBlockSchema.parse(data);
-}
-export async function handlerSaveAssets(data) {
-  try {
-    const { selector = "img, audio, video, source", findBy = "cssSelector", option } = data;
-    const elements = await findElement({ selector, findBy, option });
-    if (!elements || !Array.isArray(elements)) {
-      return { data: [] };
-    }
-    const assetUrls = [];
-    elements.forEach((element) => {
-      let src = "";
-      if (element instanceof HTMLImageElement || element instanceof HTMLAudioElement || element instanceof HTMLVideoElement || element instanceof HTMLSourceElement) {
-        src = element.src;
-      }
-      if (src && !assetUrls.includes(src)) {
-        assetUrls.push(src);
-      }
-    });
-    return { data: assetUrls };
-  } catch (error) {
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in save-assets handler",
-      data: null
-    };
-  }
-}

package/dist/src/blocks/ScrollBlock.ts.js

@@ -1,111 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--34285d49.js";
-import { BaseBlockSchema } from "/src/blocks/types.ts.js";
-import { findElement } from "/src/content/elements/index.ts.js";
-export const ScrollBlockSchema = BaseBlockSchema.extend({
-  name: z.literal("scroll"),
-  scrollType: z.enum(["toElement", "toBottom", "byDistance", "untilLoaded"]).optional(),
-  distance: z.number().optional(),
-  behavior: z.enum(["auto", "smooth"]).optional(),
-  maxScrolls: z.number().optional(),
-  waitAfterScroll: z.number().optional()
-});
-export function validateScrollBlock(data) {
-  return ScrollBlockSchema.parse(data);
-}
-export async function handlerScroll(data) {
-  try {
-    const {
-      selector = "",
-      scrollType = "toBottom",
-      distance = 500,
-      behavior = "smooth",
-      maxScrolls = 50,
-      waitAfterScroll = 300,
-      findBy = "cssSelector",
-      option
-    } = data;
-    switch (scrollType) {
-      case "toElement":
-        if (!selector) {
-          throw new Error("Selector is required for toElement scroll type");
-        }
-        return await scrollToElement(selector, findBy, option, behavior);
-      case "toBottom":
-        return await scrollToBottom(behavior, waitAfterScroll);
-      case "byDistance":
-        return await scrollByDistance(distance, behavior);
-      case "untilLoaded":
-        return await scrollUntilLoaded(maxScrolls, distance, behavior, waitAfterScroll);
-      default:
-        throw new Error(`Unknown scroll type: ${scrollType}`);
-    }
-  } catch (error) {
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in scroll handler",
-      data: false
-    };
-  }
-}
-async function scrollToElement(selector, findBy, option, behavior) {
-  const element = await findElement({ selector, findBy, option });
-  if (!element) {
-    return {
-      hasError: true,
-      message: "Element not found for scrolling",
-      data: false
-    };
-  }
-  const targetElement = Array.isArray(element) ? element[0] : element;
-  targetElement.scrollIntoView({ behavior, block: "center" });
-  return { data: true };
-}
-async function scrollToBottom(behavior, waitAfterScroll) {
-  let lastHeight = document.body.scrollHeight;
-  let attempts = 0;
-  const maxAttempts = 50;
-  while (attempts < maxAttempts) {
-    window.scrollTo({
-      top: document.body.scrollHeight,
-      behavior
-    });
-    await new Promise((resolve) => setTimeout(resolve, waitAfterScroll));
-    const newHeight = document.body.scrollHeight;
-    if (newHeight === lastHeight) {
-      break;
-    }
-    lastHeight = newHeight;
-    attempts++;
-  }
-  return { data: true };
-}
-async function scrollByDistance(distance, behavior) {
-  window.scrollBy({
-    top: distance,
-    behavior
-  });
-  return { data: true };
-}
-async function scrollUntilLoaded(maxScrolls, distance, behavior, waitAfterScroll) {
-  let scrollCount = 0;
-  let lastHeight = document.body.scrollHeight;
-  while (scrollCount < maxScrolls) {
-    window.scrollBy({
-      top: distance,
-      behavior
-      // Use provided behavior
-    });
-    await new Promise((resolve) => setTimeout(resolve, waitAfterScroll));
-    const newHeight = document.body.scrollHeight;
-    const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
-    const windowHeight = window.innerHeight;
-    if (scrollTop + windowHeight >= newHeight - 10) {
-      if (newHeight === lastHeight) {
-        break;
-      }
-    }
-    lastHeight = newHeight;
-    scrollCount++;
-  }
-  return { data: true };
-}