scordi-extension 1.14.6 → 1.14.8

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

@@ -0,0 +1,152 @@
+import z from "/vendor/.vite-deps-zod.js__v--e2a1f584.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

@@ -0,0 +1,52 @@
+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--e2a1f584.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

@@ -0,0 +1,89 @@
+import z from "/vendor/.vite-deps-zod.js__v--e2a1f584.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/SaveAssetsBlock.ts.js

@@ -0,0 +1,35 @@
+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--e2a1f584.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

@@ -0,0 +1,111 @@
+import z from "/vendor/.vite-deps-zod.js__v--e2a1f584.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 };
+}

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

@@ -0,0 +1,56 @@
+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--e2a1f584.js";
+export const SetValueFormsBlockSchema = BaseBlockSchema.extend({
+  name: z.literal("set-value-form"),
+  setValue: z.string(),
+  type: z.enum(["text-field", "select", "checkbox"]).optional()
+});
+export function validateSetValueFormsBlock(data) {
+  return SetValueFormsBlockSchema.parse(data);
+}
+export async function handlerSetValueForm(data) {
+  try {
+    const { selector = "", setValue, type = "text-field", findBy = "cssSelector" } = data;
+    if (!selector) {
+      throw new Error("Selector is required for set-value-form block");
+    }
+    const element = await findElement({ selector, findBy, option: data.option });
+    if (!element) {
+      throw new Error("Form element not found");
+    }
+    setFormValue(element, setValue, type);
+    return { data: "Form element updated successfully" };
+  } catch (error) {
+    return {
+      hasError: true,
+      message: error instanceof Error ? error.message : "Unknown error in set-value-form handler",
+      data: null
+    };
+  }
+}
+function setFormValue(element, value, type) {
+  switch (type) {
+    case "text-field":
+      if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+        element.value = value;
+        element.dispatchEvent(new Event("input", { bubbles: true }));
+        element.dispatchEvent(new Event("change", { bubbles: true }));
+      }
+      break;
+    case "select":
+      if (element instanceof HTMLSelectElement) {
+        element.value = value;
+        element.dispatchEvent(new Event("change", { bubbles: true }));
+      }
+      break;
+    case "checkbox":
+      if (element instanceof HTMLInputElement && element.type === "checkbox") {
+        element.checked = value === "true" || value === "checked";
+        element.dispatchEvent(new Event("change", { bubbles: true }));
+      }
+      break;
+    default:
+      throw new Error(`Unsupported form element type: ${type}`);
+  }
+}

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

@@ -0,0 +1,24 @@
+import z from "/vendor/.vite-deps-zod.js__v--e2a1f584.js";
+export const WaitBlockSchema = z.object({
+  name: z.literal("wait"),
+  duration: z.number().min(0)
+});
+export function validateWaitBlock(data) {
+  return WaitBlockSchema.parse(data);
+}
+export async function handlerWait(data) {
+  try {
+    const { duration } = data;
+    console.log(`[Wait] Waiting for ${duration}ms...`);
+    await new Promise((resolve) => setTimeout(resolve, duration));
+    console.log(`[Wait] Wait completed after ${duration}ms`);
+    return { data: true };
+  } catch (error) {
+    console.log(error);
+    return {
+      hasError: true,
+      message: error instanceof Error ? error.message : "Unknown error in wait handler",
+      data: false
+    };
+  }
+}