@atlaskit/util-data-test 17.8.2 → 17.8.4

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

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

@@ -0,0 +1,3 @@
+export { toEmojiId, toOptionalEmojiId } from './util/type-helpers';
+export { denormaliseEmojiServiceResponse } from './api/EmojiUtils';
+export { UsageFrequencyTracker } from './api/internal/UsageFrequencyTracker';

package/dist/types-ts4.5/mention/src/_constants.d.ts

@@ -0,0 +1 @@
+export declare const ELEMENTS_CHANNEL = "fabric-elements";

package/dist/types-ts4.5/mention/src/api/ContextMentionResource.d.ts

@@ -0,0 +1,23 @@
+import { MentionProvider, MentionContextIdentifier, ErrorCallback, InfoCallback, ResultCallback } from './MentionResource';
+import { MentionDescription, InviteFromMentionProvider } from '../types';
+export type { MentionDescription };
+export type MentionProviderFunctions = Omit<{
+    [Key in keyof MentionProvider]: MentionProvider[Key] extends Function ? MentionProvider[Key] : never;
+}, keyof InviteFromMentionProvider>;
+/**
+ * This component is stateful and should be instantianted per contextIdentifiers.
+ */
+export default class ContextMentionResource implements MentionProvider {
+    private mentionProvider;
+    private contextIdentifier;
+    constructor(mentionProvider: MentionProvider, contextIdentifier: MentionContextIdentifier);
+    getContextIdentifier(): MentionContextIdentifier | undefined;
+    callWithContextIds: <K extends "subscribe" | "unsubscribe" | "filter" | "recordMentionSelection" | "shouldHighlightMention" | "isFiltering">(f: K, declaredArgs: number) => MentionProvider[K];
+    callDefault: <K extends "subscribe" | "unsubscribe" | "filter" | "recordMentionSelection" | "shouldHighlightMention" | "isFiltering">(f: K) => MentionProvider[K];
+    subscribe: (key: string, callback?: ResultCallback<MentionDescription[]> | undefined, errCallback?: ErrorCallback | undefined, infoCallback?: InfoCallback | undefined, allResultsCallback?: ResultCallback<MentionDescription[]> | undefined, analyticsCallback?: import("../types").AnalyticsCallback | undefined) => void;
+    unsubscribe: (key: string) => void;
+    filter: (query?: string | undefined, contextIdentifier?: MentionContextIdentifier | undefined) => void;
+    recordMentionSelection: (mention: MentionDescription, contextIdentifier?: MentionContextIdentifier | undefined) => void;
+    shouldHighlightMention: (mention: MentionDescription) => boolean;
+    isFiltering: (query: string) => boolean;
+}

package/dist/types-ts4.5/mention/src/api/MentionNameClient.d.ts

@@ -0,0 +1,11 @@
+import { MentionNameDetails } from '../types';
+export interface MentionNameClient {
+    getLookupLimit(): number;
+    lookupMentionNames(ids: string[]): Promise<MentionNameDetails[]>;
+}
+/**
+ * Supports the Atlassian Profile retrieval service.
+ *
+ * Uses:
+ *   https://statlas.prod.atl-paas.net/swagger-ui-2.2.6/index.html?url=https://profile-retrieval-service.prod.atl-paas.net:443/api/swagger.yaml#!/default/getUsersByIds
+ */

package/dist/types-ts4.5/mention/src/api/MentionNameResolver.d.ts

@@ -0,0 +1,23 @@
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import { MentionNameDetails, MentionNameResolver } from '../types';
+import { MentionNameClient } from './MentionNameClient';
+export type { MentionNameResolver } from '../types';
+export declare class DefaultMentionNameResolver implements MentionNameResolver {
+    static waitForBatch: number;
+    private client;
+    private nameCache;
+    private nameQueue;
+    private nameStartTime;
+    private processingQueue;
+    private debounce;
+    private fireHydrationEvent;
+    constructor(client: MentionNameClient, analyticsProps?: WithAnalyticsEventsProps);
+    lookupName(id: string): Promise<MentionNameDetails> | MentionNameDetails;
+    cacheName(id: string, name: string): void;
+    private scheduleProcessQueue;
+    private isQueueAtLimit;
+    private splitQueueAtLimit;
+    private resolveQueueItem;
+    private processQueue;
+    private fireAnalytics;
+}

