@atlaskit/renderer 108.0.1 → 108.1.0

package/dist/types-ts4.5/ui/annotations/element/mark.d.ts

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import React from 'react';
+import type { OnAnnotationClickPayload } from '@atlaskit/editor-common/types';
+import { AnnotationMarkStates, AnnotationId, AnnotationDataAttributes } from '@atlaskit/adf-schema';
+type MarkComponentProps = {
+    id: AnnotationId;
+    annotationParentIds: AnnotationId[];
+    dataAttributes: AnnotationDataAttributes;
+    state: AnnotationMarkStates | null;
+    hasFocus: boolean;
+    onClick: (props: OnAnnotationClickPayload) => void;
+};
+export declare const MarkComponent: React.FC<MarkComponentProps>;
+export {};

package/dist/types-ts4.5/ui/annotations/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { useHasFocusEvent, useAnnotationClickEvent } from './use-events';
+export { useInlineCommentsFilter } from './use-inline-comments-filter';
+export { useInlineCommentSubscriberContext } from './use-inline-comment-subscriber';

package/dist/types-ts4.5/ui/annotations/hooks/use-events.d.ts

@@ -0,0 +1,18 @@
+import { AnnotationUpdateEmitter } from '@atlaskit/editor-common/types';
+import type { InlineCommentViewComponentProps } from '@atlaskit/editor-common/types';
+import { AnnotationMarkStates, AnnotationId, AnnotationTypes } from '@atlaskit/adf-schema';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+type ListenEventProps = {
+    id: AnnotationId;
+    updateSubscriber: AnnotationUpdateEmitter | null;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+};
+type UseAnnotationUpdateSatteByEventProps = {
+    type: AnnotationTypes;
+    updateSubscriber: AnnotationUpdateEmitter | null;
+};
+export declare const useAnnotationStateByTypeEvent: ({ type, updateSubscriber, }: UseAnnotationUpdateSatteByEventProps) => Record<string, AnnotationMarkStates | null>;
+export declare const useHasFocusEvent: ({ id, updateSubscriber, }: ListenEventProps) => boolean;
+type AnnotationsWithClickTarget = Pick<InlineCommentViewComponentProps, 'annotations' | 'clickElementTarget'> | null;
+export declare const useAnnotationClickEvent: (props: Pick<ListenEventProps, 'updateSubscriber' | 'createAnalyticsEvent'>) => AnnotationsWithClickTarget;
+export {};

package/dist/types-ts4.5/ui/annotations/hooks/use-inline-comment-subscriber.d.ts

@@ -0,0 +1 @@
+export declare const useInlineCommentSubscriberContext: () => import("@atlaskit/editor-common/types").AnnotationUpdateEmitter | null;

package/dist/types-ts4.5/ui/annotations/hooks/use-inline-comments-filter.d.ts

@@ -0,0 +1,9 @@
+import { AnnotationId, AnnotationMarkStates } from '@atlaskit/adf-schema';
+type Props = {
+    annotationIds: AnnotationId[];
+    filter: {
+        state: AnnotationMarkStates;
+    };
+};
+export declare const useInlineCommentsFilter: ({ annotationIds, filter: { state: stateFilter }, }: Props) => string[];
+export {};

package/dist/types-ts4.5/ui/annotations/hooks/use-load-annotations.d.ts

@@ -0,0 +1,6 @@
+import { JSONDocNode } from '@atlaskit/editor-json-transformer';
+type Props = {
+    adfDocument: JSONDocNode;
+};
+export declare const useLoadAnnotations: ({ adfDocument }: Props) => void;
+export {};

package/dist/types-ts4.5/ui/annotations/hooks/user-selection.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+type Props = {
+    rendererRef: React.RefObject<HTMLDivElement>;
+};
+export declare const useUserSelectionRange: (props: Props) => [
+    Range | null,
+    () => void
+];
+export {};

package/dist/types-ts4.5/ui/annotations/hooks/utils.d.ts

@@ -0,0 +1,2 @@
+/** Exists in its own module to allow mocking in unit tests */
+export declare const isRangeInsideOfRendererContainer: (rendererDOM: HTMLElement, range: Range) => boolean;

package/dist/types-ts4.5/ui/annotations/index.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { AnnotationsWrapperProps } from './types';
+export declare const AnnotationsWrapper: React.FC<AnnotationsWrapperProps>;
+export { TextWithAnnotationDraft } from './draft';
+export { MarkElement as AnnotationMark } from './element';

