@bendyline/docblocks-react 2.2.0 → 2.2.2

package/dist/chunk-VRRL6VTD.js

@@ -0,0 +1,606 @@
+import {
+  Dialog
+} from "./chunk-LG6HAWCK.js";
+
+// src/Settings/Settings.tsx
+import {
+  useCallback,
+  useEffect,
+  useId,
+  useLayoutEffect,
+  useRef,
+  useState
+} from "react";
+
+// src/preferences/theme.ts
+var ACCENT_COLORS = [
+  "brown",
+  "green",
+  "blue",
+  "purple",
+  "maroon",
+  "orange",
+  "gray"
+];
+var DB_CHROME_COLORS = {
+  light: "#f3eede",
+  dark: "#262219"
+};
+var THEME_STORAGE_KEY = "docblocks:themePreference";
+var ACCENT_STORAGE_KEY = "docblocks:accentColor";
+function loadThemePreference() {
+  try {
+    const raw = localStorage.getItem(THEME_STORAGE_KEY);
+    if (raw === "light" || raw === "dark" || raw === "auto") return raw;
+  } catch {
+  }
+  return "auto";
+}
+function saveThemePreference(value) {
+  try {
+    localStorage.setItem(THEME_STORAGE_KEY, value);
+  } catch {
+  }
+}
+function loadAccentColor() {
+  try {
+    const raw = localStorage.getItem(ACCENT_STORAGE_KEY);
+    if (ACCENT_COLORS.some((color) => color === raw)) return raw;
+  } catch {
+  }
+  return "brown";
+}
+function saveAccentColor(value) {
+  try {
+    localStorage.setItem(ACCENT_STORAGE_KEY, value);
+  } catch {
+  }
+}
+
+// src/preferences/write-canvas.ts
+var SANS_STACK = 'system-ui, -apple-system, "Segoe UI", Roboto, sans-serif';
+var SERIF_STACK = 'Georgia, "Times New Roman", serif';
+var WRITE_CANVAS_FONT_SCHEMES = [
+  { id: "theme", label: "Inherit from theme", group: "theme" },
+  {
+    id: "serif-sans",
+    label: "Serif headings \xB7 Sans body",
+    group: "system",
+    headerFont: SERIF_STACK,
+    bodyFont: SANS_STACK
+  },
+  {
+    id: "sans-sans",
+    label: "Sans headings \xB7 Sans body",
+    group: "system",
+    headerFont: SANS_STACK,
+    bodyFont: SANS_STACK
+  },
+  {
+    id: "serif-serif",
+    label: "Serif headings \xB7 Serif body",
+    group: "system",
+    headerFont: SERIF_STACK,
+    bodyFont: SERIF_STACK
+  },
+  {
+    id: "pt-serif",
+    label: "PT Serif",
+    group: "curated",
+    headerFont: '"PT Serif", Georgia, serif',
+    bodyFont: '"PT Serif", Georgia, serif'
+  },
+  {
+    id: "hanken",
+    label: "Hanken Grotesk",
+    group: "curated",
+    headerFont: '"Hanken Grotesk", system-ui, sans-serif',
+    bodyFont: '"Hanken Grotesk", system-ui, sans-serif'
+  },
+  {
+    id: "playfair-pt-serif",
+    label: "Playfair Display \xB7 PT Serif",
+    group: "curated",
+    headerFont: '"Playfair Display", Georgia, serif',
+    bodyFont: '"PT Serif", Georgia, serif'
+  },
+  {
+    id: "hanken-lora",
+    label: "Hanken Grotesk \xB7 Lora",
+    group: "curated",
+    headerFont: '"Hanken Grotesk", system-ui, sans-serif',
+    bodyFont: '"Lora", Georgia, serif'
+  },
+  {
+    id: "dm-serif-dm-sans",
+    label: "DM Serif Display \xB7 DM Sans",
+    group: "curated",
+    headerFont: '"DM Serif Display", Georgia, serif',
+    bodyFont: '"DM Sans", system-ui, sans-serif'
+  },
+  {
+    id: "inter",
+    label: "Inter",
+    group: "curated",
+    headerFont: '"Inter", system-ui, sans-serif',
+    bodyFont: '"Inter", system-ui, sans-serif'
+  }
+];
+var FONT_SCHEMES_BY_ID = new Map(WRITE_CANVAS_FONT_SCHEMES.map((scheme) => [scheme.id, scheme]));
+var DEFAULT_WRITE_CANVAS_FONT_SCHEME = "theme";
+function resolveWriteCanvasFonts(scheme) {
+  const option = FONT_SCHEMES_BY_ID.get(scheme);
+  const resolved = {};
+  if (option?.headerFont) resolved.headerFont = option.headerFont;
+  if (option?.bodyFont) resolved.bodyFont = option.bodyFont;
+  return resolved;
+}
+function isWriteCanvasFontScheme(value) {
+  return typeof value === "string" && FONT_SCHEMES_BY_ID.has(value);
+}
+var WRITE_CANVAS_TEXT_SIZE_MIN = 12;
+var WRITE_CANVAS_TEXT_SIZE_MAX = 32;
+var WRITE_CANVAS_LINE_SPACING_MIN = 1;
+var WRITE_CANVAS_LINE_SPACING_MAX = 2.4;
+var DEFAULT_WRITE_CANVAS_PREFERENCES = {
+  textSize: 16,
+  lineSpacing: 1.7,
+  fontScheme: DEFAULT_WRITE_CANVAS_FONT_SCHEME
+};
+var WRITE_CANVAS_STORAGE_KEY = "docblocks:writeCanvasSettings";
+function loadWriteCanvasPreferences() {
+  try {
+    const raw = localStorage.getItem(WRITE_CANVAS_STORAGE_KEY);
+    if (!raw) return { ...DEFAULT_WRITE_CANVAS_PREFERENCES };
+    const stored = JSON.parse(raw);
+    if (!isRecord(stored)) return { ...DEFAULT_WRITE_CANVAS_PREFERENCES };
+    return {
+      textSize: numberInRange(
+        stored.textSize,
+        WRITE_CANVAS_TEXT_SIZE_MIN,
+        WRITE_CANVAS_TEXT_SIZE_MAX
+      ) ? stored.textSize : DEFAULT_WRITE_CANVAS_PREFERENCES.textSize,
+      lineSpacing: numberInRange(
+        stored.lineSpacing,
+        WRITE_CANVAS_LINE_SPACING_MIN,
+        WRITE_CANVAS_LINE_SPACING_MAX
+      ) ? stored.lineSpacing : DEFAULT_WRITE_CANVAS_PREFERENCES.lineSpacing,
+      // Older stored preferences predate fontScheme; fall back to the default.
+      fontScheme: isWriteCanvasFontScheme(stored.fontScheme) ? stored.fontScheme : DEFAULT_WRITE_CANVAS_PREFERENCES.fontScheme
+    };
+  } catch {
+    return { ...DEFAULT_WRITE_CANVAS_PREFERENCES };
+  }
+}
+function saveWriteCanvasPreferences(value) {
+  try {
+    localStorage.setItem(WRITE_CANVAS_STORAGE_KEY, JSON.stringify(value));
+  } catch {
+  }
+}
+function numberInRange(value, min, max) {
+  return typeof value === "number" && Number.isFinite(value) && value >= min && value <= max;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/Settings/Settings.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var ACCENT_LABELS = {
+  brown: "Brown",
+  green: "Green",
+  blue: "Blue",
+  purple: "Purple",
+  maroon: "Maroon",
+  orange: "Orange",
+  gray: "Gray"
+};
+function SettingsDialog({ title = "Settings", onClose, children }) {
+  return /* @__PURE__ */ jsx(Dialog, { title, onClose, size: "wide", children });
+}
+function ThemeSettings({ value, onChange, name = "theme" }) {
+  return /* @__PURE__ */ jsxs("fieldset", { className: "db-settings-fieldset", children: [
+    /* @__PURE__ */ jsx("legend", { className: "db-settings-legend", children: "Theme" }),
+    /* @__PURE__ */ jsxs("div", { className: "db-settings-radio-row", children: [
+      /* @__PURE__ */ jsxs("label", { className: "db-settings-radio db-settings-radio--inline", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "radio",
+            name,
+            value: "auto",
+            checked: value === "auto",
+            onChange: () => onChange("auto")
+          }
+        ),
+        "System default"
+      ] }),
+      /* @__PURE__ */ jsxs("label", { className: "db-settings-radio db-settings-radio--inline", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "radio",
+            name,
+            value: "light",
+            checked: value === "light",
+            onChange: () => onChange("light")
+          }
+        ),
+        "Light"
+      ] }),
+      /* @__PURE__ */ jsxs("label", { className: "db-settings-radio db-settings-radio--inline", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "radio",
+            name,
+            value: "dark",
+            checked: value === "dark",
+            onChange: () => onChange("dark")
+          }
+        ),
+        "Dark"
+      ] })
+    ] })
+  ] });
+}
+function AccentColorSettings({
+  value,
+  onChange,
+  name = "accent-color"
+}) {
+  return /* @__PURE__ */ jsxs("fieldset", { className: "db-settings-fieldset", children: [
+    /* @__PURE__ */ jsx("legend", { className: "db-settings-legend", children: "Accent color" }),
+    /* @__PURE__ */ jsx("p", { className: "db-settings-hint", children: "Used in both light and dark appearances." }),
+    /* @__PURE__ */ jsx("div", { className: "db-settings-accent-grid", children: ACCENT_COLORS.map((color) => /* @__PURE__ */ jsxs(
+      "label",
+      {
+        className: `db-settings-accent${value === color ? " db-settings-accent--selected" : ""}`,
+        children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              className: "db-settings-accent-input",
+              type: "radio",
+              name,
+              value: color,
+              checked: value === color,
+              onChange: () => onChange(color)
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: `db-settings-accent-swatch db-settings-accent-swatch--${color}`,
+              "aria-hidden": "true"
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { children: ACCENT_LABELS[color] })
+        ]
+      },
+      color
+    )) })
+  ] });
+}
+function WriteCanvasSettingsControls({ value, onChange }) {
+  return /* @__PURE__ */ jsxs("fieldset", { className: "db-settings-fieldset", children: [
+    /* @__PURE__ */ jsx("legend", { className: "db-settings-legend", children: "Write canvas" }),
+    /* @__PURE__ */ jsx("p", { className: "db-settings-hint", children: "Adjust the writing view without changing the document or its exported text." }),
+    /* @__PURE__ */ jsxs("label", { className: "db-settings-slider", children: [
+      /* @__PURE__ */ jsxs("span", { className: "db-settings-slider-header", children: [
+        /* @__PURE__ */ jsx("span", { children: "Text size" }),
+        /* @__PURE__ */ jsxs("output", { className: "db-settings-slider-value", "aria-hidden": "true", children: [
+          value.textSize,
+          "px"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "range",
+          min: WRITE_CANVAS_TEXT_SIZE_MIN,
+          max: WRITE_CANVAS_TEXT_SIZE_MAX,
+          step: 1,
+          value: value.textSize,
+          "aria-label": "Text size",
+          "aria-valuetext": `${value.textSize} pixels`,
+          onChange: (event) => onChange({ ...value, textSize: Number(event.currentTarget.value) })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("label", { className: "db-settings-slider", children: [
+      /* @__PURE__ */ jsxs("span", { className: "db-settings-slider-header", children: [
+        /* @__PURE__ */ jsx("span", { children: "Line spacing" }),
+        /* @__PURE__ */ jsx("output", { className: "db-settings-slider-value", "aria-hidden": "true", children: formatLineSpacing(value.lineSpacing) })
+      ] }),
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "range",
+          min: WRITE_CANVAS_LINE_SPACING_MIN,
+          max: WRITE_CANVAS_LINE_SPACING_MAX,
+          step: 0.1,
+          value: value.lineSpacing,
+          "aria-label": "Line spacing",
+          "aria-valuetext": `${value.lineSpacing} times`,
+          onChange: (event) => onChange({ ...value, lineSpacing: Number(event.currentTarget.value) })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(
+      FontSchemePicker,
+      {
+        value: value.fontScheme,
+        onChange: (fontScheme) => onChange({ ...value, fontScheme })
+      }
+    )
+  ] });
+}
+function FontSchemePicker({ value, onChange }) {
+  const selectedIndex = Math.max(
+    0,
+    WRITE_CANVAS_FONT_SCHEMES.findIndex((scheme) => scheme.id === value)
+  );
+  const selectedScheme = WRITE_CANVAS_FONT_SCHEMES[selectedIndex];
+  const [isOpen, setIsOpen] = useState(false);
+  const [activeIndex, setActiveIndex] = useState(selectedIndex);
+  const [menuPosition, setMenuPosition] = useState(null);
+  const rootRef = useRef(null);
+  const triggerRef = useRef(null);
+  const listboxRef = useRef(null);
+  const optionRefs = useRef([]);
+  const labelId = useId();
+  const listboxId = useId();
+  const close = useCallback((returnFocus) => {
+    setIsOpen(false);
+    setMenuPosition(null);
+    if (returnFocus) triggerRef.current?.focus({ preventScroll: true });
+  }, []);
+  const updateMenuPosition = useCallback(() => {
+    const trigger = triggerRef.current;
+    if (!trigger) return;
+    const rect = trigger.getBoundingClientRect();
+    const viewportWidth = document.documentElement.clientWidth || window.innerWidth;
+    const viewportHeight = document.documentElement.clientHeight || window.innerHeight;
+    const gutter = 8;
+    const gap = 4;
+    const width = Math.min(rect.width, viewportWidth - gutter * 2);
+    const left = Math.min(Math.max(gutter, rect.left), viewportWidth - width - gutter);
+    const spaceBelow = viewportHeight - rect.bottom - gap - gutter;
+    const spaceAbove = rect.top - gap - gutter;
+    const openAbove = spaceBelow < 260 && spaceAbove > spaceBelow;
+    const availableHeight = openAbove ? spaceAbove : spaceBelow;
+    const maxHeight = Math.max(80, Math.min(420, availableHeight));
+    setMenuPosition(
+      openAbove ? {
+        left,
+        bottom: viewportHeight - rect.top + gap,
+        width,
+        maxHeight
+      } : {
+        left,
+        top: rect.bottom + gap,
+        width,
+        maxHeight
+      }
+    );
+  }, []);
+  const open = useCallback(
+    (index) => {
+      setActiveIndex(index);
+      updateMenuPosition();
+      setIsOpen(true);
+    },
+    [updateMenuPosition]
+  );
+  useEffect(() => {
+    if (!isOpen) setActiveIndex(selectedIndex);
+  }, [isOpen, selectedIndex]);
+  useLayoutEffect(() => {
+    if (!isOpen) return;
+    updateMenuPosition();
+    listboxRef.current?.focus({ preventScroll: true });
+    optionRefs.current[activeIndex]?.scrollIntoView?.({ block: "nearest" });
+  }, [activeIndex, isOpen, updateMenuPosition]);
+  useEffect(() => {
+    if (!isOpen) return;
+    const handleOutsidePointer = (event) => {
+      if (!rootRef.current?.contains(event.target)) close(false);
+    };
+    const handleViewportChange = () => updateMenuPosition();
+    document.addEventListener("mousedown", handleOutsidePointer);
+    window.addEventListener("resize", handleViewportChange);
+    window.addEventListener("scroll", handleViewportChange, true);
+    return () => {
+      document.removeEventListener("mousedown", handleOutsidePointer);
+      window.removeEventListener("resize", handleViewportChange);
+      window.removeEventListener("scroll", handleViewportChange, true);
+    };
+  }, [close, isOpen, updateMenuPosition]);
+  const select = useCallback(
+    (index) => {
+      const scheme = WRITE_CANVAS_FONT_SCHEMES[index];
+      if (!scheme) return;
+      onChange(scheme.id);
+      close(true);
+    },
+    [close, onChange]
+  );
+  const handleTriggerKeyDown = (event) => {
+    if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+      event.preventDefault();
+      open(selectedIndex);
+    }
+  };
+  const handleListboxKeyDown = (event) => {
+    switch (event.key) {
+      case "ArrowDown":
+        event.preventDefault();
+        setActiveIndex((current) => (current + 1) % WRITE_CANVAS_FONT_SCHEMES.length);
+        break;
+      case "ArrowUp":
+        event.preventDefault();
+        setActiveIndex(
+          (current) => (current - 1 + WRITE_CANVAS_FONT_SCHEMES.length) % WRITE_CANVAS_FONT_SCHEMES.length
+        );
+        break;
+      case "Home":
+        event.preventDefault();
+        setActiveIndex(0);
+        break;
+      case "End":
+        event.preventDefault();
+        setActiveIndex(WRITE_CANVAS_FONT_SCHEMES.length - 1);
+        break;
+      case "Enter":
+      case " ":
+        event.preventDefault();
+        select(activeIndex);
+        break;
+      case "Escape":
+        event.preventDefault();
+        event.stopPropagation();
+        close(true);
+        break;
+      case "Tab":
+        close(false);
+        break;
+    }
+  };
+  const menuStyle = menuPosition ? {
+    left: `${menuPosition.left}px`,
+    top: menuPosition.top === void 0 ? void 0 : `${menuPosition.top}px`,
+    bottom: menuPosition.bottom === void 0 ? void 0 : `${menuPosition.bottom}px`,
+    width: `${menuPosition.width}px`,
+    maxHeight: `${menuPosition.maxHeight}px`
+  } : void 0;
+  return /* @__PURE__ */ jsxs("div", { ref: rootRef, className: "db-settings-select db-font-picker", children: [
+    /* @__PURE__ */ jsx("span", { className: "db-settings-select-header", children: /* @__PURE__ */ jsx("span", { id: labelId, children: "Font" }) }),
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        ref: triggerRef,
+        type: "button",
+        className: "db-font-picker-trigger",
+        "aria-label": `Font, ${selectedScheme.label}`,
+        "aria-haspopup": "listbox",
+        "aria-expanded": isOpen,
+        "aria-controls": isOpen ? listboxId : void 0,
+        onClick: () => isOpen ? close(false) : open(selectedIndex),
+        onKeyDown: handleTriggerKeyDown,
+        children: [
+          /* @__PURE__ */ jsx(FontSchemePreview, { scheme: selectedScheme, compact: true }),
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: `db-font-picker-caret${isOpen ? " db-font-picker-caret--open" : ""}`,
+              "aria-hidden": "true"
+            }
+          )
+        ]
+      }
+    ),
+    isOpen && /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref: listboxRef,
+        id: listboxId,
+        className: "db-font-picker-menu",
+        style: menuStyle,
+        role: "listbox",
+        tabIndex: -1,
+        "aria-labelledby": labelId,
+        "aria-activedescendant": `${listboxId}-option-${activeIndex}`,
+        onKeyDown: handleListboxKeyDown,
+        children: [
+          WRITE_CANVAS_FONT_SCHEMES.filter((scheme) => scheme.group === "theme").map(
+            (scheme) => renderFontSchemeOption(scheme)
+          ),
+          FONT_SCHEME_GROUPS.map(({ group, label }) => /* @__PURE__ */ jsxs("div", { role: "group", "aria-label": label, children: [
+            /* @__PURE__ */ jsx("div", { className: "db-font-picker-group", "aria-hidden": "true", children: label }),
+            WRITE_CANVAS_FONT_SCHEMES.filter((scheme) => scheme.group === group).map(
+              (scheme) => renderFontSchemeOption(scheme)
+            )
+          ] }, group))
+        ]
+      }
+    )
+  ] });
+  function renderFontSchemeOption(scheme) {
+    const index = WRITE_CANVAS_FONT_SCHEMES.indexOf(scheme);
+    const selected = scheme.id === value;
+    const active = index === activeIndex;
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref: (element) => {
+          optionRefs.current[index] = element;
+        },
+        id: `${listboxId}-option-${index}`,
+        className: `db-font-picker-option${selected ? " db-font-picker-option--selected" : ""}${active ? " db-font-picker-option--active" : ""}`,
+        role: "option",
+        "aria-selected": selected,
+        onMouseDown: (event) => event.preventDefault(),
+        onMouseMove: () => setActiveIndex(index),
+        onClick: () => select(index),
+        children: [
+          /* @__PURE__ */ jsx(FontSchemePreview, { scheme }),
+          /* @__PURE__ */ jsx("span", { className: "db-font-picker-check", "aria-hidden": "true", children: selected ? "\u2713" : "" })
+        ]
+      },
+      scheme.id
+    );
+  }
+}
+function FontSchemePreview({
+  scheme,
+  compact = false
+}) {
+  const labels = scheme.label.split(/\s*\u00b7\s*/u);
+  const headingLabel = labels[0] ?? scheme.label;
+  const bodyLabel = labels[1] ?? (scheme.id === "theme" ? "Use the active theme" : "Headings & body");
+  return /* @__PURE__ */ jsxs("span", { className: `db-font-picker-preview${compact ? " db-font-picker-preview--compact" : ""}`, children: [
+    /* @__PURE__ */ jsx(
+      "span",
+      {
+        className: "db-font-picker-heading",
+        style: scheme.headerFont ? { fontFamily: scheme.headerFont } : void 0,
+        children: headingLabel
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "span",
+      {
+        className: "db-font-picker-body",
+        style: scheme.bodyFont ? { fontFamily: scheme.bodyFont } : void 0,
+        children: bodyLabel
+      }
+    )
+  ] });
+}
+var FONT_SCHEME_GROUPS = [
+  { group: "system", label: "System fonts" },
+  { group: "curated", label: "Curated pairings" }
+];
+function formatLineSpacing(value) {
+  return `${value.toFixed(1).replace(/\.0$/, "")}\xD7`;
+}
+
+export {
+  WRITE_CANVAS_FONT_SCHEMES,
+  DEFAULT_WRITE_CANVAS_FONT_SCHEME,
+  resolveWriteCanvasFonts,
+  DEFAULT_WRITE_CANVAS_PREFERENCES,
+  loadWriteCanvasPreferences,
+  saveWriteCanvasPreferences,
+  DB_CHROME_COLORS,
+  loadThemePreference,
+  saveThemePreference,
+  loadAccentColor,
+  saveAccentColor,
+  SettingsDialog,
+  ThemeSettings,
+  AccentColorSettings,
+  WriteCanvasSettingsControls
+};

package/dist/editor.d.ts

@@ -1,3 +1,14 @@
+import { ViewportPreset } from '@bendyline/squisq/schemas';
+
+declare const PORTRAIT_FORM_FACTOR_QUERY = "(orientation: portrait)";
+/** Map the host surface orientation to Squisq's matching preview canvas. */
+declare function previewViewportPresetForOrientation(isPortrait: boolean): ViewportPreset;
+/**
+ * Follow the host viewport orientation so slideshow/video previews make useful
+ * use of portrait screens. Squisq still gives document and manual selections
+ * precedence over this host-provided default.
+ */
+declare function useResponsivePreviewViewportPreset(): ViewportPreset;
 /**
  * Placeholder prompts shown by DocBlocks when a Markdown document is empty.
  * Hosts pick one prompt for each mounted document generation and pass it to
@@ -8,4 +19,4 @@ type EmptyDocumentPrompt = (typeof EMPTY_DOCUMENT_PROMPTS)[number];
 /** Pick a prompt using the supplied random source, or `Math.random`. */
 declare function pickEmptyDocumentPrompt(random?: () => number): EmptyDocumentPrompt;
 
-export { EMPTY_DOCUMENT_PROMPTS, type EmptyDocumentPrompt, pickEmptyDocumentPrompt };
+export { EMPTY_DOCUMENT_PROMPTS, type EmptyDocumentPrompt, PORTRAIT_FORM_FACTOR_QUERY, pickEmptyDocumentPrompt, previewViewportPresetForOrientation, useResponsivePreviewViewportPreset };

package/dist/editor.js

@@ -1,8 +1,14 @@
 import {
   EMPTY_DOCUMENT_PROMPTS,
-  pickEmptyDocumentPrompt
-} from "./chunk-BPGEBGAN.js";
+  PORTRAIT_FORM_FACTOR_QUERY,
+  pickEmptyDocumentPrompt,
+  previewViewportPresetForOrientation,
+  useResponsivePreviewViewportPreset
+} from "./chunk-JDJVRDOP.js";
 export {
   EMPTY_DOCUMENT_PROMPTS,
-  pickEmptyDocumentPrompt
+  PORTRAIT_FORM_FACTOR_QUERY,
+  pickEmptyDocumentPrompt,
+  previewViewportPresetForOrientation,
+  useResponsivePreviewViewportPreset
 };

package/dist/export/index.d.ts

@@ -81,8 +81,6 @@ interface ExportDialogProps {
     onExport: (options: ExportOptions) => void;
     /** Called whenever the currently selected options change. */
     onOptionsChange?: (options: ExportOptions) => void;
-    /** Opens the richer animated-GIF export flow when the host supports ffmpeg.wasm. */
-    onAnimatedGifExport?: () => void;
     /** Called when the dialog is dismissed. */
     onClose: () => void;
 }
@@ -95,7 +93,7 @@ interface ExportDestinationControl {
     /** A host-supplied validation error for the current destination value. */
     error?: string | null;
 }
-declare function ExportDialog({ initial, exporting, error, destination, onExport, onOptionsChange, onAnimatedGifExport, onClose, }: ExportDialogProps): react_jsx_runtime.JSX.Element;
+declare function ExportDialog({ initial, exporting, error, destination, onExport, onOptionsChange, onClose, }: ExportDialogProps): react_jsx_runtime.JSX.Element;
 
 /** Keep a user-edited target name while switching the selected export format. */
 declare function updateExportTargetExtension(targetPath: string, suggestedFilename: string): string;

package/dist/export/index.js

@@ -3,7 +3,7 @@ import {
 } from "../chunk-BI7NVU6T.js";
 import {
   ExportDialog
-} from "../chunk-3CZ27FOA.js";
+} from "../chunk-MHTQORMH.js";
 import {
   buildExportFilename,
   runExport