@atlaskit/editor-core 182.2.0 → 183.0.6

package/dist/types-ts4.0/types/editor-appearance-component.d.ts

@@ -0,0 +1,48 @@
+import { EditorView } from 'prosemirror-view';
+import { RefObject } from 'react';
+import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { EventDispatcher } from '../event-dispatcher';
+import EditorActions from '../actions';
+import { UIComponentFactory } from '../types/ui-components';
+import { ReactComponents, PrimaryToolbarComponents, UseStickyToolbarType } from '../types/editor-props';
+import { ToolbarUIComponentFactory } from '../ui/Toolbar/types';
+import { CollabEditOptions } from '../plugins/collab-edit/types';
+import { DispatchAnalyticsEvent } from '../plugins/analytics';
+import { EditorAppearance } from './editor-appearance';
+import { MenuItem } from '../ui/DropdownMenu/types';
+import { ReactElement } from 'react';
+import { FeatureFlags } from './feature-flags';
+export interface EditorAppearanceComponentProps {
+    appearance?: EditorAppearance;
+    onSave?: (editorView: EditorView) => void;
+    onCancel?: (editorView: EditorView) => void;
+    providerFactory: ProviderFactory;
+    editorActions?: EditorActions;
+    editorDOMElement: JSX.Element;
+    editorView?: EditorView;
+    eventDispatcher?: EventDispatcher;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    maxHeight?: number;
+    minHeight?: number;
+    contentComponents?: UIComponentFactory[];
+    primaryToolbarComponents?: ToolbarUIComponentFactory[];
+    primaryToolbarIconBefore?: ReactElement;
+    secondaryToolbarComponents?: UIComponentFactory[];
+    customContentComponents?: ReactComponents;
+    customPrimaryToolbarComponents?: PrimaryToolbarComponents;
+    customSecondaryToolbarComponents?: ReactComponents;
+    insertMenuItems?: MenuItem[];
+    contextPanel?: ReactComponents;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    extensionHandlers?: ExtensionHandlers;
+    disabled?: boolean;
+    collabEdit?: CollabEditOptions;
+    persistScrollGutter?: boolean;
+    enableToolbarMinWidth?: boolean;
+    featureFlags: FeatureFlags;
+    useStickyToolbar?: UseStickyToolbarType;
+    innerRef?: RefObject<HTMLDivElement>;
+}

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

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

package/dist/types-ts4.0/types/editor-config.d.ts

@@ -0,0 +1,24 @@
+import { ToolbarUIComponentFactory } from '../ui/Toolbar/types';
+import { Transaction, EditorState } from 'prosemirror-state';
+import { PMPlugin } from './pm-plugin';
+import { MarkConfig, NodeConfig } from './pm-config';
+import { UIComponentFactory } from './ui-components';
+declare type EditorViewStateUpdatedCallbackProps = {
+    readonly originalTransaction: Readonly<Transaction>;
+    readonly transactions: Transaction[];
+    readonly oldEditorState: Readonly<EditorState>;
+    readonly newEditorState: Readonly<EditorState>;
+};
+export interface EditorConfig {
+    nodes: NodeConfig[];
+    marks: MarkConfig[];
+    pmPlugins: Array<PMPlugin>;
+    contentComponents: UIComponentFactory[];
+    primaryToolbarComponents: ToolbarUIComponentFactory[];
+    secondaryToolbarComponents: UIComponentFactory[];
+    onEditorViewStateUpdatedCallbacks: Array<{
+        pluginName: string;
+        callback: (props: EditorViewStateUpdatedCallbackProps) => void;
+    }>;
+}
+export {};

package/dist/types-ts4.0/types/editor-instance.d.ts

