type-plus 4.9.1 → 4.10.0

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,5 +1,5 @@
-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

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> = {

package/ts/math/GreaterThan.ts

@@ -1,9 +1,9 @@
-import type { Head, PadLeft, Tail } from '../array'
-import type { And, Equal, Or, Xor } 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<IsWhole<A>, IsWhole<B>> extends false ? Fail :

package/ts/math/Max.ts

@@ -1,5 +1,5 @@
-import type { Equal } from '../predicates'
-import { GreaterThan } from './GreaterThan'
+import type { Equal } from '../predicates/index.js'
+import { GreaterThan } from './GreaterThan.js'
 
 export type Max<A extends number, B extends number, Fail = never> =
   GreaterThan<A, B> extends infer Result ?

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

package/ts/object/ANotB.ts

@@ -1,21 +1,21 @@
-import { Equal } from '../predicates'
-import { AnyRecord } from './AnyRecord'
-import { IsDisjoint } from './IsDisjoint'
-import { KeysWithDiffType } from './KeysWithDiffType'
-
-export type ANotB<A extends AnyRecord, B extends AnyRecord> =
-  Equal<A, B> extends true
-  ? never
-  : (IsDisjoint<A, B> extends true
-    ? A
-    : { [k in Exclude<keyof A, keyof B> | KeysWithDiffType<A, B>]: A[k] })
-
-export type BNotA<A extends AnyRecord, B extends AnyRecord> = ANotB<B, A>
-
-export type LeftJoin<A extends AnyRecord, B extends AnyRecord> =
-  Equal<A, B> extends true
-  ? A
-  : (IsDisjoint<A, B> extends true
-    ? A & B
-    : { [k in Exclude<keyof A, keyof B>]: A[k] } & { [k in keyof B]: B[k] }
-  )
+import type { Equal } from '../predicates/index.js'
+import type { AnyRecord } from './AnyRecord.js'
+import type { IsDisjoint } from './IsDisjoint.js'
+import type { KeysWithDiffType } from './KeysWithDiffType.js'
+
+export type ANotB<A extends AnyRecord, B extends AnyRecord> =
+  Equal<A, B> extends true
+  ? never
+  : (IsDisjoint<A, B> extends true
+    ? A
+    : { [k in Exclude<keyof A, keyof B> | KeysWithDiffType<A, B>]: A[k] })
+
+export type BNotA<A extends AnyRecord, B extends AnyRecord> = ANotB<B, A>
+
+export type LeftJoin<A extends AnyRecord, B extends AnyRecord> =
+  Equal<A, B> extends true
+  ? A
+  : (IsDisjoint<A, B> extends true
+    ? A & B
+    : { [k in Exclude<keyof A, keyof B>]: A[k] } & { [k in keyof B]: B[k] }
+  )

package/ts/object/IsDisjoint.ts

@@ -1,12 +1,12 @@
-import { And, Not } from '../predicates'
-import { AnyRecord } from './AnyRecord'
-import { HasKey } from './hasKey'
-
-/**
- * Are the two records disjoint from each other.
- * Disjoint means no common property.
- */
-export type IsDisjoint<
-  A extends AnyRecord,
-  B extends AnyRecord
-  > = And<Not<HasKey<A, keyof B>>, Not<HasKey<B, keyof A>>>
+import { And, Not } from '../predicates/index.js'
+import type { AnyRecord } from './AnyRecord.js'
+import { HasKey } from './hasKey.js'
+
+/**
+ * Are the two records disjoint from each other.
+ * Disjoint means no common property.
+ */
+export type IsDisjoint<
+  A extends AnyRecord,
+  B extends AnyRecord
+  > = And<Not<HasKey<A, keyof B>>, Not<HasKey<B, keyof A>>>

package/ts/object/KeysWithDiffType.ts

@@ -1,6 +1,6 @@
-import { ValueOf } from './ValueOf'
-import { IsDisjoint } from './IsDisjoint'
-import { AnyRecord } from './AnyRecord'
+import { ValueOf } from './ValueOf.js'
+import type { IsDisjoint } from './IsDisjoint.js'
+import type { AnyRecord } from './AnyRecord.js'
 
 export type KeysWithDiffType<A extends AnyRecord, B extends AnyRecord> =
   IsDisjoint<A, B> extends true ? never :

package/ts/object/KnownKeys.ts

@@ -2,7 +2,7 @@
 // known from Gerrit Birkeland @Gerrit0
 // https://github.com/Microsoft/TypeScript/issues/25987#issuecomment-408339599
 
-import { PrimitiveTypes } from '../PrimitiveTypes'
+import { PrimitiveTypes } from '../PrimitiveTypes.js'
 
 // https://github.com/microsoft/TypeScript/issues/25987#issuecomment-441224690
 export type KnownKeys<T> =

package/ts/object/OptionalKeys.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import { KeyTypes } from './KeyTypes.js'
 
 export type OptionalKeys<O extends Record<KeyTypes, any>> = O extends unknown
 ? OptionalKeys._<O>

package/ts/object/Partial.ts

@@ -1,6 +1,6 @@
-import { UnionKeys } from '../UnionKeys'
-import { Omit } from './omit'
-import { Pick } from './pick'
+import { UnionKeys } from '../UnionKeys.js'
+import { Omit } from './omit.js'
+import { Pick } from './pick.js'
 
 /**
  * Apply `Partial<>` on the selected properties.

package/ts/object/RecursiveIntersect.ts

@@ -1,4 +1,4 @@
-import { AnyRecord } from './AnyRecord'
+import type { AnyRecord } from './AnyRecord.js'
 
 /**
  * Intersect type recursively.

package/ts/object/RecursivePartial.ts

@@ -1,4 +1,4 @@
-import { AnyRecord } from './AnyRecord'
+import type { AnyRecord } from './AnyRecord.js'
 
 // Source: https://stackoverflow.com/questions/41980195/recursive-partialt-in-typescript-2-1
 export type RecursivePartial<T> = {

package/ts/object/RecursiveRequired.ts

@@ -1,4 +1,4 @@
-import { AnyRecord } from './AnyRecord'
+import type { AnyRecord } from './AnyRecord.js'
 
 export type RecursiveRequired<T> = {
   [P in keyof T]-?:

package/ts/object/RequiredKeys.ts

@@ -1,5 +1,5 @@
-import { KeyTypes } from './KeyTypes'
-import { OptionalKeys } from './OptionalKeys'
+import type { KeyTypes } from './KeyTypes.js'
+import type { OptionalKeys } from './OptionalKeys.js'
 
 export type RequiredKeys<T extends Record<KeyTypes, any>> = T extends unknown
 ? RequiredKeys._<T> : never

package/ts/object/SpreadRecord.ts

@@ -1,6 +1,6 @@
-import { Omit } from '../object'
-
-export type SpreadRecord<
-A extends Record<any, any>,
-B extends Record<any, any>
-> = Omit<A, Extract<keyof A, keyof B>> & B
+import type { Omit } from '../object/index.js'
+
+export type SpreadRecord<
+A extends Record<any, any>,
+B extends Record<any, any>
+> = Omit<A, Extract<keyof A, keyof B>> & B

package/ts/object/everyKey.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import type { KeyTypes } from './KeyTypes.js'
 
 export function everyKey<S extends Record<KeyTypes, any>, T = any>(
   subject: S,

package/ts/object/facade.ts

@@ -1,39 +1,39 @@
-import { AnyRecord } from './AnyRecord'
-
-/**
- * creates a facade of the subject.
- */
-export function facade<T extends AnyRecord, P1 extends keyof T>(subject: T, prop1: P1): Pick<T, P1>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T>(subject: T, prop1: P1, prop2: P2): Pick<T, P1 | P2>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3): Pick<T, P1 | P2 | P3>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Pick<T, P1 | P2 | P3 | P4>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Pick<T, P1 | P2 | P3 | P4 | P5>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Pick<T, P1 | P2 | P3 | P4 | P5 | P6>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T, P10 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T, P10 extends keyof T, P11 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T, P10 extends keyof T, P11 extends keyof T, P12 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11, prop12: P12): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
-export function facade<T extends AnyRecord>(subject: T, ...props: (keyof T)[]) {
-  return props.reduce((p, k) => {
-    const prop = subject[k]
-    if (typeof prop === 'function') {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
-      p[k] = prop.bind(subject)
-    }
-    else {
-      Object.defineProperty(p, k, {
-        get() {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-          return subject[k]
-        },
-        set(value: any) {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment
-          return subject[k] = value
-        },
-      })
-    }
-    return p
-  }, {} as T)
-}
+import type { AnyRecord } from './AnyRecord.js'
+
+/**
+ * creates a facade of the subject.
+ */
+export function facade<T extends AnyRecord, P1 extends keyof T>(subject: T, prop1: P1): Pick<T, P1>
+export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T>(subject: T, prop1: P1, prop2: P2): Pick<T, P1 | P2>
+export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3): Pick<T, P1 | P2 | P3>
+export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Pick<T, P1 | P2 | P3 | P4>
+export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Pick<T, P1 | P2 | P3 | P4 | P5>
+export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Pick<T, P1 | P2 | P3 | P4 | P5 | P6>
+export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
+export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
+export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
+export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T, P10 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
+export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T, P10 extends keyof T, P11 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
+export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T, P10 extends keyof T, P11 extends keyof T, P12 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11, prop12: P12): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
+export function facade<T extends AnyRecord>(subject: T, ...props: (keyof T)[]) {
+  return props.reduce((p, k) => {
+    const prop = subject[k]
+    if (typeof prop === 'function') {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+      p[k] = prop.bind(subject)
+    }
+    else {
+      Object.defineProperty(p, k, {
+        get() {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+          return subject[k]
+        },
+        set(value: any) {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment
+          return subject[k] = value
+        },
+      })
+    }
+    return p
+  }, {} as T)
+}

