@qkix/strapi-plugin-better-blocks 0.23.0

package/dist/admin/src/components/BlocksInput/Blocks/Audio.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+declare const insertAudio: (editor: Editor) => void;
+declare const withAudio: (editor: Editor) => Editor;
+declare const audioBlocks: Pick<BlocksStore, 'audio'>;
+export { audioBlocks, withAudio, insertAudio };

package/dist/admin/src/components/BlocksInput/Blocks/AudioEditorModal.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { type AudioAlignment, type AudioElement, type AudioPlayerSettings } from '../utils/types';
+/** Human-readable file size. Strapi stores media size in KB (float). */
+export declare const formatBytes: (bytes?: number) => string;
+export declare const DEFAULT_PLAYER: AudioPlayerSettings;
+export interface AudioDraft {
+    file: AudioElement['file'];
+    title?: string;
+    caption?: string;
+    player: AudioPlayerSettings;
+    alignment: AudioAlignment;
+}
+interface AudioEditorModalProps {
+    open: boolean;
+    element: AudioElement;
+    onSave: (draft: AudioDraft) => void;
+    onRemove: () => void;
+    onClose: () => void;
+}
+export declare const AudioEditorModal: ({ open, element, onSave, onRemove, onClose, }: AudioEditorModalProps) => React.JSX.Element;
+export default AudioEditorModal;

package/dist/admin/src/components/BlocksInput/Blocks/Button.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { Editor } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+interface ButtonIconProps extends React.SVGProps<SVGSVGElement> {
+    fill?: string;
+}
+declare const ButtonIcon: ({ fill, ...rest }: ButtonIconProps) => React.JSX.Element;
+declare const insertButton: (editor: Editor) => void;
+declare const withButtons: (editor: Editor) => Editor;
+declare const buttonBlocks: Pick<BlocksStore, 'button'>;
+export { buttonBlocks, withButtons, insertButton, ButtonIcon };

package/dist/admin/src/components/BlocksInput/Blocks/ButtonEditorModal.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { type ButtonElement, type ButtonPresets } from '../utils/types';
+/** Bytes → human readable, e.g. 5242880 → "5 MB". */
+export declare const formatFileSize: (bytes?: number) => string;
+/** File extension (with or without dot) → emoji icon. */
+export declare const getFileIcon: (ext?: string) => string;
+interface ButtonEditorModalProps {
+    open: boolean;
+    element: ButtonElement;
+    /** Per-project preset overrides (merged over the built-in presets). */
+    presets?: ButtonPresets;
+    onSave: (patch: Partial<ButtonElement>) => void;
+    onRemove: () => void;
+    onClose: () => void;
+}
+declare const ButtonEditorModal: ({ open, element, presets, onSave, onRemove, onClose, }: ButtonEditorModalProps) => React.JSX.Element;
+export { ButtonEditorModal };

package/dist/admin/src/components/BlocksInput/Blocks/Callout.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { type MessageDescriptor } from 'react-intl';
+import { Editor } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+import { type CalloutVariant } from '../utils/types';
+interface VariantMeta {
+    icon: React.ComponentType<any>;
+    /** Strapi color family; we use `${family}600` (accent) and `${family}100` (tint) */
+    family: 'secondary' | 'success' | 'alternative' | 'warning' | 'danger';
+    label: MessageDescriptor;
+}
+declare const VARIANTS: Record<CalloutVariant, VariantMeta>;
+declare const VARIANT_ORDER: CalloutVariant[];
+/**
+ * Wrap the current top-level block in a callout of the given variant.
+ * Normalization guarantees the callout ends up with at least one block child.
+ */
+declare const insertCallout: (editor: Editor, variant?: CalloutVariant) => void;
+declare const withCallout: (editor: Editor) => Editor;
+declare const calloutBlocks: Pick<BlocksStore, 'callout'>;
+export { calloutBlocks, withCallout, insertCallout, VARIANTS, VARIANT_ORDER };

