@atlaskit/editor-common 70.1.3 → 70.2.1

package/dist/types-ts4.0/utils/performance/measure-render.d.ts

@@ -1,41 +0,0 @@
-/**
- * Measures time it takes to render a frame including -> style, paint, layout and composition.
- *
- * How does it work:
- * 1. We mark the beginning of a render with the `startMark`
- * 2. We schedule `requestAnimationFrame` callback for the next frame
- * 3. Framework (e.g. prosemirror) does its magic and mounts dom nodes "synchronously"
- * 4. When the main thread is unblocked our callback gets executed and onMeasureComplete is being called
- *
- * Why does it work:
- * | javascript (framework)           | style | layout | paint | composite | javascript  | ...
- *  | startMark + scheduling rAF |                                                       | rAF callback, endMark
- */
-export declare function measureRender(
-/**
- * Unique name for the measurement
- *
- * Important: if multiple measureRender events are fired at the same time
- * with the same measure name -- the result will not be correct.
- */
-measureName: string, 
-/**
- * Call back fired when the measurement completes.
- *
- * Note: when this function is called when the Document.visibilityState is not
- * visible -- the duration is likely to be misleading/inaccurate. This is due
- * to the measurements use of the `requestAnimationFrame` api which only fires
- * when the Document.visibilityState is visible.
- */
-onMeasureComplete: ({ duration, startTime, distortedDuration, }: {
-    duration: number;
-    startTime: number;
-    /**
-     * Will be true when the measurement takes place in a background tab or some
-     * other case which results in the Document.visibilityState not being visible.
-     *
-     * When true -- the duration value is not useful to provide to consumers. See
-     * onMeasureComplete description for more details.
-     */
-    distortedDuration: boolean;
-}) => void): void;

package/dist/types-ts4.0/utils/performance/measure-tti.d.ts

@@ -1,14 +0,0 @@
-import { SEVERITY } from '../analytics';
-export declare function measureTTI(onMeasureComplete: (tti: number, ttiFromInvocation: number, canceled: boolean) => void, idleThreshold?: number, cancelAfter?: number, PerfObserver?: typeof window.PerformanceObserver): void;
-export declare const TTI_SEVERITY_THRESHOLD_DEFAULTS: {
-    NORMAL: number;
-    DEGRADED: number;
-};
-export declare const TTI_FROM_INVOCATION_SEVERITY_THRESHOLD_DEFAULTS: {
-    NORMAL: number;
-    DEGRADED: number;
-};
-export declare function getTTISeverity(tti: number, ttiFromInvocation: number, ttiSeverityNormalTheshold?: number, ttiSeverityDegradedThreshold?: number, ttiFromInvocationSeverityNormalThreshold?: number, ttiFromInvocationSeverityDegradedThreshold?: number): {
-    ttiSeverity: SEVERITY;
-    ttiFromInvocationSeverity: SEVERITY;
-};

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

@@ -1,3 +0,0 @@
-export declare function startMeasure(measureName: string): void;
-export declare function stopMeasure(measureName: string, onMeasureComplete?: (duration: number, startTime: number) => void): void;
-export declare function clearMeasure(measureName: string): void;

package/dist/types-ts4.0/utils/performance/navigation.d.ts

@@ -1 +0,0 @@
-export declare function getResponseEndTime(): number | undefined;

package/dist/types-ts4.0/utils/plugin-state-factory.d.ts

