@qkix/strapi-plugin-better-blocks 0.23.0

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

@@ -0,0 +1,90 @@
+import { Editor, Path } from 'slate';
+import type { CustomElement, TableCellElement } from '../utils/types';
+/**
+ * Span-aware view of a table.
+ *
+ * Once cells can carry `colSpan` / `rowSpan`, a cell's index within its row
+ * stops being its visual column: a row of three cells can cover four columns,
+ * and a cell with `rowSpan: 2` occupies a slot in the row below without having
+ * a node there. Every structural operation therefore works against this grid —
+ * a slot-by-slot map of what covers what — rather than against raw child
+ * indices.
+ */
+/** A cell as it sits in the grid. One per node, shared by every slot it covers. */
+export interface GridCell {
+    node: TableCellElement;
+    /** Path of the node itself: [...tablePath, rowIndex, indexWithinRow]. */
+    path: Path;
+    /** Row this cell's node lives in. */
+    row: number;
+    /** Leftmost grid column this cell covers. */
+    col: number;
+    rowSpan: number;
+    colSpan: number;
+    /** Index of the node among its row's children. */
+    indexInRow: number;
+}
+export interface TableGrid {
+    tablePath: Path;
+    rowCount: number;
+    /** Total grid columns, spans included. */
+    colCount: number;
+    /** `matrix[row][col]` — the cell covering that slot, or undefined if ragged. */
+    matrix: (GridCell | undefined)[][];
+    /** Every cell once, in document order. */
+    cells: GridCell[];
+}
+/** A rectangle of grid slots, inclusive on both ends. */
+export interface GridRange {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+}
+/**
+ * Lays a table's cells out into grid slots.
+ *
+ * Standard table layout: walk each row left to right, skipping slots already
+ * claimed by a `rowSpan` from an earlier row, and stamp each cell across every
+ * slot it covers.
+ */
+export declare const buildTableGrid: (table: CustomElement, tablePath: Path) => TableGrid;
+/** The cell whose node sits at `path`, or undefined. */
+export declare const findCellByPath: (grid: TableGrid, path: Path) => GridCell | undefined;
+/** Cells that originate in `row`, left to right. */
+export declare const cellsOriginatingInRow: (grid: TableGrid, row: number) => GridCell[];
+/**
+ * Where a new cell covering grid column `col` has to be inserted among row
+ * `row`'s children — i.e. how many of that row's own cells start left of it.
+ * Cells that merely reach into the row from above have no node here and so
+ * don't count.
+ */
+export declare const nodeIndexForColumn: (grid: TableGrid, row: number, col: number) => number;
+/** Whether `cell` covers the given slot. */
+export declare const covers: (cell: GridCell, row: number, col: number) => boolean;
+/**
+ * Grows `range` until every cell it touches is fully inside it.
+ *
+ * Selecting two cells that a third one straddles can't produce a rectangle
+ * without swallowing that third cell — so the range expands to include it,
+ * which may in turn pull in others. Repeats to a fixed point, which always
+ * terminates because the range only ever grows and is bounded by the table.
+ */
+export declare const expandRangeToRectangle: (grid: TableGrid, range: GridRange) => GridRange;
+/** Every cell with at least one slot inside `range`, without duplicates. */
+export declare const cellsInRange: (grid: TableGrid, range: GridRange) => GridCell[];
+/**
+ * The rectangle of cells the selection covers, or null when it stays within a
+ * single cell.
+ *
+ * The selection model is Slate's own — dragging across cells already produces a
+ * range spanning both, and Shift+arrow already extends it, so there's no
+ * separate cell-selection state to keep in sync.
+ *
+ * Only the two *endpoints* define the rectangle, though. A document range is
+ * linear, so everything between r2c1 and r3c2 includes the whole tail of row 2
+ * — taking the bounding box of every touched cell would turn a 2x2 pick into a
+ * full-width 2x5 one. Treating anchor and focus as opposite corners gives the
+ * 2D behaviour authors expect from a table.
+ */
+export declare const getSelectedRange: (editor: Editor, grid: TableGrid) => GridRange | null;

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

