scordi-extension 1.16.2 → 1.16.4

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

@@ -1,56 +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 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/TransformDataBlock.ts.js

@@ -1,42 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--34285d49.js";
-import __vite__cjsImport1_jsonata from "/vendor/.vite-deps-jsonata.js__v--34285d49.js"; const jsonata = __vite__cjsImport1_jsonata.__esModule ? __vite__cjsImport1_jsonata.default : __vite__cjsImport1_jsonata;
-export const TransformDataBlockSchema = z.object({
-  name: z.literal("transform-data"),
-  sourceData: z.any().optional(),
-  expression: z.string().min(1, "JSONata expression is required")
-});
-export function validateTransformDataBlock(data) {
-  return TransformDataBlockSchema.parse(data);
-}
-export async function handlerTransformData(data) {
-  try {
-    const { sourceData, expression } = data;
-    const input = sourceData !== void 0 && sourceData !== null ? sourceData : {};
-    let compiledExpression;
-    try {
-      compiledExpression = jsonata(expression);
-    } catch (error) {
-      throw new Error(
-        `Invalid JSONata expression: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-    let result;
-    try {
-      result = await compiledExpression.evaluate(input);
-    } catch (error) {
-      console.error("JSONata evaluation failed:", error);
-      throw new Error(
-        `JSONata evaluation failed: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-    return {
-      data: result
-    };
-  } catch (error) {
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in transform-data handler",
-      data: null
-    };
-  }
-}

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

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

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

@@ -1,187 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--34285d49.js";
-export const WaitForConditionBlockSchema = z.object({
-  name: z.literal("wait-for-condition"),
-  conditions: z.object({
-    urlPattern: z.string().optional(),
-    elementExists: z.object({
-      selector: z.string(),
-      findBy: z.enum(["cssSelector", "xpath"])
-    }).optional(),
-    cookieExists: z.string().optional(),
-    storageKey: z.object({
-      type: z.enum(["localStorage", "sessionStorage"]),
-      key: z.string()
-    }).optional(),
-    userConfirmation: z.boolean().optional(),
-    message: z.string().optional(),
-    buttonText: z.string().optional()
-  }).refine(
-    (data) => {
-      return data.urlPattern !== void 0 || data.elementExists !== void 0 || data.cookieExists !== void 0 || data.storageKey !== void 0 || data.userConfirmation === true;
-    },
-    {
-      message: "At least one condition must be specified"
-    }
-  ),
-  mode: z.enum(["auto", "manual", "auto-or-manual"]).optional(),
-  pollingIntervalMs: z.number().min(100).optional(),
-  timeoutMs: z.number().min(1e3).optional(),
-  position: z.enum(["top-left", "top-right", "bottom-left", "bottom-right"]).optional()
-});
-export function validateWaitForConditionBlock(data) {
-  return WaitForConditionBlockSchema.parse(data);
-}
-export async function handlerWaitForCondition(data) {
-  try {
-    const {
-      conditions,
-      mode = "auto-or-manual",
-      pollingIntervalMs = 1e3,
-      timeoutMs = 3e5,
-      position = "bottom-right"
-    } = data;
-    console.log("[WaitForCondition] Starting wait with conditions:", conditions);
-    console.log("[WaitForCondition] Mode:", mode, "Timeout:", timeoutMs);
-    const hasAutoConditions = !!(conditions.urlPattern || conditions.elementExists || conditions.cookieExists || conditions.storageKey);
-    const hasManualConfirmation = conditions.userConfirmation === true;
-    let userConfirmedPromise = null;
-    let confirmResolve = null;
-    if ((mode === "manual" || mode === "auto-or-manual") && hasManualConfirmation) {
-      userConfirmedPromise = new Promise((resolve) => {
-        confirmResolve = resolve;
-      });
-      window.dispatchEvent(
-        new CustomEvent("8g-show-confirmation-ui", {
-          detail: {
-            message: conditions.message || "작업을 완료하셨나요?",
-            buttonText: conditions.buttonText || "완료",
-            position,
-            onConfirm: confirmResolve
-          }
-        })
-      );
-    }
-    const checkAutoConditions = async () => {
-      if (conditions.urlPattern) {
-        try {
-          const regex = new RegExp(conditions.urlPattern);
-          if (regex.test(window.location.href)) {
-            return {
-              success: true,
-              reason: "urlPattern",
-              message: `URL matches pattern: ${conditions.urlPattern}`
-            };
-          }
-        } catch (error) {
-          console.warn("[WaitForCondition] Invalid URL pattern:", error);
-        }
-      }
-      if (conditions.elementExists) {
-        const { selector, findBy } = conditions.elementExists;
-        let element = null;
-        if (findBy === "cssSelector") {
-          element = document.querySelector(selector);
-        } else if (findBy === "xpath") {
-          const xpathResult = document.evaluate(
-            selector,
-            document,
-            null,
-            XPathResult.FIRST_ORDERED_NODE_TYPE,
-            null
-          );
-          element = xpathResult.singleNodeValue;
-        }
-        if (element) {
-          return {
-            success: true,
-            reason: "elementExists",
-            message: `Element found: ${selector}`
-          };
-        }
-      }
-      if (conditions.cookieExists) {
-        const cookies = document.cookie.split(";");
-        const cookieExists = cookies.some((cookie) => {
-          const [name] = cookie.trim().split("=");
-          return name === conditions.cookieExists;
-        });
-        if (cookieExists) {
-          return {
-            success: true,
-            reason: "cookieExists",
-            message: `Cookie found: ${conditions.cookieExists}`
-          };
-        }
-      }
-      if (conditions.storageKey) {
-        const { type, key } = conditions.storageKey;
-        const storage = type === "localStorage" ? window.localStorage : window.sessionStorage;
-        const value = storage.getItem(key);
-        if (value !== null) {
-          return {
-            success: true,
-            reason: "storageKey",
-            message: `Storage key found: ${type}.${key}`
-          };
-        }
-      }
-      return null;
-    };
-    return new Promise((resolve) => {
-      let intervalId = null;
-      let resolved = false;
-      const cleanup = () => {
-        if (intervalId) {
-          clearInterval(intervalId);
-          intervalId = null;
-        }
-        window.dispatchEvent(new CustomEvent("8g-hide-confirmation-ui"));
-      };
-      const resolveWith = (result) => {
-        if (resolved) return;
-        resolved = true;
-        cleanup();
-        console.log("[WaitForCondition] Resolved with:", result);
-        resolve({ data: result });
-      };
-      const timeoutId = setTimeout(() => {
-        resolveWith({
-          success: false,
-          reason: "timeout",
-          message: `Timeout after ${timeoutMs}ms`
-        });
-      }, timeoutMs);
-      if ((mode === "auto" || mode === "auto-or-manual") && hasAutoConditions) {
-        intervalId = setInterval(async () => {
-          const result = await checkAutoConditions();
-          if (result) {
-            clearTimeout(timeoutId);
-            resolveWith(result);
-          }
-        }, pollingIntervalMs);
-      }
-      if ((mode === "manual" || mode === "auto-or-manual") && userConfirmedPromise) {
-        userConfirmedPromise.then(() => {
-          clearTimeout(timeoutId);
-          resolveWith({
-            success: true,
-            reason: "userConfirmation",
-            message: "User confirmed completion"
-          });
-        });
-      }
-      if (mode === "manual" && !hasAutoConditions) {
-      }
-    });
-  } catch (error) {
-    console.error("[WaitForCondition] Error:", error);
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in wait-for-condition handler",
-      data: {
-        success: false,
-        message: error instanceof Error ? error.message : "Unknown error"
-      }
-    };
-  }
-}

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

