@atlaskit/editor-plugin-block-menu 10.1.14 → 10.1.16

package/dist/types-ts4.5/editor-commands/transform-node-utils/steps/wrapMixedContentStep.d.ts

@@ -1,39 +0,0 @@
-import type { TransformStep } from '../types';
-/**
- * A wrap step that handles mixed content according to the Compatibility Matrix:
- * - Wraps consecutive compatible nodes into the target container
- * - Same-type containers break out as separate containers (preserved as-is)
- * - NestedExpands break out as regular expands (converted since nestedExpand can't exist outside expand)
- * - Container structures that can't be nested in target break out (not flattened)
- * - Text/list nodes that can't be wrapped are converted to paragraphs and merged into the container
- * - Atomic nodes (tables, media, macros) break out
- *
- * Special handling for layouts:
- * - Layout sections break out as separate layouts (preserved as-is, not wrapped)
- * - Other nodes (including headings, paragraphs, lists) are wrapped into layout columns within a layout section
- * - Layouts always require layoutColumns as children (never paragraphs directly)
- * - Layout columns can contain most block content including headings, paragraphs, lists, etc.
- *
- * Special handling for codeblocks:
- * - Text nodes are converted to plain text and added to the codeblock
- *
- * Edge case handling:
- * - For regular containers: If all content breaks out (container → container transform with no
- *   valid children), an empty container with a paragraph is created to ensure the target type exists
- * - For layouts: Edge case handling is skipped because layouts require columns, not direct paragraphs.
- *   If all content breaks out, only the broken-out nodes are returned (no empty layout created)
- *
- * What can be wrapped depends on the target container's schema:
- * - expand → panel: tables break out, nestedExpands convert to expands and break out
- * - expand → blockquote: tables/media break out, nestedExpands convert to expands and break out, headings converted to paragraphs
- * - expand → expand: tables/media stay inside (expands can contain them)
- * - multi → layoutSection: layout sections break out, headings/paragraphs/lists wrapped into layout columns
- *
- * Example: expand(p('a'), table(), p('b')) → panel: [panel(p('a')), table(), panel(p('b'))]
- * Example: expand(p('a'), panel(p('x')), p('b')) → panel: [panel(p('a')), panel(p('x')), panel(p('b'))]
- * Example: expand(p('a'), nestedExpand({title: 'inner'})(p('x')), p('b')) → panel: [panel(p('a')), expand({title: 'inner'})(p('x')), panel(p('b'))]
- * Example: expand(nestedExpand()(p())) → panel: [panel(), expand()(p())] (empty panel when all content breaks out)
- * Example: [p('a'), layoutSection(...), p('b')] → layoutSection: [layoutSection(layoutColumn(p('a'))), layoutSection(...), layoutSection(layoutColumn(p('b')))]
- * Example: [h1('heading'), p('para')] → layoutSection: [layoutSection(layoutColumn(h1('heading'), p('para')))] (headings stay as headings in layouts)
- */
-export declare const wrapMixedContentStep: TransformStep;

package/dist/types-ts4.5/editor-commands/transform-node-utils/steps/wrapStep.d.ts

@@ -1,10 +0,0 @@
-import type { TransformStep } from '../types';
-/**
- * Wraps nodes into the target container type.
- * When wrapping into expand, any expand children are converted to nestedExpand
- * since expand cannot be a direct child of expand.
- *
- * Preserves breakout marks when both source and target nodes support resizing
- * (codeBlock, expand, layoutSection).
- */
-export declare const wrapStep: TransformStep;

package/dist/types-ts4.5/editor-commands/transform-node-utils/transform.d.ts

