@fluidframework/core-utils 2.0.0-dev-rc.1.0.0.224419

package/dist/unreachable.js

@@ -0,0 +1,28 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unreachableCase = void 0;
+/**
+ * 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);
+ * }
+ * ```
+ * @internal
+ */
+function unreachableCase(_, message = "Unreachable Case") {
+    throw new Error(message);
+}
+exports.unreachableCase = unreachableCase;
+//# sourceMappingURL=unreachable.js.map

package/dist/unreachable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unreachable.js","sourceRoot":"","sources":["../src/unreachable.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,eAAe,CAAC,CAAQ,EAAE,OAAO,GAAG,kBAAkB;IACrE,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;AAC1B,CAAC;AAFD,0CAEC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * This function can be used to assert at compile time that a given value has type never.\n * One common usage is in the default case of a switch block,\n * to ensure that all cases are explicitly handled.\n *\n * Example:\n * ```typescript\n * const bool: true | false = ...;\n * switch(bool) {\n *   case true: {...}\n *   case false: {...}\n *   default: unreachableCase(bool);\n * }\n * ```\n * @internal\n */\nexport function unreachableCase(_: never, message = \"Unreachable Case\"): never {\n\tthrow new Error(message);\n}\n"]}

package/lib/assert.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * 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.
+ * @alpha
+ */
+export declare function assert(condition: boolean, message: string | number): asserts condition;
+//# sourceMappingURL=assert.d.ts.map

package/lib/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../src/assert.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,SAAS,CAMtF"}

package/lib/assert.js

@@ -0,0 +1,25 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+/**
+ * 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.
+ * @alpha
+ */
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(typeof message === "number" ? `0x${message.toString(16).padStart(3, "0")}` : message);
+    }
+}
+exports.assert = assert;
+//# sourceMappingURL=assert.js.map

