@atlaskit/editor-core 182.2.0 → 183.0.6

package/dist/types-ts4.0/plugins/type-ahead/pm-plugins/main.d.ts

@@ -0,0 +1,15 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { IntlShape } from 'react-intl-next';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { Dispatch } from '../../../event-dispatcher';
+import type { PopupMountPointReference, TypeAheadHandler } from '../types';
+declare type Props = {
+    reactDispatch: Dispatch;
+    popupMountRef: PopupMountPointReference;
+    typeAheadHandlers: Array<TypeAheadHandler>;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    getIntl: () => IntlShape;
+    useBetterTypeaheadNavigation: boolean;
+};
+export declare function createPlugin({ reactDispatch, popupMountRef, createAnalyticsEvent, typeAheadHandlers, getIntl, useBetterTypeaheadNavigation, }: Props): SafePlugin;
+export {};

package/dist/types-ts4.0/plugins/type-ahead/pm-plugins/reducer.d.ts

@@ -0,0 +1,10 @@
+import { ReadonlyTransaction } from 'prosemirror-state';
+import { InsertTypeAheadStep } from '@atlaskit/adf-schema/steps';
+import { CreateTypeAheadDecorations, PopupMountPointReference, RemoveTypeAheadDecorations, TypeAheadHandler, TypeAheadPluginState } from '../types';
+export declare type ReducerOptions = {
+    popupMountRef: PopupMountPointReference;
+    createDecorations: CreateTypeAheadDecorations;
+    removeDecorations: RemoveTypeAheadDecorations;
+    typeAheadHandlers: Array<TypeAheadHandler>;
+};
+export declare const createReducer: ({ typeAheadHandlers, removeDecorations, createDecorations, }: ReducerOptions) => (tr: ReadonlyTransaction, currentPluginState: TypeAheadPluginState, typeAheadStepOverride: InsertTypeAheadStep | null) => TypeAheadPluginState;

package/dist/types-ts4.0/plugins/type-ahead/pm-plugins/utils.d.ts

@@ -0,0 +1,4 @@
+import { Transaction } from 'prosemirror-state';
+import type { InsertionTransactionMeta } from '../types';
+import { ACTIONS } from './actions';
+export declare const isInsertionTransaction: (transactions: Transaction[], action: ACTIONS) => InsertionTransactionMeta | null;

package/dist/types-ts4.0/plugins/type-ahead/stats-modifier.d.ts

@@ -0,0 +1,20 @@
+import type { TypeAheadStatsModifier } from './types';
+export declare class StatsModifier implements TypeAheadStatsModifier {
+    startedAt: number;
+    endedAt: number;
+    keyCount: {
+        arrowUp: number;
+        arrowDown: number;
+    };
+    constructor();
+    increaseArrowUp: () => void;
+    increaseArrowDown: () => void;
+    serialize: () => {
+        startedAt: number;
+        endedAt: number;
+        keyCount: {
+            arrowUp: number;
+            arrowDown: number;
+        };
+    };
+}

package/dist/types-ts4.0/plugins/type-ahead/transforms/close-type-ahead.d.ts

@@ -0,0 +1,2 @@
+import { Transaction } from 'prosemirror-state';
+export declare const closeTypeAhead: (tr: Transaction) => Transaction;

package/dist/types-ts4.0/plugins/type-ahead/transforms/open-typeahead-at-cursor.d.ts

@@ -0,0 +1,10 @@
+import { Transaction } from 'prosemirror-state';
+import type { TypeAheadHandler, TypeAheadInputMethod } from '../types';
+declare type Props = {
+    triggerHandler: TypeAheadHandler;
+    inputMethod: TypeAheadInputMethod;
+    query?: string;
+};
+export declare const openTypeAhead: (props: Props) => (tr: Transaction) => void;
+export declare const openTypeAheadAtCursor: ({ triggerHandler, inputMethod, query }: Props) => (tr: Transaction) => Transaction | null;
+export {};

package/dist/types-ts4.0/plugins/type-ahead/transforms/set-selection-before-query.d.ts

@@ -0,0 +1,2 @@
+import { Transaction } from 'prosemirror-state';
+export declare const setSelectionBeforeQuery: (rawText: string) => (tr: Transaction) => void;