@@ -1,29 +0,0 @@
-import type { Node as PMNode, NodeType, Schema } from '@atlaskit/editor-prosemirror/model';
-import type { NodeTypeName } from './types';
-interface GetOutputNodesArgs {
-    isNested: boolean;
-    parentNode?: PMNode;
-    schema: Schema;
-    sourceNodes: PMNode[];
-    targetAttrs?: Record<string, unknown>;
-    targetNodeType: NodeType;
-}
-export declare const upgradePanelNodesToPanelC1: (nodes: PMNode[], parentNode: PMNode | undefined, schema: Schema) => PMNode[];
-/**
- * Convert a list of nodes to a target node type.
- * If no steps are found, the source nodes are returned unchanged.
- * If steps are found, they are applied to the source nodes in order.
- * If a step returns an empty array, the source nodes are returned.
- * If a step returns a non-empty array, that array is returned.
- * @param args - The conversion arguments
- * @param args.sourceNodes - The list of nodes to convert
- * @param args.targetNodeType - The type of node to convert into
- * @param args.schema - The schema to use for the conversion
- * @param args.isNested - Whether the conversion is nested
- * @param args.targetAttrs - The attributes to use for the conversion
- * @param args.parentNode - The parent node of the selected node
- * @returns The converted list of nodes
- */
-export declare const convertNodesToTargetType: ({ sourceNodes, targetNodeType, schema, isNested, targetAttrs, parentNode, }: GetOutputNodesArgs) => PMNode[];
-export declare const isTransformDisabledBasedOnStepsConfig: (selectedNodeType: NodeTypeName, targetNodeType: NodeTypeName) => boolean;
-export {};

package/dist/types-ts4.5/editor-commands/transform-node-utils/types.d.ts