@@ -0,0 +1,124 @@
+import { Editor, Path } from 'slate';
+import type { CustomElement, TableCellAlign } from '../utils/types';
+import { type GridCell, type GridRange, type TableGrid } from './tableGrid';
+declare const CELL_TYPES: readonly ["table-cell", "table-header-cell"];
+declare const TABLE_TYPES: readonly ["table", "table-row", "table-cell", "table-header-cell"];
+declare const createTableCell: (isHeader?: boolean) => CustomElement;
+declare const createTableRow: (cols: number, isHeader?: boolean) => CustomElement;
+/**
+ * Builds a table of `rows` x `cols`. The first row is a header row unless
+ * `withHeader` is false, in which case every row holds plain data cells.
+ */
+declare const createTable: (rows: number, cols: number, withHeader?: boolean) => CustomElement;
+/**
+ * Inserts a table at the current selection, followed by an empty paragraph so
+ * the author always has somewhere to continue writing below it.
+ */
+declare const insertTable: (editor: Editor, rows?: number, cols?: number, withHeader?: boolean) => void;
+/**
+ * Runs `fn` with the table structure protection in `withTables` temporarily
+ * lifted. Everything that legitimately adds/removes rows, columns or the table
+ * itself has to go through here, otherwise `editor.apply` swallows the ops.
+ */
+declare const allowTableEdit: (editor: Editor, fn: () => void) => void;
+declare const isCellType: (node: unknown) => boolean;
+declare const isTableElement: (node: unknown) => boolean;
+interface TableLocation {
+    tablePath: Path;
+    table: CustomElement;
+    /** Span-aware layout of the whole table. */
+    grid: TableGrid;
+    /** The cell holding the caret, with its grid coordinates. */
+    focused: GridCell;
+    /** Rectangle of cells the selection covers, or null within a single cell. */
+    range: GridRange | null;
+    /** Row the caret's cell lives in. */
+    rowIndex: number;
+    /** Leftmost grid column the caret's cell covers. */
+    colIndex: number;
+    rowCount: number;
+    /** Total grid columns, spans included. */
+    colCount: number;
+    cell: CustomElement;
+    cellPath: Path;
+}
+/**
+ * Resolves the table cell the caret currently sits in, together with the grid
+ * it belongs to. Returns null when the selection is outside any table.
+ */
+declare const getTableLocation: (editor: Editor) => TableLocation | null;
+/** A row is a header row when every one of its cells is a header cell. */
+declare const isHeaderRow: (row: CustomElement) => boolean;
+declare const isHeaderRowAt: (table: CustomElement, rowIndex: number) => boolean;
+/**
+ * Inserts a column beside the caret's cell.
+ *
+ * A cell that straddles the insertion boundary is widened rather than given a
+ * new neighbour — otherwise the merge would visually break apart. Every other
+ * row gets a fresh cell, placed at the child index that lands it in the new
+ * grid column (which is not the same as the column number once spans exist).
+ */
+declare const insertColumn: (editor: Editor, location: TableLocation, position: 'left' | 'right') => void;
+/**
+ * Deletes the grid column the caret's cell starts in. Cells that span across it
+ * shrink by one instead of disappearing.
+ */
+declare const deleteColumn: (editor: Editor, location: TableLocation) => void;
+/**
+ * Inserts a row above or below the caret's cell. Cells whose rowSpan straddles
+ * the boundary are stretched instead of being split by the new row, and the new
+ * row only gets cells for the columns those stretched cells don't already cover.
+ */
+declare const insertRow: (editor: Editor, location: TableLocation, position: 'above' | 'below') => void;
+/**
+ * Deletes the row the caret sits in.
+ *
+ * Cells reaching into the row from above simply shrink. Cells that *start* in
+ * the row but continue below it can't just be removed — they're re-inserted
+ * into the following row, one row shorter, so the merge survives.
+ */
+declare const deleteRow: (editor: Editor, location: TableLocation) => void;
+declare const deleteTable: (editor: Editor, location: TableLocation) => void;
+/**
+ * Whether a range straddles the header/body divide.
+ *
+ * A header cell labels a column; one that runs from the header down into the
+ * body labels nothing and belongs to neither. HTML agrees — a `rowSpan` may not
+ * cross the `<thead>`/`<tbody>` boundary, so a browser would clamp it and render
+ * something different from what the editor shows. Merging is therefore confined
+ * to one side of the divide. Merging *within* the header (a heading spanning two
+ * columns) is perfectly fine and stays allowed.
+ */
+declare const rangeCrossesHeaderBoundary: (table: CustomElement, range: GridRange) => boolean;
+/** Whether the selection covers enough distinct cells to merge. */
+declare const canMergeCells: (location: TableLocation) => boolean;
+/** Whether the caret's cell is the result of a merge. */
+declare const canSplitCell: (location: TableLocation) => boolean;
+/**
+ * Merges the selected rectangle into its top-left cell.
+ *
+ * The range arrives already squared off (see expandRangeToRectangle), so the
+ * result always tiles the grid. Content from the absorbed cells is appended to
+ * the anchor rather than discarded — losing an author's text to a layout
+ * operation would be unforgivable.
+ */
+declare const mergeCells: (editor: Editor, location: TableLocation) => void;
+/**
+ * Undoes a merge: the cell shrinks back to 1x1 and every slot it vacates is
+ * refilled with an empty cell. The content stays in the original cell.
+ */
+declare const splitCell: (editor: Editor, location: TableLocation) => void;
+/**
+ * Applies a horizontal alignment to every cell the selection touches (a single
+ * cell in the common case). `left` clears the property rather than storing it,
+ * so untouched documents and left-aligned cells stay byte-identical.
+ */
+declare const setCellAlign: (editor: Editor, align: TableCellAlign) => void;
+declare const getCellAlign: (location: TableLocation) => TableCellAlign;
+/**
+ * Turns the table's first row into header cells, or back into data cells.
+ * Header cells render as `<th scope="col">` for screen readers.
+ */
+declare const toggleHeaderRow: (editor: Editor, location: TableLocation) => void;
+declare const hasHeaderRow: (location: TableLocation) => boolean;
+export { type TableLocation, CELL_TYPES, TABLE_TYPES, allowTableEdit, canMergeCells, canSplitCell, createTable, createTableCell, createTableRow, deleteColumn, deleteRow, deleteTable, getCellAlign, getTableLocation, hasHeaderRow, insertColumn, insertRow, insertTable, isCellType, isHeaderRow, isHeaderRowAt, isTableElement, mergeCells, rangeCrossesHeaderBoundary, setCellAlign, splitCell, toggleHeaderRow, };

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

