@mnaoumov/typescript-lib 1.4.0 → 1.5.0

package/dist/lib/esm/api-contract.mjs

@@ -14,6 +14,8 @@ import {
   isStringArray,
   isUndefined,
   literalTypeGuard,
+  objectTypeGuard,
+  optionalTypeGuard,
   unionTypeGuard
 } from "./type-guards.mjs";
 const BOOLEAN_GUARD = { expected: "a boolean", typeGuard: isBoolean };
@@ -68,12 +70,29 @@ function nullableGuard(guard) {
     typeGuard: (value) => value === null || guard.typeGuard(value)
   };
 }
+function objectGuard(propertyGuards, options) {
+  const guards = castTo(propertyGuards);
+  const exactOptionalKeys = options?.exactOptionalKeys ?? {};
+  return createExpectedTypeGuard(
+    describeObject(options?.description, guards, (key) => Object.hasOwn(exactOptionalKeys, key)),
+    objectTypeGuard(castTo(mapGuards(guards, (guard) => guard.typeGuard)), options)
+  );
+}
 function optionalGuard(guard) {
   return {
     expected: `${guard.expected} or undefined`,
     typeGuard: (value) => value === void 0 || guard.typeGuard(value)
   };
 }
+function optionsGuard(optionGuards, options) {
+  const guards = castTo(optionGuards);
+  return createExpectedTypeGuard(
+    describeObject(options?.description, guards, () => true),
+    objectTypeGuard(castTo(mapGuards(guards, (guard) => optionalTypeGuard(guard.typeGuard))), {
+      shouldRejectUnknownKeys: options?.shouldRejectUnknownKeys ?? false
+    })
+  );
+}
 function unionGuard(...guards) {
   return createExpectedTypeGuard(
     guards.map((guard) => guard.expected).join(" or "),
@@ -89,6 +108,11 @@ function createSchema(validate, vendor) {
     }
   };
 }
