@atlaskit/emoji 65.2.0 → 65.2.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @atlaskit/emoji
 
+## 65.2.1
+
+### Patch Changes
+
+- [`8cc2f888c83`](https://bitbucket.org/atlassian/atlassian-frontend/commits/8cc2f888c83) - Upgrade Typescript from `4.3.5` to `4.5.5`
+
 ## 65.2.0
 
 ### Minor Changes

package/admin/package.json

@@ -4,5 +4,12 @@
   "module": "../dist/esm/admin.js",
   "module:es2019": "../dist/es2019/admin.js",
   "sideEffects": false,
-  "types": "../dist/types/admin.d.ts"
+  "types": "../dist/types/admin.d.ts",
+  "typesVersions": {
+    ">=4.0 <4.5": {
+      "*": [
+        "../dist/types-ts4.0/admin.d.ts"
+      ]
+    }
+  }
 }

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/emoji",
-	"version": "65.2.0",
+	"version": "65.2.1",
 	"sideEffects": false
 }

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/emoji",
-	"version": "65.2.0",
+	"version": "65.2.1",
 	"sideEffects": false
 }

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/emoji",
-	"version": "65.2.0",
+	"version": "65.2.1",
 	"sideEffects": false
 }

package/dist/types-ts4.0/admin.d.ts

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

package/dist/types-ts4.0/api/EmojiLoader.d.ts

@@ -0,0 +1,13 @@
+import { EmojiResponse } from '../types';
+import { EmojiLoaderConfig } from './EmojiUtils';
+/**
+ * Emoji providers should return JSON in the format defined by EmojiServiceResponse.
+ */
+export default class EmojiLoader {
+    private config;
+    constructor(config: EmojiLoaderConfig);
+    /**
+     * Returns a promise with an array of Emoji from all providers.
+     */
+    loadEmoji(): Promise<EmojiResponse>;
+}

package/dist/types-ts4.0/api/EmojiRepository.d.ts

@@ -0,0 +1,72 @@
+import { CategoryId } from '../components/picker/categories';
+import { EmojiDescription, EmojiSearchResult, OptionalEmojiDescription, SearchOptions } from '../types';
+import { UsageFrequencyTracker } from './internal/UsageFrequencyTracker';
+export declare const getEmojiVariation: (emoji: EmojiDescription, options?: SearchOptions | undefined) => EmojiDescription;
+export default class EmojiRepository {
+    private emojis;
+    private fullSearch;
+    private shortNameMap;
+    private idMap;
+    private asciiMap;
+    private dynamicCategoryList;
+    private static readonly defaultEmojiWeight;
+    protected usageTracker: UsageFrequencyTracker;
+    constructor(emojis: EmojiDescription[], usageTracker?: UsageFrequencyTracker);
+    /**
+     * Returns all available (and searchable) emoji in some default order.
+     */
+    all(): EmojiSearchResult;
+    /**
+     * Text search of emoji shortName and name field for suitable matches.
+     *
+     * Returns an array of all (searchable) emoji if query is empty or null, otherwise returns matching emoji.
+     *
+     * You can change how the results are sorted by specifying a custom EmojiComparator in the SearchOptions. If
+     * you don't want any sorting you can also disable via the SearchOptions (this might be a useful optimisation).
+     * If no sort is specified in SearchOptions then a default sorting it applied based on the query.
+     */
+    search(query?: string, options?: SearchOptions): EmojiSearchResult;
+    /**
+     * Returns all emoji with matching shortName
+     */
+    findAllMatchingShortName(shortName: string): EmojiDescription[];
+    /**
+     * Returns the first matching emoji matching the shortName, or null if none found.
+     */
+    findByShortName(shortName: string): OptionalEmojiDescription;
+    /**
+     * Returns the first matching emoji matching the id, or null if none found.
+     */
+    findById(id: string): OptionalEmojiDescription;
+    findByAsciiRepresentation(asciiEmoji: string): OptionalEmojiDescription;
+    findInCategory(categoryId: CategoryId): EmojiDescription[];
+    addUnknownEmoji(emoji: EmojiDescription): void;
+    getAsciiMap(): Map<string, EmojiDescription>;
+    /**
+     * Return the most frequently used emoji, ordered from most frequent to least frequent. Return an empty array if
+     * there are none.
+     *
+     * @param options optional settings to be applied to the set of frequently used emoji
+     */
+    getFrequentlyUsed(options?: SearchOptions): EmojiDescription[];
+    getDynamicCategoryList(): CategoryId[];
+    /**
+     * Call this on emoji usage to allow the EmojiRepository to track the usage of emoji (which could be useful
+     * in sorting, etc).
+     *
+     * @param emoji the emoji that was just used
+     */
+    used(emoji: EmojiDescription): void;
+    delete(emoji: EmojiDescription): void;
+    private withAsciiMatch;
+    private applySearchOptions;
+    private initMembers;
+    /**
+     * Optimisation to initialise all map member variables in single loop over emojis
+     */
+    private initRepositoryMetadata;
+    private initSearchIndex;
+    private getAllSearchableEmojis;
+    private addToMaps;
+    private addToDynamicCategories;
+}

