{"version":3,"file":"functional.mjs","names":[],"sources":["../src/functional.ts"],"sourcesContent":["import { IValidation } from \"@typia/interface\";\n\nimport { TypeGuardError } from \"./TypeGuardError\";\nimport { NoTransformConfigurationError } from \"./transformers/NoTransformConfigurationError\";\n\ntype FunctionalIs<T extends (...args: any[]) => any> = T extends (\n  this: infer This,\n  ...args: infer Arguments\n) => infer Output\n  ? Output extends Promise<infer R>\n    ? (this: This, ...args: Arguments) => Promise<R | null>\n    : (this: This, ...args: Arguments) => Output | null\n  : never;\n\ntype FunctionalValidate<T extends (...args: any[]) => any> = T extends (\n  this: infer This,\n  ...args: infer Arguments\n) => infer Output\n  ? Output extends Promise<infer R>\n    ? (this: This, ...args: Arguments) => Promise<IValidation<R>>\n    : (this: This, ...args: Arguments) => IValidation<Output>\n  : never;\n\n/* ===========================================================\n  FUNCTIONAL\n    - ASSERT\n    - IS\n    - VALIDATE\n==============================================================\n  ASSERT\n----------------------------------------------------------- */\n/**\n * Wraps function to assert both parameters and return value.\n *\n * Wraps the target function and validates all parameters before calling and\n * return value after calling through {@link assert}. Throws on first mismatch.\n *\n * Error path format:\n *\n * - Parameter errors: `$input.parameters[0].property`\n * - Return errors: `$input.return.property`\n *\n * Related functions:\n *\n * - {@link assertParameters} — Validates parameters only\n * - {@link assertReturn} — Validates return value only\n * - {@link validateFunction} — Collects all errors instead of throwing\n * - {@link assertEqualsFunction} — Also rejects extra properties\n *\n * @template T Target function type\n * @param func Function to wrap\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Wrapped function with same signature\n * @throws {TypeGuardError} When parameter or return value type mismatch\n */\nexport function assertFunction<T extends (...args: any[]) => any>(\n  func: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assertFunction(): never {\n  NoTransformConfigurationError(\"functional.assertFunction\");\n}\n\n/**\n * Wraps function to assert parameters only.\n *\n * Wraps the target function and validates all parameters before calling through\n * {@link assert}. Return value is not validated. Throws on first mismatch.\n *\n * Error path format: `$input.parameters[0].property`\n *\n * Related functions:\n *\n * - {@link assertFunction} — Also validates return value\n * - {@link assertReturn} — Validates return value only\n * - {@link validateParameters} — Collects all errors instead of throwing\n * - {@link assertEqualsParameters} — Also rejects extra properties\n *\n * @template T Target function type\n * @param func Function to wrap\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Wrapped function with same signature\n * @throws {TypeGuardError} When parameter type mismatch\n */\nexport function assertParameters<T extends (...args: any[]) => any>(\n  func: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assertParameters(): never {\n  NoTransformConfigurationError(\"functional.assertParameters\");\n}\n\n/**\n * Wraps function to assert return value only.\n *\n * Wraps the target function and validates return value after calling through\n * {@link assert}. Parameters are not validated. Throws on mismatch.\n *\n * Error path format: `$input.return.property`\n *\n * Related functions:\n *\n * - {@link assertFunction} — Also validates parameters\n * - {@link assertParameters} — Validates parameters only\n * - {@link validateReturn} — Collects all errors instead of throwing\n * - {@link assertEqualsReturn} — Also rejects extra properties\n *\n * @template T Target function type\n * @param func Function to wrap\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Wrapped function with same signature\n * @throws {TypeGuardError} When return value type mismatch\n */\nexport function assertReturn<T extends (...args: any[]) => any>(\n  func: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assertReturn(): never {\n  NoTransformConfigurationError(\"functional.assertReturn\");\n}\n\n/**\n * Wraps function to assert parameters and return value with strict equality.\n *\n * Wraps the target function and validates through {@link assertEquals}. Also\n * rejects extra properties not defined in type. Throws on first mismatch.\n *\n * Error path format:\n *\n * - Parameter errors: `$input.parameters[0].property`\n * - Return errors: `$input.return.property`\n *\n * Related functions:\n *\n * - {@link assertFunction} — Allows extra properties\n * - {@link assertEqualsParameters} — Validates parameters only\n * - {@link assertEqualsReturn} — Validates return value only\n * - {@link validateEqualsFunction} — Collects all errors instead of throwing\n *\n * @template T Target function type\n * @param func Function to wrap\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Wrapped function with same signature\n * @throws {TypeGuardError} When type mismatch or extra property detected\n */\nexport function assertEqualsFunction<T extends (...args: any[]) => any>(\n  func: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assertEqualsFunction(): never {\n  NoTransformConfigurationError(\"functional.assertEqualsFunction\");\n}\n\n/**\n * Wraps function to assert parameters with strict equality.\n *\n * Wraps the target function and validates parameters through\n * {@link assertEquals}. Also rejects extra properties. Return value is not\n * validated.\n *\n * Error path format: `$input.parameters[0].property`\n *\n * Related functions:\n *\n * - {@link assertParameters} — Allows extra properties\n * - {@link assertEqualsFunction} — Also validates return value\n * - {@link validateEqualsParameters} — Collects all errors instead of throwing\n *\n * @template T Target function type\n * @param func Function to wrap\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Wrapped function with same signature\n * @throws {TypeGuardError} When type mismatch or extra property detected\n */\nexport function assertEqualsParameters<T extends (...args: any[]) => any>(\n  func: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assertEqualsParameters(): never {\n  NoTransformConfigurationError(\"functional.assertEqualsParameters\");\n}\n\n/**\n * Wraps function to assert return value with strict equality.\n *\n * Wraps the target function and validates return value through\n * {@link assertEquals}. Also rejects extra properties. Parameters are not\n * validated.\n *\n * Error path format: `$input.return.property`\n *\n * Related functions:\n *\n * - {@link assertReturn} — Allows extra properties\n * - {@link assertEqualsFunction} — Also validates parameters\n * - {@link validateEqualsReturn} — Collects all errors instead of throwing\n *\n * @template T Target function type\n * @param func Function to wrap\n * @param errorFactory Custom error factory receiving\n *   {@link TypeGuardError.IProps}\n * @returns Wrapped function with same signature\n * @throws {TypeGuardError} When type mismatch or extra property detected\n */\nexport function assertEqualsReturn<T extends (...args: any[]) => any>(\n  func: T,\n  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),\n): T;\n\n/** @internal */\nexport function assertEqualsReturn(): never {\n  NoTransformConfigurationError(\"functional.assertEqualsReturn\");\n}\n\n/* -----------------------------------------------------------\n  IS\n----------------------------------------------------------- */\n/**\n * Wraps function to test both parameters and return value.\n *\n * Wraps the target function and checks all parameters before calling and return\n * value after calling through {@link is}. Returns `null` on mismatch.\n *\n * Related functions:\n *\n * - {@link isParameters} — Tests parameters only\n * - {@link isReturn} — Tests return value only\n * - {@link assertFunction} — Throws with error details on mismatch\n * - {@link validateFunction} — Returns all error details\n * - {@link equalsFunction} — Also rejects extra properties\n *\n * @template T Target function type\n * @param func Function to wrap\n * @returns Wrapped function returning `Output | null`\n */\nexport function isFunction<T extends (...args: any[]) => any>(\n  func: T,\n): FunctionalIs<T>;\n\n/** @internal */\nexport function isFunction(): never {\n  NoTransformConfigurationError(\"functional.isFunction\");\n}\n\n/**\n * Wraps function to test parameters only.\n *\n * Wraps the target function and checks all parameters before calling through\n * {@link is}. Return value is not checked. Returns `null` on mismatch.\n *\n * Related functions:\n *\n * - {@link isFunction} — Also tests return value\n * - {@link isReturn} — Tests return value only\n * - {@link assertParameters} — Throws with error details\n * - {@link validateParameters} — Returns all error details\n * - {@link equalsParameters} — Also rejects extra properties\n *\n * @template T Target function type\n * @param func Function to wrap\n * @returns Wrapped function returning `Output | null`\n */\nexport function isParameters<T extends (...args: any[]) => any>(\n  func: T,\n): FunctionalIs<T>;\n\n/** @internal */\nexport function isParameters(): never {\n  NoTransformConfigurationError(\"functional.isParameters\");\n}\n\n/**\n * Wraps function to test return value only.\n *\n * Wraps the target function and checks return value after calling through\n * {@link is}. Parameters are not checked. Returns `null` on mismatch.\n *\n * Related functions:\n *\n * - {@link isFunction} — Also tests parameters\n * - {@link isParameters} — Tests parameters only\n * - {@link assertReturn} — Throws with error details\n * - {@link validateReturn} — Returns all error details\n * - {@link equalsReturn} — Also rejects extra properties\n *\n * @template T Target function type\n * @param func Function to wrap\n * @returns Wrapped function returning `Output | null`\n */\nexport function isReturn<T extends (...args: any[]) => any>(\n  func: T,\n): FunctionalIs<T>;\n\n/** @internal */\nexport function isReturn(): never {\n  NoTransformConfigurationError(\"functional.isReturn\");\n}\n\n/**\n * Wraps function to test parameters and return value with strict equality.\n *\n * Wraps the target function and checks through {@link equals}. Also rejects\n * extra properties not defined in type. Returns `null` on mismatch.\n *\n * Related functions:\n *\n * - {@link isFunction} — Allows extra properties\n * - {@link equalsParameters} — Tests parameters only\n * - {@link equalsReturn} — Tests return value only\n * - {@link assertEqualsFunction} — Throws with error details\n * - {@link validateEqualsFunction} — Returns all error details\n *\n * @template T Target function type\n * @param func Function to wrap\n * @returns Wrapped function returning `Output | null`\n */\nexport function equalsFunction<T extends (...args: any[]) => any>(\n  func: T,\n): FunctionalIs<T>;\n\n/** @internal */\nexport function equalsFunction(): never {\n  NoTransformConfigurationError(\"functional.equalsFunction\");\n}\n\n/**\n * Wraps function to test parameters with strict equality.\n *\n * Wraps the target function and checks parameters through {@link equals}. Also\n * rejects extra properties. Return value is not checked.\n *\n * Related functions:\n *\n * - {@link isParameters} — Allows extra properties\n * - {@link equalsFunction} — Also tests return value\n * - {@link equalsReturn} — Tests return value only\n * - {@link assertEqualsParameters} — Throws with error details\n * - {@link validateEqualsParameters} — Returns all error details\n *\n * @template T Target function type\n * @param func Function to wrap\n * @returns Wrapped function returning `Output | null`\n */\nexport function equalsParameters<T extends (...args: any[]) => any>(\n  func: T,\n): FunctionalIs<T>;\n\n/** @internal */\nexport function equalsParameters(): never {\n  NoTransformConfigurationError(\"functional.equalsParameters\");\n}\n\n/**\n * Wraps function to test return value with strict equality.\n *\n * Wraps the target function and checks return value through {@link equals}. Also\n * rejects extra properties. Parameters are not checked.\n *\n * Related functions:\n *\n * - {@link isReturn} — Allows extra properties\n * - {@link equalsFunction} — Also tests parameters\n * - {@link equalsParameters} — Tests parameters only\n * - {@link assertEqualsReturn} — Throws with error details\n * - {@link validateEqualsReturn} — Returns all error details\n *\n * @template T Target function type\n * @param func Function to wrap\n * @returns Wrapped function returning `Output | null`\n */\nexport function equalsReturn<T extends (...args: any[]) => any>(\n  func: T,\n): FunctionalIs<T>;\n\n/** @internal */\nexport function equalsReturn(): never {\n  NoTransformConfigurationError(\"functional.equalsReturn\");\n}\n\n/* -----------------------------------------------------------\n  VALIDATE\n----------------------------------------------------------- */\n/**\n * Wraps function to validate both parameters and return value.\n *\n * Wraps the target function and validates all parameters before calling and\n * return value after calling through {@link validate}. Collects all errors.\n *\n * Error path format:\n *\n * - Parameter errors: `$input.parameters[0].property`\n * - Return errors: `$input.return.property`\n *\n * Related functions:\n *\n * - {@link validateParameters} — Validates parameters only\n * - {@link validateReturn} — Validates return value only\n * - {@link assertFunction} — Throws on first error\n * - {@link validateEqualsFunction} — Also rejects extra properties\n *\n * @template T Target function type\n * @param func Function to wrap\n * @returns Wrapped function returning {@link IValidation}\n */\nexport function validateFunction<T extends (...args: any[]) => any>(\n  func: T,\n): FunctionalValidate<T>;\n\n/** @internal */\nexport function validateFunction(): never {\n  NoTransformConfigurationError(\"functional.validateFunction\");\n}\n\n/**\n * Wraps function to validate parameters only.\n *\n * Wraps the target function and validates all parameters before calling through\n * {@link validate}. Return value is not validated. Collects all errors.\n *\n * Error path format: `$input.parameters[0].property`\n *\n * Related functions:\n *\n * - {@link validateFunction} — Also validates return value\n * - {@link validateReturn} — Validates return value only\n * - {@link assertParameters} — Throws on first error\n * - {@link validateEqualsParameters} — Also rejects extra properties\n *\n * @template T Target function type\n * @param func Function to wrap\n * @returns Wrapped function returning {@link IValidation}\n */\nexport function validateParameters<T extends (...args: any[]) => any>(\n  func: T,\n): FunctionalValidate<T>;\n\n/** @internal */\nexport function validateParameters(): never {\n  NoTransformConfigurationError(\"functional.validateParameters\");\n}\n\n/**\n * Wraps function to validate return value only.\n *\n * Wraps the target function and validates return value after calling through\n * {@link validate}. Parameters are not validated. Collects all errors.\n *\n * Error path format: `$input.return.property`\n *\n * Related functions:\n *\n * - {@link validateFunction} — Also validates parameters\n * - {@link validateParameters} — Validates parameters only\n * - {@link assertReturn} — Throws on first error\n * - {@link validateEqualsReturn} — Also rejects extra properties\n *\n * @template T Target function type\n * @param func Function to wrap\n * @returns Wrapped function returning {@link IValidation}\n */\nexport function validateReturn<T extends (...args: any[]) => any>(\n  func: T,\n): FunctionalValidate<T>;\n\n/** @internal */\nexport function validateReturn(): never {\n  NoTransformConfigurationError(\"functional.validateReturn\");\n}\n\n/**\n * Wraps function to validate parameters and return value with strict equality.\n *\n * Wraps the target function and validates through {@link validateEquals}. Also\n * rejects extra properties not defined in type. Collects all errors.\n *\n * Error path format:\n *\n * - Parameter errors: `$input.parameters[0].property`\n * - Return errors: `$input.return.property`\n *\n * Related functions:\n *\n * - {@link validateFunction} — Allows extra properties\n * - {@link validateEqualsParameters} — Validates parameters only\n * - {@link validateEqualsReturn} — Validates return value only\n * - {@link assertEqualsFunction} — Throws on first error\n *\n * @template T Target function type\n * @param func Function to wrap\n * @returns Wrapped function returning {@link IValidation}\n */\nexport function validateEqualsFunction<T extends (...args: any[]) => any>(\n  func: T,\n): FunctionalValidate<T>;\n\n/** @internal */\nexport function validateEqualsFunction(): never {\n  NoTransformConfigurationError(\"functional.validateEqualsFunction\");\n}\n\n/**\n * Wraps function to validate parameters with strict equality.\n *\n * Wraps the target function and validates parameters through\n * {@link validateEquals}. Also rejects extra properties. Return value is not\n * validated.\n *\n * Error path format: `$input.parameters[0].property`\n *\n * Related functions:\n *\n * - {@link validateParameters} — Allows extra properties\n * - {@link validateEqualsFunction} — Also validates return value\n * - {@link assertEqualsParameters} — Throws on first error\n *\n * @template T Target function type\n * @param func Function to wrap\n * @returns Wrapped function returning {@link IValidation}\n */\nexport function validateEqualsParameters<T extends (...args: any[]) => any>(\n  func: T,\n): FunctionalValidate<T>;\n\n/** @internal */\nexport function validateEqualsParameters(): never {\n  NoTransformConfigurationError(\"functional.validateEqualsParameters\");\n}\n\n/**\n * Wraps function to validate return value with strict equality.\n *\n * Wraps the target function and validates return value through\n * {@link validateEquals}. Also rejects extra properties. Parameters are not\n * validated.\n *\n * Error path format: `$input.return.property`\n *\n * Related functions:\n *\n * - {@link validateReturn} — Allows extra properties\n * - {@link validateEqualsFunction} — Also validates parameters\n * - {@link assertEqualsReturn} — Throws on first error\n *\n * @template T Target function type\n * @param func Function to wrap\n * @returns Wrapped function returning {@link IValidation}\n */\nexport function validateEqualsReturn<T extends (...args: any[]) => any>(\n  func: T,\n): FunctionalValidate<T>;\n\n/** @internal */\nexport function validateEqualsReturn(): never {\n  NoTransformConfigurationError(\"functional.validateEqualsReturn\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA8DA,SAAgB,iBAAwB;CACtC,8BAA8B,2BAA2B;AAC3D;;AA8BA,SAAgB,mBAA0B;CACxC,8BAA8B,6BAA6B;AAC7D;;AA8BA,SAAgB,eAAsB;CACpC,8BAA8B,yBAAyB;AACzD;;AAiCA,SAAgB,uBAA8B;CAC5C,8BAA8B,iCAAiC;AACjE;;AA8BA,SAAgB,yBAAgC;CAC9C,8BAA8B,mCAAmC;AACnE;;AA8BA,SAAgB,qBAA4B;CAC1C,8BAA8B,+BAA+B;AAC/D;;AA4BA,SAAgB,aAAoB;CAClC,8BAA8B,uBAAuB;AACvD;;AAyBA,SAAgB,eAAsB;CACpC,8BAA8B,yBAAyB;AACzD;;AAyBA,SAAgB,WAAkB;CAChC,8BAA8B,qBAAqB;AACrD;;AAyBA,SAAgB,iBAAwB;CACtC,8BAA8B,2BAA2B;AAC3D;;AAyBA,SAAgB,mBAA0B;CACxC,8BAA8B,6BAA6B;AAC7D;;AAyBA,SAAgB,eAAsB;CACpC,8BAA8B,yBAAyB;AACzD;;AAgCA,SAAgB,mBAA0B;CACxC,8BAA8B,6BAA6B;AAC7D;;AA0BA,SAAgB,qBAA4B;CAC1C,8BAA8B,+BAA+B;AAC/D;;AA0BA,SAAgB,iBAAwB;CACtC,8BAA8B,2BAA2B;AAC3D;;AA6BA,SAAgB,yBAAgC;CAC9C,8BAA8B,mCAAmC;AACnE;;AA0BA,SAAgB,2BAAkC;CAChD,8BAA8B,qCAAqC;AACrE;;AA0BA,SAAgB,uBAA8B;CAC5C,8BAA8B,iCAAiC;AACjE"}