package/dist/admin/src/components/BlocksInput/Blocks/Code.d.ts

@@ -0,0 +1,18 @@
+import { BaseRange, Editor, NodeEntry } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+type BaseRangeCustom = BaseRange & {
+    color: string;
+};
+/**
+ * Syntax highlighting via Shiki.
+ *
+ * Returns a factory so the editor can pass in its current `editor` (to resolve
+ * the parent code element + language) and `isDark` (to pick the matching Shiki
+ * theme). Decoration runs on the code block's text node, mapping each Shiki
+ * token to a Slate range carrying a `color`, which `renderLeaf` turns into an
+ * inline style. Shiki loads asynchronously: until it (and the requested
+ * grammar) are ready, this returns no ranges and a subscriber re-decorates.
+ */
+export declare const decorateCode: (editor: Editor, isDark: boolean) => ([node, path]: NodeEntry) => BaseRangeCustom[];
+declare const codeBlocks: Pick<BlocksStore, 'code'>;
+export { codeBlocks };

package/dist/admin/src/components/BlocksInput/Blocks/Details.d.ts

@@ -0,0 +1,12 @@
+import { Editor } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+declare const DEFAULT_SUMMARY = "Click to expand";
+/**
+ * Wrap the current block in a collapsible details section. Nesting is allowed,
+ * so we wrap any block that is a direct child of the editor or of another
+ * details node. Normalization guarantees at least one block child.
+ */
+declare const insertDetails: (editor: Editor, summary?: string) => void;
+declare const withDetails: (editor: Editor) => Editor;
+declare const detailsBlocks: Pick<BlocksStore, 'details'>;
+export { detailsBlocks, withDetails, insertDetails, DEFAULT_SUMMARY };

package/dist/admin/src/components/BlocksInput/Blocks/Diagram.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { Editor } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+interface DiagramIconProps extends React.SVGProps<SVGSVGElement> {
+    fill?: string;
+}
+declare const DiagramIcon: ({ fill, ...rest }: DiagramIconProps) => React.JSX.Element;
+/**
+ * Convert the currently selected block into a (block) diagram node.
+ * Re-inserts a clean node so no stale text is left in the void's children.
+ */
+declare const setBlockDiagram: (editor: Editor) => void;
+declare const withDiagram: (editor: Editor) => Editor;
+declare const diagramBlocks: Pick<BlocksStore, 'diagram'>;
+export { diagramBlocks, withDiagram, setBlockDiagram, DiagramIcon };

package/dist/admin/src/components/BlocksInput/Blocks/Embed.d.ts

@@ -0,0 +1,22 @@
+import { Editor } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+import { type EmbedElement } from '../utils/types';
+import { isEmbeddableUrl } from './embedProviders';
+/**
+ * Insert a blank embed. With no `embedHtml` the block opens its editor on
+ * mount, so the author lands straight in the URL field.
+ */
+declare const insertEmbed: (editor: Editor, initial?: Partial<EmbedElement>) => void;
+/**
+ * Insert a ready-to-render embed straight from a share URL — used by the
+ * toolbar's media button, which takes the URL up front and so can skip the
+ * modal entirely. Returns false when the URL isn't one we can embed.
+ *
+ * Unlike `insertEmbed`, this *appends* a node instead of converting the block
+ * at the selection: the toolbar button can be pressed with any block selected,
+ * and converting would silently destroy it.
+ */
+declare const insertEmbedFromUrl: (editor: Editor, url: string) => boolean;
+declare const withEmbed: (editor: Editor) => Editor;
+declare const embedBlocks: Pick<BlocksStore, 'embed'>;
+export { embedBlocks, withEmbed, insertEmbed, insertEmbedFromUrl, isEmbeddableUrl, };

