@atlaskit/editor-common 111.16.2 → 111.16.4

package/dist/esm/performance-ssr-measures/SSRRenderMeasure.js

@@ -0,0 +1,83 @@
+import React, { useCallback, memo, useRef } from 'react';
+import { isSSR } from '../core-utils/is-ssr';
+import { RenderMarker } from './RenderMarker';
+
+/**
+ * Props for SSRRenderMeasure component
+ */
+
+function SSRRenderMeasureImpl(_ref) {
+  var onSSRMeasure = _ref.onSSRMeasure,
+    segmentName = _ref.segmentName,
+    startTimestampRef = _ref.startTimestampRef,
+    children = _ref.children;
+  var wasMeasured = useRef(false);
+  var handleOnRender = useCallback(function () {
+    if (wasMeasured.current) {
+      return;
+    }
+    onSSRMeasure === null || onSSRMeasure === void 0 || onSSRMeasure({
+      segmentName: segmentName,
+      startTimestamp: startTimestampRef.current,
+      endTimestamp: performance.now()
+    });
+    wasMeasured.current = true;
+  }, [onSSRMeasure, segmentName, startTimestampRef]);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, children, /*#__PURE__*/React.createElement(RenderMarker, {
+    onRender: handleOnRender
+  }));
+}
+var SSRRenderMeasureNoOp = /*#__PURE__*/memo(function (_ref2) {
+  var children = _ref2.children;
+  return children;
+});
+
+/**
+ * Component for measuring render performance during Server-Side Rendering (SSR).
+ *
+ * This component wraps content to measure its render duration in SSR mode.
+ * On client builds, it's optimized to a no-op component with zero performance overhead.
+ * On SSR builds, it captures timing data and reports it via the `onSSRMeasure` callback.
+ *
+ * **How it works:**
+ * - Measures from `startTimestampRef.current` (component start) to when `RenderMarker` is rendered
+ * - Uses `RenderMarker` to detect when the render completes successfully
+ * - Only reports the measurement once (protected by `wasMeasured` ref)
+ * - If child components throw errors during render, the measurement will not be reported
+ *
+ * **Usage pattern:**
+ * 1. Create `startTimestampRef` as the **first line** in your component using `useRef(performance.now())`
+ * 2. Wrap your content with `SSRRenderMeasure` at the end of your component
+ * 3. Provide the `onSSRMeasure` callback to receive timing data
+ *
+ * @example
+ * ```tsx
+ * function FullPageEditor({ onSSRMeasure }) {
+ *   // CRITICAL: Must be the first line for accurate timing
+ *   const startTimestampRef = useRef(performance.now());
+ *
+ *   // ...component logic, hooks, etc.
+ *
+ *   return (
+ *     <SSRRenderMeasure
+ *       segmentName="ssr-app/render/fullPageEditor"
+ *       startTimestampRef={startTimestampRef}
+ *       onSSRMeasure={onSSRMeasure}
+ *     >
+ *       <EditorContent />
+ *     </SSRRenderMeasure>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Handling the measurement callback
+ * const handleSSRMeasure = (measure) => {
+ *   const duration = measure.endTimestamp - measure.startTimestamp;
+ *   console.log(`${measure.segmentName} rendered in ${duration}ms`);
+ *   // Send to analytics, logging, etc.
+ * };
+ * ```
+ */
+export var SSRRenderMeasure = isSSR() ? SSRRenderMeasureImpl : SSRRenderMeasureNoOp;

package/dist/esm/performance-ssr-measures/index.js

@@ -0,0 +1,5 @@
+// Disable no-re-export rule for entry point files
+/* eslint-disable @atlaskit/editor/no-re-export */
+
+export { SSRRenderMeasure } from './SSRRenderMeasure';
+export { profileSSROperation } from './profileSSROperation';

package/dist/esm/performance-ssr-measures/profileSSROperation.js