package/dist/types-ts4.0/api/EmojiRepositoryRegex.d.ts

@@ -0,0 +1 @@
+export declare const tokenizerRegex: RegExp;

package/dist/types-ts4.0/api/EmojiResource.d.ts

@@ -0,0 +1,123 @@
+import { AbstractResource, OnProviderChange, ServiceConfig } from '@atlaskit/util-service-support';
+import { CategoryId } from '../components/picker/categories';
+import { EmojiDescription, EmojiId, EmojiProvider, EmojiResponse, EmojiSearchResult, EmojiUpload, OptionalEmojiDescription, OptionalEmojiDescriptionWithVariations, OptionalUser, SearchOptions, ToneSelection, UploadingEmojiProvider, User } from '../types';
+import EmojiRepository from './EmojiRepository';
+import SiteEmojiResource from './media/SiteEmojiResource';
+import { OptimisticImageApiLoaderConfig, SingleEmojiApiLoaderConfig } from './EmojiUtils';
+export type { EmojiProvider, UploadingEmojiProvider } from '../types';
+export interface EmojiResourceConfig {
+    /**
+     * The service configuration for remotely recording emoji selections.
+     * A post will be performed to this URL with the EmojiId as the body.
+     */
+    recordConfig?: ServiceConfig;
+    /**
+     * This defines the different providers. Later providers will override earlier
+     * providers when performing shortName based look up.
+     */
+    providers: ServiceConfig[];
+    /**
+     * Must be set to true to enable upload support in the emoji components.
+     *
+     * Can be used for the restriction of the upload UI based on permissions, or feature flags.
+     *
+     * Note this also requires that other conditions are met (for example, one of the providers
+     * must support upload for the UploadingEmojiResource implementation of UploadingEmojiProvider).
+     */
+    allowUpload?: boolean;
+    /**
+     * Logged user in the Product.
+     */
+    currentUser?: User;
+    /**
+     * This is specifically used for fetching a meta information of a single emoji.
+     * Useful for when rendering a single or a subset of emojis on a page that does not require the
+     * whole provider list to be downloaded.
+     */
+    singleEmojiApi?: SingleEmojiApiLoaderConfig;
+    /**
+     * Renders an image while the provider is being downloaded to reduce the time
+     * the user is being presented with a placeholder
+     */
+    optimisticImageApi?: OptimisticImageApiLoaderConfig;
+}
+export interface OnEmojiProviderChange extends OnProviderChange<EmojiSearchResult, any, void> {
+}
+export interface Retry<T> {
+    (): Promise<T> | T;
+}
+export interface ResolveReject<T> {
+    resolve(result: T): void;
+    reject(reason?: any): void;
+}
+/**
+ * Checks if the emojiProvider can support uploading at a feature level.
+ *
+ * Follow this up with an isUploadSupported() check to see if the provider is actually
+ * configured to support uploads.
+ * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates
+ */
+export declare const supportsUploadFeature: (emojiProvider: EmojiProvider) => emojiProvider is UploadingEmojiProvider;
+export interface LastQuery {
+    query?: string;
+    options?: SearchOptions;
+}
+export declare class EmojiResource extends AbstractResource<string, EmojiSearchResult, any, undefined, SearchOptions> implements EmojiProvider {
+    protected recordConfig?: ServiceConfig;
+    protected emojiRepository?: EmojiRepository;
+    protected lastQuery?: LastQuery;
+    protected activeLoaders: number;
+    protected retries: Map<Retry<any>, ResolveReject<any>>;
+    protected siteEmojiResource?: SiteEmojiResource;
+    protected selectedTone: ToneSelection;
+    protected currentUser?: User;
+    protected isInitialised: boolean;
+    emojiProviderConfig: EmojiResourceConfig;
+    constructor(config: EmojiResourceConfig);
+    fetchEmojiProvider(force?: boolean): Promise<EmojiRepository | undefined>;
+    fetchByEmojiId(emojiId: EmojiId, optimistic: boolean): Promise<OptionalEmojiDescriptionWithVariations>;
+    private getProviderType;
+    protected initEmojiRepository(emojiResponses: EmojiResponse[]): void;
+    protected initSiteEmojiResource(emojiResponse: EmojiResponse, provider: ServiceConfig): Promise<void>;
+    private performRetries;
+    getOptimisticImageURL: (emojiId: EmojiId) => string | undefined;
+    private loadStoredTone;
+    protected refreshLastFilter(): void;
+    protected isLoaded: () => false | EmojiRepository | undefined;
+    protected retryIfLoading<T>(retry: Retry<T>, defaultResponse: T): Promise<T>;
+    protected notifyResult(result: EmojiSearchResult): void;
+    /**
+     *  Returns the EmojiDescription with a valid media path that includes query token and client attributes to access the emoji media inline.
+     */
+    getMediaEmojiDescriptionURLWithInlineToken(emoji: EmojiDescription): Promise<EmojiDescription>;
+    loadMediaEmoji(emoji: EmojiDescription, useAlt?: boolean): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    optimisticMediaRendering(emoji: EmojiDescription, useAlt?: boolean): boolean;
+    filter(query?: string, options?: SearchOptions): void;
+    findByShortName(shortName: string): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    findByEmojiId(emojiId: EmojiId): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    findById(id: string): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    findInCategory(categoryId: CategoryId): Promise<EmojiDescription[]>;
+    getAsciiMap(): Promise<Map<string, EmojiDescription>>;
+    getFrequentlyUsed(options?: SearchOptions): Promise<EmojiDescription[]>;
+    /**
+     * Record the selection of an emoji to a remote service if 'recordConfig' has been supplied.
+     * Regardless of the recordConfig, emoji selections will always be recorded on the EmojiRepository
+     * for the purposes of tracking the frequency of use.
+     *
+     * @param emoji The full description of the emoji to record usage for.
+     */
+    recordSelection(emoji: EmojiDescription): Promise<any>;
+    deleteSiteEmoji(emoji: EmojiDescription): Promise<boolean>;
+    getSelectedTone(): ToneSelection;
+    setSelectedTone(tone: ToneSelection): void;
+    calculateDynamicCategories(): Promise<CategoryId[]>;
+    getCurrentUser(): OptionalUser;
+    protected addUnknownEmoji(emoji: EmojiDescription): void;
+}
+export default class UploadingEmojiResource extends EmojiResource implements UploadingEmojiProvider {
+    protected allowUpload: boolean;
+    constructor(config: EmojiResourceConfig);
+    isUploadSupported(): Promise<boolean>;
+    uploadCustomEmoji(upload: EmojiUpload, retry?: boolean): Promise<EmojiDescription>;
+    prepareForUpload(): Promise<void>;
+}

