scordi-extension 1.16.3 → 1.16.4

package/dist/manifest.json

@@ -1,55 +0,0 @@
-{
-  "manifest_version": 3,
-  "name": "scordi-extension",
-  "version": "1.16.2",
-  "icons": {
-    "48": "public/logo.png"
-  },
-  "action": {
-    "default_icon": {
-      "48": "public/logo.png"
-    },
-    "default_popup": "src/popup/index.html"
-  },
-  "permissions": [
-    "contentSettings",
-    "tabs",
-    "storage",
-    "activeTab",
-    "scripting",
-    "webNavigation",
-    "debugger",
-    "downloads"
-  ],
-  "host_permissions": [
-    "<all_urls>"
-  ],
-  "content_scripts": [
-    {
-      "js": [
-        "src/content/main.tsx-loader.js"
-      ],
-      "matches": [
-        "<all_urls>"
-      ],
-      "run_at": "document_start",
-      "match_about_blank": true
-    }
-  ],
-  "background": {
-    "service_worker": "service-worker-loader.js",
-    "type": "module"
-  },
-  "web_accessible_resources": [
-    {
-      "matches": [
-        "<all_urls>"
-      ],
-      "resources": [
-        "**/*",
-        "*"
-      ],
-      "use_dynamic_url": false
-    }
-  ]
-}

package/dist/service-worker-loader.js

@@ -1,3 +0,0 @@
-import 'http://localhost:5173/@vite/env';
-import 'http://localhost:5173/@crx/client-worker';
-import 'http://localhost:5173/src/background/index.ts';

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

@@ -1,111 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--34285d49.js";
-import { CurrencyInfoSchema } from "/src/sdk/types.ts.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, "AI API key is required"),
-  // 필수
-  provider: z.enum(["openai", "anthropic"])
-  // 필수
-});
-export function validateAiParseDataBlock(data) {
-  return AiParseDataBlockSchema.parse(data);
-}
-export async function handlerAiParseData(data) {
-  try {
-    const {
-      sourceData,
-      schemaDefinition,
-      prompt,
-      model,
-      apiKey,
-      provider
-    } = 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,
-        provider
-      }
-    });
-    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
-  }),
-  currency: (options) => ({
-    type: "currency",
-    shape: CurrencyInfoSchema,
-    description: options?.description || "Currency information with code, symbol, format, amount, and text",
-    optional: options?.optional
-  })
-};

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

@@ -1,55 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--7cce5f32.js";
-export const CaptureNetworkBlockSchema = z.object({
-  name: z.literal("capture-network"),
-  targetUrl: z.string().url(),
-  waitForLoadComplete: z.boolean().optional(),
-  timeout: z.number().min(0).optional(),
-  includeRequestHeaders: z.boolean().optional(),
-  includeResponseHeaders: z.boolean().optional(),
-  includeResponseBody: z.boolean().optional(),
-  urlFilter: z.string().optional(),
-  resourceTypes: z.array(z.string()).optional()
-});
-export function validateCaptureNetworkBlock(data) {
-  return CaptureNetworkBlockSchema.parse(data);
-}
-export async function handlerCaptureNetwork(data) {
-  try {
-    console.log("[CaptureNetworkBlock] Capturing network requests for URL:", data.targetUrl);
-    const response = await chrome.runtime.sendMessage({
-      type: "CDP_CAPTURE_NETWORK",
-      data: {
-        targetUrl: data.targetUrl,
-        waitForLoadComplete: data.waitForLoadComplete ?? true,
-        timeout: data.timeout || 3e4,
-        includeRequestHeaders: data.includeRequestHeaders ?? false,
-        includeResponseHeaders: data.includeResponseHeaders ?? false,
-        includeResponseBody: data.includeResponseBody ?? false,
-        urlFilter: data.urlFilter,
-        resourceTypes: data.resourceTypes
-      }
-    });
-    if (response.$isError) {
-      return {
-        hasError: true,
-        message: response.message || "Network capture failed",
-        data: void 0
-      };
-    }
-    console.log(
-      "[CaptureNetworkBlock] Network capture successful, captured:",
-      response.data.summary.totalRequests,
-      "requests"
-    );
-    return {
-      data: response.data
-    };
-  } catch (error) {
-    console.error("[CaptureNetworkBlock] Network capture error:", error);
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in network capture",
-      data: void 0
-    };
-  }
-}

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--34285d49.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--7cce5f32.js";
-import __vite__cjsImport1_jsonata from "/vendor/.vite-deps-jsonata.js__v--7cce5f32.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--34285d49.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--34285d49.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/ExportDataBlock.ts.js

@@ -1,47 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--34285d49.js";
-export const ExportDataBlockSchema = z.object({
-  name: z.literal("export-data"),
-  data: z.any(),
-  format: z.enum(["json", "csv", "xlsx"]),
-  filename: z.string().optional(),
-  csvOptions: z.object({
-    delimiter: z.string().optional(),
-    includeHeaders: z.boolean().optional()
-  }).optional()
-});
-export function validateExportDataBlock(data) {
-  return ExportDataBlockSchema.parse(data);
-}
-export async function handlerExportData(block) {
-  try {
-    const { data, format, filename, csvOptions } = block;
-    console.log("[ExportDataBlock] Sending export request to background:", format);
-    const response = await chrome.runtime.sendMessage({
-      type: "EXPORT_DATA",
-      data: {
-        data,
-        format,
-        filename,
-        csvOptions
-      }
-    });
-    if (response.$isError) {
-      return {
-        hasError: true,
-        message: response.message || "Export failed",
-        data: void 0
-      };
-    }
-    console.log("[ExportDataBlock] Export successful:", response.data.filename);
-    return {
-      data: response.data
-    };
-  } catch (error) {
-    console.error("[ExportDataBlock] Export error:", error);
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in export-data handler",
-      data: void 0
-    };
-  }
-}

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

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