@atlaskit/util-data-test 17.8.2 → 17.8.4

package/dist/types/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/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/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;

package/dist/types/emoji/src/util/DuplicateLimitedQueue.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The options used to configure a newly constructed queue.
+ */
+export interface QueueOptions {
+    /**
+     * The maximum number of duplicates allowed per item in the queue.
+     */
+    maxDuplicates: number;
+    /**
+     * The minimum number of unique items the queue should try to contain.
+     * This number constrains the absolute size of the queue. It needs to be
+     * large enough to contain maxDuplicates * minUniqueItems.
+     */
+    minUniqueItems: number;
+}
+/**
+ * A queue which will limit the number of duplicates of type T that it holds. When the duplicate limit is
+ * reached the earliest inserted duplicate (the "original") is removed to make room for the new insertion.
+ */
+export default class DuplicateLimitedQueue<T> {
+    private maximumSize;
+    private perItemSize;
+    private items;
+    private itemCountMap;
+    /**
+     * An array derived from items and itemCountMap which holds each item once and is ordered by
+     * how often an item is duplicated in the items array.
+     */
+    private itemsOrderedByFrequency;
+    /**
+     * Construct a new DuplicateLimitedQueue.
+     *
+     * @param options the options for this queue.
+     */
+    constructor(options: QueueOptions);
+    /**
+     * @param item the item to add to the queue.
+     */
+    enqueue(item: T): void;
+    /**
+     * Return the items in the queue, ordered by how often they are duplicated. The items with the
+     * most duplicates come first in the returned Array.
+     *
+     * If there are no items in the queue then an empty Array will be returned.
+     */
+    getItemsOrderedByDuplicateCount(): Array<T>;
+    /**
+     * Exposed for storybook/testing purposes only. Clear the contents of the queue.
+     */
+    clear(): void;
+    /**
+     * A more efficient mechanism for adding multiple items. Ordering is only performed once all
+     * the items have been added.
+     *
+     * @param items the items to be enqueued, which happens in their presented order.
+     */
+    protected bulkEnqueue(items: T[]): void;
+    /**
+     * Return the items currently stored in the queue.
+     */
+    protected getItems(): T[];
+    private createEmptyState;
+    /**
+     * Enqueue the supplied item, keeping consistency with the limits configured. However no ordering is
+     * performed by this enqueuing. You must trigger that manually if required.
+     *
+     * @param item the item to be queued
+     */
+    private enqueueWithoutOrdering;
+    /**
+     * Get an array of items from the queue ordered by how often they are duplicated in the queue.
+     */
+    private orderItemsByFrequency;
+    private decrementCount;
+    /**
+     * Walk the list of items and remove the first occurrence of the matching item.
+     *
+     * @param item the item to be removed.
+     */
+    private removeFirstOccurrence;
+    /**
+     * Remove the first item from the queue and update the itemCountMap accordingly.
+     * @return the item add the front of the queue or undefined if the queue is empty
+     */
+    private remove;
+    /**
+     * Add the supplied item to the end of the queue and update the itemCountMap accordingly.
+     * @param item the item to be added to the queue
+     */
+    private add;
+}

package/dist/types/emoji/src/util/StoredDuplicateLimitedQueue.d.ts

@@ -0,0 +1,46 @@
+import DuplicateLimitedQueue, { QueueOptions } from './DuplicateLimitedQueue';
+/**
+ * The options used to configure a newly constructed queue.
+ */
+export interface StoredQueueOptions extends QueueOptions {
+    /**
+     * The Storage that will be used to persist the queue contents.
+     */
+    storage: Storage;
+    /**
+     * An identifier to be prefixed on the keys used to store data.
+     */
+    storagePrefix: string;
+}
+/**
+ * An extension to the DuplicateLimitedQueue that will initialise its contents from the
+ * supplied Storage and will also update the storage for every new item enqueued.
+ */
+export default class StoredDuplicateLimitedQueue<T> extends DuplicateLimitedQueue<T> {
+    private static readonly storageKey;
+    private storage;
+    private prefixedStorageKey;
+    constructor(options: StoredQueueOptions);
+    /**
+     * Enqueue the supplied item and also persist the new contents of the queue to storage.
+     *
+     * @param item the item to be enqueued
+     */
+    enqueue(item: T): void;
+    /**
+     * Exposed for storybook/testing purposes only. Clear the contents of the queue, and localStorage.
+     */
+    clear(): void;
+    /**
+     * Initialise the queue contents from the configured Storage. If there is no data found in
+     * storage then the queue will have no items added. Likewise, a failure to read or parse stored
+     * data will be swallowed and no items are added to the queue.
+     */
+    private load;
+    /**
+     * Save the current items in the queue, overwriting any previously stored queue.
+     * Any failure in saving will be silently ignored with the likely outcome that any previous
+     * saved items will remain unchanged in storage.
+     */
+    private save;
+}