package/ts/object/filterKey.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import { KeyTypes } from './KeyTypes.js'
 
 export function filterKey<S extends Record<KeyTypes, any>, T = any>(
   subject: S,

package/ts/object/findKey.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import { KeyTypes } from './KeyTypes.js'
 
 export function findKey<S extends Record<KeyTypes, any>, T = any>(
   subject: S,

package/ts/object/forEachKey.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import { KeyTypes } from './KeyTypes.js'
 
 export function forEachKey<S extends Record<KeyTypes, any>, T = any>(
   subject: S,

package/ts/object/getField.ts

@@ -1,4 +1,4 @@
-import { UnionKeys } from '../UnionKeys'
+import { UnionKeys } from '../UnionKeys.js'
 
 export function getField<
   T,

package/ts/object/hasKey.ts

@@ -1,7 +1,7 @@
-import { AnyRecord } from './AnyRecord'
-
-export type HasKey<T, K, Then = true, Else = false> = K extends keyof T ? Then : Else
-
-export function hasKey<T extends AnyRecord, K extends string>(subject: T, ...keys: K[]): HasKey<T, K> {
-  return !keys.some(key => !subject[key]) as unknown as HasKey<T, K>
-}
+import type { AnyRecord } from './AnyRecord.js'
+
+export type HasKey<T, K, Then = true, Else = false> = K extends keyof T ? Then : Else
+
+export function hasKey<T extends AnyRecord, K extends string>(subject: T, ...keys: K[]): HasKey<T, K> {
+  return !keys.some(key => !subject[key]) as unknown as HasKey<T, K>
+}

package/ts/object/hasProperty.ts

@@ -1,4 +1,4 @@
-import { UnionKeys } from '../UnionKeys'
+import { UnionKeys } from '../UnionKeys.js'
 
 export function hasProperty<T, P extends UnionKeys<T>>(value: T, prop: P): value is T & Record<P, T[P]> {
   return !!value[prop]