package/dist/types-ts4.5/mention/src/api/MentionResource.d.ts

@@ -0,0 +1,93 @@
+import { AnalyticsCallback, ErrorCallback, InfoCallback, InviteExperimentCohort, InviteFlow, MentionContextIdentifier, MentionDescription, MentionNameDetails, MentionProvider, MentionResourceConfig, MentionsResult, MentionStats, ResourceProvider, ResultCallback, UserRole } from '../types';
+export type { MentionStats, ResultCallback, ErrorCallback, InfoCallback, MentionResourceConfig, ResourceProvider, MentionContextIdentifier, MentionProvider, } from '../types';
+export interface TeamMentionResourceConfig extends MentionResourceConfig {
+    teamLinkResolver?: (teamId: string) => string;
+}
+/**
+ * Support
+ */
+export interface ResolvingMentionProvider extends MentionProvider {
+    resolveMentionName(id: string): Promise<MentionNameDetails> | MentionNameDetails;
+    cacheMentionName(id: string, mentionName: string): void;
+    supportsMentionNameResolving(): boolean;
+}
+declare class AbstractResource<Result> implements ResourceProvider<Result> {
+    protected changeListeners: Map<string, ResultCallback<Result>>;
+    protected errListeners: Map<string, ErrorCallback>;
+    protected infoListeners: Map<string, InfoCallback>;
+    protected allResultsListeners: Map<string, ResultCallback<Result>>;
+    protected analyticsListeners: Map<string, AnalyticsCallback>;
+    constructor();
+    subscribe(key: string, callback?: ResultCallback<Result>, errCallback?: ErrorCallback, infoCallback?: InfoCallback, allResultsCallback?: ResultCallback<Result>, analyticsListeners?: AnalyticsCallback): void;
+    unsubscribe(key: string): void;
+}
+declare class AbstractMentionResource extends AbstractResource<MentionDescription[]> implements MentionProvider {
+    shouldHighlightMention(_mention: MentionDescription): boolean;
+    filter(query?: string): void;
+    recordMentionSelection(_mention: MentionDescription): void;
+    isFiltering(_query: string): boolean;
+    protected _notifyListeners(mentionsResult: MentionsResult, stats?: MentionStats): void;
+    protected _notifyAllResultsListeners(mentionsResult: MentionsResult): void;
+    protected _notifyErrorListeners(error: Error, query?: string): void;
+    protected _notifyInfoListeners(info: string): void;
+    protected _notifyAnalyticsListeners(event: string, actionSubject: string, action: string, attributes?: {
+        [key: string]: any;
+    }): void;
+}
+/**
+ * Provides a Javascript API
+ */
+export declare class MentionResource extends AbstractMentionResource implements ResolvingMentionProvider {
+    private config;
+    private lastReturnedSearch;
+    private activeSearches;
+    productName?: string;
+    shouldEnableInvite: boolean;
+    inviteExperimentCohort?: InviteExperimentCohort;
+    userRole: UserRole;
+    onInviteItemClick?: (flow: InviteFlow) => void;
+    constructor(config: MentionResourceConfig);
+    shouldHighlightMention(mention: MentionDescription): boolean;
+    notify(searchTime: number, mentionResult: MentionsResult, query?: string): void;
+    notifyError(error: Error, query?: string): void;
+    filter(query?: string, contextIdentifier?: MentionContextIdentifier): Promise<void>;
+    recordMentionSelection(mention: MentionDescription, contextIdentifier?: MentionContextIdentifier): Promise<void>;
+    isFiltering(query: string): boolean;
+    resolveMentionName(id: string): Promise<MentionNameDetails> | MentionNameDetails;
+    cacheMentionName(id: string, mentionName: string): void;
+    supportsMentionNameResolving(): boolean;
+    protected updateActiveSearches(query: string): void;
+    protected verifyMentionConfig(config: MentionResourceConfig): void;
+    private initialState;
+    /**
+     * Clear a context object to generate query params by removing empty
+     * strings, `undefined` and empty values.
+     *
+     * @param contextIdentifier the current context identifier
+     * @returns a safe context for query encoding
+     */
+    private clearContext;
+    private getQueryParams;
+    /**
+     * Returns the initial mention display list before a search is performed for the specified
+     * container.
+     *
+     * @param contextIdentifier
+     * @returns Promise
+     */
+    protected remoteInitialState(contextIdentifier?: MentionContextIdentifier): Promise<MentionsResult>;
+    private search;
+    protected remoteSearch(query: string, contextIdentifier?: MentionContextIdentifier): Promise<MentionsResult>;
+    private transformServiceResponse;
+    recordSelection(mention: MentionDescription, contextIdentifier?: MentionContextIdentifier): Promise<void>;
+}
+export declare class HttpError implements Error {
+    name: string;
+    message: string;
+    statusCode: number;
+    stack?: string;
+    constructor(statusCode: number, statusMessage: string);
+}
+export declare const isResolvingMentionProvider: (p: any) => p is ResolvingMentionProvider;
+export { AbstractResource, AbstractMentionResource };
+export default MentionResource;