package/dist/types-ts4.5/ui/annotations/selection/index.d.ts

@@ -0,0 +1 @@
+export { Wrapper as SelectionComponentWrapper } from './wrapper';

package/dist/types-ts4.5/ui/annotations/selection/mounter.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { AnnotationByMatches, InlineCommentSelectionComponentProps } from '@atlaskit/editor-common/types';
+import { ApplyAnnotation } from '../../../actions/index';
+import { Position } from '../types';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+type Props = {
+    range: Range;
+    component: React.ComponentType<InlineCommentSelectionComponentProps>;
+    wrapperDOM: React.RefObject<HTMLDivElement>;
+    documentPosition: Position | false;
+    isAnnotationAllowed: boolean;
+    onClose: () => void;
+    applyAnnotation: ApplyAnnotation;
+    applyAnnotationDraftAt: (position: Position) => void;
+    clearAnnotationDraft: () => void;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    generateIndexMatch?: (pos: Position) => false | AnnotationByMatches;
+};
+export declare const SelectionInlineCommentMounter: React.FC<Props>;
+export {};

package/dist/types-ts4.5/ui/annotations/selection/range-validator.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { Position } from '../types';
+import type { InlineCommentSelectionComponentProps } from '@atlaskit/editor-common/types';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+type Props = {
+    selectionComponent: React.ComponentType<InlineCommentSelectionComponentProps>;
+    rendererRef: React.RefObject<HTMLDivElement>;
+    applyAnnotationDraftAt: (position: Position) => void;
+    clearAnnotationDraft: () => void;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+};
+export declare const SelectionRangeValidator: React.FC<Props>;
+export {};

package/dist/types-ts4.5/ui/annotations/selection/wrapper.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+type Props = {
+    rendererRef: React.RefObject<HTMLDivElement>;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+};
+export declare const Wrapper: (props: React.PropsWithChildren<Props>) => JSX.Element;
+export {};

package/dist/types-ts4.5/ui/annotations/types.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import type { AnnotationProviders } from '@atlaskit/editor-common/types';
+export declare enum InsertDraftPosition {
+    AROUND_TEXT = "AROUND_TEXT",
+    START = "START",
+    END = "END",
+    INSIDE = "INSIDE"
+}
+export type Position = {
+    from: number;
+    to: number;
+};
+export type AnnotationsWrapperProps = {
+    adfDocument: JSONDocNode;
+    annotationProvider: AnnotationProviders | null | undefined;
+    rendererRef: React.RefObject<HTMLDivElement>;
+};
+export type TextPosition = {
+    start: number;
+    end: number;
+};

package/dist/types-ts4.5/ui/annotations/view/index.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+type Props = {
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+};
+declare const AnnotationView: React.FC<Props>;
+export { AnnotationView };

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

@@ -0,0 +1 @@
+export { default as Renderer } from './Renderer';

package/dist/types-ts4.5/ui/renderer-props.d.ts