+function describeObject(description, guards, isOptional) {
+  const entries = Object.entries(guards);
+  const properties = entries.length === 0 ? "{}" : `{ ${entries.map(([key, guard]) => `${key}${isOptional(key) ? "?" : ""}: ${guard.expected}`).join("; ")} }`;
+  return description === void 0 ? properties : `${description}: ${properties}`;
+}
 function formatLiteral(literal) {
   if (isString(literal)) {
     return `'${literal}'`;
@@ -98,6 +122,9 @@ function formatLiteral(literal) {
 function isReadonlyArray(value) {
   return Array.isArray(value);
 }
+function mapGuards(guards, toTypeGuard) {
+  return Object.fromEntries(Object.entries(guards).map(([key, guard]) => [key, toTypeGuard(guard)]));
+}
 export {
   BOOLEAN_GUARD,
   NUMBER_GUARD,
@@ -113,7 +140,9 @@ export {
   instanceOfGuard,
   literalGuard,
   nullableGuard,
+  objectGuard,
   optionalGuard,
+  optionsGuard,
   unionGuard
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/api-contract.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The contract of an API one module exposes to another: which methods it promises, and a\n * {@link https://standardschema.dev | Standard Schema} over each method's arguments and return value.\n *\n * The schemas are plain objects over plain functions, which a type guard already is, so a contract can cross a\n * boundary between two copies of a library and still be run by whichever copy reads it. The builders here turn\n * the guards a module already has into the two shapes a method contract needs: one value (an output) and one\n * argument list (an input). zod / valibot / arktype schemas plug into the same slots unchanged; this module just\n * does not make every provider bundle one to describe two arguments.\n *\n * Running the schemas is left to whoever owns the call path, since that is where an issue can be reported.\n */\n\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\n\nimport type {\n  GuardedType,\n  Literal,\n  TypeGuard\n} from './type-guards.ts';\n\nimport { LIBRARY_NAME } from './library.ts';\nimport { castTo } from './object-utils.ts';\nimport {\n  arrayTypeGuard,\n  instanceOfTypeGuard,\n  isBoolean,\n  isNumber,\n  isString,\n  isStringArray,\n  isUndefined,\n  literalTypeGuard,\n  unionTypeGuard\n} from './type-guards.ts';\n\n/**\n * The contract an API declares: every key is a method the API promises to expose, and its value optionally\n * carries the payload schemas for that method.\n *\n * Typed over the API when one is named: `ApiContract<MyApi>` has exactly one entry per function member of\n * `MyApi` (a missing method, an extra one or a misspelled one does not compile), and each entry's schemas must\n * produce that method's parameters and awaited return value. Without a type argument, or for `object`, it is the\n * loose record a reader that knows nothing about the API sees.\n *\n * @typeParam TApi - The API the contract describes. `object`, the default, means \"not typed\".\n */\nexport type ApiContract<TApi extends object = object> = object extends TApi ? Readonly<Record<string, ApiMethodContract>>\n  : TypedApiContract<TApi>;\n\n/**\n * The schema builders of this module with the Standard Schema `vendor` already bound, as\n * {@link createApiContractSchemaBuilders} returns them.\n */\nexport interface ApiContractSchemaBuilders {\n  /**\n   * {@link createArgumentsSchema}, reporting the bound vendor.\n   *\n   * @typeParam TParameters - The method's parameters, inferred from the guards or from the contract entry.\n   * @param parameters - One guard per parameter, in order.\n   * @returns The schema.\n   */\n  readonly createArgumentsSchema: <const TParameters extends readonly unknown[]>(\n    parameters: ArgumentTypeGuards<TParameters>\n  ) => StandardSchemaV1<unknown, MutableTuple<TParameters>>;\n\n  /**\n   * {@link createTypeGuardSchema}, reporting the bound vendor.\n   *\n   * @typeParam T - The type the guard narrows to.\n   * @param guard - The guard and what it expects.\n   * @returns The schema.\n   */\n  readonly createTypeGuardSchema: <T>(guard: ExpectedTypeGuard<T>) => StandardSchemaV1<unknown, T>;\n}\n\n/**\n * The payload schemas for a single API method. Both halves are optional: a method may declare only its input,\n * only its output, neither (the entry then just declares that the method must exist), or both.\n *\n * @typeParam TParameters - The method's parameters, as a tuple, which the input schema must produce.\n * @typeParam TReturnValue - The method's return value, awaited, which the output schema must produce.\n */\nexport interface ApiMethodContract<TParameters = unknown, TReturnValue = unknown> {\n  /**\n   * Validates the method's arguments, as an array.\n   */\n  readonly input?: StandardSchemaV1<unknown, TParameters>;\n\n  /**\n   * Validates the method's return value, or, when the method returns a thenable, the value it resolves to.\n   */\n  readonly output?: StandardSchemaV1<unknown, TReturnValue>;\n}\n\n/**\n * The names of the function members of an API, which are exactly the keys a typed {@link ApiContract} has.\n *\n * @typeParam TApi - The API.\n */\nexport type ApiMethodName<TApi extends object> = keyof ApiMethods<TApi> & string;\n\n/**\n * The function members of an API.\n *\n * @typeParam TApi - The API.\n */\nexport type ApiMethods<TApi extends object> = {\n  [TKey in keyof TApi as TApi[TKey] extends (...arguments_: never) => unknown ? TKey : never]: TApi[TKey];\n};\n\n/**\n * One type guard per parameter of a method, in order.\n *\n * @typeParam TParameters - The method's parameters.\n */\nexport type ArgumentTypeGuards<TParameters extends readonly unknown[]> = {\n  readonly [TIndex in keyof TParameters]: ExpectedTypeGuard<TParameters[TIndex]>;\n};\n/**\n * Options for {@link createArgumentsSchema}.\n */\nexport interface CreateArgumentsSchemaOptions {\n  /**\n   * The Standard Schema `vendor` the schema reports. Defaults to this library's name.\n   */\n  readonly vendor?: string;\n}\n\n/**\n * Parameters for {@link createTypeGuardSchema}: the guard, what it expects, and optionally the schema's vendor.\n *\n * @typeParam T - The type the guard narrows to.\n */\nexport interface CreateTypeGuardSchemaParams<T> extends ExpectedTypeGuard<T> {\n  /**\n   * The Standard Schema `vendor` the schema reports. Defaults to this library's name.\n   */\n  readonly vendor?: string;\n}\n\n/**\n * One value a schema accepts, described by a type guard and by what it expects, for the issue message.\n *\n * @typeParam T - The type the guard narrows to.\n */\nexport interface ExpectedTypeGuard<T> {\n  /**\n   * What the value should have been, phrased to follow \"Expected\", e.g. `'a string'`.\n   */\n  readonly expected: string;\n\n  /**\n   * Decides whether the value is acceptable.\n   *\n   * @param value - The value to check.\n   * @returns Whether the value is a `T`.\n   */\n  readonly typeGuard: (value: unknown) => value is T;\n}\n\n/**\n * The {@link ApiContract} of a named API: one entry per function member, each typed against that member. Both\n * schemas are REQUIRED here, so a typed contract is a full description of every signature and a `{}` entry does\n * not compile. Only the loose form leaves them optional.\n *\n * @typeParam TApi - The API the contract describes.\n */\nexport type TypedApiContract<TApi extends object> = {\n  readonly [TKey in ApiMethodName<TApi>]-?: TApi[TKey] extends (...arguments_: infer TParameters) => infer TReturnValue ? Required<ApiMethodContract<TParameters, Awaited<TReturnValue>>>\n    : never;\n};\n\ntype MutableTuple<TTuple extends readonly unknown[]> = { -readonly [TIndex in keyof TTuple]: TTuple[TIndex] };\n\n/**\n * Accepts a boolean.\n */\nexport const BOOLEAN_GUARD: ExpectedTypeGuard<boolean> = { expected: 'a boolean', typeGuard: isBoolean };\n\n/**\n * Accepts a number.\n */\nexport const NUMBER_GUARD: ExpectedTypeGuard<number> = { expected: 'a number', typeGuard: isNumber };\n\n/**\n * Accepts a string. Spread it to say what the string is: `{ ...STRING_GUARD, expected: 'a path' }`.\n */\nexport const STRING_GUARD: ExpectedTypeGuard<string> = { expected: 'a string', typeGuard: isString };\n\n/**\n * Accepts an array of strings.\n */\nexport const STRING_ARRAY_GUARD: ExpectedTypeGuard<string[]> = { expected: 'an array of strings', typeGuard: isStringArray };\n\n/**\n * Accepts `undefined`, which is the output of a method returning `void` or `Promise<void>`.\n */\nexport const UNDEFINED_GUARD: ExpectedTypeGuard<undefined> = { expected: 'undefined', typeGuard: isUndefined };\n\n/**\n * Widens a guard to an array whose every item `itemGuard` accepts.\n *\n * @typeParam T - The type of an item.\n * @param itemGuard - The guard for one item.\n * @returns The guard.\n */\nexport function arrayGuard<T>(itemGuard: ExpectedTypeGuard<T>): ExpectedTypeGuard<T[]> {\n  return createExpectedTypeGuard(`an array whose every item is ${itemGuard.expected}`, arrayTypeGuard(itemGuard.typeGuard));\n}\n\n/**\n * Binds the Standard Schema `vendor` once, so a contract does not pass it to every schema builder. Destructure the\n * result under the builders' own names and the calls read exactly as the unbound ones do:\n *\n * ```ts\n * const { createArgumentsSchema, createTypeGuardSchema } = createApiContractSchemaBuilders('my-plugin');\n * ```\n *\n * @param vendor - The vendor every schema reports.\n * @returns The bound builders.\n */\nexport function createApiContractSchemaBuilders(vendor: string): ApiContractSchemaBuilders {\n  return {\n    createArgumentsSchema: <const TParameters extends readonly unknown[]>(parameters: ArgumentTypeGuards<TParameters>) => createArgumentsSchema(parameters, { vendor }),\n    createTypeGuardSchema: <T>(guard: ExpectedTypeGuard<T>) => createTypeGuardSchema({ ...guard, vendor })\n  };\n}\n\n/**\n * Builds the input schema of a method contract: a schema over the method's ARGUMENT LIST, one type guard per\n * parameter. An argument that fails its guard is reported with its index as the issue path, and an argument list\n * longer than the parameter list is refused. A missing argument reaches its guard as `undefined`, so an optional\n * parameter's guard accepts `undefined` (see {@link optionalGuard}).\n *\n * @typeParam TParameters - The method's parameters, inferred from the guards or from the contract entry.\n * @param parameters - One guard per parameter, in order.\n * @param options - The options for the schema.\n * @returns The schema.\n */\nexport function createArgumentsSchema<const TParameters extends readonly unknown[]>(\n  parameters: ArgumentTypeGuards<TParameters>,\n  options?: CreateArgumentsSchemaOptions\n): StandardSchemaV1<unknown, MutableTuple<TParameters>> {\n  const parameterList = castTo<readonly ExpectedTypeGuard<unknown>[]>(parameters);\n  return createSchema((value: unknown): StandardSchemaV1.Result<MutableTuple<TParameters>> => {\n    if (!Array.isArray(value)) {\n      return { issues: [{ message: 'Expected an argument list.' }] };\n    }\n\n    if (value.length > parameterList.length) {\n      return { issues: [{ message: `Expected at most ${String(parameterList.length)} argument(s), got ${String(value.length)}.` }] };\n    }\n\n    const issues = parameterList.flatMap((parameter, index): StandardSchemaV1.Issue[] => parameter.typeGuard(value[index]) ? [] : [{ message: `Expected ${parameter.expected}.`, path: [index] }]);\n    return issues.length === 0 ? { value: castTo<MutableTuple<TParameters>>(value) } : { issues };\n  }, options?.vendor);\n}\n\n/**\n * Pairs a type guard with what it expects.\n *\n * @typeParam T - The type the guard narrows to.\n * @param expected - What the value should have been, phrased to follow \"Expected\", e.g. `'a string'`.\n * @param typeGuard - The guard.\n * @returns The guard.\n */\nexport function createExpectedTypeGuard<T>(expected: string, typeGuard: TypeGuard<T>): ExpectedTypeGuard<T> {\n  return { expected, typeGuard };\n}\n\n/**\n * Builds a schema over one value from a type guard: the output schema of a method contract, typically.\n *\n * @typeParam T - The type the guard narrows to.\n * @param params - The guard, what it expects, and optionally the schema's vendor.\n * @returns The schema.\n */\nexport function createTypeGuardSchema<T>(params: CreateTypeGuardSchemaParams<T>): StandardSchemaV1<unknown, T> {\n  return createSchema(\n    (value: unknown): StandardSchemaV1.Result<T> => params.typeGuard(value) ? { value } : { issues: [{ message: `Expected ${params.expected}.` }] },\n    params.vendor\n  );\n}\n\n/**\n * States a contract against an API type, so every entry is checked against its method and the schema builders\n * inside it infer their types from the method rather than from a restated tuple. It returns the contract as is.\n *\n * @typeParam TApi - The API the contract describes.\n * @param contract - The contract.\n * @returns The same contract.\n */\nexport function defineApiContract<TApi extends object>(contract: TypedApiContract<NoInfer<TApi>>): TypedApiContract<TApi> {\n  return contract;\n}\n\n/**\n * Builds a guard accepting an instance of a class, or of a class derived from it, expecting `an instance of` the\n * class's name.\n *\n * @typeParam T - The type of an instance.\n * @param constructor - The class.\n * @returns The guard.\n */\nexport function instanceOfGuard<T>(constructor: abstract new (...arguments_: never[]) => T): ExpectedTypeGuard<T> {\n  return createExpectedTypeGuard(`an instance of ${constructor.name}`, instanceOfTypeGuard(constructor));\n}\n\n/**\n * Builds a guard accepting exactly the keys of a record, expecting `one of` them. Typing the record over a union\n * makes a member later added to the union fail to compile until 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 literalGuard<T extends string>(literals: Readonly<Record<T, true>>): ExpectedTypeGuard<T>;\n/**\n * Builds a guard accepting exactly the listed values, expecting `one of` them.\n *\n * @typeParam T - The accepted values.\n * @param literals - The accepted values.\n * @returns The guard.\n */\nexport function literalGuard<T extends Literal>(literals: readonly T[]): ExpectedTypeGuard<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 literalGuard(literals: Readonly<Record<string, true>> | readonly Literal[]): ExpectedTypeGuard<Literal> {\n  const literalList: readonly Literal[] = isReadonlyArray(literals) ? literals : Object.keys(literals);\n  return createExpectedTypeGuard(`one of ${literalList.map((literal) => formatLiteral(literal)).join(', ')}`, literalTypeGuard(literalList));\n}\n\n/**\n * Widens a guard to also accept `null`.\n *\n * @typeParam T - The type the guard narrows to.\n * @param guard - The guard to widen.\n * @returns A guard accepting what `guard` accepts, or `null`.\n */\nexport function nullableGuard<T>(guard: ExpectedTypeGuard<T>): ExpectedTypeGuard<null | T> {\n  return {\n    expected: `${guard.expected} or null`,\n    typeGuard: (value: unknown): value is null | T => value === null || guard.typeGuard(value)\n  };\n}\n\n/**\n * Widens a guard to also accept `undefined`, which is what an optional parameter receives when it is left out.\n *\n * @typeParam T - The type the guard narrows to.\n * @param guard - The guard to widen.\n * @returns A guard accepting what `guard` accepts, or `undefined`.\n */\nexport function optionalGuard<T>(guard: ExpectedTypeGuard<T>): ExpectedTypeGuard<T | undefined> {\n  return {\n    expected: `${guard.expected} or undefined`,\n    typeGuard: (value: unknown): value is T | undefined => value === undefined || guard.typeGuard(value)\n  };\n}\n\n/**\n * Builds a guard accepting what any of the given guards accepts, expecting their `expected` texts joined by `or`.\n *\n * @typeParam TGuards - The guards.\n * @param guards - The guards, tried in order.\n * @returns The guard.\n */\nexport function unionGuard<const TGuards extends readonly ExpectedTypeGuard<unknown>[]>(\n  ...guards: TGuards\n): ExpectedTypeGuard<GuardedType<TGuards[number]['typeGuard']>> {\n  return createExpectedTypeGuard(\n    guards.map((guard) => guard.expected).join(' or '),\n    unionTypeGuard(...guards.map((guard) => guard.typeGuard))\n  );\n}\n\nfunction createSchema<T>(validate: (value: unknown) => StandardSchemaV1.Result<T>, vendor: string | undefined): StandardSchemaV1<unknown, T> {\n  return {\n    '~standard': {\n      validate,\n      vendor: vendor ?? LIBRARY_NAME,\n      version: 1\n    }\n  };\n}\n\nfunction formatLiteral(literal: Literal): string {\n  if (isString(literal)) {\n    return `'${literal}'`;\n  }\n\n  return typeof literal === 'bigint' ? `${String(literal)}n` : String(literal);\n}\n\nfunction isReadonlyArray(value: unknown): value is readonly unknown[] {\n  return Array.isArray(value);\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/api-contract.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The contract of an API one module exposes to another: which methods it promises, and a\n * {@link https://standardschema.dev | Standard Schema} over each method's arguments and return value.\n *\n * The schemas are plain objects over plain functions, which a type guard already is, so a contract can cross a\n * boundary between two copies of a library and still be run by whichever copy reads it. The builders here turn\n * the guards a module already has into the two shapes a method contract needs: one value (an output) and one\n * argument list (an input). zod / valibot / arktype schemas plug into the same slots unchanged; this module just\n * does not make every provider bundle one to describe two arguments.\n *\n * Running the schemas is left to whoever owns the call path, since that is where an issue can be reported.\n */\n\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\n\nimport type {\n  GuardedType,\n  Literal,\n  ObjectTypeGuardOptions,\n  PropertyTypeGuards,\n  TypeGuard\n} from './type-guards.ts';\n\nimport { LIBRARY_NAME } from './library.ts';\nimport { castTo } from './object-utils.ts';\nimport {\n  arrayTypeGuard,\n  instanceOfTypeGuard,\n  isBoolean,\n  isNumber,\n  isString,\n  isStringArray,\n  isUndefined,\n  literalTypeGuard,\n  objectTypeGuard,\n  optionalTypeGuard,\n  unionTypeGuard\n} from './type-guards.ts';\n\n/**\n * The contract an API declares: every key is a method the API promises to expose, and its value optionally\n * carries the payload schemas for that method.\n *\n * Typed over the API when one is named: `ApiContract<MyApi>` has exactly one entry per function member of\n * `MyApi` (a missing method, an extra one or a misspelled one does not compile), and each entry's schemas must\n * produce that method's parameters and awaited return value. Without a type argument, or for `object`, it is the\n * loose record a reader that knows nothing about the API sees.\n *\n * @typeParam TApi - The API the contract describes. `object`, the default, means \"not typed\".\n */\nexport type ApiContract<TApi extends object = object> = object extends TApi ? Readonly<Record<string, ApiMethodContract>>\n  : TypedApiContract<TApi>;\n\n/**\n * The schema builders of this module with the Standard Schema `vendor` already bound, as\n * {@link createApiContractSchemaBuilders} returns them.\n */\nexport interface ApiContractSchemaBuilders {\n  /**\n   * {@link createArgumentsSchema}, reporting the bound vendor.\n   *\n   * @typeParam TParameters - The method's parameters, inferred from the guards or from the contract entry.\n   * @param parameters - One guard per parameter, in order.\n   * @returns The schema.\n   */\n  readonly createArgumentsSchema: <const TParameters extends readonly unknown[]>(\n    parameters: ArgumentTypeGuards<TParameters>\n  ) => StandardSchemaV1<unknown, MutableTuple<TParameters>>;\n\n  /**\n   * {@link createTypeGuardSchema}, reporting the bound vendor.\n   *\n   * @typeParam T - The type the guard narrows to.\n   * @param guard - The guard and what it expects.\n   * @returns The schema.\n   */\n  readonly createTypeGuardSchema: <T>(guard: ExpectedTypeGuard<T>) => StandardSchemaV1<unknown, T>;\n}\n\n/**\n * The payload schemas for a single API method. Both halves are optional: a method may declare only its input,\n * only its output, neither (the entry then just declares that the method must exist), or both.\n *\n * @typeParam TParameters - The method's parameters, as a tuple, which the input schema must produce.\n * @typeParam TReturnValue - The method's return value, awaited, which the output schema must produce.\n */\nexport interface ApiMethodContract<TParameters = unknown, TReturnValue = unknown> {\n  /**\n   * Validates the method's arguments, as an array.\n   */\n  readonly input?: StandardSchemaV1<unknown, TParameters>;\n\n  /**\n   * Validates the method's return value, or, when the method returns a thenable, the value it resolves to.\n   */\n  readonly output?: StandardSchemaV1<unknown, TReturnValue>;\n}\n\n/**\n * The names of the function members of an API, which are exactly the keys a typed {@link ApiContract} has.\n *\n * @typeParam TApi - The API.\n */\nexport type ApiMethodName<TApi extends object> = keyof ApiMethods<TApi> & string;\n\n/**\n * The function members of an API.\n *\n * @typeParam TApi - The API.\n */\nexport type ApiMethods<TApi extends object> = {\n  [TKey in keyof TApi as TApi[TKey] extends (...arguments_: never) => unknown ? TKey : never]: TApi[TKey];\n};\n\n/**\n * One type guard per parameter of a method, in order.\n *\n * @typeParam TParameters - The method's parameters.\n */\nexport type ArgumentTypeGuards<TParameters extends readonly unknown[]> = {\n  readonly [TIndex in keyof TParameters]: ExpectedTypeGuard<TParameters[TIndex]>;\n};\n/**\n * Options for {@link createArgumentsSchema}.\n */\nexport interface CreateArgumentsSchemaOptions {\n  /**\n   * The Standard Schema `vendor` the schema reports. Defaults to this library's name.\n   */\n  readonly vendor?: string;\n}\n\n/**\n * Parameters for {@link createTypeGuardSchema}: the guard, what it expects, and optionally the schema's vendor.\n *\n * @typeParam T - The type the guard narrows to.\n */\nexport interface CreateTypeGuardSchemaParams<T> extends ExpectedTypeGuard<T> {\n  /**\n   * The Standard Schema `vendor` the schema reports. Defaults to this library's name.\n   */\n  readonly vendor?: string;\n}\n\n/**\n * One value a schema accepts, described by a type guard and by what it expects, for the issue message.\n *\n * @typeParam T - The type the guard narrows to.\n */\nexport interface ExpectedTypeGuard<T> {\n  /**\n   * What the value should have been, phrased to follow \"Expected\", e.g. `'a string'`.\n   */\n  readonly expected: string;\n\n  /**\n   * Decides whether the value is acceptable.\n   *\n   * @param value - The value to check.\n   * @returns Whether the value is a `T`.\n   */\n  readonly typeGuard: (value: unknown) => value is T;\n}\n\n/**\n * Options for {@link objectGuard}.\n *\n * @typeParam T - The object type the guard narrows to.\n */\nexport interface ObjectGuardOptions<T extends object> extends ObjectTypeGuardOptions<T> {\n  /**\n   * What the object is, put before its properties in `expected`, e.g. `'the options of the link'`.\n   */\n  readonly description?: string;\n}\n\n/**\n * One guard per option of an all-optional object type, as {@link optionsGuard} takes them: each describes a\n * PRESENT option, so it does not accept `undefined`. A required property of `T` takes `never`, so a type that is\n * not all-optional does not compile.\n *\n * @typeParam T - The object type.\n */\nexport type OptionGuards<T extends object> = {\n  readonly [TKey in keyof T]-?: Partial<Pick<T, TKey>> extends Pick<T, TKey> ? ExpectedTypeGuard<Exclude<T[TKey], undefined>> : never;\n};\n\n/**\n * Options for {@link optionsGuard}.\n */\nexport interface OptionsGuardOptions {\n  /**\n   * What the options are, put before them in `expected`, e.g. `'select options'`.\n   */\n  readonly description?: string;\n\n  /**\n   * Whether a value carrying an own enumerable string key that no option guard names is refused. Letting it through,\n   * the default, lets a consumer compiled against a later version of the options pass one this version does not know.\n   *\n   * @default `false`\n   */\n  readonly shouldRejectUnknownKeys?: boolean;\n}\n\n/**\n * One guard per property of an object type, as {@link objectGuard} takes them, typed as {@link PropertyTypeGuards}\n * types the bare guards.\n *\n * @typeParam T - The object type.\n */\nexport type PropertyGuards<T extends object> = {\n  readonly [TKey in keyof T]-?: ExpectedTypeGuard<Partial<Pick<T, TKey>> extends Pick<T, TKey> ? T[TKey] | undefined : T[TKey]>;\n};\n\n/**\n * The {@link ApiContract} of a named API: one entry per function member, each typed against that member. Both\n * schemas are REQUIRED here, so a typed contract is a full description of every signature and a `{}` entry does\n * not compile. Only the loose form leaves them optional.\n *\n * @typeParam TApi - The API the contract describes.\n */\nexport type TypedApiContract<TApi extends object> = {\n  readonly [TKey in ApiMethodName<TApi>]-?: TApi[TKey] extends (...arguments_: infer TParameters) => infer TReturnValue ? Required<ApiMethodContract<TParameters, Awaited<TReturnValue>>>\n    : never;\n};\n\ntype MutableTuple<TTuple extends readonly unknown[]> = { -readonly [TIndex in keyof TTuple]: TTuple[TIndex] };\n\n/**\n * Accepts a boolean.\n */\nexport const BOOLEAN_GUARD: ExpectedTypeGuard<boolean> = { expected: 'a boolean', typeGuard: isBoolean };\n\n/**\n * Accepts a number.\n */\nexport const NUMBER_GUARD: ExpectedTypeGuard<number> = { expected: 'a number', typeGuard: isNumber };\n\n/**\n * Accepts a string. Spread it to say what the string is: `{ ...STRING_GUARD, expected: 'a path' }`.\n */\nexport const STRING_GUARD: ExpectedTypeGuard<string> = { expected: 'a string', typeGuard: isString };\n\n/**\n * Accepts an array of strings.\n */\nexport const STRING_ARRAY_GUARD: ExpectedTypeGuard<string[]> = { expected: 'an array of strings', typeGuard: isStringArray };\n\n/**\n * Accepts `undefined`, which is the output of a method returning `void` or `Promise<void>`.\n */\nexport const UNDEFINED_GUARD: ExpectedTypeGuard<undefined> = { expected: 'undefined', typeGuard: isUndefined };\n\n/**\n * Widens a guard to an array whose every item `itemGuard` accepts.\n *\n * @typeParam T - The type of an item.\n * @param itemGuard - The guard for one item.\n * @returns The guard.\n */\nexport function arrayGuard<T>(itemGuard: ExpectedTypeGuard<T>): ExpectedTypeGuard<T[]> {\n  return createExpectedTypeGuard(`an array whose every item is ${itemGuard.expected}`, arrayTypeGuard(itemGuard.typeGuard));\n}\n\n/**\n * Binds the Standard Schema `vendor` once, so a contract does not pass it to every schema builder. Destructure the\n * result under the builders' own names and the calls read exactly as the unbound ones do:\n *\n * ```ts\n * const { createArgumentsSchema, createTypeGuardSchema } = createApiContractSchemaBuilders('my-plugin');\n * ```\n *\n * @param vendor - The vendor every schema reports.\n * @returns The bound builders.\n */\nexport function createApiContractSchemaBuilders(vendor: string): ApiContractSchemaBuilders {\n  return {\n    createArgumentsSchema: <const TParameters extends readonly unknown[]>(parameters: ArgumentTypeGuards<TParameters>) => createArgumentsSchema(parameters, { vendor }),\n    createTypeGuardSchema: <T>(guard: ExpectedTypeGuard<T>) => createTypeGuardSchema({ ...guard, vendor })\n  };\n}\n\n/**\n * Builds the input schema of a method contract: a schema over the method's ARGUMENT LIST, one type guard per\n * parameter. An argument that fails its guard is reported with its index as the issue path, and an argument list\n * longer than the parameter list is refused. A missing argument reaches its guard as `undefined`, so an optional\n * parameter's guard accepts `undefined` (see {@link optionalGuard}).\n *\n * @typeParam TParameters - The method's parameters, inferred from the guards or from the contract entry.\n * @param parameters - One guard per parameter, in order.\n * @param options - The options for the schema.\n * @returns The schema.\n */\nexport function createArgumentsSchema<const TParameters extends readonly unknown[]>(\n  parameters: ArgumentTypeGuards<TParameters>,\n  options?: CreateArgumentsSchemaOptions\n): StandardSchemaV1<unknown, MutableTuple<TParameters>> {\n  const parameterList = castTo<readonly ExpectedTypeGuard<unknown>[]>(parameters);\n  return createSchema((value: unknown): StandardSchemaV1.Result<MutableTuple<TParameters>> => {\n    if (!Array.isArray(value)) {\n      return { issues: [{ message: 'Expected an argument list.' }] };\n    }\n\n    if (value.length > parameterList.length) {\n      return { issues: [{ message: `Expected at most ${String(parameterList.length)} argument(s), got ${String(value.length)}.` }] };\n    }\n\n    const issues = parameterList.flatMap((parameter, index): StandardSchemaV1.Issue[] => parameter.typeGuard(value[index]) ? [] : [{ message: `Expected ${parameter.expected}.`, path: [index] }]);\n    return issues.length === 0 ? { value: castTo<MutableTuple<TParameters>>(value) } : { issues };\n  }, options?.vendor);\n}\n\n/**\n * Pairs a type guard with what it expects.\n *\n * @typeParam T - The type the guard narrows to.\n * @param expected - What the value should have been, phrased to follow \"Expected\", e.g. `'a string'`.\n * @param typeGuard - The guard.\n * @returns The guard.\n */\nexport function createExpectedTypeGuard<T>(expected: string, typeGuard: TypeGuard<T>): ExpectedTypeGuard<T> {\n  return { expected, typeGuard };\n}\n\n/**\n * Builds a schema over one value from a type guard: the output schema of a method contract, typically.\n *\n * @typeParam T - The type the guard narrows to.\n * @param params - The guard, what it expects, and optionally the schema's vendor.\n * @returns The schema.\n */\nexport function createTypeGuardSchema<T>(params: CreateTypeGuardSchemaParams<T>): StandardSchemaV1<unknown, T> {\n  return createSchema(\n    (value: unknown): StandardSchemaV1.Result<T> => params.typeGuard(value) ? { value } : { issues: [{ message: `Expected ${params.expected}.` }] },\n    params.vendor\n  );\n}\n\n/**\n * States a contract against an API type, so every entry is checked against its method and the schema builders\n * inside it infer their types from the method rather than from a restated tuple. It returns the contract as is.\n *\n * @typeParam TApi - The API the contract describes.\n * @param contract - The contract.\n * @returns The same contract.\n */\nexport function defineApiContract<TApi extends object>(contract: TypedApiContract<NoInfer<TApi>>): TypedApiContract<TApi> {\n  return contract;\n}\n\n/**\n * Builds a guard accepting an instance of a class, or of a class derived from it, expecting `an instance of` the\n * class's name.\n *\n * @typeParam T - The type of an instance.\n * @param constructor - The class.\n * @returns The guard.\n */\nexport function instanceOfGuard<T>(constructor: abstract new (...arguments_: never[]) => T): ExpectedTypeGuard<T> {\n  return createExpectedTypeGuard(`an instance of ${constructor.name}`, instanceOfTypeGuard(constructor));\n}\n\n/**\n * Builds a guard accepting exactly the keys of a record, expecting `one of` them. Typing the record over a union\n * makes a member later added to the union fail to compile until 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 literalGuard<T extends string>(literals: Readonly<Record<T, true>>): ExpectedTypeGuard<T>;\n/**\n * Builds a guard accepting exactly the listed values, expecting `one of` them.\n *\n * @typeParam T - The accepted values.\n * @param literals - The accepted values.\n * @returns The guard.\n */\nexport function literalGuard<T extends Literal>(literals: readonly T[]): ExpectedTypeGuard<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 literalGuard(literals: Readonly<Record<string, true>> | readonly Literal[]): ExpectedTypeGuard<Literal> {\n  const literalList: readonly Literal[] = isReadonlyArray(literals) ? literals : Object.keys(literals);\n  return createExpectedTypeGuard(`one of ${literalList.map((literal) => formatLiteral(literal)).join(', ')}`, literalTypeGuard(literalList));\n}\n\n/**\n * Widens a guard to also accept `null`.\n *\n * @typeParam T - The type the guard narrows to.\n * @param guard - The guard to widen.\n * @returns A guard accepting what `guard` accepts, or `null`.\n */\nexport function nullableGuard<T>(guard: ExpectedTypeGuard<T>): ExpectedTypeGuard<null | T> {\n  return {\n    expected: `${guard.expected} or null`,\n    typeGuard: (value: unknown): value is null | T => value === null || guard.typeGuard(value)\n  };\n}\n\n/**\n * Builds a guard accepting an object whose every listed property its guard accepts, as {@link objectTypeGuard} does,\n * expecting the properties and what each expects: `{ alias?: a string; path: a string }`, after the\n * {@link ObjectGuardOptions.description} when one is given. A key is marked optional when it is listed in\n * {@link ObjectTypeGuardOptions.exactOptionalKeys}; without that list, an optional property's guard says\n * `or undefined` itself.\n *\n * @typeParam T - The object type.\n * @param propertyGuards - One guard per property of `T`.\n * @param options - The options for the guard.\n * @returns The guard.\n */\nexport function objectGuard<T extends object>(propertyGuards: PropertyGuards<T>, options?: ObjectGuardOptions<T>): ExpectedTypeGuard<T> {\n  const guards = castTo<Readonly<Record<string, ExpectedTypeGuard<unknown>>>>(propertyGuards);\n  const exactOptionalKeys: object = options?.exactOptionalKeys ?? {};\n  return createExpectedTypeGuard(\n    describeObject(options?.description, guards, (key) => Object.hasOwn(exactOptionalKeys, key)),\n    objectTypeGuard<T>(castTo<PropertyTypeGuards<T>>(mapGuards(guards, (guard) => guard.typeGuard)), options)\n  );\n}\n\n/**\n * Widens a guard to also accept `undefined`, which is what an optional parameter receives when it is left out.\n *\n * @typeParam T - The type the guard narrows to.\n * @param guard - The guard to widen.\n * @returns A guard accepting what `guard` accepts, or `undefined`.\n */\nexport function optionalGuard<T>(guard: ExpectedTypeGuard<T>): ExpectedTypeGuard<T | undefined> {\n  return {\n    expected: `${guard.expected} or undefined`,\n    typeGuard: (value: unknown): value is T | undefined => value === undefined || guard.typeGuard(value)\n  };\n}\n\n/**\n * Builds a guard accepting an options bag: an object whose every option may be absent, or `undefined`, and must\n * otherwise pass its guard. A key no guard names is let through unless\n * {@link OptionsGuardOptions.shouldRejectUnknownKeys} is set. It expects the options and what each expects:\n * `{ prefix?: a string; isHidden?: a boolean }`, after the {@link OptionsGuardOptions.description} when one is given.\n *\n * @typeParam T - The options type, every property of which is optional.\n * @param optionGuards - One guard per option of `T`, for a present value.\n * @param options - The options for the guard.\n * @returns The guard.\n */\nexport function optionsGuard<T extends object>(optionGuards: OptionGuards<T>, options?: OptionsGuardOptions): ExpectedTypeGuard<T> {\n  const guards = castTo<Readonly<Record<string, ExpectedTypeGuard<unknown>>>>(optionGuards);\n  return createExpectedTypeGuard(\n    describeObject(options?.description, guards, () => true),\n    objectTypeGuard<T>(castTo<PropertyTypeGuards<T>>(mapGuards(guards, (guard) => optionalTypeGuard(guard.typeGuard))), {\n      shouldRejectUnknownKeys: options?.shouldRejectUnknownKeys ?? false\n    })\n  );\n}\n\n/**\n * Builds a guard accepting what any of the given guards accepts, expecting their `expected` texts joined by `or`.\n *\n * @typeParam TGuards - The guards.\n * @param guards - The guards, tried in order.\n * @returns The guard.\n */\nexport function unionGuard<const TGuards extends readonly ExpectedTypeGuard<unknown>[]>(\n  ...guards: TGuards\n): ExpectedTypeGuard<GuardedType<TGuards[number]['typeGuard']>> {\n  return createExpectedTypeGuard(\n    guards.map((guard) => guard.expected).join(' or '),\n    unionTypeGuard(...guards.map((guard) => guard.typeGuard))\n  );\n}\n\nfunction createSchema<T>(validate: (value: unknown) => StandardSchemaV1.Result<T>, vendor: string | undefined): StandardSchemaV1<unknown, T> {\n  return {\n    '~standard': {\n      validate,\n      vendor: vendor ?? LIBRARY_NAME,\n      version: 1\n    }\n  };\n}\n\nfunction describeObject(\n  description: string | undefined,\n  guards: Readonly<Record<string, ExpectedTypeGuard<unknown>>>,\n  isOptional: (key: string) => boolean\n): string {\n  const entries = Object.entries(guards);\n  const properties = entries.length === 0\n    ? '{}'\n    : `{ ${entries.map(([key, guard]) => `${key}${isOptional(key) ? '?' : ''}: ${guard.expected}`).join('; ')} }`;\n  return description === undefined ? properties : `${description}: ${properties}`;\n}\n\nfunction formatLiteral(literal: Literal): string {\n  if (isString(literal)) {\n    return `'${literal}'`;\n  }\n\n  return typeof literal === 'bigint' ? `${String(literal)}n` : String(literal);\n}\n\nfunction isReadonlyArray(value: unknown): value is readonly unknown[] {\n  return Array.isArray(value);\n}\n\nfunction mapGuards(\n  guards: Readonly<Record<string, ExpectedTypeGuard<unknown>>>,\n  toTypeGuard: (guard: ExpectedTypeGuard<unknown>) => TypeGuard<unknown>\n): Record<string, TypeGuard<unknown>> {\n  return Object.fromEntries(Object.entries(guards).map(([key, guard]) => [key, toTypeGuard(guard)]));\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/index.d.mts

@@ -1,6 +1,7 @@
 /// <reference path="./library-references.d.mts" />
 export * as 'abort-controller' from './abort-controller.mjs';
 export * as 'aggregate-error' from './aggregate-error.mjs';
+export * as 'api-contract-verifier' from './api-contract-verifier.mjs';
 export * as 'api-contract' from './api-contract.mjs';
 export * as 'array-buffer' from './array-buffer.mjs';
 export * as 'array' from './array.mjs';

package/dist/lib/esm/index.mjs

@@ -5,6 +5,7 @@ if you want to view the source, please visit the github repository of this plugi
 
 import * as abort_controller from "./abort-controller.mjs";
 import * as aggregate_error from "./aggregate-error.mjs";
+import * as api_contract_verifier from "./api-contract-verifier.mjs";
 import * as api_contract from "./api-contract.mjs";
 import * as array_buffer from "./array-buffer.mjs";
 import * as array from "./array.mjs";
@@ -41,6 +42,7 @@ export {
   abort_controller as "abort-controller",
   aggregate_error as "aggregate-error",
   api_contract as "api-contract",
+  api_contract_verifier as "api-contract-verifier",
   array,
   array_buffer as "array-buffer",
   async,
@@ -73,4 +75,4 @@ export {
   value_provider as "value-provider",
   value_wrapper as "value-wrapper"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -27,8 +27,22 @@ export type GuardedType<TTypeGuard> = TTypeGuard extends (value: unknown) => val
 export type Literal = bigint | boolean | null | number | string | symbol | undefined;
 /**
  * Options for {@link objectTypeGuard}.
+ *
+ * @typeParam T - The object type the guard narrows to.
  */
-export interface ObjectTypeGuardOptions {
+export interface ObjectTypeGuardOptions<T extends object = object> {
+    /**
+     * Switches the guard to EXACT optional properties, reading only the value's OWN keys. Listing it is the switch,
+     * so pass `{}` for a type with no optional key.
+     *
+     * Every optional key of `T` must be listed, so an optional property later added to `T` fails to compile until it
+     * is. A listed key may then be absent, and its guard is not run; present, even as `undefined`, it must pass its
+     * guard. Any other key must be present. An inherited key counts as absent.
+     *
+     * Without it, a property is read with `Reflect.get`, so an inherited one counts and an absent one reads as
+     * `undefined`, which the guard of an optional property must then accept.
+     */
+    readonly exactOptionalKeys?: Readonly<Record<OptionalKeys<T>, true>>;
     /**
      * Whether a value carrying an own enumerable string key that no property guard names is refused.
      *
@@ -36,6 +50,12 @@ export interface ObjectTypeGuardOptions {
      */
     readonly shouldRejectUnknownKeys?: boolean;
 }
+/**
+ * The keys of an object type that are optional.
+ *
+ * @typeParam T - The object type.
+ */
+export type OptionalKeys<T extends object> = OptionalKeyMap<T>[keyof T];
 /**
  * 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
@@ -54,6 +74,9 @@ export type PropertyTypeGuards<T extends object> = {
  */
 export type TypeGuard<T> = (value: unknown) => value is T;
 type NullableConstraint<T> = null extends T ? unknown : undefined extends T ? unknown : never;
+type OptionalKeyMap<T extends object> = {
+    [TKey in keyof T]-?: Partial<Pick<T, TKey>> extends Pick<T, TKey> ? TKey : never;
+};
 /**
  * Builds a guard accepting an array whose every item the item guard accepts.
  *
@@ -232,14 +255,15 @@ export declare function literalTypeGuard<T extends Literal>(literals: readonly T
 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`.
+ * `Reflect.get`, so an inherited one counts and an absent one reads as `undefined`, unless
+ * {@link ObjectTypeGuardOptions.exactOptionalKeys} switches the guard to own keys and exact optional properties.
  *
  * @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>;
+export declare function objectTypeGuard<T extends object>(propertyTypeGuards: PropertyTypeGuards<T>, options?: ObjectTypeGuardOptions<T>): TypeGuard<T>;
 /**
  * Widens a guard to also accept `undefined`, which is what an optional property or parameter reads as when it is
  * left out.

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

@@ -75,6 +75,7 @@ function nullableTypeGuard(isValue) {
 }
 function objectTypeGuard(propertyTypeGuards, options) {
   const shouldRejectUnknownKeys = options?.shouldRejectUnknownKeys ?? false;
+  const exactOptionalKeys = options?.exactOptionalKeys;
   return (value) => {
     if (!isObject(value)) {
       return false;
@@ -82,8 +83,15 @@ function objectTypeGuard(propertyTypeGuards, options) {
     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))) {
+    const typeGuards = propertyTypeGuards;
+    for (const [key, typeGuard] of Object.entries(typeGuards)) {
+      if (exactOptionalKeys && !Object.hasOwn(value, key)) {
+        if (Object.hasOwn(exactOptionalKeys, key)) {
+          continue;
+        }
+        return false;
+      }
+      if (!typeGuard(Reflect.get(value, key))) {
         return false;
       }
     }
@@ -123,4 +131,4 @@ export {
   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, 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": []
}

+//# 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 *\n * @typeParam T - The object type the guard narrows to.\n */\nexport interface ObjectTypeGuardOptions<T extends object = object> {\n  /**\n   * Switches the guard to EXACT optional properties, reading only the value's OWN keys. Listing it is the switch,\n   * so pass `{}` for a type with no optional key.\n   *\n   * Every optional key of `T` must be listed, so an optional property later added to `T` fails to compile until it\n   * is. A listed key may then be absent, and its guard is not run; present, even as `undefined`, it must pass its\n   * guard. Any other key must be present. An inherited key counts as absent.\n   *\n   * Without it, a property is read with `Reflect.get`, so an inherited one counts and an absent one reads as\n   * `undefined`, which the guard of an optional property must then accept.\n   */\n  readonly exactOptionalKeys?: Readonly<Record<OptionalKeys<T>, true>>;\n\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 * The keys of an object type that are optional.\n *\n * @typeParam T - The object type.\n */\nexport type OptionalKeys<T extends object> = OptionalKeyMap<T>[keyof T];\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\ntype OptionalKeyMap<T extends object> = {\n  [TKey in keyof T]-?: Partial<Pick<T, TKey>> extends Pick<T, TKey> ? TKey : never;\n};\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`, unless\n * {@link ObjectTypeGuardOptions.exactOptionalKeys} switches the guard to own keys and exact optional properties.\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<T>): TypeGuard<T> {\n  const shouldRejectUnknownKeys = options?.shouldRejectUnknownKeys ?? false;\n  const exactOptionalKeys = options?.exactOptionalKeys;\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    const typeGuards: Readonly<Record<string, TypeGuard<unknown>>> = propertyTypeGuards;\n    for (const [key, typeGuard] of Object.entries(typeGuards)) {\n      if (exactOptionalKeys && !Object.hasOwn(value, key)) {\n        if (Object.hasOwn(exactOptionalKeys, key)) {\n          continue;\n        }\n\n        return false;\n      }\n\n      if (!typeGuard(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;AAuFd,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;AAYO,SAAS,gBAAkC,oBAA2C,SAAmD;AAC9I,QAAM,0BAA0B,SAAS,2BAA2B;AACpE,QAAM,oBAAoB,SAAS;AACnC,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,UAAM,aAA2D;AACjE,eAAW,CAAC,KAAK,SAAS,KAAK,OAAO,QAAQ,UAAU,GAAG;AACzD,UAAI,qBAAqB,CAAC,OAAO,OAAO,OAAO,GAAG,GAAG;AACnD,YAAI,OAAO,OAAO,mBAAmB,GAAG,GAAG;AACzC;AAAA,QACF;AAEA,eAAO;AAAA,MACT;AAEA,UAAI,CAAC,UAAU,QAAQ,IAAI,OAAO,GAAG,CAAC,GAAG;AACvC,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnaoumov/typescript-lib",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Generic TypeScript utilities: async helpers, errors, disposables, strings, paths, debug logging and more, usable in any TypeScript project.",
   "keywords": [
     "typescript",