@mnaoumov/typescript-lib 1.2.0 → 1.3.0

package/README.md

@@ -48,7 +48,10 @@ export const COUNTER_API_CONTRACT = defineApiContract<CounterApi>({
 - `createArgumentsSchema(guards, { vendor })` validates an argument list: one guard per parameter, issues carrying the argument index, too many arguments refused.
 - `createTypeGuardSchema({ expected, typeGuard, vendor })` validates one value.
 - `BOOLEAN_GUARD`, `NUMBER_GUARD`, `STRING_GUARD`, `STRING_ARRAY_GUARD` and `UNDEFINED_GUARD` are ready-made guards, `optionalGuard` and `nullableGuard` widen one, and a spread renames what it expects.
-- The schema `vendor` defaults to `@mnaoumov/typescript-lib`.
+- `arrayGuard`, `literalGuard`, `unionGuard` and `instanceOfGuard` build a guard together with what it expects, and `createExpectedTypeGuard(expected, typeGuard)` pairs any other type guard with its text.
+- The schema `vendor` defaults to `@mnaoumov/typescript-lib`. `createApiContractSchemaBuilders(vendor)` binds it once: destructure `createArgumentsSchema` and `createTypeGuardSchema` from it, and no call passes the vendor again.
+
+The guards for an API's own shapes come from `@mnaoumov/typescript-lib/type-guards`, whose combinators work on bare type guards: `objectTypeGuard<T>({ ... })` takes one guard per property of `T` and none may be missing (`{ shouldRejectUnknownKeys: true }` refuses extra keys), and `arrayTypeGuard`, `literalTypeGuard`, `unionTypeGuard`, `optionalTypeGuard`, `nullableTypeGuard`, `instanceOfTypeGuard` and `functionTypeGuard` build the rest. A name ending in `TypeGuard` returns a bare type guard; the `api-contract` name without `Type` returns the same guard paired with its `expected` text.
 
 Running the schemas belongs to whoever owns the call path. `@mnaoumov/obsidian-lib`'s plugin API registry runs them while its debugger is on.
 

package/dist/lib/cjs/api-contract.cjs

@@ -28,11 +28,17 @@ __export(api_contract_exports, {
   STRING_ARRAY_GUARD: () => STRING_ARRAY_GUARD,
   STRING_GUARD: () => STRING_GUARD,
   UNDEFINED_GUARD: () => UNDEFINED_GUARD,
+  arrayGuard: () => arrayGuard,
+  createApiContractSchemaBuilders: () => createApiContractSchemaBuilders,
   createArgumentsSchema: () => createArgumentsSchema,
+  createExpectedTypeGuard: () => createExpectedTypeGuard,
   createTypeGuardSchema: () => createTypeGuardSchema,
   defineApiContract: () => defineApiContract,
+  instanceOfGuard: () => instanceOfGuard,
+  literalGuard: () => literalGuard,
   nullableGuard: () => nullableGuard,
-  optionalGuard: () => optionalGuard
+  optionalGuard: () => optionalGuard,
+  unionGuard: () => unionGuard
 });
 module.exports = __toCommonJS(api_contract_exports);
 var import_library = require('./library.cjs');
@@ -43,6 +49,15 @@ const NUMBER_GUARD = { expected: "a number", typeGuard: import_type_guards.isNum
 const STRING_GUARD = { expected: "a string", typeGuard: import_type_guards.isString };
 const STRING_ARRAY_GUARD = { expected: "an array of strings", typeGuard: import_type_guards.isStringArray };
 const UNDEFINED_GUARD = { expected: "undefined", typeGuard: import_type_guards.isUndefined };
+function arrayGuard(itemGuard) {
+  return createExpectedTypeGuard(`an array whose every item is ${itemGuard.expected}`, (0, import_type_guards.arrayTypeGuard)(itemGuard.typeGuard));
+}
+function createApiContractSchemaBuilders(vendor) {
+  return {
+    createArgumentsSchema: (parameters) => createArgumentsSchema(parameters, { vendor }),
+    createTypeGuardSchema: (guard) => createTypeGuardSchema({ ...guard, vendor })
+  };
+}
 function createArgumentsSchema(parameters, options) {
   const parameterList = (0, import_object_utils.castTo)(parameters);
   return createSchema((value) => {
@@ -56,6 +71,9 @@ function createArgumentsSchema(parameters, options) {
     return issues.length === 0 ? { value: (0, import_object_utils.castTo)(value) } : { issues };
   }, options?.vendor);
 }
+function createExpectedTypeGuard(expected, typeGuard) {
+  return { expected, typeGuard };
+}
 function createTypeGuardSchema(params) {
   return createSchema(
     (value) => params.typeGuard(value) ? { value } : { issues: [{ message: `Expected ${params.expected}.` }] },
@@ -65,6 +83,13 @@ function createTypeGuardSchema(params) {
 function defineApiContract(contract) {
   return contract;
 }
+function instanceOfGuard(constructor) {
+  return createExpectedTypeGuard(`an instance of ${constructor.name}`, (0, import_type_guards.instanceOfTypeGuard)(constructor));
+}
+function literalGuard(literals) {
+  const literalList = isReadonlyArray(literals) ? literals : Object.keys(literals);
+  return createExpectedTypeGuard(`one of ${literalList.map((literal) => formatLiteral(literal)).join(", ")}`, (0, import_type_guards.literalTypeGuard)(literalList));
+}
 function nullableGuard(guard) {
   return {
     expected: `${guard.expected} or null`,
@@ -77,6 +102,12 @@ function optionalGuard(guard) {
     typeGuard: (value) => value === void 0 || guard.typeGuard(value)
   };
 }
+function unionGuard(...guards) {
+  return createExpectedTypeGuard(
+    guards.map((guard) => guard.expected).join(" or "),
+    (0, import_type_guards.unionTypeGuard)(...guards.map((guard) => guard.typeGuard))
+  );
+}
 function createSchema(validate, vendor) {
   return {
     "~standard": {
@@ -86,6 +117,15 @@ function createSchema(validate, vendor) {
     }
   };
 }
+function formatLiteral(literal) {
+  if ((0, import_type_guards.isString)(literal)) {
+    return `'${literal}'`;
+  }
+  return typeof literal === "bigint" ? `${String(literal)}n` : String(literal);
+}
+function isReadonlyArray(value) {
+  return Array.isArray(value);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BOOLEAN_GUARD,
@@ -93,10 +133,16 @@ function createSchema(validate, vendor) {
   STRING_ARRAY_GUARD,
   STRING_GUARD,
   UNDEFINED_GUARD,
+  arrayGuard,
+  createApiContractSchemaBuilders,
   createArgumentsSchema,
+  createExpectedTypeGuard,
   createTypeGuardSchema,
   defineApiContract,
+  instanceOfGuard,
+  literalGuard,
   nullableGuard,
-  optionalGuard
+  optionalGuard,
+  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 { LIBRARY_NAME } from './library.ts';\nimport { castTo } from './object-utils.ts';\nimport {\n  isBoolean,\n  isNumber,\n  isString,\n  isStringArray,\n  isUndefined\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 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 * 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 * 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 * 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\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"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,qBAA6B;AAC7B,0BAAuB;AACvB,yBAMO;AAsHA,MAAM,gBAA4C,EAAE,UAAU,aAAa,WAAW,6BAAU;AAKhG,MAAM,eAA0C,EAAE,UAAU,YAAY,WAAW,4BAAS;AAK5F,MAAM,eAA0C,EAAE,UAAU,YAAY,WAAW,4BAAS;AAK5F,MAAM,qBAAkD,EAAE,UAAU,uBAAuB,WAAW,iCAAc;AAKpH,MAAM,kBAAgD,EAAE,UAAU,aAAa,WAAW,+BAAY;AAatG,SAAS,sBACd,YACA,SACsD;AACtD,QAAM,oBAAgB,4BAA8C,UAAU;AAC9E,SAAO,aAAa,CAAC,UAAuE;AAC1F,QAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACzB,aAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,6BAA6B,CAAC,EAAE;AAAA,IAC/D;AAEA,QAAI,MAAM,SAAS,cAAc,QAAQ;AACvC,aAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,oBAAoB,OAAO,cAAc,MAAM,CAAC,qBAAqB,OAAO,MAAM,MAAM,CAAC,IAAI,CAAC,EAAE;AAAA,IAC/H;AAEA,UAAM,SAAS,cAAc,QAAQ,CAAC,WAAW,UAAoC,UAAU,UAAU,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,SAAS,YAAY,UAAU,QAAQ,KAAK,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;AAC7L,WAAO,OAAO,WAAW,IAAI,EAAE,WAAO,4BAAkC,KAAK,EAAE,IAAI,EAAE,OAAO;AAAA,EAC9F,GAAG,SAAS,MAAM;AACpB;AASO,SAAS,sBAAyB,QAAsE;AAC7G,SAAO;AAAA,IACL,CAAC,UAA+C,OAAO,UAAU,KAAK,IAAI,EAAE,MAAM,IAAI,EAAE,QAAQ,CAAC,EAAE,SAAS,YAAY,OAAO,QAAQ,IAAI,CAAC,EAAE;AAAA,IAC9I,OAAO;AAAA,EACT;AACF;AAUO,SAAS,kBAAuC,UAAmE;AACxH,SAAO;AACT;AASO,SAAS,cAAiB,OAA0D;AACzF,SAAO;AAAA,IACL,UAAU,GAAG,MAAM,QAAQ;AAAA,IAC3B,WAAW,CAAC,UAAsC,UAAU,QAAQ,MAAM,UAAU,KAAK;AAAA,EAC3F;AACF;AASO,SAAS,cAAiB,OAA+D;AAC9F,SAAO;AAAA,IACL,UAAU,GAAG,MAAM,QAAQ;AAAA,IAC3B,WAAW,CAAC,UAA2C,UAAU,UAAa,MAAM,UAAU,KAAK;AAAA,EACrG;AACF;AAEA,SAAS,aAAgB,UAA0D,QAA0D;AAC3I,SAAO;AAAA,IACL,aAAa;AAAA,MACX;AAAA,MACA,QAAQ,UAAU;AAAA,MAClB,SAAS;AAAA,IACX;AAAA,EACF;AACF;",
  "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  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": []
}


package/dist/lib/cjs/api-contract.d.cts

@@ -14,6 +14,7 @@
  * Running the schemas is left to whoever owns the call path, since that is where an issue can be reported.
  */
 import type { StandardSchemaV1 } from '@standard-schema/spec' with { 'resolution-mode': 'import' };
+import type { GuardedType, Literal, TypeGuard } from './type-guards.cjs';
 /**
  * The contract an API declares: every key is a method the API promises to expose, and its value optionally
  * carries the payload schemas for that method.
@@ -26,6 +27,28 @@ import type { StandardSchemaV1 } from '@standard-schema/spec' with { 'resolution
  * @typeParam TApi - The API the contract describes. `object`, the default, means "not typed".
  */
 export type ApiContract<TApi extends object = object> = object extends TApi ? Readonly<Record<string, ApiMethodContract>> : TypedApiContract<TApi>;
+/**
+ * The schema builders of this module with the Standard Schema `vendor` already bound, as
+ * {@link createApiContractSchemaBuilders} returns them.
+ */
+export interface ApiContractSchemaBuilders {
+    /**
+     * {@link createArgumentsSchema}, reporting the bound vendor.
+     *
+     * @typeParam TParameters - The method's parameters, inferred from the guards or from the contract entry.
+     * @param parameters - One guard per parameter, in order.
+     * @returns The schema.
+     */
+    readonly createArgumentsSchema: <const TParameters extends readonly unknown[]>(parameters: ArgumentTypeGuards<TParameters>) => StandardSchemaV1<unknown, MutableTuple<TParameters>>;
+    /**
+     * {@link createTypeGuardSchema}, reporting the bound vendor.
+     *
+     * @typeParam T - The type the guard narrows to.
+     * @param guard - The guard and what it expects.
+     * @returns The schema.
+     */
+    readonly createTypeGuardSchema: <T>(guard: ExpectedTypeGuard<T>) => StandardSchemaV1<unknown, T>;
+}
 /**
  * The payload schemas for a single API method. Both halves are optional: a method may declare only its input,
  * only its output, neither (the entry then just declares that the method must exist), or both.
@@ -136,6 +159,26 @@ export declare const STRING_ARRAY_GUARD: ExpectedTypeGuard<string[]>;
  * Accepts `undefined`, which is the output of a method returning `void` or `Promise<void>`.
  */
 export declare const UNDEFINED_GUARD: ExpectedTypeGuard<undefined>;
+/**
+ * Widens a guard to an array whose every item `itemGuard` accepts.
+ *
+ * @typeParam T - The type of an item.
+ * @param itemGuard - The guard for one item.
+ * @returns The guard.
+ */
+export declare function arrayGuard<T>(itemGuard: ExpectedTypeGuard<T>): ExpectedTypeGuard<T[]>;
+/**
+ * Binds the Standard Schema `vendor` once, so a contract does not pass it to every schema builder. Destructure the
+ * result under the builders' own names and the calls read exactly as the unbound ones do:
+ *
+ * ```ts
+ * const { createArgumentsSchema, createTypeGuardSchema } = createApiContractSchemaBuilders('my-plugin');
+ * ```
+ *
+ * @param vendor - The vendor every schema reports.
+ * @returns The bound builders.
+ */
+export declare function createApiContractSchemaBuilders(vendor: string): ApiContractSchemaBuilders;
 /**
  * Builds the input schema of a method contract: a schema over the method's ARGUMENT LIST, one type guard per
  * parameter. An argument that fails its guard is reported with its index as the issue path, and an argument list
@@ -148,6 +191,15 @@ export declare const UNDEFINED_GUARD: ExpectedTypeGuard<undefined>;
  * @returns The schema.
  */
 export declare function createArgumentsSchema<const TParameters extends readonly unknown[]>(parameters: ArgumentTypeGuards<TParameters>, options?: CreateArgumentsSchemaOptions): StandardSchemaV1<unknown, MutableTuple<TParameters>>;
+/**
+ * Pairs a type guard with what it expects.
+ *
+ * @typeParam T - The type the guard narrows to.
+ * @param expected - What the value should have been, phrased to follow "Expected", e.g. `'a string'`.
+ * @param typeGuard - The guard.
+ * @returns The guard.
+ */
+export declare function createExpectedTypeGuard<T>(expected: string, typeGuard: TypeGuard<T>): ExpectedTypeGuard<T>;
 /**
  * Builds a schema over one value from a type guard: the output schema of a method contract, typically.
  *
@@ -165,6 +217,32 @@ export declare function createTypeGuardSchema<T>(params: CreateTypeGuardSchemaPa
  * @returns The same contract.
  */
 export declare function defineApiContract<TApi extends object>(contract: TypedApiContract<NoInfer<TApi>>): TypedApiContract<TApi>;
+/**
+ * Builds a guard accepting an instance of a class, or of a class derived from it, expecting `an instance of` the
+ * class's name.
+ *
+ * @typeParam T - The type of an instance.
+ * @param constructor - The class.
+ * @returns The guard.
+ */
+export declare function instanceOfGuard<T>(constructor: abstract new (...arguments_: never[]) => T): ExpectedTypeGuard<T>;
+/**
+ * Builds a guard accepting exactly the keys of a record, expecting `one of` them. Typing the record over a union
+ * 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 literalGuard<T extends string>(literals: Readonly<Record<T, true>>): ExpectedTypeGuard<T>;
+/**
+ * Builds a guard accepting exactly the listed values, expecting `one of` them.
+ *
+ * @typeParam T - The accepted values.
+ * @param literals - The accepted values.
+ * @returns The guard.
+ */
+export declare function literalGuard<T extends Literal>(literals: readonly T[]): ExpectedTypeGuard<T>;
 /**
  * Widens a guard to also accept `null`.
  *
@@ -181,4 +259,12 @@ export declare function nullableGuard<T>(guard: ExpectedTypeGuard<T>): ExpectedT
  * @returns A guard accepting what `guard` accepts, or `undefined`.
  */
 export declare function optionalGuard<T>(guard: ExpectedTypeGuard<T>): ExpectedTypeGuard<T | undefined>;
+/**
+ * Builds a guard accepting what any of the given guards accepts, expecting their `expected` texts joined by `or`.
+ *
+ * @typeParam TGuards - The guards.
+ * @param guards - The guards, tried in order.
+ * @returns The guard.
+ */
+export declare function unionGuard<const TGuards extends readonly ExpectedTypeGuard<unknown>[]>(...guards: TGuards): ExpectedTypeGuard<GuardedType<TGuards[number]['typeGuard']>>;
 export {};

package/dist/lib/cjs/type-guards.cjs

@@ -23,20 +23,34 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var type_guards_exports = {};
 __export(type_guards_exports, {
+  arrayTypeGuard: () => arrayTypeGuard,
   assert: () => assert,
   assertGenericObject: () => assertGenericObject,
   assertNever: () => assertNever,
   assertNonNullable: () => assertNonNullable,
   ensureGenericObject: () => ensureGenericObject,
   ensureNonNullable: () => ensureNonNullable,
+  functionTypeGuard: () => functionTypeGuard,
+  instanceOfTypeGuard: () => instanceOfTypeGuard,
   isBoolean: () => isBoolean,
+  isFunction: () => isFunction,
+  isNull: () => isNull,
   isNumber: () => isNumber,
+  isObject: () => isObject,
   isString: () => isString,
   isStringArray: () => isStringArray,
-  isUndefined: () => isUndefined
+  isUndefined: () => isUndefined,
+  literalTypeGuard: () => literalTypeGuard,
+  nullableTypeGuard: () => nullableTypeGuard,
+  objectTypeGuard: () => objectTypeGuard,
+  optionalTypeGuard: () => optionalTypeGuard,
+  unionTypeGuard: () => unionTypeGuard
 });
 module.exports = __toCommonJS(type_guards_exports);
 var import_function = require('./function.cjs');
+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;
@@ -63,12 +77,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";
 }
@@ -78,18 +107,65 @@ 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);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  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": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,sBAAqB;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,4BAAK;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": "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",
  "names": []
}
