{"version":3,"file":"number.mjs","sources":["../../src/primitives/number.mts"],"sourcesContent":["/* eslint-disable unicorn/no-negated-comparison */\nimport { Arr, expectType, Int, isNumber, Result } from 'ts-data-forge';\nimport {\n  type BoolAnd,\n  type BoolNot,\n  type Brand,\n  type FiniteNumber,\n  type IsNever,\n  type NegativeInt,\n  type NonPositiveInt,\n  type NonZeroFiniteNumber,\n  type NonZeroInt,\n  type PositiveInt,\n  type SafeInt,\n  type SafeUint,\n  type Uint,\n} from 'ts-type-forge';\nimport { refine } from '../other-types/index.mjs';\nimport { type Type } from '../type.mjs';\nimport {\n  createPrimitiveType,\n  type NumericConstraintViolation,\n} from '../utils/index.mjs';\n\ntype NumberType = number;\n\nexport function number(defaultValue?: NumberType): Type<NumberType>;\n\nexport function number<N extends NumberType, const C extends Constraints>(\n  defaultValue: N & DefaultValueType<N, C>,\n  constraints: C,\n): Type<ConstraintsToResultType<C>>;\n\nexport function number<C extends Constraints>(\n  defaultValue: NumberType = 0,\n  constraints?: C,\n): Type<NumberType> {\n  const baseType = createPrimitiveType({\n    typeName: 'number',\n    defaultValue,\n    is: isNumber,\n  });\n\n  if (\n    constraints === undefined ||\n    Arr.isFixedLengthTuple(Object.keys(constraints), 0)\n  ) {\n    return baseType;\n  }\n\n  const constraintsPredicate = createConstraintsPredicate(constraints);\n\n  const defaultValueConstraintsCheck = constraintsPredicate(defaultValue);\n\n  if (Result.isErr(defaultValueConstraintsCheck)) {\n    throw new Error(\n      defaultValueErrorMessage(\n        defaultValue,\n        defaultValueConstraintsCheck.value,\n      ),\n    );\n  }\n\n  return refine({\n    baseType,\n    defaultValue,\n    is: (value): value is NumberType =>\n      Result.isOk(constraintsPredicate(value)),\n    typeName: 'number',\n    getConstraintDetails: (value) => {\n      const result = constraintsPredicate(value);\n\n      return Result.isErr(result)\n        ? {\n            kind: 'numeric-constraint',\n            numericType: 'number',\n            violation: result.value,\n          }\n        : undefined;\n    },\n  });\n}\n\ntype Constraints = Partial<\n  Readonly<{\n    finite: true;\n    int: true;\n    safeInteger: true;\n    nonZero: true;\n    negative: true;\n    nonNegative: true;\n    positive: true;\n    nonPositive: true;\n\n    gt: NumberType;\n    gte: NumberType;\n    min: NumberType;\n    lt: NumberType;\n    lte: NumberType;\n    max: NumberType;\n    multipleOf: NumberType;\n    step: NumberType;\n  }>\n>;\n\n/**\n * The set of constraints accepted by {@link number}.\n */\nexport type NumberTypeConstraints = Constraints;\n\n/**\n * The numeric-range subset of {@link NumberTypeConstraints}. These constraints\n * (`gt`, `gte`, `min`, `lt`, `lte`, `max`, `multipleOf`, `step`) add runtime\n * validation without changing the result brand, so the branded number types\n * under `predefined/brand/number` accept only this subset. To build a different\n * brand from a plain number, use {@link number} with the predicate constraints\n * instead, or the dedicated branded constructor for the target type.\n */\nexport type NumberRangeConstraints = Pick<\n  NumberTypeConstraints,\n  'gt' | 'gte' | 'min' | 'lt' | 'lte' | 'max' | 'multipleOf' | 'step'\n>;\n\ntype DefaultValueType<\n  N extends NumberType,\n  C extends Constraints,\n> = DefaultValueWhenNonZeroIsOn<N, C> &\n  DefaultValueWhenNegativeIsOn<N, C> &\n  DefaultValueWhenNonNegativeIsOn<N, C> &\n  DefaultValueWhenPositiveIsOn<N, C> &\n  DefaultValueWhenNonPositiveIsOn<N, C>;\n\ntype ConstraintsToResultType<C extends Constraints> =\n  ConstraintsToResultHelperType<ConstraintsToResultBrandKeys<C>>;\n\ntype ConstraintsToResultHelperType<\n  R extends Readonly<{ brandKeys: string; brandFalseKeys: string }>,\n> =\n  IsNever<R> extends true\n    ? NumberType\n    : Brand<NumberType, R['brandKeys'], R['brandFalseKeys']>;\n\ntype ConstraintsToResultBrandKeys<C extends Constraints> =\n  | (C extends Readonly<{ int: true }>\n      ? Readonly<{ brandKeys: 'Int' | 'Finite'; brandFalseKeys: 'NaNValue' }>\n      : never)\n  | (C extends Readonly<{ safeInteger: true }>\n      ? Readonly<{\n          brandKeys: 'Finite' | 'Int' | 'SafeInt';\n          brandFalseKeys: 'NaNValue';\n        }>\n      : never)\n  | (C extends Readonly<{ finite: true }>\n      ? Readonly<{ brandKeys: 'Finite'; brandFalseKeys: 'NaNValue' }>\n      : never)\n  | (C extends Readonly<{ nonZero: true }>\n      ? Readonly<{ brandKeys: '!=0'; brandFalseKeys: 'NaNValue' }>\n      : never)\n  | (C extends Readonly<{ negative: true }>\n      ? Readonly<{\n          brandKeys: '!=0' | '< 2^15' | '< 2^16' | '< 2^31' | '< 2^32' | '<=0';\n          brandFalseKeys: '>=0' | 'NaNValue';\n        }>\n      : never)\n  | (C extends Readonly<{ nonNegative: true }>\n      ? Readonly<{\n          brandKeys: '>=0' | '> -2^16' | '> -2^32' | '>= -2^15' | '>= -2^31';\n          brandFalseKeys: 'NaNValue';\n        }>\n      : never)\n  | (C extends Readonly<{ positive: true }>\n      ? Readonly<{\n          brandKeys:\n            '>=0' | '!=0' | '> -2^16' | '> -2^32' | '>= -2^15' | '>= -2^31';\n          brandFalseKeys: '<=0' | 'NaNValue';\n        }>\n      : never)\n  | (C extends Readonly<{ nonPositive: true }>\n      ? Readonly<{\n          brandKeys: '< 2^15' | '< 2^16' | '< 2^31' | '< 2^32' | '<=0';\n          brandFalseKeys: 'NaNValue';\n        }>\n      : never);\n\n{\n  type BrandKeysInt = ConstraintsToResultBrandKeys<Readonly<{ int: true }>>;\n\n  expectType<BrandKeysInt['brandKeys'], 'Finite' | 'Int'>('=');\n\n  expectType<BrandKeysInt['brandFalseKeys'], 'NaNValue'>('=');\n\n  type BrandKeysPositiveInt = ConstraintsToResultBrandKeys<\n    Readonly<{ int: true; positive: true }>\n  >;\n\n  expectType<\n    BrandKeysPositiveInt['brandKeys'],\n    | 'Int'\n    | 'Finite'\n    | '!=0'\n    | '>=0'\n    | '> -2^16'\n    | '> -2^32'\n    | '>= -2^15'\n    | '>= -2^31'\n  >('=');\n\n  expectType<BrandKeysPositiveInt['brandFalseKeys'], '<=0' | 'NaNValue'>('=');\n\n  expectType<ConstraintsToResultType<Readonly<{ finite: true }>>, FiniteNumber>(\n    '=',\n  );\n\n  expectType<\n    ConstraintsToResultType<Readonly<{ finite: true; nonZero: true }>>,\n    NonZeroFiniteNumber\n  >('=');\n\n  expectType<\n    ConstraintsToResultType<Readonly<{ int: true; nonZero: true }>>,\n    NonZeroInt\n  >('=');\n\n  expectType<\n    ConstraintsToResultType<Readonly<{ int: true; positive: true }>>,\n    PositiveInt\n  >('=');\n\n  expectType<\n    ConstraintsToResultType<Readonly<{ int: true; negative: true }>>,\n    NegativeInt\n  >('=');\n\n  expectType<\n    ConstraintsToResultType<Readonly<{ int: true; nonPositive: true }>>,\n    NonPositiveInt\n  >('=');\n\n  expectType<\n    ConstraintsToResultType<Readonly<{ int: true; nonNegative: true }>>,\n    Uint\n  >('=');\n\n  expectType<ConstraintsToResultType<Readonly<{ safeInteger: true }>>, SafeInt>(\n    '=',\n  );\n\n  expectType<\n    ConstraintsToResultType<Readonly<{ safeInteger: true; nonNegative: true }>>,\n    SafeUint\n  >('=');\n}\n\ntype DefaultValueWhenNonZeroIsOn<N extends NumberType, C extends Constraints> =\n  C extends Readonly<{ nonZero: true }> ? NonZeroNumber<N> : NumberType;\n\ntype DefaultValueWhenNegativeIsOn<N extends NumberType, C extends Constraints> =\n  C extends Readonly<{ negative: true }> ? NegativeNumber<N> : NumberType;\n\ntype DefaultValueWhenNonNegativeIsOn<\n  N extends NumberType,\n  C extends Constraints,\n> =\n  C extends Readonly<{ nonNegative: true }> ? NonNegativeNumber<N> : NumberType;\n\ntype DefaultValueWhenPositiveIsOn<N extends NumberType, C extends Constraints> =\n  C extends Readonly<{ positive: true }> ? PositiveNumber<N> : NumberType;\n\ntype DefaultValueWhenNonPositiveIsOn<\n  N extends NumberType,\n  C extends Constraints,\n> =\n  C extends Readonly<{ nonPositive: true }> ? NonPositiveNumber<N> : NumberType;\n\ntype NonZeroNumber<N extends NumberType> = NumberType extends N\n  ? NumberType\n  : IsZero<N> extends true\n    ? never\n    : N;\n\ntype NegativeNumber<N extends NumberType> = NumberType extends N\n  ? NumberType\n  : IsNegative<N> extends true\n    ? N\n    : never;\n\ntype NonNegativeNumber<N extends NumberType> = NumberType extends N\n  ? NumberType\n  : IsNonNegative<N> extends true\n    ? N\n    : never;\n\ntype PositiveNumber<N extends NumberType> = NumberType extends N\n  ? NumberType\n  : IsPositive<N> extends true\n    ? N\n    : never;\n\ntype NonPositiveNumber<N extends NumberType> = NumberType extends N\n  ? NumberType\n  : IsNonPositive<N> extends true\n    ? N\n    : never;\n\ntype IsZero<N extends NumberType> = `${N}` extends '0' ? true : false;\n\ntype IsNonZero<N extends NumberType> = IsZero<N> extends true ? false : true;\n\ntype IsNegative<N extends NumberType> = `${N}` extends `-${string}`\n  ? true\n  : false;\n\ntype IsNonNegative<N extends NumberType> =\n  IsNegative<N> extends true ? false : true;\n\ntype IsPositive<N extends NumberType> = BoolAnd<IsNonZero<N>, IsNonNegative<N>>;\n\ntype IsNonPositive<N extends NumberType> = BoolNot<IsPositive<N>>;\n\nconst createConstraintsPredicate =\n  (constraints: Constraints) =>\n  (value: NumberType): Result<true, NumericConstraintViolation> => {\n    const {\n      finite,\n      int,\n      safeInteger,\n      nonZero,\n      negative,\n      nonNegative,\n      positive,\n      nonPositive,\n      gt,\n      gte,\n      min,\n      lt,\n      lte,\n      max,\n      multipleOf,\n      step,\n      ..._rest\n    } = constraints;\n\n    expectType<keyof typeof _rest, never>('=');\n\n    if (finite === true && !Number.isFinite(value)) {\n      return Result.err({ constraint: 'finite', value: true } as const);\n    }\n\n    if (int === true && !Int.is(value)) {\n      return Result.err({ constraint: 'int', value: true } as const);\n    }\n\n    if (safeInteger === true && !Number.isSafeInteger(value)) {\n      return Result.err({ constraint: 'safeInteger', value: true } as const);\n    }\n\n    if (nonZero === true && !(value !== 0)) {\n      return Result.err({ constraint: 'nonZero', value: true } as const);\n    }\n\n    if (negative === true && !(value < 0)) {\n      return Result.err({ constraint: 'negative', value: true } as const);\n    }\n\n    if (nonNegative === true && !(value >= 0)) {\n      return Result.err({ constraint: 'nonNegative', value: true } as const);\n    }\n\n    if (positive === true && !(value > 0)) {\n      return Result.err({ constraint: 'positive', value: true } as const);\n    }\n\n    if (nonPositive === true && !(value <= 0)) {\n      return Result.err({ constraint: 'nonPositive', value: true } as const);\n    }\n\n    if (gt !== undefined && !(value > gt)) {\n      return Result.err({ constraint: 'gt', value: String(gt) } as const);\n    }\n\n    if (gte !== undefined && !(value >= gte)) {\n      return Result.err({ constraint: 'gte', value: String(gte) } as const);\n    }\n\n    if (min !== undefined && !(value >= min)) {\n      return Result.err({ constraint: 'min', value: String(min) } as const);\n    }\n\n    if (lt !== undefined && !(value < lt)) {\n      return Result.err({ constraint: 'lt', value: String(lt) } as const);\n    }\n\n    if (lte !== undefined && !(value <= lte)) {\n      return Result.err({ constraint: 'lte', value: String(lte) } as const);\n    }\n\n    if (max !== undefined && !(value <= max)) {\n      return Result.err({ constraint: 'max', value: String(max) } as const);\n    }\n\n    // `value % 0` throws a RangeError, so the zero divisor is handled\n    // separately: it only admits zero.\n    if (multipleOf !== undefined) {\n      if (multipleOf === 0) {\n        if (value !== 0) {\n          return Result.err({\n            constraint: 'multipleOf',\n            value: String(multipleOf),\n          } as const);\n        }\n      } else if (value % multipleOf !== 0) {\n        return Result.err({\n          constraint: 'multipleOf',\n          value: String(multipleOf),\n        } as const);\n      }\n    }\n\n    if (step !== undefined) {\n      if (step === 0) {\n        if (value !== 0) {\n          return Result.err({\n            constraint: 'step',\n            value: String(step),\n          } as const);\n        }\n      } else if (value % step !== 0) {\n        return Result.err({ constraint: 'step', value: String(step) } as const);\n      }\n    }\n\n    return Result.ok(true);\n  };\n\nconst defaultValueErrorMessage = (\n  value: NumberType,\n  violation: NumericConstraintViolation,\n): string =>\n  `defaultValue [${value}] for number does not satisfy the constraint ${violation.constraint} = ${violation.value}` as const;\n"],"names":[],"mappings":"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"}