package/dist/types-ts4.5/mention/src/api/PresenceResource.d.ts

@@ -0,0 +1,119 @@
+import { Presence } from '../types';
+import { AbstractResource, ResourceProvider } from './MentionResource';
+export interface PresenceMap {
+    [userId: string]: Presence;
+}
+export interface PresenceResourceConfig {
+    url: string;
+    cloudId: string;
+    productId?: string;
+    cache?: PresenceCache;
+    cacheExpiry?: number;
+    parser?: PresenceParser;
+}
+export interface PresenceCache {
+    contains(userId: string): boolean;
+    get(userId: string): Presence;
+    getBulk(userIds: string[]): PresenceMap;
+    getMissingUserIds(userIds: string[]): string[];
+    update(presUpdate: PresenceMap): void;
+}
+export interface PresenceResponse {
+    data: Data;
+}
+export interface Data {
+    PresenceBulk: PresenceBulk[];
+}
+export interface PresenceBulk {
+    userId: string;
+    state: null | string;
+    type: null | string;
+    date: null | string;
+    message: null | string;
+    stateMetadata?: string;
+}
+export interface PresenceParser {
+    mapState(state: string): string;
+    parse(response: PresenceResponse): PresenceMap;
+}
+export interface PresenceProvider extends ResourceProvider<PresenceMap> {
+    refreshPresence(userIds: string[]): void;
+}
+declare class AbstractPresenceResource extends AbstractResource<PresenceMap> implements PresenceProvider {
+    refreshPresence(userIds: string[]): void;
+    protected notifyListeners(presences: PresenceMap): void;
+}
+declare class PresenceResource extends AbstractPresenceResource {
+    private config;
+    private presenceCache;
+    private presenceParser;
+    constructor(config: PresenceResourceConfig);
+    refreshPresence(userIds: string[]): void;
+    private retrievePresence;
+    private queryDirectoryForPresences;
+    private static cleanUrl;
+}
+export declare class DefaultPresenceCache implements PresenceCache {
+    private static readonly defaultTimeout;
+    private static readonly defaultFlushTrigger;
+    private cache;
+    private size;
+    private expiryInMillis;
+    private flushTrigger;
+    constructor(cacheTimeout?: number, cacheTrigger?: number);
+    /**
+     * Precondition: _delete is only called internally if userId exists in cache
+     * Removes cache entry
+     * @param userId
+     */
+    private _delete;
+    /**
+     * Checks a cache entry and calls delete if the info has expired
+     * @param userId
+     */
+    private _deleteIfExpired;
+    /**
+     * Cleans expired entries from cache
+     */
+    private _removeExpired;
+    /**
+     * Checks if a user exists in the cache
+     * @param userId
+     */
+    contains(userId: string): boolean;
+    /**
+     * Retrieves a presence from the cache after checking for expired entries
+     * @param userId - to index the cache
+     * @returns Presence - the presence that matches the userId
+     */
+    get(userId: string): Presence;
+    /**
+     * Retrieve multiple presences at once from the cache
+     * @param userIds - to index the cache
+     * @returns PresenceMap - A map of userIds to cached Presences
+     */
+    getBulk(userIds: string[]): PresenceMap;
+    /**
+     * For a given list of ids, returns a subset
+     * of all the ids with missing cache entries.
+     * @param userIds - to index the cache
+     * @returns string[] - ids missing from the cache
+     */
+    getMissingUserIds(userIds: string[]): string[];
+    /**
+     * Precondition: presMap only contains ids of users not in cache
+     *               expired users must first be removed then reinserted with updated presence
+     * Updates the cache by adding the new Presence entries and setting the expiry time
+     * @param presMap
+     */
+    update(presMap: PresenceMap): void;
+}
+export declare class DefaultPresenceParser implements PresenceParser {
+    static FOCUS_STATE: string;
+    mapState(state: string): string;
+    parse(response: PresenceResponse): PresenceMap;
+    private static extractState;
+    private static isFocusState;
+}
+export { AbstractPresenceResource };
+export default PresenceResource;

