@atlaskit/renderer 108.15.10 → 108.15.12

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

@@ -0,0 +1,13 @@
+import React from 'react';
+import { TextPosition, Position } from '../types';
+export declare const findTextString: (reactNode: React.ReactNode) => string | null;
+type Offset = {
+    startOffset: number;
+    endOffset: number;
+};
+export declare const splitText: (text: string, { startOffset, endOffset }: Offset) => string[] | null;
+export declare const calcTextSplitOffset: (position: Position, textPosition: TextPosition, text: string) => {
+    startOffset: number;
+    endOffset: number;
+};
+export {};

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

@@ -0,0 +1,10 @@
+import React from 'react';
+import { AnnotationId, AnnotationDataAttributes, AnnotationTypes } from '@atlaskit/adf-schema';
+type MarkElementProps = {
+    id: AnnotationId;
+    annotationParentIds: AnnotationId[];
+    dataAttributes: AnnotationDataAttributes;
+    annotationType: AnnotationTypes;
+};
+declare const MarkElement: React.FC<MarkElementProps>;
+export { MarkElement };

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,115 @@
+/// <reference types="react" />
+import type { Schema } from '@atlaskit/editor-prosemirror/model';
+import type { ExtensionHandlers } from '@atlaskit/editor-common/extensions';
+import type { 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 type { EmojiResourceConfig } from '@atlaskit/emoji/resource';
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { RendererContext } from '../';
+import type { RenderOutputStat } from '../render-document';
+import type { RendererAppearance, StickyHeaderProps, HeadingAnchorLinksProps, NodeComponentsProps } from './Renderer/types';
+import type { MediaOptions } from '../types/mediaOptions';
+import type { SmartLinksOptions } from '../types/smartLinksOptions';
+import type { ACTION_SUBJECT } from '@atlaskit/editor-common/analytics';
+import type { 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>;
+    /** @deprecated {@link https://hello.atlassian.net/browse/ENGHEALTH-3649 Internal documentation for deprecation (no external access)} This prop will be removed and set as default enabled, as the same flag on the Editor is also now default enabled. */
+    useSpecBasedValidator?: boolean;
+    allowCopyToClipboard?: boolean;
+    allowWrapCodeBlock?: boolean;
+    allowCustomPanels?: boolean;
+    analyticsEventSeverityTracking?: {
+        enabled: boolean;
+        severityNormalThreshold: number;
+        severityDegradedThreshold: number;
+    };
+    allowUgcScrubber?: boolean;
+    allowSelectAllTrap?: boolean;
+    unsupportedContentLevelsTracking?: UnsupportedContentLevelsTracking;
+    nodeComponents?: NodeComponentsProps;
+    /**
+     * When enabled a trailing telepointer will be added to the rendered document
+     * following content updates.
+     *
+     * Content is updated by passing a new value prop to the renderer.
+     *
+     * The trailing pointer is updated by dom injection to the last text node which
+     * is updated as a result of a content update.
+     */
+    addTelepointer?: boolean;
+    /**
+     * @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 '@atlaskit/editor-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 '@atlaskit/editor-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.15.10",
+  "version": "108.15.12",
   "description": "Renderer component",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -31,7 +31,7 @@
     "@atlaskit/analytics-next": "^9.1.0",
     "@atlaskit/button": "^16.10.0",
     "@atlaskit/code": "^14.6.0",
-    "@atlaskit/editor-common": "^76.6.0",
+    "@atlaskit/editor-common": "^76.10.0",
     "@atlaskit/editor-json-transformer": "^8.10.0",
     "@atlaskit/editor-palette": "1.5.1",
     "@atlaskit/editor-prosemirror": "1.1.0",
@@ -50,7 +50,7 @@
     "@atlaskit/status": "^1.4.0",
     "@atlaskit/task-decision": "^17.9.0",
     "@atlaskit/theme": "^12.6.0",
-    "@atlaskit/tokens": "^1.25.0",
+    "@atlaskit/tokens": "^1.26.0",
     "@atlaskit/tooltip": "^17.8.0",
     "@babel/runtime": "^7.0.0",
     "@emotion/react": "^11.7.1",