type-plus 4.8.2 → 4.10.0

package/ts/assertion/assertType.ts

@@ -1,105 +1,105 @@
-import { tersify } from 'tersify'
-import { AnyConstructor, isConstructor } from '../class'
-import { AnyFunction } from '../function'
-
-/**
- * assert the subject satisfies the specified type T
- * @type T the type to check against.
- */
-export function assertType<T>(subject: T): asserts subject is T
-export function assertType<T>(subject: unknown, validator: (s: T) => boolean): asserts subject is T
-export function assertType<T extends new (...args: any) => any>(subject: unknown, constructor: T): asserts subject is InstanceType<T>
-export function assertType(subject: unknown, validator?: (s: any) => boolean) {
-  if (validator) {
-    if ((isConstructor(validator) && !(subject instanceof validator)) || !validator(subject))
-      throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
-  }
-  return
-}
-
-assertType.isUndefined = function (subject: undefined): asserts subject is undefined {
-  if (typeof subject !== 'undefined') throw TypeError(`subject is not undefined`)
-}
-assertType.noUndefined = function <S>(subject: Exclude<S, undefined>): void {
-  if (typeof subject === 'undefined') throw TypeError(`subject is undefined`)
-}
-
-assertType.isNull = function (subject: null): asserts subject is null {
-  if (subject !== null) throw TypeError(`subject is not null`)
-}
-assertType.noNull = function <S>(subject: Exclude<S, null>): void {
-  if (subject === null) throw TypeError(`subject is null`)
-}
-
-assertType.isNumber = function (subject: number): asserts subject is number {
-  if (typeof subject !== 'number') throw TypeError(`subject is not number`)
-}
-assertType.noNumber = function <S>(subject: Exclude<S, number>): void {
-  if (typeof subject === 'number') throw TypeError(`subject is number`)
-}
-
-assertType.isBoolean = function (subject: boolean): asserts subject is boolean {
-  if (typeof subject !== 'boolean') throw TypeError(`subject is not boolean`)
-}
-assertType.noBoolean = function <S>(subject: Exclude<S, boolean>): void {
-  if (typeof subject === 'boolean') throw TypeError(`subject is boolean`)
-}
-
-assertType.isTrue = function (subject: true): asserts subject is true {
-  if (subject !== true) throw TypeError(`subject is not true`)
-}
-assertType.noTrue = function <S>(subject: Exclude<S, true>): void {
-  // @ts-ignore
-  if (subject === true) throw TypeError(`subject is true`)
-}
-
-assertType.isFalse = function (subject: false): asserts subject is false {
-  if (subject !== false) throw TypeError(`subject is not false`)
-}
-assertType.noFalse = function <S>(subject: Exclude<S, false>): void {
-  // @ts-ignore
-  if (subject === false) throw TypeError(`subject is false`)
-}
-
-assertType.isString = function (subject: string): asserts subject is string {
-  if (typeof subject !== 'string') throw TypeError(`subject is not string`)
-}
-assertType.noString = function <S>(subject: Exclude<S, string>): void {
-  if (typeof subject === 'string') throw TypeError(`subject is string`)
-}
-
-assertType.isFunction = function (subject: AnyFunction): asserts subject is AnyFunction {
-  if (typeof subject !== 'function') throw TypeError(`subject is not function`)
-}
-assertType.noFunction = function <S>(subject: Exclude<S, AnyFunction>): void {
-  if (typeof subject === 'function') throw TypeError(`subject is function`)
-}
-
-assertType.isConstructor = function (subject: AnyConstructor): asserts subject is AnyConstructor {
-  if (!isConstructor(subject)) throw TypeError(`subject is not a constructor`)
-}
-
-assertType.isError = function (subject: Error): asserts subject is Error {
-  if (!(subject instanceof Error)) throw TypeError(`subject is not an Error`)
-}
-assertType.noError = function <S>(subject: Exclude<S, Error>): void {
-  if (subject instanceof Error) throw TypeError(`subject is an Error`)
-}
-
-assertType.isNever = function (subject: never): asserts subject is never {
-}
-
-/**
- * creates a custom assertion function with standard TypeError.
- * Currently this requires explicity type annotation,
- * thus making it hard to use:
- * https://github.com/microsoft/TypeScript/issues/41047
- */
-assertType.custom = function <T>(
-  validator: (s: T) => boolean
-): (subject: unknown) => asserts subject is T {
-  return function (subject) {
-    if (!validator(subject as any)) throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
-    return
-  }
-}
+import { tersify } from 'tersify'
+import { AnyConstructor, isConstructor } from '../class/index.js'
+import type { AnyFunction } from '../function/index.js'
+
+/**
+ * assert the subject satisfies the specified type T
+ * @type T the type to check against.
+ */
+export function assertType<T>(subject: T): asserts subject is T
+export function assertType<T>(subject: unknown, validator: (s: T) => boolean): asserts subject is T
+export function assertType<T extends new (...args: any) => any>(subject: unknown, constructor: T): asserts subject is InstanceType<T>
+export function assertType(subject: unknown, validator?: (s: any) => boolean) {
+  if (validator) {
+    if ((isConstructor(validator) && !(subject instanceof validator)) || !validator(subject))
+      throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
+  }
+  return
+}
+
+assertType.isUndefined = function (subject: undefined): asserts subject is undefined {
+  if (typeof subject !== 'undefined') throw TypeError(`subject is not undefined`)
+}
+assertType.noUndefined = function <S>(subject: Exclude<S, undefined>): void {
+  if (typeof subject === 'undefined') throw TypeError(`subject is undefined`)
+}
+
+assertType.isNull = function (subject: null): asserts subject is null {
+  if (subject !== null) throw TypeError(`subject is not null`)
+}
+assertType.noNull = function <S>(subject: Exclude<S, null>): void {
+  if (subject === null) throw TypeError(`subject is null`)
+}
+
+assertType.isNumber = function (subject: number): asserts subject is number {
+  if (typeof subject !== 'number') throw TypeError(`subject is not number`)
+}
+assertType.noNumber = function <S>(subject: Exclude<S, number>): void {
+  if (typeof subject === 'number') throw TypeError(`subject is number`)
+}
+
+assertType.isBoolean = function (subject: boolean): asserts subject is boolean {
+  if (typeof subject !== 'boolean') throw TypeError(`subject is not boolean`)
+}
+assertType.noBoolean = function <S>(subject: Exclude<S, boolean>): void {
+  if (typeof subject === 'boolean') throw TypeError(`subject is boolean`)
+}
+
+assertType.isTrue = function (subject: true): asserts subject is true {
+  if (subject !== true) throw TypeError(`subject is not true`)
+}
+assertType.noTrue = function <S>(subject: Exclude<S, true>): void {
+  // @ts-ignore
+  if (subject === true) throw TypeError(`subject is true`)
+}
+
+assertType.isFalse = function (subject: false): asserts subject is false {
+  if (subject !== false) throw TypeError(`subject is not false`)
+}
+assertType.noFalse = function <S>(subject: Exclude<S, false>): void {
+  // @ts-ignore
+  if (subject === false) throw TypeError(`subject is false`)
+}
+
+assertType.isString = function (subject: string): asserts subject is string {
+  if (typeof subject !== 'string') throw TypeError(`subject is not string`)
+}
+assertType.noString = function <S>(subject: Exclude<S, string>): void {
+  if (typeof subject === 'string') throw TypeError(`subject is string`)
+}
+
+assertType.isFunction = function (subject: AnyFunction): asserts subject is AnyFunction {
+  if (typeof subject !== 'function') throw TypeError(`subject is not function`)
+}
+assertType.noFunction = function <S>(subject: Exclude<S, AnyFunction>): void {
+  if (typeof subject === 'function') throw TypeError(`subject is function`)
+}
+
+assertType.isConstructor = function (subject: AnyConstructor): asserts subject is AnyConstructor {
+  if (!isConstructor(subject)) throw TypeError(`subject is not a constructor`)
+}
+
+assertType.isError = function (subject: Error): asserts subject is Error {
+  if (!(subject instanceof Error)) throw TypeError(`subject is not an Error`)
+}
+assertType.noError = function <S>(subject: Exclude<S, Error>): void {
+  if (subject instanceof Error) throw TypeError(`subject is an Error`)
+}
+
+assertType.isNever = function (subject: never): asserts subject is never {
+}
+
+/**
+ * creates a custom assertion function with standard TypeError.
+ * Currently this requires explicity type annotation,
+ * thus making it hard to use:
+ * https://github.com/microsoft/TypeScript/issues/41047
+ */
+assertType.custom = function <T>(
+  validator: (s: T) => boolean
+): (subject: unknown) => asserts subject is T {
+  return function (subject) {
+    if (!validator(subject as any)) throw new TypeError(`subject fails to satisfy ${tersify(validator)}`)
+    return
+  }
+}