@@ -0,0 +1,19 @@
+import { EditorView } from 'prosemirror-view';
+import { OnEditorViewStateUpdated } from '../create-editor/get-plugins';
+import { EventDispatcher } from '../event-dispatcher';
+import { MenuItem } from '../ui/DropdownMenu/types';
+import { ToolbarUIComponentFactory } from '../ui/Toolbar/types';
+import { UIComponentFactory } from './ui-components';
+export interface EditorInstance {
+    editorView: EditorView;
+    eventDispatcher: EventDispatcher;
+    contentComponents: UIComponentFactory[];
+    primaryToolbarComponents: ToolbarUIComponentFactory[];
+    secondaryToolbarComponents: UIComponentFactory[];
+    onEditorViewStateUpdatedCallbacks: {
+        pluginName: string;
+        callback: OnEditorViewStateUpdated;
+    }[];
+    contentTransformer?: Transformer<string>;
+    insertMenuItems?: MenuItem[];
+}

package/dist/types-ts4.0/types/editor-onchange.d.ts

@@ -0,0 +1,4 @@
+import { EditorView } from 'prosemirror-view';
+export declare type EditorOnChangeHandler = (editorView: EditorView, meta: {
+    source: 'local' | 'remote';
+}) => void;

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

@@ -0,0 +1 @@
+export type { NextEditorPlugin, PluginsOptions, EditorPlugin, } from '@atlaskit/editor-common/types';

package/dist/types-ts4.0/types/editor-props.d.ts

