@atlaskit/editor-common 74.0.0 → 74.1.0

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

@@ -0,0 +1,84 @@
+/// <reference types="react" />
+import { Step } from 'prosemirror-transform';
+import { AnnotationId, AnnotationTypes } from '@atlaskit/adf-schema';
+import { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import { AnnotationState, AnnotationUpdateEmitter, AnnotationUpdateEvent, AnnotationUpdateEventPayloads, OnAnnotationClickPayload } from './emitter';
+export type { AnnotationState };
+export type AnnotationByMatches = {
+    originalSelection: string;
+    numMatches: number;
+    matchIndex: number;
+    isAnnotationAllowed?: boolean;
+};
+type ActionResult = {
+    step: Step;
+    doc: JSONDocNode;
+} | false;
+export type AnnotationActionResult = ({
+    step: Step;
+    doc: JSONDocNode;
+} & AnnotationByMatches) | false;
+export type InlineCommentSelectionComponentProps = {
+    /**
+     * Range selected
+     */
+    range: Range;
+    /**
+     * Renderer/Editor DOM element ancestors wrapping the selection.
+     */
+    wrapperDOM: HTMLElement;
+    /**
+     * If it is possible to add an inline comment on this range
+     */
+    isAnnotationAllowed: boolean;
+    /**
+     * Creates an annotation mark in the document with the given id.
+     */
+    onCreate: (annotationId: AnnotationId) => AnnotationActionResult;
+    /**
+     * Indicates that a draft comment was discarded/cancelled
+     */
+    onClose: () => void;
+    /**
+     * Call this function to surround the range with a HTML tag.
+     */
+    applyDraftMode: (keepNativeSelection?: boolean) => void;
+    /**
+     * Call this function to remove the draft HTML tags created by the applyDraftMode
+     */
+    removeDraftMode: () => void;
+    /**
+     * getAnnotationIndexMatch finds the { numMatch, matchIndex } tuple of the current selection
+     */
+    getAnnotationIndexMatch?: () => AnnotationByMatches | false;
+};
+type AnnotationInfo = {
+    id: AnnotationId;
+    type: AnnotationTypes.INLINE_COMMENT;
+};
+export type InlineCommentViewComponentProps = {
+    /**
+     * Existing annotations where the cursor is placed.
+     * These are provided in order, inner-most first.
+     */
+    annotations: Array<AnnotationInfo>;
+    /**
+     * eventTarget of the tapped annotation. Useful for UI positioning.
+     */
+    clickElementTarget?: HTMLElement;
+    deleteAnnotation: (annotationInfo: AnnotationInfo) => ActionResult;
+};
+interface AnnotationTypeProvider<Type> {
+    getState: (annotationIds: string[]) => Promise<AnnotationState<Type>[]>;
+    updateSubscriber?: AnnotationUpdateEmitter;
+    allowDraftMode?: boolean;
+}
+export type InlineCommentAnnotationProvider = AnnotationTypeProvider<AnnotationTypes.INLINE_COMMENT> & {
+    selectionComponent?: React.ComponentType<InlineCommentSelectionComponentProps>;
+    viewComponent?: React.ComponentType<InlineCommentViewComponentProps>;
+};
+export type AnnotationProviders = {
+    inlineComment: InlineCommentAnnotationProvider;
+};
+export { AnnotationUpdateEmitter, AnnotationUpdateEvent };
+export type { AnnotationUpdateEventPayloads, OnAnnotationClickPayload };

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

@@ -0,0 +1,8 @@
+export type NewCollabSyncUpErrorAttributes = {
+    lengthOfUnconfirmedSteps?: number;
+    tries: number;
+    maxRetries: number;
+    clientId?: number | string;
+    version: number;
+};
+export type SyncUpErrorFunction = (attributes: NewCollabSyncUpErrorAttributes) => void;

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

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

package/dist/types-ts4.5/types/context-panel.d.ts

@@ -0,0 +1,3 @@
+import type React from 'react';
+import type { EditorState } from 'prosemirror-state';
+export type ContextPanelHandler = (state: EditorState) => React.ReactNode;

package/dist/types-ts4.5/types/copy-button.d.ts

@@ -0,0 +1,24 @@
+import { MarkType, NodeType } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { IntlShape } from 'react-intl-next';
+import { Command } from './command';
+export type MarkOptions = {
+    state: EditorState;
+    formatMessage: IntlShape['formatMessage'];
+    nodeType?: undefined;
+    markType: MarkType;
+    onMouseEnter?: undefined;
+    onMouseLeave?: undefined;
+    onFocus?: Command;
+    onBlur?: Command;
+};
+export type NodeOptions = {
+    state: EditorState;
+    formatMessage: IntlShape['formatMessage'];
+    nodeType: NodeType | Array<NodeType>;
+    markType?: undefined;
+    onMouseEnter?: Command;
+    onMouseLeave?: Command;
+    onFocus?: Command;
+    onBlur?: Command;
+};

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

@@ -0,0 +1,21 @@
+import { Node } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import { ResolvedEditorState } from '../collab';
+import { EventDispatcher } from '../event-dispatcher';
+export type ContextUpdateHandler = (editorView: EditorView, eventDispatcher: EventDispatcher) => void;
+export type ReplaceRawValue = Node | object | string;
+export interface EditorActionsOptions<T = any> {
+    focus(): boolean;
+    blur(): boolean;
+    clear(): boolean;
+    getValue(): Promise<T | JSONDocNode | undefined>;
+    getNodeByLocalId(id: string): Node | undefined;
+    getNodeByFragmentLocalId(id: string): Node | undefined;
+    getSelectedNode(): Node | undefined;
+    replaceDocument(rawValue: any): boolean;
+    replaceSelection(rawValue: ReplaceRawValue | Array<ReplaceRawValue>): boolean;
+    appendText(text: string): boolean;
+    isDocumentEmpty(): boolean;
+    getResolvedEditorState(): Promise<ResolvedEditorState | undefined>;
+}

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

@@ -0,0 +1 @@
+export type EditorAppearance = 'comment' | 'full-page' | 'full-width' | 'chromeless' | 'mobile';

package/dist/types-ts4.5/types/editor-container-width.d.ts

@@ -0,0 +1,20 @@
+export type EditorContainerWidth = {
+    /**
+     * Starts as offsetWidth of document body, and then
+     * updates to the editors content areas offsetWidth
+     * via the use of a contentComponent (via the
+     * container element prop).
+     */
+    width: number;
+    containerWidth?: number;
+    /**
+     * Starts as undefined, and then updates to the
+     * clientWidth of the dom element the EditorView
+     * is attached to.
+     *
+     * Then the WidthEmitter updates this whenever the
+     * context panel or editor widths change.
+     */
+    lineLength?: number;
+};
+export type GetEditorContainerWidth = () => EditorContainerWidth;

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

@@ -0,0 +1,83 @@
+import type { EditorState, Transaction } from 'prosemirror-state';
+import type { ContextPanelHandler } from './context-panel';
+import type { FloatingToolbarHandler } from './floating-toolbar';
+import type { PMPlugin } from './plugin-factory';
+import type { MarkConfig, NodeConfig } from './prosemirror-config';
+import type { QuickInsertHandler } from './quick-insert';
+import type { ToolbarUIComponentFactory } from './toolbar';
+import type { TypeAheadHandler } from './type-ahead';
+import type { UIComponentFactory } from './ui-components';
+export type PluginsOptions = {
+    [pluginName: string]: any;
+    /**
+     * Handler returns an array of QuickInsertItem that are added to the Element Browser, Insert Menu and Quick Insert
+     */
+    quickInsert?: QuickInsertHandler;
+    typeAhead?: TypeAheadHandler;
+    /**
+     * See: `FloatingToolbarConfig`
+     */
+    floatingToolbar?: FloatingToolbarHandler;
+    /**
+     * Handler returning a React component that is added to the context panel.
+     *
+     * See https://product-fabric.atlassian.net/wiki/spaces/E/pages/1406016239/Context+Panel
+     */
+    contextPanel?: ContextPanelHandler;
+};
+type EditorViewStateUpdatedCallbackProps = {
+    readonly originalTransaction: Readonly<Transaction>;
+    readonly transactions: Transaction[];
+    readonly oldEditorState: Readonly<EditorState>;
+    readonly newEditorState: Readonly<EditorState>;
+};
+export interface EditorPlugin {
+    /**
+     * Name of a plugin, that other plugins can use to provide options to it or exclude via a preset.
+     */
+    name: string;
+    /**
+     * Options that will be passed to a plugin with a corresponding name if it exists and enabled.
+     */
+    pluginsOptions?: PluginsOptions;
+    /**
+     * List of ProseMirror-plugins. This is where we define which plugins will be added to EditorView (main-plugin, keybindings, input-rules, etc.).
+     */
+    pmPlugins?: (pluginOptions?: any) => Array<PMPlugin>;
+    /**
+     * A list of `NodeConfig`s with a name and a `NodeSpec`. (`NodeSpec` is imported from @atlaskit/adf-schema)
+     *
+     */
+    nodes?: () => NodeConfig[];
+    /**
+     * A list of `MarkConfig`s with a name and a `MarkSpec` (`MarkSpec` is imported from @atlaskit/adf-schema)
+     */
+    marks?: () => MarkConfig[];
+    /**
+     * Optional UI-component that lives inside the actual content-area (like mention-picker, floating toolbar for links, etc.)
+     *
+     * Handler returns a React component that is added to the top of the editor content area (PluginSlot).
+     * Although it’s common to specify a custom mount point (eg. date picker)
+     */
+    contentComponent?: UIComponentFactory;
+    /**
+     * Optional UI-component that will be added to the toolbar at the top of the editor (doesn't exist in the compact-editor).
+     *
+     * Handler returns a React component that is added to the toolbar at the top of the editor
+     *
+     * Plugins use <ToolbarButton> component to maintain design consistency.
+     */
+    primaryToolbarComponent?: ToolbarUIComponentFactory;
+    /**
+     * Optional UI-component that will be added to the toolbar at the bottom right of the editor. (doesn't exist in the full-page editor)
+     * In compact mode this toolbar lives on the right-hand side of the editor.
+     */
+    secondaryToolbarComponent?: UIComponentFactory;
+    /**
+     * Called after EditorView state is updated.
+     */
+    onEditorViewStateUpdated?: (props: EditorViewStateUpdatedCallbackProps) => void;
+}
+export type getPosHandler = getPosHandlerNode | boolean;
+export type getPosHandlerNode = () => number;
+export {};

package/dist/types-ts4.5/types/editor-react-context.d.ts

@@ -0,0 +1,6 @@
+import type { IntlShape } from 'react-intl-next';
+import type { UIAnalyticsEventHandler } from '@atlaskit/analytics-next';
+export type EditorReactContext = {
+    getAtlaskitAnalyticsEventHandlers: () => UIAnalyticsEventHandler[];
+    intl: IntlShape;
+};

package/dist/types-ts4.5/types/empty-state-handler.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export type EmptyStateHandler = (params: EmptyStateHandlerParams) => React.ReactElement<any> | null;
+export type EmptyStateHandlerParams = {
+    mode: string;
+    selectedCategory?: string;
+    searchTerm?: string;
+};