@atlaskit/editor-core 183.0.9 → 183.1.0

package/dist/types-ts4.5/utils/action.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="prosemirror-model" />
+import type { EditorView } from 'prosemirror-view';
+import type { Command } from '../types/command';
+export declare function __temporaryFixForConfigPanel(editorView: EditorView): Promise<void>;
+export declare function getEditorValueWithMedia(editorView: EditorView): Promise<import("prosemirror-model").Node<any>>;
+/**
+ * Iterates over the commands one after the other,
+ * passes the tr through and dispatches the cumulated transaction
+ */
+export declare function cascadeCommands(cmds: Command[]): Command;

package/dist/types-ts4.5/utils/announcer/announcer.d.ts

@@ -0,0 +1,22 @@
+import React, { AriaAttributes, Ref } from 'react';
+type AnnouncerProps = {
+    ref?: Ref<HTMLDivElement>;
+    /** Set 'false' for announcing only changed text
+     * (not announce duplicate part of string after second render),
+     * and 'true' for announcing all the string after each render */
+    ariaAtomic?: AriaAttributes['aria-atomic'];
+    /** Set politeness settings */
+    ariaLive?: AriaAttributes['aria-live'];
+    /** Used to describe what types of changes have occurred to an aria-live region */
+    ariaRelevant?: AriaAttributes['aria-relevant'];
+    /** Role used to set attribute role. See more details https://dequeuniversity.com/library/aria/liveregion-playground#configOptions */
+    role?: 'status' | 'log' | 'alert' | 'timer' | 'marquee';
+    /** Text message that will be announced */
+    text: string;
+    /** Debounce delay.
+     *  Set delay (ms) to prevent announce the same string multiple times.
+     *  It can be useful for cases when the parent component re-renders with the same announcer's text. */
+    delay?: number;
+};
+declare const _default: React.NamedExoticComponent<AnnouncerProps>;
+export default _default;

package/dist/types-ts4.5/utils/array.d.ts

@@ -0,0 +1,2 @@
+export declare function findUniqueItemsIn<T>(findIn: Array<T>, checkWith: Array<T>, comparator?: (firstItem: T, secondItem: T) => boolean): Array<T>;
+export declare function filterUniqueItems<T>(arr: Array<T>, comparator?: (firstItem: T, secondItem: T) => boolean): Array<T>;

package/dist/types-ts4.5/utils/cell-selection.d.ts

@@ -0,0 +1,3 @@
+import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
+import { Node } from 'prosemirror-model';
+export declare const cellSelectionNodesBetween: (selection: CellSelection, doc: Node, f: (node: Node, pos: number, parent: Node, index: number) => boolean | null | undefined | void, startPos?: number) => void;

package/dist/types-ts4.5/utils/clipboard.d.ts

@@ -0,0 +1,4 @@
+export declare function checkClipboardTypes(type: DOMStringList | ReadonlyArray<string>, item: string): boolean;
+export declare function isPastedFile(rawEvent: Event): boolean;
+export declare const copyToClipboard: (textToCopy: string) => Promise<void>;
+export declare const copyHTMLToClipboard: (elementToCopy: HTMLElement, plainTextToCopy?: string) => Promise<void>;

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