@@ -0,0 +1,59 @@
+import { isSSR } from '../core-utils/is-ssr';
+var profileSSROperationImpl = function profileSSROperationImpl(segmentName, fn, onSSRMeasure) {
+  if (!onSSRMeasure) {
+    return fn();
+  }
+  var startTimestamp = performance.now();
+  try {
+    return fn();
+  } finally {
+    onSSRMeasure({
+      segmentName: segmentName,
+      startTimestamp: startTimestamp,
+      endTimestamp: performance.now()
+    });
+  }
+};
+var profileSSROperationNoOp = function profileSSROperationNoOp(_segmentName, fn, _onSSRMeasure) {
+  return fn();
+};
+
+/**
+ * Profiles a synchronous operation during Server-Side Rendering (SSR).
+ *
+ * This function wraps an operation to measure its execution time in SSR mode.
+ * On client builds, the profiling is optimized away and the function executes normally.
+ * On SSR builds, it captures timing data using `performance.now()` and reports it via the callback.
+ *
+ * **Important notes:**
+ * - Profiling only occurs in SSR mode when `onSSRMeasure` is provided
+ * - Both `startTimestamp` and `endTimestamp` are absolute values from `performance.now()`, not relative times
+ * - Calculate duration as: `endTimestamp - startTimestamp`
+ * - The measurement is guaranteed to be reported even if the function throws an error (via `finally` block)
+ * - On client builds, this function has zero performance overhead
+ *
+ * @param segmentName - Identifier for the operation being measured (e.g., 'ssr-app/render/editor/createSchema')
+ * @param fn - The synchronous function to execute and profile
+ * @param onSSRMeasure - Optional callback to receive performance measurements
+ * @param onSSRMeasure.segmentName - Name of the measured segment
+ * @param onSSRMeasure.startTimestamp - Absolute timestamp when the operation started (from `performance.now()`)
+ * @param onSSRMeasure.endTimestamp - Absolute timestamp when the operation completed (from `performance.now()`)
+ *
+ * @returns The result of the executed function
+ *
+ * @example
+ * // Profile schema creation during SSR
+ * const schema = profileSSROperation(
+ *   'ssr-app/render/editor/createSchema',
+ *   () => createSchema(config),
+ *   (measure) => {
+ *     const duration = measure.endTimestamp - measure.startTimestamp;
+ *     console.log(`${measure.segmentName}: ${duration}ms`);
+ *   }
+ * );
+ *
+ * @example
+ * // Without callback, executes normally
+ * const result = profileSSROperation('operation', () => expensiveCalculation());
+ */
+export var profileSSROperation = isSSR() ? profileSSROperationImpl : profileSSROperationNoOp;

package/dist/esm/provider-helpers/combine-providers.js

@@ -1,6 +1,7 @@
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { fg } from '@atlaskit/platform-feature-flags';
 import { getOnlyFulfilled, waitForAllPromises, waitForFirstFulfilledPromise } from './promise-helpers';
 var flatten = function flatten(arr) {
   var _ref;
@@ -27,8 +28,16 @@ export default (function (providers) {
             }));
           case 2:
             results = _context.sent;
+            if (fg('platform_editor_fix_getautoconverter_null_error')) {
+              _context.next = 5;
+              break;
+            }
             return _context.abrupt("return", getOnlyFulfilled(results));
-          case 4:
+          case 5:
+            return _context.abrupt("return", getOnlyFulfilled(results).filter(function (provider) {
+              return provider != null;
+            }));
+          case 6:
           case "end":
             return _context.stop();
         }

package/dist/esm/ui/DropList/index.js

@@ -21,7 +21,7 @@ import withAnalyticsEvents from '@atlaskit/analytics-next/withAnalyticsEvents';
 import { fg } from '@atlaskit/platform-feature-flags';
 import Layer from '../Layer';
 var packageName = "@atlaskit/editor-common";
