scordi-extension 1.14.3 → 1.14.5

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

@@ -1,143 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--13965f26.js";
-import { BaseBlockSchema } from "/src/blocks/types.ts.js";
-import { findElement } from "/src/content/elements/index.ts.js";
-export const EventClickBlockSchema = BaseBlockSchema.extend({
-  name: z.literal("event-click"),
-  textFilter: z.object({
-    text: z.union([z.string(), z.array(z.string())]),
-    mode: z.enum(["exact", "contains", "startsWith", "endsWith", "regex"])
-  }).optional()
-});
-export function validateEventClickBlock(data) {
-  return EventClickBlockSchema.parse(data);
-}
-export async function handlerEventClick(data) {
-  try {
-    const { selector = "", findBy = "cssSelector", option, textFilter } = data;
-    if (!selector) {
-      throw new Error("Selector is required for event-click block");
-    }
-    const elements = await findElement({ selector, findBy, option });
-    if (!elements) {
-      throw new Error("Element not found for clicking");
-    }
-    let targetElement;
-    if (Array.isArray(elements)) {
-      if (textFilter) {
-        const filteredElement = selectElementByText(elements, textFilter.text, textFilter.mode);
-        if (!filteredElement) {
-          const textDisplay = Array.isArray(textFilter.text) ? textFilter.text.join(", ") : textFilter.text;
-          throw new Error(`No element found with text filter: "${textDisplay}" (mode: ${textFilter.mode})`);
-        }
-        targetElement = filteredElement;
-      } else {
-        targetElement = elements[0];
-      }
-    } else {
-      targetElement = elements;
-    }
-    await simulateClickElement(targetElement);
-    return { data: true };
-  } catch (error) {
-    console.log(error);
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in event-click handler",
-      data: false
-    };
-  }
-}
-function selectElementByText(elements, textFilter, mode) {
-  for (const element of elements) {
-    const text = getElementText(element);
-    const textsToCheck = Array.isArray(textFilter) ? textFilter : [textFilter];
-    for (const filterText of textsToCheck) {
-      let matches = false;
-      switch (mode) {
-        case "exact":
-          matches = text === filterText;
-          break;
-        case "contains":
-          matches = text.includes(filterText);
-          break;
-        case "startsWith":
-          matches = text.startsWith(filterText);
-          break;
-        case "endsWith":
-          matches = text.endsWith(filterText);
-          break;
-        case "regex":
-          try {
-            const regex = new RegExp(filterText);
-            matches = regex.test(text);
-          } catch (error) {
-            console.warn("Invalid regex pattern:", filterText);
-            continue;
-          }
-          break;
-      }
-      if (matches) {
-        return element;
-      }
-    }
-  }
-  return null;
-}
-function getElementText(element) {
-  if (element.innerText) {
-    return element.innerText.trim();
-  }
-  if (element.textContent) {
-    return element.textContent.trim();
-  }
-  if (element instanceof HTMLInputElement && element.value) {
-    return element.value.trim();
-  }
-  const placeholder = element.getAttribute("placeholder");
-  if (placeholder) {
-    return placeholder.trim();
-  }
-  const title = element.getAttribute("title");
-  if (title) {
-    return title.trim();
-  }
-  const ariaLabel = element.getAttribute("aria-label");
-  if (ariaLabel) {
-    return ariaLabel.trim();
-  }
-  return "";
-}
-async function simulateClickElement(element) {
-  element.scrollIntoView({
-    behavior: "instant",
-    block: "center",
-    inline: "center"
-  });
-  await new Promise((resolve) => setTimeout(resolve, 50));
-  if (element.focus) {
-    element.focus();
-  }
-  const rect = element.getBoundingClientRect();
-  const centerX = rect.left + rect.width / 2;
-  const centerY = rect.top + rect.height / 2;
-  try {
-    const response = await chrome.runtime.sendMessage({
-      type: "CDP_CLICK",
-      data: {
-        x: centerX,
-        y: centerY
-      }
-    });
-    if (response && !response.$isError) {
-      console.log("[EventClick] CDP click successful:", response);
-    } else {
-      throw new Error(response?.message || "CDP click failed");
-    }
-  } catch (error) {
-    console.error("[EventClick] CDP click failed, falling back to native click:", error);
-    if (element.click) {
-      element.click();
-    }
-  }
-  await new Promise((resolve) => setTimeout(resolve, 50));
-}

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

@@ -1,50 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--13965f26.js";
-export const FetchApiBlockSchema = z.object({
-  name: z.literal("fetch-api"),
-  url: z.string(),
-  method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional(),
-  headers: z.record(z.string(), z.string()).optional(),
-  body: z.record(z.string(), z.any()).optional(),
-  timeout: z.number().min(0).optional(),
-  parseJson: z.boolean().optional(),
-  returnHeaders: z.boolean().optional()
-});
-export function validateFetchApiBlock(data) {
-  return FetchApiBlockSchema.parse(data);
-}
-export async function handlerFetchApi(data) {
-  try {
-    console.log("[FetchApiBlock] Sending API request to background:", data.url);
-    const response = await chrome.runtime.sendMessage({
-      type: "FETCH_API",
-      data: {
-        url: data.url,
-        method: data.method || "GET",
-        headers: data.headers || {},
-        body: data.body,
-        timeout: data.timeout || 3e4,
-        parseJson: data.parseJson ?? true,
-        // 기본값 true
-        returnHeaders: data.returnHeaders ?? false
-      }
-    });
-    if (response.$isError) {
-      return {
-        hasError: true,
-        message: response.message || "API request failed",
-        data: void 0
-      };
-    }
-    console.log("[FetchApiBlock] API request successful");
-    return {
-      data: response.data
-    };
-  } catch (error) {
-    console.error("[FetchApiBlock] API request error:", error);
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in API request",
-      data: void 0
-    };
-  }
-}

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

@@ -1,33 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--13965f26.js";
-import { BaseBlockSchema } from "/src/blocks/types.ts.js";
-import { findElement } from "/src/content/elements/index.ts.js";
-export const GetAttributeValueBlockSchema = BaseBlockSchema.extend({
-  name: z.literal("attribute-value"),
-  attributeName: z.string()
-});
-export function validateGetAttributeValueBlock(data) {
-  return GetAttributeValueBlockSchema.parse(data);
-}
-export async function handlerGetAttributeValue(data) {
-  try {
-    const { selector = "", attributeName, findBy = "cssSelector", option } = data;
-    if (!selector) {
-      throw new Error("Selector is required for attribute-value block");
-    }
-    if (!attributeName) {
-      throw new Error("Attribute name is required for attribute-value block");
-    }
-    const elements = await findElement({ selector, findBy, option });
-    if (!elements) {
-      return { data: null };
-    }
-    const result = Array.isArray(elements) ? elements.map((element) => element.getAttribute(attributeName)).filter((value) => value !== null) : elements.getAttribute(attributeName);
-    return { data: result };
-  } catch (error) {
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in attribute-value handler",
-      data: null
-    };
-  }
-}

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

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

@@ -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--13965f26.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
-    };
-  }
-}