@@ -1,14 +0,0 @@
-import type { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
-export type NodeTypeName = 'blockquote' | 'blockCard' | 'bodiedExtension' | 'bulletList' | 'codeBlock' | 'decisionList' | 'embedCard' | 'expand' | 'extension' | 'heading' | 'layoutSection' | 'media' | 'mediaGroup' | 'mediaSingle' | 'multiBodiedExtension' | 'orderedList' | 'panel' | 'panel_c1' | 'paragraph' | 'nestedExpand' | 'taskList' | 'table' | 'multi';
-export type NodeCategory = 'atomic' | 'container' | 'list' | 'text' | 'multi';
-export declare const NODE_CATEGORY_BY_TYPE: Record<NodeTypeName, NodeCategory>;
-export declare const isNodeTypeName: (value: string) => value is NodeTypeName;
-export declare const toNodeTypeValue: (value?: string | null) => NodeTypeName | null;
-export declare const getNodeName: (nodes: PMNode[]) => string | undefined;
-export type TransformStep = (nodes: PMNode[], context: TransformStepContext) => PMNode[];
-export interface TransformStepContext {
-    fromNode: PMNode;
-    schema: Schema;
-    targetAttrs?: Record<string, unknown>;
-    targetNodeTypeName: NodeTypeName;
-}

package/dist/types-ts4.5/editor-commands/transform-node-utils/utils.d.ts

@@ -1,39 +0,0 @@
-import type { NodeRange, Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
-import type { Selection } from '@atlaskit/editor-prosemirror/state';
-import type { ContentNodeWithPos } from '@atlaskit/editor-prosemirror/utils';
-import type { NodeTypeName } from './types';
-/**
- * Determines if a node is a text node (heading or paragraph).
- * Text nodes can have their content converted to paragraphs when they can't be wrapped directly.
- */
-export declare const isTextNode: (node: PMNode) => boolean;
-export declare const isListNode: (node: PMNode) => boolean;
-export declare const getSelectedNode: (selection: Selection) => ContentNodeWithPos | undefined;
-export declare const getTargetNodeTypeNameInContext: (nodeTypeName: NodeTypeName | null, isNested?: boolean, parentNode?: PMNode, schema?: Schema) => NodeTypeName | null;
-/**
- * Converts a nestedExpand to a regular expand node.
- * NestedExpands can only exist inside expands, so when breaking out or placing
- * in containers that don't support nesting, they must be converted.
- */
-export declare const convertNestedExpandToExpand: (node: PMNode, schema: Schema) => PMNode | null;
-/**
- * Converts an expand to a nestedExpand node.
- * When placing an expand inside another expand, it must become a nestedExpand
- * since expand cannot be a direct child of expand.
- */
-export declare const convertExpandToNestedExpand: (node: PMNode, schema: Schema) => PMNode | null;
-/**
- * Converts a text node (heading, paragraph) to a paragraph preserving its inline content.
- * This is used when a text node can't be wrapped directly in the target container
- * (e.g., heading can't go in blockquote, so it becomes a paragraph).
- */
-export declare const convertTextNodeToParagraph: (node: PMNode, schema: Schema) => PMNode | null;
-export declare const getBlockNodesInRange: (range: NodeRange) => PMNode[];
-/**
- * Iterates over a nodes children and extracting text content, removing all other inline content and converting
- * hardbreaks to newlines.
- *
- * @param node - The node to create text content from (should be paragraph)
- * @returns The text content string.
- */
-export declare const createTextContent: (node: PMNode) => string;

package/dist/types-ts4.5/editor-commands/transformNode.d.ts

@@ -1,5 +0,0 @@
-import type { EditorCommand, ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { NodeType } from '@atlaskit/editor-prosemirror/model';
-import type { BlockMenuPlugin } from '../blockMenuPluginType';
-import type { TransformNodeMetadata } from './types';
-export declare const transformNode: (api?: ExtractInjectionAPI<BlockMenuPlugin>) => (targetType: NodeType, metadata?: TransformNodeMetadata) => EditorCommand;

package/dist/types-ts4.5/editor-commands/types.d.ts

@@ -1,8 +0,0 @@
-import type { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-export type TransfromNodeTargetType = 'heading1' | 'heading2' | 'heading3' | 'heading4' | 'heading5' | 'heading6' | 'paragraph' | 'blockquote' | 'expand' | 'layoutSection' | 'panel' | 'panel_c1' | 'codeBlock' | 'bulletList' | 'orderedList' | 'taskList' | 'decisionList';
-export type TransformNodeMetadata = {
-    inputMethod: INPUT_METHOD.BLOCK_MENU;
-    targetAttrs?: Record<string, unknown>;
-    targetTypeName: TransfromNodeTargetType;
-    triggeredFrom: INPUT_METHOD.MOUSE | INPUT_METHOD.KEYBOARD;
-};

package/dist/types-ts4.5/entry-points/blockMenuPlugin.d.ts

@@ -1 +0,0 @@
-export { blockMenuPlugin } from '../blockMenuPlugin';

package/dist/types-ts4.5/entry-points/blockMenuPluginType.d.ts

@@ -1 +0,0 @@
-export type { BlockMenuPlugin, RegisterBlockMenuComponent, Parent, BlockMenuPluginOptions, BlockMenuSharedState, } from '../blockMenuPluginType';

package/dist/types-ts4.5/entry-points/types.d.ts

@@ -1 +0,0 @@
-export type { TransformNodeMetadata, TransfromNodeTargetType } from '../editor-commands/types';

package/dist/types-ts4.5/index.d.ts

@@ -1,3 +0,0 @@
-export { blockMenuPlugin } from './blockMenuPlugin';
-export type { BlockMenuPlugin, RegisterBlockMenuComponent, Parent, BlockMenuPluginOptions, BlockMenuSharedState, } from './blockMenuPluginType';
-export type { TransformNodeMetadata, TransfromNodeTargetType } from './editor-commands/types';

package/dist/types-ts4.5/pm-plugins/experiences/block-menu-experiences.d.ts

@@ -1,10 +0,0 @@
-import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-type ExperienceOptions = {
-    dispatchAnalyticsEvent: DispatchAnalyticsEvent;
-    refs: {
-        popupsMountPoint?: HTMLElement;
-    };
-};
-export declare const getBlockMenuExperiencesPlugin: ({ refs, dispatchAnalyticsEvent, }: ExperienceOptions) => SafePlugin;
-export {};

package/dist/types-ts4.5/pm-plugins/experiences/experience-check-utils.d.ts

@@ -1,65 +0,0 @@
-import type { ExperienceCheckResult } from '@atlaskit/editor-common/experiences';
-/**
- * Checks if the given element or any of its ancestors is a drag handle element.
- *
- * @param element - The DOM element to check.
- * @returns True if the element is a drag handle, false otherwise.
- */
-export declare const isDragHandleElement: (element: Element | null) => boolean;
-/**
- * Checks if the block menu is currently visible within the provided popups target element.
- *
- * @param popupsTarget - The container element for popups.
- * @returns True if the block menu is visible, false otherwise.
- */
-export declare const isBlockMenuVisible: (popupsTarget: HTMLElement | undefined) => boolean;
-/**
- * Handles DOM mutations to determine if the block menu was opened
- *
- * This function looks for mutations that indicate the block menu
- * has been added to the DOM.
- *
- * @param mutations - The list of DOM mutations to evaluate
- * @returns An ExperienceCheckResult indicating success if the menu was opened, otherwise undefined
- */
-export declare const handleMenuOpenDomMutation: ({ mutations, }: {
-    mutations: MutationRecord[];
-}) => ExperienceCheckResult | undefined;
-/**
- * Handles DOM mutations to determine if a move action was performed
- *
- * Move actions typically produce two mutations: one where nodes are removed
- * from their original location, and another where the same number of nodes are
- * added to a new location. This function checks for that pattern.
- *
- * @param mutations - The list of DOM mutations to evaluate
- * @returns An ExperienceCheckResult indicating success if a move was detected, otherwise undefined
- */
-export declare const handleMoveDomMutation: ({ mutations, }: {
-    mutations: MutationRecord[];
-}) => ExperienceCheckResult | undefined;
-/**
- * Handles DOM mutations to determine if a delete action was performed
- *
- * Delete actions typically produce a single mutation where nodes are removed
- * from the DOM without any corresponding additions. This function checks for
- * that specific pattern.
- *
- * @param mutations - The list of DOM mutations to evaluate
- * @returns An ExperienceCheckResult indicating success if a delete was detected, otherwise undefined
- */
-export declare const handleDeleteDomMutation: ({ mutations, }: {
-    mutations: MutationRecord[];
-}) => ExperienceCheckResult | undefined;
-/**
- * Handles DOM mutations to determine if a transform action was performed.
- *
- * Transforms replace one block type with another (e.g. paragraph → heading),
- * producing childList mutations with both removed (old node) and added (new node).
- *
- * @param options.mutations - The list of DOM mutation records
- * @returns An ExperienceCheckResult indicating success if a transform was detected, otherwise undefined
- */
-export declare const handleTransformDomMutation: ({ mutations, }: {
-    mutations: MutationRecord[];
-}) => ExperienceCheckResult | undefined;

package/dist/types-ts4.5/pm-plugins/keymap.d.ts

@@ -1,4 +0,0 @@
-import type { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin, BlockMenuPluginOptions } from '../blockMenuPluginType';
-export declare function keymapPlugin(api: ExtractInjectionAPI<BlockMenuPlugin> | undefined, config: BlockMenuPluginOptions | undefined): SafePlugin;

package/dist/types-ts4.5/pm-plugins/main.d.ts

@@ -1,10 +0,0 @@
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import { PluginKey } from '@atlaskit/editor-prosemirror/state';
-import type { BlockMenuPlugin, FLAG_ID } from '../blockMenuPluginType';
-export declare const blockMenuPluginKey: PluginKey;
-type BlockMenuPluginState = {
-    showFlag: FLAG_ID | false;
-};
-export declare const createPlugin: (api: ExtractInjectionAPI<BlockMenuPlugin> | undefined) => SafePlugin<BlockMenuPluginState>;
-export {};

package/dist/types-ts4.5/pm-plugins/utils/shouldSuppressKeyboardEvent.d.ts

@@ -1,14 +0,0 @@
-/**
- * Determines whether keyboard events should be suppressed when the block menu is open.
- *
- * When the block menu is open, we want to block most keyboard events to prevent
- * unintended interactions. However, certain actions should still be allowed:
- * - Backspace/Delete: Allow deleting selected content
- * - Copy/Cut/Paste: Allow clipboard operations (Cmd/Ctrl+C, Cmd/Ctrl+X, Cmd/Ctrl+V)
- * - Undo/Redo: Allow undo/redo operations (Cmd/Ctrl+Z, Cmd/Ctrl+Y)
- * - Copy Link to Selection: Allow the keyboard shortcut (Cmd/Ctrl+Alt+A)
- *
- * @param event - The keyboard event to check
- * @returns true if the event should be suppressed, false if it should be allowed
- */
-export declare const shouldSuppressKeyboardEvent: (event: KeyboardEvent) => boolean;

package/dist/types-ts4.5/ui/MenuSection.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-import type { MessageDescriptor } from 'react-intl';
-type MenuSectionProps = {
-    children?: React.ReactNode;
-    hasSeparator?: boolean;
-    title: MessageDescriptor;
-};
-export declare const MenuSection: ({ children, title, hasSeparator, }: MenuSectionProps) => React.JSX.Element;
-export {};

package/dist/types-ts4.5/ui/block-menu-components.d.ts

@@ -1,6 +0,0 @@
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin, BlockMenuPluginOptions, RegisterBlockMenuComponent } from '../blockMenuPluginType';
-export declare const getBlockMenuComponents: ({ api, config, }: {
-    api: ExtractInjectionAPI<BlockMenuPlugin> | undefined;
-    config: BlockMenuPluginOptions | undefined;
-}) => RegisterBlockMenuComponent[];

package/dist/types-ts4.5/ui/block-menu-provider.d.ts

@@ -1,24 +0,0 @@
-import React from 'react';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { EditorView } from '@atlaskit/editor-prosemirror/view';
-import type { BlockMenuPlugin } from '../blockMenuPluginType';
-export type Direction = 'moveUp' | 'moveDown';
-type BlockMenuProviderProps = {
-    api: ExtractInjectionAPI<BlockMenuPlugin> | undefined;
-    children: React.ReactNode;
-    editorView: EditorView | undefined;
-};
-export type BlockMenuContextType = {
-    getFirstSelectedDomNode: () => Element | undefined;
-    moveDownRef: React.MutableRefObject<HTMLButtonElement | null>;
-    moveUpRef: React.MutableRefObject<HTMLButtonElement | null>;
-    /**
-     * Callback for when the dropdown is open/closed. Receives an object with `isOpen` state.
-     *
-     * If the dropdown was closed programmatically, the `event` parameter will be `null`.
-     */
-    onDropdownOpenChanged: (isOpen: boolean) => void;
-};
-export declare const useBlockMenu: () => BlockMenuContextType;
-export declare const BlockMenuProvider: ({ children, api, editorView, }: BlockMenuProviderProps) => React.JSX.Element;
-export {};

package/dist/types-ts4.5/ui/block-menu-renderer/BlockMenuComponent.d.ts

@@ -1,11 +0,0 @@
-import React from 'react';
-import type { RegisterBlockMenuComponent } from '../../blockMenuPluginType';
-import type { BlockMenuRenderingContext } from './types';
-type BlockMenuComponentProps = BlockMenuRenderingContext & {
-    registeredComponent: RegisterBlockMenuComponent;
-};
-/**
- * Renders the given registered component based on its type
- */
-export declare const BlockMenuComponent: ({ registeredComponent, childrenMap, fallbacks, }: BlockMenuComponentProps) => React.JSX.Element | null;
-export {};

package/dist/types-ts4.5/ui/block-menu-renderer/BlockMenuComponents.d.ts

@@ -1,12 +0,0 @@
-import React from 'react';
-import type { RegisterBlockMenuComponent } from '../../blockMenuPluginType';
-import type { BlockMenuRenderingContext } from './types';
-type BlockMenuComponentsProps = BlockMenuRenderingContext & {
-    registeredComponents?: RegisterBlockMenuComponent[];
-};
-/**
- * Renders the given registered components
- * Returns null if no components are rendered
- */
-export declare const BlockMenuComponents: ({ registeredComponents, childrenMap, fallbacks, }: BlockMenuComponentsProps) => React.JSX.Element | null;
-export {};

package/dist/types-ts4.5/ui/block-menu-renderer/BlockMenuRenderer.d.ts

@@ -1,12 +0,0 @@
-import React from 'react';
-import type { RegisterBlockMenuComponent } from '../../blockMenuPluginType';
-import type { BlockMenuFallbacks } from './types';
-type BlockMenuProps = {
-    allRegisteredComponents: RegisterBlockMenuComponent[];
-    fallbacks?: BlockMenuFallbacks;
-};
-/**
- * BlockMenuRenderer orchestrates the rendering of the entire block menu hierarchy
- */
-export declare const BlockMenuRenderer: ({ allRegisteredComponents, fallbacks, }: BlockMenuProps) => React.JSX.Element;
-export {};

package/dist/types-ts4.5/ui/block-menu-renderer/fallbacks.d.ts

@@ -1,2 +0,0 @@
-import type { BlockMenuFallbacks } from './types';
-export declare const BLOCK_MENU_FALLBACKS: BlockMenuFallbacks;

package/dist/types-ts4.5/ui/block-menu-renderer/types.d.ts

@@ -1,27 +0,0 @@
-import type { BlockMenuItemComponent, BlockMenuNestedComponent, BlockMenuSectionComponent, RegisterBlockMenuComponent } from '../../blockMenuPluginType';
-/**
- * Fallback components used as defaults when specific components aren't provided
- */
-export type BlockMenuFallbacks = {
-    'block-menu-item': BlockMenuItemComponent;
-    'block-menu-nested': BlockMenuNestedComponent;
-    'block-menu-section': BlockMenuSectionComponent;
-};
-/**
- * Map of parent keys to their sorted children components
- * Used to efficiently organize and render hierarchical menu structures
- */
-export type ChildrenMap = Map<string, RegisterBlockMenuComponent[]>;
-/**
- * Props shared across multiple block menu rendering components
- */
-export type BlockMenuRenderingContext = {
-    /**
-     * Lookup map for child components organized by parent key
-     */
-    childrenMap: ChildrenMap;
-    /**
-     * Fallback components when specific components aren't registered
-     */
-    fallbacks: BlockMenuFallbacks;
-};

package/dist/types-ts4.5/ui/block-menu-renderer/utils.d.ts

@@ -1,36 +0,0 @@
-import type { RegisterBlockMenuComponent, RegisterBlockMenuComponentType, RegisterBlockMenuSection } from '../../blockMenuPluginType';
-import type { ChildrenMap } from './types';
-/**
- * Gets all top-level sections (those without a parent) sorted by rank
- *
- * @param components All registered block menu components
- * @returns Sorted array of top-level sections
- */
-export declare const getSortedTopLevelSections: (components: RegisterBlockMenuComponent[]) => RegisterBlockMenuSection[];
-/**
- * Generates a unique key from a key and type
- * Used to lookup children in the childrenMap
- *
- * @param key The component's key
- * @param type The component's type
- * @returns A unique string key combining type and key
- */
-export declare const getChildrenMapKey: (key: string, type: Omit<RegisterBlockMenuComponentType, "block-menu-item">) => string;
-/**
- * Builds a map of parent keys to their sorted children
- * This enables efficient hierarchical rendering of the menu structure
- *
- * @param components All registered block menu components
- * @returns Map where keys are parent identifiers and values are sorted child components
- */
-export declare const buildChildrenMap: (components: RegisterBlockMenuComponent[]) => ChildrenMap;
-/**
- * Determines whether a component will render based on its type and children
- *
- * Rules:
- * - An item will not render if it has isHidden that returns true OR if its component returns null (fallback)
- * - A nested menu will render if at least one section, that has at least one registered child
- * - A section will render if it has at least one registered child component that will render
- *
- */
-export declare const willComponentRender: (registeredComponent: RegisterBlockMenuComponent, childrenMap: ChildrenMap) => boolean;

package/dist/types-ts4.5/ui/block-menu.d.ts

@@ -1,16 +0,0 @@
-import React from 'react';
-import type { WithIntlProps, WrappedComponentProps } from 'react-intl';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { EditorView } from '@atlaskit/editor-prosemirror/view';
-import type { BlockMenuPlugin } from '../blockMenuPluginType';
-export type BlockMenuProps = {
-    api: ExtractInjectionAPI<BlockMenuPlugin> | undefined;
-    boundariesElement?: HTMLElement;
-    editorView: EditorView | undefined;
-    mountTo?: HTMLElement;
-    scrollableElement?: HTMLElement;
-};
-declare const _default_1: React.FC<WithIntlProps<BlockMenuProps & WrappedComponentProps>> & {
-    WrappedComponent: React.ComponentType<BlockMenuProps & WrappedComponentProps>;
-};
-export default _default_1;

package/dist/types-ts4.5/ui/consts.d.ts

@@ -1,11 +0,0 @@
-export declare const BLOCK_MENU_LABEL = "Editor Block Menu";
-/**
- * Constants for block menu analytics menu item names
- */
-export declare const BLOCK_MENU_ITEM_NAME: {
-    readonly COPY_LINK_TO_BLOCK: "copyLinkToBlock";
-    readonly MOVE_UP: "moveUp";
-    readonly MOVE_DOWN: "moveDown";
-    readonly DELETE: "delete";
-    readonly FORMAT_MENU: "formatMenu";
-};

package/dist/types-ts4.5/ui/copy-link.d.ts

@@ -1,12 +0,0 @@
-import React from 'react';
-import type { WithIntlProps, WrappedComponentProps } from 'react-intl';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin, BlockMenuPluginOptions } from '../blockMenuPluginType';
-type Props = {
-    api: ExtractInjectionAPI<BlockMenuPlugin> | undefined;
-    config: BlockMenuPluginOptions | undefined;
-};
-export declare const CopyLinkDropdownItem: React.FC<WithIntlProps<Props & WrappedComponentProps>> & {
-    WrappedComponent: React.ComponentType<Props & WrappedComponentProps>;
-};
-export {};

package/dist/types-ts4.5/ui/copy-section.d.ts

@@ -1,4 +0,0 @@
-import React from 'react';
-export declare const CopySection: ({ children }: {
-    children: React.ReactNode;
-}) => React.JSX.Element;

package/dist/types-ts4.5/ui/delete-button.d.ts

@@ -1,11 +0,0 @@
-import React from 'react';
-import type { WithIntlProps, WrappedComponentProps } from 'react-intl';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin } from '../blockMenuPluginType';
-type Props = {
-    api: ExtractInjectionAPI<BlockMenuPlugin> | undefined;
-} & WrappedComponentProps;
-export declare const DeleteDropdownItem: React.FC<WithIntlProps<Props>> & {
-    WrappedComponent: React.ComponentType<Props>;
-};
-export {};

package/dist/types-ts4.5/ui/delete-section.d.ts

@@ -1,4 +0,0 @@
-import React from 'react';
-export declare const DeleteSection: ({ children, }: {
-    children: React.ReactNode;
-}) => React.JSX.Element | null;

package/dist/types-ts4.5/ui/flag.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin } from '../blockMenuPluginType';
-type Props = {
-    api?: ExtractInjectionAPI<BlockMenuPlugin>;
-};
-export declare const Flag: ({ api }: Props) => React.JSX.Element | undefined;
-export {};