@@ -0,0 +1,75 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { ResolvedPos, MarkType, Mark, Node as PMNode, Fragment } from 'prosemirror-model';
+import { Command, HigherOrderCommand } from '../types/command';
+type Predicate = (state: EditorState, view?: EditorView) => boolean;
+declare const filter: (predicates: Predicate[] | Predicate, cmd: Command) => Command;
+declare const isEmptySelectionAtStart: (state: EditorState) => boolean;
+declare const isEmptySelectionAtEnd: (state: EditorState) => boolean;
+declare const isFirstChildOfParent: (state: EditorState) => boolean;
+/**
+ * Creates a filter that checks if the node at a given number of parents above the current
+ * selection is of the correct node type.
+ * @param nodeType The node type to compare the nth parent against
+ * @param depthAway How many levels above the current node to check against. 0 refers to
+ * the current selection's parent, which will be the containing node when the selection
+ * is usually inside the text content.
+ */
+declare const isNthParentOfType: (nodeType: string, depthAway: number) => (state: EditorState, view?: EditorView) => boolean;
+declare function findCutBefore($pos: ResolvedPos): ResolvedPos | null;
+declare const applyMarkOnRange: (from: number, to: number, removeMark: boolean, mark: Mark, tr: Transaction) => Transaction<any>;
+/**
+ * A wrapper over the default toggleMark, except when we have a selection
+ * we only toggle marks on text nodes rather than inline nodes.
+ * @param markType
+ * @param attrs
+ */
+declare const toggleMark: (markType: MarkType, attrs?: {
+    [key: string]: any;
+} | undefined) => Command;
+declare const withScrollIntoView: HigherOrderCommand;
+export type WalkNode = {
+    $pos: ResolvedPos;
+    foundNode: boolean;
+};
+/**
+ * Walk forwards from a position until we encounter the (inside) start of
+ * the next node, or reach the end of the document.
+ *
+ * @param $startPos Position to start walking from.
+ */
+declare const walkNextNode: ($startPos: ResolvedPos) => WalkNode;
+/**
+ * Walk backwards from a position until we encounter the (inside) end of
+ * the previous node, or reach the start of the document.
+ *
+ * @param $startPos Position to start walking from.
+ */
+declare const walkPrevNode: ($startPos: ResolvedPos) => WalkNode;
+/**
+ * Insert content, delete a range and create a new selection
+ * This function automatically handles the mapping of positions for insertion and deletion.
+ * The new selection is handled as a function since it may not always be necessary to resolve a position to the transactions mapping
+ *
+ * @param getSelectionResolvedPos get the resolved position to create a new selection
+ * @param insertions content to insert at the specified position
+ * @param deletions the ranges to delete
+ */
+declare const insertContentDeleteRange: (tr: Transaction, getSelectionResolvedPos: (tr: Transaction) => ResolvedPos, insertions: [
+    Fragment,
+    number
+][], deletions: [
+    number,
+    number
+][]) => void;
+declare const selectNode: (pos: number) => Command;
+/**
+ * If the selection is empty, is inside a paragraph node and `canNextNodeMoveUp` is true then delete current paragraph
+ * and move the node below it up. The selection will be retained, to be placed in the moved node.
+ *
+ * @param canNextNodeMoveUp check if node directly after the selection is able to be brought up to selection
+ * @returns PM Command
+ */
+declare const deleteEmptyParagraphAndMoveBlockUp: (canNextNodeMoveUp: (nextNode: PMNode) => boolean) => Command;
+export { filter, isEmptySelectionAtStart, isEmptySelectionAtEnd, isFirstChildOfParent, isNthParentOfType, findCutBefore, toggleMark, applyMarkOnRange, withScrollIntoView, walkNextNode, walkPrevNode, insertContentDeleteRange, selectNode, deleteEmptyParagraphAndMoveBlockUp, };
+export type { Predicate, };

package/dist/types-ts4.5/utils/count-nodes.d.ts

@@ -0,0 +1,8 @@
+import { EditorState } from 'prosemirror-state';
+type NodeCount = Record<string, number>;
+type NodesCount = {
+    nodeCount: NodeCount;
+    extensionNodeCount: NodeCount;
+};
+export declare function countNodes(state: EditorState): NodesCount;
+export {};

package/dist/types-ts4.5/utils/deprecation-warnings.d.ts

@@ -0,0 +1,8 @@
+export interface DeprecationWarning {
+    property: string;
+    description?: string;
+    type?: string;
+    condition?: (props: any) => boolean;
+}
+declare const deprecationWarnings: (className: string, props: any, deprecations: Array<DeprecationWarning>) => void;
+export default deprecationWarnings;

package/dist/types-ts4.5/utils/document-logger.d.ts

@@ -0,0 +1,6 @@
+import { Node as PMNode } from 'prosemirror-model';
+import type { SimplifiedNode } from '@atlaskit/editor-common/analytics';
+export type { SimplifiedNode };
+export declare const getDocStructure: (doc: PMNode, options?: {
+    compact?: boolean;
+}) => SimplifiedNode | string;

package/dist/types-ts4.5/utils/document.d.ts

