@mnaoumov/typescript-lib 1.2.0 → 1.3.0

package/dist/lib/esm/type-guards.d.mts

@@ -2,15 +2,66 @@
 /**
  * @file
  *
- * Contains utility functions for type guards.
+ * Contains utility functions for type guards, and combinators that build a {@link TypeGuard} out of others.
+ *
+ * The combinators here work on bare type guards. Their `api-contract` counterparts (`arrayGuard`, `optionalGuard`,
+ * ...) work on an `ExpectedTypeGuard`, a type guard paired with the text an issue message reports, and their names
+ * drop the `Type` this layer's names carry.
  */
+import type { GenericFunction } from './function.mjs';
 /**
  * A type that represents a generic object.
  *
  * @typeParam T - The base type to intersect with.
  */
 export type GenericObject<T = unknown> = Record<string | symbol, unknown> & T;
+/**
+ * The type a {@link TypeGuard} narrows to. Distributes over a union of guards.
+ *
+ * @typeParam TTypeGuard - The type guard.
+ */
+export type GuardedType<TTypeGuard> = TTypeGuard extends (value: unknown) => value is infer T ? T : never;
+/**
+ * A value {@link literalTypeGuard} can compare against.
+ */
+export type Literal = bigint | boolean | null | number | string | symbol | undefined;
+/**
+ * Options for {@link objectTypeGuard}.
+ */
+export interface ObjectTypeGuardOptions {
+    /**
+     * Whether a value carrying an own enumerable string key that no property guard names is refused.
+     *
+     * @default `false`
+     */
+    readonly shouldRejectUnknownKeys?: boolean;
+}
+/**
+ * One type guard per property of an object type, as {@link objectTypeGuard} takes them. Every key of `T` must be
+ * listed. The guard of an optional property is typed to narrow to `undefined` as well, but a guard that refuses
+ * `undefined` still compiles there, so widen it with {@link optionalTypeGuard}: an absent property reads as
+ * `undefined`, and a guard refusing it refuses the object.
+ *
+ * @typeParam T - The object type.
+ */
+export type PropertyTypeGuards<T extends object> = {
+    readonly [TKey in keyof T]-?: TypeGuard<Partial<Pick<T, TKey>> extends Pick<T, TKey> ? T[TKey] | undefined : T[TKey]>;
+};
+/**
+ * A function deciding whether a value is a `T`.
+ *
+ * @typeParam T - The type the guard narrows to.
+ */
+export type TypeGuard<T> = (value: unknown) => value is T;
 type NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;
+/**
+ * Builds a guard accepting an array whose every item the item guard accepts.
+ *
+ * @typeParam T - The type of an item.
+ * @param isItem - The guard for one item.
+ * @returns The guard.
+ */
+export declare function arrayTypeGuard<T>(isItem: TypeGuard<T>): TypeGuard<T[]>;
 /**
  * Asserts that a condition is `true`. Throws if it is not.
  *
@@ -81,6 +132,22 @@ export declare function ensureGenericObject<T>($object: T): GenericObject<T>;
  * @throws If the value is `null` or `undefined`.
  */
 export declare function ensureNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): NonNullable<T>;
+/**
+ * Builds a guard accepting any function, narrowed to the signature `TFunction`. Only that the value is a function
+ * is checked: a signature cannot be checked at runtime, so the guard trusts it.
+ *
+ * @typeParam TFunction - The signature the guard narrows to.
+ * @returns The guard.
+ */
+export declare function functionTypeGuard<TFunction extends GenericFunction>(): TypeGuard<TFunction>;
+/**
+ * Builds a guard accepting an instance of a class, or of a class derived from it.
+ *
+ * @typeParam T - The type of an instance.
+ * @param constructor - The class.
+ * @returns The guard.
+ */
+export declare function instanceOfTypeGuard<T>(constructor: abstract new (...arguments_: never[]) => T): TypeGuard<T>;
 /**
  * Checks whether a value is a boolean.
  *
@@ -88,6 +155,20 @@ export declare function ensureNonNullable<T extends NullableConstraint<T>>(value
  * @returns Whether the value is a boolean.
  */
 export declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Checks whether a value is a function.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is a function.
+ */
+export declare function isFunction(value: unknown): value is GenericFunction;
+/**
+ * Checks whether a value is `null`.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is `null`.
+ */
+export declare function isNull(value: unknown): value is null;
 /**
  * Checks whether a value is a number.
  *
@@ -95,6 +176,13 @@ export declare function isBoolean(value: unknown): value is boolean;
  * @returns Whether the value is a number.
  */
 export declare function isNumber(value: unknown): value is number;
+/**
+ * Checks whether a value is an object: not `null`, and not a primitive or a function.
+ *
+ * @param value - The value to check.
+ * @returns Whether the value is an object.
+ */
+export declare function isObject(value: unknown): value is object;
 /**
  * Checks whether a value is a string.
  *
@@ -116,4 +204,57 @@ export declare function isStringArray(value: unknown): value is string[];
  * @returns Whether the value is `undefined`.
  */
 export declare function isUndefined(value: unknown): value is undefined;
+/**
+ * Builds a guard accepting exactly the keys of a record. Typing the record over a union, as
+ * `literalTypeGuard<Mode>({ A: true, B: true })`, makes a member later added to the union fail to compile until
+ * it is listed.
+ *
+ * @typeParam T - The accepted strings.
+ * @param literals - A record whose keys are the accepted strings.
+ * @returns The guard.
+ */
+export declare function literalTypeGuard<T extends string>(literals: Readonly<Record<T, true>>): TypeGuard<T>;
+/**
+ * Builds a guard accepting exactly the listed values, compared as `Array.prototype.includes` compares them.
+ *
+ * @typeParam T - The accepted values.
+ * @param literals - The accepted values.
+ * @returns The guard.
+ */
+export declare function literalTypeGuard<T extends Literal>(literals: readonly T[]): TypeGuard<T>;
+/**
+ * Widens a guard to also accept `null`.
+ *
+ * @typeParam T - The type the guard narrows to.
+ * @param isValue - The guard to widen.
+ * @returns A guard accepting what `isValue` accepts, or `null`.
+ */
+export declare function nullableTypeGuard<T>(isValue: TypeGuard<T>): TypeGuard<null | T>;
+/**
+ * Builds a guard accepting an object whose every listed property its guard accepts. A property is read with
+ * `Reflect.get`, so an inherited one counts and an absent one reads as `undefined`.
+ *
+ * @typeParam T - The object type.
+ * @param propertyTypeGuards - One guard per property of `T`.
+ * @param options - The options for the guard.
+ * @returns The guard.
+ */
+export declare function objectTypeGuard<T extends object>(propertyTypeGuards: PropertyTypeGuards<T>, options?: ObjectTypeGuardOptions): TypeGuard<T>;
+/**
+ * Widens a guard to also accept `undefined`, which is what an optional property or parameter reads as when it is
+ * left out.
+ *
+ * @typeParam T - The type the guard narrows to.
+ * @param isValue - The guard to widen.
+ * @returns A guard accepting what `isValue` accepts, or `undefined`.
+ */
+export declare function optionalTypeGuard<T>(isValue: TypeGuard<T>): TypeGuard<T | undefined>;
+/**
+ * Builds a guard accepting what any of the given guards accepts.
+ *
+ * @typeParam TTypeGuards - The guards.
+ * @param typeGuards - The guards, tried in order.
+ * @returns The guard.
+ */
+export declare function unionTypeGuard<const TTypeGuards extends readonly TypeGuard<unknown>[]>(...typeGuards: TTypeGuards): TypeGuard<GuardedType<TTypeGuards[number]>>;
 export {};

