@styleflow.app/flowpress-astro-core 0.2.0-beta.0 → 0.2.0-beta.11

package/dist/astro/blocks/FormBlock.astro

@@ -0,0 +1,233 @@
+---
+import S from "@styleflow.app/astro/S.astro";
+import type { FlowpressBlock } from "../../types.js";
+import type { StyleflowContract } from "../../styleflow.js";
+import { blockHtmlAttributes, semanticProps } from "./helpers.js";
+
+interface FormField {
+  name: string;
+  type: string;
+  required?: boolean;
+  values?: string[];
+  labels?: string[];
+  options?: string[];
+}
+
+interface FormSchema {
+  id: number;
+  title: string;
+  fields: FormField[];
+  submitUrl: string;
+  turnstileSiteKey: string;
+  available: boolean;
+}
+
+interface Props {
+  block: FlowpressBlock;
+  contract?: StyleflowContract;
+}
+
+const { block, contract } = Astro.props;
+const schema = block.attributes.formSchema as FormSchema | undefined;
+const semantic = semanticProps(block.attributes, contract);
+const htmlAttributes = blockHtmlAttributes(block.attributes);
+const labelFor = (field: FormField): string => field.name
+  .replace(/[-_]+/g, " ")
+  .replace(/\b\w/g, (letter) => letter.toUpperCase());
+const optionLabel = (field: FormField, index: number): string =>
+  field.labels?.[index] || field.values?.[index] || "";
+---
+
+{schema?.available ? (
+  <S as="div" {...semantic} {...htmlAttributes}>
+    <flowpress-cf7-form>
+      <form action={schema.submitUrl} method="post" enctype="multipart/form-data" novalidate>
+        {block.attributes.title || schema.title ? (
+          <S as="h2">{String(block.attributes.title || schema.title)}</S>
+        ) : null}
+        {schema.fields.map((field) => {
+          if (field.type === "submit") {
+            return (
+              <button type="submit">
+                {field.values?.[0] || "Invia"}
+              </button>
+            );
+          }
+          if (field.type === "hidden") {
+            return <input type="hidden" name={field.name} value={field.values?.[0] || ""} />;
+          }
+          if (["checkbox", "radio"].includes(field.type)) {
+            return (
+              <fieldset>
+                <legend>{labelFor(field)}</legend>
+                {(field.values || []).map((value, index) => (
+                  <label>
+                    <input
+                      type={field.type}
+                      name={field.type === "checkbox" ? `${field.name}[]` : field.name}
+                      value={value}
+                      required={field.required}
+                    />
+                    {optionLabel(field, index)}
+                  </label>
+                ))}
+                <span data-field-error={field.name}></span>
+              </fieldset>
+            );
+          }
+          if (field.type === "acceptance") {
+            return (
+              <label>
+                <input type="checkbox" name={field.name} value="1" required={field.required} />
+                {field.values?.[0] || labelFor(field)}
+                <span data-field-error={field.name}></span>
+              </label>
+            );
+          }
+          if (field.type === "select") {
+            return (
+              <label>
+                {labelFor(field)}
+                <select
+                  name={field.options?.includes("multiple") ? `${field.name}[]` : field.name}
+                  required={field.required}
+                  multiple={field.options?.includes("multiple")}
+                >
+                  {(field.values || []).map((value, index) => (
+                    <option value={value}>{optionLabel(field, index)}</option>
+                  ))}
+                </select>
+                <span data-field-error={field.name}></span>
+              </label>
+            );
+          }
+          if (field.type === "textarea") {
+            return (
+              <label>
+                {labelFor(field)}
+                <textarea name={field.name} required={field.required}></textarea>
+                <span data-field-error={field.name}></span>
+              </label>
+            );
+          }
+          return (
+            <label>
+              {labelFor(field)}
+              <input
+                type={field.type === "file" ? "file" : field.type}
+                name={field.name}
+                required={field.required}
+              />
+              <span data-field-error={field.name}></span>
+            </label>
+          );
+        })}
+        <div
+          data-turnstile
+          data-sitekey={schema.turnstileSiteKey}
+          aria-label="Verifica anti-spam"
+        ></div>
+        <p data-form-status role="status" aria-live="polite"></p>
+      </form>
+    </flowpress-cf7-form>
+  </S>
+) : (
+  <S as="p" {...semantic} {...htmlAttributes} role="status">
+    Il modulo non è temporaneamente disponibile.
+  </S>
+)}
+
+<script>
+  declare global {
+    interface Window {
+      turnstile?: {
+        render(target: Element, options: Record<string, unknown>): string;
+        reset(widgetId?: string): void;
+      };
+    }
+  }
+
+  let turnstilePromise: Promise<void> | undefined;
+  const loadTurnstile = (): Promise<void> => {
+    if (window.turnstile) return Promise.resolve();
+    if (turnstilePromise) return turnstilePromise;
+    turnstilePromise = new Promise((resolve, reject) => {
+      const existing = document.querySelector<HTMLScriptElement>(
+        'script[data-flowpress-turnstile]'
+      );
+      if (existing) {
+        existing.addEventListener("load", () => resolve(), { once: true });
+        existing.addEventListener("error", () => reject(new Error("Turnstile unavailable")), { once: true });
+        return;
+      }
+      const script = document.createElement("script");
+      script.src = "https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit";
+      script.async = true;
+      script.defer = true;
+      script.dataset.flowpressTurnstile = "true";
+      script.addEventListener("load", () => resolve(), { once: true });
+      script.addEventListener("error", () => reject(new Error("Turnstile unavailable")), { once: true });
+      document.head.append(script);
+    });
+    return turnstilePromise;
+  };
+
+  if (!customElements.get("flowpress-cf7-form")) {
+    customElements.define("flowpress-cf7-form", class extends HTMLElement {
+      private widgetId?: string;
+
+      connectedCallback() {
+        const form = this.querySelector<HTMLFormElement>("form");
+        const target = this.querySelector<HTMLElement>("[data-turnstile]");
+        const status = this.querySelector<HTMLElement>("[data-form-status]");
+        if (!form || !target || !status) return;
+
+        loadTurnstile()
+          .then(() => {
+            if (!window.turnstile || this.widgetId) return;
+            this.widgetId = window.turnstile.render(target, {
+              sitekey: target.dataset.sitekey
+            });
+          })
+          .catch(() => {
+            status.textContent = "La verifica anti-spam non è disponibile.";
+          });
+
+        form.addEventListener("submit", async (event) => {
+          event.preventDefault();
+          status.textContent = "Invio in corso…";
+          form.querySelectorAll<HTMLElement>("[data-field-error]")
+            .forEach((node) => { node.textContent = ""; });
+          const submit = form.querySelector<HTMLButtonElement>('[type="submit"]');
+          if (submit) submit.disabled = true;
+          try {
+            const response = await fetch(form.action, {
+              method: "POST",
+              body: new FormData(form),
+              headers: { Accept: "application/json" }
+            });
+            const result = await response.json() as {
+              message?: string;
+              invalidFields?: Array<{ field?: string; into?: string; message?: string }>;
+            };
+            status.textContent = result.message || (response.ok ? "Messaggio inviato." : "Invio non riuscito.");
+            for (const invalid of result.invalidFields || []) {
+              const name = invalid.field || invalid.into?.replace(/^span\./, "") || "";
+              const node = name
+                ? form.querySelector<HTMLElement>(`[data-field-error="${CSS.escape(name)}"]`)
+                : null;
+              if (node) node.textContent = invalid.message || "";
+            }
+            if (response.ok) form.reset();
+            if (window.turnstile) window.turnstile.reset(this.widgetId);
+          } catch {
+            status.textContent = "Impossibile inviare il modulo. Riprova.";
+            if (window.turnstile) window.turnstile.reset(this.widgetId);
+          } finally {
+            if (submit) submit.disabled = false;
+          }
+        });
+      }
+    });
+  }
+</script>

