scordi-extension 1.14.6 → 1.14.7

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

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

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

@@ -0,0 +1,174 @@
+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 { 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 { DataExtractBlockSchema } from "/src/blocks/DataExtractBlock.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 { 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 { handlerDataExtract, validateDataExtractBlock } from "/src/blocks/DataExtractBlock.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 { 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 { DataExtractBlockSchema as DataExtractBlockSchema2 } from "/src/blocks/DataExtractBlock.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,
+  "save-assets": SaveAssetsBlockSchema2,
+  "get-element-data": GetElementDataBlockSchema2,
+  "scroll": ScrollBlockSchema2,
+  "ai-parse-data": AiParseDataBlockSchema2,
+  "fetch-api": FetchApiBlockSchema2,
+  "data-extract": DataExtractBlockSchema2
+};
+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 "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 "data-extract": {
+          const validatedBlock = validateDataExtractBlock(block);
+          return await handlerDataExtract(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

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