@@ -0,0 +1,259 @@
+import { Node, Schema } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import { ReactElement, RefObject } from 'react';
+import EditorActions from '../actions';
+import type { ExtensionHandlers, ExtensionProvider } from '@atlaskit/editor-common/extensions';
+import type { ContextIdentifierProvider, Providers, SearchProvider } from '@atlaskit/editor-common/provider-factory';
+import type { Transformer, AllEditorPresetPluginTypes } from '@atlaskit/editor-common/types';
+import type { ErrorReportingHandler } from '@atlaskit/editor-common/utils';
+import { ActivityProvider } from '@atlaskit/activity-provider';
+import { MentionProvider } from '@atlaskit/mention/resource';
+import { TaskDecisionProvider } from '@atlaskit/task-decision';
+import { CardOptions } from '@atlaskit/editor-common/card';
+import { PluginConfig as TablesPluginConfig } from '@atlaskit/editor-plugin-table/types';
+import { AnnotationProviders } from '../plugins/annotation/types';
+import { BlockTypePluginOptions } from '../plugins/block-type/types';
+import { CodeBlockOptions } from '../plugins/code-block/types';
+import { CollabEditOptions } from '../plugins/collab-edit/types';
+import { FindReplaceOptions } from '../plugins/find-replace/types';
+import { LinkingOptions } from '../plugins/hyperlink/types';
+import { LayoutPluginOptions } from '../plugins/layout/types';
+import { MediaOptions, MediaState } from '../plugins/media/types';
+import { PlaceholderTextOptions } from '../plugins/placeholder-text/types';
+import { QuickInsertOptions } from '../plugins/quick-insert/types';
+import { TextColorPluginConfig } from '../plugins/text-color/pm-plugins/main';
+import { TextFormattingOptions } from '../plugins/text-formatting/types';
+import { MenuItem } from '../ui/DropdownMenu/types';
+import { MentionPluginConfig } from './../plugins/mentions/types';
+import { PanelPluginConfig } from './../plugins/panel/types';
+import { EditorAppearance } from './editor-appearance';
+import { EditorOnChangeHandler } from './editor-onchange';
+import { EditorPlugin } from './editor-plugin';
+import { EmptyStateHandler } from './empty-state-handler';
+import { ExtensionConfig } from './extension-config';
+import { PerformanceTracking } from './performance-tracking';
+import { EditorPresetBuilder } from '@atlaskit/editor-common/preset';
+export declare type ReactComponents = ReactElement<any> | ReactElement<any>[];
+declare type ExtensionProviders = (ExtensionProvider | Promise<ExtensionProvider>)[];
+declare type ExtensionProvidersWithEditorAction = (editorActions?: EditorActions) => ExtensionProviders;
+export declare type ExtensionProvidersProp = ExtensionProviders | ExtensionProvidersWithEditorAction;
+export declare type FeedbackInfo = {
+    product?: string;
+    packageVersion?: string;
+    packageName?: string;
+    labels?: Array<string>;
+    sessionId?: string;
+    contentId?: string;
+    tabId?: string;
+};
+export declare type BeforeAndAfterToolbarComponents = {
+    before: ReactComponents;
+    after: ReactComponents;
+};
+export declare type PrimaryToolbarComponents = BeforeAndAfterToolbarComponents | ReactComponents;
+export declare type UseStickyToolbarType = boolean | RefObject<HTMLElement> | {
+    offsetTop: number;
+};
+export interface EditorBaseProps extends EditorPluginFeatureProps, EditorProviderProps {
+    appearance?: EditorAppearance;
+    contentComponents?: ReactComponents;
+    primaryToolbarIconBefore?: ReactElement;
+    secondaryToolbarComponents?: ReactComponents;
+    persistScrollGutter?: boolean;
+    quickInsert?: QuickInsertOptions;
+    shouldFocus?: boolean;
+    disabled?: boolean;
+    contextPanel?: ReactComponents;
+    errorReporterHandler?: ErrorReportingHandler;
+    contentTransformerProvider?: (schema: Schema) => Transformer<string>;
+    textFormatting?: TextFormattingOptions;
+    maxHeight?: number;
+    minHeight?: number;
+    placeholder?: string;
+    placeholderBracketHint?: string;
+    defaultValue?: Node | string | Object;
+    assistiveLabel?: string;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    editorActions?: EditorActions;
+    onEditorReady?: (editorActions: EditorActions) => void;
+    onDestroy?: () => void;
+    onChange?: EditorOnChangeHandler;
+    onCancel?: (editorView: EditorView) => void;
+    /**
+     * @description The nth keystroke after which an input time taken event is sent, 0 to disable it
+     * @default 100
+     * @deprecated Use performanceTracking.inputSampling instead https://product-fabric.atlassian.net/browse/ED-10260
+     */
+    inputSamplingLimit?: number;
+    extensionProviders?: ExtensionProvidersProp;
+    UNSAFE_useAnalyticsContext?: boolean;
+    codeBlock?: CodeBlockOptions;
+    /**
+     * @default undefined
+     * @description Enables valid transaction events to be tracked in analytics (at a sampled rate)
+     */
+    trackValidTransactions?: {
+        samplingRate: number;
+    } | boolean;
+    /**
+     * @default undefined
+     * @description
+     * Enables the sticky toolbar in the comment/standard editor.
+     * If a boolean is specified and it's `true`, the sticky toolbar will be enabled, sticking to the top of the scroll parent.
+     * Instead a reference can be specified to an existing sticky toolbar on the page that the editor toolbar should stay below (experimental).
+     * if {offsetTop: number} is passed in, the toolbar is sticky and the toolbar's 'top' will be set to the offsetTop
+     * so the toolbar will sticks to `{offsetTop}` below the scroll parent.
+     */
+    useStickyToolbar?: UseStickyToolbarType;
+    /**
+     * @default undefined
+     * @description
+     * Short lived feature flags for experiments and gradual rollouts
+     * Flags are expected to follow these rules or they are filtered out
+     *
+     * 1. cased in kebab-case (match [a-z-])
+     * 2. have boolean values
+     *
+     * @example
+     * ```tsx
+     * (<Editor featureFlags={{ 'my-feature': true }} />);
+     * getFeatureFlags()?.myFeature === true;
+     * ```
+     *
+     * @example
+     * ```tsx
+     * (<Editor featureFlags={{ 'my-feature': 'thing' }} />);
+     * getFeatureFlags()?.myFeature === undefined;
+     * ```
+     *
+     * @example
+     * ```tsx
+     * (<Editor featureFlags={{ 'product.my-feature': false }} />);
+     * getFeatureFlags()?.myFeature === undefined;
+     * getFeatureFlags()?.productMyFeature === undefined;
+     * ```
+     */
+    featureFlags?: {
+        [featureFlag: string]: string | boolean;
+    };
+}
+export interface EditorSharedPropsWithPlugins {
+    onSave?: (editorView: EditorView) => void;
+    /**
+     * @description Control performance metric measurements and tracking
+     */
+    performanceTracking?: PerformanceTracking;
+    sanitizePrivateContent?: boolean;
+    allowAnalyticsGASV3?: boolean;
+    media?: MediaOptions;
+    collabEdit?: CollabEditOptions;
+    insertMenuItems?: MenuItem[];
+    primaryToolbarComponents?: PrimaryToolbarComponents;
+    allowUndoRedoButtons?: boolean;
+    allowTextColor?: boolean | TextColorPluginConfig;
+    allowTables?: boolean | TablesPluginConfig;
+    /** @deprecated Use smartLinks instead. */
+    UNSAFE_cards?: CardOptions;
+    /** @deprecated Use linking instead. */
+    smartLinks?: CardOptions;
+    /**
+     *  Configure and extend editor linking behaviour
+     */
+    linking?: LinkingOptions;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+}
+export interface EditorProps extends EditorBaseProps, EditorPluginFeatureProps, EditorSharedPropsWithPlugins, EditorProviderProps {
+    /**
+     * @deprecated Do not use outside of Editor team.
+     * This has subtle side effects - you __WILL__ break functionality without implementer knowledge of editor-core internals
+     */
+    dangerouslyAppendPlugins?: {
+        /**
+         * @deprecated Do not use outside of Editor team.
+         */
+        __plugins: EditorPlugin[];
+    };
+}
+export interface EditorNextProps extends EditorBaseProps, EditorSharedPropsWithPlugins, EditorProviderProps {
+    preset: EditorPresetBuilder<string[], AllEditorPresetPluginTypes[]>;
+}
+export interface EditorProviderProps {
+    activityProvider?: Promise<ActivityProvider>;
+    searchProvider?: Promise<SearchProvider>;
+    annotationProviders?: AnnotationProviders;
+    collabEditProvider?: Providers['collabEditProvider'];
+    presenceProvider?: Promise<any>;
+    emojiProvider?: Providers['emojiProvider'];
+    taskDecisionProvider?: Promise<TaskDecisionProvider>;
+    legacyImageUploadProvider?: Providers['imageUploadProvider'];
+    mentionProvider?: Promise<MentionProvider>;
+    autoformattingProvider?: Providers['autoformattingProvider'];
+    macroProvider?: Providers['macroProvider'];
+}
+export interface EditorPluginFeatureProps {
+    allowExpand?: boolean | {
+        allowInsertion?: boolean;
+        allowInteractiveExpand?: boolean;
+    };
+    allowNestedTasks?: boolean;
+    allowBlockType?: BlockTypePluginOptions['allowBlockType'];
+    allowTasksAndDecisions?: boolean;
+    allowBreakout?: boolean;
+    allowRule?: boolean;
+    allowHelpDialog?: boolean;
+    allowJiraIssue?: boolean;
+    allowPanel?: boolean | PanelPluginConfig;
+    allowExtension?: boolean | ExtensionConfig;
+    allowConfluenceInlineComment?: boolean;
+    allowTemplatePlaceholders?: boolean | PlaceholderTextOptions;
+    allowDate?: boolean;
+    allowLayouts?: boolean | LayoutPluginOptions;
+    allowStatus?: boolean | {
+        menuDisabled: boolean;
+    };
+    allowTextAlignment?: boolean;
+    allowIndentation?: boolean;
+    /**
+     * This enables new insertion behaviour only for horizontal rule and media single in certain conditions.
+     * The idea of this new behaviour is to have a consistent outcome regardless of the insertion method.
+     **/
+    allowNewInsertionBehaviour?: boolean;
+    allowFindReplace?: boolean | FindReplaceOptions;
+    /**
+     * Enable experimental support for the "border" mark.
+     * Refer to ADF Change proposal #65 for more details.
+     */
+    UNSAFE_allowBorderMark?: boolean;
+    /**
+     * Enable support for the "fragment" mark.
+     * Refer to ADF Change proposal #60 for more details.
+     */
+    allowFragmentMark?: boolean;
+    /**
+     * Set this to false to opt out of the default behaviour of auto scrolling into view
+     * whenever the document is changed
+     */
+    autoScrollIntoView?: boolean;
+    elementBrowser?: {
+        showModal?: boolean;
+        replacePlusMenu?: boolean;
+        helpUrl?: string;
+        emptyStateHandler?: EmptyStateHandler;
+    };
+    maxContentSize?: number;
+    saveOnEnter?: boolean;
+    feedbackInfo?: FeedbackInfo;
+    mention?: MentionPluginConfig;
+    /**
+     * flag to indicate display name instead of nick name should be inserted for mentions
+     * default: false, which inserts the nick name
+     * @deprecated Use mention.mentionInsertDisplayName instead
+     */
+    mentionInsertDisplayName?: boolean;
+    uploadErrorHandler?: (state: MediaState) => void;
+    waitForMediaUpload?: boolean;
+    extensionHandlers?: ExtensionHandlers;
+}
+export {};

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

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

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