@@ -1,16 +0,0 @@
-import { EditorState, PluginKey, ReadonlyTransaction, SafeStateField, Transaction } from 'prosemirror-state';
-import { Dispatch } from '../event-dispatcher';
-import { Command } from '../types';
-export declare type Reducer<PluginState, Action> = (state: PluginState, action: Action) => PluginState;
-declare type MapState<PluginState> = (tr: ReadonlyTransaction, pluginState: PluginState) => PluginState;
-declare type SafePlugin<PluginState, Action, InitialState extends PluginState> = {
-    createPluginState: (dispatch: Dispatch, initialState: InitialState | ((state: EditorState) => InitialState)) => SafeStateField<PluginState>;
-    createCommand: <A = Action>(action: A | ((state: Readonly<EditorState>) => A | false), transform?: (tr: Transaction, state: EditorState) => Transaction) => Command;
-    getPluginState: (state: EditorState) => PluginState;
-};
-export declare function pluginFactory<PluginState, Action, InitialState extends PluginState>(pluginKey: PluginKey, reducer: Reducer<PluginState, Action>, options?: {
-    mapping?: MapState<PluginState>;
-    onDocChanged?: MapState<PluginState>;
-    onSelectionChanged?: MapState<PluginState>;
-}): SafePlugin<PluginState, Action, InitialState>;
-export {};

package/dist/types-ts4.0/utils/profiler/render-count.d.ts

@@ -1,50 +0,0 @@
-export declare const PROFILER_KEY = "__editorRenderCountProfiler";
-interface ComponentInstanceRenderCounter {
-    instanceId: string;
-    count: number;
-}
-declare type ProfilerData = {
-    enabled: boolean;
-    components?: {
-        [componentId: string]: {
-            [instanceId: string]: {
-                count: number;
-            };
-        };
-    };
-};
-declare type RenderCountProfilerInstanceParams = {
-    store: Object;
-};
-export declare class RenderCountProfiler {
-    /**
-     * The singleton/cached instance of RenderCountProfiler that will be shared
-     * betweenRenderCountProfiler.getInstance() calls
-     */
-    private static instance;
-    private store;
-    private constructor();
-    /**
-     * Returns the singleton/cached instance of RenderCountProfiler that
-     * currently exists. If it hasn't been instantiated yet, the singleton
-     * instance will be created using the given params. Returns the latest
-     * singleton/instance.
-     */
-    static getInstance(params: RenderCountProfilerInstanceParams): RenderCountProfiler;
-    getData(profilerKey: typeof PROFILER_KEY): ProfilerData | void;
-    enable(): void;
-    remove(): void;
-    isEnabled(): boolean;
-    setRenderCount({ componentId, renderCount, instanceId, }: {
-        componentId: string;
-        renderCount: number;
-        instanceId: string;
-    }): void;
-    getInstanceRenderCounters({ componentId, }: {
-        componentId: string;
-    }): ComponentInstanceRenderCounter[];
-    getRenderCount({ componentId }: {
-        componentId: string;
-    }): number;
-}
-export {};

package/dist/types-ts4.0/utils/should-force-tracking.d.ts

@@ -1 +0,0 @@
-export declare const shouldForceTracking: () => boolean;

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

@@ -1,11 +0,0 @@
-import { Fragment, Node, Slice } from 'prosemirror-model';
-/**
- * A helper to get the underlying array of a fragment.
- */
-export declare function getFragmentBackingArray(fragment: Fragment): ReadonlyArray<Node>;
-export declare function mapFragment(content: Fragment, callback: (node: Node, parent: Node | null, index: number) => Node | Node[] | Fragment | null, parent?: Node | null): Fragment<any>;
-export declare function mapSlice(slice: Slice, callback: (node: Node, parent: Node | null, index: number) => Node | Node[] | Fragment | null): Slice;
-export declare type FlatMapCallback = (node: Node, index: number, fragment: Fragment) => Node | Node[];
-export declare function flatmap(fragment: Fragment, callback: FlatMapCallback): Fragment;
-export declare type MapWithCallback<T> = (node: Node, index: number, fragment: Fragment) => T;
-export declare function mapChildren<T>(node: Node | Fragment, callback: MapWithCallback<T>): Array<T>;

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

@@ -1,4 +0,0 @@
-import { Node as PmNode } from 'prosemirror-model';
-export declare function calcTableColumnWidths(node: PmNode): number[];
-export declare function hasMergedCell(tableNode: PmNode): boolean;
-export declare function convertProsemirrorTableNodeToArrayOfRows(tableNode: PmNode): Array<Array<PmNode | null>>;