package/dist/types-ts4.0/api/EmojiUtils.d.ts

@@ -0,0 +1,24 @@
+import { RequestServiceOptions, ServiceConfig } from '@atlaskit/util-service-support';
+import { AltRepresentations, EmojiDescription, EmojiDescriptionWithVariations, EmojiMeta, EmojiRepresentation, EmojiResponse, EmojiServiceDescriptionWithVariations, EmojiServiceRepresentation, EmojiServiceResponse, EmojiId } from '../types';
+export interface EmojiLoaderConfig extends ServiceConfig {
+    getRatio?: () => number;
+}
+export interface SingleEmojiApiLoaderConfig extends ServiceConfig {
+    getUrl: (emojiId: EmojiId) => string;
+}
+export interface OptimisticImageApiLoaderConfig extends ServiceConfig {
+    getUrl: (emojiId: EmojiId) => string;
+}
+export declare const emojiRequest: (provider: EmojiLoaderConfig, options?: RequestServiceOptions | undefined) => Promise<EmojiServiceResponse>;
+export declare const getPixelRatio: () => number;
+export declare const getAltRepresentation: (reps: AltRepresentations) => EmojiServiceRepresentation;
+export declare const isMediaApiUrl: (url: string, meta?: EmojiMeta | undefined) => boolean;
+export declare const denormaliseServiceRepresentation: (representation: EmojiServiceRepresentation, meta?: EmojiMeta | undefined) => EmojiRepresentation;
+export declare const denormaliseServiceAltRepresentation: (altReps?: AltRepresentations | undefined, meta?: EmojiMeta | undefined) => EmojiRepresentation;
+export declare const denormaliseSkinEmoji: (emoji: EmojiServiceDescriptionWithVariations, meta?: EmojiMeta | undefined) => EmojiDescriptionWithVariations[];
+/**
+ * Denormalised an emoji response (emojis + sprite references) into an array of
+ * emoji with local sprite definitions.
+ */
+export declare const denormaliseEmojiServiceResponse: (emojiData: EmojiServiceResponse) => EmojiResponse;
+export declare const shouldUseAltRepresentation: (emoji: EmojiDescription, fitToHeight?: number | undefined) => boolean;

