@pupt/react 0.0.1 → 1.2.0

package/dist/index.js

@@ -0,0 +1,1060 @@
+import { jsx, Fragment } from "react/jsx-runtime";
+import { useState, useRef, useEffect, useCallback, createContext, useMemo, useContext } from "react";
+import { Pupt, createInputIterator, isPuptElement, createPromptFromSource, CHILDREN, createEnvironment, render, createSearchEngine, evaluateFormula } from "@pupt/lib";
+import { CHILDREN as CHILDREN2, COMPONENT_MARKER, Component, DEFERRED_REF, PROPS, TYPE, createRuntimeConfig, evaluateFormula as evaluateFormula2, isComponentClass, isDeferredRef, isPuptElement as isPuptElement2 } from "@pupt/lib";
+function usePuptLibrary(options = {}) {
+  const { modules: initialModules = [], searchConfig } = options;
+  const [modules, setModules] = useState(initialModules);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [prompts, setPrompts] = useState([]);
+  const [tags, setTags] = useState([]);
+  const puptRef = useRef(null);
+  const searchConfigRef = useRef(searchConfig);
+  searchConfigRef.current = searchConfig;
+  useEffect(() => {
+    let cancelled = false;
+    async function init() {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const config = { modules };
+        if (searchConfigRef.current) {
+          config.searchConfig = searchConfigRef.current;
+        }
+        const pupt = new Pupt(config);
+        await pupt.init();
+        if (cancelled) {
+          return;
+        }
+        puptRef.current = pupt;
+        setPrompts(pupt.getPrompts());
+        setTags(pupt.getTags());
+      } catch (err) {
+        if (cancelled) {
+          return;
+        }
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setPrompts([]);
+        setTags([]);
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    }
+    void init();
+    return () => {
+      cancelled = true;
+    };
+  }, [modules]);
+  const getPrompt = useCallback(
+    (name) => {
+      var _a;
+      return (_a = puptRef.current) == null ? void 0 : _a.getPrompt(name);
+    },
+    [prompts]
+  );
+  const getPromptsByTag = useCallback(
+    (tag) => {
+      var _a;
+      return ((_a = puptRef.current) == null ? void 0 : _a.getPromptsByTag(tag)) ?? [];
+    },
+    [prompts]
+  );
+  const addModule = useCallback((source) => {
+    setModules((prev) => {
+      if (prev.includes(source)) {
+        return prev;
+      }
+      return [...prev, source];
+    });
+  }, []);
+  const removeModule = useCallback((source) => {
+    setModules((prev) => prev.filter((m) => m !== source));
+  }, []);
+  return {
+    isLoading,
+    error,
+    prompts,
+    tags,
+    getPrompt,
+    getPromptsByTag,
+    addModule,
+    removeModule,
+    modules
+  };
+}
+const PuptLibraryContext = createContext(null);
+PuptLibraryContext.displayName = "PuptLibraryContext";
+function PuptLibraryProvider({ children, modules, searchConfig }) {
+  const opts = {};
+  if (modules) {
+    opts.modules = modules;
+  }
+  if (searchConfig) {
+    opts.searchConfig = searchConfig;
+  }
+  const library = usePuptLibrary(opts);
+  const value = useMemo(
+    () => library,
+    [library.isLoading, library.error, library.prompts, library.tags, library.modules]
+  );
+  return /* @__PURE__ */ jsx(PuptLibraryContext.Provider, { value, children });
+}
+const defaultContextValue = {
+  _initialized: false,
+  searchEngine: null,
+  prompts: [],
+  renderOptions: {},
+  environment: {},
+  isLoading: false,
+  error: null
+};
+const PuptContext = createContext(defaultContextValue);
+PuptContext.displayName = "PuptContext";
+async function transformSource(source, options = {}) {
+  const { filename = "prompt.tsx" } = options;
+  return createPromptFromSource(source, filename);
+}
+async function extractInputRequirements(element, options) {
+  try {
+    const iteratorOpts = {
+      validateOnSubmit: false,
+      environment: "browser"
+    };
+    if (options == null ? void 0 : options.values) {
+      iteratorOpts.values = options.values;
+    }
+    const iterator = createInputIterator(element, iteratorOpts);
+    const requirements = [];
+    await iterator.start();
+    while (!iterator.isDone()) {
+      const current = iterator.current();
+      if (current) {
+        requirements.push(current);
+        await iterator.submit(void 0);
+      }
+      await iterator.advance();
+    }
+    return requirements;
+  } catch {
+    return [];
+  }
+}
+function isAskComponent(type) {
+  if (typeof type === "string") {
+    return type.startsWith("Ask.") || type === "Ask";
+  }
+  return false;
+}
+function traverseElement(element, visitor) {
+  visitor(element);
+  const children = element[CHILDREN];
+  if (children) {
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        if (isElement(child)) {
+          traverseElement(child, visitor);
+        }
+      }
+    } else if (isElement(children)) {
+      traverseElement(children, visitor);
+    }
+  }
+}
+function isElement(value) {
+  return isPuptElement(value);
+}
+function validateInput(requirement, value) {
+  const errors = [];
+  switch (requirement.type) {
+    case "number":
+      if (typeof value !== "number" || isNaN(value)) {
+        errors.push({
+          field: requirement.name,
+          message: `Expected a number, got ${typeof value}`,
+          code: "INVALID_TYPE"
+        });
+      } else {
+        if (requirement.min !== void 0 && value < requirement.min) {
+          errors.push({
+            field: requirement.name,
+            message: `Value ${value} is below minimum ${requirement.min}`,
+            code: "BELOW_MIN"
+          });
+        }
+        if (requirement.max !== void 0 && value > requirement.max) {
+          errors.push({
+            field: requirement.name,
+            message: `Value ${value} exceeds maximum ${requirement.max}`,
+            code: "ABOVE_MAX"
+          });
+        }
+      }
+      break;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        errors.push({
+          field: requirement.name,
+          message: `Expected a boolean, got ${typeof value}`,
+          code: "INVALID_TYPE"
+        });
+      }
+      break;
+    case "select":
+      if (requirement.options && requirement.options.length > 0) {
+        const validValues = requirement.options.map((o) => o.value);
+        if (!validValues.includes(String(value))) {
+          errors.push({
+            field: requirement.name,
+            message: `Invalid selection. Valid options: ${validValues.join(", ")}`,
+            code: "INVALID_OPTION"
+          });
+        }
+      }
+      break;
+    case "multiselect":
+      if (!Array.isArray(value)) {
+        errors.push({
+          field: requirement.name,
+          message: "Expected an array for multiselect",
+          code: "INVALID_TYPE"
+        });
+      }
+      break;
+    case "string":
+    case "secret":
+      if (typeof value !== "string" && value !== void 0 && value !== null) {
+        errors.push({
+          field: requirement.name,
+          message: `Expected a string, got ${typeof value}`,
+          code: "INVALID_TYPE"
+        });
+      }
+      if (typeof value === "string") {
+        if (requirement.min !== void 0 && value.length < requirement.min) {
+          errors.push({
+            field: requirement.name,
+            message: `Value must be at least ${requirement.min} characters`,
+            code: "TOO_SHORT"
+          });
+        }
+        if (requirement.max !== void 0 && value.length > requirement.max) {
+          errors.push({
+            field: requirement.name,
+            message: `Value must be at most ${requirement.max} characters`,
+            code: "TOO_LONG"
+          });
+        }
+      }
+      break;
+  }
+  if (requirement.required && (value === void 0 || value === null || value === "")) {
+    errors.push({
+      field: requirement.name,
+      message: `${requirement.label || requirement.name} is required`,
+      code: "REQUIRED"
+    });
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings: []
+  };
+}
+function useAskIterator(options) {
+  const { element, onComplete, initialValues, preSuppliedValues, onMissingDefault } = options;
+  const [requirements, setRequirements] = useState([]);
+  const [currentIndex, setCurrentIndex] = useState(0);
+  const [values, setValues] = useState(() => new Map(initialValues));
+  const [isLoading, setIsLoading] = useState(false);
+  const onCompleteRef = useRef(onComplete);
+  onCompleteRef.current = onComplete;
+  const completedRef = useRef(false);
+  useEffect(() => {
+    if (!element) {
+      setRequirements([]);
+      setCurrentIndex(0);
+      setValues(new Map(initialValues));
+      completedRef.current = false;
+      return void 0;
+    }
+    let cancelled = false;
+    setIsLoading(true);
+    const extractOpts = preSuppliedValues ? { values: preSuppliedValues } : void 0;
+    void extractInputRequirements(element, extractOpts).then((reqs) => {
+      if (!cancelled) {
+        setRequirements(reqs);
+        setCurrentIndex(0);
+        setValues(new Map(initialValues));
+        completedRef.current = false;
+        setIsLoading(false);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [element, initialValues, preSuppliedValues]);
+  const totalInputs = requirements.length;
+  const isDone = totalInputs > 0 ? currentIndex >= totalInputs : !isLoading;
+  const current = currentIndex < totalInputs ? requirements[currentIndex] ?? null : null;
+  useEffect(() => {
+    var _a;
+    if (isDone && totalInputs > 0 && !completedRef.current) {
+      completedRef.current = true;
+      (_a = onCompleteRef.current) == null ? void 0 : _a.call(onCompleteRef, new Map(values));
+    }
+  }, [isDone, totalInputs, values]);
+  const submit = useCallback(
+    (value) => {
+      if (!current) {
+        return Promise.resolve({
+          valid: false,
+          errors: [{ field: "", message: "No current requirement", code: "NO_REQUIREMENT" }],
+          warnings: []
+        });
+      }
+      const result = validateInput(current, value);
+      if (result.valid) {
+        setValues((prev) => {
+          const next = new Map(prev);
+          next.set(current.name, value);
+          return next;
+        });
+        setCurrentIndex((prev) => prev + 1);
+      }
+      return Promise.resolve(result);
+    },
+    [current]
+  );
+  const previous = useCallback(() => {
+    setCurrentIndex((prev) => Math.max(0, prev - 1));
+    completedRef.current = false;
+  }, []);
+  const goTo = useCallback(
+    (index) => {
+      if (index >= 0 && index < totalInputs) {
+        setCurrentIndex(index);
+        completedRef.current = false;
+      }
+    },
+    [totalInputs]
+  );
+  const reset = useCallback(() => {
+    setCurrentIndex(0);
+    setValues(/* @__PURE__ */ new Map());
+    completedRef.current = false;
+  }, []);
+  const setValue = useCallback((name, value) => {
+    setValues((prev) => {
+      const next = new Map(prev);
+      next.set(name, value);
+      return next;
+    });
+  }, []);
+  const getValue = useCallback(
+    (name) => {
+      return values.get(name);
+    },
+    [values]
+  );
+  const runNonInteractive = useCallback(async () => {
+    if (!element) {
+      return /* @__PURE__ */ new Map();
+    }
+    const iteratorOpts = {
+      validateOnSubmit: false,
+      environment: "browser",
+      nonInteractive: true,
+      onMissingDefault: onMissingDefault ?? "error"
+    };
+    if (preSuppliedValues) {
+      iteratorOpts.values = preSuppliedValues;
+    }
+    const iterator = createInputIterator(element, iteratorOpts);
+    await iterator.start();
+    const result = await iterator.runNonInteractive();
+    setValues(result);
+    setCurrentIndex(requirements.length);
+    return result;
+  }, [element, preSuppliedValues, onMissingDefault, requirements.length]);
+  return {
+    requirements,
+    current,
+    currentIndex,
+    totalInputs,
+    isDone,
+    isLoading,
+    inputs: values,
+    submit,
+    previous,
+    goTo,
+    reset,
+    setValue,
+    getValue,
+    runNonInteractive
+  };
+}
+const INPUT_TYPE_MAP = {
+  string: "text",
+  number: "number",
+  boolean: "checkbox",
+  secret: "password",
+  date: "date",
+  path: "text",
+  select: "text",
+  multiselect: "text",
+  rating: "number"
+};
+function AskHandler({ children, element, onComplete, initialValues }) {
+  const {
+    requirements,
+    current,
+    currentIndex,
+    totalInputs,
+    isDone,
+    isLoading,
+    inputs: values,
+    submit,
+    previous,
+    goTo,
+    reset,
+    setValue,
+    getValue
+  } = useAskIterator({
+    element,
+    ...onComplete !== void 0 && { onComplete },
+    ...initialValues !== void 0 && { initialValues }
+  });
+  let progress;
+  if (totalInputs === 0) {
+    progress = isDone ? 100 : 0;
+  } else {
+    progress = Math.round(currentIndex / totalInputs * 100);
+  }
+  const getInputProps = useCallback(
+    (name) => {
+      const requirement = requirements.find((r) => r.name === name) ?? {
+        name,
+        label: name,
+        type: "string",
+        description: name,
+        required: false
+      };
+      const inputType = INPUT_TYPE_MAP[requirement.type] ?? "text";
+      return {
+        inputProps: {
+          id: `ask-${name}`,
+          name,
+          type: inputType,
+          required: requirement.required ?? false,
+          "aria-label": requirement.label
+        },
+        requirement,
+        value: getValue(name),
+        setValue: (value) => {
+          setValue(name, value);
+        },
+        errors: []
+      };
+    },
+    [requirements, getValue, setValue]
+  );
+  return /* @__PURE__ */ jsx(Fragment, { children: children({
+    requirements,
+    current,
+    currentIndex,
+    totalInputs,
+    progress,
+    isDone,
+    isLoading,
+    values,
+    submit,
+    previous,
+    goTo,
+    reset,
+    getInputProps
+  }) });
+}
+const DEFAULT_DEBOUNCE$1 = 300;
+function PromptEditor({
+  children,
+  defaultValue = "",
+  onChange,
+  debounce = DEFAULT_DEBOUNCE$1
+}) {
+  const [value, setValueState] = useState(defaultValue);
+  const [element, setElement] = useState(null);
+  const [error, setError] = useState(null);
+  const [isTransforming, setIsTransforming] = useState(false);
+  const timerRef = useRef(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      if (timerRef.current !== null) {
+        clearTimeout(timerRef.current);
+      }
+    };
+  }, []);
+  const scheduleTransform = useCallback(
+    (source) => {
+      if (timerRef.current !== null) {
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+      if (source.trim() === "") {
+        setElement(null);
+        setError(null);
+        setIsTransforming(false);
+        return;
+      }
+      const doTransform = async () => {
+        timerRef.current = null;
+        if (!mountedRef.current) {
+          return;
+        }
+        setIsTransforming(true);
+        try {
+          const result = await transformSource(source);
+          if (mountedRef.current) {
+            setElement(result);
+            setError(null);
+          }
+        } catch (err) {
+          if (mountedRef.current) {
+            setElement(null);
+            setError(err instanceof Error ? err : new Error(String(err)));
+          }
+        } finally {
+          if (mountedRef.current) {
+            setIsTransforming(false);
+          }
+        }
+      };
+      if (debounce <= 0) {
+        void doTransform();
+      } else {
+        setIsTransforming(true);
+        timerRef.current = setTimeout(() => {
+          void doTransform();
+        }, debounce);
+      }
+    },
+    [debounce]
+  );
+  useEffect(() => {
+    if (defaultValue.trim() !== "") {
+      scheduleTransform(defaultValue);
+    }
+  }, []);
+  const handleChange = useCallback(
+    (e) => {
+      const newValue = e.target.value;
+      setValueState(newValue);
+      onChange == null ? void 0 : onChange(newValue);
+      scheduleTransform(newValue);
+    },
+    [onChange, scheduleTransform]
+  );
+  const setValue = useCallback(
+    (newValue) => {
+      setValueState(newValue);
+      onChange == null ? void 0 : onChange(newValue);
+      scheduleTransform(newValue);
+    },
+    [onChange, scheduleTransform]
+  );
+  return /* @__PURE__ */ jsx(Fragment, { children: children({
+    inputProps: {
+      value,
+      onChange: handleChange
+    },
+    value,
+    setValue,
+    element,
+    error,
+    isTransforming
+  }) });
+}
+function usePupt() {
+  const context = useContext(PuptContext);
+  if (!context._initialized) {
+    throw new Error("usePupt must be used within a PuptProvider");
+  }
+  return context;
+}
+function usePromptRender(options = {}) {
+  const {
+    source: initialSource,
+    inputs,
+    environment,
+    renderOptions: customRenderOptions,
+    autoRender = false,
+    filename
+  } = options;
+  const { renderOptions: contextRenderOptions, environment: contextEnvironment } = usePupt();
+  const [source, setSourceState] = useState(initialSource ?? null);
+  const [element, setElement] = useState(null);
+  const [output, setOutput] = useState(null);
+  const [error, setError] = useState(null);
+  const [isTransforming, setIsTransforming] = useState(false);
+  const [isRendering, setIsRendering] = useState(false);
+  const [inputRequirements, setInputRequirements] = useState([]);
+  const [postActions, setPostActions] = useState([]);
+  const [renderErrors, setRenderErrors] = useState([]);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const doTransform = useCallback(
+    async (sourceToTransform) => {
+      setIsTransforming(true);
+      setError(null);
+      try {
+        let newElement;
+        if (sourceToTransform.type === "element") {
+          newElement = sourceToTransform.value;
+        } else {
+          newElement = await transformSource(sourceToTransform.value, filename ? { filename } : void 0);
+        }
+        if (mountedRef.current) {
+          setElement(newElement);
+          const requirements = await extractInputRequirements(newElement);
+          setInputRequirements(requirements);
+        }
+        return newElement;
+      } catch (err) {
+        if (mountedRef.current) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+          setElement(null);
+          setInputRequirements([]);
+        }
+        return null;
+      } finally {
+        if (mountedRef.current) {
+          setIsTransforming(false);
+        }
+      }
+    },
+    [filename]
+  );
+  const doRender = useCallback(
+    async (elementToRender) => {
+      setIsRendering(true);
+      setError(null);
+      setRenderErrors([]);
+      try {
+        const mergedOptions = {
+          ...contextRenderOptions,
+          ...customRenderOptions,
+          inputs: inputs ?? /* @__PURE__ */ new Map()
+        };
+        const envOverrides = { ...contextEnvironment, ...environment };
+        if (Object.keys(envOverrides).length > 0) {
+          mergedOptions.env = createEnvironment(envOverrides);
+        }
+        const result = await render(elementToRender, mergedOptions);
+        if (mountedRef.current) {
+          setOutput(result.text);
+          setPostActions(result.postExecution ?? []);
+          if (!result.ok && "errors" in result) {
+            setRenderErrors(result.errors);
+            const firstError = result.errors[0];
+            if (firstError) {
+              setError(new Error(`${firstError.component}: ${firstError.message}`));
+            }
+          } else {
+            setRenderErrors([]);
+          }
+        }
+      } catch (err) {
+        if (mountedRef.current) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+          setOutput(null);
+          setPostActions([]);
+        }
+      } finally {
+        if (mountedRef.current) {
+          setIsRendering(false);
+        }
+      }
+    },
+    [contextRenderOptions, contextEnvironment, customRenderOptions, environment, inputs]
+  );
+  const transform = useCallback(
+    async (sourceCode) => {
+      const sourceToUse = sourceCode ? { type: "source", value: sourceCode } : source;
+      if (!sourceToUse) {
+        return null;
+      }
+      if (sourceCode) {
+        setSourceState({ type: "source", value: sourceCode });
+      }
+      return doTransform(sourceToUse);
+    },
+    [source, doTransform]
+  );
+  const render$1 = useCallback(async () => {
+    if (element) {
+      await doRender(element);
+    }
+  }, [element, doRender]);
+  const setSource = useCallback((newSource) => {
+    setSourceState(newSource);
+  }, []);
+  const externalSourceValue = (initialSource == null ? void 0 : initialSource.type) === "source" ? initialSource.value : null;
+  const prevExternalSourceValue = useRef(externalSourceValue);
+  useEffect(() => {
+    if (externalSourceValue !== prevExternalSourceValue.current) {
+      prevExternalSourceValue.current = externalSourceValue;
+      if (initialSource) {
+        setSourceState(initialSource);
+      }
+    }
+  }, [externalSourceValue, initialSource]);
+  useEffect(() => {
+    if (source) {
+      void doTransform(source);
+    } else {
+      setElement(null);
+      setInputRequirements([]);
+      setError(null);
+    }
+  }, [source, doTransform]);
+  useEffect(() => {
+    if (autoRender && element) {
+      void doRender(element);
+    }
+  }, [autoRender, element, doRender]);
+  useEffect(() => {
+    if (autoRender && element && inputs) {
+      void doRender(element);
+    }
+  }, [autoRender, element, inputs, doRender]);
+  return {
+    source,
+    setSource,
+    element,
+    output,
+    error,
+    renderErrors,
+    isTransforming,
+    isRendering,
+    isLoading: isTransforming || isRendering,
+    inputRequirements,
+    postActions,
+    render: render$1,
+    transform
+  };
+}
+function PromptRenderer({
+  children,
+  source,
+  autoRender = true,
+  inputs,
+  renderOptions,
+  environment,
+  filename
+}) {
+  const [isCopied, setIsCopied] = useState(false);
+  const normalizedSource = useMemo(
+    () => typeof source === "string" ? { type: "source", value: source } : source,
+    [source]
+  );
+  const {
+    output,
+    error,
+    isLoading,
+    inputRequirements,
+    postActions,
+    render: doRender
+  } = usePromptRender({
+    source: normalizedSource,
+    autoRender,
+    ...inputs !== void 0 && { inputs },
+    ...renderOptions !== void 0 && { renderOptions },
+    ...environment !== void 0 && { environment },
+    ...filename !== void 0 && { filename }
+  });
+  const isReady = output !== null && inputRequirements.length === 0;
+  const copyToClipboard = useCallback(async () => {
+    if (output === null) {
+      return;
+    }
+    try {
+      await navigator.clipboard.writeText(output);
+      setIsCopied(true);
+      setTimeout(() => {
+        setIsCopied(false);
+      }, 2e3);
+    } catch {
+    }
+  }, [output]);
+  const render2 = useCallback(async () => {
+    await doRender();
+  }, [doRender]);
+  return /* @__PURE__ */ jsx(Fragment, { children: children({
+    output,
+    isReady,
+    isLoading,
+    error,
+    pendingInputs: inputRequirements,
+    postActions,
+    copyToClipboard,
+    isCopied,
+    render: render2
+  }) });
+}
+function PuptProvider({
+  children,
+  prompts,
+  searchConfig,
+  renderOptions = {},
+  environment = {}
+}) {
+  const [isLoading] = useState(false);
+  const [error] = useState(null);
+  const searchEngine = useMemo(() => {
+    if (!prompts || prompts.length === 0) {
+      return null;
+    }
+    try {
+      const engine = createSearchEngine(searchConfig);
+      engine.index(prompts);
+      return engine;
+    } catch (err) {
+      console.error("Failed to initialize search engine:", err);
+      return null;
+    }
+  }, [prompts, searchConfig]);
+  const contextValue = useMemo(
+    () => ({
+      _initialized: true,
+      searchEngine,
+      prompts: prompts ?? [],
+      renderOptions,
+      environment,
+      isLoading,
+      error
+    }),
+    [searchEngine, prompts, renderOptions, environment, isLoading, error]
+  );
+  return /* @__PURE__ */ jsx(PuptContext.Provider, { value: contextValue, children });
+}
+function useFormula(options) {
+  const { formula, inputs } = options;
+  return useMemo(() => {
+    try {
+      return { result: evaluateFormula(formula, inputs), error: null };
+    } catch (err) {
+      return {
+        result: false,
+        error: err instanceof Error ? err : new Error(String(err))
+      };
+    }
+  }, [formula, inputs]);
+}
+function usePostActions(options) {
+  const { actions, handlers } = options;
+  const [executedSet, setExecutedSet] = useState(() => /* @__PURE__ */ new Set());
+  const [dismissedSet, setDismissedSet] = useState(() => /* @__PURE__ */ new Set());
+  const prevActionsRef = useRef(actions);
+  if (prevActionsRef.current !== actions) {
+    prevActionsRef.current = actions;
+    setExecutedSet(/* @__PURE__ */ new Set());
+    setDismissedSet(/* @__PURE__ */ new Set());
+  }
+  const pendingActions = actions.filter((a) => !executedSet.has(a) && !dismissedSet.has(a));
+  const executedActions = actions.filter((a) => executedSet.has(a));
+  const dismissedActions = actions.filter((a) => dismissedSet.has(a));
+  const allDone = pendingActions.length === 0;
+  const execute = useCallback(
+    async (action) => {
+      if (executedSet.has(action)) {
+        return;
+      }
+      const handler = handlers == null ? void 0 : handlers[action.type];
+      if (handler) {
+        await handler(action);
+      }
+      setExecutedSet((prev) => {
+        const next = new Set(prev);
+        next.add(action);
+        return next;
+      });
+    },
+    [handlers, executedSet]
+  );
+  const dismiss = useCallback((action) => {
+    setDismissedSet((prev) => {
+      const next = new Set(prev);
+      next.add(action);
+      return next;
+    });
+  }, []);
+  const executeAll = useCallback(async () => {
+    for (const action of pendingActions) {
+      const handler = handlers == null ? void 0 : handlers[action.type];
+      if (handler) {
+        await handler(action);
+      }
+    }
+    setExecutedSet((prev) => {
+      const next = new Set(prev);
+      for (const action of pendingActions) {
+        next.add(action);
+      }
+      return next;
+    });
+  }, [pendingActions, handlers]);
+  const dismissAll = useCallback(() => {
+    setDismissedSet((prev) => {
+      const next = new Set(prev);
+      for (const action of pendingActions) {
+        next.add(action);
+      }
+      return next;
+    });
+  }, [pendingActions]);
+  const reset = useCallback(() => {
+    setExecutedSet(/* @__PURE__ */ new Set());
+    setDismissedSet(/* @__PURE__ */ new Set());
+  }, []);
+  return {
+    pendingActions,
+    executedActions,
+    dismissedActions,
+    allDone,
+    execute,
+    dismiss,
+    executeAll,
+    dismissAll,
+    reset
+  };
+}
+const DEFAULT_DEBOUNCE = 200;
+function usePromptSearch(options = {}) {
+  const { debounce = DEFAULT_DEBOUNCE, limit } = options;
+  const { searchEngine } = usePupt();
+  const [query, setQueryState] = useState("");
+  const [results, setResults] = useState([]);
+  const [isSearching, setIsSearching] = useState(false);
+  const timerRef = useRef(null);
+  const performSearch = useCallback(
+    (searchQuery) => {
+      if (!searchEngine || searchQuery.trim() === "") {
+        setResults([]);
+        setIsSearching(false);
+        return;
+      }
+      setIsSearching(true);
+      try {
+        const searchOptions = limit !== void 0 ? { limit } : {};
+        const searchResults = searchEngine.search(searchQuery, searchOptions);
+        setResults(searchResults);
+      } finally {
+        setIsSearching(false);
+      }
+    },
+    [searchEngine, limit]
+  );
+  const setQuery = useCallback(
+    (newQuery) => {
+      setQueryState(newQuery);
+      if (timerRef.current !== null) {
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+      if (newQuery.trim() === "") {
+        setResults([]);
+        setIsSearching(false);
+        return;
+      }
+      if (debounce <= 0) {
+        performSearch(newQuery);
+      } else {
+        setIsSearching(true);
+        timerRef.current = setTimeout(() => {
+          timerRef.current = null;
+          performSearch(newQuery);
+        }, debounce);
+      }
+    },
+    [debounce, performSearch]
+  );
+  const clear = useCallback(() => {
+    if (timerRef.current !== null) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    setQueryState("");
+    setResults([]);
+    setIsSearching(false);
+  }, []);
+  const allTags = searchEngine ? searchEngine.getAllTags() : [];
+  useEffect(() => {
+    return () => {
+      if (timerRef.current !== null) {
+        clearTimeout(timerRef.current);
+      }
+    };
+  }, []);
+  return {
+    query,
+    setQuery,
+    results,
+    isSearching,
+    allTags,
+    clear
+  };
+}
+function usePuptLibraryContext() {
+  const ctx = useContext(PuptLibraryContext);
+  if (!ctx) {
+    throw new Error("usePuptLibraryContext must be used within a PuptLibraryProvider");
+  }
+  return ctx;
+}
+const VERSION = "1.0.0";
+export {
+  AskHandler,
+  CHILDREN2 as CHILDREN,
+  COMPONENT_MARKER,
+  Component,
+  DEFERRED_REF,
+  PROPS,
+  PromptEditor,
+  PromptRenderer,
+  PuptContext,
+  PuptLibraryContext,
+  PuptLibraryProvider,
+  PuptProvider,
+  TYPE,
+  VERSION,
+  createRuntimeConfig,
+  evaluateFormula2 as evaluateFormula,
+  extractInputRequirements,
+  isAskComponent,
+  isComponentClass,
+  isDeferredRef,
+  isElement,
+  isPuptElement2 as isPuptElement,
+  transformSource,
+  traverseElement,
+  useAskIterator,
+  useFormula,
+  usePostActions,
+  usePromptRender,
+  usePromptSearch,
+  usePupt,
+  usePuptLibrary,
+  usePuptLibraryContext,
+  validateInput
+};
+//# sourceMappingURL=index.js.map