@@ -1,198 +0,0 @@
-export { BaseBlockSchema } from "/src/blocks/types.ts.js";
-export { createSchema, createArraySchema, Schema } from "/src/blocks/AiParseDataBlock.ts.js";
-export { GetTextBlockSchema } from "/src/blocks/GetTextBlock.ts.js";
-export { GetAttributeValueBlockSchema } from "/src/blocks/GetAttributeValueBlock.ts.js";
-export { GetValueFormsBlockSchema } from "/src/blocks/GetValueFormBlock.ts.js";
-export { SetValueFormsBlockSchema } from "/src/blocks/SetValueFormBlock.ts.js";
-export { ClearValueFormsBlockSchema } from "/src/blocks/ClearValueFormBlock.ts.js";
-export { ElementExistsBlockSchema } from "/src/blocks/ElementExistsBlock.ts.js";
-export { EventClickBlockSchema } from "/src/blocks/EventClickBlock.ts.js";
-export { KeypressBlockSchema } from "/src/blocks/KeypressBlock.ts.js";
-export { WaitBlockSchema } from "/src/blocks/WaitBlock.ts.js";
-export { WaitForConditionBlockSchema } from "/src/blocks/WaitForConditionBlock.ts.js";
-export { NavigateBlockSchema } from "/src/blocks/NavigateBlock.ts.js";
-export { SaveAssetsBlockSchema } from "/src/blocks/SaveAssetsBlock.ts.js";
-export { GetElementDataBlockSchema } from "/src/blocks/GetElementDataBlock.ts.js";
-export { ScrollBlockSchema } from "/src/blocks/ScrollBlock.ts.js";
-export { AiParseDataBlockSchema } from "/src/blocks/AiParseDataBlock.ts.js";
-export { FetchApiBlockSchema } from "/src/blocks/FetchApiBlock.ts.js";
-export { TransformDataBlockSchema } from "/src/blocks/TransformDataBlock.ts.js";
-export { ExportDataBlockSchema } from "/src/blocks/ExportDataBlock.ts.js";
-export { NetworkCatchBlockSchema } from "/src/blocks/NetworkCatchBlock.ts.js";
-import { handlerGetText, validateGetTextBlock } from "/src/blocks/GetTextBlock.ts.js";
-import {
-  handlerGetAttributeValue,
-  validateGetAttributeValueBlock
-} from "/src/blocks/GetAttributeValueBlock.ts.js";
-import {
-  handlerGetValueForm,
-  validateGetValueFormsBlock
-} from "/src/blocks/GetValueFormBlock.ts.js";
-import {
-  handlerSetValueForm,
-  validateSetValueFormsBlock
-} from "/src/blocks/SetValueFormBlock.ts.js";
-import {
-  handlerClearValueForm,
-  validateClearValueFormsBlock
-} from "/src/blocks/ClearValueFormBlock.ts.js";
-import {
-  handlerElementExists,
-  validateElementExistsBlock
-} from "/src/blocks/ElementExistsBlock.ts.js";
-import { handlerEventClick, validateEventClickBlock } from "/src/blocks/EventClickBlock.ts.js";
-import { handlerKeypress, validateKeypressBlock } from "/src/blocks/KeypressBlock.ts.js";
-import { handlerWait, validateWaitBlock } from "/src/blocks/WaitBlock.ts.js";
-import {
-  handlerWaitForCondition,
-  validateWaitForConditionBlock
-} from "/src/blocks/WaitForConditionBlock.ts.js";
-import { handlerNavigate, validateNavigateBlock } from "/src/blocks/NavigateBlock.ts.js";
-import { handlerSaveAssets, validateSaveAssetsBlock } from "/src/blocks/SaveAssetsBlock.ts.js";
-import {
-  handlerGetElementData,
-  validateGetElementDataBlock
-} from "/src/blocks/GetElementDataBlock.ts.js";
-import { handlerScroll, validateScrollBlock } from "/src/blocks/ScrollBlock.ts.js";
-import { handlerAiParseData, validateAiParseDataBlock } from "/src/blocks/AiParseDataBlock.ts.js";
-import { handlerFetchApi, validateFetchApiBlock } from "/src/blocks/FetchApiBlock.ts.js";
-import { handlerTransformData, validateTransformDataBlock } from "/src/blocks/TransformDataBlock.ts.js";
-import { handlerExportData, validateExportDataBlock } from "/src/blocks/ExportDataBlock.ts.js";
-import { handlerNetworkCatch, validateNetworkCatchBlock } from "/src/blocks/NetworkCatchBlock.ts.js";
-import { GetTextBlockSchema as GetTextBlockSchema2 } from "/src/blocks/GetTextBlock.ts.js";
-import { GetAttributeValueBlockSchema as GetAttributeValueBlockSchema2 } from "/src/blocks/GetAttributeValueBlock.ts.js";
-import { GetValueFormsBlockSchema as GetValueFormsBlockSchema2 } from "/src/blocks/GetValueFormBlock.ts.js";
-import { SetValueFormsBlockSchema as SetValueFormsBlockSchema2 } from "/src/blocks/SetValueFormBlock.ts.js";
-import { ClearValueFormsBlockSchema as ClearValueFormsBlockSchema2 } from "/src/blocks/ClearValueFormBlock.ts.js";
-import { ElementExistsBlockSchema as ElementExistsBlockSchema2 } from "/src/blocks/ElementExistsBlock.ts.js";
-import { EventClickBlockSchema as EventClickBlockSchema2 } from "/src/blocks/EventClickBlock.ts.js";
-import { KeypressBlockSchema as KeypressBlockSchema2 } from "/src/blocks/KeypressBlock.ts.js";
-import { WaitBlockSchema as WaitBlockSchema2 } from "/src/blocks/WaitBlock.ts.js";
-import { WaitForConditionBlockSchema as WaitForConditionBlockSchema2 } from "/src/blocks/WaitForConditionBlock.ts.js";
-import { NavigateBlockSchema as NavigateBlockSchema2 } from "/src/blocks/NavigateBlock.ts.js";
-import { SaveAssetsBlockSchema as SaveAssetsBlockSchema2 } from "/src/blocks/SaveAssetsBlock.ts.js";
-import { GetElementDataBlockSchema as GetElementDataBlockSchema2 } from "/src/blocks/GetElementDataBlock.ts.js";
-import { ScrollBlockSchema as ScrollBlockSchema2 } from "/src/blocks/ScrollBlock.ts.js";
-import { AiParseDataBlockSchema as AiParseDataBlockSchema2 } from "/src/blocks/AiParseDataBlock.ts.js";
-import { FetchApiBlockSchema as FetchApiBlockSchema2 } from "/src/blocks/FetchApiBlock.ts.js";
-import { TransformDataBlockSchema as TransformDataBlockSchema2 } from "/src/blocks/TransformDataBlock.ts.js";
-import { ExportDataBlockSchema as ExportDataBlockSchema2 } from "/src/blocks/ExportDataBlock.ts.js";
-import { NetworkCatchBlockSchema as NetworkCatchBlockSchema2 } from "/src/blocks/NetworkCatchBlock.ts.js";
-export const AllBlockSchemas = {
-  "get-text": GetTextBlockSchema2,
-  "attribute-value": GetAttributeValueBlockSchema2,
-  "get-value-form": GetValueFormsBlockSchema2,
-  "set-value-form": SetValueFormsBlockSchema2,
-  "clear-value-form": ClearValueFormsBlockSchema2,
-  "element-exists": ElementExistsBlockSchema2,
-  "event-click": EventClickBlockSchema2,
-  "keypress": KeypressBlockSchema2,
-  "wait": WaitBlockSchema2,
-  "wait-for-condition": WaitForConditionBlockSchema2,
-  "navigate": NavigateBlockSchema2,
-  "save-assets": SaveAssetsBlockSchema2,
-  "get-element-data": GetElementDataBlockSchema2,
-  "scroll": ScrollBlockSchema2,
-  "ai-parse-data": AiParseDataBlockSchema2,
-  "fetch-api": FetchApiBlockSchema2,
-  "transform-data": TransformDataBlockSchema2,
-  "export-data": ExportDataBlockSchema2,
-  "network-catch": NetworkCatchBlockSchema2
-};
-export class BlockHandler {
-  // Implementation
-  static async executeBlock(block) {
-    try {
-      switch (block.name) {
-        case "get-text": {
-          const validatedBlock = validateGetTextBlock(block);
-          return await handlerGetText(validatedBlock);
-        }
-        case "attribute-value": {
-          const validatedBlock = validateGetAttributeValueBlock(block);
-          return await handlerGetAttributeValue(validatedBlock);
-        }
-        case "get-value-form": {
-          const validatedBlock = validateGetValueFormsBlock(block);
-          return await handlerGetValueForm(validatedBlock);
-        }
-        case "set-value-form": {
-          const validatedBlock = validateSetValueFormsBlock(block);
-          return await handlerSetValueForm(validatedBlock);
-        }
-        case "clear-value-form": {
-          const validatedBlock = validateClearValueFormsBlock(block);
-          return await handlerClearValueForm(validatedBlock);
-        }
-        case "element-exists": {
-          const validatedBlock = validateElementExistsBlock(block);
-          return await handlerElementExists(validatedBlock);
-        }
-        case "event-click": {
-          const validatedBlock = validateEventClickBlock(block);
-          return await handlerEventClick(validatedBlock);
-        }
-        case "keypress": {
-          const validatedBlock = validateKeypressBlock(block);
-          return await handlerKeypress(validatedBlock);
-        }
-        case "wait": {
-          const validatedBlock = validateWaitBlock(block);
-          return await handlerWait(validatedBlock);
-        }
-        case "wait-for-condition": {
-          const validatedBlock = validateWaitForConditionBlock(block);
-          return await handlerWaitForCondition(validatedBlock);
-        }
-        case "navigate": {
-          const validatedBlock = validateNavigateBlock(block);
-          return await handlerNavigate(validatedBlock);
-        }
-        case "save-assets": {
-          const validatedBlock = validateSaveAssetsBlock(block);
-          return await handlerSaveAssets(validatedBlock);
-        }
-        case "get-element-data": {
-          const validatedBlock = validateGetElementDataBlock(block);
-          return await handlerGetElementData(validatedBlock);
-        }
-        case "scroll": {
-          const validatedBlock = validateScrollBlock(block);
-          return await handlerScroll(validatedBlock);
-        }
-        case "ai-parse-data": {
-          const validatedBlock = validateAiParseDataBlock(block);
-          return await handlerAiParseData(validatedBlock);
-        }
-        case "fetch-api": {
-          const validatedBlock = validateFetchApiBlock(block);
-          return await handlerFetchApi(validatedBlock);
-        }
-        case "transform-data": {
-          const validatedBlock = validateTransformDataBlock(block);
-          return await handlerTransformData(validatedBlock);
-        }
-        case "export-data": {
-          const validatedBlock = validateExportDataBlock(block);
-          return await handlerExportData(validatedBlock);
-        }
-        case "network-catch": {
-          const validatedBlock = validateNetworkCatchBlock(block);
-          return await handlerNetworkCatch(validatedBlock);
-        }
-        default:
-          return {
-            hasError: true,
-            message: `Unknown block type: ${block.name}`,
-            data: null
-          };
-      }
-    } catch (error) {
-      return {
-        hasError: true,
-        message: error instanceof Error ? error.message : "Unknown error in block execution",
-        data: null
-      };
-    }
-  }
-}

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

@@ -1,11 +0,0 @@
-import { z } from "/vendor/.vite-deps-zod.js__v--34285d49.js";
-export const BaseBlockSchema = z.object({
-  name: z.string(),
-  selector: z.string(),
-  findBy: z.enum(["cssSelector", "xpath"]),
-  option: z.object({
-    waitForSelector: z.boolean().optional(),
-    waitSelectorTimeout: z.number().optional(),
-    multiple: z.boolean().optional()
-  })
-});