@@ -0,0 +1,37 @@
+import { type VideoProvider } from '../utils/types';
+/** Hosts an app must allow for Mux playback (media-src / img-src). */
+export declare const MUX_HOSTS: {
+    stream: string;
+    image: string;
+};
+/**
+ * HLS manifest for a Mux playback id.
+ *
+ * Only valid for assets with a **public** playback policy. Signed playback
+ * requires a per-request JWT (`?token=…`) that must be minted server-side with
+ * a Mux signing key, which this block deliberately does not handle — storing a
+ * short-lived token in the document body would break as soon as it expired.
+ */
+export declare const muxPlaybackUrl: (playbackId: string) => string;
+/** Auto-generated poster frame for a Mux playback id (public policy only). */
+export declare const muxThumbnailUrl: (playbackId: string) => string;
+export declare const isMuxPlaybackId: (value: string) => boolean;
+export interface DetectedVideo {
+    provider: VideoProvider;
+    url: string;
+    playbackId?: string;
+    poster?: string;
+}
+/**
+ * Work out what a pasted string is: a Mux playback id, a provider URL, or a
+ * plain video file URL. Returns null for empty input.
+ */
+export declare const detectVideoSource: (input: string) => DetectedVideo | null;
+/**
+ * True when the URL needs an HLS/DASH-capable player rather than a plain
+ * `<video src>`. Safari plays HLS natively; other browsers need hls.js or a
+ * provider player, which is a frontend-renderer concern — the editor preview
+ * degrades to the poster image instead.
+ */
+export declare const isStreamingUrl: (url: string) => boolean;
+export declare const VIDEO_PROVIDER_LABELS: Record<VideoProvider, string>;