@@ -0,0 +1,104 @@
+/// <reference types="react" />
+import { Schema } from 'prosemirror-model';
+import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import type { ADFStage } from '@atlaskit/editor-common/validator';
+import type { AnnotationProviders } from '@atlaskit/editor-common/types';
+import type { EventHandlers } from '@atlaskit/editor-common/ui';
+import type { UnsupportedContentLevelsTracking } from '@atlaskit/editor-common/utils';
+import { EmojiResourceConfig } from '@atlaskit/emoji/resource';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import { RendererContext } from '../';
+import { RenderOutputStat } from '../render-document';
+import { RendererAppearance, StickyHeaderProps, HeadingAnchorLinksProps, NodeComponentsProps } from './Renderer/types';
+import { MediaOptions } from '../types/mediaOptions';
+import { SmartLinksOptions } from '../types/smartLinksOptions';
+import { ACTION_SUBJECT } from '@atlaskit/editor-common/analytics';
+import { DocNode } from '@atlaskit/adf-schema';
+export interface RawObjectFeatureFlags {
+    ['renderer-render-tracking']: string;
+}
+export interface NormalizedObjectFeatureFlags {
+    rendererRenderTracking: {
+        [ACTION_SUBJECT.RENDERER]: {
+            enabled: boolean;
+            useShallow: boolean;
+        };
+    };
+}
+export interface RendererProps {
+    document: DocNode;
+    dataProviders?: ProviderFactory;
+    eventHandlers?: EventHandlers;
+    extensionHandlers?: ExtensionHandlers;
+    enableSsrInlineScripts?: boolean;
+    onComplete?: (stat: RenderOutputStat) => void;
+    onError?: (error: any) => void;
+    portal?: HTMLElement;
+    rendererContext?: RendererContext;
+    schema?: Schema;
+    appearance?: RendererAppearance;
+    adfStage?: ADFStage;
+    disableHeadingIDs?: boolean;
+    disableActions?: boolean;
+    allowHeadingAnchorLinks?: HeadingAnchorLinksProps;
+    allowPlaceholderText?: boolean;
+    maxHeight?: number;
+    fadeOutHeight?: number;
+    truncated?: boolean;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    allowColumnSorting?: boolean;
+    shouldOpenMediaViewer?: boolean;
+    allowAltTextOnImages?: boolean;
+    stickyHeaders?: StickyHeaderProps;
+    media?: MediaOptions;
+    emojiResourceConfig?: EmojiResourceConfig;
+    smartLinks?: SmartLinksOptions;
+    allowAnnotations?: boolean;
+    annotationProvider?: AnnotationProviders | null;
+    innerRef?: React.RefObject<HTMLDivElement>;
+    useSpecBasedValidator?: boolean;
+    allowCopyToClipboard?: boolean;
+    allowWrapCodeBlock?: boolean;
+    allowCustomPanels?: boolean;
+    analyticsEventSeverityTracking?: {
+        enabled: boolean;
+        severityNormalThreshold: number;
+        severityDegradedThreshold: number;
+    };
+    allowUgcScrubber?: boolean;
+    allowSelectAllTrap?: boolean;
+    unsupportedContentLevelsTracking?: UnsupportedContentLevelsTracking;
+    nodeComponents?: NodeComponentsProps;
+    /**
+     * @default undefined
+     * @description
+     * Short lived feature flags for experiments and gradual rollouts
+     * Flags are expected to follow these rules or they are filtered out
+     *
+     * 1. cased in kebab-case (match [a-z-])
+     * 2. have boolean values or object {} values
+     *
+     * @example
+     * ```tsx
+     * (<Renderer featureFlags={{ 'my-feature': true }} />);
+     * getFeatureFlags()?.myFeature === true;
+     * ```
+     *
+     * @example
+     * ```tsx
+     * (<Renderer featureFlags={{ 'my-feature': 'thing' }} />);
+     * getFeatureFlags()?.myFeature === undefined;
+     * ```
+     *
+     * @example
+     * ```tsx
+     * (<Renderer featureFlags={{ 'product.my-feature': false }} />);
+     * getFeatureFlags()?.myFeature === undefined;
+     * getFeatureFlags()?.productMyFeature === undefined;
+     * ```
+     */
+    featureFlags?: {
+        [featureFlag: string]: boolean;
+    } | Partial<RawObjectFeatureFlags>;
+}

package/dist/types-ts4.5/use-feature-flags.d.ts

@@ -0,0 +1,2 @@
+import { RendererContextProps } from './renderer-context';
+export declare const useFeatureFlags: () => RendererContextProps['featureFlags'] | undefined;

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

@@ -0,0 +1,24 @@
+import type { Schema } from 'prosemirror-model';
+import type { ADNode } from '@atlaskit/editor-common/validator';
+import type { EventHandlers } from '@atlaskit/editor-common/ui';
+import type { Transformer } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from 'prosemirror-model';
+import type { RendererAppearance } from './ui/Renderer/types';
+export type TransformerProvider<T> = (schema: Schema) => Transformer<T>;
+export declare class ADFEncoder<T> {
+    encode: (value: T) => any;
+    constructor(createTransformerWithSchema: TransformerProvider<T>);
+}
+export declare const getText: (node: PMNode | ADNode) => string;
+export declare const getEventHandler: (eventHandlers?: EventHandlers, type?: keyof EventHandlers, eventName?: string) => any;
+export declare const getPlatform: (rendererAppearance: RendererAppearance) => "mobile" | "web";
+/**
+ * Traverse through parent elements of element. Return element for which evaluate(element) returns
+ * true. If topElement is reached before evaluate returns true, return false. Does not run evaluate
+ * on topElement.
+ * @param element Starting HTMLElement
+ * @param topElement HTMLElement to end search at. evaluate is not called on this element
+ * @param evaluate Function which returns true or false based on the given element. eg: Checks if
+ * element has desired classname.
+ */
+export declare function findInTree(element: HTMLElement, topElement: HTMLElement, evaluate: (element: HTMLElement) => boolean): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/renderer",
-  "version": "108.0.1",
+  "version": "108.1.0",
   "description": "Renderer component",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -39,18 +39,19 @@
     "@atlaskit/analytics-next": "^9.1.0",
     "@atlaskit/button": "^16.7.0",
     "@atlaskit/code": "^14.6.0",
