scordi-extension 1.14.4 → 1.14.5

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

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

@@ -1,111 +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 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

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

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

@@ -1,163 +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 { 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 { 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 { 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,
-  "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 "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
-      };
-    }
-  }
-}