@@ -0,0 +1 @@
+export type { EmptyStateHandler, EmptyStateHandlerParams, } from '@atlaskit/editor-common/types';

package/dist/types-ts4.0/types/extension-config.d.ts

@@ -0,0 +1,5 @@
+export interface ExtensionConfig {
+    allowBreakout?: boolean;
+    allowAutoSave?: boolean;
+    allowExtendFloatingToolbars?: boolean;
+}

package/dist/types-ts4.0/types/feature-flags.d.ts

@@ -0,0 +1 @@
+export type { FeatureFlags, FeatureFlagKey, } from '@atlaskit/editor-common/types';

package/dist/types-ts4.0/types/get-editor-props.d.ts

@@ -0,0 +1,12 @@
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+import { InsertNodeAPI } from '../insert-api/types';
+import { EditorPlugin, EditorProps, EditorAppearance } from '../types';
+export declare type GetEditorPluginsProps = {
+    props: EditorProps;
+    prevAppearance?: EditorAppearance;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    insertNodeAPI?: InsertNodeAPI;
+    editorAnalyticsAPI?: EditorAnalyticsAPI;
+};
+export declare type GetEditorPlugins = (props: GetEditorPluginsProps) => EditorPlugin[];

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

@@ -0,0 +1,5 @@
+export interface MessageDescriptor {
+    id: string;
+    description: string;
+    defaultMessage: string;
+}

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