package/dist/types-ts4.0/api/internal/Comparators.d.ts

@@ -0,0 +1,109 @@
+import { EmojiDescription } from '../../types';
+/**
+ * Create the default sort comparator to be used for the user queries against emoji
+ *
+ * @param query the query used in the search to be sorted. Any colons will be stripped from the query and it will be
+ * converted to lowercase.
+ * @param orderedIds the id of emoji ordered by how frequently they are used
+ */
+export declare function createSearchEmojiComparator(query?: string, orderedIds?: Array<string>): EmojiComparator;
+export declare function createUsageOnlyEmojiComparator(orderedIds: Array<string>): EmojiComparator;
+/**
+ * Returns a number representing the result of comparing e1 and e2.
+ * Compatible with Array.sort, which is to say -
+ *   - less than 0 if e1 should come first
+ *   - 0 if they are equal; e1 and e2 will be unchanged in position relative to each other
+ *   - greater than 0 if e2 should come first.
+ */
+export interface EmojiComparator {
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+}
+/**
+ * A combinator comparator that applies an ordered chained of sub-comparators. The first comparator that
+ * returns a non-zero value stops the chain and causes that value to be returned. If a comparator returns a
+ * zero then the next one in the chain is tried.
+ *
+ * If no comparators in the chain return a non-zero value then zero will be returned.
+ */
+export declare class ChainedEmojiComparator implements EmojiComparator {
+    private chain;
+    constructor(...comparators: EmojiComparator[]);
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+}
+/**
+ * Orders two emoji such that if one of them has an ascii representation that exactly matches the query then it will
+ * be ordered first.
+ */
+export declare class AsciiMatchComparator implements EmojiComparator {
+    private query;
+    constructor(query: string);
+    compare(e1: EmojiDescription, e2: EmojiDescription): 0 | 1 | -1;
+}
+/**
+ * Orders two emoji such that the one who's shortname matches the query exactly comes first. If there are matching
+ * shortnames then the type of emoji is taken into account with SITE emoji coming first.
+ */
+export declare class ExactShortNameMatchComparator implements EmojiComparator {
+    private colonQuery;
+    private typeComparator;
+    constructor(query: string);
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+}
+/**
+ * Orders two emoji based on their type, with the types being STANDARD, ATLASSIAN and SITE (in that order).
+ * If the comparator is configured to 'reverse' then the order will be SITE, ATLASSIAN, STANDARD.
+ *
+ * Regardless of the reverse setting, an unknown type will always come last.
+ */
+export declare class EmojiTypeComparator implements EmojiComparator {
+    private typeToNumber;
+    constructor(reverse?: boolean);
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+    private emojiTypeToOrdinal;
+}
+/**
+ * Order two emoji such as the one which is more frequently used comes first. If neither have any usage
+ * information then leave their order unchanged.
+ */
+export declare class UsageFrequencyComparator implements EmojiComparator {
+    private positionLookup;
+    constructor(orderedIds: Array<string>);
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+    /**
+     * Get the ordinal representing the position of this emoji.
+     *
+     * @param id the id of the emoji
+     */
+    private getPositionInOrder;
+}
+declare type KeysOfType<T, TProp> = {
+    [P in keyof T]: T[P] extends TProp | undefined ? P : never;
+}[keyof T];
+/**
+ * A comparator that will sort higher an emoji which matches the query string earliest in the indicated
+ * property.
+ */
+export declare class QueryStringPositionMatchComparator implements EmojiComparator {
+    private readonly propertyName;
+    private query;
+    /**
+     * @param query the query to match
+     * @param propertyToCompare the property of EmojiDescription to check for query within
+     */
+    constructor(query: string, propertyToCompare: KeysOfType<EmojiDescription, string>);
+    private getScore;
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+}
+export declare class OrderComparator implements EmojiComparator {
+    private static INSTANCE;
+    private constructor();
+    static get Instance(): OrderComparator;
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+}
+export declare class AlphabeticalShortnameComparator implements EmojiComparator {
+    private static INSTANCE;
+    private constructor();
+    static get Instance(): AlphabeticalShortnameComparator;
+    compare(e1: EmojiDescription, e2: EmojiDescription): number;
+}
+export {};