package/dist/lib/esm/type-guards.mjs

@@ -4,6 +4,9 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 import { noop } from "./function.mjs";
+function arrayTypeGuard(isItem) {
+  return (value) => Array.isArray(value) && value.every((item) => isItem(item));
+}
 function assert(isTrue, errorOrMessage) {
   if (!isTrue) {
     throw typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
@@ -30,12 +33,27 @@ function ensureNonNullable(value, errorOrMessage) {
   assertNonNullable(value, errorOrMessage);
   return value;
 }
+function functionTypeGuard() {
+  return (value) => isFunction(value);
+}
+function instanceOfTypeGuard(constructor) {
+  return (value) => value instanceof constructor;
+}
 function isBoolean(value) {
   return typeof value === "boolean";
 }
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isNull(value) {
+  return value === null;
+}
 function isNumber(value) {
   return typeof value === "number";
 }
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
 function isString(value) {
   return typeof value === "string";
 }
@@ -45,17 +63,64 @@ function isStringArray(value) {
 function isUndefined(value) {
   return value === void 0;
 }
+function literalTypeGuard(literals) {
+  if (isReadonlyArray(literals)) {
+    const literalList = literals;
+    return (value) => literalList.includes(value);
+  }
+  return (value) => isString(value) && Object.hasOwn(literals, value);
+}
+function nullableTypeGuard(isValue) {
+  return unionTypeGuard(isNull, isValue);
+}
+function objectTypeGuard(propertyTypeGuards, options) {
+  const shouldRejectUnknownKeys = options?.shouldRejectUnknownKeys ?? false;
+  return (value) => {
+    if (!isObject(value)) {
+      return false;
+    }
+    if (shouldRejectUnknownKeys && Object.keys(value).some((key) => !Object.hasOwn(propertyTypeGuards, key))) {
+      return false;
+    }
+    for (const key in propertyTypeGuards) {
+      if (!propertyTypeGuards[key](Reflect.get(value, key))) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+function optionalTypeGuard(isValue) {
+  return unionTypeGuard(isUndefined, isValue);
+}
+function unionTypeGuard(...typeGuards) {
+  return (value) => typeGuards.some((typeGuard) => typeGuard(value));
+}
+function isReadonlyArray(value) {
+  return Array.isArray(value);
+}
 export {
+  arrayTypeGuard,
   assert,
   assertGenericObject,
   assertNever,
   assertNonNullable,
   ensureGenericObject,
   ensureNonNullable,
+  functionTypeGuard,
+  instanceOfTypeGuard,
   isBoolean,
+  isFunction,
+  isNull,
   isNumber,
+  isObject,
   isString,
   isStringArray,
-  isUndefined
+  isUndefined,
+  literalTypeGuard,
+  nullableTypeGuard,
+  objectTypeGuard,
+  optionalTypeGuard,
+  unionTypeGuard
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/type-guards.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for type guards.\n */\n\nimport { noop } from './function.ts';\n\n/**\n * A type that represents a generic object.\n *\n * @typeParam T - The base type to intersect with.\n */\nexport type GenericObject<T = unknown> = Record<string | symbol, unknown> & T;\n\ntype NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;\n\n/**\n * Asserts that a condition is `true`. Throws if it is not.\n *\n * Use in place of `/* v8 ignore *\\/` for defensive guards that should\n * never trigger at runtime but would otherwise create uncovered branches.\n *\n * @param isTrue - The condition to assert.\n * @param errorOrMessage - The error or message to throw if the condition is `false`.\n */\nexport function assert(isTrue: boolean, errorOrMessage: Error | string): asserts isTrue {\n  if (!isTrue) {\n    throw typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage;\n  }\n}\n\n/**\n * Asserts that a value is a generic object, narrowing its type in place.\n *\n * @typeParam T - The type of the value.\n * @param _object - The value to assert.\n */\nexport function assertGenericObject<T>(_object: T): asserts _object is GenericObject<T> {\n  noop();\n}\n\n/**\n * Asserts at compile time that every case of a discriminated union has been\n * handled. Place at the `default` branch of a `switch` over a union or enum.\n *\n * If a new variant is added to the union without a matching `case`, the call\n * to {@link assertNever} fails to compile because `value` is no longer `never`.\n * If reached at runtime (e.g. because the value was bypassed via JSON or a\n * type assertion), it throws a descriptive `Error`.\n *\n * @example\n * ```ts\n * switch (mode) {\n *   case 'a': return doA();\n *   case 'b': return doB();\n *   default: assertNever(mode);\n * }\n * ```\n *\n * @param value - The exhaustively-handled value, narrowed to `never` by control flow.\n * @throws Always, if reached at runtime.\n */\nexport function assertNever(value: never): never {\n  throw new Error(`Unhandled value: ${String(value)}`);\n}\n\n/**\n * Asserts that a value is not `null` or `undefined`, narrowing its type in place.\n *\n * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.\n *\n * @typeParam T - The type of the value.\n * @param value - The value to check.\n * @param errorOrMessage - Optional {@link Error} or error message string.\n * @throws If the value is `null` or `undefined`.\n */\nexport function assertNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): asserts value is NonNullable<T> {\n  if (value !== null && value !== undefined) {\n    return;\n  }\n\n  errorOrMessage ??= value === null ? 'Value is null' : 'Value is undefined';\n  const error = typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage;\n  throw error;\n}\n\n/**\n * Ensures that a value is a generic object, returning it with narrowed type.\n *\n * @typeParam T - The type of the value.\n * @param $object - The value to ensure.\n * @returns The value as a generic object.\n */\nexport function ensureGenericObject<T>($object: T): GenericObject<T> {\n  return $object as GenericObject<T>;\n}\n\n/**\n * Ensures that a value is not `null` or `undefined` and returns it with narrowed type.\n *\n * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.\n *\n * @typeParam T - The type of the value.\n * @param value - The value to check.\n * @param errorOrMessage - Optional {@link Error} or error message string.\n * @returns The value with `null` and `undefined` excluded from its type.\n * @throws If the value is `null` or `undefined`.\n */\nexport function ensureNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): NonNullable<T> {\n  assertNonNullable(value, errorOrMessage);\n  return value;\n}\n\n/**\n * Checks whether a value is a boolean.\n *\n * @param value - The value to check.\n * @returns Whether the value is a boolean.\n */\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean';\n}\n\n/**\n * Checks whether a value is a number.\n *\n * @param value - The value to check.\n * @returns Whether the value is a number.\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number';\n}\n\n/**\n * Checks whether a value is a string.\n *\n * @param value - The value to check.\n * @returns Whether the value is a string.\n */\nexport function isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n\n/**\n * Checks whether a value is an array of strings.\n *\n * @param value - The value to check.\n * @returns Whether the value is an array whose every item is a string.\n */\nexport function isStringArray(value: unknown): value is string[] {\n  return Array.isArray(value) && value.every(isString);\n}\n\n/**\n * Checks whether a value is `undefined`.\n *\n * @param value - The value to check.\n * @returns Whether the value is `undefined`.\n */\nexport function isUndefined(value: unknown): value is undefined {\n  return value === undefined;\n}\n"],
  "mappings": ";;;;;AAMA,SAAS,YAAY;AAoBd,SAAS,OAAO,QAAiB,gBAAgD;AACtF,MAAI,CAAC,QAAQ;AACX,UAAM,OAAO,mBAAmB,WAAW,IAAI,MAAM,cAAc,IAAI;AAAA,EACzE;AACF;AAQO,SAAS,oBAAuB,SAAiD;AACtF,OAAK;AACP;AAuBO,SAAS,YAAY,OAAqB;AAC/C,QAAM,IAAI,MAAM,oBAAoB,OAAO,KAAK,CAAC,EAAE;AACrD;AAYO,SAAS,kBAAmD,OAAU,gBAAkE;AAC7I,MAAI,UAAU,QAAQ,UAAU,QAAW;AACzC;AAAA,EACF;AAEA,qBAAmB,UAAU,OAAO,kBAAkB;AACtD,QAAM,QAAQ,OAAO,mBAAmB,WAAW,IAAI,MAAM,cAAc,IAAI;AAC/E,QAAM;AACR;AASO,SAAS,oBAAuB,SAA8B;AACnE,SAAO;AACT;AAaO,SAAS,kBAAmD,OAAU,gBAAiD;AAC5H,oBAAkB,OAAO,cAAc;AACvC,SAAO;AACT;AAQO,SAAS,UAAU,OAAkC;AAC1D,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,SAAS,OAAiC;AACxD,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,SAAS,OAAiC;AACxD,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,cAAc,OAAmC;AAC/D,SAAO,MAAM,QAAQ,KAAK,KAAK,MAAM,MAAM,QAAQ;AACrD;AAQO,SAAS,YAAY,OAAoC;AAC9D,SAAO,UAAU;AACnB;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/type-guards.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for type guards, and combinators that build a {@link TypeGuard} out of others.\n *\n * The combinators here work on bare type guards. Their `api-contract` counterparts (`arrayGuard`, `optionalGuard`,\n * ...) work on an `ExpectedTypeGuard`, a type guard paired with the text an issue message reports, and their names\n * drop the `Type` this layer's names carry.\n */\n\nimport type { GenericFunction } from './function.ts';\n\nimport { noop } from './function.ts';\n\n/**\n * A type that represents a generic object.\n *\n * @typeParam T - The base type to intersect with.\n */\nexport type GenericObject<T = unknown> = Record<string | symbol, unknown> & T;\n\n/**\n * The type a {@link TypeGuard} narrows to. Distributes over a union of guards.\n *\n * @typeParam TTypeGuard - The type guard.\n */\nexport type GuardedType<TTypeGuard> = TTypeGuard extends (value: unknown) => value is infer T ? T : never;\n\n/**\n * A value {@link literalTypeGuard} can compare against.\n */\nexport type Literal = bigint | boolean | null | number | string | symbol | undefined;\n\n/**\n * Options for {@link objectTypeGuard}.\n */\nexport interface ObjectTypeGuardOptions {\n  /**\n   * Whether a value carrying an own enumerable string key that no property guard names is refused.\n   *\n   * @default `false`\n   */\n  readonly shouldRejectUnknownKeys?: boolean;\n}\n\n/**\n * One type guard per property of an object type, as {@link objectTypeGuard} takes them. Every key of `T` must be\n * listed. The guard of an optional property is typed to narrow to `undefined` as well, but a guard that refuses\n * `undefined` still compiles there, so widen it with {@link optionalTypeGuard}: an absent property reads as\n * `undefined`, and a guard refusing it refuses the object.\n *\n * @typeParam T - The object type.\n */\nexport type PropertyTypeGuards<T extends object> = {\n  readonly [TKey in keyof T]-?: TypeGuard<Partial<Pick<T, TKey>> extends Pick<T, TKey> ? T[TKey] | undefined : T[TKey]>;\n};\n\n/**\n * A function deciding whether a value is a `T`.\n *\n * @typeParam T - The type the guard narrows to.\n */\nexport type TypeGuard<T> = (value: unknown) => value is T;\n\ntype NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;\n\n/**\n * Builds a guard accepting an array whose every item the item guard accepts.\n *\n * @typeParam T - The type of an item.\n * @param isItem - The guard for one item.\n * @returns The guard.\n */\nexport function arrayTypeGuard<T>(isItem: TypeGuard<T>): TypeGuard<T[]> {\n  return (value): value is T[] => Array.isArray(value) && value.every((item) => isItem(item));\n}\n\n/**\n * Asserts that a condition is `true`. Throws if it is not.\n *\n * Use in place of `/* v8 ignore *\\/` for defensive guards that should\n * never trigger at runtime but would otherwise create uncovered branches.\n *\n * @param isTrue - The condition to assert.\n * @param errorOrMessage - The error or message to throw if the condition is `false`.\n */\nexport function assert(isTrue: boolean, errorOrMessage: Error | string): asserts isTrue {\n  if (!isTrue) {\n    throw typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage;\n  }\n}\n\n/**\n * Asserts that a value is a generic object, narrowing its type in place.\n *\n * @typeParam T - The type of the value.\n * @param _object - The value to assert.\n */\nexport function assertGenericObject<T>(_object: T): asserts _object is GenericObject<T> {\n  noop();\n}\n\n/**\n * Asserts at compile time that every case of a discriminated union has been\n * handled. Place at the `default` branch of a `switch` over a union or enum.\n *\n * If a new variant is added to the union without a matching `case`, the call\n * to {@link assertNever} fails to compile because `value` is no longer `never`.\n * If reached at runtime (e.g. because the value was bypassed via JSON or a\n * type assertion), it throws a descriptive `Error`.\n *\n * @example\n * ```ts\n * switch (mode) {\n *   case 'a': return doA();\n *   case 'b': return doB();\n *   default: assertNever(mode);\n * }\n * ```\n *\n * @param value - The exhaustively-handled value, narrowed to `never` by control flow.\n * @throws Always, if reached at runtime.\n */\nexport function assertNever(value: never): never {\n  throw new Error(`Unhandled value: ${String(value)}`);\n}\n\n/**\n * Asserts that a value is not `null` or `undefined`, narrowing its type in place.\n *\n * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.\n *\n * @typeParam T - The type of the value.\n * @param value - The value to check.\n * @param errorOrMessage - Optional {@link Error} or error message string.\n * @throws If the value is `null` or `undefined`.\n */\nexport function assertNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): asserts value is NonNullable<T> {\n  if (value !== null && value !== undefined) {\n    return;\n  }\n\n  errorOrMessage ??= value === null ? 'Value is null' : 'Value is undefined';\n  const error = typeof errorOrMessage === 'string' ? new Error(errorOrMessage) : errorOrMessage;\n  throw error;\n}\n\n/**\n * Ensures that a value is a generic object, returning it with narrowed type.\n *\n * @typeParam T - The type of the value.\n * @param $object - The value to ensure.\n * @returns The value as a generic object.\n */\nexport function ensureGenericObject<T>($object: T): GenericObject<T> {\n  return $object as GenericObject<T>;\n}\n\n/**\n * Ensures that a value is not `null` or `undefined` and returns it with narrowed type.\n *\n * Only callable when `T` includes `null` or `undefined`. Passing an already non-nullable type is a compile error.\n *\n * @typeParam T - The type of the value.\n * @param value - The value to check.\n * @param errorOrMessage - Optional {@link Error} or error message string.\n * @returns The value with `null` and `undefined` excluded from its type.\n * @throws If the value is `null` or `undefined`.\n */\nexport function ensureNonNullable<T extends NullableConstraint<T>>(value: T, errorOrMessage?: Error | string): NonNullable<T> {\n  assertNonNullable(value, errorOrMessage);\n  return value;\n}\n\n/**\n * Builds a guard accepting any function, narrowed to the signature `TFunction`. Only that the value is a function\n * is checked: a signature cannot be checked at runtime, so the guard trusts it.\n *\n * @typeParam TFunction - The signature the guard narrows to.\n * @returns The guard.\n */\nexport function functionTypeGuard<TFunction extends GenericFunction>(): TypeGuard<TFunction> {\n  return (value): value is TFunction => isFunction(value);\n}\n\n/**\n * Builds a guard accepting an instance of a class, or of a class derived from it.\n *\n * @typeParam T - The type of an instance.\n * @param constructor - The class.\n * @returns The guard.\n */\nexport function instanceOfTypeGuard<T>(constructor: abstract new (...arguments_: never[]) => T): TypeGuard<T> {\n  return (value): value is T => value instanceof constructor;\n}\n\n/**\n * Checks whether a value is a boolean.\n *\n * @param value - The value to check.\n * @returns Whether the value is a boolean.\n */\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean';\n}\n\n/**\n * Checks whether a value is a function.\n *\n * @param value - The value to check.\n * @returns Whether the value is a function.\n */\nexport function isFunction(value: unknown): value is GenericFunction {\n  return typeof value === 'function';\n}\n\n/**\n * Checks whether a value is `null`.\n *\n * @param value - The value to check.\n * @returns Whether the value is `null`.\n */\nexport function isNull(value: unknown): value is null {\n  return value === null;\n}\n\n/**\n * Checks whether a value is a number.\n *\n * @param value - The value to check.\n * @returns Whether the value is a number.\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number';\n}\n\n/**\n * Checks whether a value is an object: not `null`, and not a primitive or a function.\n *\n * @param value - The value to check.\n * @returns Whether the value is an object.\n */\nexport function isObject(value: unknown): value is object {\n  return typeof value === 'object' && value !== null;\n}\n\n/**\n * Checks whether a value is a string.\n *\n * @param value - The value to check.\n * @returns Whether the value is a string.\n */\nexport function isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n\n/**\n * Checks whether a value is an array of strings.\n *\n * @param value - The value to check.\n * @returns Whether the value is an array whose every item is a string.\n */\nexport function isStringArray(value: unknown): value is string[] {\n  return Array.isArray(value) && value.every(isString);\n}\n\n/**\n * Checks whether a value is `undefined`.\n *\n * @param value - The value to check.\n * @returns Whether the value is `undefined`.\n */\nexport function isUndefined(value: unknown): value is undefined {\n  return value === undefined;\n}\n\n/**\n * Builds a guard accepting exactly the keys of a record. Typing the record over a union, as\n * `literalTypeGuard<Mode>({ A: true, B: true })`, makes a member later added to the union fail to compile until\n * it is listed.\n *\n * @typeParam T - The accepted strings.\n * @param literals - A record whose keys are the accepted strings.\n * @returns The guard.\n */\nexport function literalTypeGuard<T extends string>(literals: Readonly<Record<T, true>>): TypeGuard<T>;\n/**\n * Builds a guard accepting exactly the listed values, compared as `Array.prototype.includes` compares them.\n *\n * @typeParam T - The accepted values.\n * @param literals - The accepted values.\n * @returns The guard.\n */\nexport function literalTypeGuard<T extends Literal>(literals: readonly T[]): TypeGuard<T>;\n/**\n * Builds a guard accepting exactly the listed values.\n *\n * @param literals - The accepted values, as a list or as the keys of a record.\n * @returns The guard.\n */\nexport function literalTypeGuard(literals: Readonly<Record<string, true>> | readonly Literal[]): TypeGuard<Literal> {\n  if (isReadonlyArray(literals)) {\n    const literalList: readonly unknown[] = literals;\n    return (value): value is Literal => literalList.includes(value);\n  }\n\n  return (value): value is Literal => isString(value) && Object.hasOwn(literals, value);\n}\n\n/**\n * Widens a guard to also accept `null`.\n *\n * @typeParam T - The type the guard narrows to.\n * @param isValue - The guard to widen.\n * @returns A guard accepting what `isValue` accepts, or `null`.\n */\nexport function nullableTypeGuard<T>(isValue: TypeGuard<T>): TypeGuard<null | T> {\n  return unionTypeGuard(isNull, isValue);\n}\n\n/**\n * Builds a guard accepting an object whose every listed property its guard accepts. A property is read with\n * `Reflect.get`, so an inherited one counts and an absent one reads as `undefined`.\n *\n * @typeParam T - The object type.\n * @param propertyTypeGuards - One guard per property of `T`.\n * @param options - The options for the guard.\n * @returns The guard.\n */\nexport function objectTypeGuard<T extends object>(propertyTypeGuards: PropertyTypeGuards<T>, options?: ObjectTypeGuardOptions): TypeGuard<T> {\n  const shouldRejectUnknownKeys = options?.shouldRejectUnknownKeys ?? false;\n  return (value): value is T => {\n    if (!isObject(value)) {\n      return false;\n    }\n\n    if (shouldRejectUnknownKeys && Object.keys(value).some((key) => !Object.hasOwn(propertyTypeGuards, key))) {\n      return false;\n    }\n\n    for (const key in propertyTypeGuards) {\n      if (!propertyTypeGuards[key](Reflect.get(value, key))) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n}\n\n/**\n * Widens a guard to also accept `undefined`, which is what an optional property or parameter reads as when it is\n * left out.\n *\n * @typeParam T - The type the guard narrows to.\n * @param isValue - The guard to widen.\n * @returns A guard accepting what `isValue` accepts, or `undefined`.\n */\nexport function optionalTypeGuard<T>(isValue: TypeGuard<T>): TypeGuard<T | undefined> {\n  return unionTypeGuard(isUndefined, isValue);\n}\n\n/**\n * Builds a guard accepting what any of the given guards accepts.\n *\n * @typeParam TTypeGuards - The guards.\n * @param typeGuards - The guards, tried in order.\n * @returns The guard.\n */\nexport function unionTypeGuard<const TTypeGuards extends readonly TypeGuard<unknown>[]>(\n  ...typeGuards: TTypeGuards\n): TypeGuard<GuardedType<TTypeGuards[number]>> {\n  return (value): value is GuardedType<TTypeGuards[number]> => typeGuards.some((typeGuard) => typeGuard(value));\n}\n\nfunction isReadonlyArray(value: unknown): value is readonly unknown[] {\n  return Array.isArray(value);\n}\n"],
  "mappings": ";;;;;AAYA,SAAS,YAAY;AA6Dd,SAAS,eAAkB,QAAsC;AACtE,SAAO,CAAC,UAAwB,MAAM,QAAQ,KAAK,KAAK,MAAM,MAAM,CAAC,SAAS,OAAO,IAAI,CAAC;AAC5F;AAWO,SAAS,OAAO,QAAiB,gBAAgD;AACtF,MAAI,CAAC,QAAQ;AACX,UAAM,OAAO,mBAAmB,WAAW,IAAI,MAAM,cAAc,IAAI;AAAA,EACzE;AACF;AAQO,SAAS,oBAAuB,SAAiD;AACtF,OAAK;AACP;AAuBO,SAAS,YAAY,OAAqB;AAC/C,QAAM,IAAI,MAAM,oBAAoB,OAAO,KAAK,CAAC,EAAE;AACrD;AAYO,SAAS,kBAAmD,OAAU,gBAAkE;AAC7I,MAAI,UAAU,QAAQ,UAAU,QAAW;AACzC;AAAA,EACF;AAEA,qBAAmB,UAAU,OAAO,kBAAkB;AACtD,QAAM,QAAQ,OAAO,mBAAmB,WAAW,IAAI,MAAM,cAAc,IAAI;AAC/E,QAAM;AACR;AASO,SAAS,oBAAuB,SAA8B;AACnE,SAAO;AACT;AAaO,SAAS,kBAAmD,OAAU,gBAAiD;AAC5H,oBAAkB,OAAO,cAAc;AACvC,SAAO;AACT;AASO,SAAS,oBAA6E;AAC3F,SAAO,CAAC,UAA8B,WAAW,KAAK;AACxD;AASO,SAAS,oBAAuB,aAAuE;AAC5G,SAAO,CAAC,UAAsB,iBAAiB;AACjD;AAQO,SAAS,UAAU,OAAkC;AAC1D,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,WAAW,OAA0C;AACnE,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,OAAO,OAA+B;AACpD,SAAO,UAAU;AACnB;AAQO,SAAS,SAAS,OAAiC;AACxD,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,SAAS,OAAiC;AACxD,SAAO,OAAO,UAAU,YAAY,UAAU;AAChD;AAQO,SAAS,SAAS,OAAiC;AACxD,SAAO,OAAO,UAAU;AAC1B;AAQO,SAAS,cAAc,OAAmC;AAC/D,SAAO,MAAM,QAAQ,KAAK,KAAK,MAAM,MAAM,QAAQ;AACrD;AAQO,SAAS,YAAY,OAAoC;AAC9D,SAAO,UAAU;AACnB;AA0BO,SAAS,iBAAiB,UAAmF;AAClH,MAAI,gBAAgB,QAAQ,GAAG;AAC7B,UAAM,cAAkC;AACxC,WAAO,CAAC,UAA4B,YAAY,SAAS,KAAK;AAAA,EAChE;AAEA,SAAO,CAAC,UAA4B,SAAS,KAAK,KAAK,OAAO,OAAO,UAAU,KAAK;AACtF;AASO,SAAS,kBAAqB,SAA4C;AAC/E,SAAO,eAAe,QAAQ,OAAO;AACvC;AAWO,SAAS,gBAAkC,oBAA2C,SAAgD;AAC3I,QAAM,0BAA0B,SAAS,2BAA2B;AACpE,SAAO,CAAC,UAAsB;AAC5B,QAAI,CAAC,SAAS,KAAK,GAAG;AACpB,aAAO;AAAA,IACT;AAEA,QAAI,2BAA2B,OAAO,KAAK,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,OAAO,OAAO,oBAAoB,GAAG,CAAC,GAAG;AACxG,aAAO;AAAA,IACT;AAEA,eAAW,OAAO,oBAAoB;AACpC,UAAI,CAAC,mBAAmB,GAAG,EAAE,QAAQ,IAAI,OAAO,GAAG,CAAC,GAAG;AACrD,eAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AACF;AAUO,SAAS,kBAAqB,SAAiD;AACpF,SAAO,eAAe,aAAa,OAAO;AAC5C;AASO,SAAS,kBACX,YAC0C;AAC7C,SAAO,CAAC,UAAqD,WAAW,KAAK,CAAC,cAAc,UAAU,KAAK,CAAC;AAC9G;AAEA,SAAS,gBAAgB,OAA6C;AACpE,SAAO,MAAM,QAAQ,KAAK;AAC5B;",
  "names": []
}


package/dist/lib/esm/type.mjs

@@ -36,4 +36,4 @@ class TypeAsserter {
 export {
   TypeAsserter
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/type.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Type utilities.\n */\n\nimport type { GenericFunction } from './function.ts';\n\nimport { castTo } from './object-utils.ts';\n\n/**\n * A type that represents the keys of an object as strings and asserts that all keys are present in a list of keys.\n *\n * @typeParam Type - The type of the object.\n * @typeParam Keys - The list of keys to assert.\n */\nexport type ExactKeys<Type extends object, Keys extends readonly string[]> = ExactMembers<StringKeys<Type>, Keys>;\n\n/**\n * A type that represents the members of a type.\n *\n * @typeParam Type - The type to assert the members of.\n * @typeParam Keys - The list of members to assert.\n */\nexport type ExactMembers<\n  Type extends LiteralKey,\n  Keys extends readonly LiteralKey[]\n> = Exclude<Keys[number], Type> extends never ? Exclude<Type, Keys[number]> extends never ? Duplicates<Keys> extends [] ? Keys\n    : `ERROR: Duplicate members: ${TupleToCSV<Duplicates<Keys>>}`\n  : `ERROR: Missing members: ${TupleToCSV<UnionToTuple<Exclude<Type, Keys[number]>>>}`\n  : `ERROR: Invalid members: ${TupleToCSV<UnionToTuple<Exclude<Keys[number], Type>>>}`;\n\n/**\n * Derives an event map (`{ eventName: [callbackArgs] }`) from a type exposing an overloaded `on(name, callback)`\n * method \u2014 e.g. Obsidian's `Workspace` / `Vault` / `MetadataCache`. Each `on` overload becomes one entry keyed by\n * the event name, with the callback's parameters as a labeled tuple; the wide `on(name: string, \u2026)` catch-all\n * overload is dropped. The map auto-tracks upstream overloads (no hand-authoring). It cannot reconstruct\n * genuinely generic overloads, but Obsidian's event overloads are all concrete string-literal ones.\n *\n * @typeParam T - A type exposing an `on(name, callback, \u2026)` method (e.g. an Obsidian `Events` subclass).\n *\n * @example\n * ```ts\n * type WorkspaceEventMap = ExtractEventMap<Workspace>;\n * // { 'file-menu': [menu: Menu, file: TAbstractFile, source: string, leaf?: WorkspaceLeaf]; \u2026 }\n * ```\n */\nexport type ExtractEventMap<T extends EventsWithOn> = UnionToIntersection<EntryOfOverload<OverloadUnion<T['on']>>>;\n\n/**\n * A type that represents a return value that may be `void`.\n *\n * @typeParam T - The type of the value that may be returned.\n */\n// eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- We need to use the `void` return type.\nexport type MaybeReturn<T> = T | void;\n\n/**\n * A type that represents the values of an object.\n *\n * @typeParam T - The type of the object.\n */\nexport type PropertyValues<T extends object> = T[StringKeys<T>];\n\n/**\n * A type that represents the keys of an object as strings.\n *\n * @typeParam T - The type of the object.\n */\nexport type StringKeys<T extends object> = Extract<keyof T, string>;\n\ntype Duplicates<\n  T extends readonly unknown[],\n  Seen extends readonly unknown[] = [],\n  Added extends readonly unknown[] = [],\n  Out extends readonly unknown[] = []\n> = T extends readonly [infer First, ...infer Rest] ? Includes<Seen, First> extends true ? Includes<Added, First> extends true ? Duplicates<Rest, Seen, Added, Out>\n    : Duplicates<Rest, Seen, [...Added, First], [...Out, First]>\n  : Duplicates<Rest, [...Seen, First], Added, Out>\n  : Out;\n\n// Maps one `on(name, callback, \u2026)` overload to a `{ [name]: [callbackArgs] }` entry; drops the wide `name: string` catch-all.\ntype EntryOfOverload<TOverload> = TOverload extends (name: infer Name, callback: (...$arguments: infer Arguments) => unknown, ...rest: never[]) => unknown ? Name extends string ? string extends Name ? never : Record<Name, Arguments>\n  : never\n  : never;\n\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters,no-magic-numbers -- We need to use the dummy parameter to get type inference.\ntype Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;\n\n// The minimal shape {@link ExtractEventMap} operates on: a type exposing an overloaded `on` method.\ninterface EventsWithOn {\n  on: GenericFunction;\n}\n\ntype Includes<Type extends readonly unknown[], Member> = Type extends readonly [infer First, ...infer Rest] ? Equal<First, Member> extends true ? true : Includes<Rest, Member>\n  : false;\n\ntype LastInUnion<Union> = UnionToIntersection<Union extends unknown ? () => Union : never> extends () => infer Last ? Last : never;\n\ntype LiteralKey = number | string;\n\n// Splits an overloaded call signature into a union of its individual call signatures (a well-known overload-to-union trick).\n/* eslint-disable perfectionist/sort-intersection-types, perfectionist/sort-union-types, @stylistic/operator-linebreak -- The OverloadUnion recursion relies on this exact operand order; reordering breaks termination (TS2589), and the line-break shape is left to dprint. */\ntype OverloadUnion<TOverload extends GenericFunction> = Exclude<\n  OverloadUnionRecursive<(() => never) & TOverload>,\n  TOverload extends () => never ? never : () => never\n>;\n\ntype OverloadUnionRecursive<TOverload, TPartialOverload = unknown> = TOverload extends (...$arguments: infer Arguments) => infer Return ? TPartialOverload extends TOverload ? never\n  :\n    | OverloadUnionRecursive<TPartialOverload & TOverload, TPartialOverload & ((...$arguments: Arguments) => Return) & Pick<TOverload, keyof TOverload>>\n    | ((...$arguments: Arguments) => Return)\n  : never;\n/* eslint-enable perfectionist/sort-intersection-types, perfectionist/sort-union-types, @stylistic/operator-linebreak -- The OverloadUnion recursion relies on this exact operand order; reordering breaks termination (TS2589), and the line-break shape is left to dprint. */\n\ntype ToString<T> = T extends number | string ? `${T}` : never;\n\ntype TupleToCSV<Tuple extends readonly unknown[]> = Tuple extends readonly [infer First, ...infer Rest] ? First extends LiteralKey ? Rest extends readonly unknown[] ? Rest['length'] extends 0 ? ToString<First> : `${ToString<First>},${TupleToCSV<Rest>}`\n    : never\n  : never\n  : '';\n\n/**\n * Internal method shapes for {@link TypeAsserter}: a conditional type disables each method when the\n * captured type does not support it.\n *\n * @typeParam Type - The captured type.\n */\ninterface TypeAssertions<Type> {\n  assertAllKeys: [Type] extends [object] ? <const Keys extends readonly string[]>(\n      keys: ExactMembers<StringKeys<Type>, Keys>\n    ) => readonly (keyof Type)[]\n    : never;\n  assertAllMembers: [Type] extends [LiteralKey] ? <const Keys extends readonly LiteralKey[]>(\n      keys: ExactMembers<Type, Keys>\n    ) => readonly Type[]\n    : never;\n}\n\ntype UnionToIntersection<Union> = (Union extends unknown ? (key: Union) => void : never) extends (key: infer Intersection) => void ? Intersection : never;\n\ntype UnionToTuple<Union, Last = LastInUnion<Union>> = [Union] extends [never] ? [] : [...UnionToTuple<Exclude<Union, Last>>, Last];\n\n/**\n * A helper that captures a type parameter and provides methods for compile-time exhaustiveness checks.\n *\n * @typeParam Type - The captured type.\n *\n * @remarks\n * - `assertAllKeys` is available when `Type` is an object type.\n * - `assertAllMembers` is available when `Type` is a literal key union (`string | number`).\n *\n * @example\n * ```ts\n * type A = { a: 1, b: 2, c: 3 };\n * new TypeAsserter<A>().assertAllKeys(['a', 'b', 'c']); // OK\n * new TypeAsserter<A>().assertAllKeys(['c', 'a', 'b']); // OK, order is ignored\n * new TypeAsserter<A>().assertAllKeys(['a', 'b', 'c', 'd']); // Error: Invalid members: d\n * new TypeAsserter<A>().assertAllKeys(['a', 'b']); // Error: Missing members: c\n *\n * type B = 1 | 2 | 3 | 'a';\n * new TypeAsserter<B>().assertAllMembers([1, 2, 3, 'a']); // OK\n * new TypeAsserter<B>().assertAllMembers([1, 2, 3, 'a', 4]); // Error: Invalid members: 4\n * new TypeAsserter<B>().assertAllMembers([1, 2, 3]); // Error: Missing members: a\n * ```\n */\nexport class TypeAsserter<Type> {\n  /**\n   * Asserts that all keys of an object type are present in a list of keys.\n   *\n   * @remarks Only available when `[Type] extends [object]`.\n   */\n  public readonly assertAllKeys: TypeAssertions<Type>['assertAllKeys'];\n\n  /**\n   * Asserts that all members of a union type are present in a list of members.\n   *\n   * @remarks Only available when `[Type] extends [LiteralKey]`.\n   */\n  public readonly assertAllMembers: TypeAssertions<Type>['assertAllMembers'];\n\n  /**\n   * Creates a type asserter that captures {@link Type} for compile-time exhaustiveness checks.\n   */\n  public constructor() {\n    const assertions = castTo<TypeAssertions<Type>>({\n      assertAllKeys<const Keys extends readonly string[]>(\n        keys: ExactMembers<StringKeys<object & Type>, Keys>\n      ): readonly (keyof (object & Type))[] {\n        // eslint-disable-next-line unicorn/prefer-spread -- `Type` may be a string, and spreading one splits surrogate pairs (`@typescript-eslint/no-misused-spread`).\n        return Object.freeze(Array.from(keys) as (keyof (object & Type))[]);\n      },\n      assertAllMembers<const Keys extends readonly LiteralKey[]>(\n        keys: ExactMembers<LiteralKey & Type, Keys>\n      ): readonly (LiteralKey & Type)[] {\n        // eslint-disable-next-line unicorn/prefer-spread -- `Type` may be a string, and spreading one splits surrogate pairs (`@typescript-eslint/no-misused-spread`).\n        return Object.freeze(Array.from(keys) as (LiteralKey & Type)[]);\n      }\n    });\n    this.assertAllKeys = assertions.assertAllKeys;\n    this.assertAllMembers = assertions.assertAllMembers;\n  }\n}\n"],
  "mappings": ";;;;;AAQA,SAAS,cAAc;AA8JhB,MAAM,aAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA;AAAA;AAAA;AAAA;AAAA,EAKT,cAAc;AACnB,UAAM,aAAa,OAA6B;AAAA,MAC9C,cACE,MACoC;AAEpC,eAAO,OAAO,OAAO,MAAM,KAAK,IAAI,CAA8B;AAAA,MACpE;AAAA,MACA,iBACE,MACgC;AAEhC,eAAO,OAAO,OAAO,MAAM,KAAK,IAAI,CAA0B;AAAA,MAChE;AAAA,IACF,CAAC;AACD,SAAK,gBAAgB,WAAW;AAChC,SAAK,mBAAmB,WAAW;AAAA,EACrC;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/type.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Type utilities.\n */\n\nimport type { GenericFunction } from './function.ts';\n\nimport { castTo } from './object-utils.ts';\n\n/**\n * A type that represents the keys of an object as strings and asserts that all keys are present in a list of keys.\n *\n * @typeParam Type - The type of the object.\n * @typeParam Keys - The list of keys to assert.\n */\nexport type ExactKeys<Type extends object, Keys extends readonly string[]> = ExactMembers<StringKeys<Type>, Keys>;\n\n/**\n * A type that represents the members of a type.\n *\n * @typeParam Type - The type to assert the members of.\n * @typeParam Keys - The list of members to assert.\n */\nexport type ExactMembers<\n  Type extends LiteralKey,\n  Keys extends readonly LiteralKey[]\n> = Exclude<Keys[number], Type> extends never ? Exclude<Type, Keys[number]> extends never ? Duplicates<Keys> extends [] ? Keys\n    : `ERROR: Duplicate members: ${TupleToCSV<Duplicates<Keys>>}`\n  : `ERROR: Missing members: ${TupleToCSV<UnionToTuple<Exclude<Type, Keys[number]>>>}`\n  : `ERROR: Invalid members: ${TupleToCSV<UnionToTuple<Exclude<Keys[number], Type>>>}`;\n\n/**\n * Derives an event map (`{ eventName: [callbackArgs] }`) from a type exposing an overloaded `on(name, callback)`\n * method \u2014 e.g. Obsidian's `Workspace` / `Vault` / `MetadataCache`. Each `on` overload becomes one entry keyed by\n * the event name, with the callback's parameters as a labeled tuple; the wide `on(name: string, \u2026)` catch-all\n * overload is dropped. The map auto-tracks upstream overloads (no hand-authoring). It cannot reconstruct\n * genuinely generic overloads, but Obsidian's event overloads are all concrete string-literal ones.\n *\n * @typeParam T - A type exposing an `on(name, callback, \u2026)` method (e.g. an Obsidian `Events` subclass).\n *\n * @example\n * ```ts\n * type WorkspaceEventMap = ExtractEventMap<Workspace>;\n * // { 'file-menu': [menu: Menu, file: TAbstractFile, source: string, leaf?: WorkspaceLeaf]; \u2026 }\n * ```\n */\nexport type ExtractEventMap<T extends EventsWithOn> = UnionToIntersection<EntryOfOverload<OverloadUnion<T['on']>>>;\n\n/**\n * A type that represents a return value that may be `void`.\n *\n * @typeParam T - The type of the value that may be returned.\n */\n// eslint-disable-next-line @typescript-eslint/no-invalid-void-type -- We need to use the `void` return type.\nexport type MaybeReturn<T> = T | void;\n\n/**\n * A type that represents the values of an object.\n *\n * @typeParam T - The type of the object.\n */\nexport type PropertyValues<T extends object> = T[StringKeys<T>];\n\n/**\n * A type that represents the keys of an object as strings.\n *\n * @typeParam T - The type of the object.\n */\nexport type StringKeys<T extends object> = Extract<keyof T, string>;\n\ntype Duplicates<\n  T extends readonly unknown[],\n  Seen extends readonly unknown[] = [],\n  Added extends readonly unknown[] = [],\n  Out extends readonly unknown[] = []\n> = T extends readonly [infer First, ...infer Rest] ? Includes<Seen, First> extends true ? Includes<Added, First> extends true ? Duplicates<Rest, Seen, Added, Out>\n    : Duplicates<Rest, Seen, [...Added, First], [...Out, First]>\n  : Duplicates<Rest, [...Seen, First], Added, Out>\n  : Out;\n\n// Maps one `on(name, callback, \u2026)` overload to a `{ [name]: [callbackArgs] }` entry; drops the wide `name: string` catch-all.\ntype EntryOfOverload<TOverload> = TOverload extends (name: infer Name, callback: (...$arguments: infer Arguments) => unknown, ...rest: never[]) => unknown ? Name extends string ? string extends Name ? never : Record<Name, Arguments>\n  : never\n  : never;\n\n// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters,no-magic-numbers -- We need to use the dummy parameter to get type inference.\ntype Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;\n\n// The minimal shape {@link ExtractEventMap} operates on: a type exposing an overloaded `on` method.\ninterface EventsWithOn {\n  on: GenericFunction;\n}\n\ntype Includes<Type extends readonly unknown[], Member> = Type extends readonly [infer First, ...infer Rest] ? Equal<First, Member> extends true ? true : Includes<Rest, Member>\n  : false;\n\ntype LastInUnion<Union> = UnionToIntersection<Union extends unknown ? () => Union : never> extends () => infer Last ? Last : never;\n\ntype LiteralKey = number | string;\n\n// Splits an overloaded call signature into a union of its individual call signatures (a well-known overload-to-union trick).\n/* eslint-disable perfectionist/sort-intersection-types, perfectionist/sort-union-types -- The OverloadUnion recursion relies on this exact operand order; reordering breaks termination (TS2589). */\ntype OverloadUnion<TOverload extends GenericFunction> = Exclude<\n  OverloadUnionRecursive<(() => never) & TOverload>,\n  TOverload extends () => never ? never : () => never\n>;\n\ntype OverloadUnionRecursive<TOverload, TPartialOverload = unknown> = TOverload extends (...$arguments: infer Arguments) => infer Return ? TPartialOverload extends TOverload ? never\n  :\n    | OverloadUnionRecursive<TPartialOverload & TOverload, TPartialOverload & ((...$arguments: Arguments) => Return) & Pick<TOverload, keyof TOverload>>\n    | ((...$arguments: Arguments) => Return)\n  : never;\n/* eslint-enable perfectionist/sort-intersection-types, perfectionist/sort-union-types -- The OverloadUnion recursion relies on this exact operand order; reordering breaks termination (TS2589). */\n\ntype ToString<T> = T extends number | string ? `${T}` : never;\n\ntype TupleToCSV<Tuple extends readonly unknown[]> = Tuple extends readonly [infer First, ...infer Rest] ? First extends LiteralKey ? Rest extends readonly unknown[] ? Rest['length'] extends 0 ? ToString<First> : `${ToString<First>},${TupleToCSV<Rest>}`\n    : never\n  : never\n  : '';\n\n/**\n * Internal method shapes for {@link TypeAsserter}: a conditional type disables each method when the\n * captured type does not support it.\n *\n * @typeParam Type - The captured type.\n */\ninterface TypeAssertions<Type> {\n  assertAllKeys: [Type] extends [object] ? <const Keys extends readonly string[]>(\n      keys: ExactMembers<StringKeys<Type>, Keys>\n    ) => readonly (keyof Type)[]\n    : never;\n  assertAllMembers: [Type] extends [LiteralKey] ? <const Keys extends readonly LiteralKey[]>(\n      keys: ExactMembers<Type, Keys>\n    ) => readonly Type[]\n    : never;\n}\n\ntype UnionToIntersection<Union> = (Union extends unknown ? (key: Union) => void : never) extends (key: infer Intersection) => void ? Intersection : never;\n\ntype UnionToTuple<Union, Last = LastInUnion<Union>> = [Union] extends [never] ? [] : [...UnionToTuple<Exclude<Union, Last>>, Last];\n\n/**\n * A helper that captures a type parameter and provides methods for compile-time exhaustiveness checks.\n *\n * @typeParam Type - The captured type.\n *\n * @remarks\n * - `assertAllKeys` is available when `Type` is an object type.\n * - `assertAllMembers` is available when `Type` is a literal key union (`string | number`).\n *\n * @example\n * ```ts\n * type A = { a: 1, b: 2, c: 3 };\n * new TypeAsserter<A>().assertAllKeys(['a', 'b', 'c']); // OK\n * new TypeAsserter<A>().assertAllKeys(['c', 'a', 'b']); // OK, order is ignored\n * new TypeAsserter<A>().assertAllKeys(['a', 'b', 'c', 'd']); // Error: Invalid members: d\n * new TypeAsserter<A>().assertAllKeys(['a', 'b']); // Error: Missing members: c\n *\n * type B = 1 | 2 | 3 | 'a';\n * new TypeAsserter<B>().assertAllMembers([1, 2, 3, 'a']); // OK\n * new TypeAsserter<B>().assertAllMembers([1, 2, 3, 'a', 4]); // Error: Invalid members: 4\n * new TypeAsserter<B>().assertAllMembers([1, 2, 3]); // Error: Missing members: a\n * ```\n */\nexport class TypeAsserter<Type> {\n  /**\n   * Asserts that all keys of an object type are present in a list of keys.\n   *\n   * @remarks Only available when `[Type] extends [object]`.\n   */\n  public readonly assertAllKeys: TypeAssertions<Type>['assertAllKeys'];\n\n  /**\n   * Asserts that all members of a union type are present in a list of members.\n   *\n   * @remarks Only available when `[Type] extends [LiteralKey]`.\n   */\n  public readonly assertAllMembers: TypeAssertions<Type>['assertAllMembers'];\n\n  /**\n   * Creates a type asserter that captures {@link Type} for compile-time exhaustiveness checks.\n   */\n  public constructor() {\n    const assertions = castTo<TypeAssertions<Type>>({\n      assertAllKeys<const Keys extends readonly string[]>(\n        keys: ExactMembers<StringKeys<object & Type>, Keys>\n      ): readonly (keyof (object & Type))[] {\n        // eslint-disable-next-line unicorn/prefer-spread -- `Type` may be a string, and spreading one splits surrogate pairs (`@typescript-eslint/no-misused-spread`).\n        return Object.freeze(Array.from(keys) as (keyof (object & Type))[]);\n      },\n      assertAllMembers<const Keys extends readonly LiteralKey[]>(\n        keys: ExactMembers<LiteralKey & Type, Keys>\n      ): readonly (LiteralKey & Type)[] {\n        // eslint-disable-next-line unicorn/prefer-spread -- `Type` may be a string, and spreading one splits surrogate pairs (`@typescript-eslint/no-misused-spread`).\n        return Object.freeze(Array.from(keys) as (LiteralKey & Type)[]);\n      }\n    });\n    this.assertAllKeys = assertions.assertAllKeys;\n    this.assertAllMembers = assertions.assertAllMembers;\n  }\n}\n"],
  "mappings": ";;;;;AAQA,SAAS,cAAc;AA8JhB,MAAM,aAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA;AAAA;AAAA;AAAA;AAAA,EAKT,cAAc;AACnB,UAAM,aAAa,OAA6B;AAAA,MAC9C,cACE,MACoC;AAEpC,eAAO,OAAO,OAAO,MAAM,KAAK,IAAI,CAA8B;AAAA,MACpE;AAAA,MACA,iBACE,MACgC;AAEhC,eAAO,OAAO,OAAO,MAAM,KAAK,IAAI,CAA0B;AAAA,MAChE;AAAA,IACF,CAAC;AACD,SAAK,gBAAgB,WAAW;AAChC,SAAK,mBAAmB,WAAW;AAAA,EACrC;AACF;",
  "names": []
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnaoumov/typescript-lib",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Generic TypeScript utilities: async helpers, errors, disposables, strings, paths, debug logging and more, usable in any TypeScript project.",
   "keywords": [
     "typescript",
@@ -84,6 +84,7 @@
     "build:lib": "jiti scripts/build-lib.ts",
     "build:types": "jiti scripts/build-types.ts",
     "build:validate-declarations": "jiti scripts/build-validate-declarations.ts",
+    "build:validate-dependencies": "jiti scripts/build-validate-dependencies.ts",
     "commit": "jiti scripts/commit.ts",
     "docs:build": "jiti scripts/docs-build.ts",
     "docs:dev": "jiti scripts/docs-dev.ts",
@@ -117,7 +118,7 @@
     "@astrojs/starlight": "^0.42.6",
     "@commitlint/cli": "^21.2.2",
     "@commitlint/config-conventional": "^21.2.2",
-    "@mnaoumov/typescript-dev-toolkit": "^2.0.0",
+    "@mnaoumov/typescript-dev-toolkit": "^3.4.0",
     "@mnaoumov/typescript-test-toolkit": "^1.0.0",
     "@resvg/resvg-js": "^2.6.2",
     "@total-typescript/ts-reset": "^0.6.1",