@atlaskit/editor-common 76.9.0 → 76.9.2

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

@@ -0,0 +1,52 @@
+type DistortedDurationMonitor = {
+    distortedDuration: boolean;
+    cleanup: () => void;
+};
+/**
+ * Monitors if a pages enters a visibility state which will lead to
+ * distorted duration measurements (where the measurement uses the
+ * requestAnimationFrame api).
+ */
+export declare const getDistortedDurationMonitor: () => DistortedDurationMonitor;
+/**
+ * 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;
+export {};

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

@@ -0,0 +1,14 @@
+import { SEVERITY } from '../analytics';
+export declare function measureTTI(onMeasureComplete: (tti: number, ttiFromInvocation: number, canceled: boolean, distortedDuration: 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, ttiSeverityNormalThreshold?: number, ttiSeverityDegradedThreshold?: number, ttiFromInvocationSeverityNormalThreshold?: number, ttiFromInvocationSeverityDegradedThreshold?: number): {
+    ttiSeverity: SEVERITY;
+    ttiFromInvocationSeverity: SEVERITY;
+};

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

@@ -0,0 +1,3 @@
+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.5/utils/performance/navigation.d.ts

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

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

@@ -0,0 +1,16 @@
+import type { EditorState, PluginKey, ReadonlyTransaction, SafeStateField, Transaction } from '@atlaskit/editor-prosemirror/state';
+import { Dispatch } from '../event-dispatcher';
+import { Command } from '../types';
+export type Reducer<PluginState, Action> = (state: PluginState, action: Action) => PluginState;
+type MapState<PluginState> = (tr: ReadonlyTransaction, pluginState: PluginState, editorState: EditorState) => PluginState;
+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.5/utils/profiler/render-count.d.ts

@@ -0,0 +1,50 @@
+export declare const PROFILER_KEY = "__editorRenderCountProfiler";
+interface ComponentInstanceRenderCounter {
+    instanceId: string;
+    count: number;
+}
+type ProfilerData = {
+    enabled: boolean;
+    components?: {
+        [componentId: string]: {
+            [instanceId: string]: {
+                count: number;
+            };
+        };
+    };
+};
+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.5/utils/prosemirror/autojoin.d.ts

@@ -0,0 +1,13 @@
+import type { Node } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+/**
+ * Checks whether two adjacent nodes can be joined. If so, the document
+ * will be updated to join those nodes. If not, the original transaction
+ * remains untouched.
+ *
+ * Nodes are considered joinable if the `isJoinable` predicate returns true or,
+ * if an array of strings was passed, if their node type name is in that array.
+ *
+ * Adapted from https://github.com/ProseMirror/prosemirror-commands/blob/master/src/commands.js#L597-L610
+ */
+export declare function autoJoinTr(tr: Transaction, isJoinable: ((before: Node, after: Node) => boolean) | string[]): void;

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