package/dist/types-ts4.0/api/internal/UsageFrequencyTracker.d.ts

@@ -0,0 +1,46 @@
+import { EmojiDescription } from '../../types';
+import DuplicateLimitedQueue from '../../util/DuplicateLimitedQueue';
+/**
+ * Keeps track of the last 150 emoji usages, although limiting the maximum count for a single emoji to 25 to
+ * ensure we don't end up with only a single emoji being recorded. Usage is persisted to local storage for
+ * consistency between 'sessions'.
+ *
+ * Skin tone variations for an emoji will be 'collapsed' so they are tracked as their base emoji. Gender
+ * variations are not collapsed in this way and will be tracked per gender. This decision reflects the UI of
+ * the EmojiPicker component.
+ */
+export declare class UsageFrequencyTracker {
+    private static readonly queueOptions;
+    protected queue: DuplicateLimitedQueue<string>;
+    private gateway;
+    constructor(useStorageIfPossible?: boolean);
+    /**
+     * Record the fact that the supplied emoji was used. You should note that usage is updated asynchronously so you can not
+     * count on getOrder() reflecting this usage immediately.
+     *
+     * @param emoji the emoji who's usage is to be recorded. If the emoji has no id then no usage will be recorded
+     */
+    recordUsage(emoji: EmojiDescription): void;
+    /**
+     * Returns an array of emoji id (without skin tone variations) sorted by most used to least used. If there
+     * are no usages then an empty array will be returned.
+     */
+    getOrder(): Array<string>;
+    /**
+     * Exposed for testing only. Clear any recorded usage.
+     */
+    clear(): void;
+}
+export declare class Gateway {
+    private maximumPermitted;
+    private count;
+    constructor(maximumPermitted: number);
+    /**
+     * Run the supplied function if the count of already submitted work allows it. Drop the work
+     * if it's not allowed to run.
+     *
+     * Will return true if the function has been submitted or false if it was not submitted.
+     */
+    submit(f: () => void): boolean;
+    private completed;
+}

package/dist/types-ts4.0/api/media/MediaEmojiCache.d.ts