@@ -0,0 +1,18 @@
+export type { EditorInstance } from './editor-instance';
+export type { EditorConfig } from './editor-config';
+export type { NextEditorPlugin, EditorPlugin, PluginsOptions, } from './editor-plugin';
+export type { EditorReactContext } from './editor-react-context';
+export type { EditorProps, FeedbackInfo, ReactComponents, ExtensionProvidersProp, PrimaryToolbarComponents, } from './editor-props';
+export type { EditorAppearanceComponentProps } from './editor-appearance-component';
+export type { Command, CommandDispatch } from './command';
+export type { MessageDescriptor } from './i18n';
+export type { DomAtPos } from './dom-at-pos';
+export type { AllowedBlockTypes } from './allowed-block-types';
+export type { ExtensionConfig } from './extension-config';
+export type { EditorAppearance } from './editor-appearance';
+export type { ToolbarUIComponentFactory, ToolbarUiComponentFactoryParams, } from '../ui/Toolbar/types';
+export type { PMPlugin, PMPluginFactory, PMPluginFactoryParams, } from './pm-plugin';
+export type { PMPluginCreateConfig } from './pm-plugin-list';
+export type { NodeViewConfig, MarkConfig, NodeConfig } from './pm-config';
+export type { UIComponentFactory, UiComponentFactoryParams, } from './ui-components';
+export type { DisableSpellcheckByBrowser, Range, Browsers } from './browser';