@fluidframework/core-utils 2.0.0-dev.7.4.0.215747 → 2.0.0-dev.7.4.0.216897

package/lib/core-utils-public.d.ts

@@ -1,404 +1,41 @@
-/**
- * A browser friendly assert library.
- * Use this instead of the 'assert' package, which has a big impact on bundle sizes.
- * @param condition - The condition that should be true, if the condition is false an error will be thrown.
- * Only use this API when `false` indicates a logic error in the problem and thus a bug that should be fixed.
- * @param message - The message to include in the error when the condition does not hold.
- * A number should not be specified manually: use a string.
- * Before a release, policy-check should be run, which will convert any asserts still using strings to
- * use numbered error codes instead.
- * @public
- */
-export declare function assert(condition: boolean, message: string | number): asserts condition;
+/* Excluded from this release type: assert */
 
 /* Excluded from this release type: compareArrays */
 
-/**
- * A deferred creates a promise and the ability to resolve or reject it
- * @public
- */
-export declare class Deferred<T> {
-    private readonly p;
-    private res;
-    private rej;
-    private completed;
-    constructor();
-    /**
-     * Returns whether the underlying promise has been completed
-     */
-    get isCompleted(): boolean;
-    /**
-     * Retrieves the underlying promise for the deferred
-     *
-     * @returns the underlying promise
-     */
-    get promise(): Promise<T>;
-    /**
-     * Resolves the promise
-     *
-     * @param value - the value to resolve the promise with
-     */
-    resolve(value: T | PromiseLike<T>): void;
-    /**
-     * Rejects the promise
-     *
-     * @param value - the value to reject the promise with
-     */
-    reject(error: any): void;
-}
+/* Excluded from this release type: Deferred */
 
-/**
- * Returns a promise that resolves after `timeMs`.
- * @param timeMs - Time in milliseconds to wait.
- * @public
- */
-export declare const delay: (timeMs: number) => Promise<void>;
+/* Excluded from this release type: delay */
 
-/**
- * Ordered {@link https://en.wikipedia.org/wiki/Heap_(data_structure) | Heap} data structure implementation.
- * @public
- */
-export declare class Heap<T> {
-    comp: IComparer<T>;
-    private L;
-    /**
-     * Creates an instance of `Heap` with comparer.
-     * @param comp - A comparer that specify how elements are ordered.
-     */
-    constructor(comp: IComparer<T>);
-    /**
-     * Return the smallest element in the heap as determined by the order of the comparer
-     *
-     * @returns Heap node containing the smallest element
-     */
-    peek(): IHeapNode<T>;
-    /**
-     * Get and remove the smallest element in the heap as determined by the order of the comparer
-     *
-     * @returns The smallest value in the heap
-     */
-    get(): T;
-    /**
-     * Add a value to the heap
-     *
-     * @param x - value to add
-     * @returns The heap node that contains the value
-     */
-    add(x: T): IHeapNode<T>;
-    /**
-     * Allows for the Heap to be updated after a node's value changes.
-     */
-    update(node: IHeapNode<T>): void;
-    /**
-     * Removes the given node from the heap.
-     *
-     * @param node - The node to remove from the heap.
-     */
-    remove(node: IHeapNode<T>): void;
-    /**
-     * Get the number of elements in the Heap.
-     *
-     * @returns The number of elements in the Heap.
-     */
-    count(): number;
-    private fixup;
-    private isGreaterThanParent;
-    private fixdown;
-    private swap;
-}
+/* Excluded from this release type: Heap */
 
-/**
- * Interface for a comparer.
- * @public
- */
-export declare interface IComparer<T> {
-    /**
-     * The minimum value of type T.
-     */
-    min: T;
-    /**
-     * Compare the two value
-     *
-     * @returns 0 if the value is equal, negative number if a is smaller then b, positive number otherwise
-     */
-    compare(a: T, b: T): number;
-}
+/* Excluded from this release type: IComparer */
 
-/**
- * Interface to a node in {@link Heap}.
- * @public
- */
-export declare interface IHeapNode<T> {
-    value: T;
-    position: number;
-}
+/* Excluded from this release type: IHeapNode */
 
-/**
- * Timer which offers a promise that fulfills when the timer
- * completes.
- * @public
- */
-export declare interface IPromiseTimer extends ITimer {
-    /**
-     * Starts the timer and returns a promise that
-     * resolves when the timer times out or is canceled.
-     */
-    start(): Promise<IPromiseTimerResult>;
-}
+/* Excluded from this release type: IPromiseTimer */
 