package/dist/types-ts4.0/plugins/type-ahead/types.d.ts

@@ -0,0 +1,65 @@
+import type { DecorationSet } from 'prosemirror-view';
+import { EditorState, Transaction, ReadonlyTransaction } from 'prosemirror-state';
+import type { INPUT_METHOD } from '../analytics/types/enums';
+import type { CloseSelectionOptions } from './constants';
+import type { UiComponentFactoryParams } from '../../types/ui-components';
+import type { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import type { TypeAheadStats, TypeAheadItemRenderProps, TypeAheadInsert, TypeAheadSelectItem, TypeAheadItem, TypeAheadForceSelect, TypeAheadHandler } from '@atlaskit/editor-common/types';
+export type { TypeAheadStats, TypeAheadItemRenderProps, TypeAheadInsert, TypeAheadSelectItem, TypeAheadItem, TypeAheadForceSelect, TypeAheadHandler, };
+export declare type OnSelectItem = (props: {
+    index: number;
+    item: TypeAheadItem;
+}) => void;
+export interface TypeAheadStatsSerializable extends TypeAheadStats {
+    serialize: () => TypeAheadStats;
+}
+export interface TypeAheadStatsModifier extends TypeAheadStatsSerializable {
+    increaseArrowUp: () => void;
+    increaseArrowDown: () => void;
+}
+export interface TypeAheadStatsMobileModifier extends TypeAheadStatsSerializable {
+    resetTime: () => void;
+    closeTime: () => void;
+}
+export declare type TypeAheadPluginState = {
+    decorationSet: DecorationSet;
+    decorationElement: HTMLElement | null;
+    typeAheadHandlers: Array<TypeAheadHandler>;
+    query: string;
+    items: Array<TypeAheadItem>;
+    triggerHandler?: TypeAheadHandler;
+    selectedIndex: number;
+    stats: TypeAheadStatsSerializable | null;
+    inputMethod: TypeAheadInputMethod | null;
+};
+export declare type OnInsertSelectedItemProps = {
+    mode: SelectItemMode;
+    index: number;
+    query: string;
+};
+export declare type OnItemMatchProps = {
+    mode: SelectItemMode;
+    query: string;
+};
+export declare type OnInsertSelectedItem = (props: OnInsertSelectedItemProps) => void;
+export declare type OnItemMatch = (props: OnItemMatchProps) => boolean;
+export declare type OnTextInsertProps = {
+    forceFocusOnEditor: boolean;
+    setSelectionAt: CloseSelectionOptions;
+    text: string;
+};
+export declare type OnTextInsert = (props: OnTextInsertProps) => void;
+export declare type TypeAheadInputMethod = INPUT_METHOD.INSERT_MENU | INPUT_METHOD.KEYBOARD | INPUT_METHOD.QUICK_INSERT | INPUT_METHOD.TOOLBAR;
+export declare type InsertionTransactionMeta = (editorState: EditorState) => Transaction | false;
+declare type PopupMountPoints = Pick<UiComponentFactoryParams, 'popupsMountPoint' | 'popupsBoundariesElement' | 'popupsScrollableElement'>;
+export declare type PopupMountPointReference = Record<'current', PopupMountPoints | null>;
+export declare type CreateTypeAheadDecorations = (tr: ReadonlyTransaction, options: {
+    triggerHandler: TypeAheadHandler;
+    inputMethod: TypeAheadInputMethod;
+    reopenQuery?: string;
+}) => {
+    decorationSet: DecorationSet;
+    decorationElement: HTMLElement | null;
+    stats: TypeAheadStatsSerializable | null;
+};
+export declare type RemoveTypeAheadDecorations = (decorationSet?: DecorationSet) => boolean;

package/dist/types-ts4.0/plugins/type-ahead/ui/AssistiveText.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="lodash" />
+/** @jsx jsx */
+import debounce from 'lodash/debounce';
+import React from 'react';
+import { jsx } from '@emotion/react';
+declare type Cancelable = ReturnType<typeof debounce>;
+declare type AssistiveTextProps = {
+    assistiveText: string;
+    isInFocus: boolean;
+    id: string;
+    statusDebounceMillis?: number;
+    debounce?: boolean;
+};
+declare type AssistiveTextState = {
+    bump: boolean;
+    debounced: boolean;
+    silenced: boolean;
+};
+declare class AssistveTextComponent extends React.Component<AssistiveTextProps, AssistiveTextState> {
+    static defaultProps: AssistiveTextProps;
+    debounceStatusUpdate: (() => void) & Cancelable;
+    state: {
+        bump: boolean;
+        debounced: boolean;
+        silenced: boolean;
+    };
+    componentWillMount(): void;
+    componentWillUnmount(): void;
+    componentWillReceiveProps(): void;
+    render(): jsx.JSX.Element;
+}
+export declare const AssistiveText: typeof AssistveTextComponent;
+export {};

package/dist/types-ts4.0/plugins/type-ahead/ui/InputQuery.d.ts

@@ -0,0 +1,27 @@
+/** @jsx jsx */
+import React from 'react';
+import type { EditorView } from 'prosemirror-view';
+import { CloseSelectionOptions } from '../constants';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+declare type InputQueryProps = {
+    triggerQueryPrefix: string;
+    onQueryChange: (query: string) => void;
+    onItemSelect: (mode: SelectItemMode) => void;
+    selectNextItem: () => void;
+    selectPreviousItem: () => void;
+    cancel: (props: {
+        forceFocusOnEditor: boolean;
+        setSelectionAt: CloseSelectionOptions;
+        addPrefixTrigger: boolean;
+        text: string;
+    }) => void;
+    onQueryFocus: () => void;
+    forceFocus: boolean;
+    onUndoRedo?: (inputType: 'historyUndo' | 'historyRedo') => boolean;
+    reopenQuery?: string;
+    editorView: EditorView;
+    items: any[];
+    useBetterTypeaheadNavigation: boolean;
+};
+export declare const InputQuery: React.FC<InputQueryProps>;
+export {};

package/dist/types-ts4.0/plugins/type-ahead/ui/TypeAheadList.d.ts

@@ -0,0 +1,25 @@
+/** @jsx jsx */
+import React from 'react';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import { WrappedComponentProps } from 'react-intl-next';
+import type { TypeAheadHandler, TypeAheadItem } from '../types';
+import { EditorView } from 'prosemirror-view';
+export declare const TypeAheadList: React.FC<import("react-intl-next").WithIntlProps<{
+    items: Array<TypeAheadItem>;
+    selectedIndex: number;
+    editorView: EditorView;
+    onItemClick: (mode: SelectItemMode, index: number) => void;
+    fitHeight: number;
+    decorationElement: HTMLElement;
+    triggerHandler?: TypeAheadHandler | undefined;
+} & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<{
+        items: Array<TypeAheadItem>;
+        selectedIndex: number;
+        editorView: EditorView;
+        onItemClick: (mode: SelectItemMode, index: number) => void;
+        fitHeight: number;
+        decorationElement: HTMLElement;
+        triggerHandler?: TypeAheadHandler | undefined;
+    } & WrappedComponentProps<"intl">>;
+};