package/dist/admin/src/components/BlocksInput/BlocksContent.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+interface BlocksContentProps {
+    placeholder?: string;
+    ariaLabelId: string;
+}
+declare const BlocksContent: ({ placeholder, ariaLabelId, }: BlocksContentProps) => React.JSX.Element;
+export { BlocksContent, BlocksContentProps };

package/dist/admin/src/components/BlocksInput/BlocksEditor.d.ts

@@ -0,0 +1,71 @@
+import * as React from 'react';
+import { type FieldValue } from '@strapi/admin/strapi-admin';
+import { MessageDescriptor } from 'react-intl';
+import { Editor } from 'slate';
+import { type RenderElementProps } from 'slate-react';
+import { type CSSProperties } from 'styled-components';
+import { type BlocksContentProps } from './BlocksContent';
+import { type ModifiersStore } from './Modifiers';
+import { type Schema } from '@strapi/types';
+interface BaseBlock {
+    renderElement: (props: RenderElementProps) => React.JSX.Element;
+    matchNode: (node: Schema.Attribute.BlocksNode) => boolean;
+    handleConvert?: (editor: Editor) => void | (() => React.JSX.Element);
+    handleEnterKey?: (editor: Editor) => void;
+    handleBackspaceKey?: (editor: Editor, event: React.KeyboardEvent<HTMLElement>) => void;
+    handleTab?: (editor: Editor, event: React.KeyboardEvent<HTMLElement>) => void;
+    snippets?: string[];
+    dragHandleTopMargin?: CSSProperties['marginTop'];
+}
+interface NonSelectorBlock extends BaseBlock {
+    isInBlocksSelector: false;
+}
+interface SelectorBlock extends BaseBlock {
+    isInBlocksSelector: true;
+    icon: React.ComponentType;
+    label: MessageDescriptor;
+}
+type NonSelectorBlockKey = 'list-item' | 'link' | 'horizontal-line' | 'table' | 'table-row' | 'table-cell' | 'table-header-cell' | 'media-embed';
+declare const selectorBlockKeys: readonly ["paragraph", "heading-one", "heading-two", "heading-three", "heading-four", "heading-five", "heading-six", "list-ordered", "list-unordered", "list-todo", "image", "audio", "video", "embed", "quote", "code", "math", "diagram", "callout", "details", "button", "social-embed"];
+type SelectorBlockKey = (typeof selectorBlockKeys)[number];
+declare const isSelectorBlockKey: (key: unknown) => key is "image" | "audio" | "math" | "diagram" | "callout" | "details" | "button" | "social-embed" | "embed" | "video" | "code" | "paragraph" | "heading-one" | "heading-two" | "heading-three" | "heading-four" | "heading-five" | "heading-six" | "list-ordered" | "list-unordered" | "list-todo" | "quote";
+type BlocksStore = {
+    [K in SelectorBlockKey]: SelectorBlock;
+} & {
+    [K in NonSelectorBlockKey]: NonSelectorBlock;
+};
+interface BlocksEditorContextValue {
+    blocks: BlocksStore;
+    modifiers: ModifiersStore;
+    disabled: boolean;
+    name: string;
+    setLiveText: (text: string) => void;
+    isExpandedMode: boolean;
+    /** Enters or leaves fullscreen. Surfaced so the toolbar owns the toggle. */
+    onToggleExpand: () => void;
+    pluginOptions?: Record<string, any>;
+}
+interface BlocksEditorProviderProps {
+    children: React.ReactNode;
+    blocks: BlocksStore;
+    modifiers: ModifiersStore;
+    disabled: boolean;
+    name: string;
+    setLiveText: (text: string) => void;
+    isExpandedMode: boolean;
+    onToggleExpand: () => void;
+    pluginOptions?: Record<string, any>;
+}
+declare function useBlocksEditorContext(consumerName: string): BlocksEditorContextValue & {
+    editor: Editor;
+};
+interface BlocksEditorProps extends Pick<FieldValue<Schema.Attribute.BlocksValue>, 'onChange' | 'value' | 'error'>, BlocksContentProps {
+    disabled?: boolean;
+    name: string;
+    pluginOptions?: Record<string, any>;
+}
+declare const BlocksEditor: React.ForwardRefExoticComponent<BlocksEditorProps & React.RefAttributes<{
+    focus: () => void;
+}>>;
+declare const BlocksEditorProvider: React.FC<BlocksEditorProviderProps>;
+export { type BlocksStore, type SelectorBlockKey, BlocksEditor, BlocksEditorProvider, useBlocksEditorContext, isSelectorBlockKey, };