-/**
- * @public
- */
-export declare interface IPromiseTimerResult {
-    timerResult: "timeout" | "cancel";
-}
+/* Excluded from this release type: IPromiseTimerResult */
 
-/**
- * @public
- */
-export declare interface ITimer {
-    /**
-     * True if timer is currently running
-     */
-    readonly hasTimer: boolean;
-    /**
-     * Starts the timer
-     */
-    start(): void;
-    /**
-     * Cancels the timer if already running
-     */
-    clear(): void;
-}
+/* Excluded from this release type: ITimer */
 
-/**
- * Helper class for lazy initialized values. Ensures the value is only generated once, and remain immutable.
- * @public
- */
-export declare class Lazy<T> {
-    private readonly valueGenerator;
-    private _value;
-    private _evaluated;
-    /**
-     * Instantiates an instance of Lazy<T>.
-     * @param valueGenerator - The function that will generate the value when value is accessed the first time.
-     */
-    constructor(valueGenerator: () => T);
-    /**
-     * Return true if the value as been generated, otherwise false.
-     */
-    get evaluated(): boolean;
-    /**
-     * Get the value. If this is the first call the value will be generated.
-     */
-    get value(): T;
-}
+/* Excluded from this release type: Lazy */
 
-/**
- * A lazy evaluated promise. The execute function is delayed until
- * the promise is used, e.g. await, then, catch ...
- * The execute function is only called once.
- * All calls are then proxied to the promise returned by the execute method.
- * @public
- */
-export declare class LazyPromise<T> implements Promise<T> {
-    private readonly execute;
-    get [Symbol.toStringTag](): string;
-    private result;
-    constructor(execute: () => Promise<T>);
-    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
-    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
-    private getPromise;
-}
+/* Excluded from this release type: LazyPromise */
 
-/**
- * A comparer for numbers.
- * @public
- */
-export declare const NumberComparer: IComparer<number>;
+/* Excluded from this release type: NumberComparer */
 
-/**
- * A specialized cache for async work, allowing you to safely cache the promised result of some async work
- * without fear of running it multiple times or losing track of errors.
- * @public
- */
-export declare class PromiseCache<TKey, TResult> {
-    private readonly cache;
-    private readonly gc;
-    private readonly removeOnError;
-    /**
-     * Create the PromiseCache with the given options, with the following defaults:
-     *
-     * expiry: indefinite, removeOnError: true for all errors
-     */
-    constructor({ expiry, removeOnError, }?: PromiseCacheOptions);
-    /**
-     * Check if there's anything cached at the given key
-     */
-    has(key: TKey): boolean;
-    /**
-     * Get the Promise for the given key, or undefined if it's not found.
-     * Extend expiry if applicable.
-     */
-    get(key: TKey): Promise<TResult> | undefined;
-    /**
-     * Remove the Promise for the given key, returning true if it was found and removed
-     */
-    remove(key: TKey): boolean;
-    /**
-     * Try to add the result of the given asyncFn, without overwriting an existing cache entry at that key.
-     * Returns a Promise for the added or existing async work being done at that key.
-     * @param key - key name where to store the async work
-     * @param asyncFn - the async work to do and store, if not already in progress under the given key
-     */
-    addOrGet(key: TKey, asyncFn: () => Promise<TResult>): Promise<TResult>;
-    /**
-     * Try to add the result of the given asyncFn, without overwriting an existing cache entry at that key.
-     * Returns false if the cache already contained an entry at that key, and true otherwise.
-     * @param key - key name where to store the async work
-     * @param asyncFn - the async work to do and store, if not already in progress under the given key
-     */
-    add(key: TKey, asyncFn: () => Promise<TResult>): boolean;
-    /**
-     * Try to add the given value, without overwriting an existing cache entry at that key.
-     * Returns a Promise for the added or existing async work being done at that key.
-     * @param key - key name where to store the async work
-     * @param value - value to store
-     */
-    addValueOrGet(key: TKey, value: TResult): Promise<TResult>;
-    /**
-     * Try to add the given value, without overwriting an existing cache entry at that key.
-     * Returns false if the cache already contained an entry at that key, and true otherwise.
-     * @param key - key name where to store the value
-     * @param value - value to store
-     */
-    addValue(key: TKey, value: TResult): boolean;
-}
+/* Excluded from this release type: PromiseCache */
 