package/dist/types-ts4.0/utils/track-unsupported-content.d.ts

@@ -1,8 +0,0 @@
-import { Node as PMNode, Schema } from 'prosemirror-model';
-import { ACTION_SUBJECT_ID, UnsupportedContentPayload, UnsupportedContentTooltipPayload } from './analytics';
-declare type DispatchAnalyticsEvent = (payload: UnsupportedContentPayload) => void;
-declare type DispatchAnalyticsEventTooltip = (payload: UnsupportedContentTooltipPayload) => void;
-export declare const findAndTrackUnsupportedContentNodes: (node: PMNode, schema: Schema, dispatchAnalyticsEvent: DispatchAnalyticsEvent, ancestorHierarchy?: string) => void;
-export declare const fireUnsupportedEvent: (dispatchAnalyticsEvent: DispatchAnalyticsEvent, actionSubjectId: ACTION_SUBJECT_ID, unsupportedNode?: {}, errorCode?: string | undefined) => void;
-export declare const trackUnsupportedContentTooltipDisplayedFor: (dispatchAnalyticsEvent: DispatchAnalyticsEventTooltip, unsupportedContentType: UnsupportedContentTooltipPayload['actionSubjectId'], originalNodeType?: string | undefined) => void;
-export {};

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

@@ -1,9 +0,0 @@
-export declare type SubscriberCallback = (node: any) => void;
-declare class ADFTraversor {
-    private doc;
-    private subscribers;
-    constructor(doc: any);
-    subscribe(type: string, callback: SubscriberCallback): void;
-    exec(): void;
-}
-export default ADFTraversor;

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

@@ -1,2 +0,0 @@
-export declare type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
-export declare type Diff<T, K> = Omit<T, keyof K>;

package/dist/types-ts4.0/utils/unsupportedContent/get-unsupported-content-level-data.d.ts

@@ -1,57 +0,0 @@
-import type { ADFEntity } from '@atlaskit/adf-utils/types';
-export declare enum UNSUPPORTED_CONTENT_LEVEL_SEVERITY {
-    NORMAL = "normal",
-    DEGRADED = "degraded",
-    BLOCKING = "blocking"
-}
-declare type UnsupportedContentLevelThresholds = {
-    blocking: number;
-    degraded: number;
-};
-export declare type UnsupportedContentLevelsTracking = {
-    enabled: boolean;
-    thresholds?: Partial<UnsupportedContentLevelThresholds>;
-    samplingRates?: {
-        [key: string]: number;
-    };
-};
-export declare const UNSUPPORTED_CONTENT_LEVEL_SEVERITY_THRESHOLD_DEFAULTS: {
-    DEGRADED: number;
-    BLOCKING: number;
-};
-/**
- * When given a valid ADF document, this function will return an information
- * object about the level of unsupported content in the document including:
- *
- * - counts: an object with the unsupportedNodes count and supportedNodes count.
- * - percentage: the percentage of unsupported nodes in the document relative to the rest
- * of the document content
- * - severity: The percentage mapped to a string value. This string will be either
- * "normal", "degraded" or "blocking" based on the threshold rules. (For e.g. if
- * `customThresholds = { degraded: 10, blocking: 30 }`, then a document with 9%
- * unsupported content will map to "normal", a document with 14% unsupported content
- * will map to "degraded" and a document with 33% unsupported content will map to "blocking".)
- *
- * **Example usage**
- *
- * ```
- * const exampleAdf = { type: 'doc', version: 1, content: [...] };
- * const customThresholds = { degraded: 30, blocking: 50 };
- * const data = getUnsupportedContentLevelData(exampleAdf, customThresholds);
- *
- * console.log(data.severity); // "normal"
- * console.log(data.counts.percentage); // 28
- * console.log(data.counts.unsupportedNodes); // 50
- * console.log(data.counts.supportedNodes); // 129
- * ```
- *
- */
-export declare const getUnsupportedContentLevelData: (validDocument: ADFEntity, customThresholds: UnsupportedContentLevelsTracking['thresholds']) => {
-    severity: UNSUPPORTED_CONTENT_LEVEL_SEVERITY;
-    percentage: number;
-    counts: {
-        supportedNodes: number;
-        unsupportedNodes: number;
-    };
-};
-export {};