-    "@atlaskit/editor-common": "^74.0.0",
+    "@atlaskit/editor-common": "^74.1.0",
     "@atlaskit/editor-json-transformer": "^8.9.0",
     "@atlaskit/editor-palette": "1.4.1",
     "@atlaskit/editor-shared-styles": "^2.4.0",
     "@atlaskit/emoji": "^67.4.0",
     "@atlaskit/icon": "^21.12.0",
-    "@atlaskit/media-card": "^74.8.0",
+    "@atlaskit/media-card": "^75.0.0",
     "@atlaskit/media-client": "^22.0.0",
     "@atlaskit/media-common": "^4.1.0",
     "@atlaskit/media-filmstrip": "^47.0.0",
-    "@atlaskit/media-ui": "^22.4.0",
-    "@atlaskit/media-viewer": "^47.6.0",
+    "@atlaskit/media-ui": "^23.0.0",
+    "@atlaskit/media-viewer": "^48.0.0",
+    "@atlaskit/platform-feature-flags": "^0.2.0",
     "@atlaskit/smart-card": "^26.1.0",
     "@atlaskit/status": "^1.3.0",
     "@atlaskit/task-decision": "^17.6.0",
@@ -61,7 +62,7 @@
     "@emotion/react": "^11.7.1",
     "lodash": "^4.17.21",
     "memoize-one": "^6.0.0",
-    "prosemirror-model": "1.14.3",
+    "prosemirror-model": "1.16.0",
     "prosemirror-transform": "1.3.2",
     "prosemirror-utils": "^1.0.0-0",
     "react-intl-next": "npm:react-intl@^5.18.1",
@@ -79,9 +80,10 @@
     "@atlaskit/avatar": "^21.3.0",
     "@atlaskit/css-reset": "^6.5.0",
     "@atlaskit/docs": "*",
-    "@atlaskit/editor-core": "^183.0.0",
+    "@atlaskit/editor-core": "^183.1.0",
     "@atlaskit/editor-test-helpers": "^18.3.0",
     "@atlaskit/link-provider": "^1.6.0",
+    "@atlaskit/link-test-helpers": "^2.2.0",
     "@atlaskit/logo": "^13.14.0",
     "@atlaskit/media-core": "^34.1.0",
     "@atlaskit/media-integration-test-helpers": "^2.6.0",
@@ -126,5 +128,10 @@
         "emotion"
       ]
     }
+  },
+  "platform-feature-flags": {
+    "platform.editor.sentry-error-monitoring_6bksu": {
+      "type": "boolean"
+    }
   }
 }

package/report.api.md

@@ -381,10 +381,8 @@ export const renderDocument: <T>(
   adfStage?: ADFStage,
   useSpecBasedValidator?: boolean,
   rendererId?: string,
-  dispatchAnalyticsEvent?: DispatchAnalyticsEvent | undefined,
-  unsupportedContentLevelsTracking?:
-    | UnsupportedContentLevelsTracking
-    | undefined,
+  dispatchAnalyticsEvent?: DispatchAnalyticsEvent,
+  unsupportedContentLevelsTracking?: UnsupportedContentLevelsTracking,
   appearance?: RendererAppearance,
 ) => RenderOutput<T | null>;
 
@@ -759,8 +757,8 @@ type VisitMediaLinkAEP = AEP<
 
 ```json
 {
-  "@atlaskit/link-provider": "^1.5.3",
-  "@atlaskit/media-core": "^34.0.2",
+  "@atlaskit/link-provider": "^1.6.1",
+  "@atlaskit/media-core": "^34.1.1",
   "react": "^16.8.0",
   "react-dom": "^16.8.0"
 }