-/**
- * Three supported expiry policies:
- * - indefinite: entries don't expire and must be explicitly removed
- * - absolute: entries expire after the given duration in MS, even if accessed multiple times in the mean time
- * - sliding: entries expire after the given duration in MS of inactivity (i.e. get resets the clock)
- * @public
- */
-export declare type PromiseCacheExpiry = {
-    policy: "indefinite";
-} | {
-    policy: "absolute" | "sliding";
-    durationMs: number;
-};
+/* Excluded from this release type: PromiseCacheExpiry */
 
-/**
- * Options for configuring the {@link PromiseCache}
- * @public
- */
-export declare interface PromiseCacheOptions {
-    /**
-     * Common expiration policy for all items added to this cache
-     */
-    expiry?: PromiseCacheExpiry;
-    /**
-     * If the stored Promise is rejected with a particular error, should the given key be removed?
-     */
-    removeOnError?: (error: any) => boolean;
-}
+/* Excluded from this release type: PromiseCacheOptions */
 
-/**
- * This class is a wrapper over setTimeout and clearTimeout which
- * makes it simpler to keep track of recurring timeouts with the
- * same handlers and timeouts, while also providing a promise that
- * resolves when it times out.
- * @public
- */
-export declare class PromiseTimer implements IPromiseTimer {
-    private deferred?;
-    private readonly timer;
-    /**
-     * {@inheritDoc Timer.hasTimer}
-     */
-    get hasTimer(): boolean;
-    constructor(defaultTimeout: number, defaultHandler: () => void);
-    /**
-     * {@inheritDoc IPromiseTimer.start}
-     */
-    start(ms?: number, handler?: () => void): Promise<IPromiseTimerResult>;
-    clear(): void;
-    protected wrapHandler(handler: () => void): void;
-}
+/* Excluded from this release type: PromiseTimer */
 
-/**
- * Sets timeouts like the setTimeout function allowing timeouts to exceed the setTimeout's max timeout limit.
- * Timeouts may not be exactly accurate due to browser implementations and the OS.
- * https://stackoverflow.com/questions/21097421/what-is-the-reason-javascript-settimeout-is-so-inaccurate
- * @param timeoutFn - Executed when the timeout expires
- * @param timeoutMs - Duration of the timeout in milliseconds
- * @param setTimeoutIdFn - Executed to update the timeout if multiple timeouts are required when
- * timeoutMs greater than maxTimeout
- * @returns The initial timeout
- * @public
- */
-export declare function setLongTimeout(timeoutFn: () => void, timeoutMs: number, setTimeoutIdFn?: (timeoutId: ReturnType<typeof setTimeout>) => void): ReturnType<typeof setTimeout>;
+/* Excluded from this release type: setLongTimeout */
 
-/**
- * This class is a thin wrapper over setTimeout and clearTimeout which
- * makes it simpler to keep track of recurring timeouts with the same
- * or similar handlers and timeouts. This class supports long timeouts
- * or timeouts exceeding (2^31)-1 ms or approximately 24.8 days.
- * @public
- */
-export declare class Timer implements ITimer {
-    private readonly defaultTimeout;
-    private readonly defaultHandler;
-    private readonly getCurrentTick;
-    /**
-     * Returns true if the timer is running.
-     */
-    get hasTimer(): boolean;
-    private runningState;
-    constructor(defaultTimeout: number, defaultHandler: () => void, getCurrentTick?: () => number);
-    /**
-     * Calls setTimeout and tracks the resulting timeout.
-     * @param ms - overrides default timeout in ms
-     * @param handler - overrides default handler
-     */
-    start(ms?: number, handler?: () => void): void;
-    /**
-     * Calls clearTimeout on the underlying timeout if running.
-     */
-    clear(): void;
-    /**
-     * Restarts the timer with the new handler and duration.
-     * If a new handler is passed, the original handler may
-     * never execute.
-     * This is a potentially more efficient way to clear and start
-     * a new timer.
-     * @param ms - overrides previous or default timeout in ms
-     * @param handler - overrides previous or default handler
-     */
-    restart(ms?: number, handler?: () => void): void;
-    private startCore;
-    private handler;
-    private calculateRemainingTime;
-}
+/* Excluded from this release type: Timer */
 
