@ahrjarrett/v0.39.0

[ahrjarrett]

changelog

fixes

• 61

• 62

new features

• any.scalar: adds any.scalar: describe any non-composite JSON value (string | number | boolean | null)
• never.uninhabited: free semantics for default arguments that are typed as never
• (internal): implementation of any.object now points to a new name, any_object (so users will always see any.object or any_object)
• Kind.constraintsOf: infer a Kind's constraints
• adds potential implementations of string.delimitedCase, string.snake, string.kebab, etc.
• check: adds ambient namespaces is and non, which expose the following type constructors:
  • check.is.stringLiteral:

  • declare function fn<T extends check.is.stringLiteral<t>>(t: t): t
    //                  ^ raises a TypeError if `T` is not a string literal

  • check.is.numberLiteral:

  • declare function fn<T extends check.is.numberLiteral<t>>(t: t): t
    //                  ^ raises a TypeError if `T` is not a number literal

  • check.is.booleanLiteral:

  • declare function fn<T extends check.is.numberLiteral<t>>(t: t): t
    //                  ^ raises a TypeError if `T` is not a boolean literal

  • check.is.literal:

  • declare function fn<T extends check.is.literal<t>>(t: t): t
    //                  ^ raises a TypeError if `T` is not a literal

  • check.is.union:

  • declare function fn<T extends check.is.union<t>>(t: t): t
    //                  ^ raises a TypeError if `T` is not a union

  • check.non.array:

  • declare function fn<T extends check.non.array<t>>(t: t): t
    //                  ^ raises a TypeError if `T` is an array (must be an object)

  • check.non.union:

  • declare function fn<T extends check.non.union<t>>(t: t): t
    //                  ^ raises a TypeError if `T` is a union

  • check.non.finiteBoolean:

  • declare function fn<T extends check.non.finiteBoolean<t>>(t: t): t
    //                  ^ raises a TypeError if `T` is `true` or `false` (must be `boolean`)

  • check.non.finiteString:

  • declare function fn<T extends check.non.finiteString<t>>(t: t): t
    //                  ^ raises a TypeError if `T` is a literal string (must be `string`)

  • check.non.finiteNumber:

  • declare function fn<T extends check.non.finiteNumber<t>>(t: t): t
    //                  ^ raises a TypeError if `T` is a literal number (must be a `number`)

deprecations