@@ -0,0 +1,53 @@
+import { Node, Fragment, Schema, ResolvedPos } from 'prosemirror-model';
+import { Transaction, ReadonlyTransaction, EditorState } from 'prosemirror-state';
+import { ContentNodeWithPos } from 'prosemirror-utils';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { Transformer, ReplaceRawValue } from '@atlaskit/editor-common/types';
+import { DispatchAnalyticsEvent } from '../plugins/analytics/types/dispatch-analytics-event';
+import { BreakoutMarkAttrs } from '@atlaskit/adf-schema';
+/**
+ * Returns false if node contains only empty inline nodes and hardBreaks.
+ */
+export declare function hasVisibleContent(node: Node): boolean;
+/**
+ * Checks if a node has any content. Ignores node that only contain empty block nodes.
+ */
+export declare function isNodeEmpty(node?: Node): boolean;
+/**
+ * Checks if a node looks like an empty document
+ */
+export declare function isEmptyDocument(node: Node): boolean;
+export declare function hasDocAsParent($anchor: ResolvedPos): boolean;
+export declare function isProseMirrorSchemaCheckError(error: unknown): boolean;
+export declare function isInEmptyLine(state: EditorState): boolean;
+export declare function bracketTyped(state: EditorState): boolean;
+export declare function processRawFragmentValue(schema: Schema, value?: ReplaceRawValue[], providerFactory?: ProviderFactory, sanitizePrivateContent?: boolean, contentTransformer?: Transformer<string>, dispatchAnalyticsEvent?: DispatchAnalyticsEvent): Fragment | undefined;
+export declare function processRawValue(schema: Schema, value?: ReplaceRawValue, providerFactory?: ProviderFactory, sanitizePrivateContent?: boolean, contentTransformer?: Transformer<string>, dispatchAnalyticsEvent?: DispatchAnalyticsEvent): Node | undefined;
+export declare const getStepRange: (transaction: Transaction | ReadonlyTransaction) => {
+    from: number;
+    to: number;
+} | null;
+/**
+ * Find the farthest node given a condition
+ * @param predicate Function to check the node
+ */
+export declare const findFarthestParentNode: (predicate: (node: Node) => boolean) => ($pos: ResolvedPos) => ContentNodeWithPos | null;
+export declare const isSelectionEndOfParagraph: (state: EditorState) => boolean;
+export type ChangedFn = (node: Node<any>, pos: number, parent: Node<any>, index: number) => boolean | null | undefined | void;
+export declare function getChangedNodesIn({ tr, doc, }: {
+    tr: ReadonlyTransaction | Transaction;
+    doc: Node;
+}): {
+    node: Node;
+    pos: number;
+}[];
+export declare function getChangedNodes(tr: ReadonlyTransaction | Transaction): {
+    node: Node;
+    pos: number;
+}[];
+export declare function nodesBetweenChanged(tr: Transaction | ReadonlyTransaction, f: ChangedFn, startPos?: number): void;
+export declare function getNodesCount(node: Node): Record<string, number>;
+/**
+ * Returns a set of active child breakout modes
+ */
+export declare function getChildBreakoutModes(doc: Node, schema: Schema, filter?: BreakoutMarkAttrs['mode'][]): BreakoutMarkAttrs['mode'][];

package/dist/types-ts4.5/utils/dom.d.ts

@@ -0,0 +1,2 @@
+export { walkUpTreeUntil, unwrap, removeNestedEmptyEls, containsClassName, closest, closestElement, parsePx, mapElem, maphElem, } from '@atlaskit/editor-common/utils';
+export type { MapCallback } from '@atlaskit/editor-common/utils';

package/dist/types-ts4.5/utils/drag-drop.d.ts

@@ -0,0 +1 @@
+export declare function isDroppedFile(rawEvent: Event): boolean;

package/dist/types-ts4.5/utils/extensions.d.ts

@@ -0,0 +1,6 @@
+import type { ExtensionProvider } from '@atlaskit/editor-common/extensions';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next/types';
+import { QuickInsertProvider } from '@atlaskit/editor-common/provider-factory';
+import EditorActions from '../actions';
+export declare function extensionProviderToQuickInsertProvider(extensionProvider: ExtensionProvider, editorActions: EditorActions, createAnalyticsEvent?: CreateUIAnalyticsEvent): Promise<QuickInsertProvider>;
+export declare function combineQuickInsertProviders(quickInsertProviders: Array<QuickInsertProvider | Promise<QuickInsertProvider>>): Promise<QuickInsertProvider>;

package/dist/types-ts4.5/utils/filter/privacy-filter.d.ts