-/**
- * This function can be used to assert at compile time that a given value has type never.
- * One common usage is in the default case of a switch block,
- * to ensure that all cases are explicitly handled.
- *
- * Example:
- * ```typescript
- * const bool: true | false = ...;
- * switch(bool) {
- *   case true: {...}
- *   case false: {...}
- *   default: unreachableCase(bool);
- * }
- * ```
- * @public
- */
-export declare function unreachableCase(_: never, message?: string): never;
+/* Excluded from this release type: unreachableCase */
 
 export { }

package/lib/core-utils-untrimmed.d.ts

@@ -7,7 +7,7 @@
  * A number should not be specified manually: use a string.
  * Before a release, policy-check should be run, which will convert any asserts still using strings to
  * use numbered error codes instead.
- * @public
+ * @internal
  */
 export declare function assert(condition: boolean, message: string | number): asserts condition;
 
@@ -25,7 +25,7 @@ export declare const compareArrays: <T>(left: readonly T[], right: readonly T[],
 
 /**
  * A deferred creates a promise and the ability to resolve or reject it
- * @public
+ * @internal
  */
 export declare class Deferred<T> {
     private readonly p;
@@ -60,13 +60,13 @@ export declare class Deferred<T> {
 /**
  * Returns a promise that resolves after `timeMs`.
  * @param timeMs - Time in milliseconds to wait.
- * @public
+ * @internal
  */
 export declare const delay: (timeMs: number) => Promise<void>;
 
 /**
  * Ordered {@link https://en.wikipedia.org/wiki/Heap_(data_structure) | Heap} data structure implementation.
- * @public
+ * @internal
  */
 export declare class Heap<T> {
     comp: IComparer<T>;
@@ -119,7 +119,7 @@ export declare class Heap<T> {
 
 /**
  * Interface for a comparer.
- * @public
+ * @internal
  */
 export declare interface IComparer<T> {
     /**
@@ -136,7 +136,7 @@ export declare interface IComparer<T> {
 
 /**
  * Interface to a node in {@link Heap}.
- * @public
+ * @internal
  */
 export declare interface IHeapNode<T> {
     value: T;
@@ -146,7 +146,7 @@ export declare interface IHeapNode<T> {
 /**
  * Timer which offers a promise that fulfills when the timer
  * completes.
- * @public
+ * @internal
  */
 export declare interface IPromiseTimer extends ITimer {
     /**
@@ -157,14 +157,14 @@ export declare interface IPromiseTimer extends ITimer {
 }
 
 /**
- * @public
+ * @internal
  */
 export declare interface IPromiseTimerResult {
     timerResult: "timeout" | "cancel";
 }
 
 /**
- * @public
+ * @internal
  */
 export declare interface ITimer {
     /**
@@ -183,7 +183,7 @@ export declare interface ITimer {
 
 /**
  * Helper class for lazy initialized values. Ensures the value is only generated once, and remain immutable.
- * @public
+ * @internal
  */
 export declare class Lazy<T> {
     private readonly valueGenerator;
@@ -209,7 +209,7 @@ export declare class Lazy<T> {
  * the promise is used, e.g. await, then, catch ...
  * The execute function is only called once.
  * All calls are then proxied to the promise returned by the execute method.
- * @public
+ * @internal
  */
 export declare class LazyPromise<T> implements Promise<T> {
     private readonly execute;
@@ -224,14 +224,14 @@ export declare class LazyPromise<T> implements Promise<T> {
 
 /**
  * A comparer for numbers.
- * @public
+ * @internal
  */
 export declare const NumberComparer: IComparer<number>;
 
 /**
  * A specialized cache for async work, allowing you to safely cache the promised result of some async work
  * without fear of running it multiple times or losing track of errors.
- * @public
+ * @internal
  */
 export declare class PromiseCache<TKey, TResult> {
     private readonly cache;
@@ -291,7 +291,7 @@ export declare class PromiseCache<TKey, TResult> {
  * - indefinite: entries don't expire and must be explicitly removed
  * - absolute: entries expire after the given duration in MS, even if accessed multiple times in the mean time
  * - sliding: entries expire after the given duration in MS of inactivity (i.e. get resets the clock)
- * @public
+ * @internal
  */
 export declare type PromiseCacheExpiry = {
     policy: "indefinite";
@@ -302,7 +302,7 @@ export declare type PromiseCacheExpiry = {
 
 /**
  * Options for configuring the {@link PromiseCache}
- * @public
+ * @internal
  */
 export declare interface PromiseCacheOptions {
     /**
@@ -320,7 +320,7 @@ export declare interface PromiseCacheOptions {
  * makes it simpler to keep track of recurring timeouts with the
  * same handlers and timeouts, while also providing a promise that
  * resolves when it times out.
- * @public
+ * @internal
  */
 export declare class PromiseTimer implements IPromiseTimer {
     private deferred?;
@@ -347,7 +347,7 @@ export declare class PromiseTimer implements IPromiseTimer {
  * @param setTimeoutIdFn - Executed to update the timeout if multiple timeouts are required when
  * timeoutMs greater than maxTimeout
  * @returns The initial timeout
- * @public
+ * @internal
  */
 export declare function setLongTimeout(timeoutFn: () => void, timeoutMs: number, setTimeoutIdFn?: (timeoutId: ReturnType<typeof setTimeout>) => void): ReturnType<typeof setTimeout>;
 
@@ -356,7 +356,7 @@ export declare function setLongTimeout(timeoutFn: () => void, timeoutMs: number,
  * makes it simpler to keep track of recurring timeouts with the same
  * or similar handlers and timeouts. This class supports long timeouts
  * or timeouts exceeding (2^31)-1 ms or approximately 24.8 days.
- * @public
+ * @internal
  */
 export declare class Timer implements ITimer {
     private readonly defaultTimeout;
@@ -407,7 +407,7 @@ export declare class Timer implements ITimer {
  *   default: unreachableCase(bool);
  * }
  * ```
- * @public
+ * @internal
  */
 export declare function unreachableCase(_: never, message?: string): never;
 

package/lib/delay.d.ts

@@ -5,7 +5,7 @@
 /**
  * Returns a promise that resolves after `timeMs`.
  * @param timeMs - Time in milliseconds to wait.
- * @public
+ * @internal
  */
 export declare const delay: (timeMs: number) => Promise<void>;
 //# sourceMappingURL=delay.d.ts.map

package/lib/delay.js

@@ -5,7 +5,7 @@
 /**
  * Returns a promise that resolves after `timeMs`.
  * @param timeMs - Time in milliseconds to wait.
- * @public
+ * @internal
  */
 export const delay = async (timeMs) => new Promise((resolve) => setTimeout(() => resolve(), timeMs));
 //# sourceMappingURL=delay.js.map

package/lib/delay.js.map

@@ -1 +1 @@
-{"version":3,"file":"delay.js","sourceRoot":"","sources":["../src/delay.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,KAAK,EAAE,MAAc,EAAiB,EAAE,CAC5D,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Returns a promise that resolves after `timeMs`.\n * @param timeMs - Time in milliseconds to wait.\n * @public\n */\nexport const delay = async (timeMs: number): Promise<void> =>\n\tnew Promise((resolve) => setTimeout(() => resolve(), timeMs));\n"]}
+{"version":3,"file":"delay.js","sourceRoot":"","sources":["../src/delay.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,KAAK,EAAE,MAAc,EAAiB,EAAE,CAC5D,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Returns a promise that resolves after `timeMs`.\n * @param timeMs - Time in milliseconds to wait.\n * @internal\n */\nexport const delay = async (timeMs: number): Promise<void> =>\n\tnew Promise((resolve) => setTimeout(() => resolve(), timeMs));\n"]}

package/lib/heap.d.ts

@@ -4,7 +4,7 @@
  */
 /**
  * Interface for a comparer.
- * @public
+ * @internal
  */
 export interface IComparer<T> {
     /**
@@ -20,12 +20,12 @@ export interface IComparer<T> {
 }
 /**
  * A comparer for numbers.
- * @public
+ * @internal
  */
 export declare const NumberComparer: IComparer<number>;
 /**
  * Interface to a node in {@link Heap}.
- * @public
+ * @internal
  */
 export interface IHeapNode<T> {
     value: T;
@@ -33,7 +33,7 @@ export interface IHeapNode<T> {
 }
 /**
  * Ordered {@link https://en.wikipedia.org/wiki/Heap_(data_structure) | Heap} data structure implementation.
- * @public
+ * @internal
  */
 export declare class Heap<T> {
     comp: IComparer<T>;

package/lib/heap.js

@@ -4,7 +4,7 @@
  */
 /**
  * A comparer for numbers.
- * @public
+ * @internal
  */
 export const NumberComparer = {
     /**
@@ -19,7 +19,7 @@ export const NumberComparer = {
 };
 /**
  * Ordered {@link https://en.wikipedia.org/wiki/Heap_(data_structure) | Heap} data structure implementation.
- * @public
+ * @internal
  */
 export class Heap {
     /**