package/dist/admin/src/components/BlocksInput/BlocksToolbar.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { MessageDescriptor } from 'react-intl';
+/**
+ * Handles the modal component that may be returned by a block when converting it
+ */
+declare function useConversionModal(): {
+    modalElement: React.JSX.Element | null;
+    handleConversionResult: (renderModal: void | (() => React.JSX.Element) | undefined) => void;
+};
+interface ToolbarButtonProps {
+    icon: React.ComponentType<React.SVGProps<SVGSVGElement>>;
+    name: string;
+    label: MessageDescriptor;
+    isActive: boolean;
+    disabled: boolean;
+    handleClick: () => void;
+}
+declare const ToolbarButton: ({ icon: Icon, name, label, isActive, disabled, handleClick, }: ToolbarButtonProps) => React.JSX.Element;
+declare const LinkButton: ({ disabled, location, }: {
+    disabled: boolean;
+    location?: 'toolbar' | 'menu';
+}) => React.JSX.Element;
+declare const RemoveFormattingButton: ({ disabled }: {
+    disabled: boolean;
+}) => React.JSX.Element;
+declare const BlocksToolbar: () => React.JSX.Element;
+export { BlocksToolbar, useConversionModal, ToolbarButton, LinkButton, RemoveFormattingButton, };

package/dist/admin/src/components/BlocksInput/EditorLayout.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+interface EditorLayoutProps {
+    children: React.ReactNode;
+    error?: string;
+    onCollapse: () => void;
+    disabled: boolean;
+    ariaDescriptionId: string;
+}
+declare const EditorLayout: ({ children, error, disabled, onCollapse, ariaDescriptionId, }: EditorLayoutProps) => React.JSX.Element;
+export { EditorLayout };

package/dist/admin/src/components/BlocksInput/EmojiPicker.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+declare const EmojiPicker: ({ disabled }: {
+    disabled: boolean;
+}) => React.JSX.Element;
+export { EmojiPicker };

package/dist/admin/src/components/BlocksInput/FindReplace.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { Range } from 'slate';
+/**
+ * Decorate function for highlighting search matches.
+ * Call this from BlocksContent's decorate prop.
+ */
+declare const decorateSearchMatches: (editor: any) => ([node, path]: [any, number[]]) => Range[];
+declare const FindReplace: ({ disabled }: {
+    disabled: boolean;
+}) => React.JSX.Element;
+export { FindReplace, decorateSearchMatches };