@@ -0,0 +1,18 @@
+import type { FragmentAttributes } from '@atlaskit/adf-schema/schema';
+import { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import { ConfirmDialogChildInfo } from '../types';
+type LocalId = FragmentAttributes['localId'];
+type NodeAndTargetLinkages = {
+    readonly localId: LocalId;
+    readonly name: string;
+    readonly node: PMNode;
+    readonly pos: number;
+    readonly targets: LocalId[];
+};
+export declare const isReferencedSource: (state: EditorState, node?: PMNode) => boolean;
+export declare const getConnections: (state: EditorState) => Record<string, NodeAndTargetLinkages>;
+export declare const removeConnectedNodes: (state: EditorState, node?: PMNode) => import("prosemirror-state").Transaction;
+export declare const getChildrenInfo: (state: EditorState, node?: PMNode) => ConfirmDialogChildInfo[];
+export declare const getNodeName: (state: EditorState, node?: PMNode) => string;
+export {};

package/dist/types-ts4.5/utils/rich-media-utils.d.ts

@@ -0,0 +1,9 @@
+import type { RichMediaAttributes, RichMediaLayout } from '@atlaskit/adf-schema';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { SnapPointsProps } from '../types';
+export declare const shouldAddDefaultWrappedWidth: (layout: RichMediaLayout, width?: number, lineLength?: number) => boolean | 0 | undefined;
+export declare const nonWrappedLayouts: RichMediaLayout[];
+export declare const floatingLayouts: string[];
+export declare const isRichMediaInsideOfBlockNode: (view: EditorView, pos: number | boolean) => boolean;
+export declare const alignAttributes: (layout: RichMediaLayout, oldAttrs: RichMediaAttributes, gridSize: number | undefined, originalWidth: number, lineLength?: number) => RichMediaAttributes;
+export declare function calculateSnapPoints({ $pos, akEditorWideLayoutWidth, allowBreakoutSnapPoints, containerWidth, gridSize, gridWidth, insideInlineLike, insideLayout, isVideoFile, lineLength, offsetLeft, wrappedLayout, }: SnapPointsProps): number[];

package/dist/types-ts4.5/utils/scroll-gutter.d.ts

@@ -0,0 +1,3 @@
+export declare const GUTTER_SIZE_IN_PX = 120;
+export declare const GUTTER_SIZE_MOBILE_IN_PX = 36;
+export declare const GUTTER_SELECTOR = "#editor-scroll-gutter";

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

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

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

@@ -0,0 +1,11 @@
+import { Fragment, Node, Slice } from '@atlaskit/editor-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;
+export declare function mapSlice(slice: Slice, callback: (node: Node, parent: Node | null, index: number) => Node | Node[] | Fragment | null): Slice;
+export type FlatMapCallback = (node: Node, index: number, fragment: Fragment) => Node | Node[];
+export declare function flatmap(fragment: Fragment, callback: FlatMapCallback): Fragment;
+export 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.5/utils/table.d.ts

@@ -0,0 +1,5 @@
+import type { Node as PmNode, ResolvedPos, Schema } from '@atlaskit/editor-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>>;
+export declare function isPositionNearTableRow(pos: ResolvedPos, schema: Schema, direction: 'before' | 'after'): boolean;

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

@@ -0,0 +1,20 @@
+import type { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import { ACTION_SUBJECT_ID } from '../analytics';
+import type { UnsupportedContentPayload, UnsupportedContentTooltipPayload } from './analytics';
+type DispatchAnalyticsEvent = (payload: UnsupportedContentPayload) => void;
+type DispatchAnalyticsEventTooltip = (payload: UnsupportedContentTooltipPayload) => void;
+export declare const findAndTrackUnsupportedContentNodes: (node: PMNode, schema: Schema, dispatchAnalyticsEvent: DispatchAnalyticsEvent, ancestorHierarchy?: string) => void;
+interface UnsupportedNode {
+    type: string;
+    ancestry: string;
+    parentType: string;
+    marks: {
+        [key: string]: any;
+    }[];
+    attrs: {
+        [key: string]: any;
+    };
+}
+export declare const fireUnsupportedEvent: (dispatchAnalyticsEvent: DispatchAnalyticsEvent, actionSubjectId: ACTION_SUBJECT_ID, unsupportedNode: UnsupportedNode, errorCode?: string) => void;
+export declare const trackUnsupportedContentTooltipDisplayedFor: (dispatchAnalyticsEvent: DispatchAnalyticsEventTooltip, unsupportedContentType: UnsupportedContentTooltipPayload['actionSubjectId'], originalNodeType?: string) => void;
+export {};

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

@@ -0,0 +1,9 @@
+export 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.5/utils/types.d.ts

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

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

@@ -0,0 +1,57 @@
+import type { ADFEntity } from '@atlaskit/adf-utils/types';
+export declare enum UNSUPPORTED_CONTENT_LEVEL_SEVERITY {
+    NORMAL = "normal",
+    DEGRADED = "degraded",
+    BLOCKING = "blocking"
+}
+type UnsupportedContentLevelThresholds = {
+    blocking: number;
+    degraded: number;
+};
+export 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.5/utils/validate-using-spec.d.ts

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

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

@@ -0,0 +1,42 @@
+import type { Mark as PMMark, Schema } from '@atlaskit/editor-prosemirror/model';
+export declare const ADFStages: {
+    readonly FINAL: "final";
+    readonly STAGE_0: "stage0";
+};
+export 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: readonly PMMark[]) => PMMark[];
+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.5/utils/whitespace.d.ts

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

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

@@ -0,0 +1,9 @@
+import type { NodeType } from '@atlaskit/editor-prosemirror/model';
+import type { Command } from '../types';
+/**
+ * Function will add wrapping node.
+ * 1. If currently selected blocks can be wrapped in the wrapper type it will wrap them.
+ * 2. If current block can not be wrapped inside wrapping block it will create a new block below selection,
+ *  and set selection on it.
+ */
+export declare function wrapSelectionIn(type: NodeType): Command;

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

@@ -0,0 +1,2 @@
+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.5/with-plugin-state/index.d.ts

@@ -0,0 +1,108 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import type { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+import { EventDispatcher } from '../event-dispatcher';
+import type { NamedPluginKeys, NamedPluginStates } from './types';
+export type PerformanceOptions = {
+    samplingRate: number;
+    slowThreshold: number;
+    trackingEnabled: boolean;
+};
+export interface State {
+    [name: string]: any;
+}
+type ContextUpdateHandler = (editorView: EditorView, eventDispatcher: EventDispatcher) => void;
+export type EditorActionsPrivateAccess = {
+    _privateGetEditorView: () => EditorView;
+    _privateGetEventDispatcher: () => EventDispatcher;
+    _privateSubscribe: (cb: ContextUpdateHandler) => void;
+    _privateUnsubscribe: (cb: ContextUpdateHandler) => void;
+};
+type EditorSharedConfigPrivateAccess = {
+    editorView: EditorView;
+    eventDispatcher: EventDispatcher;
+};
+export type PluginsConfig = {
+    [name: string]: PluginKey;
+};
+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;
+}
+/**
+ * @private
+ * @deprecated
+ *
+ * Using this component is deprecated. It should be replaced with `useSharedPluginState`.
+ * This requires having access to the injection API from the plugin itself.
+ *
+ * An example of the refactor with the new hook (using hyperlink as an example) is:
+ *
+ * Before:
+ * ```ts
+ * <WithPluginState
+ *   editorView={editorView}
+ *   plugins={{
+ *     hyperlinkState: hyperlinkPluginKey
+ *   }}
+ *   render={({ hyperlinkState }) =>
+ *     renderComponent({ hyperlinkState })
+ *   }
+ * />
+ * ```
+ *
+ * After:
+ * ```ts
+ * import { useSharedPluginState } from '@atlaskit/editor-common/hooks';
+ * import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+ *
+ * function ComponentWithState(
+ *   api: ExtractInjectionAPI<typeof hyperlinkPlugin> | undefined
+ * ) {
+ *   const { hyperlinkState } = useSharedPluginState(api, ['hyperlink']);
+ *   return renderComponent({ hyperlinkState })
+ * }
+ * ```
+ *
+ */
+declare class WithPluginState<P extends NamedPluginKeys> extends React.Component<Props<P>, State> {
+    static displayName: string;
+    private listeners;
+    private debounce;
+    private notAppliedState;
+    private isSubscribed;
+    private callsCount;
+    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 dispatchAnalyticsEvent;
+    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.5/with-plugin-state/types.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/editor-common",
-  "version": "76.9.0",
+  "version": "76.9.2",
   "description": "A package that contains common classes and components for editor and renderer",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -117,7 +117,7 @@
     "@atlaskit/task-decision": "^17.9.0",
     "@atlaskit/textfield": "^5.6.0",
     "@atlaskit/theme": "^12.6.0",
-    "@atlaskit/tokens": "^1.25.0",
+    "@atlaskit/tokens": "^1.26.0",
     "@atlaskit/tooltip": "^17.8.0",
     "@atlaskit/ufo": "^0.2.0",
     "@atlaskit/width-detector": "^4.1.0",

package/tmp/api-report-tmp.d.ts

@@ -0,0 +1,9 @@
+## API Report File for "@atlaskit/editor-common"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+// (No @packageDocumentation comment for this package)
+
+```