package/dist/admin/src/components/BlocksInput/Blocks/EmbedEditorModal.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { type AspectRatio, type EmbedElement, type EmbedProvider, type MediaAlignment } from '../utils/types';
+import { isEmbeddableUrl } from './embedProviders';
+export interface EmbedDraft {
+    source: 'url' | 'iframe';
+    url?: string;
+    iframe?: string;
+    embedHtml?: string;
+    embedSrc?: string;
+    provider?: EmbedProvider;
+    thumbnail?: string;
+    aspectRatio: AspectRatio;
+    customAspectRatio?: string;
+    alignment: MediaAlignment;
+    caption?: string;
+    title?: string;
+}
+interface EmbedEditorModalProps {
+    open: boolean;
+    element: EmbedElement;
+    onSave: (draft: EmbedDraft) => void;
+    onRemove: () => void;
+    onClose: () => void;
+}
+export declare const EmbedEditorModal: ({ open, element, onSave, onRemove, onClose, }: EmbedEditorModalProps) => React.JSX.Element;
+export { isEmbeddableUrl };
+export default EmbedEditorModal;

package/dist/admin/src/components/BlocksInput/Blocks/Heading.d.ts

@@ -0,0 +1,14 @@
+import { type BlocksStore } from '../BlocksEditor';
+/**
+ * Type scale used to preview each block type inside the block-type dropdown.
+ *
+ * Deliberately a compressed version of the editor sizes above (4.2rem down to
+ * 1.6rem): the point is to convey the hierarchy at a glance, and a literal 4.2rem
+ * H1 would turn the menu into a scroll container.
+ */
+declare const BLOCK_PREVIEW_TYPOGRAPHY: Record<string, {
+    fontSize: string;
+    fontWeight: number;
+}>;
+declare const headingBlocks: Pick<BlocksStore, 'heading-one' | 'heading-two' | 'heading-three' | 'heading-four' | 'heading-five' | 'heading-six'>;
+export { headingBlocks, BLOCK_PREVIEW_TYPOGRAPHY };

package/dist/admin/src/components/BlocksInput/Blocks/HorizontalLine.d.ts

@@ -0,0 +1,10 @@
+import { Editor } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+declare const withHorizontalLine: (editor: Editor) => Editor;
+/**
+ * Insert a horizontal line block after the current selection,
+ * followed by an empty paragraph so the user can keep typing.
+ */
+declare const insertHorizontalLine: (editor: Editor) => void;
+declare const horizontalLineBlocks: Pick<BlocksStore, 'horizontal-line'>;
+export { horizontalLineBlocks, withHorizontalLine, insertHorizontalLine };

package/dist/admin/src/components/BlocksInput/Blocks/Image.d.ts

@@ -0,0 +1,5 @@
+import { Editor } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+declare const withImages: (editor: Editor) => Editor;
+declare const imageBlocks: Pick<BlocksStore, 'image'>;
+export { imageBlocks, withImages };

package/dist/admin/src/components/BlocksInput/Blocks/Link.d.ts

@@ -0,0 +1,3 @@
+import { type BlocksStore } from '../BlocksEditor';
+declare const linkBlocks: Pick<BlocksStore, 'link'>;
+export { linkBlocks };

package/dist/admin/src/components/BlocksInput/Blocks/List.d.ts

@@ -0,0 +1,3 @@
+import { type BlocksStore } from '../BlocksEditor';
+declare const listBlocks: Pick<BlocksStore, 'list-ordered' | 'list-unordered' | 'list-todo' | 'list-item'>;
+export { listBlocks };

package/dist/admin/src/components/BlocksInput/Blocks/Math.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { Editor } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+import 'katex/dist/katex.min.css';
+interface MathIconProps extends React.SVGProps<SVGSVGElement> {
+    fill?: string;
+}
+declare const MathIcon: ({ fill, ...rest }: MathIconProps) => React.JSX.Element;
+declare const insertInlineMath: (editor: Editor, value?: string) => void;
+/**
+ * Convert the currently selected block into a (block) math node.
+ * Re-inserts a clean node so no stale text is left in the void's children.
+ */
+declare const setBlockMath: (editor: Editor) => void;
+declare const withMath: (editor: Editor) => Editor;
+declare const mathBlocks: Pick<BlocksStore, 'math'>;
+export { mathBlocks, withMath, insertInlineMath, setBlockMath, MathIcon };