package/dist/admin/src/components/BlocksInput/FloatingSelectionToolbar.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+/**
+ * Medium/Notion-style mini toolbar that appears over a text selection, so
+ * formatting doesn't require a trip up to the main toolbar.
+ *
+ * It positions itself imperatively (writing to `style` in an effect rather than
+ * storing a rect in state) because it has to re-measure on every editor render,
+ * and a state write there would loop.
+ */
+declare const FloatingSelectionToolbar: () => React.JSX.Element;
+export { FloatingSelectionToolbar };

package/dist/admin/src/components/BlocksInput/FontModifiersIcons.d.ts

@@ -0,0 +1,32 @@
+import * as React from 'react';
+type FontModifierIconProps = {
+    fill: string;
+};
+export declare const Uppercase: ({ fill }: FontModifierIconProps) => React.JSX.Element;
+export declare const Superscript: ({ fill }: FontModifierIconProps) => React.JSX.Element;
+export declare const UndoIcon: ({ fill, ...props }: React.SVGProps<SVGSVGElement> & {
+    fill?: string;
+}) => React.JSX.Element;
+export declare const RedoIcon: ({ fill, ...props }: React.SVGProps<SVGSVGElement> & {
+    fill?: string;
+}) => React.JSX.Element;
+export declare const AlignLeftIcon: ({ fill, ...props }: React.SVGProps<SVGSVGElement> & {
+    fill?: string;
+}) => React.JSX.Element;
+export declare const AlignCenterIcon: ({ fill, ...props }: React.SVGProps<SVGSVGElement> & {
+    fill?: string;
+}) => React.JSX.Element;
+export declare const AlignRightIcon: ({ fill, ...props }: React.SVGProps<SVGSVGElement> & {
+    fill?: string;
+}) => React.JSX.Element;
+export declare const AlignJustifyIcon: ({ fill, ...props }: React.SVGProps<SVGSVGElement> & {
+    fill?: string;
+}) => React.JSX.Element;
+export declare const LineHeightIcon: ({ fill, ...props }: React.SVGProps<SVGSVGElement> & {
+    fill?: string;
+}) => React.JSX.Element;
+export declare const SpecialCharIcon: ({ fill, ...props }: React.SVGProps<SVGSVGElement> & {
+    fill?: string;
+}) => React.JSX.Element;
+export declare const Subsscript: ({ fill }: FontModifierIconProps) => React.JSX.Element;
+export {};

package/dist/admin/src/components/BlocksInput/InlineColorPicker.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const InlineColorPicker: () => React.JSX.Element;
+export default InlineColorPicker;

package/dist/admin/src/components/BlocksInput/MenuScrollbar.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+/**
+ * Strapi's design system hides the scrollbar on the popover behind the toolbar
+ * dropdown menus (`scrollbar-width: none` + `::-webkit-scrollbar { display: none }`),
+ * and only scrolls on overflow. That means longer menus give no visual cue that
+ * the list can be scrolled up and down.
+ *
+ * Every toolbar dropdown (block type, "+" insert, font size, font family,
+ * alignment, line height, …) is built on the design-system `Menu` component, so
+ * they all share a single scroll container: `[data-radix-menu-content]`. This
+ * forces an always-visible, theme-aware scrollbar on it.
+ *
+ * Implementation notes (verified in Chromium):
+ *   - `overflow-y: scroll` (not `auto`) keeps the scrollbar visible even when the
+ *     content fits.
+ *   - `scrollbar-width` must be overridden to `auto` (not `thin`) to un-hide the
+ *     design-system's `none`. `auto` keeps the `::-webkit-scrollbar`
+ *     pseudo-elements active, whereas `thin` — like `scrollbar-color` — makes
+ *     Chromium fall back to an OS overlay scrollbar that is invisible until you
+ *     scroll (defeating the purpose on macOS). We therefore do NOT set
+ *     `scrollbar-color`; Firefox falls back to its own always-visible bar.
+ *   - The track gets a real background so the channel stays visible even when the
+ *     content fits and the thumb spans the full height; the colours are
+ *     mid-range neutrals that contrast with the menu background (`neutral0`) in
+ *     both the light and dark themes.
+ *   - `!important` / `display: block` are required to beat the design-system
+ *     rules, which share the same specificity.
+ */
+declare const MenuScrollbarStyles: import("react").NamedExoticComponent<import("styled-components").ExecutionProps & object>;
+export { MenuScrollbarStyles };