package/dist/types-ts4.5/ui/format-menu-nested.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin } from '../blockMenuPluginType';
-export declare const FormatMenuComponent: ({ api, children, }: {
-    api: ExtractInjectionAPI<BlockMenuPlugin> | undefined;
-    children: React.ReactNode;
-}) => React.JSX.Element;

package/dist/types-ts4.5/ui/format-menu-section.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin } from '../blockMenuPluginType';
-export declare const FormatMenuSection: ({ children, api, }: {
-    api: ExtractInjectionAPI<BlockMenuPlugin> | undefined;
-    children: React.ReactNode;
-}) => React.JSX.Element | null;

package/dist/types-ts4.5/ui/hooks/useSuggestedItems.d.ts

@@ -1,3 +0,0 @@
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin, RegisterBlockMenuItem } from '../../blockMenuPluginType';
-export declare const useSuggestedItems: (api: ExtractInjectionAPI<BlockMenuPlugin> | undefined) => RegisterBlockMenuItem[];

package/dist/types-ts4.5/ui/move-down.d.ts

@@ -1,11 +0,0 @@
-import React from 'react';
-import type { WithIntlProps, WrappedComponentProps } from 'react-intl';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin } from '../blockMenuPluginType';
-type Props = {
-    api: ExtractInjectionAPI<BlockMenuPlugin> | undefined;
-};
-export declare const MoveDownDropdownItem: React.FC<WithIntlProps<Props & WrappedComponentProps>> & {
-    WrappedComponent: React.ComponentType<Props & WrappedComponentProps>;
-};
-export {};