package/dist/types-ts4.0/utils/validate-using-spec.d.ts

@@ -1,19 +0,0 @@
-import { Schema } from 'prosemirror-model';
-import type { ADFEntity } from '@atlaskit/adf-utils/types';
-import type { ErrorCallbackOptions, Validate, ValidationError } from '@atlaskit/adf-utils/validatorTypes';
-export declare const UNSUPPORTED_NODE_ATTRIBUTE = "unsupportedNodeAttribute";
-import { UnsupportedContentPayload } from './analytics';
-export declare type DispatchAnalyticsEvent = (event: UnsupportedContentPayload) => void;
-export declare const validationErrorHandler: (entity: ADFEntity, error: ValidationError, options: ErrorCallbackOptions, marks: string[], validate: Validate, dispatchAnalyticsEvent?: DispatchAnalyticsEvent | undefined) => ADFEntity | {
-    type: string;
-    attrs: {
-        originalValue: ADFEntity;
-    };
-} | undefined;
-export declare const validateADFEntity: (schema: Schema, node: ADFEntity, dispatchAnalyticsEvent?: DispatchAnalyticsEvent | undefined) => ADFEntity;
-export declare function wrapWithUnsupported(originalValue: ADFEntity, type?: 'block' | 'inline' | 'mark'): {
-    type: string;
-    attrs: {
-        originalValue: ADFEntity;
-    };
-};

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

@@ -1,42 +0,0 @@
-import { Mark as PMMark, Schema } from 'prosemirror-model';
-export declare const ADFStages: {
-    readonly FINAL: "final";
-    readonly STAGE_0: "stage0";
-};
-export declare type ADFStage = typeof ADFStages[keyof typeof ADFStages];
-export interface ADDoc {
-    version: 1;
-    type: 'doc';
-    content: ADNode[];
-}
-export interface ADNode {
-    type: string;
-    attrs?: any;
-    content?: ADNode[];
-    marks?: ADMark[];
-    text?: string;
-}
-export interface ADMark {
-    type: string;
-    attrs?: any;
-}
-export interface ADMarkSimple {
-    type: {
-        name: string;
-    };
-    attrs?: any;
-}
-export declare const markOrder: string[];
-export declare const isSubSupType: (type: string) => type is "sub" | "sup";
-export declare const getMarksByOrder: (marks: PMMark[]) => PMMark<any>[];
-export declare const isSameMark: (mark: PMMark | null, otherMark: PMMark | null) => boolean;
-export declare const getValidDocument: (doc: ADDoc, schema?: Schema, adfStage?: ADFStage) => ADDoc | null;
-export declare const getValidContent: (content: ADNode[], schema?: Schema, adfStage?: ADFStage) => ADNode[];
-/**
- * Sanitize unknown node tree
- *
- * @see https://product-fabric.atlassian.net/wiki/spaces/E/pages/11174043/Document+structure#Documentstructure-ImplementationdetailsforHCNGwebrenderer
- */
-export declare const getValidUnknownNode: (node: ADNode) => ADNode;
-export declare const getValidNode: (originalNode: ADNode, schema?: Schema, adfStage?: ADFStage) => ADNode;
-export declare const getValidMark: (mark: ADMark, adfStage?: ADFStage) => ADMark | null;

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

@@ -1,2 +0,0 @@
-export declare const ZERO_WIDTH_SPACE = "\u200B";
-export declare const ZERO_WIDTH_JOINER = "\u200D";

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