package/dist/astro/blocks/GridBlock.astro

@@ -0,0 +1,70 @@
+---
+import S from "@styleflow.app/astro/S.astro";
+import type { FlowpressBlock } from "../../types.js";
+import type { StyleflowContract } from "../../styleflow.js";
+import {
+  blockHtmlAttributes,
+  responsiveValues,
+  semanticProps
+} from "./helpers.js";
+
+interface Props {
+  block: FlowpressBlock;
+  contract?: StyleflowContract;
+}
+
+const { block, contract } = Astro.props;
+const values = responsiveValues(
+  block.attributes,
+  "columns",
+  Number(block.attributes.columns) || 12
+);
+const align = ["start", "center", "end", "stretch"].includes(
+  String(block.attributes.align)
+) ? String(block.attributes.align) : "stretch";
+const semantic = semanticProps(block.attributes, contract, {
+  surface: "default",
+  layoutRole: "container",
+  density: "md"
+});
+const htmlAttributes = blockHtmlAttributes(block.attributes, "flowpress-grid");
+const style = [
+  `--flowpress-grid-base:${values.base}`,
+  `--flowpress-grid-sm:${values.sm}`,
+  `--flowpress-grid-md:${values.md}`,
+  `--flowpress-grid-lg:${values.lg}`,
+  `--flowpress-grid-xl:${values.xl}`,
+  `--flowpress-grid-2xl:${values["2xl"]}`
+].join(";");
+---
+
+<S as="div" {...semantic} {...htmlAttributes} data-align={align} style={style}>
+  <slot />
+</S>
+
+<style>
+  .flowpress-grid {
+    display: grid;
+    grid-template-columns: repeat(var(--flowpress-grid-base), minmax(0, 1fr));
+    align-items: var(--flowpress-grid-align, stretch);
+  }
+  .flowpress-grid[data-align="start"] { --flowpress-grid-align: start; }
+  .flowpress-grid[data-align="center"] { --flowpress-grid-align: center; }
+  .flowpress-grid[data-align="end"] { --flowpress-grid-align: end; }
+  .flowpress-grid[data-align="stretch"] { --flowpress-grid-align: stretch; }
+  @media (min-width: 40rem) {
+    .flowpress-grid { grid-template-columns: repeat(var(--flowpress-grid-sm), minmax(0, 1fr)); }
+  }
+  @media (min-width: 48rem) {
+    .flowpress-grid { grid-template-columns: repeat(var(--flowpress-grid-md), minmax(0, 1fr)); }
+  }
+  @media (min-width: 64rem) {
+    .flowpress-grid { grid-template-columns: repeat(var(--flowpress-grid-lg), minmax(0, 1fr)); }
+  }
+  @media (min-width: 80rem) {
+    .flowpress-grid { grid-template-columns: repeat(var(--flowpress-grid-xl), minmax(0, 1fr)); }
+  }
+  @media (min-width: 96rem) {
+    .flowpress-grid { grid-template-columns: repeat(var(--flowpress-grid-2xl), minmax(0, 1fr)); }
+  }
+</style>