package/dist/admin/src/components/BlocksInput/Blocks/MediaEmbed.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+declare const isMediaUrl: (url: string) => boolean;
+declare const insertMediaEmbed: (editor: Editor, url: string) => void;
+declare const withMediaEmbed: (editor: Editor) => Editor;
+declare const mediaEmbedBlocks: Pick<BlocksStore, 'media-embed'>;
+export { mediaEmbedBlocks, withMediaEmbed, insertMediaEmbed, isMediaUrl };

package/dist/admin/src/components/BlocksInput/Blocks/Paragraph.d.ts

@@ -0,0 +1,3 @@
+import { type BlocksStore } from '../BlocksEditor';
+declare const paragraphBlocks: Pick<BlocksStore, 'paragraph'>;
+export { paragraphBlocks };

package/dist/admin/src/components/BlocksInput/Blocks/Quote.d.ts

@@ -0,0 +1,3 @@
+import { type BlocksStore } from '../BlocksEditor';
+declare const quoteBlocks: Pick<BlocksStore, 'quote'>;
+export { quoteBlocks };

package/dist/admin/src/components/BlocksInput/Blocks/SocialEmbed.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { Editor } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+declare const SocialIcon: (props: React.SVGProps<SVGSVGElement>) => React.JSX.Element;
+declare const insertSocialEmbed: (editor: Editor) => void;
+declare const withSocialEmbed: (editor: Editor) => Editor;
+declare const socialEmbedBlocks: Pick<BlocksStore, 'social-embed'>;
+export { socialEmbedBlocks, withSocialEmbed, insertSocialEmbed, SocialIcon };

package/dist/admin/src/components/BlocksInput/Blocks/SocialEmbedEditorModal.d.ts

@@ -0,0 +1,41 @@
+import * as React from 'react';
+import { type SocialAlignment, type SocialEmbedElement, type SocialOEmbed, type SocialPlatform } from '../utils/types';
+export interface PlatformMeta {
+    label: string;
+    icon: string;
+    color: string;
+}
+export declare const PLATFORM_META: Record<SocialPlatform, PlatformMeta>;
+export declare const ALL_PLATFORMS: SocialPlatform[];
+/** Detect the platform from a pasted URL (mirrors the server-side detection). */
+export declare const detectPlatform: (url: string) => SocialPlatform | null;
+/**
+ * Widget scripts pasted along with an embed snippet are inert once injected via
+ * `innerHTML`, and their leftover tags make renderers think the widget is
+ * already loaded. Renderers load those scripts themselves, so keep markup only.
+ */
+export declare const stripScripts: (html: string) => string;
+/**
+ * Pull the canonical post URL out of a pasted embed snippet, so an embed-code-only
+ * embed still carries a link for fallbacks and analytics. Covers Instagram's
+ * `data-instgrm-permalink`, blockquote `cite`, and iframe `src`.
+ */
+export declare const extractUrlFromEmbedCode: (code: string) => string | null;
+export interface SocialEmbedDraft {
+    platform: SocialPlatform;
+    url: string;
+    embedCode?: string;
+    oembed?: SocialOEmbed;
+    alignment: SocialAlignment;
+    caption?: string;
+}
+interface SocialEmbedEditorModalProps {
+    open: boolean;
+    element: SocialEmbedElement;
+    enabledPlatforms?: SocialPlatform[];
+    onSave: (patch: SocialEmbedDraft) => void;
+    onRemove: () => void;
+    onClose: () => void;
+}
+export declare const SocialEmbedEditorModal: ({ open, element, enabledPlatforms, onSave, onRemove, onClose, }: SocialEmbedEditorModalProps) => React.JSX.Element;
+export default SocialEmbedEditorModal;