package/dist/types-ts4.5/mention/src/api/TeamMentionResource.d.ts

@@ -0,0 +1,33 @@
+import { MentionsResult } from '../types';
+import MentionResource, { MentionContextIdentifier, MentionResourceConfig, TeamMentionResourceConfig, MentionProvider } from './MentionResource';
+/**
+ * Provides a Javascript API to fetch users and teams
+ * In future we will have a new endpoint to return both users and teams, we can
+ * remove this class at this point
+ */
+export default class TeamMentionResource extends MentionResource implements MentionProvider {
+    private readonly teamMentionConfig;
+    private lastSearchQuery?;
+    private lastReturnedSearchTeam;
+    constructor(userMentionConfig: MentionResourceConfig, teamMentionConfig: TeamMentionResourceConfig);
+    filter(query?: string, contextIdentifier?: MentionContextIdentifier): Promise<void>;
+    /**
+     * Returns the initial mention display list before a search is performed for the specified
+     * container.
+     */
+    private remoteInitialStateTeamAndUsers;
+    /**
+     * Both user and team requests are not blocked together
+     * If users request arrives first, show users. Show teams when team request arrives.
+     * If team request arrives first, block waiting for user request, then show both
+     * If one errors, show the non-erroring one
+     * If both error, show error
+     */
+    private handleBothRequests;
+    notify(searchTime: number, mentionResult: MentionsResult, query?: string): void;
+    private getQueryParamsOfTeamMentionConfig;
+    private remoteUserSearch;
+    private remoteTeamSearch;
+    private convertTeamResultToMentionResult;
+    private trimTeamARI;
+}

package/dist/types-ts4.5/mention/src/components/LockCircleIcon/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const AsyncLockCircleIcon: import("react").LazyExoticComponent<typeof import("@atlaskit/icon/glyph/lock-circle").default>;
+export default AsyncLockCircleIcon;

package/dist/types-ts4.5/mention/src/components/Mention/PrimitiveMention.d.ts

@@ -0,0 +1,7 @@
+import { MentionType } from '../../types';
+import { HTMLAttributes } from 'react';
+export interface PrimitiveMentionProps extends HTMLAttributes<HTMLSpanElement> {
+    mentionType: MentionType;
+}
+declare const PrimitiveMention: import("react").ForwardRefExoticComponent<PrimitiveMentionProps & import("react").RefAttributes<HTMLSpanElement>>;
+export default PrimitiveMention;

package/dist/types-ts4.5/mention/src/components/Mention/ResourcedMention.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { MentionProvider } from '../../api/MentionResource';
+import { MentionEventHandler } from '../../types';
+export interface Props {
+    id: string;
+    text: string;
+    accessLevel?: string;
+    mentionProvider?: Promise<MentionProvider>;
+    onClick?: MentionEventHandler;
+    onMouseEnter?: MentionEventHandler;
+    onMouseLeave?: MentionEventHandler;
+}
+export interface State {
+    isHighlighted: boolean;
+    resolvedMentionName?: string;
+}
+export default class ResourcedMention extends React.PureComponent<Props, State> {
+    _isMounted: boolean;
+    constructor(props: Props);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    private setStateSafely;
+    private processName;
+    private handleMentionProvider;
+    render(): JSX.Element;
+}