@atlaskit/editor-common 111.16.1 → 111.16.4

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;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-common",
-	"version": "111.16.1",
+	"version": "111.16.4",
 	"description": "A package that contains common classes and components for editor and renderer",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/"
@@ -70,18 +70,18 @@
 		"@atlaskit/platform-feature-flags-react": "^0.4.0",
 		"@atlaskit/popper": "^7.1.0",
 		"@atlaskit/primitives": "^18.0.0",
-		"@atlaskit/profilecard": "^24.36.0",
+		"@atlaskit/profilecard": "^24.37.0",
 		"@atlaskit/prosemirror-history": "^0.2.0",
 		"@atlaskit/react-ufo": "^5.2.0",
 		"@atlaskit/section-message": "^8.12.0",
-		"@atlaskit/smart-card": "^43.24.0",
+		"@atlaskit/smart-card": "^43.25.0",
 		"@atlaskit/smart-user-picker": "^9.0.0",
 		"@atlaskit/spinner": "^19.0.0",
 		"@atlaskit/status": "^3.1.0",
 		"@atlaskit/task-decision": "^19.2.0",
 		"@atlaskit/textfield": "^8.2.0",
 		"@atlaskit/theme": "^21.0.0",
-		"@atlaskit/tmp-editor-statsig": "^25.7.0",
+		"@atlaskit/tmp-editor-statsig": "^27.1.0",
 		"@atlaskit/tokens": "^11.0.0",
 		"@atlaskit/tooltip": "^20.14.0",
 		"@atlaskit/width-detector": "^5.0.0",
@@ -222,6 +222,9 @@
 		"platform_editor_fix_unsubscribe_of_provider": {
 			"type": "boolean"
 		},
+		"platform_editor_fix_getautoconverter_null_error": {
+			"type": "boolean"
+		},
 		"platform_editor_legacy_content_macro_visual_update": {
 			"type": "boolean"
 		},

package/performance/ssr-measures/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@atlaskit/editor-common/performance/ssr-measures",
+  "main": "../../dist/cjs/performance-ssr-measures/index.js",
+  "module": "../../dist/esm/performance-ssr-measures/index.js",
+  "module:es2019": "../../dist/es2019/performance-ssr-measures/index.js",
+  "sideEffects": [
+    "**/*.compiled.css"
+  ],
+  "types": "../../dist/types/performance-ssr-measures/index.d.ts",
+  "typesVersions": {
+    ">=4.5 <5.9": {
+      "*": [
+        "../../dist/types-ts4.5/performance-ssr-measures/index.d.ts"
+      ]
+    }
+  }
+}