package/dist/types-ts4.5/ui/move-up.d.ts

@@ -1,11 +0,0 @@
-import React from 'react';
-import type { WithIntlProps, WrappedComponentProps } from 'react-intl';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin } from '../blockMenuPluginType';
-type Props = {
-    api: ExtractInjectionAPI<BlockMenuPlugin> | undefined;
-};
-export declare const MoveUpDropdownItem: React.FC<WithIntlProps<Props & WrappedComponentProps>> & {
-    WrappedComponent: React.ComponentType<Props & WrappedComponentProps>;
-};
-export {};

package/dist/types-ts4.5/ui/suggested-items-menu-section.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin } from '../blockMenuPluginType';
-type SuggestedItemsMenuSectionProps = {
-    api: ExtractInjectionAPI<BlockMenuPlugin> | undefined;
-    children?: React.ReactNode;
-};
-export declare const SuggestedItemsMenuSection: React.NamedExoticComponent<SuggestedItemsMenuSectionProps>;
-export {};

package/dist/types-ts4.5/ui/suggested-menu-items.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin } from '../blockMenuPluginType';
-type SuggestedMenuItemsProps = {
-    api: ExtractInjectionAPI<BlockMenuPlugin> | undefined;
-};
-export declare const SuggestedMenuItems: React.NamedExoticComponent<SuggestedMenuItemsProps>;
-export {};