package/dist/types-ts4.0/plugins/type-ahead/ui/TypeAheadListItem.d.ts

@@ -0,0 +1,18 @@
+/** @jsx jsx */
+import React from 'react';
+import type { TypeAheadItem } from '../types';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+export declare const ICON_HEIGHT = 40;
+export declare const ICON_WIDTH = 40;
+export declare const ITEM_PADDING = 12;
+export declare const itemIcon: import("@emotion/react").SerializedStyles;
+declare type TypeAheadListItemProps = {
+    item: TypeAheadItem;
+    itemsLength: number;
+    itemIndex: number;
+    selectedIndex: number;
+    ariaLabel?: string;
+    onItemClick: (mode: SelectItemMode, index: number) => void;
+};
+export declare const TypeAheadListItem: React.FC<TypeAheadListItemProps>;
+export {};

package/dist/types-ts4.0/plugins/type-ahead/ui/TypeAheadPopup.d.ts

@@ -0,0 +1,29 @@
+/** @jsx jsx */
+import React from 'react';
+import { EditorView, DecorationSet } from 'prosemirror-view';
+import type { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import { FireAnalyticsCallback } from '@atlaskit/editor-common/analytics';
+import { CloseSelectionOptions } from '../constants';
+import type { TypeAheadHandler, TypeAheadItem, OnSelectItem } from '../types';
+declare type TypeAheadPopupProps = {
+    triggerHandler: TypeAheadHandler;
+    editorView: EditorView;
+    anchorElement: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    fireAnalyticsCallback: FireAnalyticsCallback;
+    items: Array<TypeAheadItem>;
+    selectedIndex: number;
+    setSelectedItem: OnSelectItem;
+    decorationSet: DecorationSet;
+    isEmptyQuery: boolean;
+    onItemInsert: (mode: SelectItemMode, index: number) => void;
+    cancel: (params: {
+        setSelectionAt: CloseSelectionOptions;
+        addPrefixTrigger: boolean;
+        forceFocusOnEditor: boolean;
+    }) => void;
+};
+export declare const TypeAheadPopup: React.FC<TypeAheadPopupProps>;
+export {};

package/dist/types-ts4.0/plugins/type-ahead/ui/WrapperTypeAhead.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { EditorView } from 'prosemirror-view';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { TypeAheadHandler, TypeAheadInputMethod } from '../types';
+declare type WrapperProps = {
+    triggerHandler: TypeAheadHandler;
+    editorView: EditorView;
+    anchorElement: HTMLElement;
+    getDecorationPosition: () => number;
+    shouldFocusCursorInsideQuery: boolean;
+    onUndoRedo?: (inputType: 'historyUndo' | 'historyRedo') => boolean;
+    reopenQuery?: string;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    inputMethod?: TypeAheadInputMethod;
+    useBetterTypeaheadNavigation: boolean;
+};
+export declare const WrapperTypeAhead: React.FC<WrapperProps>;
+export {};

package/dist/types-ts4.0/plugins/type-ahead/ui/hooks/use-item-insert.d.ts

@@ -0,0 +1,7 @@
+import type { EditorView } from 'prosemirror-view';
+import type { TypeAheadHandler, TypeAheadItem, OnItemMatch, OnTextInsert, OnInsertSelectedItem } from '../../types';
+export declare const useItemInsert: (triggerHandler: TypeAheadHandler, editorView: EditorView, items: Array<TypeAheadItem>) => [
+    OnInsertSelectedItem,
+    OnTextInsert,
+    OnItemMatch
+];

package/dist/types-ts4.0/plugins/type-ahead/ui/hooks/use-load-items.d.ts

@@ -0,0 +1,3 @@
+import type { EditorView } from 'prosemirror-view';
+import type { TypeAheadItem, TypeAheadHandler } from '../../types';
+export declare const useLoadItems: (triggerHandler: TypeAheadHandler, editorView: EditorView, query: string) => Array<TypeAheadItem>;

package/dist/types-ts4.0/plugins/type-ahead/ui/hooks/use-on-force-select.d.ts

@@ -0,0 +1,11 @@
+import type { EditorView } from 'prosemirror-view';
+import { TypeAheadHandler, TypeAheadItem } from '../../types';
+declare type Props = {
+    triggerHandler: TypeAheadHandler;
+    items: Array<TypeAheadItem>;
+    query: string;
+    editorView: EditorView;
+    closePopup: () => void;
+};
+export declare const useOnForceSelect: ({ triggerHandler, items, query, editorView, closePopup, }: Props) => void;
+export {};

package/dist/types-ts4.0/plugins/type-ahead/utils.d.ts

@@ -0,0 +1,29 @@
+import { EditorState } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { TypeAheadAvailableNodes } from '@atlaskit/editor-common/type-ahead';
+import type { TypeAheadHandler, TypeAheadItem, TypeAheadPluginState } from './types';
+import { IntlShape } from 'react-intl-next';
+export declare const isTypeAheadHandler: (handler: any) => handler is TypeAheadHandler;
+/** Is a typeahead plugin open? */
+export declare const isTypeAheadOpen: (editorState: EditorState) => boolean;
+export declare const getPluginState: (editorState: EditorState) => TypeAheadPluginState;
+export declare const getTypeAheadHandler: (editorState: EditorState) => any;
+export declare const getTypeAheadQuery: (editorState: EditorState) => any;
+export declare const isTypeAheadAllowed: (state: EditorState) => boolean;
+export declare const findHandler: (id: TypeAheadAvailableNodes, state: EditorState) => TypeAheadHandler | null;
+export declare const findHandlerByTrigger: ({ trigger, editorState, }: {
+    trigger: string;
+    editorState: EditorState;
+}) => TypeAheadHandler | null;
+declare type MoveSelectedIndexProps = {
+    editorView: EditorView;
+    direction: 'next' | 'previous';
+    useBetterTypeaheadNavigation?: boolean;
+};
+export declare const moveSelectedIndex: ({ editorView, direction, useBetterTypeaheadNavigation, }: MoveSelectedIndexProps) => () => void;
+declare type TypeAheadAssistiveLabels = {
+    popupAriaLabel: string;
+    listItemAriaLabel?: string;
+};
+export declare const getTypeAheadListAriaLabels: (trigger: string | undefined, intl: IntlShape, item?: TypeAheadItem | undefined) => TypeAheadAssistiveLabels;
+export {};

package/dist/types-ts4.0/plugins/undo-redo/attach-input-meta.d.ts

@@ -0,0 +1,5 @@
+import { HigherOrderCommand } from '../../types/command';
+import { InputSource } from './enums';
+declare type AttachInputMeta = (inputSource: InputSource) => HigherOrderCommand;
+export declare const attachInputMeta: AttachInputMeta;
+export {};

package/dist/types-ts4.0/plugins/undo-redo/commands.d.ts

@@ -0,0 +1,4 @@
+export declare const undoFromKeyboard: import("../..").Command;
+export declare const redoFromKeyboard: import("../..").Command;
+export declare const undoFromToolbar: import("../..").Command;
+export declare const redoFromToolbar: import("../..").Command;

package/dist/types-ts4.0/plugins/undo-redo/enums.d.ts

@@ -0,0 +1,4 @@
+export declare enum InputSource {
+    TOOLBAR = "toolbar",
+    KEYBOARD = "keyboard"
+}

package/dist/types-ts4.0/plugins/undo-redo/index.d.ts

@@ -0,0 +1,3 @@
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+declare const undoRedoPlugin: NextEditorPlugin<'undoRedoPlugin'>;
+export default undoRedoPlugin;

package/dist/types-ts4.0/plugins/undo-redo/messages.d.ts

@@ -0,0 +1,12 @@
+export declare const messages: {
+    undo: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    redo: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types-ts4.0/plugins/undo-redo/pm-plugins/keymaps.d.ts

@@ -0,0 +1,2 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+export declare function keymapPlugin(): SafePlugin;

package/dist/types-ts4.0/plugins/undo-redo/pm-plugins/main.d.ts

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

package/dist/types-ts4.0/plugins/undo-redo/pm-plugins/plugin-key.d.ts

@@ -0,0 +1,2 @@
+import { PluginKey } from 'prosemirror-state';
+export declare const pluginKey: PluginKey<any, any>;

package/dist/types-ts4.0/plugins/undo-redo/ui/ToolbarUndoRedo/index.d.ts

@@ -0,0 +1,21 @@
+/** @jsx jsx */
+import { PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { EditorView } from 'prosemirror-view';
+import { HistoryPluginState } from '../../../history/types';
+export interface Props {
+    undoDisabled?: boolean;
+    redoDisabled?: boolean;
+    disabled?: boolean;
+    isReducedSpacing?: boolean;
+    historyState: HistoryPluginState;
+    editorView: EditorView;
+}
+export declare class ToolbarUndoRedo extends PureComponent<Props & WrappedComponentProps> {
+    render(): jsx.JSX.Element;
+}
+declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: import("react").ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.0/plugins/undo-redo/undo-redo-input-source.d.ts

@@ -0,0 +1,3 @@
+import { Transaction } from 'prosemirror-state';
+import { AnalyticsPayload } from '@atlaskit/adf-schema/steps';
+export declare const generateUndoRedoInputSoucePayload: (tr: Transaction) => <T extends AnalyticsPayload>(payload: T) => T;

package/dist/types-ts4.0/plugins/unsupported-content/index.d.ts

@@ -0,0 +1,5 @@
+import { PluginKey } from 'prosemirror-state';
+import { NextEditorPlugin } from '@atlaskit/editor-common/types';
+export declare const pluginKey: PluginKey<any, any>;
+declare const unsupportedContentPlugin: NextEditorPlugin<'unsupportedContent'>;
+export default unsupportedContentPlugin;

package/dist/types-ts4.0/plugins/unsupported-content/styles.d.ts

@@ -0,0 +1,5 @@
+export declare const UnsupportedSharedCssClassName: {
+    BLOCK_CONTAINER: string;
+    INLINE_CONTAINER: string;
+};
+export declare const unsupportedStyles: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.0/plugins/unsupported-content/unsupported-inline-node-view.d.ts

@@ -0,0 +1,11 @@
+/** @jsx jsx */
+import React from 'react';
+import { Node as PMNode } from 'prosemirror-model';
+import { UnsupportedContentTooltipPayload } from '@atlaskit/editor-common/utils';
+import { InlineNodeViewComponentProps } from '../../nodeviews/getInlineNodeViewProducer';
+export declare type Props = InlineNodeViewComponentProps & {
+    node?: PMNode;
+    children?: React.ReactNode;
+    dispatchAnalyticsEvent?: (payload: UnsupportedContentTooltipPayload) => void;
+};
+export declare const UnsupportedInlineNodeView: React.FC<Props>;

package/dist/types-ts4.0/plugins/view-update-subscription/index.d.ts

@@ -0,0 +1,19 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+declare type UpdateArgs = {
+    newEditorState: EditorState;
+    oldEditorState: EditorState;
+    transactions: Transaction[];
+};
+export declare type ViewUpdateSubscription = (args: UpdateArgs) => void;
+export declare const trackerStore: WeakMap<EditorView<any>, Tracker>;
+declare class Tracker {
+    private subscriptions;
+    constructor();
+    update: (props: UpdateArgs) => void;
+    add: (subscription: ViewUpdateSubscription) => void;
+    remove: (subscription: ViewUpdateSubscription) => void;
+}
+declare const createViewUpdateSubscriptionPlugin: NextEditorPlugin<'viewUpdateSubscription'>;
+export default createViewUpdateSubscriptionPlugin;

package/dist/types-ts4.0/plugins/view-update-subscription/subscribe/toolbarAndPickerUpdates.d.ts

@@ -0,0 +1,12 @@
+import { EditorView } from 'prosemirror-view';
+import { DatePluginState } from '../../date/pm-plugins/types';
+import { ConfigWithNodeInfo } from '../../floating-toolbar';
+import { StatusState } from '../../status/types';
+declare type SubscribeToToolbarAndPickerUpdatesCallbackArgs = {
+    dateState: DatePluginState;
+    statusState: StatusState;
+    toolbarConfig: ConfigWithNodeInfo | null | undefined;
+};
+declare type SubscribeToToolbarAndPickerUpdates = (editorView: EditorView, cb: (args: SubscribeToToolbarAndPickerUpdatesCallbackArgs) => void) => () => void;
+export declare const subscribeToToolbarAndPickerUpdates: SubscribeToToolbarAndPickerUpdates;
+export {};

package/dist/types-ts4.0/plugins/view-update-subscription/subscribe/type-ahead-updates.d.ts

@@ -0,0 +1,9 @@
+import { EditorView } from 'prosemirror-view';
+import type { TypeAheadPluginState } from '../../type-ahead/types';
+declare type Props = {
+    oldPluginState: TypeAheadPluginState;
+    newPluginState: TypeAheadPluginState;
+};
+declare type SubscribeTypeAheadUpdates = (editorView: EditorView, cb: (props: Props) => void) => () => void;
+export declare const subscribeTypeAheadUpdates: SubscribeTypeAheadUpdates;
+export {};

package/dist/types-ts4.0/plugins/width/index.d.ts

@@ -0,0 +1,10 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import { Dispatch } from '../../event-dispatcher';
+import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import type { EditorContainerWidth } from '@atlaskit/editor-common/types';
+export declare type WidthPluginState = EditorContainerWidth;
+export declare const pluginKey: PluginKey<EditorContainerWidth, any>;
+export declare function createPlugin(dispatch: Dispatch<WidthPluginState>): SafePlugin | undefined;
+declare const widthPlugin: NextEditorPlugin<'width'>;
+export default widthPlugin;

package/dist/types-ts4.0/selection-api/api.d.ts

@@ -0,0 +1,11 @@
+import { RelativeSelectionPos } from '@atlaskit/editor-common/selection';
+import type { Transaction, Selection, EditorState } from 'prosemirror-state';
+import type { SelectionPluginState } from '../plugins/selection/types';
+export declare type EditorSelectionAPI = {
+    setSelectionRelativeToNode: (props: {
+        selectionRelativeToNode?: RelativeSelectionPos;
+        selection?: Selection | null;
+    }) => (state: EditorState) => Transaction;
+    getSelectionPluginState: (state: EditorState) => SelectionPluginState;
+};
+export declare const createEditorSelectionAPI: () => EditorSelectionAPI;

package/dist/types-ts4.0/stories/examples.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import Editor from '../editor';
+declare const _default: {
+    title: string;
+    component: typeof Editor;
+    decorators: ((...args: any) => any)[];
+};
+export default _default;
+export declare const EditorExample: (args: any) => JSX.Element;

package/dist/types-ts4.0/test-utils.d.ts

@@ -0,0 +1,39 @@
+import { Plugin } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { LightPMPlugin, LightPMPluginFactoryParams, OnEditorViewStateUpdated } from './create-editor/get-plugins';
+import { Schema } from 'prosemirror-model';
+import { MarkConfig, NodeConfig } from './types/pm-config';
+export { createTypeAheadTools } from './plugins/type-ahead/api';
+export type { LightEditorPlugin } from './create-editor/get-plugins';
+export type { DispatchAnalyticsEvent } from './plugins/analytics/types';
+export type { FeatureFlags } from './types/feature-flags';
+import type { EditorPluginInjectionAPI } from '@atlaskit/editor-common/preset';
+import { EditorPresetBuilder } from '@atlaskit/editor-common/preset';
+import type { AllEditorPresetPluginTypes } from '@atlaskit/editor-common/types';
+export interface LightEditorConfig {
+    nodes: NodeConfig[];
+    marks: MarkConfig[];
+    plugins: Array<LightPMPlugin>;
+    onEditorViewStateUpdatedCallbacks: Array<OnEditorViewStateUpdated>;
+}
+export declare function getFireAnalytics(editorView: EditorView): any;
+declare type PluginData = {
+    plugins: Plugin[];
+    schema: Schema;
+    onEditorViewStateUpdatedCallbacks: Array<OnEditorViewStateUpdated>;
+};
+export declare const createPMSchemaAndPlugins: (inputPreset?: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>) => (pluginFactoryParams: Omit<LightPMPluginFactoryParams, 'schema'> & {
+    pluginInjectionAPI: EditorPluginInjectionAPI;
+}) => PluginData;
+export { PortalProviderAPI } from './ui/PortalProvider';
+export { EventDispatcher } from './event-dispatcher';
+export type { Dispatch } from './event-dispatcher';
+export { GapCursorSelection, Side as GapCursorSide, } from './plugins/selection/gap-cursor/selection';
+export declare function setTextSelection(view: EditorView, anchor: number, head?: number): void;
+/**
+ * Given a selector, checks if an element matching the selector exists in the
+ * document.
+ * @param selector
+ * @returns true if element matching selector exists in document, false otherwise
+ */
+export declare const isElementBySelectorInDocument: (selector: string) => boolean;

package/dist/types-ts4.0/types/allowed-block-types.d.ts

@@ -0,0 +1 @@
+export declare type AllowedBlockTypes = 'heading' | 'blockquote' | 'hardBreak' | 'codeBlock';

package/dist/types-ts4.0/types/browser.d.ts

@@ -0,0 +1 @@
+export type { Browsers, Range, DisableSpellcheckByBrowser, } from '@atlaskit/editor-common/types';

package/dist/types-ts4.0/types/command.d.ts

@@ -0,0 +1,5 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+export declare type CommandDispatch = (tr: Transaction) => void;
+export declare type Command = (state: EditorState, dispatch?: CommandDispatch, view?: EditorView) => boolean;
+export declare type HigherOrderCommand = (command: Command) => Command;

package/dist/types-ts4.0/types/dom-at-pos.d.ts

@@ -0,0 +1,4 @@
+export declare type DomAtPos = (pos: number) => {
+    node: Node;
+    offset: number;
+};