package/dist/admin/src/components/BlocksInput/Blocks/SourceEditorModal.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+interface SourceEditorModalProps {
+    open: boolean;
+    /** Modal heading, e.g. "Edit Mermaid diagram". */
+    title: string;
+    /** Label shown above the source textarea, e.g. "Mermaid". */
+    label: string;
+    placeholder?: string;
+    /** The committed source value (used to detect the initial empty state). */
+    source: string;
+    onSourceChange: (value: string) => void;
+    /** Renders the live preview for the current (uncommitted) source. */
+    renderPreview: (source: string) => React.ReactNode;
+    onSave: () => void;
+    onRemove: () => void;
+    onClose: () => void;
+}
+declare const SourceEditorModal: ({ open, title, label, placeholder, source, onSourceChange, renderPreview, onSave, onRemove, onClose, }: SourceEditorModalProps) => React.JSX.Element;
+export { SourceEditorModal };

package/dist/admin/src/components/BlocksInput/Blocks/Table.d.ts

@@ -0,0 +1,14 @@
+import { Editor } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+import { createTableCell, createTableRow, insertTable } from './tableOperations';
+/**
+ * Protects the table's shape from Slate's generic editing behaviours (deleting
+ * across cells, normalizing rows away, converting a cell to a paragraph, …).
+ *
+ * Structural edits are performed by tableOperations, which lifts the guard via
+ * `allowTableEdit`. Inline editing inside a cell — marks, links, inline math —
+ * is deliberately untouched, so cells keep full rich-text parity.
+ */
+declare const withTables: (editor: Editor) => Editor;
+declare const tableBlocks: Pick<BlocksStore, 'table' | 'table-row' | 'table-cell' | 'table-header-cell'>;
+export { tableBlocks, withTables, insertTable, createTableCell, createTableRow, };

package/dist/admin/src/components/BlocksInput/Blocks/TableGridPicker.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+/** Size of the hover grid. Larger tables go through the custom-size inputs. */
+declare const GRID_ROWS = 10;
+declare const GRID_COLS = 10;
+/** Upper bound for the custom-size inputs — a guard against typos, not a limit
+ *  anyone should hit in practice. */
+declare const MAX_DIMENSION = 50;
+interface TableGridPickerProps {
+    /** Called with a 1-based row/column count once the author commits a size. */
+    onSelect: (rows: number, cols: number) => void;
+}
+/**
+ * Notion/Word-style table size picker: hover (or arrow-key) across a 10x10 grid
+ * to pick the dimensions, with a custom-size fallback for anything bigger.
+ *
+ * The grid is plain divs in a CSS grid rather than SVG or a canvas, so it
+ * paints instantly and stays keyboard navigable for free.
+ */
+declare const TableGridPicker: ({ onSelect }: TableGridPickerProps) => React.JSX.Element;
+export { TableGridPicker, GRID_ROWS, GRID_COLS, MAX_DIMENSION };

package/dist/admin/src/components/BlocksInput/Blocks/TableIcons.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+/**
+ * Icons for the table contextual toolbar.
+ *
+ * They all share one visual language: a 3x3 table frame with the row or column
+ * the action targets picked out by a tinted band, plus a `+` or `x` marker for
+ * insert vs delete. That makes "insert row above" readable at a glance instead
+ * of relying on the tooltip.
+ *
+ * `fill` follows the same convention as FontModifiersIcons: a theme color token
+ * (e.g. "neutral600"), falling back to a raw CSS color.
+ */
+interface TableIconProps {
+    fill?: string;
+}
+export declare const InsertRowAboveIcon: ({ fill }: TableIconProps) => React.JSX.Element;
+export declare const InsertRowBelowIcon: ({ fill }: TableIconProps) => React.JSX.Element;
+export declare const InsertColumnLeftIcon: ({ fill }: TableIconProps) => React.JSX.Element;
+export declare const InsertColumnRightIcon: ({ fill }: TableIconProps) => React.JSX.Element;
+export declare const DeleteRowIcon: ({ fill }: TableIconProps) => React.JSX.Element;
+export declare const DeleteColumnIcon: ({ fill }: TableIconProps) => React.JSX.Element;
+/** Table frame with a solid top row — the "toggle header row" affordance. */
+export declare const HeaderRowIcon: ({ fill }: TableIconProps) => React.JSX.Element;
+/**
+ * Merge: the top-left 2x2 block reads as one tinted cell, with arrows pointing
+ * inward to say "these become one".
+ */
+export declare const MergeCellsIcon: ({ fill }: TableIconProps) => React.JSX.Element;
+/** Split: one cell with a dashed divider appearing down the middle. */
+export declare const SplitCellIcon: ({ fill }: TableIconProps) => React.JSX.Element;
+export {};