@@ -1,2 +0,0 @@
-export { getMarksByOrder, getValidContent, getValidDocument, getValidMark, getValidNode, getValidUnknownNode, isSameMark, isSubSupType, markOrder, ADFStages, } from './utils/validator';
-export type { ADDoc, ADFStage, ADMark, ADMarkSimple, ADNode, } from './utils/validator';

package/dist/types-ts4.0/with-plugin-state/index.d.ts

@@ -1,86 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import { PluginKey } from 'prosemirror-state';
-import { EditorView } from 'prosemirror-view';
-import type { EventDispatcher } from '../event-dispatcher';
-import type { NamedPluginKeys, NamedPluginStates } from './types';
-export declare type PerformanceOptions = {
-    samplingRate: number;
-    slowThreshold: number;
-    trackingEnabled: boolean;
-};
-export interface State {
-    [name: string]: any;
-}
-declare type ContextUpdateHandler = (editorView: EditorView, eventDispatcher: EventDispatcher) => void;
-declare type EditorActionsPrivateAccess = {
-    _privateGetEditorView: () => EditorView;
-    _privateGetEventDispatcher: () => EventDispatcher;
-    _privateSubscribe: (cb: ContextUpdateHandler) => void;
-    _privateUnsubscribe: (cb: ContextUpdateHandler) => void;
-};
-declare type EditorSharedConfigPrivateAccess = {
-    editorView: EditorView;
-    eventDispatcher: EventDispatcher;
-};
-export declare type PluginsConfig = {
-    [name: string]: PluginKey;
-};
-declare type Context = {
-    editorActions?: EditorActionsPrivateAccess;
-    editorSharedConfig?: EditorSharedConfigPrivateAccess;
-};
-export interface Props<P extends NamedPluginKeys> {
-    debounce?: boolean;
-    eventDispatcher?: EventDispatcher;
-    editorView?: EditorView;
-    plugins: P;
-    render: (pluginState: NamedPluginStates<P>) => React.ReactElement | null;
-}
-/**
- * Wraps component in a high order component that watches state changes of given plugins
- * and passes those states to the wrapped component.
- *
- * Example:
- * <WithPluginState
- *   eventDispatcher={eventDispatcher}
- *   editorView={editorView}
- *   plugins={{
- *     hyperlink: hyperlinkPluginKey
- *   }}
- *   render={renderComponent}
- * />
- *
- * renderComponent: ({ hyperlink }) => React.Component;
- */
-declare class WithPluginState<P extends NamedPluginKeys> extends React.Component<Props<P>, State> {
-    static displayName: string;
-    private listeners;
-    private debounce;
-    private notAppliedState;
-    private isSubscribed;
-    static contextTypes: {
-        editorActions: PropTypes.Requireable<object>;
-        editorSharedConfig: PropTypes.Requireable<object>;
-    };
-    context: Context;
-    state: NamedPluginStates<P>;
-    private getEditorView;
-    private getEventDispatcher;
-    private handlePluginStateChange;
-    /**
-     * Debounces setState calls in order to reduce number of re-renders caused by several plugin state changes.
-     */
-    private updateState;
-    private getPluginsStates;
-    private subscribe;
-    private unsubscribe;
-    private onContextUpdate;
-    private subscribeToContextUpdates;
-    private unsubscribeFromContextUpdates;
-    componentDidMount(): void;
-    UNSAFE_componentWillReceiveProps(nextProps: Props<P>): void;
-    componentWillUnmount(): void;
-    render(): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
-}
-export { WithPluginState };

package/dist/types-ts4.0/with-plugin-state/types.d.ts

@@ -1,10 +0,0 @@
-import { PluginKey } from 'prosemirror-state';
-export declare type NamedPluginKeys = Readonly<{
-    [stateName: string]: PluginKey;
-}>;
-export declare type NamedPluginStates<P extends NamedPluginKeys> = Readonly<Partial<{
-    [K in keyof P]: P[K] extends PluginKey<infer T> ? T : never;
-}>>;
-export declare type Writeable<T> = {
-    -readonly [P in keyof T]: T[P];
-};