@atlaskit/util-data-test 17.8.2 → 17.8.4

package/dist/types-ts4.5/emoji/src/api/media/SiteEmojiResource.d.ts

@@ -0,0 +1,46 @@
+import { ServiceConfig } from '@atlaskit/util-service-support';
+import { EmojiDescription, EmojiId, EmojiServiceDescription, EmojiUpload, MediaApiToken, OptionalEmojiDescription } from '../../types';
+import TokenManager from './TokenManager';
+export interface EmojiUploadResponse {
+    emojis: EmojiServiceDescription[];
+}
+export interface EmojiProgress {
+    readonly percent: number;
+}
+export interface EmojiProgessCallback {
+    (progress: EmojiProgress): void;
+}
+export declare const mediaProportionOfProgress: number;
+export default class SiteEmojiResource {
+    private siteServiceConfig;
+    private mediaApiToken;
+    private mediaEmojiCache;
+    protected tokenManager: TokenManager;
+    constructor(siteServiceConfig: ServiceConfig, mediaApiToken: MediaApiToken);
+    /**
+     * Will generate an emoji media path that is inclusive of client and token within the query parameter
+     */
+    generateTokenisedMediaURL(emoji: EmojiDescription): Promise<string>;
+    /**
+     * Will load media emoji, returning a new EmojiDescription if, for example,
+     * the URL has changed.
+     */
+    loadMediaEmoji(emoji: EmojiDescription, useAlt?: boolean): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    optimisticRendering(emoji: EmojiDescription, useAlt?: boolean): boolean | Promise<boolean>;
+    uploadEmoji(upload: EmojiUpload, retry?: boolean, progressCallback?: EmojiProgessCallback): Promise<EmojiDescription>;
+    /**
+     * Check if the MediaEmojiResource has been able to initialise an uploadToken. Retrieving an upload token
+     * is asynchronous so the Promise will need to resolve before the state is known. If the token retrieval
+     * completes with failure then the Promise will resolve to false.
+     */
+    hasUploadToken(): Promise<boolean>;
+    prepareForUpload(): void;
+    findEmoji(emojiId: EmojiId): Promise<OptionalEmojiDescription>;
+    /**
+     * Calls to site-scoped EmojiResource to delete emoji
+     * @param emoji media emoji to delete
+     * @returns Promise.resolve() if success and Promise.reject() for failure
+     */
+    deleteEmoji(emoji: EmojiDescription): Promise<boolean>;
+    private postToEmojiService;
+}

package/dist/types-ts4.5/emoji/src/api/media/TokenManager.d.ts

@@ -0,0 +1,13 @@
+import { MediaApiToken } from '../../types';
+import { ServiceConfig } from '@atlaskit/util-service-support';
+export declare const EXPIRES_AT_LATENCY_IN_SECONDS = 30;
+export type TokenType = 'read' | 'upload';
+export default class TokenManager {
+    private siteServiceConfig;
+    private tokens;
+    constructor(siteServiceConfig: ServiceConfig);
+    isValidToken(mediaApiToken: MediaApiToken): boolean;
+    fetchNewToken(type: TokenType): Promise<MediaApiToken>;
+    addToken(type: TokenType, mediaApiToken: MediaApiToken): void;
+    getToken(type: TokenType, forceRefresh?: boolean): Promise<MediaApiToken>;
+}

package/dist/types-ts4.5/emoji/src/components/i18n.d.ts