package/dist/admin/src/components/BlocksInput/Blocks/TableToolbar.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { type TableLocation } from './tableOperations';
+interface TableToolbarProps {
+    location: TableLocation;
+    disabled: boolean;
+}
+/**
+ * Contextual toolbar that floats above a table while the caret is inside it.
+ *
+ * Every row/column action is directional and anchored on the focused cell —
+ * "insert row above" means above *this* row, not at the end of the table.
+ */
+declare const TableToolbar: ({ location, disabled }: TableToolbarProps) => React.JSX.Element;
+export { TableToolbar };

package/dist/admin/src/components/BlocksInput/Blocks/Video.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from 'slate';
+import { type BlocksStore } from '../BlocksEditor';
+declare const insertVideo: (editor: Editor) => void;
+declare const withVideo: (editor: Editor) => Editor;
+declare const videoBlocks: Pick<BlocksStore, 'video'>;
+export { videoBlocks, withVideo, insertVideo };

package/dist/admin/src/components/BlocksInput/Blocks/VideoEditorModal.d.ts

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import { type AspectRatio, type MediaAlignment, type VideoElement, type VideoPlayerSettings, type VideoProvider } from '../utils/types';
+/** Human-readable file size. Strapi stores media size in KB (float). */
+export declare const formatBytes: (bytes?: number) => string;
+export declare const DEFAULT_VIDEO_PLAYER: VideoPlayerSettings;
+export interface VideoDraft {
+    provider: VideoProvider;
+    assetId?: string;
+    playbackId?: string;
+    url: string;
+    file?: VideoElement['file'];
+    poster?: string;
+    title?: string;
+    caption?: string;
+    transcript?: string;
+    player: VideoPlayerSettings;
+    alignment: MediaAlignment;
+    aspectRatio: AspectRatio;
+    customAspectRatio?: string;
+}
+interface VideoEditorModalProps {
+    open: boolean;
+    element: VideoElement;
+    onSave: (draft: VideoDraft) => void;
+    onRemove: () => void;
+    onClose: () => void;
+}
+export declare const VideoEditorModal: ({ open, element, onSave, onRemove, onClose, }: VideoEditorModalProps) => React.JSX.Element;
+export default VideoEditorModal;

package/dist/admin/src/components/BlocksInput/Blocks/embedProviders.d.ts

