@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/lib/util/stackyIterator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stackyIterator.js","sourceRoot":"","sources":["../../src/util/stackyIterator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,OAAO,cAAc;IAK1B,YAAmB,IAAkB;QAHpB,UAAK,GAAQ,EAAE,CAAC;QACzB,UAAK,GAAG,CAAC,CAAC;QAGjB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IAClB,CAAC;IAEM,CAAC,MAAM,CAAC,QAAQ,CAAC;QACvB,OAAO,IAAI,CAAC;IACb,CAAC;IAEM,IAAI;QACV,IAAI,IAAI,CAAC,IAAI,EAAE;YACd,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;SACxC;QACD,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,GAAG,EAAO,EAAE,CAAC;IACnC,CAAC;IAED,IAAW,IAAI;QACd,OAAO,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;IAClE,CAAC;IAEM,IAAI,CAAC,IAAO;QAClB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;IAEM,GAAG;QACT,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;YAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;SACxB;QACD,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YACnC,OAAO,SAAS,CAAC;SACjB;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IAChC,CAAC;IAEM,IAAI;QACV,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;YAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;SACzC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;CACD","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * An iterator that supports having items pushed onto it for later iteration.\n */\nexport class StackyIterator<T> implements Iterator<T>, Iterable<T> {\n\tprivate readonly list: readonly T[];\n\tprivate readonly stack: T[] = [];\n\tprivate index = 0;\n\n\tpublic constructor(list: readonly T[]) {\n\t\tthis.list = list;\n\t}\n\n\tpublic [Symbol.iterator](): Iterator<T> {\n\t\treturn this;\n\t}\n\n\tpublic next(): IteratorResult<T> {\n\t\tif (this.done) {\n\t\t\treturn { value: undefined, done: true };\n\t\t}\n\t\treturn { value: this.pop() as T };\n\t}\n\n\tpublic get done(): boolean {\n\t\treturn this.index >= this.list.length && this.stack.length === 0;\n\t}\n\n\tpublic push(item: T): void {\n\t\tthis.stack.push(item);\n\t}\n\n\tpublic pop(): T | undefined {\n\t\tif (this.stack.length > 0) {\n\t\t\treturn this.stack.pop();\n\t\t}\n\t\tif (this.index >= this.list.length) {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn this.list[this.index++];\n\t}\n\n\tpublic peek(): T | undefined {\n\t\tif (this.stack.length > 0) {\n\t\t\treturn this.stack[this.stack.length - 1];\n\t\t}\n\t\treturn this.list[this.index];\n\t}\n}\n"]}

package/lib/util/transactionResult.d.ts

@@ -0,0 +1,20 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Describes the result of a transaction.
+ * Transactions may either succeed and commit, or fail and abort.
+ * @internal
+ */
+export declare enum TransactionResult {
+    /**
+     * Indicates the transaction failed.
+     */
+    Abort = 0,
+    /**
+     * Indicates the transaction succeeded.
+     */
+    Commit = 1
+}
+//# sourceMappingURL=transactionResult.d.ts.map

package/lib/util/transactionResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionResult.d.ts","sourceRoot":"","sources":["../../src/util/transactionResult.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,oBAAY,iBAAiB;IAC5B;;OAEG;IACH,KAAK,IAAA;IACL;;OAEG;IACH,MAAM,IAAA;CACN"}

package/lib/util/transactionResult.js

@@ -0,0 +1,21 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Describes the result of a transaction.
+ * Transactions may either succeed and commit, or fail and abort.
+ * @internal
+ */
+export var TransactionResult;
+(function (TransactionResult) {
+    /**
+     * Indicates the transaction failed.
+     */
+    TransactionResult[TransactionResult["Abort"] = 0] = "Abort";
+    /**
+     * Indicates the transaction succeeded.
+     */
+    TransactionResult[TransactionResult["Commit"] = 1] = "Commit";
+})(TransactionResult || (TransactionResult = {}));
+//# sourceMappingURL=transactionResult.js.map

package/lib/util/transactionResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionResult.js","sourceRoot":"","sources":["../../src/util/transactionResult.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,MAAM,CAAN,IAAY,iBASX;AATD,WAAY,iBAAiB;IAC5B;;OAEG;IACH,2DAAK,CAAA;IACL;;OAEG;IACH,6DAAM,CAAA;AACP,CAAC,EATW,iBAAiB,KAAjB,iBAAiB,QAS5B","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Describes the result of a transaction.\n * Transactions may either succeed and commit, or fail and abort.\n * @internal\n */\nexport enum TransactionResult {\n\t/**\n\t * Indicates the transaction failed.\n\t */\n\tAbort,\n\t/**\n\t * Indicates the transaction succeeded.\n\t */\n\tCommit,\n}\n"]}

package/lib/util/typeCheck.d.ts

@@ -0,0 +1,183 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export type { EnforceTypeCheckTests } from "./typeCheckTests";
+/**
+ * Utilities for manipulating the typescript typechecker.
+ *
+ * @remarks
+ * While it appears the the variance parts of this library are made obsolete by TypeScript 4.7's explicit variance annotations,
+ * many cases still type check with incorrect variance even when using the explicit annotations,
+ * and are fixed by using the patterns in this library.
+ *
+ * TypeScript uses structural typing if there are no private or protected members,
+ * and variance of generic type parameters depends on their usages.
+ * Thus when trying to constrain code by adding extra type information,
+ * it often fails to actually constrain as desired, and these utilities can help with those cases.
+ *
+ * This library is designed so that the desired variance can be documented in a way that is easy to read, concise,
+ * and allows easy navigation to documentation explaining what is being done
+ * for readers who are not familiar with this library.
+ * Additionally it constrains the types so the undesired usage patterns will not compile,
+ * and will give somewhat intelligible errors.
+ *
+ * Additionally this library provides the tools needed to test that the type constraints are working as expected,
+ * or test any other similar typing constraints in an application.
+ *
+ * This library assumes you are compiling with --strictFunctionTypes:
+ * (Covariance and Contravariance is explained along with how these helpers cause it in typescript at this link)
+ * {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-6.html#strict-function-types}.
+ * If compiled with a TypeScript configuration that is not strict enough for these features to work,
+ * the test suite should fail to build.
+ *
+ * Classes in TypeScript by default allow all assignments:
+ * its only though adding members that any type constraints actually get applied.
+ * This library provides types that can be used on a protected member of a class to add the desired constraints.
+ *
+ * Typical usages (use one field like this at the top of a class):
+ * ```typescript
+ * protected _typeCheck?: MakeNominal;
+ * protected _typeCheck?: Contravariant<T>;
+ * protected _typeCheck?: Covariant<T>;
+ * protected _typeCheck?: Invariant<T>;
+ * protected _typeCheck?: Contravariant<T> & Invariant<K>;
+ * ```
+ *
+ * See tests for examples.
+ *
+ * Note that all of these cause nominal typing.
+ * If constraints on generic type parameter variance are desired, but nominal typing is not,
+ * these types can be used on a public field. This case also works with interfaces.
+ *
+ * Be aware that other members of your type might apply further constraints
+ * (ex: you might try and write a Contravariant<T> class, but it ends up being Invariant<T> due to a field of type T).
+ *
+ * Be aware of TypeScript Bug:
+ * {@link https://github.com/microsoft/TypeScript/issues/36906}.
+ * This bug is why the fields here are protected not private.
+ * Note that this bug is closed as a duplicate of {@link https://github.com/microsoft/TypeScript/issues/20979}
+ * which was closed because fixing it would be too large of a breaking change.
+ * Thus we expect this bug to be part of TypeScript for the forseeable future.
+ */
+/**
+ * Use this as the type of a protected field to cause a type to use nominal typing instead of structural.
+ *
+ * @remarks
+ * Using nominal typing in this way prevents assignment of objects which are not instances of this class to values of this class's type.
+ * Classes which are used with "instanceof", or are supposed to be instantiated in particular ways (not just made with object literals)
+ * can use this to prevent undesired assignments.
+ * @example
+ * ```typescript
+ * protected _typeCheck?: MakeNominal;
+ * ```
+ * @privateRemarks
+ * See: {@link https://dev.azure.com/intentional/intent/_wiki/wikis/NP%20Platform/7146/Nominal-vs-Structural-Types}
+ * @beta
+ */
+export interface MakeNominal {
+}
+/**
+ * Constrain generic type parameters to Contravariant.
+ *
+ * @example
+ *
+ * ```typescript
+ * protected _typeCheck?: Contravariant<T>;
+ * ```
+ *
+ * @internal
+ */
+export interface Contravariant<in T> {
+    _removeCovariance?: (_: T) => void;
+}
+/**
+ * Constrain generic type parameters to Covariant.
+ *
+ * @example
+ *
+ * ```typescript
+ * protected _typeCheck?: Covariant<T>;
+ * ```
+ *
+ * @internal
+ */
+export interface Covariant<out T> {
+    _removeContravariance?: T;
+}
+/**
+ * Constrain generic type parameters to Invariant.
+ *
+ * @example
+ *
+ * ```typescript
+ * protected _typeCheck?: Invariant<T>;
+ * ```
+ *
+ * @internal
+ */
+export interface Invariant<in out T> extends Contravariant<T>, Covariant<T> {
+}
+/**
+ * Compile time assert that X is True.
+ * To use, simply define a type:
+ * `type _check = requireTrue<your type check>;`
+ *
+ * @internal
+ */
+export type requireTrue<_X extends true> = true;
+/**
+ * Compile time assert that X is False.
+ * To use, simply define a type:
+ * `type _check = requireFalse<your type check>;`
+ *
+ * @internal
+ */
+export type requireFalse<_X extends false> = true;
+/**
+ * Returns a type parameter that is true iff Source is assignable to Destination.
+ *
+ * @privateRemarks
+ * Use of [] in the extends clause prevents unions from being distributed over this conditional and returning `boolean` in some cases.
+ * @see {@link https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types | distributive-conditional-types} for details.
+ * @internal
+ */
+export type isAssignableTo<Source, Destination> = [Source] extends [Destination] ? true : false;
+/**
+ * Returns a type parameter that is true iff Subset is a strict subset of Superset.
+ *
+ * @internal
+ */
+export type isStrictSubset<Subset, Superset> = isAssignableTo<Subset, Superset> extends false ? false : isAssignableTo<Superset, Subset> extends true ? false : true;
+/**
+ * Returns a type parameter that is true iff A and B are assignable to each other, and neither is any.
+ * This is useful for checking if the output of a type meta-function is the expected type.
+ *
+ * @internal
+ */
+export type areSafelyAssignable<A, B> = eitherIsAny<A, B> extends true ? false : isAssignableTo<A, B> extends true ? isAssignableTo<B, A> : false;
+/**
+ * Returns a type parameter that is true iff A is any or B is any.
+ *
+ * @internal
+ */
+export type eitherIsAny<A, B> = true extends isAny<A> | isAny<B> ? true : false;
+/**
+ * Returns a type parameter that is true iff T is any.
+ *
+ * @privateRemarks
+ * Only `never` is assignable to `never` (`any` isn't),
+ * but `any` distributes over the `extends` here while nothing else should.
+ * This can be used to detect `any`.
+ * @internal
+ */
+export type isAny<T> = boolean extends (T extends never ? true : false) ? true : false;
+/**
+ * Compile time assert that A is assignable to (extends) B.
+ * To use, simply define a type:
+ * `type _check = requireAssignableTo<T, Expected>;`
+ *
+ * @internal
+ */
+export type requireAssignableTo<_A extends B, B> = true;
+//# sourceMappingURL=typeCheck.d.ts.map

package/lib/util/typeCheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeCheck.d.ts","sourceRoot":"","sources":["../../src/util/typeCheck.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,YAAY,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,WAAW;CAAG;AAE/B;;;;;;;;;;GAUG;AACH,MAAM,WAAW,aAAa,CAAC,EAAE,CAAC,CAAC;IAClC,iBAAiB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;CACnC;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,SAAS,CAAC,GAAG,CAAC,CAAC;IAC/B,qBAAqB,CAAC,EAAE,CAAC,CAAC;CAC1B;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,SAAS,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;CAAG;AAE9E;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,EAAE,SAAS,IAAI,IAAI,IAAI,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,CAAC,EAAE,SAAS,KAAK,IAAI,IAAI,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,CAAC,MAAM,EAAE,WAAW,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAEhG;;;;GAIG;AACH,MAAM,MAAM,cAAc,CAAC,MAAM,EAAE,QAAQ,IAAI,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,KAAK,GAC1F,KAAK,GACL,cAAc,CAAC,QAAQ,EAAE,MAAM,CAAC,SAAS,IAAI,GAC7C,KAAK,GACL,IAAI,CAAC;AAER;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,EAAE,CAAC,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GACnE,KAAK,GACL,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GACjC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,GACpB,KAAK,CAAC;AAET;;;;GAIG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,SAAS,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAEhF;;;;;;;;GAQG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,OAAO,SAAS,CAAC,CAAC,SAAS,KAAK,GAAG,IAAI,GAAG,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAEvF;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC"}

package/lib/util/typeCheck.js

@@ -0,0 +1,6 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export {};
+//# sourceMappingURL=typeCheck.js.map

package/lib/util/typeCheck.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeCheck.js","sourceRoot":"","sources":["../../src/util/typeCheck.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n// Normally we would put tests in the test directory.\n// However in this case,\n// it's important that the tests are run with the same compiler settings this library is being used with,\n// since this library does not work for some configurations (ex: with strictNullChecks disabled).\n// Since the tests don't generate any JS: they only produce types,\n// importing them here gets us the validation of the compiler settings we want, with no JS size overhead.\nexport type { EnforceTypeCheckTests } from \"./typeCheckTests\";\n\n/**\n * Utilities for manipulating the typescript typechecker.\n *\n * @remarks\n * While it appears the the variance parts of this library are made obsolete by TypeScript 4.7's explicit variance annotations,\n * many cases still type check with incorrect variance even when using the explicit annotations,\n * and are fixed by using the patterns in this library.\n *\n * TypeScript uses structural typing if there are no private or protected members,\n * and variance of generic type parameters depends on their usages.\n * Thus when trying to constrain code by adding extra type information,\n * it often fails to actually constrain as desired, and these utilities can help with those cases.\n *\n * This library is designed so that the desired variance can be documented in a way that is easy to read, concise,\n * and allows easy navigation to documentation explaining what is being done\n * for readers who are not familiar with this library.\n * Additionally it constrains the types so the undesired usage patterns will not compile,\n * and will give somewhat intelligible errors.\n *\n * Additionally this library provides the tools needed to test that the type constraints are working as expected,\n * or test any other similar typing constraints in an application.\n *\n * This library assumes you are compiling with --strictFunctionTypes:\n * (Covariance and Contravariance is explained along with how these helpers cause it in typescript at this link)\n * {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-6.html#strict-function-types}.\n * If compiled with a TypeScript configuration that is not strict enough for these features to work,\n * the test suite should fail to build.\n *\n * Classes in TypeScript by default allow all assignments:\n * its only though adding members that any type constraints actually get applied.\n * This library provides types that can be used on a protected member of a class to add the desired constraints.\n *\n * Typical usages (use one field like this at the top of a class):\n * ```typescript\n * protected _typeCheck?: MakeNominal;\n * protected _typeCheck?: Contravariant<T>;\n * protected _typeCheck?: Covariant<T>;\n * protected _typeCheck?: Invariant<T>;\n * protected _typeCheck?: Contravariant<T> & Invariant<K>;\n * ```\n *\n * See tests for examples.\n *\n * Note that all of these cause nominal typing.\n * If constraints on generic type parameter variance are desired, but nominal typing is not,\n * these types can be used on a public field. This case also works with interfaces.\n *\n * Be aware that other members of your type might apply further constraints\n * (ex: you might try and write a Contravariant<T> class, but it ends up being Invariant<T> due to a field of type T).\n *\n * Be aware of TypeScript Bug:\n * {@link https://github.com/microsoft/TypeScript/issues/36906}.\n * This bug is why the fields here are protected not private.\n * Note that this bug is closed as a duplicate of {@link https://github.com/microsoft/TypeScript/issues/20979}\n * which was closed because fixing it would be too large of a breaking change.\n * Thus we expect this bug to be part of TypeScript for the forseeable future.\n */\n\n/**\n * Use this as the type of a protected field to cause a type to use nominal typing instead of structural.\n *\n * @remarks\n * Using nominal typing in this way prevents assignment of objects which are not instances of this class to values of this class's type.\n * Classes which are used with \"instanceof\", or are supposed to be instantiated in particular ways (not just made with object literals)\n * can use this to prevent undesired assignments.\n * @example\n * ```typescript\n * protected _typeCheck?: MakeNominal;\n * ```\n * @privateRemarks\n * See: {@link https://dev.azure.com/intentional/intent/_wiki/wikis/NP%20Platform/7146/Nominal-vs-Structural-Types}\n * @beta\n */\nexport interface MakeNominal {}\n\n/**\n * Constrain generic type parameters to Contravariant.\n *\n * @example\n *\n * ```typescript\n * protected _typeCheck?: Contravariant<T>;\n * ```\n *\n * @internal\n */\nexport interface Contravariant<in T> {\n\t_removeCovariance?: (_: T) => void;\n}\n\n/**\n * Constrain generic type parameters to Covariant.\n *\n * @example\n *\n * ```typescript\n * protected _typeCheck?: Covariant<T>;\n * ```\n *\n * @internal\n */\nexport interface Covariant<out T> {\n\t_removeContravariance?: T;\n}\n\n/**\n * Constrain generic type parameters to Invariant.\n *\n * @example\n *\n * ```typescript\n * protected _typeCheck?: Invariant<T>;\n * ```\n *\n * @internal\n */\nexport interface Invariant<in out T> extends Contravariant<T>, Covariant<T> {}\n\n/**\n * Compile time assert that X is True.\n * To use, simply define a type:\n * `type _check = requireTrue<your type check>;`\n *\n * @internal\n */\nexport type requireTrue<_X extends true> = true;\n\n/**\n * Compile time assert that X is False.\n * To use, simply define a type:\n * `type _check = requireFalse<your type check>;`\n *\n * @internal\n */\nexport type requireFalse<_X extends false> = true;\n\n/**\n * Returns a type parameter that is true iff Source is assignable to Destination.\n *\n * @privateRemarks\n * Use of [] in the extends clause prevents unions from being distributed over this conditional and returning `boolean` in some cases.\n * @see {@link https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types | distributive-conditional-types} for details.\n * @internal\n */\nexport type isAssignableTo<Source, Destination> = [Source] extends [Destination] ? true : false;\n\n/**\n * Returns a type parameter that is true iff Subset is a strict subset of Superset.\n *\n * @internal\n */\nexport type isStrictSubset<Subset, Superset> = isAssignableTo<Subset, Superset> extends false\n\t? false\n\t: isAssignableTo<Superset, Subset> extends true\n\t? false\n\t: true;\n\n/**\n * Returns a type parameter that is true iff A and B are assignable to each other, and neither is any.\n * This is useful for checking if the output of a type meta-function is the expected type.\n *\n * @internal\n */\nexport type areSafelyAssignable<A, B> = eitherIsAny<A, B> extends true\n\t? false\n\t: isAssignableTo<A, B> extends true\n\t? isAssignableTo<B, A>\n\t: false;\n\n/**\n * Returns a type parameter that is true iff A is any or B is any.\n *\n * @internal\n */\nexport type eitherIsAny<A, B> = true extends isAny<A> | isAny<B> ? true : false;\n\n/**\n * Returns a type parameter that is true iff T is any.\n *\n * @privateRemarks\n * Only `never` is assignable to `never` (`any` isn't),\n * but `any` distributes over the `extends` here while nothing else should.\n * This can be used to detect `any`.\n * @internal\n */\nexport type isAny<T> = boolean extends (T extends never ? true : false) ? true : false;\n\n/**\n * Compile time assert that A is assignable to (extends) B.\n * To use, simply define a type:\n * `type _check = requireAssignableTo<T, Expected>;`\n *\n * @internal\n */\nexport type requireAssignableTo<_A extends B, B> = true;\n"]}

package/lib/util/typeCheckTests.d.ts

@@ -0,0 +1,60 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { MakeNominal, Covariant, Contravariant, Invariant, requireTrue, requireFalse, isAssignableTo, areSafelyAssignable, isAny, eitherIsAny, isStrictSubset } from "./typeCheck";
+/**
+ * Checks that typeCheck's constraints work as intended.
+ * Since typescript does type erasure, these tests have to be compile time checks.
+ */
+declare class Empty1 {
+}
+declare class Empty2 {
+}
+declare class Nominal1 {
+    protected _typeCheck?: MakeNominal;
+}
+declare class Nominal2 {
+    protected _typeCheck?: MakeNominal;
+}
+declare class Derived1 extends Nominal1 {
+    protected _typeCheck?: MakeNominal;
+}
+declare class Derived2 extends Nominal1 {
+    protected _typeCheck?: MakeNominal;
+}
+declare class Generic<_T> {
+}
+declare class GenericCovariant<out T> {
+    protected _typeCheck?: Covariant<T>;
+}
+declare class GenericContravariant<in T> {
+    protected _typeCheck?: Contravariant<T>;
+}
+declare class GenericInvariant<in out T> {
+    protected _typeCheck?: Invariant<T>;
+}
+declare class GenericMulti<in out T, out K> {
+    protected _typeCheck?: Invariant<T> & Covariant<K>;
+}
+interface GenericCovariantInterface<out T> {
+    _typeCheck?: Covariant<T>;
+}
+interface GenericContravariantInterface<in T> {
+    _typeCheck?: Contravariant<T>;
+}
+interface GenericInvariantInterface<in out T> {
+    _typeCheck?: Invariant<T>;
+}
+declare class GenericInvariantImplementation<T> implements GenericInvariantInterface<T> {
+}
+/**
+ * Import this into a context where you want to be sure the TypeCheck library is functioning properly.
+ *
+ * It's functionality depends on compiler settings (requires several of the strict options),
+ * and could break with compiler version changes.
+ * Thus for maximal confidence everything is working correctly, you need to import this.
+ */
+export type EnforceTypeCheckTests = requireTrue<isAssignableTo<GenericInvariantImplementation<number>, GenericInvariantInterface<number>>> | requireTrue<true> | requireFalse<false> | requireTrue<isAssignableTo<Empty1, Empty1>> | requireTrue<isAssignableTo<Empty1, Empty2>> | requireTrue<isAssignableTo<Nominal1, Nominal1>> | requireFalse<isAssignableTo<Nominal1, Nominal2>> | requireTrue<isAssignableTo<Derived1, Nominal1>> | requireFalse<isAssignableTo<Derived1, Derived2>> | requireTrue<isAssignableTo<Generic<Nominal1>, Generic<Nominal2>>> | requireTrue<isAssignableTo<any, Nominal1>> | requireTrue<isAssignableTo<Nominal1, any>> | requireFalse<isAssignableTo<unknown, Nominal1>> | requireTrue<isAssignableTo<Nominal1, unknown>> | requireTrue<isAssignableTo<never, Nominal1>> | requireFalse<isAssignableTo<Nominal1, never>> | requireFalse<isAssignableTo<GenericCovariant<Nominal1>, GenericCovariant<Nominal2>>> | requireTrue<isAssignableTo<GenericCovariant<Derived1>, GenericCovariant<Nominal1>>> | requireFalse<isAssignableTo<GenericCovariant<Nominal1>, GenericCovariant<Derived1>>> | requireFalse<isAssignableTo<GenericContravariant<Nominal1>, GenericContravariant<Nominal2>>> | requireFalse<isAssignableTo<GenericContravariant<Derived1>, GenericContravariant<Nominal1>>> | requireTrue<isAssignableTo<GenericContravariant<Nominal1>, GenericContravariant<Derived1>>> | requireFalse<isAssignableTo<GenericInvariant<Nominal1>, GenericInvariant<Nominal2>>> | requireFalse<isAssignableTo<GenericInvariant<Derived1>, GenericInvariant<Nominal1>>> | requireFalse<isAssignableTo<GenericInvariant<Nominal1>, GenericInvariant<Derived1>>> | requireFalse<isAssignableTo<GenericMulti<Nominal1, number>, GenericMulti<Derived1, number>>> | requireFalse<isAssignableTo<GenericMulti<number, Nominal1>, GenericMulti<number, Derived1>>> | requireTrue<isAssignableTo<GenericMulti<number, Derived1>, GenericMulti<number, Nominal1>>> | requireFalse<isAssignableTo<GenericCovariantInterface<Nominal1>, GenericCovariantInterface<Nominal2>>> | requireTrue<isAssignableTo<GenericCovariantInterface<Derived1>, GenericCovariantInterface<Nominal1>>> | requireFalse<isAssignableTo<GenericCovariantInterface<Nominal1>, GenericCovariantInterface<Derived1>>> | requireFalse<isAssignableTo<GenericContravariantInterface<Nominal1>, GenericContravariantInterface<Nominal2>>> | requireFalse<isAssignableTo<GenericContravariantInterface<Derived1>, GenericContravariantInterface<Nominal1>>> | requireTrue<isAssignableTo<GenericContravariantInterface<Nominal1>, GenericContravariantInterface<Derived1>>> | requireFalse<isAssignableTo<GenericInvariantInterface<Nominal1>, GenericInvariantInterface<Nominal2>>> | requireFalse<isAssignableTo<GenericInvariantInterface<Derived1>, GenericInvariantInterface<Nominal1>>> | requireFalse<isAssignableTo<GenericInvariantInterface<Nominal1>, GenericInvariantInterface<Derived1>>> | requireTrue<eitherIsAny<any, Nominal1>> | requireTrue<eitherIsAny<Nominal1, any>> | requireTrue<eitherIsAny<any, any>> | requireFalse<eitherIsAny<Nominal1, Nominal1>> | requireTrue<areSafelyAssignable<Nominal1, Nominal1>> | requireFalse<areSafelyAssignable<unknown, Nominal1>> | requireFalse<areSafelyAssignable<any, any>> | requireTrue<areSafelyAssignable<unknown, unknown>> | requireFalse<areSafelyAssignable<any, Nominal1>> | requireFalse<areSafelyAssignable<Nominal1, any>> | requireFalse<areSafelyAssignable<unknown, any>> | requireTrue<isAny<any>> | requireFalse<isAny<unknown>> | requireFalse<isAny<Nominal1>> | requireFalse<isAny<never>> | requireFalse<isAny<{}>> | requireFalse<isAny<boolean>> | requireFalse<isAny<number | undefined>> | requireFalse<isAny<1 & "x">> | requireFalse<isAny<(1 & 2) | {}>> | requireTrue<isStrictSubset<1, 1 | 2>> | requireTrue<isStrictSubset<[1, true], [1 | 2, true]>> | requireTrue<isStrictSubset<[1, true], [1 | 2, true | false]>> | requireTrue<isStrictSubset<[1, true], [1, true | false]>> | requireTrue<isStrictSubset<[1, true], [1, true] | [1 | false]>> | requireFalse<isStrictSubset<1, 1>> | requireFalse<isStrictSubset<1, 2>> | requireFalse<isStrictSubset<[1, true], [1, true]>> | requireFalse<isStrictSubset<1 | 2, 1>>;
+export {};
+//# sourceMappingURL=typeCheckTests.d.ts.map

package/lib/util/typeCheckTests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeCheckTests.d.ts","sourceRoot":"","sources":["../../src/util/typeCheckTests.ts"],"names":[],"mappings":"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"}

package/lib/util/typeCheckTests.js

@@ -0,0 +1,6 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export {};
+//# sourceMappingURL=typeCheckTests.js.map

package/lib/util/typeCheckTests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeCheckTests.js","sourceRoot":"","sources":["../../src/util/typeCheckTests.ts"],"names":[],"mappings":"AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n// These tests include making sure some banned types (like `{}`) work correctly,\n// and are authored with awareness of the issues with these types.\n\n/* eslint-disable @typescript-eslint/ban-types */\n/* eslint-disable @typescript-eslint/no-extraneous-class */\n\nimport {\n\tMakeNominal,\n\tCovariant,\n\tContravariant,\n\tInvariant,\n\trequireTrue,\n\trequireFalse,\n\tisAssignableTo,\n\tareSafelyAssignable,\n\tisAny,\n\teitherIsAny,\n\tisStrictSubset,\n} from \"./typeCheck\";\n\n/**\n * Checks that typeCheck's constraints work as intended.\n * Since typescript does type erasure, these tests have to be compile time checks.\n */\n\ndeclare class Empty1 {}\ndeclare class Empty2 {}\n\ndeclare class Nominal1 {\n\tprotected _typeCheck?: MakeNominal;\n}\n\ndeclare class Nominal2 {\n\tprotected _typeCheck?: MakeNominal;\n}\n\ndeclare class Derived1 extends Nominal1 {\n\tprotected _typeCheck?: MakeNominal;\n}\n\ndeclare class Derived2 extends Nominal1 {\n\tprotected _typeCheck?: MakeNominal;\n}\n\ndeclare class Generic<_T> {}\n\ndeclare class GenericCovariant<out T> {\n\tprotected _typeCheck?: Covariant<T>;\n}\n\ndeclare class GenericContravariant<in T> {\n\tprotected _typeCheck?: Contravariant<T>;\n}\n\ndeclare class GenericInvariant<in out T> {\n\tprotected _typeCheck?: Invariant<T>;\n}\n\ndeclare class GenericMulti<in out T, out K> {\n\tprotected _typeCheck?: Invariant<T> & Covariant<K>;\n}\n\ninterface GenericCovariantInterface<out T> {\n\t_typeCheck?: Covariant<T>;\n}\n\ninterface GenericContravariantInterface<in T> {\n\t_typeCheck?: Contravariant<T>;\n}\n\ninterface GenericInvariantInterface<in out T> {\n\t_typeCheck?: Invariant<T>;\n}\n\n// Check that interface can be implemented without needing extra members\ndeclare class GenericInvariantImplementation<T> implements GenericInvariantInterface<T> {}\n\n/**\n * Import this into a context where you want to be sure the TypeCheck library is functioning properly.\n *\n * It's functionality depends on compiler settings (requires several of the strict options),\n * and could break with compiler version changes.\n * Thus for maximal confidence everything is working correctly, you need to import this.\n */\nexport type EnforceTypeCheckTests =\n\t// Add dummy use of type checking types above\n\t| requireTrue<\n\t\t\tisAssignableTo<\n\t\t\t\tGenericInvariantImplementation<number>,\n\t\t\t\tGenericInvariantInterface<number>\n\t\t\t>\n\t  >\n\n\t// Positive tests\n\t| requireTrue<true>\n\t| requireFalse<false>\n\n\t// test isAssignableTo for normal types\n\t| requireTrue<isAssignableTo<Empty1, Empty1>>\n\t| requireTrue<isAssignableTo<Empty1, Empty2>>\n\t| requireTrue<isAssignableTo<Nominal1, Nominal1>>\n\t| requireFalse<isAssignableTo<Nominal1, Nominal2>>\n\t| requireTrue<isAssignableTo<Derived1, Nominal1>>\n\t| requireFalse<isAssignableTo<Derived1, Derived2>>\n\t| requireTrue<isAssignableTo<Generic<Nominal1>, Generic<Nominal2>>>\n\n\t// test isAssignableTo for any\n\t| requireTrue<isAssignableTo<any, Nominal1>>\n\t| requireTrue<isAssignableTo<Nominal1, any>>\n\n\t// test isAssignableTo for unknown: all types are assignable to unknown\n\t| requireFalse<isAssignableTo<unknown, Nominal1>>\n\t| requireTrue<isAssignableTo<Nominal1, unknown>>\n\n\t// test isAssignableTo for never: all types are assignable from never\n\t| requireTrue<isAssignableTo<never, Nominal1>>\n\t| requireFalse<isAssignableTo<Nominal1, never>>\n\n\t// test Covariant\n\t| requireFalse<isAssignableTo<GenericCovariant<Nominal1>, GenericCovariant<Nominal2>>>\n\t| requireTrue<isAssignableTo<GenericCovariant<Derived1>, GenericCovariant<Nominal1>>>\n\t| requireFalse<isAssignableTo<GenericCovariant<Nominal1>, GenericCovariant<Derived1>>>\n\n\t// test Contravariant\n\t| requireFalse<isAssignableTo<GenericContravariant<Nominal1>, GenericContravariant<Nominal2>>>\n\t| requireFalse<isAssignableTo<GenericContravariant<Derived1>, GenericContravariant<Nominal1>>>\n\t| requireTrue<isAssignableTo<GenericContravariant<Nominal1>, GenericContravariant<Derived1>>>\n\n\t// test Invariant\n\t| requireFalse<isAssignableTo<GenericInvariant<Nominal1>, GenericInvariant<Nominal2>>>\n\t| requireFalse<isAssignableTo<GenericInvariant<Derived1>, GenericInvariant<Nominal1>>>\n\t| requireFalse<isAssignableTo<GenericInvariant<Nominal1>, GenericInvariant<Derived1>>>\n\n\t// test Multiple parameters\n\t| requireFalse<isAssignableTo<GenericMulti<Nominal1, number>, GenericMulti<Derived1, number>>>\n\t| requireFalse<isAssignableTo<GenericMulti<number, Nominal1>, GenericMulti<number, Derived1>>>\n\t| requireTrue<isAssignableTo<GenericMulti<number, Derived1>, GenericMulti<number, Nominal1>>>\n\n\t// test Covariant Interface\n\t| requireFalse<\n\t\t\tisAssignableTo<GenericCovariantInterface<Nominal1>, GenericCovariantInterface<Nominal2>>\n\t  >\n\t| requireTrue<\n\t\t\tisAssignableTo<GenericCovariantInterface<Derived1>, GenericCovariantInterface<Nominal1>>\n\t  >\n\t| requireFalse<\n\t\t\tisAssignableTo<GenericCovariantInterface<Nominal1>, GenericCovariantInterface<Derived1>>\n\t  >\n\n\t// test Contravariant Interface\n\t| requireFalse<\n\t\t\tisAssignableTo<\n\t\t\t\tGenericContravariantInterface<Nominal1>,\n\t\t\t\tGenericContravariantInterface<Nominal2>\n\t\t\t>\n\t  >\n\t| requireFalse<\n\t\t\tisAssignableTo<\n\t\t\t\tGenericContravariantInterface<Derived1>,\n\t\t\t\tGenericContravariantInterface<Nominal1>\n\t\t\t>\n\t  >\n\t| requireTrue<\n\t\t\tisAssignableTo<\n\t\t\t\tGenericContravariantInterface<Nominal1>,\n\t\t\t\tGenericContravariantInterface<Derived1>\n\t\t\t>\n\t  >\n\n\t// test Invariant Interface\n\t| requireFalse<\n\t\t\tisAssignableTo<GenericInvariantInterface<Nominal1>, GenericInvariantInterface<Nominal2>>\n\t  >\n\t| requireFalse<\n\t\t\tisAssignableTo<GenericInvariantInterface<Derived1>, GenericInvariantInterface<Nominal1>>\n\t  >\n\t| requireFalse<\n\t\t\tisAssignableTo<GenericInvariantInterface<Nominal1>, GenericInvariantInterface<Derived1>>\n\t  >\n\n\t// test eitherIsAny\n\t| requireTrue<eitherIsAny<any, Nominal1>>\n\t| requireTrue<eitherIsAny<Nominal1, any>>\n\t| requireTrue<eitherIsAny<any, any>>\n\t| requireFalse<eitherIsAny<Nominal1, Nominal1>>\n\n\t// areSafelyAssignable tests\n\t| requireTrue<areSafelyAssignable<Nominal1, Nominal1>>\n\t| requireFalse<areSafelyAssignable<unknown, Nominal1>>\n\t| requireFalse<areSafelyAssignable<any, any>>\n\t| requireTrue<areSafelyAssignable<unknown, unknown>>\n\t| requireFalse<areSafelyAssignable<any, Nominal1>>\n\t| requireFalse<areSafelyAssignable<Nominal1, any>>\n\t| requireFalse<areSafelyAssignable<unknown, any>>\n\n\t// test isAny\n\t| requireTrue<isAny<any>>\n\t| requireFalse<isAny<unknown>>\n\t| requireFalse<isAny<Nominal1>>\n\t| requireFalse<isAny<never>>\n\t| requireFalse<isAny<{}>>\n\t| requireFalse<isAny<boolean>>\n\t| requireFalse<isAny<number | undefined>>\n\t| requireFalse<isAny<1 & \"x\">>\n\t| requireFalse<isAny<(1 & 2) | {}>>\n\n\t// test isStrictSubset\n\t| requireTrue<isStrictSubset<1, 1 | 2>>\n\t| requireTrue<isStrictSubset<[1, true], [1 | 2, true]>>\n\t| requireTrue<isStrictSubset<[1, true], [1 | 2, true | false]>>\n\t| requireTrue<isStrictSubset<[1, true], [1, true | false]>>\n\t| requireTrue<isStrictSubset<[1, true], [1, true] | [1 | false]>>\n\t| requireFalse<isStrictSubset<1, 1>>\n\t| requireFalse<isStrictSubset<1, 2>>\n\t| requireFalse<isStrictSubset<[1, true], [1, true]>>\n\t| requireFalse<isStrictSubset<1 | 2, 1>>;\n\n// negative tests (should not build)\n// @ts-expect-error negative test\ntype _falseIsTrue = requireTrue<false>;\n// @ts-expect-error negative test\ntype _trueIsFalse = requireFalse<true>;\n// @ts-expect-error negative test\ntype _booleanIsTrue = requireTrue<boolean>;\n// @ts-expect-error negative test\ntype _booleanIsFalse = requireFalse<boolean>;\n// @ts-expect-error negative test\ntype _emptyNotAssignable = requireFalse<isAssignableTo<Empty1, Empty2>>;\n// @ts-expect-error negative test\ntype _numberAssignableToString = requireTrue<isAssignableTo<number, string>>;\n// @ts-expect-error negative test\ntype _anyNotAny = requireFalse<isAny<any>>;\n"]}

package/lib/util/typeUtils.d.ts

@@ -0,0 +1,129 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Utilities for manipulating types.
+ */
+/**
+ * Return a type thats equivalent to the input, but with different IntelliSense.
+ * This tends to convert unions and intersections into objects.
+ * @internal
+ */
+export type FlattenKeys<T> = [{
+    [Property in keyof T]: T[Property];
+}][_InlineTrick];
+/**
+ * Remove all fields which permit undefined from `T`.
+ * @internal
+ */
+export type RequiredFields<T> = [
+    {
+        [P in keyof T as undefined extends T[P] ? never : P]: T[P];
+    }
+][_InlineTrick];
+/**
+ * Extract fields which permit undefined but can also hold other types.
+ * @internal
+ */
+export type OptionalFields<T> = [
+    {
+        [P in keyof T as undefined extends T[P] ? T[P] extends undefined ? never : P : never]?: T[P];
+    }
+][_InlineTrick];
+/**
+ * Converts properties of an object which permit undefined into optional properties.
+ * Removes fields which only allow undefined.
+ *
+ * @remarks
+ * This version does not flatten the resulting type.
+ * This version exists because some cases recursive types need to avoid this
+ * flattening since it causes complication issues.
+ *
+ * See also `AllowOptional`.
+ * @internal
+ */
+export type AllowOptionalNotFlattened<T> = [RequiredFields<T> & OptionalFields<T>][_InlineTrick];
+/**
+ * Converts properties of an object which permit undefined into optional properties.
+ * Removes fields which only allow undefined.
+ * @internal
+ */
+export type AllowOptional<T> = [FlattenKeys<RequiredFields<T> & OptionalFields<T>>][_InlineTrick];
+/**
+ * Use for trick to "inline" generic types.
+ *
+ * @remarks
+ * The TypeScript compiler can be convinced to inline a generic type
+ * (so the result of evaluating the generic type show up in IntelliSense and error messages instead of just the invocation of the generic type)
+ * by creating an object with a field, and returning the type of that field.
+ *
+ * For example:
+ * ```typescript
+ * type MyGeneric<T1, T2> = {x: T1 extends [] ? T1 : T2 };
+ * type MyGenericExpanded<T1, T2> = [{x: T1 extends [] ? T1 : T2 }][_InlineTrick]
+ *
+ * // Type is MyGeneric<5, string>
+ * const foo: MyGeneric<5, string> = {x: "x"}
+ * // Type is {x: "x"}
+ * const foo2: MyGenericExpanded<5, string> = {x: "x"}
+ * ```
+ *
+ * This constant is defined to provide a way to find this documentation from types which use this pattern,
+ * and to locate types which use this pattern in case they need updating for compiler changes.
+ * @internal
+ */
+export type _InlineTrick = 0;
+/**
+ * Use for trick to prevent self reference error `ts(2456)`.
+ *
+ * Prefix a type expression with `K extends _RecursiveTrick ? _RecursiveTrick : ` for some K to break the cycle.
+ *
+ * @remarks
+ * The TypeScript compiler handles some cases of recursive types, but not others.
+ * Sometimes adding an otherwise needless conditional can make a type compile.
+ * Use this type in such cases.
+ *
+ *For example:
+ * ```typescript
+ * // The TypeScript compiler can't handle this case
+ * type Broken<T> = FlattenKeys<
+ *	{
+ * 		[K in keyof T]: 0;
+ * 	} & {
+ * 		[K in keyof T]: Broken<T[K]>;
+ * 	}
+ * >;
+ *
+ * // Adding `K extends _RecursiveTrick ? _RecursiveTrick :` makes it compile, and has no effect on the type produced.
+ * type Works<T> = FlattenKeys<
+ * 	{
+ * 		[K in keyof T]: 0;
+ * 	} & {
+ * 		// Trick added here. Since `k` never extends `never`, the second conditional option is always taken,
+ * 		// making this equivalent to the broken version, except this one compiles.
+ * 		[K in keyof T]: K extends _RecursiveTrick ? _RecursiveTrick : Works<T[K]>;
+ * 	}
+ * >;
+ * ```
+ *
+ * This trick appears to start working in TypeScript 4.1 and is confirmed to still work in 5.0.4.
+ *
+ * This constant is defined to provide a way to find this documentation from types which use this pattern,
+ * and to locate types which use this pattern in case they need updating for compiler changes.
+ * @internal
+ */
+export type _RecursiveTrick = never;
+/**
+ * Alternative to the built in Record type which does not permit unexpected members,
+ * and is readonly.
+ *
+ * @privateRemarks
+ * `number` is not allowed as a key here since doing so causes the compiler to reject recursive schema.
+ * The cause for this is unclear, but empirically it was the case when this comment was written.
+ * @beta
+ */
+export type RestrictiveReadonlyRecord<K extends symbol | string, T> = {
+    readonly [P in symbol | string]: P extends K ? T : never;
+};
+//# sourceMappingURL=typeUtils.d.ts.map

package/lib/util/typeUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtils.d.ts","sourceRoot":"","sources":["../../src/util/typeUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AAEH;;;;GAIG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC;KAAG,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC;CAAE,CAAC,CAAC,YAAY,CAAC,CAAC;AAEpF;;;GAGG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC/B;SACE,CAAC,IAAI,MAAM,CAAC,IAAI,SAAS,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KAC1D;CACD,CAAC,YAAY,CAAC,CAAC;AAEhB;;;GAGG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC/B;SACE,CAAC,IAAI,MAAM,CAAC,IAAI,SAAS,SAAS,CAAC,CAAC,CAAC,CAAC,GACpC,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,GACrB,KAAK,GACL,CAAC,GACF,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;KAChB;CACD,CAAC,YAAY,CAAC,CAAC;AAEhB;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,yBAAyB,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;AAEjG;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;AAElG;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,MAAM,eAAe,GAAG,KAAK,CAAC;AA8BpC;;;;;;;;GAQG;AACH,MAAM,MAAM,yBAAyB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,IAAI;IACrE,QAAQ,EAAE,CAAC,IAAI,MAAM,GAAG,MAAM,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK;CACxD,CAAC"}

package/lib/util/typeUtils.js

@@ -0,0 +1,10 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+// This block is kept here to ensure the above example behaves as documented, and can be copied into the example to update it as needed.
+{
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+}
+export {};
+//# sourceMappingURL=typeUtils.js.map

package/lib/util/typeUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtils.js","sourceRoot":"","sources":["../../src/util/typeUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA6HH,wIAAwI;AACxI;IAwBC,qDAAqD;CACrD","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Utilities for manipulating types.\n */\n\n/**\n * Return a type thats equivalent to the input, but with different IntelliSense.\n * This tends to convert unions and intersections into objects.\n * @internal\n */\nexport type FlattenKeys<T> = [{ [Property in keyof T]: T[Property] }][_InlineTrick];\n\n/**\n * Remove all fields which permit undefined from `T`.\n * @internal\n */\nexport type RequiredFields<T> = [\n\t{\n\t\t[P in keyof T as undefined extends T[P] ? never : P]: T[P];\n\t},\n][_InlineTrick];\n\n/**\n * Extract fields which permit undefined but can also hold other types.\n * @internal\n */\nexport type OptionalFields<T> = [\n\t{\n\t\t[P in keyof T as undefined extends T[P]\n\t\t\t? T[P] extends undefined\n\t\t\t\t? never\n\t\t\t\t: P\n\t\t\t: never]?: T[P];\n\t},\n][_InlineTrick];\n\n/**\n * Converts properties of an object which permit undefined into optional properties.\n * Removes fields which only allow undefined.\n *\n * @remarks\n * This version does not flatten the resulting type.\n * This version exists because some cases recursive types need to avoid this\n * flattening since it causes complication issues.\n *\n * See also `AllowOptional`.\n * @internal\n */\n// export type AllowOptionalNotFlattened<T> = [RequiredFields<T> & OptionalFields<T>][_InlineTrick];\nexport type AllowOptionalNotFlattened<T> = [RequiredFields<T> & OptionalFields<T>][_InlineTrick];\n\n/**\n * Converts properties of an object which permit undefined into optional properties.\n * Removes fields which only allow undefined.\n * @internal\n */\nexport type AllowOptional<T> = [FlattenKeys<RequiredFields<T> & OptionalFields<T>>][_InlineTrick];\n\n/**\n * Use for trick to \"inline\" generic types.\n *\n * @remarks\n * The TypeScript compiler can be convinced to inline a generic type\n * (so the result of evaluating the generic type show up in IntelliSense and error messages instead of just the invocation of the generic type)\n * by creating an object with a field, and returning the type of that field.\n *\n * For example:\n * ```typescript\n * type MyGeneric<T1, T2> = {x: T1 extends [] ? T1 : T2 };\n * type MyGenericExpanded<T1, T2> = [{x: T1 extends [] ? T1 : T2 }][_InlineTrick]\n *\n * // Type is MyGeneric<5, string>\n * const foo: MyGeneric<5, string> = {x: \"x\"}\n * // Type is {x: \"x\"}\n * const foo2: MyGenericExpanded<5, string> = {x: \"x\"}\n * ```\n *\n * This constant is defined to provide a way to find this documentation from types which use this pattern,\n * and to locate types which use this pattern in case they need updating for compiler changes.\n * @internal\n */\nexport type _InlineTrick = 0;\n\n/**\n * Use for trick to prevent self reference error `ts(2456)`.\n *\n * Prefix a type expression with `K extends _RecursiveTrick ? _RecursiveTrick : ` for some K to break the cycle.\n *\n * @remarks\n * The TypeScript compiler handles some cases of recursive types, but not others.\n * Sometimes adding an otherwise needless conditional can make a type compile.\n * Use this type in such cases.\n *\n *For example:\n * ```typescript\n * // The TypeScript compiler can't handle this case\n * type Broken<T> = FlattenKeys<\n *\t{\n * \t\t[K in keyof T]: 0;\n * \t} & {\n * \t\t[K in keyof T]: Broken<T[K]>;\n * \t}\n * >;\n *\n * // Adding `K extends _RecursiveTrick ? _RecursiveTrick :` makes it compile, and has no effect on the type produced.\n * type Works<T> = FlattenKeys<\n * \t{\n * \t\t[K in keyof T]: 0;\n * \t} & {\n * \t\t// Trick added here. Since `k` never extends `never`, the second conditional option is always taken,\n * \t\t// making this equivalent to the broken version, except this one compiles.\n * \t\t[K in keyof T]: K extends _RecursiveTrick ? _RecursiveTrick : Works<T[K]>;\n * \t}\n * >;\n * ```\n *\n * This trick appears to start working in TypeScript 4.1 and is confirmed to still work in 5.0.4.\n *\n * This constant is defined to provide a way to find this documentation from types which use this pattern,\n * and to locate types which use this pattern in case they need updating for compiler changes.\n * @internal\n */\nexport type _RecursiveTrick = never;\n\n// This block is kept here to ensure the above example behaves as documented, and can be copied into the example to update it as needed.\n{\n\t/* eslint-disable @typescript-eslint/no-unused-vars */\n\n\t// @ts-expect-error The TypeScript compiler can't handle this case\n\ttype Broken<T> = FlattenKeys<\n\t\t{\n\t\t\t[K in keyof T]: 0;\n\t\t} & {\n\t\t\t// @ts-expect-error Same error as above.\n\t\t\t[K in keyof T]: Broken<T[K]>;\n\t\t}\n\t>;\n\n\t// Adding `K extends _RecursiveTrick ? _RecursiveTrick:` OR `T extends _RecursiveTrick ? _RecursiveTrick :` makes it compile and has no effect on the type produced.\n\ttype Works<T> = FlattenKeys<\n\t\t{\n\t\t\t[K in keyof T]: 0;\n\t\t} & {\n\t\t\t// Trick added here. Since `K` never extends `never`, the second conditional option is always taken,\n\t\t\t// making this equivalent to the broken version, except this one compiles.\n\t\t\t[K in keyof T]: T extends _RecursiveTrick ? _RecursiveTrick : Works<T[K]>;\n\t\t}\n\t>;\n\n\t/* eslint-enable @typescript-eslint/no-unused-vars */\n}\n\n/**\n * Alternative to the built in Record type which does not permit unexpected members,\n * and is readonly.\n *\n * @privateRemarks\n * `number` is not allowed as a key here since doing so causes the compiler to reject recursive schema.\n * The cause for this is unclear, but empirically it was the case when this comment was written.\n * @beta\n */\nexport type RestrictiveReadonlyRecord<K extends symbol | string, T> = {\n\treadonly [P in symbol | string]: P extends K ? T : never;\n};\n"]}