package/dist/astro/blocks/HeroBlock.astro

@@ -0,0 +1,113 @@
+---
+import S from "@styleflow.app/astro/S.astro";
+import type { FlowpressBlock } from "../../types.js";
+import type { StyleflowContract } from "../../styleflow.js";
+import {
+  blockHtmlAttributes,
+  objectValue,
+  semanticProps
+} from "./helpers.js";
+
+interface Props {
+  block: FlowpressBlock;
+  contract?: StyleflowContract;
+}
+
+const { block, contract } = Astro.props;
+const attributes = block.attributes;
+const semantic = semanticProps(attributes, contract, {
+  surface: "default",
+  layoutRole: "region",
+  density: "md"
+});
+const htmlAttributes = blockHtmlAttributes(attributes, "flowpress-hero");
+const backgroundType = ["color", "image", "video"].includes(
+  String(attributes.backgroundType)
+) ? String(attributes.backgroundType) : "color";
+const image = objectValue(block, "backgroundImage");
+const video = objectValue(block, "backgroundVideo");
+const imageSrc = String(image.url ?? image.sourceUrl ?? "");
+const videoSrc = String(video.url ?? video.sourceUrl ?? video.mediaItemUrl ?? "");
+const scrimEnabled = Boolean(attributes.scrimEnabled) && backgroundType !== "color";
+const scrimIntensity = Math.min(10, Math.max(1, Number(attributes.scrimIntensity) || 6));
+---
+
+<S
+  as="section"
+  {...semantic}
+  {...htmlAttributes}
+  style={`--flowpress-scrim-opacity:${scrimIntensity * 10}%`}
+>
+  {backgroundType === "image" && imageSrc ? (
+    <img
+      class="flowpress-hero__media"
+      src={imageSrc}
+      alt=""
+      aria-hidden="true"
+      loading="eager"
+      decoding="async"
+    />
+  ) : null}
+  {backgroundType === "video" && videoSrc ? (
+    <video
+      class="flowpress-hero__media"
+      src={videoSrc}
+      poster={imageSrc || undefined}
+      autoplay
+      muted
+      loop
+      playsinline
+      preload="metadata"
+      aria-hidden="true"
+      tabindex="-1"
+    />
+  ) : null}
+  {scrimEnabled ? <span class="flowpress-hero__scrim" aria-hidden="true"></span> : null}
+  <div class="flowpress-hero__content">
+    <slot />
+  </div>
+</S>
+
+<style>
+  .flowpress-hero {
+    position: relative;
+    display: grid;
+    overflow: hidden;
+    isolation: isolate;
+  }
+
+  .flowpress-hero__media,
+  .flowpress-hero__scrim {
+    position: absolute;
+    inset: 0;
+    width: 100%;
+    height: 100%;
+  }
+
+  .flowpress-hero__media {
+    z-index: -2;
+    object-fit: cover;
+  }
+
+  .flowpress-hero__scrim {
+    z-index: -1;
+    background: color-mix(
+      in srgb,
+      var(--sf-background) var(--flowpress-scrim-opacity),
+      transparent
+    );
+    pointer-events: none;
+  }
+
+  .flowpress-hero__content {
+    position: relative;
+    display: grid;
+    gap: inherit;
+  }
+
+  @media (prefers-reduced-motion: reduce) {
+    .flowpress-hero__media:is(video) {
+      display: none;
+    }
+  }
+</style>