@@ -0,0 +1,43 @@
+import { type AspectRatio, type EmbedProvider } from '../utils/types';
+/** Hosts an app must allow in `frame-src` for URL-based embeds to render. */
+export declare const EMBED_FRAME_HOSTS: string[];
+/** Human-readable provider name for a URL, e.g. "YouTube". */
+export declare const getProviderLabel: (provider?: EmbedProvider) => string;
+/** Detected provider for a share URL, or `generic` when unrecognised. */
+export declare const detectProvider: (url: string) => EmbedProvider;
+/** Iframe `src` derived from a share URL, or null when not derivable. */
+export declare const getEmbedSrc: (url: string) => string | null;
+/** Poster image derived from a share URL, when the provider exposes one. */
+export declare const getThumbnail: (url: string) => string | null;
+/** True when the URL is one this block can turn into an embed by itself. */
+export declare const isEmbeddableUrl: (url: string) => boolean;
+export interface SanitizedIframe {
+    /** Discriminant against `IframeError`; never set on success. */
+    error?: undefined;
+    /** Rebuilt, safe-to-store iframe markup. */
+    html: string;
+    /** The iframe's `src`, hoisted for preview/validation. */
+    src: string;
+    width?: string;
+    height?: string;
+}
+export interface IframeError {
+    html?: undefined;
+    error: 'no-iframe' | 'no-src' | 'insecure-src';
+}
+/**
+ * Parse a pasted embed snippet and rebuild a single safe `<iframe>` from it.
+ * Returns an error code instead of throwing so the modal can explain what's
+ * wrong with the paste.
+ */
+export declare const sanitizeIframe: (input: string) => SanitizedIframe | IframeError;
+/**
+ * Build the iframe markup for a recognised share URL. Returns null when the URL
+ * isn't one of the known providers — the author then has to use embed-code mode.
+ */
+export declare const buildUrlEmbed: (url: string, title?: string) => SanitizedIframe | null;
+export declare const ASPECT_RATIOS: AspectRatio[];
+/** `"16:9"` → `"16 / 9"`, the value the CSS `aspect-ratio` property expects. */
+export declare const toCssAspectRatio: (ratio?: string) => string;
+/** Best-effort ratio from a pasted iframe's width/height attributes. */
+export declare const inferAspectRatio: (width?: string, height?: string) => AspectRatio | null;

package/dist/admin/src/components/BlocksInput/Blocks/muxClient.d.ts

@@ -0,0 +1,40 @@
+export declare const MUX_PLUGIN_ID = "mux-video-uploader";
+/** Subset of `plugin::mux-video-uploader.mux-asset` this block consumes. */
+export interface MuxAsset {
+    documentId: string;
+    title: string;
+    asset_id?: string;
+    playback_id?: string;
+    /** True when the asset uses a signed playback policy. */
+    signed: boolean;
+    isReady: boolean;
+    duration?: number;
+    /** Mux reports this as e.g. "16:9". */
+    aspect_ratio?: string;
+}
+/**
+ * Thumbnails go through the plugin's own proxy rather than image.mux.com
+ * directly: the route is unauthenticated and exists precisely because the
+ * Strapi admin CSP blocks the Mux image host.
+ */
+export declare const muxThumbnailProxyUrl: (playbackId: string) => string;
+export interface UseMuxAssetsResult {
+    /** null while still probing for the plugin. */
+    available: boolean | null;
+    assets: MuxAsset[];
+    totalCount: number;
+    loading: boolean;
+    error: string | null;
+    search: (query: string) => void;
+    query: string;
+}
+/**
+ * List Mux assets, with title search. Returns `available: false` when the Mux
+ * plugin isn't installed or can't be queried, so callers can hide their UI.
+ *
+ * Availability is decided by the asset-list call itself rather than the
+ * plugin's `mux-settings` route: that route reports "configured" only when a
+ * *webhook signing secret* is also set, which listing assets does not need — so
+ * it answers false for perfectly usable installs.
+ */
+export declare const useMuxAssets: (enabled: boolean) => UseMuxAssetsResult;

package/dist/admin/src/components/BlocksInput/Blocks/socialFrame.d.ts

@@ -0,0 +1,13 @@
+import { type SocialEmbedElement, type SocialPlatform } from '../utils/types';
+export interface SocialFrame {
+    src: string;
+    /** Fixed height in px: these frames don't post their size to the parent. */
+    height: number;
+}
+/** Hosts an app must allow in `frame-src` for live previews to render. */
+export declare const SOCIAL_FRAME_HOSTS: Record<SocialPlatform, string>;
+/**
+ * Build the URL of a script-free preview frame for a social-embed node, or null
+ * when the post can't be identified (then the editor keeps showing the card).
+ */
+export declare const getSocialFrame: (element: Pick<SocialEmbedElement, 'platform' | 'url' | 'embedCode' | 'oembed'>) => SocialFrame | null;