@atlaskit/editor-common 74.0.1 → 74.1.0

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

@@ -0,0 +1,103 @@
+import React from 'react';
+import { ShadowObserver } from './shadowObserver';
+export declare const shadowClassNames: {
+    RIGHT_SHADOW: string;
+    LEFT_SHADOW: string;
+};
+export interface OverflowShadowProps {
+    handleRef?: (ref: HTMLElement | null) => void;
+    shadowClassNames?: string;
+}
+export interface OverflowShadowState {
+    showLeftShadow: boolean;
+    showRightShadow: boolean;
+}
+export interface OverflowShadowOptions {
+    overflowSelector: string;
+    useShadowObserver?: boolean;
+}
+export default function overflowShadow<P>(Component: React.ComponentType<P & OverflowShadowProps> | React.StatelessComponent<P & OverflowShadowProps>, options: OverflowShadowOptions): {
+    new (props: Readonly<P>): {
+        overflowContainer?: HTMLElement | null | undefined;
+        container?: HTMLElement | undefined;
+        shadowObserver?: ShadowObserver | undefined;
+        overflowContainerWidth: number;
+        scrollable?: NodeList | undefined;
+        diff?: number | undefined;
+        state: {
+            showLeftShadow: boolean;
+            showRightShadow: boolean;
+        };
+        componentWillUnmount(): void;
+        componentDidUpdate(): void;
+        handleScroll: (event: Event) => void;
+        updateShadows: () => void;
+        showLeftShadow: (overflowContainer: HTMLElement | null | undefined) => boolean;
+        calcOverflowDiff: () => number;
+        calcScrollableWidth: () => number;
+        handleContainer: (container: HTMLElement | null) => void;
+        initShadowObserver(): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends keyof OverflowShadowState>(state: OverflowShadowState | ((prevState: Readonly<OverflowShadowState>, props: Readonly<P>) => OverflowShadowState | Pick<OverflowShadowState, K> | null) | Pick<OverflowShadowState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<P> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<OverflowShadowState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<OverflowShadowState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<OverflowShadowState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<OverflowShadowState>, nextContext: any): void;
+    };
+    new (props: P, context?: any): {
+        overflowContainer?: HTMLElement | null | undefined;
+        container?: HTMLElement | undefined;
+        shadowObserver?: ShadowObserver | undefined;
+        overflowContainerWidth: number;
+        scrollable?: NodeList | undefined;
+        diff?: number | undefined;
+        state: {
+            showLeftShadow: boolean;
+            showRightShadow: boolean;
+        };
+        componentWillUnmount(): void;
+        componentDidUpdate(): void;
+        handleScroll: (event: Event) => void;
+        updateShadows: () => void;
+        showLeftShadow: (overflowContainer: HTMLElement | null | undefined) => boolean;
+        calcOverflowDiff: () => number;
+        calcScrollableWidth: () => number;
+        handleContainer: (container: HTMLElement | null) => void;
+        initShadowObserver(): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends keyof OverflowShadowState>(state: OverflowShadowState | ((prevState: Readonly<OverflowShadowState>, props: Readonly<P>) => OverflowShadowState | Pick<OverflowShadowState, K> | null) | Pick<OverflowShadowState, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<P> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<OverflowShadowState>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<OverflowShadowState>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<OverflowShadowState>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<OverflowShadowState>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};

package/dist/types-ts4.5/ui/OverflowShadow/shadowObserver.d.ts

@@ -0,0 +1,27 @@
+export declare enum ShadowKeys {
+    SHOW_LEFT_SHADOW = "showLeftShadow",
+    SHOW_RIGHT_SHADOW = "showRightShadow"
+}
+export type ShadowsStates = {
+    [ShadowKey in ShadowKeys]: boolean;
+};
+export declare const shadowObserverClassNames: {
+    SENTINEL_LEFT: string;
+    SENTINEL_RIGHT: string;
+    SHADOW_CONTAINER: string;
+};
+export declare class ShadowObserver {
+    private intersectionObserver?;
+    private scrollContainer;
+    private onUpdateShadows;
+    private sentinels;
+    private requestCallbackId?;
+    readonly shadowStates: ShadowsStates;
+    constructor({ scrollContainer, onUpdateShadows, }: {
+        scrollContainer: HTMLElement;
+        onUpdateShadows: (eventData: ShadowsStates) => void;
+    });
+    private init;
+    private onIntersect;
+    dispose(): void;
+}

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

@@ -0,0 +1,83 @@
+import React from 'react';
+import { Position } from './utils';
+export interface Props {
+    zIndex?: number;
+    alignX?: 'left' | 'right' | 'center' | 'end';
+    alignY?: 'top' | 'bottom' | 'start';
+    target?: HTMLElement;
+    fitHeight?: number;
+    fitWidth?: number;
+    boundariesElement?: HTMLElement;
+    mountTo?: HTMLElement;
+    offset?: number[];
+    onPositionCalculated?: (position: Position) => Position;
+    onPlacementChanged?: (placement: [
+        string,
+        string
+    ]) => void;
+    shouldRenderPopup?: (position: Position) => boolean;
+    scrollableElement?: HTMLElement;
+    stick?: boolean;
+    ariaLabel?: string;
+    forcePlacement?: boolean;
+    allowOutOfBounds?: boolean;
+    rect?: DOMRect;
+    style?: React.CSSProperties;
+    /** Enable focus trap to contain the user's focus within the popup */
+    focusTrap?: boolean;
+    preventOverflow?: boolean;
+}
+export interface State {
+    popup?: HTMLElement;
+    position?: Position;
+    validPosition: boolean;
+}
+export default class Popup extends React.Component<Props, State> {
+    scrollElement: undefined | false | HTMLElement;
+    scrollParentElement: undefined | false | HTMLElement;
+    rafIds: Set<number>;
+    static defaultProps: {
+        offset: number[];
+        allowOutOfBound: boolean;
+    };
+    state: State;
+    private popupRef;
+    private focusTrap?;
+    private placement;
+    /**
+     * Calculates new popup position
+     */
+    private calculatePosition;
+    private updatePosition;
+    private cannotSetPopup;
+    /**
+     * Popup initialization.
+     * Checks whether it's possible to position popup along given target, and if it's not throws an error.
+     */
+    private initPopup;
+    private handleRef;
+    private scheduledUpdatePosition;
+    onResize: () => void;
+    UNSAFE_componentWillReceiveProps(newProps: Props): void;
+    resizeObserver: ResizeObserver | undefined;
+    /**
+     * Raf scheduled so that it also occurs after the initial update position
+     */
+    private initFocusTrap;
+    /**
+     * Cancels the initialisation of the focus trap if it has not yet occured
+     * Deactivates the focus trap if it exists
+     */
+    private destroyFocusTrap;
+    /**
+     * Handle pausing, unpausing, and initialising (if not yet initialised) of the focus trap
+     */
+    handleChangedFocusTrapProp(prevProps: Props): void;
+    componentDidUpdate(prevProps: Props): void;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private renderPopup;
+    render(): JSX.Element | null;
+}
+export { findOverflowScrollParent } from './utils';
+export type { Position } from './utils';

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

@@ -0,0 +1,42 @@
+export interface Position {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+export interface CalculatePositionParams {
+    placement: [
+        string,
+        string
+    ];
+    target?: HTMLElement;
+    popup?: HTMLElement;
+    offset: number[];
+    stick?: boolean;
+    allowOutOfBounds?: boolean;
+    rect?: DOMRect;
+}
+export declare function isBody(elem: HTMLElement | Element): boolean;
+export declare function isTextNode(elem: HTMLElement | Element): boolean;
+/**
+ * Decides if given fitHeight fits below or above the target taking boundaries into account.
+ */
+export declare function getVerticalPlacement(target: HTMLElement, boundariesElement: HTMLElement, fitHeight?: number, alignY?: string, forcePlacement?: boolean, preventOverflow?: boolean): string;
+/**
+ * Decides if given fitWidth fits to the left or to the right of the target taking boundaries into account.
+ */
+export declare function getHorizontalPlacement(target: HTMLElement, boundariesElement: HTMLElement, fitWidth?: number, alignX?: string, forcePlacement?: boolean, preventOverflow?: boolean): string;
+export declare function calculatePlacement(target: HTMLElement, boundariesElement: HTMLElement, fitWidth?: number, fitHeight?: number, alignX?: string, alignY?: string, forcePlacement?: boolean, preventOverflow?: boolean): [
+    string,
+    string
+];
+/**
+ * Calculates relative coordinates for placing popup along with the target.
+ * Uses placement from calculatePlacement.
+ */
+export declare function calculatePosition({ placement, target, popup, offset, stick, allowOutOfBounds, rect, }: CalculatePositionParams): Position;
+export declare function validatePosition(popup: HTMLElement): boolean;
+/**
+ * Traverse DOM Tree upwards looking for popup parents with "overflow: scroll".
+ */
+export declare function findOverflowScrollParent(popup: HTMLElement | null): HTMLElement | false;

package/dist/types-ts4.5/ui/PortalProvider/PortalProviderThemesProvider.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { ThemeModes } from '@atlaskit/theme/types';
+export declare function PortalProviderThemeProviders(props: {
+    mode: ThemeModes;
+    children: React.ReactNode;
+}): JSX.Element;

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

@@ -0,0 +1,51 @@
+import React from 'react';
+import { IntlShape, WrappedComponentProps } from 'react-intl-next';
+import type { ThemeModes } from '@atlaskit/theme/types';
+import { FireAnalyticsCallback } from '../../analytics';
+import { EventDispatcher } from '../../event-dispatcher';
+export type BasePortalProviderProps = {
+    render: (portalProviderAPI: PortalProviderAPI) => React.ReactChild | JSX.Element | null;
+    onAnalyticsEvent?: FireAnalyticsCallback;
+    useAnalyticsContext?: boolean;
+    themeMode?: ThemeModes;
+} & WrappedComponentProps;
+export type Portals = Map<HTMLElement, React.ReactChild>;
+export type PortalRendererState = {
+    portals: Portals;
+};
+type MountedPortal = {
+    children: () => React.ReactChild | null;
+    hasAnalyticsContext: boolean;
+    hasIntlContext: boolean;
+};
+export declare class PortalProviderAPI extends EventDispatcher {
+    portals: Map<HTMLElement, MountedPortal>;
+    context: any;
+    intl: IntlShape;
+    onAnalyticsEvent?: FireAnalyticsCallback;
+    useAnalyticsContext?: boolean;
+    themeMode?: ThemeModes;
+    constructor(intl: IntlShape, onAnalyticsEvent?: FireAnalyticsCallback, analyticsContext?: boolean, themeMode?: ThemeModes);
+    setContext: (context: any) => void;
+    render(children: () => React.ReactChild | JSX.Element | null, container: HTMLElement, hasAnalyticsContext?: boolean, hasIntlContext?: boolean): void;
+    forceUpdate({ intl, themeMode, }: {
+        intl: IntlShape;
+        themeMode: ThemeModes | undefined;
+    }): void;
+    remove(container: HTMLElement): void;
+}
+export declare const PortalProvider: React.FC<import("react-intl-next").WithIntlProps<BasePortalProviderProps>> & {
+    WrappedComponent: React.ComponentType<BasePortalProviderProps>;
+};
+type PortalProviderWithThemeProvidersProps = Omit<BasePortalProviderProps, 'intl' | 'themeMode'>;
+export declare const PortalProviderWithThemeProviders: ({ onAnalyticsEvent, useAnalyticsContext, render, }: PortalProviderWithThemeProvidersProps) => JSX.Element;
+export declare class PortalRenderer extends React.Component<{
+    portalProviderAPI: PortalProviderAPI;
+}, PortalRendererState> {
+    constructor(props: {
+        portalProviderAPI: PortalProviderAPI;
+    });
+    handleUpdate: (portals: Portals) => void;
+    render(): JSX.Element;
+}
+export {};

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

@@ -0,0 +1,22 @@
+import React, { PropsWithChildren } from 'react';
+import { HandleComponent } from 're-resizable';
+import { EnabledHandles, HandleResize } from './types';
+export interface ResizableNumberSize {
+    width: number;
+    height: number;
+}
+export type ResizerProps = {
+    enable: EnabledHandles;
+    width: number;
+    handleResizeStart: () => number;
+    handleResize: HandleResize;
+    handleResizeStop: HandleResize;
+    innerPadding?: number;
+    handleClassName?: string;
+    className?: string;
+    minWidth?: number;
+    maxWidth?: number;
+    handleWrapperStyle?: React.CSSProperties;
+    handleComponent?: HandleComponent;
+};
+export default function ResizerNext(props: PropsWithChildren<ResizerProps>): JSX.Element;

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

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+export type EnabledHandles = {
+    left?: boolean;
+    right?: boolean;
+};
+export type HandleResize = (newWidth: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, delta: {
+    width: number;
+    height: number;
+}) => number;
+export type HandleStyles = {
+    right?: React.CSSProperties;
+    left?: React.CSSProperties;
+};

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

@@ -0,0 +1 @@
+export declare const handleSides: Array<'left' | 'right'>;

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

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import React from 'react';
+import { Node as PMNode } from 'prosemirror-model';
+import { WrappedComponentProps } from 'react-intl-next';
+import { UnsupportedContentTooltipPayload } from '../../utils';
+export interface Props {
+    node?: PMNode;
+    children?: React.ReactNode;
+    dispatchAnalyticsEvent?: (payload: UnsupportedContentTooltipPayload) => void;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import React from 'react';
+import { Node as PMNode } from 'prosemirror-model';
+import { WrappedComponentProps } from 'react-intl-next';
+import { UnsupportedContentTooltipPayload } from '../../utils';
+export interface Props {
+    node?: PMNode;
+    children?: React.ReactNode;
+    dispatchAnalyticsEvent?: (payload: UnsupportedContentTooltipPayload) => void;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

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

@@ -0,0 +1,29 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+export type Breakpoints = 'S' | 'M' | 'L';
+export type WidthConsumerContext = {
+    width: number;
+    breakpoint: Breakpoints;
+};
+export declare function getBreakpoint(width?: number): Breakpoints;
+export declare function createWidthContext(width?: number): WidthConsumerContext;
+export declare const WidthContext: React.Context<WidthConsumerContext>;
+declare const Consumer: React.Consumer<WidthConsumerContext>;
+export type WidthProviderState = {
+    width?: number;
+};
+type WidthProviderProps = {
+    className?: string;
+};
+export declare class WidthProvider extends React.Component<WidthProviderProps, WidthProviderState> {
+    state: {
+        width: number;
+    };
+    constructor(props: any);
+    render(): jsx.JSX.Element;
+    setWidth: ((width: number) => void) & {
+        cancel(): void;
+    };
+}
+export { Consumer as WidthConsumer };

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

@@ -0,0 +1,6 @@
+import React from 'react';
+import { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+export type Props = {
+    render: (createAnalyticsEvent?: CreateUIAnalyticsEvent) => React.ReactNode;
+};
+export declare const WithCreateAnalyticsEvent: React.ComponentType<Props>;

package/dist/types-ts4.5/ui/clear-next-sibling-margin-top.d.ts

@@ -0,0 +1,2 @@
+export declare const clearNextSiblingMarginTopStyle: import("@emotion/react").SerializedStyles;
+export declare const clearNextSiblingBlockMarkMarginTopStyle: import("@emotion/react").SerializedStyles;

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

@@ -0,0 +1,28 @@
+export { default as Caption } from './Caption';
+export { default as MediaSingle, DEFAULT_IMAGE_WIDTH, DEFAULT_IMAGE_HEIGHT, shouldAddDefaultWrappedWidth, } from './MediaSingle';
+export type { Props as MediaSingleProps } from './MediaSingle';
+export { MediaSingleDimensionHelper } from './MediaSingle/styled';
+export type { MediaSingleWrapperProps as MediaSingleDimensionHelperProps } from './MediaSingle/styled';
+export { layoutSupportsWidth, calcPxFromColumns, calcPctFromPx, calcPxFromPct, calcColumnsFromPx, snapToGrid, calcMediaPxWidth, wrappedLayouts, } from './MediaSingle/grid';
+export { mediaLinkStyle } from './MediaSingle/link';
+export { default as Popup, findOverflowScrollParent } from './Popup';
+export type { Position as PopupPosition, Props as PopupProps } from './Popup';
+export { default as UnsupportedBlock } from './UnsupportedBlock';
+export { default as UnsupportedInline } from './UnsupportedInline';
+export { BaseTheme, mapBreakpointToLayoutMaxWidth } from './BaseTheme';
+export { default as withOuterListeners } from './with-outer-listeners';
+export type { WithOutsideClickProps } from './with-outer-listeners';
+export type { CardEventClickHandler, CardSurroundings, EventHandlers, LinkEventClickHandler, MentionEventHandler, MentionEventHandlers, SmartCardEventClickHandler, } from './EventHandlers';
+export { WidthContext, WidthConsumer, WidthProvider, getBreakpoint, } from './WidthProvider';
+export type { WidthConsumerContext, Breakpoints } from './WidthProvider';
+export { default as overflowShadow, shadowClassNames } from './OverflowShadow';
+export type { OverflowShadowOptions, OverflowShadowProps, OverflowShadowState, } from './OverflowShadow';
+export { shadowObserverClassNames, ShadowObserver, } from './OverflowShadow/shadowObserver';
+export { WithCreateAnalyticsEvent } from './WithCreateAnalyticsEvent';
+export { messages as expandMessages, sharedExpandStyles, ExpandIconWrapper, expandLayoutWrapperStyle, ExpandLayoutWrapperWithRef, } from './Expand';
+export type { StyleProps as ExpandStyleProps } from './Expand';
+export { ErrorMessage, HelperMessage, ValidMessage } from './Messages';
+export { clearNextSiblingMarginTopStyle, clearNextSiblingBlockMarkMarginTopStyle, } from './clear-next-sibling-margin-top';
+export { IntlErrorBoundary, REACT_INTL_ERROR_MESSAGE, } from './IntlErrorBoundary';
+export { default as IntlProviderIfMissingWrapper } from './IntlProviderIfMissingWrapper';
+export { default as FloatingToolbarButton } from './FloatingToolbar/Button';

package/dist/types-ts4.5/ui/unsupported-content-helper.d.ts

@@ -0,0 +1,3 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { IntlShape } from 'react-intl-next';
+export declare function getUnsupportedContent(message: any, prefix: string, node?: PMNode, intl?: IntlShape): any;

package/dist/types-ts4.5/ui/with-outer-listeners.d.ts

@@ -0,0 +1,8 @@
+import { ComponentClass, StatelessComponent } from 'react';
+type SimpleEventHandler<T> = (event: T) => void;
+export interface WithOutsideClickProps {
+    handleClickOutside?: SimpleEventHandler<MouseEvent>;
+    handleEscapeKeydown?: SimpleEventHandler<KeyboardEvent>;
+}
+export default function withOuterListeners<P>(Component: ComponentClass<P> | StatelessComponent<P>): ComponentClass<P & WithOutsideClickProps>;
+export {};

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

@@ -0,0 +1,20 @@
+/** @jsx jsx */
+import React, { PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+export interface Props {
+    value: string;
+    label: string;
+    tabIndex?: number;
+    isSelected?: boolean;
+    onClick: (value: string, label: string) => void;
+    borderColor: string;
+    checkMarkColor?: string;
+    autoFocus?: boolean;
+    hexToPaletteColor?: (hexColor: string) => string | undefined;
+}
+declare class Color extends PureComponent<Props> {
+    render(): jsx.JSX.Element;
+    onMouseDown: (e: React.MouseEvent<{}>) => void;
+    onClick: (e: React.MouseEvent<{}>) => void;
+}
+export default Color;

package/dist/types-ts4.5/ui-color/ColorPalette/Color/styles.d.ts

@@ -0,0 +1,4 @@
+/** this is not new usage - old code extracted from editor-core */
+export declare const buttonStyle: import("@emotion/react").SerializedStyles;
+/** this is not new usage - old code extracted from editor-core */
+export declare const buttonWrapperStyle: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/ui-color/ColorPalette/Palettes/borderColorPalette.d.ts

@@ -0,0 +1,3 @@
+import { PaletteColor } from './type';
+declare const borderColorPalette: Array<PaletteColor>;
+export default borderColorPalette;

package/dist/types-ts4.5/ui-color/ColorPalette/Palettes/cellBackgroundColorPalette.d.ts

@@ -0,0 +1,3 @@
+import { PaletteColor } from './type';
+declare const cellBackgroundColorPalette: Array<PaletteColor>;
+export default cellBackgroundColorPalette;

package/dist/types-ts4.5/ui-color/ColorPalette/Palettes/common.d.ts

@@ -0,0 +1,2 @@
+/** this is not new usage - old code extracted from editor-core */
+export declare const DEFAULT_BORDER_COLOR: string;

package/dist/types-ts4.5/ui-color/ColorPalette/Palettes/getColorMessage.d.ts

@@ -0,0 +1,2 @@
+import { MessageDescriptor } from 'react-intl-next';
+export default function getColorMessage(messages: Record<string | number, MessageDescriptor>, color: string): MessageDescriptor | undefined;

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

@@ -0,0 +1,3 @@
+export type { PaletteColor } from './type';
+export { DEFAULT_BORDER_COLOR } from './common';
+export { backgroundPaletteTooltipMessages, borderPaletteTooltipMessages, chartsColorPaletteTooltipMessages, textPaletteTooltipMessages, } from './paletteMessagesTokenModeNames';

package/dist/types-ts4.5/ui-color/ColorPalette/Palettes/paletteMessages.d.ts

@@ -0,0 +1,123 @@
+declare const _default: {
+    white: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-blue': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-teal': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-green': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-yellow': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-red': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-purple': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-gray': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    blue: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    teal: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    green: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    yellow: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    red: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    orange: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    purple: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    gray: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-blue': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-teal': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-green': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-yellow': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-red': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-purple': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'subtle-gray': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'bold-gray': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export default _default;