package/dist/types-ts4.5/ui/utils/checkHasPreviousSectionContent.d.ts

@@ -1,26 +0,0 @@
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin } from '../../blockMenuPluginType';
-/**
- * Checks if the Suggested section has any visible content
- */
-export declare const hasSuggestedSectionContent: (api: ExtractInjectionAPI<BlockMenuPlugin> | undefined) => boolean;
-/**
- * Checks if the Create section has any visible content
- */
-export declare const hasCreateSectionContent: (api: ExtractInjectionAPI<BlockMenuPlugin> | undefined) => boolean;
-/**
- * Checks if the Structure section has any visible content
- */
-export declare const hasStructureSectionContent: (api: ExtractInjectionAPI<BlockMenuPlugin> | undefined) => boolean;
-/**
- * Checks if there's any content before the Create section (i.e., Suggested section has content)
- */
-export declare const hasContentBeforeCreate: (api: ExtractInjectionAPI<BlockMenuPlugin> | undefined) => boolean;
-/**
- * Checks if there's any content before the Structure section (i.e., Create or Suggested sections have content)
- */
-export declare const hasContentBeforeStructure: (api: ExtractInjectionAPI<BlockMenuPlugin> | undefined) => boolean;
-/**
- * Checks if there's any content before the Headings section (i.e., Structure, Create, or Suggested sections have content)
- */
-export declare const hasContentBeforeHeadings: (api: ExtractInjectionAPI<BlockMenuPlugin> | undefined) => boolean;

package/dist/types-ts4.5/ui/utils/checkIsFormatMenuHidden.d.ts

@@ -1,3 +0,0 @@
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { BlockMenuPlugin } from '../../blockMenuPluginType';
-export declare const checkIsFormatMenuHidden: (api: ExtractInjectionAPI<BlockMenuPlugin> | undefined) => boolean;

package/dist/types-ts4.5/ui/utils/copyLink.d.ts

@@ -1,8 +0,0 @@
-import type { Selection } from '@atlaskit/editor-prosemirror/state';
-type CopyLinkOptions = {
-    blockLinkHashPrefix?: string;
-    getLinkPath?: () => string | null;
-    selection: Selection;
-};
-export declare const copyLink: ({ getLinkPath, blockLinkHashPrefix, selection, }: CopyLinkOptions) => Promise<boolean>;
-export {};