package/dist/types/emoji/src/util/analytics/samplingUfo.d.ts

@@ -0,0 +1,38 @@
+import { UFOExperience } from '@atlaskit/ufo';
+export interface UFOExperienceSampledRecords {
+    [experienceName: string]: UFOExperienceSampledRecord;
+}
+interface SamplingInstancesRecord {
+    [key: string]: boolean;
+}
+interface UFOExperienceSampledRecord {
+    sampledInstance: SamplingInstancesRecord;
+    sampled: boolean;
+}
+export interface WithSamplingUFOExperience extends Omit<UFOExperience, 'start'> {
+    start: (options: {
+        samplingRate: number;
+        samplingFunc?: SamplingFunc;
+        startTime?: number;
+    }) => Promise<void>;
+}
+export declare const ufoExperiencesSampled: UFOExperienceSampledRecords;
+type SamplingFunc = (rate: number) => boolean;
+export declare const clearSampled: () => void;
+/**
+ * A random sampling function
+ * sampling algorithm is from @atlassian/jira-coinflip at https://stash.atlassian.com/projects/JIRACLOUD/repos/jira-frontend/browse/src/packages/platform/app-framework/coinflip/src/index.tsx
+ * E.g. isExperienceSampled(2) will pass 50% of the time
+ * @param rate The chance that it will pass (1 in <rate> times)
+ * @returns bool, if it passes or not
+ */
+export declare const isExperienceSampled: (rate: number) => boolean;
+/**
+ * This function is a temp solution to reduce the event traffic, as UFO package does not support it.
+ *
+ * e.g. Emoji Picker contains thousands of emojis, which means will trigger a large number of renderred events without sampling
+ * @param ufoExperience
+ * @returns
+ */
+export declare const withSampling: (ufoExperience: UFOExperience) => WithSamplingUFOExperience;
+export {};

package/dist/types/emoji/src/util/analytics/ufoExperiences.d.ts

@@ -0,0 +1,14 @@
+import { EmojiId, ProviderTypes } from '../../types';
+import { ConcurrentExperience, UFOExperience } from '@atlaskit/ufo';
+import { WithSamplingUFOExperience } from './samplingUfo';
+export declare const ufoExperiences: {
+    'emoji-rendered': ConcurrentExperience;
+    'emoji-resource-fetched': ConcurrentExperience;
+    'emoji-picker-opened': UFOExperience;
+    'emoji-selection-recorded': UFOExperience;
+    'emoji-uploaded': UFOExperience;
+    'emoji-searched': UFOExperience;
+};
+export declare const sampledUfoRenderedEmoji: (emojiId: EmojiId) => WithSamplingUFOExperience;
+export declare const hasUfoMarked: (ufoExperience: UFOExperience | WithSamplingUFOExperience, name: string) => boolean;
+export declare const sampledUfoEmojiResourceFetched: (providerType: ProviderTypes) => WithSamplingUFOExperience;

package/dist/types/emoji/src/util/constants.d.ts