-var packageVersion = "0.0.0-development";
+var packageVersion = "111.16.4";
 var halfFocusRing = 1;
 var dropOffset = '0, 8';
 var fadeIn = keyframes({

package/dist/esm/utils/index.js

@@ -120,7 +120,7 @@ export { isPerformanceAPIAvailable, isPerformanceObserverAvailable } from './per
  *
  * Private API - should not be used. Use `@atlaskit/editor-common/performance/navigation` if required.
  */
-export { getResponseEndTime } from './performance/navigation';
+export { getRequestToResponseTime, getResponseEndTime } from './performance/navigation';
 export { getExtensionRenderer } from './extension-handler';
 export { hasMergedCell, getColumnWidths, calcTableColumnWidths, convertProsemirrorTableNodeToArrayOfRows, isPositionNearTableRow } from './table';
 export { createCompareNodes } from './compareNodes';

package/dist/esm/utils/performance/navigation.js

@@ -8,4 +8,14 @@ export function getResponseEndTime() {
     return nav.responseEnd;
   }
   return;
+}
+export function getRequestToResponseTime() {
+  if (!isPerformanceAPIAvailable()) {
+    return;
+  }
+  var nav = performance.getEntriesByType('navigation')[0];
+  if (nav) {
+    return nav.responseEnd - nav.requestStart;
+  }
+  return;
 }

package/dist/types/analytics/types/block-menu-events.d.ts

@@ -27,10 +27,9 @@ interface ElementTransformErrorAttr {
     errorStack?: string;
     from: string;
     inputMethod: INPUT_METHOD.BLOCK_MENU;
-    position: number;
     selection: SelectionJson;
     to: string;
-    triggeredFrom: INPUT_METHOD.MOUSE | INPUT_METHOD.KEYBOARD;
+    triggeredFrom?: INPUT_METHOD.MOUSE | INPUT_METHOD.KEYBOARD;
 }
 export type ElementTransformErrorAEP = OperationalAEP<ACTION.ERRORED, ACTION_SUBJECT.ELEMENT, ACTION_SUBJECT_ID.TRANSFORM, ElementTransformErrorAttr>;
 interface ElementTransformAttr {

package/dist/types/messages/syncBlock.d.ts

@@ -384,4 +384,14 @@ export declare const syncBlockMessages: {
         defaultMessage: string;
         description: string;
     };
+    inlineExtensionInSyncBlockTitle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    inlineExtensionInSyncBlockDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
 };

package/dist/types/performance-ssr-measures/RenderMarker.d.ts

@@ -0,0 +1,5 @@
+interface RenderMarkerProps {
+    onRender?: () => void;
+}
+export declare function RenderMarker({ onRender }: RenderMarkerProps): null;
+export {};

package/dist/types/performance-ssr-measures/SSRRenderMeasure.d.ts

@@ -0,0 +1,114 @@
+import React, { type ReactNode } from 'react';
+/**
+ * Props for SSRRenderMeasure component
+ */
+interface SSRRenderMeasureProps {
+    children?: ReactNode;
+    /**
+     * Callback invoked during Server-Side Rendering (SSR) to measure and track performance metrics.
+     * Provides timing information for the render duration of the measured component.
+     *
+     * @param measure.segmentName - Name identifier of the measured segment
+     * @param measure.startTimestamp - Absolute timestamp when rendering started (from `performance.now()`)
+     * @param measure.endTimestamp - Absolute timestamp when rendering completed (from `performance.now()`)
+     *
+     * **Note:** Both timestamps are absolute values from `performance.now()`, not relative times.
+     * Calculate duration as: `measure.endTimestamp - measure.startTimestamp`
+     *
+     * Optional - if not provided, the component renders without measurement.
+     */
+    onSSRMeasure?: (measure: {
+        endTimestamp: number;
+        segmentName: string;
+        startTimestamp: number;
+    }) => void;
+    /**
+     * The name identifier of the component being measured for tracing.
+     *
+     * @example 'ssr-app/render/fullPageEditor'
+     */
+    segmentName: string;
+    /**
+     * Reference to the start timestamp of the component render.
+     *
+     * **CRITICAL:** Must be created using `useRef(performance.now())` as the **first line**
+     * in the component being profiled to capture the most accurate start time.
+     *
+     * Using a ref (instead of state or regular variable) is essential to:
+     * - Avoid triggering re-renders
+     * - Preserve the initial timestamp across component lifecycle
+     * - Ensure measurement accuracy
+     *
+     * @example
+     * ```tsx
+     * function MyComponent() {
+     *   const startTimestampRef = useRef(performance.now()); // MUST be first line
+     *   // ...rest of component logic
+     *
+     *   return (
+     *     <SSRRenderMeasure
+     *       segmentName="ssr-app/render/myComponent"
+     *       startTimestampRef={startTimestampRef}
+     *       onSSRMeasure={handleMeasure}
+     *     >
+     *       {content}
+     *     </SSRRenderMeasure>
+     *   );
+     * }
+     * ```
+     */
+    startTimestampRef: {
+        current: number;
+    };
+}
+declare function SSRRenderMeasureImpl({ onSSRMeasure, segmentName, startTimestampRef, children, }: SSRRenderMeasureProps): React.JSX.Element;
+/**
+ * Component for measuring render performance during Server-Side Rendering (SSR).
+ *
+ * This component wraps content to measure its render duration in SSR mode.
+ * On client builds, it's optimized to a no-op component with zero performance overhead.
+ * On SSR builds, it captures timing data and reports it via the `onSSRMeasure` callback.
+ *
+ * **How it works:**
+ * - Measures from `startTimestampRef.current` (component start) to when `RenderMarker` is rendered
+ * - Uses `RenderMarker` to detect when the render completes successfully
+ * - Only reports the measurement once (protected by `wasMeasured` ref)
+ * - If child components throw errors during render, the measurement will not be reported
+ *
+ * **Usage pattern:**
+ * 1. Create `startTimestampRef` as the **first line** in your component using `useRef(performance.now())`
+ * 2. Wrap your content with `SSRRenderMeasure` at the end of your component
+ * 3. Provide the `onSSRMeasure` callback to receive timing data
+ *
+ * @example
+ * ```tsx
+ * function FullPageEditor({ onSSRMeasure }) {
+ *   // CRITICAL: Must be the first line for accurate timing
+ *   const startTimestampRef = useRef(performance.now());
+ *
+ *   // ...component logic, hooks, etc.
+ *
+ *   return (
+ *     <SSRRenderMeasure
+ *       segmentName="ssr-app/render/fullPageEditor"
+ *       startTimestampRef={startTimestampRef}
+ *       onSSRMeasure={onSSRMeasure}
+ *     >
+ *       <EditorContent />
+ *     </SSRRenderMeasure>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Handling the measurement callback
+ * const handleSSRMeasure = (measure) => {
+ *   const duration = measure.endTimestamp - measure.startTimestamp;
+ *   console.log(`${measure.segmentName} rendered in ${duration}ms`);
+ *   // Send to analytics, logging, etc.
+ * };
+ * ```
+ */
+export declare const SSRRenderMeasure: React.MemoExoticComponent<({ children }: SSRRenderMeasureProps) => React.ReactNode> | typeof SSRRenderMeasureImpl;
+export {};

package/dist/types/performance-ssr-measures/index.d.ts

@@ -0,0 +1,2 @@
+export { SSRRenderMeasure } from './SSRRenderMeasure';
+export { profileSSROperation } from './profileSSROperation';

package/dist/types/performance-ssr-measures/profileSSROperation.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Profiles a synchronous operation during Server-Side Rendering (SSR).
+ *
+ * This function wraps an operation to measure its execution time in SSR mode.
+ * On client builds, the profiling is optimized away and the function executes normally.
+ * On SSR builds, it captures timing data using `performance.now()` and reports it via the callback.
+ *
+ * **Important notes:**
+ * - Profiling only occurs in SSR mode when `onSSRMeasure` is provided
+ * - Both `startTimestamp` and `endTimestamp` are absolute values from `performance.now()`, not relative times
+ * - Calculate duration as: `endTimestamp - startTimestamp`
+ * - The measurement is guaranteed to be reported even if the function throws an error (via `finally` block)
+ * - On client builds, this function has zero performance overhead
+ *
+ * @param segmentName - Identifier for the operation being measured (e.g., 'ssr-app/render/editor/createSchema')
+ * @param fn - The synchronous function to execute and profile
+ * @param onSSRMeasure - Optional callback to receive performance measurements
+ * @param onSSRMeasure.segmentName - Name of the measured segment
+ * @param onSSRMeasure.startTimestamp - Absolute timestamp when the operation started (from `performance.now()`)
+ * @param onSSRMeasure.endTimestamp - Absolute timestamp when the operation completed (from `performance.now()`)
+ *
+ * @returns The result of the executed function
+ *
+ * @example
+ * // Profile schema creation during SSR
+ * const schema = profileSSROperation(
+ *   'ssr-app/render/editor/createSchema',
+ *   () => createSchema(config),
+ *   (measure) => {
+ *     const duration = measure.endTimestamp - measure.startTimestamp;
+ *     console.log(`${measure.segmentName}: ${duration}ms`);
+ *   }
+ * );
+ *
+ * @example
+ * // Without callback, executes normally
+ * const result = profileSSROperation('operation', () => expensiveCalculation());
+ */
+export declare const profileSSROperation: <T>(segmentName: string, fn: () => T, onSSRMeasure?: (measure: {
+    endTimestamp: number;
+    segmentName: string;
+    startTimestamp: number;
+}) => void) => T;

package/dist/types/utils/index.d.ts

@@ -126,7 +126,7 @@ export { isPerformanceAPIAvailable, isPerformanceObserverAvailable, } from './pe
  *
  * Private API - should not be used. Use `@atlaskit/editor-common/performance/navigation` if required.
  */
-export { getResponseEndTime } from './performance/navigation';
+export { getRequestToResponseTime, getResponseEndTime } from './performance/navigation';
 export { getExtensionRenderer } from './extension-handler';
 export { hasMergedCell, getColumnWidths, calcTableColumnWidths, convertProsemirrorTableNodeToArrayOfRows, isPositionNearTableRow, } from './table';
 export { createCompareNodes } from './compareNodes';

package/dist/types/utils/performance/navigation.d.ts

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

package/dist/types-ts4.5/analytics/types/block-menu-events.d.ts

@@ -27,10 +27,9 @@ interface ElementTransformErrorAttr {
     errorStack?: string;
     from: string;
     inputMethod: INPUT_METHOD.BLOCK_MENU;
-    position: number;
     selection: SelectionJson;
     to: string;
-    triggeredFrom: INPUT_METHOD.MOUSE | INPUT_METHOD.KEYBOARD;
+    triggeredFrom?: INPUT_METHOD.MOUSE | INPUT_METHOD.KEYBOARD;
 }
 export type ElementTransformErrorAEP = OperationalAEP<ACTION.ERRORED, ACTION_SUBJECT.ELEMENT, ACTION_SUBJECT_ID.TRANSFORM, ElementTransformErrorAttr>;
 interface ElementTransformAttr {

package/dist/types-ts4.5/messages/syncBlock.d.ts

@@ -384,4 +384,14 @@ export declare const syncBlockMessages: {
         defaultMessage: string;
         description: string;
     };
+    inlineExtensionInSyncBlockTitle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    inlineExtensionInSyncBlockDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
 };

package/dist/types-ts4.5/performance-ssr-measures/RenderMarker.d.ts

@@ -0,0 +1,5 @@
+interface RenderMarkerProps {
+    onRender?: () => void;
+}
+export declare function RenderMarker({ onRender }: RenderMarkerProps): null;
+export {};

package/dist/types-ts4.5/performance-ssr-measures/SSRRenderMeasure.d.ts

@@ -0,0 +1,114 @@
+import React, { type ReactNode } from 'react';
+/**
+ * Props for SSRRenderMeasure component
+ */
+interface SSRRenderMeasureProps {
+    children?: ReactNode;
+    /**
+     * Callback invoked during Server-Side Rendering (SSR) to measure and track performance metrics.
+     * Provides timing information for the render duration of the measured component.
+     *
+     * @param measure.segmentName - Name identifier of the measured segment
+     * @param measure.startTimestamp - Absolute timestamp when rendering started (from `performance.now()`)
+     * @param measure.endTimestamp - Absolute timestamp when rendering completed (from `performance.now()`)
+     *
+     * **Note:** Both timestamps are absolute values from `performance.now()`, not relative times.
+     * Calculate duration as: `measure.endTimestamp - measure.startTimestamp`
+     *
+     * Optional - if not provided, the component renders without measurement.
+     */
+    onSSRMeasure?: (measure: {
+        endTimestamp: number;
+        segmentName: string;
+        startTimestamp: number;
+    }) => void;
+    /**
+     * The name identifier of the component being measured for tracing.
+     *
+     * @example 'ssr-app/render/fullPageEditor'
+     */
+    segmentName: string;
+    /**
+     * Reference to the start timestamp of the component render.
+     *
+     * **CRITICAL:** Must be created using `useRef(performance.now())` as the **first line**
+     * in the component being profiled to capture the most accurate start time.
+     *
+     * Using a ref (instead of state or regular variable) is essential to:
+     * - Avoid triggering re-renders
+     * - Preserve the initial timestamp across component lifecycle
+     * - Ensure measurement accuracy
+     *
+     * @example
+     * ```tsx
+     * function MyComponent() {
+     *   const startTimestampRef = useRef(performance.now()); // MUST be first line
+     *   // ...rest of component logic
+     *
+     *   return (
+     *     <SSRRenderMeasure
+     *       segmentName="ssr-app/render/myComponent"
+     *       startTimestampRef={startTimestampRef}
+     *       onSSRMeasure={handleMeasure}
+     *     >
+     *       {content}
+     *     </SSRRenderMeasure>
+     *   );
+     * }
+     * ```
+     */
+    startTimestampRef: {
+        current: number;
+    };
+}
+declare function SSRRenderMeasureImpl({ onSSRMeasure, segmentName, startTimestampRef, children, }: SSRRenderMeasureProps): React.JSX.Element;
+/**
+ * Component for measuring render performance during Server-Side Rendering (SSR).
+ *
+ * This component wraps content to measure its render duration in SSR mode.
+ * On client builds, it's optimized to a no-op component with zero performance overhead.
+ * On SSR builds, it captures timing data and reports it via the `onSSRMeasure` callback.
+ *
+ * **How it works:**
+ * - Measures from `startTimestampRef.current` (component start) to when `RenderMarker` is rendered
+ * - Uses `RenderMarker` to detect when the render completes successfully
+ * - Only reports the measurement once (protected by `wasMeasured` ref)
+ * - If child components throw errors during render, the measurement will not be reported
+ *
+ * **Usage pattern:**
+ * 1. Create `startTimestampRef` as the **first line** in your component using `useRef(performance.now())`
+ * 2. Wrap your content with `SSRRenderMeasure` at the end of your component
+ * 3. Provide the `onSSRMeasure` callback to receive timing data
+ *
+ * @example
+ * ```tsx
+ * function FullPageEditor({ onSSRMeasure }) {
+ *   // CRITICAL: Must be the first line for accurate timing
+ *   const startTimestampRef = useRef(performance.now());
+ *
+ *   // ...component logic, hooks, etc.
+ *
+ *   return (
+ *     <SSRRenderMeasure
+ *       segmentName="ssr-app/render/fullPageEditor"
+ *       startTimestampRef={startTimestampRef}
+ *       onSSRMeasure={onSSRMeasure}
+ *     >
+ *       <EditorContent />
+ *     </SSRRenderMeasure>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Handling the measurement callback
+ * const handleSSRMeasure = (measure) => {
+ *   const duration = measure.endTimestamp - measure.startTimestamp;
+ *   console.log(`${measure.segmentName} rendered in ${duration}ms`);
+ *   // Send to analytics, logging, etc.
+ * };
+ * ```
+ */
+export declare const SSRRenderMeasure: React.MemoExoticComponent<({ children }: SSRRenderMeasureProps) => React.ReactNode> | typeof SSRRenderMeasureImpl;
+export {};

package/dist/types-ts4.5/performance-ssr-measures/index.d.ts

@@ -0,0 +1,2 @@
+export { SSRRenderMeasure } from './SSRRenderMeasure';
+export { profileSSROperation } from './profileSSROperation';

package/dist/types-ts4.5/performance-ssr-measures/profileSSROperation.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Profiles a synchronous operation during Server-Side Rendering (SSR).
+ *
+ * This function wraps an operation to measure its execution time in SSR mode.
+ * On client builds, the profiling is optimized away and the function executes normally.
+ * On SSR builds, it captures timing data using `performance.now()` and reports it via the callback.
+ *
+ * **Important notes:**
+ * - Profiling only occurs in SSR mode when `onSSRMeasure` is provided
+ * - Both `startTimestamp` and `endTimestamp` are absolute values from `performance.now()`, not relative times
+ * - Calculate duration as: `endTimestamp - startTimestamp`
+ * - The measurement is guaranteed to be reported even if the function throws an error (via `finally` block)
+ * - On client builds, this function has zero performance overhead
+ *
+ * @param segmentName - Identifier for the operation being measured (e.g., 'ssr-app/render/editor/createSchema')
+ * @param fn - The synchronous function to execute and profile
+ * @param onSSRMeasure - Optional callback to receive performance measurements
+ * @param onSSRMeasure.segmentName - Name of the measured segment
+ * @param onSSRMeasure.startTimestamp - Absolute timestamp when the operation started (from `performance.now()`)
+ * @param onSSRMeasure.endTimestamp - Absolute timestamp when the operation completed (from `performance.now()`)
+ *
+ * @returns The result of the executed function
+ *
+ * @example
+ * // Profile schema creation during SSR
+ * const schema = profileSSROperation(
+ *   'ssr-app/render/editor/createSchema',
+ *   () => createSchema(config),
+ *   (measure) => {
+ *     const duration = measure.endTimestamp - measure.startTimestamp;
+ *     console.log(`${measure.segmentName}: ${duration}ms`);
+ *   }
+ * );
+ *
+ * @example
+ * // Without callback, executes normally
+ * const result = profileSSROperation('operation', () => expensiveCalculation());
+ */
+export declare const profileSSROperation: <T>(segmentName: string, fn: () => T, onSSRMeasure?: (measure: {
+    endTimestamp: number;
+    segmentName: string;
+    startTimestamp: number;
+}) => void) => T;

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

@@ -126,7 +126,7 @@ export { isPerformanceAPIAvailable, isPerformanceObserverAvailable, } from './pe
  *
  * Private API - should not be used. Use `@atlaskit/editor-common/performance/navigation` if required.
  */
-export { getResponseEndTime } from './performance/navigation';
+export { getRequestToResponseTime, getResponseEndTime } from './performance/navigation';
 export { getExtensionRenderer } from './extension-handler';
 export { hasMergedCell, getColumnWidths, calcTableColumnWidths, convertProsemirrorTableNodeToArrayOfRows, isPositionNearTableRow, } from './table';
 export { createCompareNodes } from './compareNodes';

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

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