@sevenfold/setto-client 0.5.0 → 0.6.1

package/dist/setto-client.js

@@ -20805,6 +20805,18 @@ function createApi(args) {
         }
       );
       if (!res.ok) throw await asError(res, "cancelDeployment failed");
+    },
+    /** Request a password-reset email (link goes via setto-server, then site /setto). */
+    async requestPasswordReset(siteId, email) {
+      const res = await fetch(
+        `${apiUrl}/sites/${encodeURIComponent(siteId)}/auth/password-reset`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ email })
+        }
+      );
+      if (!res.ok) throw await asError(res, "requestPasswordReset failed");
     }
   };
 }
@@ -21199,9 +21211,6 @@ function isAdminRoute() {
 function isAdminDeploymentView() {
   return isAdminRoute() && new URLSearchParams(window.location.search).has("deployment");
 }
-function adminRedirectUrl() {
-  return `${window.location.origin}${SETTO_BASE}`;
-}
 const FAB_SIZE = 52;
 const FAB_INSET = 16;
 const STYLE_ID$1 = "setto-edit-layout";
@@ -23786,6 +23795,236 @@ const removeBtnStyle = {
   boxShadow: "0 1px 4px rgba(0,0,0,0.18)",
   fontFamily: 'system-ui, -apple-system, "Segoe UI", sans-serif'
 };
+function SettoForm({
+  formId,
+  fields,
+  endpoint,
+  endpointKey,
+  className
+}) {
+  const { t } = useTranslation();
+  const [status, setStatus] = useState("idle");
+  const [values, setValues] = useState(
+    () => Object.fromEntries(fields.map((f) => [f.name, ""]))
+  );
+  const setField = useCallback(
+    (name, value) => setValues((prev) => ({ ...prev, [name]: value })),
+    []
+  );
+  const resolveEndpoint = () => {
+    if (endpoint) return endpoint;
+    if (endpointKey) {
+      const resolved = t(endpointKey, { defaultValue: "" });
+      return resolved && resolved !== endpointKey ? resolved : null;
+    }
+    return null;
+  };
+  const onSubmit = async (e) => {
+    e.preventDefault();
+    const url = resolveEndpoint();
+    if (!url) {
+      setStatus("error");
+      return;
+    }
+    setStatus("submitting");
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(values)
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      setStatus("success");
+      setValues(
+        (prev) => Object.fromEntries(Object.keys(prev).map((k) => [k, ""]))
+      );
+    } catch {
+      setStatus("error");
+    }
+  };
+  if (status === "success") {
+    return /* @__PURE__ */ jsx("div", { className, "data-setto-form-status": "success", children: /* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx(T, { k: `form.${formId}.success` }) }) });
+  }
+  return /* @__PURE__ */ jsxs("form", { className, onSubmit, "data-setto-form": formId, noValidate: true, children: [
+    fields.map((field) => /* @__PURE__ */ jsxs("label", { "data-setto-form-field": field.name, children: [
+      /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(T, { k: field.labelKey }) }),
+      field.type === "textarea" ? /* @__PURE__ */ jsx(
+        "textarea",
+        {
+          name: field.name,
+          required: field.required,
+          value: values[field.name] ?? "",
+          placeholder: field.placeholderKey ? t(field.placeholderKey, { defaultValue: "" }) : void 0,
+          onChange: (e) => setField(field.name, e.target.value)
+        }
+      ) : /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: field.type,
+          name: field.name,
+          required: field.required,
+          value: values[field.name] ?? "",
+          placeholder: field.placeholderKey ? t(field.placeholderKey, { defaultValue: "" }) : void 0,
+          onChange: (e) => setField(field.name, e.target.value)
+        }
+      )
+    ] }, field.name)),
+    /* @__PURE__ */ jsx("button", { type: "submit", disabled: status === "submitting", children: /* @__PURE__ */ jsx(T, { k: `form.${formId}.submit` }) }),
+    status === "error" ? /* @__PURE__ */ jsx("p", { "data-setto-form-status": "error", role: "alert", children: /* @__PURE__ */ jsx(T, { k: `form.${formId}.error` }) }) : null
+  ] });
+}
+function SettoVideo({ srcKey, posterKey, title, className }) {
+  const { t, i18n } = useTranslation();
+  const { store } = useSetto();
+  const src = store ? store.get(srcKey, i18n.language) : t(srcKey, { defaultValue: "" });
+  const poster = posterKey ? store ? store.get(posterKey, i18n.language) : t(posterKey, { defaultValue: "" }) : void 0;
+  if (!src) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className,
+        "data-setto-video": srcKey,
+        "data-setto-video-empty": "1"
+      }
+    );
+  }
+  const embed = toEmbedUrl(src);
+  if (embed) {
+    return /* @__PURE__ */ jsx(
+      "iframe",
+      {
+        className,
+        src: embed,
+        title: title ?? "Video",
+        loading: "lazy",
+        allow: "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture",
+        allowFullScreen: true,
+        "data-setto-video": srcKey
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    "video",
+    {
+      className,
+      src,
+      poster,
+      controls: true,
+      preload: "metadata",
+      "data-setto-video": srcKey
+    }
+  );
+}
+function toEmbedUrl(url) {
+  try {
+    const u = new URL(url);
+    if (u.hostname === "youtu.be") {
+      return `https://www.youtube.com/embed/${u.pathname.slice(1)}`;
+    }
+    if (u.hostname.endsWith("youtube.com")) {
+      const v = u.searchParams.get("v");
+      if (v) return `https://www.youtube.com/embed/${v}`;
+      if (u.pathname.startsWith("/embed/")) return url;
+    }
+    if (u.hostname.endsWith("vimeo.com")) {
+      const id = u.pathname.split("/").filter(Boolean).pop();
+      if (id && /^\d+$/.test(id)) return `https://player.vimeo.com/video/${id}`;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+const DEFAULT_DURATION = {
+  fadeIn: 600,
+  slideUp: 700,
+  stagger: 700,
+  scrollReveal: 700
+};
+function SettoAnimation({
+  preset,
+  delay = 0,
+  duration,
+  className,
+  children
+}) {
+  const ref = useRef(null);
+  const [visible, setVisible] = useState(preset === "fadeIn" || preset === "slideUp");
+  useEffect(() => {
+    if (preset === "fadeIn" || preset === "slideUp") {
+      const t = window.setTimeout(() => setVisible(true), delay);
+      return () => window.clearTimeout(t);
+    }
+    const el = ref.current;
+    if (!el || typeof IntersectionObserver === "undefined") {
+      setVisible(true);
+      return;
+    }
+    const io = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          if (entry.isIntersecting) {
+            setVisible(true);
+            io.disconnect();
+          }
+        }
+      },
+      { threshold: 0.15 }
+    );
+    io.observe(el);
+    return () => io.disconnect();
+  }, [preset, delay]);
+  const reduced = typeof window !== "undefined" && window.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
+  const ms = duration ?? DEFAULT_DURATION[preset];
+  const transition = reduced ? void 0 : `opacity ${ms}ms ease-out ${delay}ms, transform ${ms}ms ease-out ${delay}ms`;
+  const hiddenTransform = preset === "slideUp" || preset === "scrollReveal" ? "translateY(24px)" : "none";
+  const style = reduced ? void 0 : {
+    opacity: visible ? 1 : 0,
+    transform: visible ? "none" : hiddenTransform,
+    transition,
+    willChange: "opacity, transform"
+  };
+  if (preset === "stagger") {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        className,
+        "data-setto-animation": preset,
+        "data-setto-animation-visible": visible ? "1" : "0",
+        children: wrapChildrenForStagger(children, visible, ms, delay, reduced)
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref,
+      className,
+      style,
+      "data-setto-animation": preset,
+      "data-setto-animation-visible": visible ? "1" : "0",
+      children
+    }
+  );
+}
+function wrapChildrenForStagger(children, visible, ms, baseDelay, reduced) {
+  if (reduced) return children;
+  const arr = Array.isArray(children) ? children : [children];
+  const step = 80;
+  return arr.map((child, i) => /* @__PURE__ */ jsx(
+    "div",
+    {
+      style: {
+        opacity: visible ? 1 : 0,
+        transform: visible ? "none" : "translateY(16px)",
+        transition: `opacity ${ms}ms ease-out ${baseDelay + i * step}ms, transform ${ms}ms ease-out ${baseDelay + i * step}ms`
+      },
+      children: child
+    },
+    i
+  ));
+}
 function authCallbackType() {
   const hash = window.location.hash.replace(/^#/, "");
   if (!hash) return null;
@@ -23804,10 +24043,10 @@ function consumeInviteErrorFromUrl() {
   params.delete("setto_invite_error");
   const qs = params.toString();
   window.history.replaceState(null, "", `${window.location.pathname}${qs ? `?${qs}` : ""}`);
-  return code === "invalid" ? "Invitasjonslenken er ugyldig eller utløpt. Be administratoren om en ny." : "Kunne ikke aktivere invitasjonen.";
+  return code === "invalid" ? "Lenken er ugyldig eller utløpt. Be om en ny nullstilling eller invitasjon." : "Kunne ikke aktivere lenken.";
 }
 function AuthGate({ children }) {
-  const { supabase, session, authLoading } = useSetto();
+  const { supabase, api, config, session, authLoading } = useSetto();
   const [mode, setMode] = useState("signin");
   const [email, setEmail] = useState("");
   const [password, setPassword] = useState("");
@@ -23858,10 +24097,7 @@ function AuthGate({ children }) {
     setError(null);
     setInfo(null);
     try {
-      const { error: resetError } = await supabase.auth.resetPasswordForEmail(email, {
-        redirectTo: adminRedirectUrl()
-      });
-      if (resetError) throw resetError;
+      await api.requestPasswordReset(config.siteId, email);
       setInfo("Vi har sendt en lenke for å nullstille passordet. Sjekk innboksen.");
     } catch (err) {
       setError(err instanceof Error ? err.message : "Ukjent feil");
@@ -24386,20 +24622,504 @@ function depDotStyle(status) {
     flexShrink: 0
   };
 }
+const BLOCK_REGISTRY = {
+  section: { allowedChildren: "any", themed: true, selectable: true },
+  block: { allowedChildren: "any", themed: true, selectable: true },
+  container: { allowedChildren: "any", themed: false, selectable: false },
+  animation: { allowedChildren: "any", themed: false, selectable: false },
+  repeater: { allowedChildren: "any", themed: false, selectable: false },
+  text: { allowedChildren: null, themed: false, selectable: false },
+  image: { allowedChildren: null, themed: false, selectable: false },
+  icon: { allowedChildren: null, themed: false, selectable: false },
+  form: { allowedChildren: null, themed: false, selectable: false },
+  video: { allowedChildren: null, themed: false, selectable: false }
+};
+const BLOCK_TYPES = Object.keys(
+  BLOCK_REGISTRY
+);
+function nodeChildren(node) {
+  switch (node.type) {
+    case "section":
+    case "block":
+    case "container":
+    case "animation":
+      return node.children;
+    case "repeater":
+      return node.itemTemplate;
+    default:
+      return [];
+  }
+}
+const FIELD_TYPES = ["text", "email", "tel", "textarea"];
+const ANIMATION_PRESETS = ["fadeIn", "slideUp", "stagger", "scrollReveal"];
+function validateBlockTree(input) {
+  const issues = [];
+  if (!isRecord(input)) {
+    return fail("$", "Block tree must be an object");
+  }
+  if (input.version !== "1") {
+    issues.push({ path: "$.version", message: 'Expected version "1"' });
+  }
+  if (!Array.isArray(input.root)) {
+    return fail("$.root", "root must be an array of block nodes");
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < input.root.length; i++) {
+    validateNode(input.root[i], `root[${i}]`, seenIds, issues);
+  }
+  return issues.length ? { ok: false, issues } : { ok: true };
+}
+function validateNode(raw, path, seenIds, issues) {
+  if (!isRecord(raw)) {
+    issues.push({ path, message: "Node must be an object" });
+    return;
+  }
+  const type = raw.type;
+  if (typeof type !== "string" || !(type in BLOCK_REGISTRY)) {
+    issues.push({ path, message: `Unknown block type "${String(type)}"` });
+    return;
+  }
+  if (typeof raw.id !== "string" || raw.id.length === 0) {
+    issues.push({ path, message: "Node is missing a non-empty string id" });
+  } else if (seenIds.has(raw.id)) {
+    issues.push({ path, message: `Duplicate node id "${raw.id}"` });
+  } else {
+    seenIds.add(raw.id);
+  }
+  if (raw.className !== void 0 && typeof raw.className !== "string") {
+    issues.push({ path: `${path}.className`, message: "className must be a string" });
+  }
+  validateTypeSpecific(raw, type, path, issues);
+  const meta = BLOCK_REGISTRY[type];
+  if (meta.allowedChildren === null && Array.isArray(raw.children) && raw.children.length > 0) {
+    issues.push({ path, message: `Type "${type}" cannot have children` });
+    return;
+  }
+  const children = nodeChildren(raw);
+  if (meta.allowedChildren === null && children.length > 0) {
+    issues.push({ path, message: `Type "${type}" cannot have children` });
+    return;
+  }
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    const childPath = type === "repeater" ? `${path}.itemTemplate[${i}]` : `${path}.children[${i}]`;
+    validateNode(child, childPath, seenIds, issues);
+    if (meta.allowedChildren !== "any" && meta.allowedChildren !== null && isRecord(child) && typeof child.type === "string" && !meta.allowedChildren.includes(child.type)) {
+      issues.push({
+        path: childPath,
+        message: `Type "${child.type}" not allowed inside "${type}"`
+      });
+    }
+  }
+}
+function validateTypeSpecific(raw, type, path, issues) {
+  switch (type) {
+    case "section":
+      requireString(raw, "sectionId", path, issues);
+      requireArray(raw, "children", path, issues);
+      break;
+    case "block":
+      requireString(raw, "blockId", path, issues);
+      requireArray(raw, "children", path, issues);
+      break;
+    case "container":
+      requireArray(raw, "children", path, issues);
+      break;
+    case "text":
+      requireString(raw, "k", path, issues);
+      break;
+    case "image":
+      requireString(raw, "srcKey", path, issues);
+      break;
+    case "icon":
+      requireString(raw, "k", path, issues);
+      break;
+    case "repeater":
+      requireString(raw, "itemsKey", path, issues);
+      requireArray(raw, "itemTemplate", path, issues);
+      if (!isRecord(raw.defaultItem)) {
+        issues.push({
+          path: `${path}.defaultItem`,
+          message: "defaultItem must be an object mapping field names to default strings"
+        });
+      } else {
+        for (const [field, value] of Object.entries(raw.defaultItem)) {
+          if (typeof value !== "string") {
+            issues.push({
+              path: `${path}.defaultItem.${field}`,
+              message: "defaultItem values must be strings"
+            });
+          }
+        }
+      }
+      break;
+    case "form":
+      requireString(raw, "formId", path, issues);
+      if (!Array.isArray(raw.fields) || raw.fields.length === 0) {
+        issues.push({ path: `${path}.fields`, message: "form must declare at least one field" });
+        break;
+      }
+      for (let i = 0; i < raw.fields.length; i++) {
+        validateFormField(raw.fields[i], `${path}.fields[${i}]`, issues);
+      }
+      if (raw.endpoint === void 0 && raw.endpointKey === void 0) {
+        issues.push({
+          path,
+          message: "form must declare either endpoint or endpointKey"
+        });
+      }
+      break;
+    case "video":
+      requireString(raw, "srcKey", path, issues);
+      break;
+    case "animation":
+      requireArray(raw, "children", path, issues);
+      if (typeof raw.preset !== "string" || !ANIMATION_PRESETS.includes(raw.preset)) {
+        issues.push({
+          path: `${path}.preset`,
+          message: `preset must be one of ${ANIMATION_PRESETS.join(", ")}`
+        });
+      }
+      break;
+  }
+}
+function validateFormField(raw, path, issues) {
+  if (!isRecord(raw)) {
+    issues.push({ path, message: "field must be an object" });
+    return;
+  }
+  if (typeof raw.name !== "string" || raw.name.length === 0) {
+    issues.push({ path: `${path}.name`, message: "field.name must be a non-empty string" });
+  }
+  if (typeof raw.type !== "string" || !FIELD_TYPES.includes(raw.type)) {
+    issues.push({
+      path: `${path}.type`,
+      message: `field.type must be one of ${FIELD_TYPES.join(", ")}`
+    });
+  }
+  requireString(raw, "labelKey", path, issues);
+}
+function requireString(raw, field, path, issues) {
+  const value = raw[field];
+  if (typeof value !== "string" || value.length === 0) {
+    issues.push({ path: `${path}.${field}`, message: `${field} must be a non-empty string` });
+  }
+}
+function requireArray(raw, field, path, issues) {
+  if (!Array.isArray(raw[field])) {
+    issues.push({ path: `${path}.${field}`, message: `${field} must be an array` });
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fail(path, message) {
+  return { ok: false, issues: [{ path, message }] };
+}
+function parseBlockTree(input) {
+  const result = validateBlockTree(input);
+  if (!result.ok) {
+    const first = result.issues[0];
+    const detail = first ? `${first.path}: ${first.message}` : "unknown";
+    throw new Error(`Invalid block tree at ${detail}`);
+  }
+  return input;
+}
+const IconRegistryContext = createContext(null);
+const RepeaterScopeContext = createContext(null);
+function SettoBlockTree({ tree, icons, validate = true }) {
+  if (validate) {
+    const result = validateBlockTree(tree);
+    if (!result.ok) {
+      const first = result.issues[0];
+      const detail = first ? `${first.path}: ${first.message}` : "unknown";
+      throw new Error(`Invalid block tree at ${detail}`);
+    }
+  }
+  return /* @__PURE__ */ jsx(IconRegistryContext.Provider, { value: { icons }, children: tree.root.map((node) => /* @__PURE__ */ jsx(RenderNode, { node }, node.id)) });
+}
+function RenderNode({ node }) {
+  switch (node.type) {
+    case "section":
+      return /* @__PURE__ */ jsx(SettoSection, { sectionId: node.sectionId, className: node.className, children: renderChildren(node.children) });
+    case "block":
+      return /* @__PURE__ */ jsx(SettoBlock, { blockId: node.blockId, className: node.className, children: renderChildren(node.children) });
+    case "container":
+      return renderContainer(node.tag ?? "div", node.className, renderChildren(node.children));
+    case "animation":
+      return /* @__PURE__ */ jsx(
+        SettoAnimation,
+        {
+          preset: node.preset,
+          delay: node.delay,
+          duration: node.duration,
+          className: node.className,
+          children: renderChildren(node.children)
+        }
+      );
+    case "repeater":
+      return /* @__PURE__ */ jsx(
+        SettoRepeater,
+        {
+          itemsKey: node.itemsKey,
+          defaultItem: node.defaultItem,
+          itemLabel: node.itemLabel,
+          className: node.className,
+          children: (itemKey) => /* @__PURE__ */ jsx(
+            RepeaterScopeContext.Provider,
+            {
+              value: { itemsKey: node.itemsKey, itemKey },
+              children: renderChildren(node.itemTemplate)
+            }
+          )
+        }
+      );
+    case "text":
+      return /* @__PURE__ */ jsx(TextLeaf, { node });
+    case "image":
+      return /* @__PURE__ */ jsx(ImageLeaf, { node });
+    case "icon":
+      return /* @__PURE__ */ jsx(IconLeaf, { node });
+    case "form":
+      return /* @__PURE__ */ jsx(
+        SettoForm,
+        {
+          formId: node.formId,
+          fields: node.fields,
+          endpoint: node.endpoint,
+          endpointKey: node.endpointKey,
+          className: node.className
+        }
+      );
+    case "video":
+      return /* @__PURE__ */ jsx(VideoLeaf, { node });
+  }
+}
+function renderChildren(children) {
+  return children.map((child) => /* @__PURE__ */ jsx(RenderNode, { node: child }, child.id));
+}
+function TextLeaf({ node }) {
+  const k = useScopedKey(node.k);
+  const inner = /* @__PURE__ */ jsx(T, { k });
+  if (!node.as) {
+    return node.className ? /* @__PURE__ */ jsx("span", { className: node.className, children: inner }) : inner;
+  }
+  return renderTag(node.as, node.className, inner);
+}
+function ImageLeaf({ node }) {
+  const srcKey = useScopedKey(node.srcKey);
+  return /* @__PURE__ */ jsx(SettoImage, { srcKey, alt: node.alt, className: node.className });
+}
+function VideoLeaf({ node }) {
+  const srcKey = useScopedKey(node.srcKey);
+  const posterKey = useScopedKey(node.posterKey ?? "");
+  return /* @__PURE__ */ jsx(
+    SettoVideo,
+    {
+      srcKey,
+      posterKey: node.posterKey ? posterKey : void 0,
+      title: node.title,
+      className: node.className
+    }
+  );
+}
+function IconLeaf({ node }) {
+  const registry = useContext(IconRegistryContext);
+  const k = useScopedKey(node.k);
+  if (!registry) {
+    throw new Error("SettoBlockTree must be mounted with an `icons` prop for icon nodes");
+  }
+  return /* @__PURE__ */ jsx(
+    SettoIcon,
+    {
+      k,
+      icons: registry.icons,
+      size: node.size,
+      className: node.className
+    }
+  );
+}
+function useScopedKey(key) {
+  const scope = useContext(RepeaterScopeContext);
+  if (!scope) return key;
+  return `${scope.itemsKey}.${scope.itemKey}.${key}`;
+}
+function renderTag(tag, className, children) {
+  switch (tag) {
+    case "h1":
+      return /* @__PURE__ */ jsx("h1", { className, children });
+    case "h2":
+      return /* @__PURE__ */ jsx("h2", { className, children });
+    case "h3":
+      return /* @__PURE__ */ jsx("h3", { className, children });
+    case "h4":
+      return /* @__PURE__ */ jsx("h4", { className, children });
+    case "h5":
+      return /* @__PURE__ */ jsx("h5", { className, children });
+    case "h6":
+      return /* @__PURE__ */ jsx("h6", { className, children });
+    case "p":
+      return /* @__PURE__ */ jsx("p", { className, children });
+    case "span":
+      return /* @__PURE__ */ jsx("span", { className, children });
+    case "div":
+      return /* @__PURE__ */ jsx("div", { className, children });
+    case "label":
+      return /* @__PURE__ */ jsx("label", { className, children });
+    case "em":
+      return /* @__PURE__ */ jsx("em", { className, children });
+    case "strong":
+      return /* @__PURE__ */ jsx("strong", { className, children });
+  }
+}
+function renderContainer(tag, className, children) {
+  switch (tag) {
+    case "div":
+      return /* @__PURE__ */ jsx("div", { className, children });
+    case "section":
+      return /* @__PURE__ */ jsx("section", { className, children });
+    case "header":
+      return /* @__PURE__ */ jsx("header", { className, children });
+    case "footer":
+      return /* @__PURE__ */ jsx("footer", { className, children });
+    case "main":
+      return /* @__PURE__ */ jsx("main", { className, children });
+    case "aside":
+      return /* @__PURE__ */ jsx("aside", { className, children });
+    case "nav":
+      return /* @__PURE__ */ jsx("nav", { className, children });
+    case "article":
+      return /* @__PURE__ */ jsx("article", { className, children });
+    case "ul":
+      return /* @__PURE__ */ jsx("ul", { className, children });
+    case "ol":
+      return /* @__PURE__ */ jsx("ol", { className, children });
+    case "li":
+      return /* @__PURE__ */ jsx("li", { className, children });
+    case "p":
+      return /* @__PURE__ */ jsx("p", { className, children });
+    case "span":
+      return /* @__PURE__ */ jsx("span", { className, children });
+  }
+}
+function extractContentKeys(tree) {
+  const out = {
+    keys: /* @__PURE__ */ new Set(),
+    themeIds: /* @__PURE__ */ new Set(),
+    repeaters: []
+  };
+  for (const node of tree.root) {
+    walk(node, out, null);
+  }
+  return out;
+}
+function walk(node, out, repeaterCtx) {
+  switch (node.type) {
+    case "section":
+      out.themeIds.add(node.sectionId);
+      for (const child of node.children) walk(child, out, repeaterCtx);
+      return;
+    case "block":
+      out.themeIds.add(node.blockId);
+      for (const child of node.children) walk(child, out, repeaterCtx);
+      return;
+    case "container":
+    case "animation":
+      for (const child of node.children) walk(child, out, repeaterCtx);
+      return;
+    case "text":
+      out.keys.add(scopedKey(node.k, repeaterCtx));
+      return;
+    case "image":
+      out.keys.add(scopedKey(node.srcKey, repeaterCtx));
+      return;
+    case "icon":
+      out.keys.add(scopedKey(node.k, repeaterCtx));
+      return;
+    case "video":
+      out.keys.add(scopedKey(node.srcKey, repeaterCtx));
+      if (node.posterKey) out.keys.add(scopedKey(node.posterKey, repeaterCtx));
+      return;
+    case "form":
+      out.keys.add(`form.${node.formId}.submit`);
+      out.keys.add(`form.${node.formId}.success`);
+      if (node.endpointKey) out.keys.add(node.endpointKey);
+      for (const field of node.fields) {
+        out.keys.add(field.labelKey);
+        if (field.placeholderKey) out.keys.add(field.placeholderKey);
+      }
+      return;
+    case "repeater":
+      recordRepeater(node, out);
+      for (const child of node.itemTemplate) {
+        walk(child, out, { itemsKey: node.itemsKey });
+      }
+      return;
+  }
+}
+function scopedKey(key, repeaterCtx) {
+  if (!repeaterCtx) return key;
+  return `${repeaterCtx.itemsKey}.*.${key}`;
+}
+function recordRepeater(node, out) {
+  const fields = Object.keys(node.defaultItem);
+  const itemKeys = [];
+  collectRelativeKeys(node.itemTemplate, "", itemKeys);
+  out.repeaters.push({
+    itemsKey: node.itemsKey,
+    fields,
+    itemKeys
+  });
+}
+function collectRelativeKeys(nodes, prefix, out) {
+  for (const node of nodes) {
+    switch (node.type) {
+      case "text":
+      case "icon":
+        out.push(node.k);
+        break;
+      case "image":
+        out.push(node.srcKey);
+        break;
+      case "video":
+        out.push(node.srcKey);
+        if (node.posterKey) {
+          out.push(node.posterKey);
+        }
+        break;
+      case "section":
+      case "block":
+      case "container":
+      case "animation":
+        collectRelativeKeys(node.children, prefix, out);
+        break;
+    }
+  }
+}
 export {
   AuthGate,
+  BLOCK_REGISTRY,
+  BLOCK_TYPES,
   GuestEditProvider,
   SETTO_BASE,
   SettoAdminApp,
+  SettoAnimation,
   SettoBlock,
+  SettoBlockTree,
+  SettoForm,
   SettoIcon,
   SettoImage,
   SettoProvider,
   SettoRepeater,
   SettoSection,
+  SettoVideo,
   T,
+  extractContentKeys,
+  nodeChildren,
+  parseBlockTree,
   useGuestEdit,
   useSectionTheme,
-  useSetto
+  useSetto,
+  validateBlockTree
 };
 //# sourceMappingURL=setto-client.js.map