@@ -0,0 +1,60 @@
+import { CategoryId } from '../components/picker/categories';
+export declare const customCategory = "CUSTOM";
+export declare const frequentCategory = "FREQUENT";
+export declare const customType = "SITE";
+export declare const searchCategory = "SEARCH";
+export declare const yourUploadsCategory = "USER_CUSTOM";
+export declare const customTitle = "allUploadsCustomCategory";
+export declare const userCustomTitle = "userUploadsCustomCategory";
+export declare const dataURLPrefix = "data:";
+export declare const deleteEmojiLabel = "delete-emoji";
+/**
+ * A constant used in sorting/ordering to represent a number 'obviously much bigger than any item in the set being handled'.
+ * This is used instead of Number.MAX_VALUE since subtraction of MAX_VALUE from itself occassionaly doesn't equal zero exactly :-(
+ */
+export declare const MAX_ORDINAL = 100000;
+export declare const defaultEmojiHeight = 20;
+export declare const emojiPickerWidth = 350;
+export declare const sizeGap = 80;
+export declare const defaultEmojiPickerSize = "medium";
+export declare const emojiPickerMinHeight = 260;
+export declare const emojiPickerHeight = 295;
+export declare const emojiPickerListHeight: number;
+export declare const emojiPickerPreviewHeight = 54;
+export declare const emojiPickerHeightWithPreview: number;
+export declare const localStoragePrefix = "fabric.emoji";
+export declare const selectedToneStorageKey: string;
+export declare const defaultCategories: CategoryId[];
+export declare enum KeyboardKeys {
+    ArrowLeft = "ArrowLeft",
+    ArrowRight = "ArrowRight",
+    ArrowUp = "ArrowUp",
+    ArrowDown = "ArrowDown",
+    PageUp = "PageUp",
+    PageDown = "PageDown",
+    Home = "Home",
+    End = "End",
+    Enter = "Enter",
+    Tab = "Tab",
+    Space = " ",
+    Backspace = "Backspace"
+}
+export declare enum KeyboardNavigationDirection {
+    Down = "Down",
+    Up = "Up",
+    Left = "Left",
+    Right = "Right"
+}
+export declare const CATEGORYSELECTOR_KEYBOARD_KEYS_SUPPORTED: string[];
+export declare const EMOJI_KEYBOARD_KEYS_SUPPORTED: string[];
+export declare const TONESELECTOR_KEYBOARD_KEYS_SUPPORTED: string[];
+export declare const EMOJIPICKERLIST_KEYBOARD_KEYS_SUPPORTED: string[];
+export declare const DEFAULT_TONE = 0;
+export declare const defaultListLimit = 50;
+export declare const migrationUserId = "hipchat_migration_emoticons";
+export declare const analyticsEmojiPrefix = "atlassian.fabric.emoji.picker";
+export declare const EMOJI_LIST_COLUMNS = 8;
+export declare const EMOJI_LIST_PAGE_COUNT = 5;
+export declare const EMOJI_SEARCH_DEBOUNCE = 150;
+export declare const SAMPLING_RATE_EMOJI_RENDERED_EXP = 20;
+export declare const SAMPLING_RATE_EMOJI_RESOURCE_FETCHED_EXP = 100;

package/dist/types/emoji/src/util/image.d.ts

@@ -0,0 +1,10 @@
+export declare const getNaturalImageSize: (dataURL: string) => Promise<{
+    width: number;
+    height: number;
+}>;
+export declare const parseImage: (dataURL: string) => Promise<{
+    src: string;
+}>;
+export declare const hasFileExceededSize: (file: File) => boolean;
+export declare const checkWebpSupport: () => Promise<boolean>;
+export declare const imageAcceptHeader: () => Promise<string>;

package/dist/types/emoji/src/util/logger.d.ts

@@ -0,0 +1,4 @@
+export declare function enableLogger(enable: boolean): void;
+export declare function enableStacktraces(enable: boolean): void;
+export declare function logStacktrace(): void;
+export default function debug(msg: any, ...args: any[]): void;

package/dist/types/emoji/src/util/storage-available.d.ts

@@ -0,0 +1,3 @@
+type StorageType = 'localStorage';
+export default function storageAvailable(type: StorageType): boolean | undefined;
+export {};

package/dist/types/emoji/src/util/type-helpers.d.ts