package/ts/assertion/index.ts

@@ -1 +1 @@
-export * from './assertType'
+export * from './assertType.js'

package/ts/binary/_binary.ts

@@ -1 +1 @@
-export type { Bit, BitAnd, BitNot, BitOr, BitXor } from './Bit'
+export type { Bit, BitAnd, BitNot, BitOr, BitXor } from './Bit.js'

package/ts/binary/index.ts

@@ -1,2 +1,2 @@
-export * as B from './_binary'
-export * as Bit from './_binary'
+export * as B from './_binary.js'
+export * as Bit from './_binary.js'

package/ts/class/index.ts

@@ -1,2 +1,2 @@
-export type { AnyConstructor } from './AnyConstructor'
-export * from './isConstructor'
+export type { AnyConstructor } from './AnyConstructor.js'
+export * from './isConstructor.js'

package/ts/class/isConstructor.ts

@@ -1,4 +1,4 @@
-import { AnyConstructor } from './AnyConstructor'
+import type { AnyConstructor } from './AnyConstructor.js'
 
 export function isConstructor(subject: unknown): subject is AnyConstructor {
   try {

package/ts/function/index.ts

@@ -1 +1 @@
-export type { AnyFunction } from './AnyFunction'
+export type { AnyFunction } from './AnyFunction.js'

package/ts/functional/Maybe.ts

@@ -1,19 +1,19 @@
-import { Brand } from '../nominal-types'
-import { Equal } from '../predicates'
-import { Widen } from '../utils'
-
-export type Maybe<T> = Just<T> | None<T>
-export type Just<T> = Brand<'maybe', T> & { unwrap(): T }
-export type None<T> = Brand<'maybe', void> & { unwrap(): T }
-
-export function just<T>(value: T):
-  Equal<T, undefined | null> extends true ?
-  None<T> :
-  Just<Widen<NonNullable<T>>> {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  return { unwrap() { return value } } as any
-}
-
-export function none<T>(): None<T> {
-  return { unwrap() { } } as None<T>
-}
+import type { Brand } from '../nominal-types/index.js'
+import type { Equal } from '../predicates/index.js'
+import type { Widen } from '../utils/index.js'
+
+export type Maybe<T> = Just<T> | None<T>
+export type Just<T> = Brand<'maybe', T> & { unwrap(): T }
+export type None<T> = Brand<'maybe', void> & { unwrap(): T }
+
+export function just<T>(value: T):
+  Equal<T, undefined | null> extends true ?
+  None<T> :
+  Just<Widen<NonNullable<T>>> {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return { unwrap() { return value } } as any
+}
+
+export function none<T>(): None<T> {
+  return { unwrap() { } } as None<T>
+}

package/ts/functional/compose.ts

@@ -1,9 +1,10 @@
-import { Head, Last } from '../array'
-import { AnyFunction } from '../function/AnyFunction'
+import type { Head, Last } from '../array/index.js'
+import type { AnyFunction } from '../function/AnyFunction.js'
 
 /**
  * compose functions
  */
 export function compose<FS extends AnyFunction[]>(...fns: FS): (...args: Parameters<Head<FS>>) => ReturnType<Last<FS>> {
-  return (...args: any[]) => fns.reduce((args, fn) => [fn(...args)], args)[0] as any
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return (...args: any[]) => fns.reduce((args, fn) => [fn(...args)], args)[0]
 }

package/ts/functional/index.ts

@@ -1,3 +1,3 @@
-// export * from './Maybe'
-export type { ChainFn, EndoFn } from './ChainFn'
-export * from './compose'
+// export * from './Maybe.js'
+export type { ChainFn, EndoFn } from './ChainFn.js'
+export * from './compose.js'

package/ts/index.ts

@@ -1,22 +1,22 @@
-// import * as types from './types'
+// import * as types from './types/index.js'
 export { required, requiredDeep } from 'unpartial'
-export * from './array'
-export * from './assertion'
-export * from './class'
-export type { ComposableTypes, NonComposableTypes } from './ComposableTypes'
-export * from './function'
-export * from './functional'
-export * from './JSONTypes'
-export * from './math'
-export * from './nodejs'
-export * from './nominal-types'
-export * from './object'
-export * from './predicates'
-export type { PrimitiveTypes } from './PrimitiveTypes'
-export * from './promise'
-export * from './testing'
-// export * from './types/optional'
+export * from './array/index.js'
+export * from './assertion/index.js'
+export * from './class/index.js'
+export type { ComposableTypes, NonComposableTypes } from './ComposableTypes.js'
+export * from './function/index.js'
+export * from './functional/index.js'
+export * from './JSONTypes.js'
+export * from './math/index.js'
+export * from './nodejs/index.js'
+export * from './nominal-types/index.js'
+export * from './object/index.js'
+export * from './predicates/index.js'
+export type { PrimitiveTypes } from './PrimitiveTypes.js'
+export * from './promise/index.js'
+export * from './testing/index.js'
+// export * from './types/optional.js'
 // export * from './types/required'
-export type { UnionKeys } from './UnionKeys'
-export * from './utils'
+export type { UnionKeys } from './UnionKeys.js'
+export * from './utils/index.js'
 // export { types, types as T }

package/ts/math/Abs.ts

@@ -1,4 +1,4 @@
-import type { DigitArray } from './Digit'
+import type { DigitArray } from './Digit.js'
 
 export type Abs<N extends number, Fail = never> = number extends N ? Fail :
   `${N}` extends `-${infer P}` ? DigitArray.ToNumber<DigitArray.FromString<P>> : N

package/ts/math/Add.ts

@@ -1,10 +1,10 @@
-import type { PadLeft } from '../array'
-import type { And } from '../predicates'
+import type { PadLeft } from '../array/index.js'
+import type { And } from '../predicates/index.js'
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import type { Digit, DigitArray } from './Digit'
-import type { IsPositive } from './IsPositive'
-import type { IsWhole } from './IsWhole'
-import type { Max } from './Max'
+import type { Digit, DigitArray } from './Digit.js'
+import type { IsPositive } from './IsPositive.js'
+import type { IsWhole } from './IsWhole.js'
+import type { Max } from './Max.js'
 
 /**
  * Add two number literals.

package/ts/math/Digit.ts

@@ -1,7 +1,7 @@
-import { Tail } from '../array'
-import { And } from '../predicates'
-import { IsPositive } from './IsPositive'
-import { IsWhole } from './IsWhole'
+import type { Tail } from '../array/index.js'
+import type { And } from '../predicates/index.js'
+import type { IsPositive } from './IsPositive.js'
+import type { IsWhole } from './IsWhole.js'
 
 export namespace Digit {
   export type ToTuple<T = 1> = {
@@ -66,6 +66,8 @@ export namespace DigitArray {
 
 
   export type FromNumber<N extends number> = FromString<NumberToString<N>>
+  export type FromNumberAbs<N extends number> = FromString<TrimMinusSign<`${N}`>>
+  export type TrimMinusSign<N extends string> = N extends `-${infer rest}` ? rest : N
 
   export type NumberToString<N extends number> = (And<IsPositive<N>, IsWhole<N>>) extends true ? `${N}` : never
 

package/ts/math/GreaterThan.ts

@@ -1,28 +1,27 @@
-import type { Head, PadLeft, Tail } from '../array'
-import type { And, Equal } from '../predicates'
-import type { Digit, DigitArray } from './Digit'
-import type { IsPositive } from './IsPositive'
-import type { IsWhole } from './IsWhole'
-import type { Max } from './Max'
+import type { Head, PadLeft, Tail } from '../array/index.js'
+import type { And, Equal, Or, Xor } from '../predicates/index.js'
+import type { Digit, DigitArray } from './Digit.js'
+import type { IsPositive } from './IsPositive.js'
+import type { IsWhole } from './IsWhole.js'
+import type { Max } from './Max.js'
 
 export type GreaterThan<A extends number, B extends number, Fail = never> =
-  And<
-    And<IsPositive<A>, IsWhole<A>>,
-    And<IsPositive<B>, IsWhole<B>>
-  > extends false ? Fail :
+  And<IsWhole<A>, IsWhole<B>> extends false ? Fail :
   number extends A ? Fail :
   number extends B ? Fail :
   Equal<A, B> extends true ? false :
-  GreaterThan.OnPositiveWhole<A, B>
+  Xor<IsPositive<A>, IsPositive<B>> extends true ? IsPositive<A> :
+  Or<IsPositive<A>, IsPositive<B>> extends false ? GreaterThan.ForWholeNumber<B, A> :
+  GreaterThan.ForWholeNumber<A, B>
 
 export namespace GreaterThan {
-  export type OnPositiveWhole<A extends number, B extends number> = (
-    DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ?
-    DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ?
+  export type ForWholeNumber<A extends number, B extends number> = (
+    DigitArray.FromNumberAbs<A> extends infer DA ? DA extends number[] ?
+    DigitArray.FromNumberAbs<B> extends infer DB ? DB extends number[] ?
     Max<DA['length'], DB['length']> extends infer M ? M extends number ?
     PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ?
     PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ?
-    OnDigitArray<PDA, PDB>
+    ForDigitArray<PDA, PDB>
     : never : never
     : never : never
     : never : never
@@ -30,9 +29,9 @@ export namespace GreaterThan {
     : never : never
   )
 
-  export type OnDigitArray<DA extends number[], DB extends number[]> = (
+  export type ForDigitArray<DA extends number[], DB extends number[]> = (
     Equal<Head<DA>, Head<DB>> extends true
-    ? OnDigitArray<Tail<DA>, Tail<DB>>
+    ? ForDigitArray<Tail<DA>, Tail<DB>>
     : Digit.GreaterThan<Head<DA>, Head<DB>>
   )
 }

package/ts/math/Max.ts

@@ -1,32 +1,8 @@
-import type { Head, Tail } from '../array'
-import type { And, Equal } from '../predicates'
-import type { Digit, DigitArray } from './Digit'
-import type { IsPositive } from './IsPositive'
-import type { IsWhole } from './IsWhole'
+import type { Equal } from '../predicates/index.js'
+import { GreaterThan } from './GreaterThan.js'
 
 export type Max<A extends number, B extends number, Fail = never> =
-  And<IsPositive<A>, IsWhole<A>> extends false ? Fail :
-  And<IsPositive<B>, IsWhole<B>> extends false ? Fail :
-  number extends A ? Fail :
-  number extends B ? Fail :
-  Equal<A, B> extends true ? A :
-  Max.OnPositiveWhole<A, B>
-
-export namespace Max {
-  export type OnPositiveWhole<A extends number, B extends number> = (
-    DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ?
-    DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ?
-    OnDigitArray<DA, DB> extends DA ? A : B
-    : never : never
-    : never : never
-  )
-
-  export type OnDigitArray<DA extends number[], DB extends number[]> =
-    Equal<DA['length'], DB['length']> extends true
-    ? (Equal<Head<DA>, Head<DB>> extends true
-      ? (Tail<DA> extends infer TDA ? TDA extends number[] ?
-        OnDigitArray<TDA, Tail<DB>> extends TDA ? DA : DB
-        : never : never)
-      : Digit.GreaterThan<Head<DA>, Head<DB>> extends true ? DA : DB)
-    : OnPositiveWhole<DA['length'], DB['length']> extends DA['length'] ? DA : DB
-}
+  GreaterThan<A, B> extends infer Result ?
+  Equal<Result, never> extends true ? Fail :
+  Result extends true ? A : B
+  : never

package/ts/math/Subtract.ts

@@ -1,10 +1,10 @@
-import type { PadLeft, Some, Tail } from '../array'
-import type { And } from '../predicates'
+import type { PadLeft, Some, Tail } from '../array/index.js'
+import type { And } from '../predicates/index.js'
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import type { Digit, DigitArray } from './Digit'
-import type { IsPositive } from './IsPositive'
-import type { IsWhole } from './IsWhole'
-import type { Max } from './Max'
+import type { Digit, DigitArray } from './Digit.js'
+import type { IsPositive } from './IsPositive.js'
+import type { IsWhole } from './IsWhole.js'
+import type { Max } from './Max.js'
 
 export type Subtract<A extends number, B extends number, Fail = never> =
   And<

package/ts/math/index.ts

@@ -1,8 +1,8 @@
-export type { Abs } from './Abs'
-export type { Add, Increment } from './Add'
-export type { Digit, DigitArray } from './Digit'
-export type { GreaterThan } from './GreaterThan'
-export type { IsPositive } from './IsPositive'
-export type { IsWhole } from './IsWhole'
-export type { Max } from './Max'
-export type { Decrement, Subtract } from './Subtract'
+export type { Abs } from './Abs.js'
+export type { Add, Increment } from './Add.js'
+export type { Digit, DigitArray } from './Digit.js'
+export type { GreaterThan } from './GreaterThan.js'
+export type { IsPositive } from './IsPositive.js'
+export type { IsWhole } from './IsWhole.js'
+export type { Max } from './Max.js'
+export type { Decrement, Subtract } from './Subtract.js'

package/ts/nodejs/index.ts

@@ -1 +1 @@
-export * from './isNodeError'
+export * from './isNodeError.js'

package/ts/nominal-types/Brand.ts

@@ -1,8 +1,8 @@
 // By Drew Colthorp, <https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/#comment-604580>
 // <https://gist.github.com/dcolthorp/aa21cf87d847ae9942106435bf47565d>
 
-import { Widen } from '../utils'
-import { typeSym, valueSym } from './types'
+import { Widen } from '../utils/index.js'
+import { typeSym, valueSym } from './types.js'
 
 /**
  * Create a "branded" version of a type.

package/ts/nominal-types/Flavor.ts

@@ -1,32 +1,32 @@
-// By Drew Colthorp, <https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/#comment-604580>
-// <https://gist.github.com/dcolthorp/aa21cf87d847ae9942106435bf47565d>
-
-import { Widen } from '../utils'
-import { typeSym } from './types'
-
-/**
- * Create a "flavored" version of a type.
- * TypeScript will disallow mixing flavors,
- * but will allow unflavored values of that type to be passed in where a flavored version is expected.
- * This is a less restrictive form of branding.
- */
-export type Flavor<F extends string, T> = T & {
-  [typeSym]?: F
-}
-
-/**
- * Creates a brand creator with the specified type.
- */
-export function flavor<F extends string>(type: F): <T>(subject: T) => Flavor<F, Widen<T>>
-/**
- * Creates a branded value of specified type.
- */
-export function flavor<F extends string, T>(type: F, subject: T): Flavor<F, Widen<T>>
-export function flavor(type: string, subject?: unknown) {
-  if (subject === undefined) return function <T>(subject: T) { return flavor(type, subject) }
-  if (typeof subject === 'object' && subject !== null) {
-    // if subject is not an object, the branding will exist only in type-level.
-    (subject as { [typeSym]: string })[typeSym] = type
-  }
-  return subject
-}
+// By Drew Colthorp, <https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/#comment-604580>
+// <https://gist.github.com/dcolthorp/aa21cf87d847ae9942106435bf47565d>
+
+import type { Widen } from '../utils/index.js'
+import { typeSym } from './types.js'
+
+/**
+ * Create a "flavored" version of a type.
+ * TypeScript will disallow mixing flavors,
+ * but will allow unflavored values of that type to be passed in where a flavored version is expected.
+ * This is a less restrictive form of branding.
+ */
+export type Flavor<F extends string, T> = T & {
+  [typeSym]?: F
+}
+
+/**
+ * Creates a brand creator with the specified type.
+ */
+export function flavor<F extends string>(type: F): <T>(subject: T) => Flavor<F, Widen<T>>
+/**
+ * Creates a branded value of specified type.
+ */
+export function flavor<F extends string, T>(type: F, subject: T): Flavor<F, Widen<T>>
+export function flavor(type: string, subject?: unknown) {
+  if (subject === undefined) return function <T>(subject: T) { return flavor(type, subject) }
+  if (typeof subject === 'object' && subject !== null) {
+    // if subject is not an object, the branding will exist only in type-level.
+    (subject as { [typeSym]: string })[typeSym] = type
+  }
+  return subject
+}

package/ts/nominal-types/index.ts

@@ -1,3 +1,3 @@
-export * from './Brand'
-export * from './Flavor'
-export * from './nominalMatch'
+export * from './Brand.js'
+export * from './Flavor.js'
+export * from './nominalMatch.js'

package/ts/nominal-types/nominalMatch.ts

@@ -1,6 +1,6 @@
-import { Brand } from './Brand'
-import { Flavor } from './Flavor'
-import { typeSym } from './types'
+import type { Brand } from './Brand.js'
+import type { Flavor } from './Flavor.js'
+import { typeSym } from './types.js'
 
 export function nominalMatch<A extends string, B extends A>(a: Brand<A, unknown>, b: Brand<B, unknown>): boolean
 export function nominalMatch<A extends string, B extends A>(a: Flavor<A, unknown>, b: Flavor<B, unknown>): boolean