@@ -0,0 +1,227 @@
+export declare const messages: {
+    deleteEmojiTooltip: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    deleteEmojiTooltipForScreenreader: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    deleteEmojiTitle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    deleteEmojiDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    deleteEmojiLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    addCustomEmojiLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiPlaceholder: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiNameAriaLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiChooseFileTitle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiChooseFileScreenReaderDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiSelectSkinToneButtonAriaLabelText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiSelectSkinToneListAriaLabelText: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiImageRequirements: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiPreviewTitle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiPreview: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    addEmojiLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    retryLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    cancelLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    searchPlaceholder: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    searchLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    searchResultsStatus: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    searchResultsStatusSeeAll: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    categoriesSelectorLabel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    categoriesSearchResults: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    frequentCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    peopleCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    natureCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    foodsCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    activityCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    placesCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    objectsCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    symbolsCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    flagsCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    productivityCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    userUploadsCustomCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    allUploadsCustomCategory: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    deleteEmojiFailed: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiInvalidImage: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiUploadFailed: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiImageTooBig: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiPickerTitle: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiPickerListPanel: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiPickerGrid: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    emojiButtonRoleDescription: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    error: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types-ts4.5/emoji/src/components/picker/categories.d.ts

@@ -0,0 +1,7 @@
+import { CategoryDescription } from '../../types';
+export type CategoryId = 'FREQUENT' | 'PEOPLE' | 'NATURE' | 'FOODS' | 'ACTIVITY' | 'PLACES' | 'OBJECTS' | 'SYMBOLS' | 'FLAGS' | 'ATLASSIAN' | 'CUSTOM';
+export type CategoryGroupKey = CategoryId | 'USER_CUSTOM' | 'SEARCH';
+export type CategoryDescriptionMap = {
+    [key in CategoryGroupKey]: CategoryDescription;
+};
+export declare const CategoryDescriptionMap: CategoryDescriptionMap;

package/dist/types-ts4.5/emoji/src/resource.d.ts

@@ -0,0 +1,5 @@
+export { AbstractResource } from '@atlaskit/util-service-support';
+export { default as EmojiResource } from './api/EmojiResource';
+export type { EmojiProvider, UploadingEmojiProvider, EmojiResourceConfig, OnEmojiProviderChange, } from './api/EmojiResource';
+export { default as EmojiRepository } from './api/EmojiRepository';
+export { default as EmojiLoader } from './api/EmojiLoader';

package/dist/types-ts4.5/emoji/src/types.d.ts

@@ -0,0 +1,363 @@
+import { SyntheticEvent } from 'react';
+import { messages } from './components/i18n';
+import { CategoryId } from './components/picker/categories';
+import { Provider } from '@atlaskit/util-service-support/types';
+import { EmojiRepository } from './resource';
+export type { CategoryId } from './components/picker/categories';
+export interface EmojiProvider extends Provider<string, EmojiSearchResult, any, undefined, SearchOptions> {
+    /**
+     * Returns an immutable copy of EmojiDescription where mediaPath has token and client appended to url.
+     *
+     * Will allow emoji to render site emojis without needing to fail first
+     */
+    getMediaEmojiDescriptionURLWithInlineToken(emoji: EmojiDescription): Promise<EmojiDescription>;
+    /**
+     * Returns the first fetched emoji matching the emojiId.id.
+     *
+     * If the interface is not defined it will fail gracefully to findByEmojiId
+     */
+    fetchByEmojiId(emojiId: EmojiId, optimistic: boolean): OptionalEmojiDescriptionWithVariations | Promise<OptionalEmojiDescriptionWithVariations>;
+    /**
+     * Returns the first matching emoji matching the shortName, or null if none found.
+     *
+     * Will load media api images before returning.
+     */
+    findByShortName(shortName: string): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    /**
+     * Returns the first matching emoji matching the emojiId.id.
+     *
+     * If not found or emojiId.id is undefined, fallback to a search by shortName.
+     *
+     * Will load media api images before returning.
+     */
+    findByEmojiId(emojiId: EmojiId): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    /**
+     * Return the emoji that matches the supplied id or undefined. As with findByEmojiId, this call should load
+     * the media api images before returning.
+     */
+    findById(id: string): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    /**
+     * Finds emojis belonging to specified category.
+     *
+     * Does not automatically load Media API images.
+     */
+    findInCategory(categoryId: string): Promise<EmojiDescription[]>;
+    /**
+     * Returns a map matching ascii representations to their corresponding EmojiDescription.
+     */
+    getAsciiMap(): Promise<Map<string, EmojiDescription>>;
+    /**
+     * Returns, in a Promise, an array of the most frequently used emoji, ordered from most frequent to least frequent.
+     * If there is no frequently used data then an empty array should be returned.
+     *
+     * @param options supply options to be applied to the request.
+     */
+    getFrequentlyUsed(options?: SearchOptions): Promise<EmojiDescription[]>;
+    /**
+     * Records an emoji selection, for example for using in tracking recent emoji.
+     * If no recordConfig is configured then a resolved promise should be returned
+     *
+     * Optional.
+     */
+    recordSelection?(emoji: EmojiDescription): Promise<any>;
+    /**
+     * Deletes the given emoji from the site emoji service
+     * No changes are made if it is not a media emoji, no siteEmojiResource has been initialised
+     * or the user is not authorised.
+     * It should also be removed from the EmojiResource so it cannot be returned via search
+     *
+     * Optional.
+     *
+     * @return a boolean indicating whether the delete was successful
+     */
+    deleteSiteEmoji(emoji: EmojiDescription): Promise<boolean>;
+    /**
+     * Load media emoji that may require authentication to download, producing
+     * a new EmojiDescription to be used for rendering, if necessary.
+     *
+     * Future results may be returned from a cache.
+     *
+     * Acts as a no-op if not a media emoji.
+     *
+     * Downloads and caches the altRepresentation image if useAlt is passed in
+     *
+     * @return an OptionalEmojiDescription or a promise for one, may be the same as the input,
+     *   or updated with a new url to cached image data. Will return the original EmojiDescription
+     *   if not a custom emoji.
+     */
+    loadMediaEmoji(emoji: EmojiDescription, useAlt?: boolean): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    /**
+     * Indicates if media emoji should be rendered optimistically,
+     * i.e. assume the url can be rendered directly from the URL, and
+     * only explicitly loaded via loadEmojiImageData if it fails to load.
+     *
+     * If useAlt is provided, the altRepresentation image URL is used
+     */
+    optimisticMediaRendering(emoji: EmojiDescription, useAlt?: boolean): boolean;
+    /**
+     * Used by the picker and typeahead to obtain a skin tone preference
+     * if the user has previously selected one via the Tone Selector
+     */
+    getSelectedTone(): ToneSelection;
+    /**
+     * Used by Tone Selector to indicate to the provider that the user
+     * has selected a skin tone preference that should be remembered
+     */
+    setSelectedTone(tone: ToneSelection): void;
+    /**
+     * Returns a list of all the non-standard categories with emojis in the EmojiRepository
+     * e.g. 'FREQUENT', 'ATLASSIAN' and 'CUSTOM'
+     */
+    calculateDynamicCategories?(): Promise<string[]>;
+    /**
+     * Returns the logged user passed by the Product
+     */
+    getCurrentUser(): OptionalUser;
+    /**
+     * Fetches and returns emojiResource
+     */
+    fetchEmojiProvider(force?: boolean): Promise<EmojiRepository | undefined>;
+    /**
+     * Returns a constructed URL to fetch emoji media asset if 'optimisticImageApi' config has been provided
+     */
+    getOptimisticImageURL(emojiId: EmojiId): string | undefined;
+}
+export interface UploadingEmojiProvider extends EmojiProvider {
+    /**
+     * Returns true if upload is supported.
+     *
+     * Waits until resources have loaded before returning.
+     */
+    isUploadSupported(): Promise<boolean>;
+    /**
+     * Uploads an emoji to the configured repository.
+     *
+     * Will return a promise with the EmojiDescription once completed.
+     *
+     * The last search will be re-run to ensure the new emoji is considered in the search.
+     */
+    uploadCustomEmoji(upload: EmojiUpload, retry?: boolean): Promise<EmojiDescription>;
+    /**
+     * Allows the preloading of data (e.g. authentication tokens) to speed the uploading of emoji.
+     */
+    prepareForUpload(): Promise<void>;
+}
+export type RelativePosition = 'above' | 'below' | 'auto';
+export type PickerSize = 'small' | 'medium' | 'large';
+export interface Styles {
+    [index: string]: any;
+}
+/**
+ * Minimum information to defined an emoji is the shortName.
+ * In order to uniquely define an emoji, the id should be included, and is
+ * used in preference to shortName if provided, and has a matching emoji.
+ * If not emoji can be found by id (e.g. a custom emoji has been removed),
+ * fallback behaviour will be to attempt to find a matching emoji by shortName.
+ */
+export interface EmojiId {
+    shortName: string;
+    id?: string;
+    fallback?: string;
+}
+export interface SpriteSheet {
+    url: string;
+    row: number;
+    column: number;
+    height: number;
+    width: number;
+}
+export interface EmojiImageRepresentation {
+    height: number;
+    width: number;
+}
+export interface SpriteImageRepresentation extends EmojiImageRepresentation {
+    x: number;
+    y: number;
+    xIndex: number;
+    yIndex: number;
+}
+/**
+ * Sprite representation exposed from the EmojiResource.
+ */
+export interface SpriteRepresentation extends SpriteImageRepresentation {
+    sprite: SpriteSheet;
+}
+/**
+ * Representation returned from a sprite service.
+ */
+export interface SpriteServiceRepresentation extends SpriteImageRepresentation {
+    /** Should match a index in a SpriteSheets */
+    spriteRef: string;
+}
+export interface ImageRepresentation extends EmojiImageRepresentation {
+    imagePath: string;
+}
+export interface MediaApiRepresentation extends EmojiImageRepresentation {
+    mediaPath: string;
+}
+export type EmojiRepresentation = SpriteRepresentation | ImageRepresentation | MediaApiRepresentation | undefined;
+export interface EmojiDescription extends EmojiId {
+    name?: string;
+    order?: number;
+    type: string;
+    category: string;
+    ascii?: string[];
+    createdDate?: string;
+    creatorUserId?: string;
+    representation: EmojiRepresentation;
+    altRepresentation?: EmojiRepresentation;
+    searchable: boolean;
+}
+export interface EmojiDescriptionWithVariations extends EmojiDescription {
+    skinVariations?: EmojiDescription[];
+}
+/**
+ * Describes an emoji which is a variant of some base emoji. This is used when you want to promote the
+ * skinVariations in an EmojiDescriptionWithVariations to represent them along side their base representations.
+ */
+export interface EmojiVariationDescription extends EmojiDescription {
+    /** The id of the 'non-variant version of the emoji */
+    baseId: string;
+}
+export type OptionalEmojiDescription = EmojiDescription | undefined;
+export type OptionalEmojiDescriptionWithVariations = EmojiDescriptionWithVariations | undefined;
+export type EmojiServiceRepresentation = SpriteServiceRepresentation | ImageRepresentation;
+export interface EmojiServiceDescription {
+    id: string;
+    shortName: string;
+    name?: string;
+    order?: number;
+    fallback?: string;
+    ascii?: string[];
+    createdDate?: string;
+    creatorUserId?: string;
+    type: string;
+    category: string;
+    representation: EmojiServiceRepresentation;
+    altRepresentations?: AltRepresentations;
+    searchable: boolean;
+}
+export interface EmojiServiceDescriptionWithVariations extends EmojiServiceDescription {
+    skinVariations?: EmojiServiceDescription[];
+}
+export interface AltRepresentations {
+    [key: string]: EmojiServiceRepresentation;
+}
+export interface SpriteSheets {
+    [index: string]: SpriteSheet;
+}
+/**
+ * An access token for emoji stored in the MediaApi
+ * (indicated by urls beginning with the url of the token.)
+ */
+export interface MediaApiToken {
+    url: string;
+    clientId: string;
+    jwt: string;
+    collectionName: string;
+    expiresAt: number;
+}
+export interface EmojiMeta {
+    spriteSheets?: SpriteSheets;
+    mediaApiToken?: MediaApiToken;
+}
+/**
+ * The expected response from an Emoji service.
+ */
+export interface EmojiServiceResponse {
+    emojis: EmojiServiceDescriptionWithVariations[];
+    meta?: EmojiMeta;
+}
+export interface EmojiResponse {
+    emojis: EmojiDescriptionWithVariations[];
+    mediaApiToken?: MediaApiToken;
+}
+export interface CategoryDescription {
+    id: string;
+    name: keyof typeof messages;
+    icon: any;
+    order: number;
+}
+export interface OnToneSelected {
+    (variation: ToneValueType): void;
+}
+export interface OnToneSelectorCancelled {
+    (): void;
+}
+export interface OnEmojiEvent<T = any> {
+    (emojiId: EmojiId, emoji: OptionalEmojiDescription, event?: SyntheticEvent<T>): void;
+}
+export interface OnCategory {
+    (categoryId: CategoryId | null): void;
+}
+export declare enum SearchSort {
+    None = 0,
+    Default = 1,
+    UsageFrequency = 2
+}
+export declare enum SearchSourceTypes {
+    PICKER = "picker",
+    TYPEAHEAD = "typeahead"
+}
+export interface SearchOptions {
+    skinTone?: number;
+    limit?: number;
+    sort?: SearchSort;
+    source?: SearchSourceTypes;
+}
+export interface EmojiSearchResult {
+    emojis: EmojiDescription[];
+    query?: string;
+}
+export type ToneSelection = number | undefined;
+export interface EmojiUpload {
+    name: string;
+    shortName: string;
+    filename: string;
+    dataURL: string;
+    width: number;
+    height: number;
+}
+export interface User {
+    id: string;
+}
+export type OptionalUser = User | undefined;
+export type Message = React.ReactNode | string;
+export declare enum ProviderTypes {
+    SITE = "SITE",
+    STANDARD = "STANDARD",
+    ATLASSIAN = "ATLASSIAN",
+    UNKNOWN = "UNKNOWN",
+    SINGLE = "SINGLE"
+}
+export declare enum UfoExperienceName {
+    EMOJI_RENDERED = "emoji-rendered",
+    EMOJI_RESOURCE_FETCHED = "emoji-resource-fetched",
+    EMOJI_PICKER_OPENED = "emoji-picker-opened",
+    EMOJI_SELECTION_RECORDED = "emoji-selection-recorded",
+    EMOJI_UPLOADED = "emoji-uploaded",
+    EMOJI_SEARCHED = "emoji-searched"
+}
+export declare enum UfoComponentName {
+    EMOJI = "emoji",
+    EMOJI_PICKER = "emoji-picker",
+    EMOJI_PROVIDER = "emoji-provider"
+}
+export declare enum UfoEmojiTimingsKeys {
+    FMP = "fmp",
+    MOUNTED = "emoji-mount",
+    METADATA = "emoji-metadata",
+    MEDIADATA = "emoji-media",
+    ONLOAD = "emoji-onload"
+}
+export declare enum UfoEmojiTimings {
+    FMP_END = "fmp",
+    MOUNTED_END = "emoji-mount_end",
+    METADATA_START = "emoji-metadata_start",
+    METADATA_END = "emoji-metadata_end",
+    MEDIA_START = "emoji-media_start",
+    MEDIA_END = "emoji-media_end",
+    ONLOAD_START = "emoji-onload_start",
+    ONLOAD_END = "emoji-onload_end"
+}
+export type ToneValueType = number;