@mnaoumov/typescript-lib 1.3.0 → 1.5.0

package/README.md

@@ -49,12 +49,15 @@ export const COUNTER_API_CONTRACT = defineApiContract<CounterApi>({
 - `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.
 - `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.
+- `objectGuard<T>({ ... }, { description })` builds an object guard from one such guard per property, expecting `description: { key: expected; ... }`. `optionsGuard<T>` does the same for an all-optional options bag: each guard describes a present option, and an absent or `undefined` one passes.
 - 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.
+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 `{ exactOptionalKeys: { ... } }`, listing every optional key, reads own keys only and refuses an optional key present as `undefined`), 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.
 
+A contract's own test can use `@mnaoumov/typescript-lib/api-contract-verifier`. `verifyApiContract(contract, { cases, vendor })` takes valid and invalid sample payloads for each half of each method and returns every violation it finds: a method the contract and the cases disagree on, a missing schema, a wrong vendor, a valid payload refused or an invalid one accepted. It returns a list rather than asserting, so it works under any test runner: `expect(await verifyApiContract(...)).toEqual([])`. `validateSync(schema, value)` runs a schema that must answer synchronously, and throws when it answers with a promise.
+
 ## License
 
 © [Michael Naumov](https://github.com/mnaoumov/)

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

@@ -0,0 +1,88 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_contract_verifier_exports = {};
+__export(api_contract_verifier_exports, {
+  validateSync: () => validateSync,
+  verifyApiContract: () => verifyApiContract
+});
+module.exports = __toCommonJS(api_contract_verifier_exports);
+function validateSync(schema, value) {
+  const result = schema["~standard"].validate(value);
+  if (result instanceof Promise) {
+    throw new TypeError("Expected a synchronous schema, got one that answers with a promise.");
+  }
+  return result;
+}
+async function verifyApiContract(contract, options) {
+  const violations = [];
+  const looseContract = contract;
+  const cases = options.cases;
+  for (const methodName of Object.keys(looseContract)) {
+    if (!Object.hasOwn(cases, methodName)) {
+      violations.push(`${methodName}: the contract has the method, but no cases are given for it.`);
+    }
+  }
+  for (const [methodName, methodCases] of Object.entries(cases)) {
+    const methodContract = looseContract[methodName];
+    if (methodContract === void 0) {
+      violations.push(`${methodName}: cases are given, but the contract has no such method.`);
+      continue;
+    }
+    for (const half of ["input", "output"]) {
+      const schema = methodContract[half];
+      if (schema === void 0) {
+        violations.push(`${methodName} ${half}: the contract has no schema.`);
+        continue;
+      }
+      const { vendor } = schema["~standard"];
+      const version = schema["~standard"].version;
+      if (vendor !== options.vendor || version !== 1) {
+        violations.push(`${methodName} ${half}: the schema reports vendor '${vendor}' and version ${String(version)}, expected '${options.vendor}' and 1.`);
+      }
+      const { invalid, valid } = methodCases[half];
+      for (const [index, value] of valid.entries()) {
+        const result = await schema["~standard"].validate(value);
+        if (result.issues !== void 0) {
+          violations.push(`${methodName} ${half}: valid case ${String(index)} was refused: ${formatIssues(result.issues)}`);
+        }
+      }
+      for (const [index, value] of invalid.entries()) {
+        const result = await schema["~standard"].validate(value);
+        if (result.issues === void 0 || result.issues.length === 0) {
+          violations.push(`${methodName} ${half}: invalid case ${String(index)} was accepted.`);
+        }
+      }
+    }
+  }
+  return violations;
+}
+function formatIssues(issues) {
+  return issues.map((issue) => issue.message).join(" ");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateSync,
+  verifyApiContract
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/api-contract-verifier.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Checks an {@link ApiContract} against sample payloads, for a contract's own test: every method has both schemas,\n * every schema reports the expected vendor, and each schema accepts every valid payload and refuses every invalid one.\n *\n * It returns what it found rather than asserting, so it runs under any test framework:\n *\n * ```ts\n * expect(await verifyApiContract(MY_API_CONTRACT, { cases, vendor: 'my-plugin' })).toEqual([]);\n * ```\n *\n * It lives apart from `api-contract.ts` because a contract a consumer copies imports that module into its plugin,\n * and nothing here is needed at runtime.\n */\n\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\n\nimport type { ApiContract } from './api-contract.ts';\n\n/**\n * The sample payloads of one method, for each half of its contract.\n */\nexport interface ApiMethodCases {\n  /**\n   * Sample argument lists.\n   */\n  readonly input: PayloadCases;\n\n  /**\n   * Sample return values.\n   */\n  readonly output: PayloadCases;\n}\n\n/**\n * Sample payloads for one schema.\n */\nexport interface PayloadCases {\n  /**\n   * Payloads the schema must refuse.\n   */\n  readonly invalid: readonly unknown[];\n\n  /**\n   * Payloads the schema must accept.\n   */\n  readonly valid: readonly unknown[];\n}\n\n/**\n * Options for {@link verifyApiContract}.\n *\n * @typeParam TContract - The contract.\n */\nexport interface VerifyApiContractOptions<TContract extends ApiContract> {\n  /**\n   * The sample payloads, one entry per method of the contract.\n   */\n  readonly cases: Readonly<Record<keyof TContract & string, ApiMethodCases>>;\n\n  /**\n   * The Standard Schema `vendor` every schema must report.\n   */\n  readonly vendor: string;\n}\n\n/**\n * Runs a Standard Schema that must be synchronous. A schema guarding a call it cannot delay, as a contract's schemas\n * do, has to answer before that call returns.\n *\n * @typeParam TOutput - The type the schema produces.\n * @param schema - The schema.\n * @param value - The value to validate.\n * @returns The schema's result.\n * @throws If the schema answers with a promise.\n */\nexport function validateSync<TOutput>(schema: StandardSchemaV1<unknown, TOutput>, value: unknown): StandardSchemaV1.Result<TOutput> {\n  const result = schema['~standard'].validate(value);\n  if (result instanceof Promise) {\n    throw new TypeError('Expected a synchronous schema, got one that answers with a promise.');\n  }\n\n  return result;\n}\n\n/**\n * Checks a contract against sample payloads: the contract has exactly the methods the cases name, each with both\n * schemas, every schema reports the given vendor and Standard Schema version 1, and each schema accepts every valid\n * payload and refuses every invalid one.\n *\n * @typeParam TContract - The contract.\n * @param contract - The contract.\n * @param options - The sample payloads and the expected vendor.\n * @returns One message per violation, empty when the contract passes.\n */\nexport async function verifyApiContract<TContract extends ApiContract>(contract: TContract, options: VerifyApiContractOptions<TContract>): Promise<string[]> {\n  const violations: string[] = [];\n  const looseContract: ApiContract = contract;\n  const cases: Readonly<Record<string, ApiMethodCases>> = options.cases;\n\n  for (const methodName of Object.keys(looseContract)) {\n    if (!Object.hasOwn(cases, methodName)) {\n      violations.push(`${methodName}: the contract has the method, but no cases are given for it.`);\n    }\n  }\n\n  for (const [methodName, methodCases] of Object.entries(cases)) {\n    const methodContract = looseContract[methodName];\n    if (methodContract === undefined) {\n      violations.push(`${methodName}: cases are given, but the contract has no such method.`);\n      continue;\n    }\n\n    for (const half of ['input', 'output'] as const) {\n      const schema = methodContract[half];\n      if (schema === undefined) {\n        violations.push(`${methodName} ${half}: the contract has no schema.`);\n        continue;\n      }\n\n      // Read as a number: the type says 1, but a schema from another library may speak a later version.\n      const { vendor } = schema['~standard'];\n      const version: number = schema['~standard'].version;\n      if (vendor !== options.vendor || version !== 1) {\n        violations.push(`${methodName} ${half}: the schema reports vendor '${vendor}' and version ${String(version)}, expected '${options.vendor}' and 1.`);\n      }\n\n      const { invalid, valid } = methodCases[half];\n      for (const [index, value] of valid.entries()) {\n        const result = await schema['~standard'].validate(value);\n        if (result.issues !== undefined) {\n          violations.push(`${methodName} ${half}: valid case ${String(index)} was refused: ${formatIssues(result.issues)}`);\n        }\n      }\n\n      for (const [index, value] of invalid.entries()) {\n        const result = await schema['~standard'].validate(value);\n        if (result.issues === undefined || result.issues.length === 0) {\n          violations.push(`${methodName} ${half}: invalid case ${String(index)} was accepted.`);\n        }\n      }\n    }\n  }\n\n  return violations;\n}\n\nfunction formatIssues(issues: readonly StandardSchemaV1.Issue[]): string {\n  return issues.map((issue) => issue.message).join(' ');\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA6EO,SAAS,aAAsB,QAA4C,OAAkD;AAClI,QAAM,SAAS,OAAO,WAAW,EAAE,SAAS,KAAK;AACjD,MAAI,kBAAkB,SAAS;AAC7B,UAAM,IAAI,UAAU,qEAAqE;AAAA,EAC3F;AAEA,SAAO;AACT;AAYA,eAAsB,kBAAiD,UAAqB,SAAiE;AAC3J,QAAM,aAAuB,CAAC;AAC9B,QAAM,gBAA6B;AACnC,QAAM,QAAkD,QAAQ;AAEhE,aAAW,cAAc,OAAO,KAAK,aAAa,GAAG;AACnD,QAAI,CAAC,OAAO,OAAO,OAAO,UAAU,GAAG;AACrC,iBAAW,KAAK,GAAG,UAAU,+DAA+D;AAAA,IAC9F;AAAA,EACF;AAEA,aAAW,CAAC,YAAY,WAAW,KAAK,OAAO,QAAQ,KAAK,GAAG;AAC7D,UAAM,iBAAiB,cAAc,UAAU;AAC/C,QAAI,mBAAmB,QAAW;AAChC,iBAAW,KAAK,GAAG,UAAU,yDAAyD;AACtF;AAAA,IACF;AAEA,eAAW,QAAQ,CAAC,SAAS,QAAQ,GAAY;AAC/C,YAAM,SAAS,eAAe,IAAI;AAClC,UAAI,WAAW,QAAW;AACxB,mBAAW,KAAK,GAAG,UAAU,IAAI,IAAI,+BAA+B;AACpE;AAAA,MACF;AAGA,YAAM,EAAE,OAAO,IAAI,OAAO,WAAW;AACrC,YAAM,UAAkB,OAAO,WAAW,EAAE;AAC5C,UAAI,WAAW,QAAQ,UAAU,YAAY,GAAG;AAC9C,mBAAW,KAAK,GAAG,UAAU,IAAI,IAAI,gCAAgC,MAAM,iBAAiB,OAAO,OAAO,CAAC,eAAe,QAAQ,MAAM,UAAU;AAAA,MACpJ;AAEA,YAAM,EAAE,SAAS,MAAM,IAAI,YAAY,IAAI;AAC3C,iBAAW,CAAC,OAAO,KAAK,KAAK,MAAM,QAAQ,GAAG;AAC5C,cAAM,SAAS,MAAM,OAAO,WAAW,EAAE,SAAS,KAAK;AACvD,YAAI,OAAO,WAAW,QAAW;AAC/B,qBAAW,KAAK,GAAG,UAAU,IAAI,IAAI,gBAAgB,OAAO,KAAK,CAAC,iBAAiB,aAAa,OAAO,MAAM,CAAC,EAAE;AAAA,QAClH;AAAA,MACF;AAEA,iBAAW,CAAC,OAAO,KAAK,KAAK,QAAQ,QAAQ,GAAG;AAC9C,cAAM,SAAS,MAAM,OAAO,WAAW,EAAE,SAAS,KAAK;AACvD,YAAI,OAAO,WAAW,UAAa,OAAO,OAAO,WAAW,GAAG;AAC7D,qBAAW,KAAK,GAAG,UAAU,IAAI,IAAI,kBAAkB,OAAO,KAAK,CAAC,gBAAgB;AAAA,QACtF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAEA,SAAS,aAAa,QAAmD;AACvE,SAAO,OAAO,IAAI,CAAC,UAAU,MAAM,OAAO,EAAE,KAAK,GAAG;AACtD;",
  "names": []
}


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

@@ -0,0 +1,81 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * Checks an {@link ApiContract} against sample payloads, for a contract's own test: every method has both schemas,
+ * every schema reports the expected vendor, and each schema accepts every valid payload and refuses every invalid one.
+ *
+ * It returns what it found rather than asserting, so it runs under any test framework:
+ *
+ * ```ts
+ * expect(await verifyApiContract(MY_API_CONTRACT, { cases, vendor: 'my-plugin' })).toEqual([]);
+ * ```
+ *
+ * It lives apart from `api-contract.ts` because a contract a consumer copies imports that module into its plugin,
+ * and nothing here is needed at runtime.
+ */
+import type { StandardSchemaV1 } from '@standard-schema/spec' with { 'resolution-mode': 'import' };
+import type { ApiContract } from './api-contract.cjs';
+/**
+ * The sample payloads of one method, for each half of its contract.
+ */
+export interface ApiMethodCases {
+    /**
+     * Sample argument lists.
+     */
+    readonly input: PayloadCases;
+    /**
+     * Sample return values.
+     */
+    readonly output: PayloadCases;
+}
+/**
+ * Sample payloads for one schema.
+ */
+export interface PayloadCases {
+    /**
+     * Payloads the schema must refuse.
+     */
+    readonly invalid: readonly unknown[];
+    /**
+     * Payloads the schema must accept.
+     */
+    readonly valid: readonly unknown[];
+}
+/**
+ * Options for {@link verifyApiContract}.
+ *
+ * @typeParam TContract - The contract.
+ */
+export interface VerifyApiContractOptions<TContract extends ApiContract> {
+    /**
+     * The sample payloads, one entry per method of the contract.
+     */
+    readonly cases: Readonly<Record<keyof TContract & string, ApiMethodCases>>;
+    /**
+     * The Standard Schema `vendor` every schema must report.
+     */
+    readonly vendor: string;
+}
+/**
+ * Runs a Standard Schema that must be synchronous. A schema guarding a call it cannot delay, as a contract's schemas
+ * do, has to answer before that call returns.
+ *
+ * @typeParam TOutput - The type the schema produces.
+ * @param schema - The schema.
+ * @param value - The value to validate.
+ * @returns The schema's result.
+ * @throws If the schema answers with a promise.
+ */
+export declare function validateSync<TOutput>(schema: StandardSchemaV1<unknown, TOutput>, value: unknown): StandardSchemaV1.Result<TOutput>;
+/**
+ * Checks a contract against sample payloads: the contract has exactly the methods the cases name, each with both
+ * schemas, every schema reports the given vendor and Standard Schema version 1, and each schema accepts every valid
+ * payload and refuses every invalid one.
+ *
+ * @typeParam TContract - The contract.
+ * @param contract - The contract.
+ * @param options - The sample payloads and the expected vendor.
+ * @returns One message per violation, empty when the contract passes.
+ */
+export declare function verifyApiContract<TContract extends ApiContract>(contract: TContract, options: VerifyApiContractOptions<TContract>): Promise<string[]>;

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

@@ -37,7 +37,9 @@ __export(api_contract_exports, {
   instanceOfGuard: () => instanceOfGuard,
   literalGuard: () => literalGuard,
   nullableGuard: () => nullableGuard,
+  objectGuard: () => objectGuard,
   optionalGuard: () => optionalGuard,
+  optionsGuard: () => optionsGuard,
   unionGuard: () => unionGuard
 });
 module.exports = __toCommonJS(api_contract_exports);
@@ -96,12 +98,29 @@ function nullableGuard(guard) {
     typeGuard: (value) => value === null || guard.typeGuard(value)
   };
 }
+function objectGuard(propertyGuards, options) {
+  const guards = (0, import_object_utils.castTo)(propertyGuards);
+  const exactOptionalKeys = options?.exactOptionalKeys ?? {};
+  return createExpectedTypeGuard(
+    describeObject(options?.description, guards, (key) => Object.hasOwn(exactOptionalKeys, key)),
+    (0, import_type_guards.objectTypeGuard)((0, import_object_utils.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 = (0, import_object_utils.castTo)(optionGuards);
+  return createExpectedTypeGuard(
+    describeObject(options?.description, guards, () => true),
+    (0, import_type_guards.objectTypeGuard)((0, import_object_utils.castTo)(mapGuards(guards, (guard) => (0, import_type_guards.optionalTypeGuard)(guard.typeGuard))), {
+      shouldRejectUnknownKeys: options?.shouldRejectUnknownKeys ?? false
+    })
+  );
+}
 function unionGuard(...guards) {
   return createExpectedTypeGuard(
     guards.map((guard) => guard.expected).join(" or "),
@@ -117,6 +136,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 ((0, import_type_guards.isString)(literal)) {
     return `'${literal}'`;
@@ -126,6 +150,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)]));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BOOLEAN_GUARD,
@@ -142,7 +169,9 @@ function isReadonlyArray(value) {
   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/cjs/api-contract.d.cts

@@ -14,7 +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';
+import type { GuardedType, Literal, ObjectTypeGuardOptions, 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.
@@ -126,6 +126,52 @@ export interface ExpectedTypeGuard<T> {
      */
     readonly typeGuard: (value: unknown) => value is T;
 }
+/**
+ * Options for {@link objectGuard}.
+ *
+ * @typeParam T - The object type the guard narrows to.
+ */
+export interface ObjectGuardOptions<T extends object> extends ObjectTypeGuardOptions<T> {
+    /**
+     * What the object is, put before its properties in `expected`, e.g. `'the options of the link'`.
+     */
+    readonly description?: string;
+}
+/**
+ * One guard per option of an all-optional object type, as {@link optionsGuard} takes them: each describes a
+ * PRESENT option, so it does not accept `undefined`. A required property of `T` takes `never`, so a type that is
+ * not all-optional does not compile.
+ *
+ * @typeParam T - The object type.
+ */
+export type OptionGuards<T extends object> = {
+    readonly [TKey in keyof T]-?: Partial<Pick<T, TKey>> extends Pick<T, TKey> ? ExpectedTypeGuard<Exclude<T[TKey], undefined>> : never;
+};
+/**
+ * Options for {@link optionsGuard}.
+ */
+export interface OptionsGuardOptions {
+    /**
+     * What the options are, put before them in `expected`, e.g. `'select options'`.
+     */
+    readonly description?: string;
+    /**
+     * Whether a value carrying an own enumerable string key that no option guard names is refused. Letting it through,
+     * the default, lets a consumer compiled against a later version of the options pass one this version does not know.
+     *
+     * @default `false`
+     */
+    readonly shouldRejectUnknownKeys?: boolean;
+}
+/**
+ * One guard per property of an object type, as {@link objectGuard} takes them, typed as {@link PropertyTypeGuards}
+ * types the bare guards.
+ *
+ * @typeParam T - The object type.
+ */
+export type PropertyGuards<T extends object> = {
+    readonly [TKey in keyof T]-?: ExpectedTypeGuard<Partial<Pick<T, TKey>> extends Pick<T, TKey> ? T[TKey] | undefined : T[TKey]>;
+};
 /**
  * The {@link ApiContract} of a named API: one entry per function member, each typed against that member. Both
  * schemas are REQUIRED here, so a typed contract is a full description of every signature and a `{}` entry does
@@ -251,6 +297,19 @@ export declare function literalGuard<T extends Literal>(literals: readonly T[]):
  * @returns A guard accepting what `guard` accepts, or `null`.
  */
 export declare function nullableGuard<T>(guard: ExpectedTypeGuard<T>): ExpectedTypeGuard<null | T>;
+/**
+ * Builds a guard accepting an object whose every listed property its guard accepts, as {@link objectTypeGuard} does,
+ * expecting the properties and what each expects: `{ alias?: a string; path: a string }`, after the
+ * {@link ObjectGuardOptions.description} when one is given. A key is marked optional when it is listed in
+ * {@link ObjectTypeGuardOptions.exactOptionalKeys}; without that list, an optional property's guard says
+ * `or undefined` itself.
+ *
+ * @typeParam T - The object type.
+ * @param propertyGuards - One guard per property of `T`.
+ * @param options - The options for the guard.
+ * @returns The guard.
+ */
+export declare function objectGuard<T extends object>(propertyGuards: PropertyGuards<T>, options?: ObjectGuardOptions<T>): ExpectedTypeGuard<T>;
 /**
  * Widens a guard to also accept `undefined`, which is what an optional parameter receives when it is left out.
  *
@@ -259,6 +318,18 @@ 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 an options bag: an object whose every option may be absent, or `undefined`, and must
+ * otherwise pass its guard. A key no guard names is let through unless
+ * {@link OptionsGuardOptions.shouldRejectUnknownKeys} is set. It expects the options and what each expects:
+ * `{ prefix?: a string; isHidden?: a boolean }`, after the {@link OptionsGuardOptions.description} when one is given.
+ *
+ * @typeParam T - The options type, every property of which is optional.
+ * @param optionGuards - One guard per option of `T`, for a present value.
+ * @param options - The options for the guard.
+ * @returns The guard.
+ */
+export declare function optionsGuard<T extends object>(optionGuards: OptionGuards<T>, options?: OptionsGuardOptions): ExpectedTypeGuard<T>;
 /**
  * Builds a guard accepting what any of the given guards accepts, expecting their `expected` texts joined by `or`.
  *