package/dist/admin/src/components/BlocksInput/Modifiers.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { type MessageDescriptor } from 'react-intl';
+import { Editor, Text } from 'slate';
+type ModifierKey = Exclude<keyof Text, 'type' | 'text'>;
+type ModifiersStore = {
+    [K in ModifierKey]: {
+        icon: React.ComponentType;
+        isValidEventKey: (event: React.KeyboardEvent<HTMLElement>) => boolean;
+        label: MessageDescriptor;
+        checkIsActive: (editor: Editor) => boolean;
+        handleToggle: (editor: Editor) => void;
+        renderLeaf: (children: React.JSX.Element | string) => React.JSX.Element;
+    };
+};
+declare const modifiers: ModifiersStore;
+export { type ModifiersStore, modifiers };

package/dist/admin/src/components/BlocksInput/SlashCommands.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const SlashCommandMenu: () => React.JSX.Element | null;
+export { SlashCommandMenu };

package/dist/admin/src/components/BlocksInput/SpecialCharPicker.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+declare const SpecialCharPicker: ({ disabled }: {
+    disabled: boolean;
+}) => React.JSX.Element;
+export { SpecialCharPicker };

package/dist/admin/src/components/BlocksInput/WordCount.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const WordCount: () => React.JSX.Element;
+export { WordCount };

package/dist/admin/src/components/BlocksInput/plugins/withAutoTransform.d.ts

@@ -0,0 +1,3 @@
+import { Editor } from 'slate';
+declare const withAutoTransform: (editor: Editor) => Editor;
+export { withAutoTransform };

package/dist/admin/src/components/BlocksInput/plugins/withLinks.d.ts

@@ -0,0 +1,8 @@
+import { type BaseEditor, Path } from 'slate';
+import { type ReactEditor } from 'slate-react';
+interface LinkEditor extends BaseEditor, ReactEditor {
+    lastInsertedLinkPath: Path | null;
+    shouldSaveLinkPath: boolean;
+}
+declare const withLinks: (editor: BaseEditor) => LinkEditor;
+export { withLinks, type LinkEditor };

package/dist/admin/src/components/BlocksInput/plugins/withMarkdownPaste.d.ts

@@ -0,0 +1,3 @@
+import { type BaseEditor } from 'slate';
+declare const withMarkdownPaste: (editor: BaseEditor) => BaseEditor;
+export { withMarkdownPaste };

package/dist/admin/src/components/BlocksInput/plugins/withStrapiSchema.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from 'slate';
+/**
+ * This plugin is used to normalize the Slate document to match the Strapi schema.
+ */
+declare const withStrapiSchema: (editor: Editor) => import("slate").BaseEditor;
+export { withStrapiSchema };

package/dist/admin/src/components/BlocksInput/utils/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const codeLanguages: {
+    value: string;
+    label: string;
+    decorate?: string;
+}[];
+export declare const ItemTypes: {
+    readonly COMPONENT: "component";
+    readonly EDIT_FIELD: "editField";
+    readonly FIELD: "field";
+    readonly DYNAMIC_ZONE: "dynamicZone";
+    readonly RELATION: "relation";
+    readonly BLOCKS: "blocks";
+};

package/dist/admin/src/components/BlocksInput/utils/conversions.d.ts