@@ -0,0 +1,53 @@
+import { EmojiDescription, OptionalEmojiDescription } from '../../types';
+import MediaImageLoader from './MediaImageLoader';
+import TokenManager from './TokenManager';
+export interface EmojiCacheStrategy {
+    loadEmoji(emoji: EmojiDescription, useAlt?: boolean): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    optimisticRendering(): boolean;
+}
+/**
+ * For browsers that support caching for resources
+ * regardless of originally supplied headers (basically everything but Firefox).
+ */
+export declare class BrowserCacheStrategy implements EmojiCacheStrategy {
+    private cachedImageUrls;
+    private mediaImageLoader;
+    constructor(mediaImageLoader: MediaImageLoader);
+    loadEmoji(emoji: EmojiDescription, useAlt?: boolean): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    optimisticRendering(): boolean;
+    static supported(mediaPath: string, mediaImageLoader: MediaImageLoader): Promise<boolean>;
+}
+/**
+ * For browsers that do no cache images without equivalent headers (e.g. Firefox).
+ *
+ * Images are cached in memory in a LRU cache. Images considered too large,
+ * are not cached, but retrieved each time.
+ *
+ * Images are still cached by the browser, but loading in asynchronous with
+ * small delay noticable to the end user.
+ */
+export declare class MemoryCacheStrategy implements EmojiCacheStrategy {
+    private dataURLCache;
+    private mediaImageLoader;
+    constructor(mediaImageLoader: MediaImageLoader);
+    loadEmoji(emoji: EmojiDescription, useAlt?: boolean): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    optimisticRendering(): boolean;
+}
+/**
+ * Provides a cache for Media Emoji.
+ *
+ * Emoji are returned immediately if cached and ready to use by the browser.
+ *
+ * Otherwise, they are loaded and returned via a promise.
+ */
+export default class MediaEmojiCache {
+    protected cache?: EmojiCacheStrategy;
+    protected waitingInitUrls: string[];
+    private cacheLoading;
+    private mediaImageLoader;
+    constructor(tokenManager: TokenManager);
+    loadEmoji(emoji: EmojiDescription, useAlt?: boolean): OptionalEmojiDescription | Promise<OptionalEmojiDescription>;
+    optimisticRendering(url: string): boolean | Promise<boolean>;
+    protected getCache(url: string): EmojiCacheStrategy | Promise<EmojiCacheStrategy>;
+    private initCache;
+}

package/dist/types-ts4.0/api/media/MediaImageLoader.d.ts

@@ -0,0 +1,21 @@
+import TokenManager from './TokenManager';
+export declare type DataURL = string;
+export interface MediaImageLoaderOptions {
+    concurrentDownloadLimit: number;
+}
+export default class MediaImageLoader {
+    private tokenManager;
+    private mediaImageQueue;
+    private activeProcessing;
+    private concurrentDownloadLimit;
+    private pendingRequests;
+    constructor(tokenManager: TokenManager, options?: MediaImageLoaderOptions);
+    loadMediaImage(url: string): Promise<DataURL>;
+    getQueueSize(): number;
+    getActiveDownloads(): number;
+    private processFromQueue;
+    private completedItem;
+    private delay;
+    private requestMediaEmoji;
+    private readBlob;
+}

package/dist/types-ts4.0/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.0/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 declare 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.0/components/common/CachingEmoji.d.ts

@@ -0,0 +1,20 @@
+import { FC } from 'react';
+import { EmojiDescription } from '../../types';
+import { Props as EmojiProps } from './Emoji';
+export interface State {
+    cachedEmoji?: EmojiDescription;
+    invalidImage?: boolean;
+}
+export interface CachingEmojiProps extends EmojiProps {
+    placeholderSize?: number;
+}
+/**
+ * Renders an emoji from a cached image, if required.
+ */
+export declare const CachingEmoji: FC<CachingEmojiProps>;
+/**
+ * Rendering a media emoji image from a cache for media emoji, with different
+ * rendering paths depending on caching strategy.
+ */
+export declare const CachingMediaEmoji: FC<CachingEmojiProps>;
+export default CachingEmoji;

package/dist/types-ts4.0/components/common/DeleteButton.d.ts

@@ -0,0 +1,4 @@
+import { CustomThemeButtonProps } from '@atlaskit/button/custom-theme-button';
+import { FC } from 'react';
+declare const DeleteButton: FC<CustomThemeButtonProps>;
+export default DeleteButton;