@@ -0,0 +1,9 @@
+import { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+/**
+ * Sanitises a document where some content should not be in the document (e.g. mention names).
+ *
+ * It is expected that these names we be resolved separately (e.g. when rendering
+ * a node view).
+ */
+export declare function sanitizeNodeForPrivacy(json: JSONDocNode, providerFactory?: ProviderFactory): JSONDocNode;

package/dist/types-ts4.5/utils/getAttrsWithChangesRecorder.d.ts

@@ -0,0 +1,23 @@
+import { Node } from 'prosemirror-model';
+export interface GetAttrsChange<T, V> {
+    node: Node;
+    prevAttrs?: T;
+    newAttrs: T | false | undefined;
+    options: V;
+}
+export type GetAttrsWithChangesRecorder<T, V> = {
+    getAttrs(prevAttrs?: T | undefined, node?: Node): T | false | undefined;
+    getAndResetAttrsChanges(): GetAttrsChange<T, V>[];
+};
+/**
+ * Create a new getAttrs handler who will wrap the original function,
+ * and store the changes internally to be used for other
+ * tools like Analytics later in the code.
+ *
+ * @param getAttrs - Function who gets the new attributes
+ * @return object
+ * @property handler - New handler to get indentation attributes (It wraps the original)
+ * @property getChanges - Return all the stored changes.
+ * @property clear - Clear the changes
+ */
+export default function getAttrsWithChangesRecorder<T, V>(getAttrs: (prevAttrs?: T, node?: Node) => T | false | undefined, options: V): GetAttrsWithChangesRecorder<T, V>;

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

@@ -0,0 +1,85 @@
+import { MarkType, Node, ResolvedPos, Schema, Slice } from 'prosemirror-model';
+import { EditorState, Selection } from 'prosemirror-state';
+import { JSONDocNode, JSONNode } from '@atlaskit/editor-json-transformer';
+export { insideTable } from '@atlaskit/editor-common/core-utils';
+export { hasVisibleContent, isNodeEmpty, isEmptyDocument, processRawValue, getStepRange, findFarthestParentNode, isSelectionEndOfParagraph, nodesBetweenChanged, getNodesCount, } from './document';
+export { sanitiseMarksInSelection } from './mark';
+export { isParagraph, isText, isLinkMark } from './nodes';
+export { setNodeSelection, setGapCursorSelection, setTextSelection, } from './selection';
+export type { JSONDocNode };
+export { default as measurements } from './performance/measure-enum';
+export declare function canMoveUp(state: EditorState): boolean;
+export declare function canMoveDown(state: EditorState): boolean;
+export declare function isSelectionInsideLastNodeInDocument(selection: Selection): boolean;
+export declare function getCursor(selection: Selection): ResolvedPos | undefined;
+/**
+ * Check if a mark is allowed at the current selection / cursor based on a given state.
+ * This method looks at both the currently active marks on the transaction, as well as
+ * the node and marks at the current selection to determine if the given mark type is
+ * allowed.
+ */
+export declare function isMarkTypeAllowedInCurrentSelection(markType: MarkType, state: EditorState): boolean;
+export declare function checkNodeDown(selection: Selection, doc: Node, filter: (node: Node) => boolean): boolean;
+export declare function toJSON(node: Node): JSONDocNode;
+export declare function nodeToJSON(node: Node): JSONNode;
+/**
+ * Repeating string for multiple times
+ */
+export declare function stringRepeat(text: string, length: number): string;
+export declare function whichTransitionEvent<TransitionEventName extends string>(): TransitionEventName | undefined;
+/**
+ * Function will check if changing block types: Paragraph, Heading is enabled.
+ */
+export declare function areBlockTypesDisabled(state: EditorState): boolean;
+export declare const isTemporary: (id: string) => boolean;
+export declare const isEmptyNode: (schema: Schema) => (node: Node) => boolean;
+export declare const insideTableCell: (state: EditorState) => boolean;
+export declare const isInLayoutColumn: (state: EditorState) => boolean;
+export declare const isInListItem: (state: EditorState) => boolean;
+export declare const hasOpenEnd: (slice: Slice) => boolean;
+export declare const isInsideBlockQuote: (state: EditorState) => boolean;
+export declare function filterChildrenBetween(doc: Node, from: number, to: number, predicate: (node: Node, pos: number, parent: Node) => boolean | undefined): {
+    node: Node;
+    pos: number;
+}[];
+export declare function dedupe<T>(list?: T[], iteratee?: (p: T) => T[keyof T] | T): T[];
+export { isTextSelection, isElementInTableCell, isLastItemMediaGroup, nonNullable, } from '@atlaskit/editor-common/utils';
+/** Helper type for single arg function */
+type Func<A, B> = (a: A) => B;
+type FuncN<A extends any[], B> = (...args: A) => B;
+/**
+ * Compose 1 to n functions.
+ * @param func first function
+ * @param funcs additional functions
+ */
+export declare function compose<F1 extends Func<any, any>, FN extends Array<Func<any, any>>, R extends FN extends [
+] ? F1 : FN extends [
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : FN extends [
+    any,
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : FN extends [
+    any,
+    any,
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : FN extends [
+    any,
+    any,
+    any,
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : FN extends [
+    any,
+    any,
+    any,
+    any,
+    Func<infer A, any>
+] ? (a: A) => ReturnType<F1> : Func<any, ReturnType<F1>>>(func: F1, ...funcs: FN): R;
+export declare function pipe(): <R>(a: R) => R;
+export declare function pipe<F extends Function>(f: F): F;
+export declare function pipe<F1 extends FuncN<any, any>>(f1: F1): (...args: Parameters<F1>) => ReturnType<F1>;
+export declare function pipe<F1 extends FuncN<any, any>, F2 extends Func<ReturnType<F1>, any>>(f1: F1, f2: F2): (...args: Parameters<F1>) => ReturnType<F2>;
+export declare function pipe<F1 extends FuncN<any, any>, F2 extends Func<ReturnType<F1>, any>, F3 extends Func<ReturnType<F2>, any>>(f1: F1, f2: F2, f3: F3): (...args: Parameters<F1>) => ReturnType<F3>;
+export declare function pipe<F1 extends FuncN<any, any>, F2 extends Func<ReturnType<F1>, any>, F3 extends Func<ReturnType<F2>, any>, FN extends Array<Func<any, any>>>(f1: F1, f2: F2, f3: F3, ...fn: FN): (...args: Parameters<F1>) => any;
+export declare function shallowEqual(obj1?: any, obj2?: any): boolean;
+export declare function sum<T>(arr: Array<T>, f: (val: T) => number): number;
+export { SetAttrsStep } from '@atlaskit/adf-schema/steps';

package/dist/types-ts4.5/utils/input-rules.d.ts

@@ -0,0 +1,29 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { Node as PMNode, NodeType } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+import { InputRuleHandler, InputRuleWrapper } from '@atlaskit/prosemirror-input-rules';
+import { AnalyticsEventPayload } from '../plugins/analytics/types';
+import { JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST } from '@atlaskit/editor-common/analytics';
+type GetPayload = AnalyticsEventPayload | ((state: EditorState, matchResult: RegExpExecArray) => AnalyticsEventPayload);
+export declare const ruleWithAnalytics: (getPayload: GetPayload) => (originalRule: InputRuleWrapper) => InputRuleWrapper;
+export declare const createRule: (match: RegExp, handler: InputRuleHandler) => InputRuleWrapper;
+type Options = {
+    isBlockNodeRule?: boolean;
+    allowInsertTextOnDocument?: boolean;
+};
+export declare const createPlugin: (pluginName: string, rules: Array<InputRuleWrapper>, options?: Options) => SafePlugin;
+type WrappingTextRuleProps = {
+    match: RegExp;
+    nodeType: NodeType;
+    getAttrs?: Record<string, any> | ((matchResult: RegExpExecArray) => Record<string, any>);
+};
+export declare const createWrappingTextBlockRule: ({ match, nodeType, getAttrs, }: WrappingTextRuleProps) => InputRuleWrapper;
+type WrappingRuleProps = {
+    match: RegExp;
+    nodeType: NodeType;
+    getAttrs?: Record<string, any> | ((matchResult: RegExpExecArray) => Record<string, any>);
+    joinPredicate?: (matchResult: RegExpExecArray, node: PMNode, joinScenario: JOIN_SCENARIOS_WHEN_TYPING_TO_INSERT_LIST) => boolean;
+};
+export declare const createWrappingJoinRule: ({ match, nodeType, getAttrs, joinPredicate, }: WrappingRuleProps) => InputRuleWrapper;
+export declare const createJoinNodesRule: (match: RegExp, nodeType: NodeType) => InputRuleWrapper;
+export {};

package/dist/types-ts4.5/utils/is-full-page.d.ts

@@ -0,0 +1,2 @@
+import { EditorAppearance } from '../types';
+export declare function isFullPage(appearance?: EditorAppearance): boolean;

package/dist/types-ts4.5/utils/is-text-input.d.ts

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

package/dist/types-ts4.5/utils/keymap.d.ts

@@ -0,0 +1,11 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+/**
+ * A workaround for mostly Cyrillic but should have a positive affect
+ * on other languages / layouts. Attempts a similar approach to OS X.
+ * @see ED-7310
+ * @see https://github.com/ProseMirror/prosemirror/issues/957
+ * @param bindings
+ */
+export declare function keymap(bindings: {
+    [key: string]: any;
+}): SafePlugin<any, any>;

package/dist/types-ts4.5/utils/linking-utils.d.ts

@@ -0,0 +1,14 @@
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE, AnalyticsEventPayload, ACTION_SUBJECT_ID, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+export declare const buildEditLinkPayload: (type: LinkType) => AnalyticsEventPayload;
+export type LinkType = ACTION_SUBJECT_ID.CARD_INLINE | ACTION_SUBJECT_ID.CARD_BLOCK | ACTION_SUBJECT_ID.EMBEDS | ACTION_SUBJECT_ID.HYPERLINK;
+export declare const buildVisitedLinkPayload: (type: LinkType) => AnalyticsEventPayload;
+export declare const buildOpenedSettingsPayload: (type: LinkType) => AnalyticsEventPayload;
+export declare const unlinkPayload: (type: LinkType) => {
+    action: ACTION;
+    actionSubject: ACTION_SUBJECT;
+    actionSubjectId: ACTION_SUBJECT_ID.CARD_INLINE | undefined;
+    attributes: {
+        inputMethod: INPUT_METHOD;
+    };
+    eventType: EVENT_TYPE;
+};

package/dist/types-ts4.5/utils/list-commands.d.ts

@@ -0,0 +1,7 @@
+import { indentList, outdentList, toggleOrderedList, toggleBulletList } from '../plugins/list/commands';
+export declare const getListCommands: () => {
+    indentList: typeof indentList;
+    outdentList: typeof outdentList;
+    toggleOrderedList: typeof toggleOrderedList;
+    toggleBulletList: typeof toggleBulletList;
+};

package/dist/types-ts4.5/utils/lists.d.ts

@@ -0,0 +1,2 @@
+import { Selection } from 'prosemirror-state';
+export declare const doesSelectionWhichStartsOrEndsInListContainEntireList: (selection: Selection) => boolean;

package/dist/types-ts4.5/utils/mark.d.ts

@@ -0,0 +1,15 @@
+import { Node, Mark, MarkType, NodeType } from 'prosemirror-model';
+import { SelectionRange, EditorState, Transaction } from 'prosemirror-state';
+export declare const isMarkAllowedInRange: (doc: Node, ranges: Array<SelectionRange>, type: MarkType) => boolean;
+export declare const isMarkExcluded: (type: MarkType, marks?: Array<Mark> | null) => boolean;
+export declare const removeBlockMarks: (state: EditorState, marks: Array<MarkType | undefined>) => Transaction | undefined;
+/**
+ * Removes marks from nodes in the current selection that are not supported
+ */
+export declare const sanitiseSelectionMarksForWrapping: (state: EditorState, newParentType?: NodeType) => Transaction | undefined;
+type NodesSanitized = Array<{
+    node: Node;
+    marksRemoved: Mark[];
+}>;
+export declare const sanitiseMarksInSelection: (tr: Transaction, newParentType?: NodeType) => NodesSanitized;
+export {};

package/dist/types-ts4.5/utils/node-width.d.ts

@@ -0,0 +1,7 @@
+import { Node as PMNode, MarkType } from 'prosemirror-model';
+import { BreakoutMarkAttrs } from '@atlaskit/adf-schema';
+export { getParentNodeWidth } from '@atlaskit/editor-common/node-width';
+/**
+ * Returns the breakout mode of a given node
+ */
+export declare const getBreakoutMode: (node: PMNode, breakout: MarkType) => BreakoutMarkAttrs['mode'] | undefined;

package/dist/types-ts4.5/utils/nodes-by-localIds.d.ts

@@ -0,0 +1,8 @@
+import { EditorState } from 'prosemirror-state';
+import { NodeWithPos } from 'prosemirror-utils';
+type FindNodesByIdsOption = {
+    includeDocNode?: boolean;
+};
+export declare const findNodePosByLocalIds: (state: EditorState, ids: string[], option?: FindNodesByIdsOption) => NodeWithPos[];
+export declare const findNodePosByFragmentLocalIds: (state: EditorState, ids: string[]) => NodeWithPos[];
+export {};

package/dist/types-ts4.5/utils/nodes.d.ts

@@ -0,0 +1 @@
+export { findChangedNodesFromTransaction, validNode, validateNodes, isType, isParagraph, isText, isLinkMark, SelectedState, isNodeSelectedOrInRange, isSupportedInParent, } from '@atlaskit/editor-common/utils';

package/dist/types-ts4.5/utils/performance/components/RenderTracking.d.ts

@@ -0,0 +1,13 @@
+import { ACTION_SUBJECT, ACTION, FireAnalyticsCallback } from '@atlaskit/editor-common/analytics';
+type RenderActions = ACTION.RE_RENDERED;
+type RenderActionSubjects = ACTION_SUBJECT.EDITOR | ACTION_SUBJECT.REACT_EDITOR_VIEW;
+export type RenderTrackingProps<ComponentProps> = {
+    componentProps: ComponentProps;
+    action: RenderActions;
+    actionSubject: RenderActionSubjects;
+    handleAnalyticsEvent: FireAnalyticsCallback;
+    propsToIgnore?: Array<keyof ComponentProps>;
+    useShallow?: boolean;
+};
+export declare function RenderTracking<Props>(props: RenderTrackingProps<Props>): null;
+export {};

package/dist/types-ts4.5/utils/performance/get-performance-timing.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Calculate the difference between performance.now() and the given startTime.
+ * This allows for the timing to be overridable during tests.
+ *
+ * @param startTime DOMHighResTimeStamp
+ * @returns DOMHighResTimeStamp
+ */
+export declare const getTimeSince: (startTime: DOMHighResTimeStamp) => DOMHighResTimeStamp;

package/dist/types-ts4.5/utils/performance/instrumented-plugin.d.ts

@@ -0,0 +1,17 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { SafePluginSpec } from 'prosemirror-state';
+import { Schema } from 'prosemirror-model';
+import { EditorProps } from '../../types/editor-props';
+import { TransactionTracker } from './track-transactions';
+import { FeatureFlags } from '../../types/feature-flags';
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+type InstrumentedPluginOptions = EditorProps['performanceTracking'] & {
+    saferDispatchedTransactions?: FeatureFlags['saferDispatchedTransactions'];
+    saferDispatchedTransactionsAnalyticsOnly?: FeatureFlags['saferDispatchedTransactionsAnalyticsOnly'];
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+};
+export declare class InstrumentedPlugin<PluginState, NodeSchema extends Schema<any, any>> extends SafePlugin<PluginState, NodeSchema> {
+    constructor(spec: SafePluginSpec, options?: InstrumentedPluginOptions, transactionTracker?: TransactionTracker);
+    static fromPlugin<T, V extends Schema<any, any>>(plugin: SafePlugin<T, V>, options: InstrumentedPluginOptions, transactionTracker?: TransactionTracker): InstrumentedPlugin<T, V>;
+}
+export {};

package/dist/types-ts4.5/utils/performance/measure-enum.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    EDITOR_MOUNTED: string;
+    PROSEMIRROR_RENDERED: string;
+    PROSEMIRROR_CONTENT_RENDERED: string;
+    ON_EDITOR_READY_CALLBACK: string;
+    PASTE: string;
+};
+export default _default;

package/dist/types-ts4.5/utils/performance/outlier.d.ts

@@ -0,0 +1 @@
+export declare const outlier: (input: number[], factor: number) => number | undefined;

package/dist/types-ts4.5/utils/performance/percentile.d.ts

@@ -0,0 +1 @@
+export declare const percentile: (input: number[], fraction: number) => number | undefined;

package/dist/types-ts4.5/utils/performance/plugin-performance-observer.d.ts

@@ -0,0 +1,22 @@
+import { NodesCount, PluginPerformanceReportData, PluginPerformanceReportOptions } from './plugin-performance-report';
+import { TransactionTracker } from './track-transactions';
+export declare class PluginPerformanceObserver implements PerformanceObserver {
+    private callback;
+    private getNodeCounts;
+    private getPlugins;
+    private getOptions;
+    private reportCount;
+    private simpleObserver;
+    private observer;
+    private getTransactionTracker?;
+    constructor(callback: (report: PluginPerformanceReportData) => void);
+    private get isSimpleTracking();
+    withNodeCounts(getNodeCounts: () => NodesCount): this;
+    withPlugins(getPlugins: () => string[]): this;
+    withOptions(getOptions: () => Partial<PluginPerformanceReportOptions>): this;
+    withTransactionTracker(getTransactionTracker: () => TransactionTracker): this;
+    private onObserveration;
+    observe(): void;
+    disconnect(): void;
+    takeRecords(): PerformanceEntryList;
+}

package/dist/types-ts4.5/utils/performance/plugin-performance-report.d.ts

@@ -0,0 +1,48 @@
+import { PluginMethodReport, PluginsReport, NodeCount, PluginPerformanceReportData } from '@atlaskit/editor-common/analytics';
+export type { PluginMethodReport, PluginsReport, NodeCount, PluginPerformanceReportData, };
+export interface OutlierReport {
+    stateApplyOutlier: number | undefined;
+    viewUpdateOutlier: number | undefined;
+}
+export interface PluginPerformanceReportOptions {
+    usePerformanceMarks?: boolean;
+    samplingRate: number;
+    slowThreshold: number;
+    outlierThreshold: number;
+    outlierFactor: number;
+}
+export type NodesCount = {
+    nodeCount: NodeCount;
+    extensionNodeCount: NodeCount;
+};
+export declare class PluginPerformanceReport {
+    private entry;
+    private count;
+    private pluginNames;
+    private entryList?;
+    private stateApplied?;
+    private viewUpdated?;
+    private onChangeCalled?;
+    private onEditorViewStateUpdatedCalled?;
+    private nodes;
+    private extensionNodes;
+    private nodesDuration;
+    private plugins;
+    private slowPlugins;
+    private options;
+    private constructor();
+    static fromEntry(entry: PerformanceEntry): PluginPerformanceReport;
+    private isChild;
+    private getEntryByName;
+    private getMethodSum;
+    private greaterEquals;
+    private hasOutlierMethods;
+    get trigger(): 'none' | 'slow' | 'distribution' | 'sample';
+    get hasSlowPlugins(): boolean;
+    withEntryList(entryList: PerformanceObserverEntryList): this;
+    withPlugins(pluginNames: string[]): this;
+    withNodes(nodesCount: NodesCount, nodesDuration?: number): this;
+    withCount(count: number): this;
+    withOptions(options: Partial<PluginPerformanceReportOptions>): this;
+    toJSON(): PluginPerformanceReportData;
+}

package/dist/types-ts4.5/utils/performance/safer-transactions.d.ts

@@ -0,0 +1,9 @@
+import type { DispatchAnalyticsEvent } from '@atlaskit/editor-common/analytics';
+export declare const UNSAFE_PROPERTY_SET_ERROR = "Setting an unsafe property on transaction after dispatch!";
+interface FreezeUnsafeTransactionOptions {
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    pluginKey?: string;
+    analyticsOnly?: boolean;
+}
+export declare const freezeUnsafeTransactionProperties: <TrType extends object>({ dispatchAnalyticsEvent, pluginKey, analyticsOnly, }: FreezeUnsafeTransactionOptions) => ProxyHandler<TrType>;
+export {};

package/dist/types-ts4.5/utils/performance/simple-measure-to-entries.d.ts

@@ -0,0 +1,28 @@
+interface Reading {
+    name: string;
+    duration: number;
+    startTime: number;
+}
+type ObservationCallback = (entries: PerformanceObserverEntryList) => void;
+/**
+ * A class that logs and collates measurement entries until
+ * EVENT_NAME_DISPATCHTRANSACTION is detected.
+ *
+ * At that point, it will group together all the entries
+ * logged and fire a callback with all entries packaged
+ * into a PerformanceObserverEntryList.
+ *
+ * We are able to make use of this method as the measurements
+ * which occur during dispatchTransactions are synchronous.
+ */
+export declare class SimpleMeasurementLogger {
+    private currentBatch;
+    private pluginNameCache;
+    private observationCallback?;
+    setPluginNames: (names: string[]) => void;
+    setOnObservation: (callback: ObservationCallback) => void;
+    private createPerformanceEntry;
+    private convertToEntryList;
+    observed: (reading: Reading) => void;
+}
+export {};