@@ -0,0 +1,14 @@
+import { type Path, Editor } from 'slate';
+import { CustomElement } from './types';
+/**
+ * Extracts some logic that is common to most blocks' handleConvert functions.
+ * @returns The path of the converted block
+ */
+declare const baseHandleConvert: <T extends CustomElement>(editor: Editor, attributesToSet: Partial<T> & {
+    type: T['type'];
+}) => void | Path;
+/**
+ * Set all attributes except type, children, and font settings to null so that Slate deletes them
+ */
+declare const getAttributesToClear: (element: CustomElement) => Record<string, any>;
+export { baseHandleConvert, getAttributesToClear };

package/dist/admin/src/components/BlocksInput/utils/enterKey.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from 'slate';
+/**
+ * Inserts a line break the first time the user presses enter, and exits the node the second time.
+ */
+declare const pressEnterTwiceToExit: (editor: Editor) => void;
+export { pressEnterTwiceToExit };

package/dist/admin/src/components/BlocksInput/utils/links.d.ts

@@ -0,0 +1,12 @@
+import { Editor } from 'slate';
+declare const removeLink: (editor: Editor) => void;
+declare const insertLink: (editor: Editor, { url }: {
+    url: string;
+}) => void;
+declare const editLink: (editor: Editor, link: {
+    url: string;
+    text: string;
+    target?: '_blank';
+    rel?: string;
+}) => void;
+export { insertLink, editLink, removeLink };

package/dist/admin/src/components/BlocksInput/utils/optionsDefaults.d.ts

@@ -0,0 +1,28 @@
+import { Option } from './types';
+export declare const COLORS_OPTIONS: {
+    label: string;
+    value: string;
+}[];
+export declare const BG_COLORS_OPTIONS: {
+    label: string;
+    value: string;
+}[];
+export declare const FONT_FAMILY_OPTIONS: Option[];
+export declare const FONT_SIZE_OPTIONS: Option[];
+export declare const FONT_LEADING_OPTIONS: Option[];
+export declare const FONT_TRACKING_OPTIONS: Option[];
+export declare const FONT_ALIGNMENT_OPTIONS: Option[];
+export declare const VIEWPORT_OPTIONS: Option[];
+export declare const SEPARATOR_STYLE_OPTIONS: Option[];
+export declare const SEPARATOR_ORIENTATION_OPTIONS: Option[];
+export declare const DEFAULT_COLOR: string;
+export declare const DEFAULT_FONT_FAMILY: string;
+export declare const DEFAULT_FONT_SIZE: string;
+export declare const DEFAULT_FONT_LEADING: string;
+export declare const DEFAULT_FONT_ALIGNMENT: string;
+export declare const DEFAULT_FONT_TRACKING: string;
+export declare const DEFAULT_VIEWPORT: string;
+export declare const DEFAULT_SEPARATOR_SIZE = 1;
+export declare const DEFAULT_SEPARATOR_STYLE: string;
+export declare const DEFAULT_SEPARATOR_ORIENTATION: string;
+export declare const DEFAULT_SEPARATOR_LENGTH = 100;

package/dist/admin/src/components/BlocksInput/utils/optionsParser.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Parses a string formatted as "Label:value\nLabel2:value2" into an array of options
+ * If no colon is found, the value is used as both label and value
+ * @param presetString The string to parse
+ * @returns Array of {label, value} objects
+ */
+export declare const parsePresetString: (presetString?: string) => {
+    label: string;
+    value: string;
+}[];
+/**
+ * Gets the custom options from plugin config if available and enabled
+ * Falls back to default options if not
+ */
+export declare const getOptionsWithFallback: (defaultOptions: Array<{
+    label: string;
+    value: string;
+}>, customPresets?: string, useCustom?: boolean) => {
+    label: string;
+    value: string;
+}[];
+export declare const _testParser: () => {
+    name: string;
+    passed: boolean;
+    input: string;
+    expected: {
+        label: string;
+        value: string;
+    }[];
+    actual: {
+        label: string;
+        value: string;
+    }[];
+}[];