package/lib/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.js","sourceRoot":"","sources":["../src/assert.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH;;;;;;;;;;GAUG;AACH,SAAgB,MAAM,CAAC,SAAkB,EAAE,OAAwB;IAClE,IAAI,CAAC,SAAS,EAAE;QACf,MAAM,IAAI,KAAK,CACd,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CACpF,CAAC;KACF;AACF,CAAC;AAND,wBAMC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * A browser friendly assert library.\n * Use this instead of the 'assert' package, which has a big impact on bundle sizes.\n * @param condition - The condition that should be true, if the condition is false an error will be thrown.\n * Only use this API when `false` indicates a logic error in the problem and thus a bug that should be fixed.\n * @param message - The message to include in the error when the condition does not hold.\n * A number should not be specified manually: use a string.\n * Before a release, policy-check should be run, which will convert any asserts still using strings to\n * use numbered error codes instead.\n * @alpha\n */\nexport function assert(condition: boolean, message: string | number): asserts condition {\n\tif (!condition) {\n\t\tthrow new Error(\n\t\t\ttypeof message === \"number\" ? `0x${message.toString(16).padStart(3, \"0\")}` : message,\n\t\t);\n\t}\n}\n"]}

package/lib/compare.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Compare two arrays.  Returns true if their elements are equivalent and in the same order.
+ *
+ * @alpha
+ *
+ * @param left - The first array to compare
+ * @param right - The second array to compare
+ * @param comparator - The function used to check if two `T`s are equivalent.
+ * Defaults to `Object.is()` equality (a shallow compare where NaN = NaN and -0 ≠ 0)
+ */
+export declare const compareArrays: <T>(left: readonly T[], right: readonly T[], comparator?: (leftItem: T, rightItem: T, index: number) => boolean) => boolean;
+//# sourceMappingURL=compare.d.ts.map

package/lib/compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../src/compare.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,+FAGsB,MAAM,KAAK,OAAO,KAI/D,OAUF,CAAC"}

package/lib/compare.js

@@ -0,0 +1,28 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareArrays = void 0;
+/**
+ * Compare two arrays.  Returns true if their elements are equivalent and in the same order.
+ *
+ * @alpha
+ *
+ * @param left - The first array to compare
+ * @param right - The second array to compare
+ * @param comparator - The function used to check if two `T`s are equivalent.
+ * Defaults to `Object.is()` equality (a shallow compare where NaN = NaN and -0 ≠ 0)
+ */
+const compareArrays = (left, right, comparator = (leftItem, rightItem) => Object.is(leftItem, rightItem)) => {
+    // PERF: 'for-loop' and 'Array.every()' tied.
+    //       '===' and 'Object.is()' tied.
+    //       Trivial acceptance adds no measurable overhead.
+    //       30% penalty vs. baseline for exported function [node 14 x64].
+    return (left === right || // Trivial acceptance: 'left' and 'right' are the same instance
+        (left.length === right.length && // Trivial rejection: 'left' and 'right' are different lengths
+            left.every((leftItem, index) => comparator(leftItem, right[index], index))));
+};
+exports.compareArrays = compareArrays;
+//# sourceMappingURL=compare.js.map

package/lib/compare.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare.js","sourceRoot":"","sources":["../src/compare.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH;;;;;;;;;GASG;AACI,MAAM,aAAa,GAAG,CAC5B,IAAkB,EAClB,KAAmB,EACnB,aAAoE,CACnE,QAAW,EACX,SAAY,EACF,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,SAAS,CAAC,EAClC,EAAE;IACZ,6CAA6C;IAC7C,sCAAsC;IACtC,wDAAwD;IACxD,sEAAsE;IACtE,OAAO,CACN,IAAI,KAAK,KAAK,IAAI,+DAA+D;QACjF,CAAC,IAAI,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,IAAI,8DAA8D;YAC9F,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAC5E,CAAC;AACH,CAAC,CAAC;AAjBW,QAAA,aAAa,iBAiBxB","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Compare two arrays.  Returns true if their elements are equivalent and in the same order.\n *\n * @alpha\n *\n * @param left - The first array to compare\n * @param right - The second array to compare\n * @param comparator - The function used to check if two `T`s are equivalent.\n * Defaults to `Object.is()` equality (a shallow compare where NaN = NaN and -0 ≠ 0)\n */\nexport const compareArrays = <T>(\n\tleft: readonly T[],\n\tright: readonly T[],\n\tcomparator: (leftItem: T, rightItem: T, index: number) => boolean = (\n\t\tleftItem: T,\n\t\trightItem: T,\n\t): boolean => Object.is(leftItem, rightItem),\n): boolean => {\n\t// PERF: 'for-loop' and 'Array.every()' tied.\n\t//       '===' and 'Object.is()' tied.\n\t//       Trivial acceptance adds no measurable overhead.\n\t//       30% penalty vs. baseline for exported function [node 14 x64].\n\treturn (\n\t\tleft === right || // Trivial acceptance: 'left' and 'right' are the same instance\n\t\t(left.length === right.length && // Trivial rejection: 'left' and 'right' are different lengths\n\t\t\tleft.every((leftItem, index) => comparator(leftItem, right[index], index)))\n\t);\n};\n"]}

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

@@ -0,0 +1,191 @@
+/**
+ * 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.
+ * @alpha
+ */
+export declare function assert(condition: boolean, message: string | number): asserts condition;
+
+/**
+ * Compare two arrays.  Returns true if their elements are equivalent and in the same order.
+ *
+ * @alpha
+ *
+ * @param left - The first array to compare
+ * @param right - The second array to compare
+ * @param comparator - The function used to check if two `T`s are equivalent.
+ * Defaults to `Object.is()` equality (a shallow compare where NaN = NaN and -0 ≠ 0)
+ */
+export declare const compareArrays: <T>(left: readonly T[], right: readonly T[], comparator?: (leftItem: T, rightItem: T, index: number) => boolean) => boolean;
+
+/**
+ * A deferred creates a promise and the ability to resolve or reject it
+ * @alpha
+ */
+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: delay */
+
+/* Excluded from this release type: Heap */
+
+/* Excluded from this release type: IComparer */
+
+/* Excluded from this release type: IHeapNode */
+
+/* Excluded from this release type: IPromiseTimer */
+
+/* Excluded from this release type: IPromiseTimerResult */
+
+/* Excluded from this release type: ITimer */
+
+/* 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.
+ * @alpha
+ */
+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: 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.
+ * @alpha
+ */
+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;
+}
+
+/**
+ * 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)
+ * @alpha
+ */
+export declare type PromiseCacheExpiry = {
+    policy: "indefinite";
+} | {
+    policy: "absolute" | "sliding";
+    durationMs: number;
+};
+
+/**
+ * Options for configuring the {@link PromiseCache}
+ * @alpha
+ */
+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: PromiseTimer */
+
+/* Excluded from this release type: setLongTimeout */
+
+/* Excluded from this release type: Timer */
+
+/* Excluded from this release type: unreachableCase */
+
+export { }

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

@@ -0,0 +1,41 @@
+/* Excluded from this release type: assert */
+
+/* Excluded from this release type: compareArrays */
+
+/* Excluded from this release type: Deferred */
+
+/* Excluded from this release type: delay */
+
+/* Excluded from this release type: Heap */
+
+/* Excluded from this release type: IComparer */
+
+/* Excluded from this release type: IHeapNode */
+
+/* Excluded from this release type: IPromiseTimer */
+
+/* Excluded from this release type: IPromiseTimerResult */
+
+/* Excluded from this release type: ITimer */
+
+/* Excluded from this release type: Lazy */
+
+/* Excluded from this release type: LazyPromise */
+
+/* Excluded from this release type: NumberComparer */
+
+/* Excluded from this release type: PromiseCache */
+
+/* Excluded from this release type: PromiseCacheExpiry */
+
+/* Excluded from this release type: PromiseCacheOptions */
+
+/* Excluded from this release type: PromiseTimer */
+
+/* Excluded from this release type: setLongTimeout */
+
+/* Excluded from this release type: Timer */
+
+/* Excluded from this release type: unreachableCase */
+
+export { }

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

@@ -0,0 +1,41 @@
+/* Excluded from this release type: assert */
+
+/* Excluded from this release type: compareArrays */
+
+/* Excluded from this release type: Deferred */
+
+/* Excluded from this release type: delay */
+
+/* Excluded from this release type: Heap */
+
+/* Excluded from this release type: IComparer */
+
+/* Excluded from this release type: IHeapNode */
+
+/* Excluded from this release type: IPromiseTimer */
+
+/* Excluded from this release type: IPromiseTimerResult */
+
+/* Excluded from this release type: ITimer */
+
+/* Excluded from this release type: Lazy */
+
+/* Excluded from this release type: LazyPromise */
+
+/* Excluded from this release type: NumberComparer */
+
+/* Excluded from this release type: PromiseCache */
+
+/* Excluded from this release type: PromiseCacheExpiry */
+
+/* Excluded from this release type: PromiseCacheOptions */
+
+/* Excluded from this release type: PromiseTimer */
+
+/* Excluded from this release type: setLongTimeout */
+
+/* Excluded from this release type: Timer */
+
+/* Excluded from this release type: unreachableCase */
+
+export { }