scordi-extension 1.14.4 → 1.14.5

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

@@ -1,101 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--13965f26.js";
-const ObjectSchemaDefinitionSchema = z.object({
-  type: z.literal("object"),
-  shape: z.record(z.string(), z.any())
-});
-const ArraySchemaDefinitionSchema = z.object({
-  type: z.literal("array"),
-  items: z.any()
-});
-const SchemaDefinitionSchema = z.discriminatedUnion("type", [
-  ObjectSchemaDefinitionSchema,
-  ArraySchemaDefinitionSchema
-]);
-export const AiParseDataBlockSchema = z.object({
-  name: z.literal("ai-parse-data"),
-  sourceData: z.any().optional(),
-  schemaDefinition: SchemaDefinitionSchema,
-  prompt: z.string().optional(),
-  model: z.string().optional(),
-  apiKey: z.string().min(1, "OpenAI API key is required")
-  // 필수
-});
-export function validateAiParseDataBlock(data) {
-  return AiParseDataBlockSchema.parse(data);
-}
-export async function handlerAiParseData(data) {
-  try {
-    const {
-      sourceData,
-      schemaDefinition,
-      prompt,
-      model = "gpt-4o-mini",
-      apiKey
-    } = data;
-    if (sourceData === void 0 || sourceData === null) {
-      throw new Error("sourceData is required for ai-parse-data block");
-    }
-    if (!apiKey || apiKey.trim() === "") {
-      throw new Error("apiKey is required for ai-parse-data block");
-    }
-    const response = await chrome.runtime.sendMessage({
-      type: "AI_PARSE_DATA",
-      data: {
-        sourceData,
-        schemaDefinition,
-        prompt,
-        model,
-        apiKey
-        // API 키 포함
-      }
-    });
-    if (response.$isError) {
-      throw new Error(response.message || "AI parsing failed");
-    }
-    return {
-      data: response.data
-    };
-  } catch (error) {
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in ai-parse-data handler",
-      data: null
-    };
-  }
-}
-export function createSchema(shape) {
-  return {
-    type: "object",
-    shape
-  };
-}
-export function createArraySchema(items) {
-  return {
-    type: "array",
-    items
-  };
-}
-export const Schema = {
-  string: (options) => ({
-    type: "string",
-    ...options
-  }),
-  number: (options) => ({
-    type: "number",
-    ...options
-  }),
-  boolean: (options) => ({
-    type: "boolean",
-    ...options
-  }),
-  array: (items, options) => ({
-    type: "array",
-    items,
-    ...options
-  }),
-  object: (shape, options) => ({
-    type: "object",
-    shape,
-    ...options
-  })
-};

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

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

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

@@ -1,28 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--13965f26.js";
-import __vite__cjsImport1_jsonata from "/vendor/.vite-deps-jsonata.js__v--5da6ca24.js"; const jsonata = __vite__cjsImport1_jsonata.__esModule ? __vite__cjsImport1_jsonata.default : __vite__cjsImport1_jsonata;
-export const DataExtractBlockSchema = z.object({
-  name: z.literal("data-extract"),
-  code: z.string(),
-  inputData: z.any().optional()
-});
-export function validateDataExtractBlock(data) {
-  return DataExtractBlockSchema.parse(data);
-}
-export async function handlerDataExtract(data) {
-  try {
-    console.log("[DataExtractBlock] Executing JSONata query:", data.code);
-    const expression = jsonata(data.code);
-    const result = await expression.evaluate(data.inputData);
-    console.log("[DataExtractBlock] Data extraction successful");
-    return {
-      data: result
-    };
-  } catch (error) {
-    console.error("[DataExtractBlock] Data extraction error:", error);
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in data extraction",
-      data: void 0
-    };
-  }
-}

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

@@ -1,26 +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 ElementExistsBlockSchema = BaseBlockSchema.extend({
-  name: z.literal("element-exists")
-});
-export function validateElementExistsBlock(data) {
-  return ElementExistsBlockSchema.parse(data);
-}
-export async function handlerElementExists(data) {
-  try {
-    const { selector = "", findBy = "cssSelector", option } = data;
-    if (!selector) {
-      throw new Error("Selector is required for element-exists block");
-    }
-    const element = await findElement({ selector, findBy, option });
-    const exists = element !== null;
-    return { data: exists };
-  } catch (error) {
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in element-exists handler",
-      data: null
-    };
-  }
-}

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;
-  };
-}