@@ -0,0 +1,23 @@
+import { CategoryId } from '../components/picker/categories';
+import { EmojiDescription, EmojiDescriptionWithVariations, EmojiId, EmojiImageRepresentation, EmojiRepresentation, EmojiServiceRepresentation, EmojiVariationDescription, ImageRepresentation, MediaApiRepresentation, OptionalEmojiDescription, SpriteRepresentation, SpriteServiceRepresentation } from '../types';
+export declare const isSpriteServiceRepresentation: (rep: EmojiServiceRepresentation) => rep is SpriteServiceRepresentation;
+export declare const isSpriteRepresentation: (rep: EmojiRepresentation) => rep is SpriteRepresentation;
+export declare const isImageRepresentation: (rep: EmojiRepresentation | EmojiServiceRepresentation | EmojiImageRepresentation) => rep is ImageRepresentation;
+export declare const isMediaRepresentation: (rep: EmojiRepresentation | EmojiImageRepresentation) => rep is MediaApiRepresentation;
+export declare const isPromise: <T>(p: any) => p is Promise<T>;
+export declare const isEmojiDescription: (possibleEmojiDescription: any) => possibleEmojiDescription is EmojiDescription;
+export declare const isMediaEmoji: (emoji: EmojiDescription) => boolean;
+export declare const hasDataURLImage: (rep: EmojiRepresentation) => boolean;
+export declare const isLoadedMediaEmoji: (emoji: EmojiDescription) => boolean;
+export declare const isEmojiDescriptionWithVariations: (emoji: OptionalEmojiDescription) => emoji is EmojiDescriptionWithVariations;
+export declare const isEmojiVariationDescription: (object: any) => object is EmojiVariationDescription;
+export declare const isMessagesKey: (key: string) => key is "deleteEmojiTooltip" | "deleteEmojiTooltipForScreenreader" | "deleteEmojiTitle" | "deleteEmojiDescription" | "deleteEmojiLabel" | "addCustomEmojiLabel" | "emojiPlaceholder" | "emojiNameAriaLabel" | "emojiChooseFileTitle" | "emojiChooseFileScreenReaderDescription" | "emojiSelectSkinToneButtonAriaLabelText" | "emojiSelectSkinToneListAriaLabelText" | "emojiImageRequirements" | "emojiPreviewTitle" | "emojiPreview" | "addEmojiLabel" | "retryLabel" | "cancelLabel" | "searchPlaceholder" | "searchLabel" | "searchResultsStatus" | "searchResultsStatusSeeAll" | "categoriesSelectorLabel" | "categoriesSearchResults" | "frequentCategory" | "peopleCategory" | "natureCategory" | "foodsCategory" | "activityCategory" | "placesCategory" | "objectsCategory" | "symbolsCategory" | "flagsCategory" | "productivityCategory" | "userUploadsCustomCategory" | "allUploadsCustomCategory" | "deleteEmojiFailed" | "emojiInvalidImage" | "emojiUploadFailed" | "emojiImageTooBig" | "emojiPickerTitle" | "emojiPickerListPanel" | "emojiPickerGrid" | "emojiButtonRoleDescription" | "error";
+export declare const toEmojiId: (emoji: EmojiDescription) => EmojiId;
+export declare const toOptionalEmojiId: (emoji: OptionalEmojiDescription) => EmojiId | undefined;
+export declare const isEmojiIdEqual: (l?: EmojiId, r?: EmojiId) => boolean | undefined;
+export declare const containsEmojiId: (emojis: EmojiDescription[], emojiId: EmojiId | undefined) => boolean;
+export declare const convertImageToMediaRepresentation: (rep: ImageRepresentation) => MediaApiRepresentation;
+export declare const convertMediaToImageRepresentation: (rep: MediaApiRepresentation, newImagePath?: string) => ImageRepresentation;
+export declare const convertMediaToImageEmoji: (emoji: EmojiDescription, newImagePath?: string, useAlt?: boolean) => EmojiDescription;
+export declare const buildEmojiDescriptionWithAltRepresentation: (emoji: EmojiDescriptionWithVariations, altRepresentation?: EmojiRepresentation) => EmojiDescriptionWithVariations;
+export declare const getCategoryId: (emoji: EmojiDescription) => CategoryId;