package/dist/astro/blocks/ListItemFallback.astro

@@ -0,0 +1,28 @@
+---
+import S from "@styleflow.app/astro/S.astro";
+
+interface Props {
+  item: Record<string, unknown>;
+}
+
+const { item } = Astro.props;
+const image = item.image && typeof item.image === "object" && !Array.isArray(item.image)
+  ? item.image as Record<string, unknown>
+  : {};
+---
+
+{image.url ? (
+  <img
+    src={String(image.url)}
+    alt={String(image.alt ?? "")}
+    loading="lazy"
+    decoding="async"
+  />
+) : null}
+{item.uri ? (
+  <S as="a" href={String(item.uri)}>{String(item.title ?? "")}</S>
+) : (
+  <S as="span">{String(item.title ?? "")}</S>
+)}
+{item.excerpt ? <S as="p">{String(item.excerpt)}</S> : null}
+{item.priceHtml ? <S as="div" set:html={String(item.priceHtml)} /> : null}

package/dist/astro/blocks/TextBlock.astro

@@ -0,0 +1,83 @@
+---
+import S from "@styleflow.app/astro/S.astro";
+import type { FlowpressBlock } from "../../types.js";
+import type { StyleflowContract } from "../../styleflow.js";
+import {
+  blockHtmlAttributes,
+  preserveEmptyTextBlock,
+  preserveRichTextSpacing,
+  semanticProps,
+  textValue,
+  unwrapCoreHtml
+} from "./helpers.js";
+
+interface Props {
+  block: FlowpressBlock;
+  contract?: StyleflowContract;
+  hasChildren?: boolean;
+}
+
+const { block, contract, hasChildren = false } = Astro.props;
+const name = block.name.replace(/^sf\//, "");
+const attributes = block.attributes;
+const heading = name === "heading" || name === "core/heading";
+const level = Math.min(6, Math.max(1, Number(attributes.level ?? 2)));
+const headingTag = `h${level}` as "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+const defaults = heading
+  ? {
+      ty: "heading",
+      v: String(attributes.v ?? attributes.variant ?? level),
+      w: String(attributes.w ?? attributes.weight ?? "strong"),
+      foreground: "primary"
+    }
+  : {
+      ty: "body",
+      v: String(attributes.v ?? (name.includes("quote") ? "lg" : "md")),
+      w: String(attributes.w ?? "default"),
+      foreground: "primary"
+    };
+const semantic = semanticProps(attributes, contract, defaults);
+const htmlAttributes = blockHtmlAttributes(attributes);
+const coreHtml = String(
+  attributes.content
+  ?? attributes.value
+  ?? block.innerHtml
+  ?? ""
+);
+const normalizedHtml = name === "heading"
+  ? textValue(block)
+  : name === "rich-text"
+    ? preserveRichTextSpacing(String(attributes.content ?? ""))
+    : name === "quote"
+      ? textValue(block, "quote")
+      : unwrapCoreHtml(preserveRichTextSpacing(coreHtml));
+const html = name === "core/list"
+  ? normalizedHtml
+  : preserveEmptyTextBlock(normalizedHtml);
+const listTag = Boolean(attributes.ordered) ? "ol" : "ul";
+---
+
+{heading ? (
+  <S as={headingTag} {...semantic} {...htmlAttributes} set:html={html} />
+) : name === "core/list" ? (
+  <S as={listTag} {...semantic} {...htmlAttributes}>
+    {hasChildren ? <slot /> : <Fragment set:html={html} />}
+  </S>
+) : name === "core/list-item" ? (
+  <S as="li" {...semantic} {...htmlAttributes}>
+    <span set:html={html}></span>
+    {hasChildren ? <slot /> : null}
+  </S>
+) : name === "quote" || name === "core/quote" ? (
+  <S as="blockquote" {...semantic} {...htmlAttributes}>
+    {hasChildren ? <slot /> : <div set:html={html}></div>}
+    {attributes.citation ? <cite>{String(attributes.citation)}</cite> : null}
+  </S>
+) : (
+  <S
+    as={name === "core/paragraph" ? "p" : "div"}
+    {...semantic}
+    {...htmlAttributes}
+    set:html={html}
+  />
+)}

package/dist/astro/blocks/helpers.d.ts

@@ -0,0 +1,26 @@
+import { type StyleflowContract } from "../../styleflow.js";
+import type { FlowpressBlock } from "../../types.js";
+export declare const DEFAULT_SEMANTIC_PROPS: {
+    surface: string;
+    layoutRole: string;
+    density: string;
+};
+export declare function blockHtmlAttributes(attributes: Record<string, unknown>, baseClass?: string): {
+    id?: string;
+    class?: string;
+};
+export declare function semanticProps(attributes: Record<string, unknown>, contract?: StyleflowContract, defaults?: Record<string, unknown>): Record<string, unknown>;
+export declare function objectValue(block: FlowpressBlock, key: string): Record<string, unknown>;
+export declare function textValue(block: FlowpressBlock, key?: string): string;
+/**
+ * Keep intentional blank lines visible across current and legacy RichText
+ * serializations. Gutenberg can represent them either as repeated `<br>` tags,
+ * empty paragraph elements, or literal newlines in an attribute value.
+ */
+export declare function preserveRichTextSpacing(html: string): string;
+/** Keep an empty text element at its typographic line height without visible text. */
+export declare function preserveEmptyTextBlock(html: string): string;
+export declare function linkValue(block: FlowpressBlock, key?: string): string;
+export declare function responsiveValues(attributes: Record<string, unknown>, prefix: "columns" | "span", fallback: number): Record<"base" | "sm" | "md" | "lg" | "xl" | "2xl", number>;
+export declare function unwrapCoreHtml(html: string): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/astro/blocks/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/astro/blocks/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,eAAO,MAAM,sBAAsB;;;;CAIlC,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,SAAS,SAAK,GACb;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAgBjC;AAqBD,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,QAAQ,CAAC,EAAE,iBAAiB,EAC5B,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAA0B,GACzD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASzB;AAED,wBAAgB,WAAW,CACzB,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,MAAM,GACV,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzB;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,SAAS,GAAG,MAAM,CAErE;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoB5D;AAED,sFAAsF;AACtF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,SAAS,GAAG,MAAM,CAMrE;AAED,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,MAAM,EAAE,SAAS,GAAG,MAAM,EAC1B,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,EAAE,MAAM,CAAC,CAe5D;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKnD"}

package/dist/astro/blocks/helpers.js

@@ -0,0 +1,108 @@
+import { resolveDynamicStyleflowProps } from "../../styleflow.js";
+export const DEFAULT_SEMANTIC_PROPS = {
+    surface: "default",
+    layoutRole: "stack",
+    density: "md"
+};
+export function blockHtmlAttributes(attributes, baseClass = "") {
+    const anchor = typeof attributes.anchor === "string"
+        ? attributes.anchor.trim()
+        : "";
+    const customClass = typeof attributes.className === "string"
+        ? attributes.className.trim()
+        : "";
+    const className = [baseClass.trim(), customClass]
+        .filter(Boolean)
+        .join(" ")
+        .replace(/\s+/g, " ");
+    return {
+        ...(anchor ? { id: anchor } : {}),
+        ...(className ? { class: className } : {})
+    };
+}
+const SEMANTIC_KEYS = [
+    "tone",
+    "intensity",
+    "surface",
+    "layoutRole",
+    "density",
+    "ty",
+    "v",
+    "w",
+    "foreground",
+    "interactivePriority",
+    "noBackground",
+    "noBorder",
+    "noPadding",
+    "noGap",
+    "noRadius",
+    "noForeground"
+];
+export function semanticProps(attributes, contract, defaults = DEFAULT_SEMANTIC_PROPS) {
+    const input = Object.fromEntries(SEMANTIC_KEYS
+        .filter((key) => attributes[key] !== undefined)
+        .map((key) => [key, attributes[key]]));
+    return contract
+        ? resolveDynamicStyleflowProps(input, defaults, contract)
+        : { ...defaults, ...input };
+}
+export function objectValue(block, key) {
+    const value = block.attributes[key];
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function textValue(block, key = "text") {
+    return String(block.attributes[key] ?? "");
+}
+/**
+ * Keep intentional blank lines visible across current and legacy RichText
+ * serializations. Gutenberg can represent them either as repeated `<br>` tags,
+ * empty paragraph elements, or literal newlines in an attribute value.
+ */
+export function preserveRichTextSpacing(html) {
+    const visibleEmptyBlocks = html
+        .replace(/\r\n?/g, "\n")
+        .replace(/<(p|div)(\s[^>]*)?>(?:\s|&nbsp;|&#160;)*<\/\1>/gi, (_match, tag, attributes = "") => `<${tag}${attributes}>&nbsp;</${tag}>`);
+    return visibleEmptyBlocks
+        .split(/(<[^>]+>)/g)
+        .map((part) => {
+        if (part.startsWith("<") || part.trim() === "") {
+            return part;
+        }
+        return part.replace(/\n(?:[ \t]*\n)+/g, (newlines) => "<br>".repeat((newlines.match(/\n/g) || []).length));
+    })
+        .join("");
+}
+/** Keep an empty text element at its typographic line height without visible text. */
+export function preserveEmptyTextBlock(html) {
+    return html.trim() === "" ? "&nbsp;" : html;
+}
+export function linkValue(block, key = "link") {
+    const value = block.attributes[key];
+    const href = typeof value === "string"
+        ? value
+        : String(objectValue(block, key).url ?? "");
+    return /^(?:\/(?!\/)|#|https?:\/\/|mailto:|tel:)/i.test(href) ? href : "";
+}
+export function responsiveValues(attributes, prefix, fallback) {
+    const keys = ["base", "sm", "md", "lg", "xl", "2xl"];
+    const result = {};
+    let inherited = fallback;
+    for (const key of keys) {
+        const suffix = key === "base"
+            ? "Base"
+            : key === "2xl" ? "2xl" : key.charAt(0).toUpperCase() + key.slice(1);
+        const candidate = Number(attributes[`${prefix}${suffix}`]);
+        if (Number.isInteger(candidate) && candidate >= 1 && candidate <= 12) {
+            inherited = candidate;
+        }
+        result[key] = inherited;
+    }
+    return result;
+}
+export function unwrapCoreHtml(html) {
+    const match = html.trim().match(/^<(p|h[1-6]|ul|ol|li|blockquote)(?:\s[^>]*)?>([\s\S]*)<\/\1>$/);
+    return match?.[2] ?? html;
+}
+//# sourceMappingURL=helpers.js.map