type-plus 4.8.2 → 4.10.0

package/ts/object/ExcludePropType.spec.ts

@@ -1,13 +0,0 @@
-import { assertType, ExcludePropType } from '..'
-
-test('exclude type R from properties of T', () => {
-  interface Customer {
-    name: string,
-    age: number | null,
-  }
-
-  type CustomerAgeNotNull = ExcludePropType<Customer, null>
-
-  const x: CustomerAgeNotNull = { name: '', age: 0 }
-  assertType.isNumber(x.age)
-})

package/ts/object/IsDisjoint.spec.ts

@@ -1,25 +0,0 @@
-import { isType, IsDisjoint } from '..'
-
-test('disjoint returns true', () => {
-  type A = { a: 1 }
-  type B = { b: 1 }
-  isType.t<IsDisjoint<A, B>>()
-})
-
-test('same type returns false', () => {
-  type A = { a: 1 }
-  type B = { a: 1 }
-  isType.f<IsDisjoint<A, B>>()
-})
-
-test('A subset of B returns false', () => {
-  type A = { a: 1 }
-  type B = { a: 1, b: 1 }
-  isType.f<IsDisjoint<A, B>>()
-})
-
-test('B subset of A returns false', () => {
-  type A = { a: 1, b: 1 }
-  type B = { a: 1 }
-  isType.f<IsDisjoint<A, B>>()
-})

package/ts/object/IsRecord.spec.ts

@@ -1,22 +0,0 @@
-import { assertType, IsRecord } from '..'
-
-test('boolean, number, string, null, undefined, symbol are not record', () => {
-  assertType.isFalse(false as IsRecord<undefined>)
-  assertType.isFalse(false as IsRecord<null>)
-  assertType.isFalse(false as IsRecord<boolean>)
-  assertType.isFalse(false as IsRecord<number>)
-  assertType.isFalse(false as IsRecord<string>)
-  assertType.isFalse(false as IsRecord<symbol>)
-})
-
-test('array is not record', () => {
-  assertType.isFalse(false as IsRecord<[]>)
-})
-
-test('object is record', () => {
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  assertType.isTrue(true as IsRecord<{}>)
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  assertType.isTrue(true as IsRecord<object>)
-  assertType.isTrue(true as IsRecord<{ a: string }>)
-})

package/ts/object/KeyTypes.spec.ts

@@ -1,9 +0,0 @@
-import { KeyTypes } from '..'
-
-test('contains type of all keys', () => {
-  acceptKeys('a')
-  acceptKeys(1)
-  acceptKeys(Symbol())
-
-  function acceptKeys(k: KeyTypes) { return k }
-})

package/ts/object/KeyofOptional.spec.ts

@@ -1,8 +0,0 @@
-import { assertType, IsEqual, KeysOfOptional } from '..'
-
-test('get keys from optional type', () => {
-  type X = { o?: { a: string, b: string } }
-  type A = KeysOfOptional<X['o']>
-
-  assertType.isTrue(true as IsEqual<'a' | 'b', A>)
-})

package/ts/object/KeysWithDiffType.spec.ts

@@ -1,21 +0,0 @@
-import { assertType, KeysWithDiffType } from '..'
-
-test('disjoint type gets never', () => {
-  type A = { a: 1 }
-  type B = { b: 2 }
-  const actual = 'a' as KeysWithDiffType<A, B>
-  assertType<never>(actual)
-})
-
-test('key with same type is not included', () => {
-  type A = { a: 1 }
-  const actual = 'a' as KeysWithDiffType<A, A>
-  assertType<never>(actual)
-})
-
-test('key with different type is returned', () => {
-  type A = { a: 1 }
-  type B = { a: 2 }
-  const actual = 'a' as KeysWithDiffType<A, B>
-  assertType<'a'>(actual)
-})

package/ts/object/KnownKeys.spec.ts

@@ -1,39 +0,0 @@
-import { assertType, KnownKeys } from '..'
-
-test('pick out only known keys', () => {
-  type A = {
-    a?: boolean,
-    b?: number,
-    [k: string]: any,
-  }
-
-  const input: A = {}
-  const actual = getKnownKeys(input)
-  assertType<'a' | 'b'>(actual)
-})
-
-test('primitive type yields never', () => {
-  assertType<never>(getKnownKeys(undefined))
-  assertType<never>(getKnownKeys(true))
-  assertType<never>(getKnownKeys(false))
-  assertType<never>(getKnownKeys(null))
-  assertType<never>(getKnownKeys('str'))
-  assertType<never>(getKnownKeys(1))
-  assertType<never>(getKnownKeys({}))
-  assertType<never>(getKnownKeys([]))
-})
-
-test('literal gets keys', () => {
-  assertType<'a'>(getKnownKeys({ a: 1 }))
-})
-
-test('empty record yields never', () => {
-  const x: Record<any, any> = {}
-  const actual = getKnownKeys(x)
-  assertType<never>(actual)
-})
-
-
-function getKnownKeys<T>(_value: T): KnownKeys<T> {
-  return {} as unknown as KnownKeys<T>
-}

package/ts/object/OptionalKeys.spec.ts

@@ -1,23 +0,0 @@
-import { assertType, IsEqual, OptionalKeys } from '..'
-
-test('extract optional keys from object', () => {
-  type X = { a?: string, b: string }
-
-  assertType.isTrue(true as IsEqual<'a', OptionalKeys<X>>)
-})
-test('work with union type', () => {
-  type X = { a?: string, b: string } | { c: string, d?: string }
-
-  type A = OptionalKeys<X>
-  assertType.isTrue(true as IsEqual<'a' | 'd', A>)
-})
-test('no optional keys returns never', () => {
-  type X = { b: string }
-
-  assertType.isTrue(true as IsEqual<never, OptionalKeys<X>>)
-})
-test('keys with undefined value is not optional', () => {
-  type X = { a: string | undefined }
-
-  assertType.isTrue(true as IsEqual<never, OptionalKeys<X>>)
-})

package/ts/object/Partial.spec.ts

@@ -1,49 +0,0 @@
-import { assertType, PartialExcept, PartialOmit, PartialPick } from '..'
-
-test('work on primitive type', () => {
-  type Foo = PartialPick<number, 'toFixed'>
-  const x: Foo = 1
-  assertType<typeof x['toFixed']>(1 as unknown as 1['toFixed'] | undefined)
-})
-
-test('make picked properties optional', () => {
-  type Foo = {
-    a: number,
-    b: number,
-    c: number,
-  }
-
-  const y: PartialPick<Foo, 'a'> = { b: 1, c: 2 }
-
-  y.a = undefined
-  assertType.noUndefined(y.b)
-  assertType.noUndefined(y.c)
-})
-
-test('make not specified properties optional', () => {
-  type Foo = {
-    a: number,
-    b: number,
-    c: number,
-  }
-
-  const y: PartialExcept<Foo, 'a'> = { a: 1 }
-  assertType.noUndefined(y.a)
-  y.b = undefined
-  y.c = undefined
-})
-
-
-test('make not specified properties optional', () => {
-  type Foo = {
-    a: number,
-    b: number,
-    c: number,
-  }
-
-  const y: PartialOmit<Foo, 'a'> = { a: 1 }
-
-  assertType.noUndefined(y.a)
-  y.b = undefined
-  y.c = undefined
-})

package/ts/object/RecursiveIntersect.spec.ts

@@ -1,39 +0,0 @@
-import { RecursiveIntersect } from '..'
-
-test('add object type to types', () => {
-  type U = { u: number }
-
-  acceptU(addU('a'))
-  acceptU(addU(1))
-  acceptU(addU(true))
-  // acceptU(addU(1n))
-  acceptU(addU(undefined))
-  acceptU(addU(null))
-
-  const obj = addU({ x: 1 })
-  acceptU(obj)
-  acceptU(obj.x)
-
-  const comObj = addU({ array: ['a'] })
-  acceptU(comObj)
-  acceptU(comObj.array)
-  acceptU(comObj.array[0])
-
-  const arr = addU(['1'])
-  acceptU(arr)
-  acceptU(arr[0])
-
-  // Not supported
-  // const comArr = addU([{ x: 1 }])
-  // acceptU(comArr)
-  // acceptU(comArr[0])
-  // acceptU(comArr[0].x)
-
-  function addU<T>(x: T): RecursiveIntersect<T, U> {
-    return x as any as RecursiveIntersect<T, U>
-  }
-
-  function acceptU(x: U) {
-    return x
-  }
-})

package/ts/object/RecursiveRequired.spec.ts

@@ -1,57 +0,0 @@
-import t from 'assert'
-import { RecursiveRequired } from '..'
-
-test('simple optional property becomes required', () => {
-  type SimpleOptional = {
-    x?: string,
-  }
-
-  const actual: RecursiveRequired<SimpleOptional> = { x: '' }
-  t.strictEqual(actual.x.length, 0)
-})
-
-test('deep optional object property becomes required', () => {
-  type DeepOptonal = {
-    x: {
-      y?: string,
-    },
-  }
-
-  const actual: RecursiveRequired<DeepOptonal> = { x: { y: '' } }
-  t.strictEqual(actual.x.y.length, 0)
-})
-
-test('deep optional array property becomes required', () => {
-  type DeepArrayOptonal = {
-    x: {
-      y?: string,
-    }[],
-  }
-
-  const actual: RecursiveRequired<DeepArrayOptonal> = { x: [{ y: '' }] }
-  t.strictEqual(actual.x[0].y.length, 0)
-})
-
-// Not supported
-
-// test('simple optional array property becomes required', () => {
-//   type SimpleArrayOptonal = Array<{ y?: string }>
-
-
-//   let actual: RecursiveRequired<SimpleArrayOptonal> = [{ y: '' }]
-//   t.strictEqual(actual[0].y.length, 0)
-// })
-
-// test('deep optional tuple property becomes required', () => {
-//   type DeepArrayOptonal = {
-//     x: [{
-//       y?: string
-//     }, {
-//       z?: string
-//     }]
-//   }
-
-//   let actual: RecursiveRequired<DeepArrayOptonal> = { x: [{ y: '' }, { z: '' }] }
-//   t.strictEqual(actual.x[0].y.length, 0)
-//   t.strictEqual(actual.x[1].z.length, 0)
-// })

package/ts/object/Required.spec.ts

@@ -1,29 +0,0 @@
-import { assertType, RequiredExcept, RequiredPick } from '..'
-
-test('make picked properties required', () => {
-  type Foo = {
-    a?: number,
-    b?: number,
-    c: number,
-  }
-
-  const y: RequiredPick<Foo, 'a'> = { a: 1, c: 2 }
-
-  assertType.noUndefined(y.a)
-  y.b = undefined
-  assertType.noUndefined(y.c)
-})
-
-test('make not picked properties required', () => {
-  type Foo = {
-    a?: number,
-    b?: number,
-    c: number,
-  }
-
-  const y: RequiredExcept<Foo, 'a'> = { b: 1, c: 2 }
-
-  y.a = undefined
-  assertType.noUndefined(y.b)
-  assertType.noUndefined(y.c)
-})

package/ts/object/RequiredKeys.spec.ts

@@ -1,24 +0,0 @@
-import { assertType, IsEqual, RequiredKeys } from '..'
-
-test('extract required keys from object', () => {
-  type X = { a?: string, b: string }
-
-  type A = RequiredKeys<X>
-  assertType.isTrue(true as IsEqual<'b', A>)
-})
-test('work with union type', () => {
-  type X = { a?: string, b: string } | { c: string, d?: string }
-
-  type A = RequiredKeys<X>
-  assertType.isTrue(true as IsEqual<'b' | 'c', A>)
-})
-test('no required keys returns never', () => {
-  type X = { b?: string }
-
-  assertType.isTrue(true as IsEqual<never, RequiredKeys<X>>)
-})
-test('keys with undefined value is required', () => {
-  type X = { a: string | undefined }
-
-  assertType.isTrue(true as IsEqual<'a', RequiredKeys<X>>)
-})

package/ts/object/SpreadRecord.spec.ts

@@ -1,14 +0,0 @@
-import { assertType, Equal, SpreadRecord } from '..'
-
-test('records are combined as intersection', () => {
-  type S = SpreadRecord<{ a: number }, { b: string }>
-  assertType.isTrue(true as Equal<S, { a: number } & { b: string }>)
-})
-
-test('Property in B overrides A', () => {
-  type A = { a: number }
-  type B = { a: string, b: string }
-  type S = SpreadRecord<A, B>
-
-  assertType.isTrue(true as Equal<S, { a: string, b: string }>)
-})

package/ts/object/ValueOf.spec.ts

@@ -1,36 +0,0 @@
-import { isType, ValueOf } from '..'
-
-test('work with primitive type', () => {
-  type A = ValueOf<string>
-  isType.equal<false, never, A>()
-})
-
-test('If all values has the same type, the result is of that type', () => {
-  const HTTP_METHOD = {
-    GET: 'GET',
-    POST: 'POST',
-    DELETE: 'DELETE',
-    PUT: 'PUT',
-  }
-  type A = ValueOf<typeof HTTP_METHOD>
-  isType.equal<true, string, A>()
-})
-
-test('If value has multiple types, the result is the union of those types', () => {
-  const logLevel = {
-    none: '0',
-    error: '1',
-    warn: 2,
-    info: 3,
-    debug: 4,
-  }
-  type A = ValueOf<typeof logLevel>
-  isType.equal<true, string | number, A>()
-})
-
-test('literal types are preserved', () => {
-  type L = { a: 1, b: 2, c: 'a', d: 'b' }
-  type A = ValueOf<L>
-  isType.equal<true, 1 | 2 | 'a' | 'b', A>()
-})
-

package/ts/object/everyKey.spec.ts

@@ -1,11 +0,0 @@
-import { everyKey } from '..'
-
-test('predicate key can be used as indexer of the subject', () => {
-  const subject = { a: 1, b: 2, c: 3 }
-  expect(everyKey(subject, key => typeof subject[key] === 'number')).toBe(true)
-})
-
-test('type this arg', () => {
-  const subject = { b: 2 }
-  expect(everyKey(subject, function () { return this.a === 1 }, { a: 1 })).toBe(true)
-})

package/ts/object/facade.spec.ts

@@ -1,22 +0,0 @@
-import { facade } from '..'
-
-test('facade on property', () => {
-  const subject = { a: 1, b: 2, c: 3 }
-
-  const actual = facade(subject, 'a', 'b')
-  expect(actual.a).toBe(1)
-  expect(actual.b).toBe(2)
-
-  actual.b = 4
-  expect(subject.b).toBe(4)
-})
-
-test('facade on function', () => {
-  const subject = {
-    a: 1,
-    foo() { return this.a },
-  }
-
-  const actual = facade(subject, 'foo')
-  expect(actual.foo()).toBe(1)
-})

package/ts/object/filterKey.spec.ts

@@ -1,8 +0,0 @@
-import t from 'assert'
-import { filterKey } from '..'
-
-test(`return type is 'keyof subject'`, () => {
-  const subject = { a: 1, b: 2, c: 3 }
-  const actual = filterKey(subject, key => subject[key] > 1)
-  t.deepStrictEqual(actual, ['b', 'c'])
-})

package/ts/object/findKey.spec.ts

@@ -1,8 +0,0 @@
-import t from 'assert'
-import { findKey } from '..'
-
-test('predicate key can be used as indexer of the subject', () => {
-  const subject = { a: 1, b: 2, c: 3 }
-  const actual = findKey(subject, key => subject[key] === 2)
-  t.strictEqual(actual, 'b')
-})

package/ts/object/forEachKey.spec.ts

@@ -1,9 +0,0 @@
-import t from 'assert'
-import { forEachKey } from '..'
-
-test('predicate key can be used as indexer of the subject', () => {
-  const subject = { a: 1, b: 2, c: 3 }
-  let actual = 0
-  forEachKey(subject, key => actual += subject[key])
-  t.strictEqual(actual, 6)
-})

package/ts/object/getField.spec.ts

@@ -1,21 +0,0 @@
-import { getField } from '..'
-
-test('support undefined', () => {
-  const sub: { a: number } | undefined = { a: 1 }
-  expect(getField(sub, 'a')).toBe(1)
-})
-
-test('support null', () => {
-  const sub: { a: number } | null = { a: 1 }
-  expect(getField(sub, 'a')).toBe(1)
-})
-
-test('can specify default value', () => {
-  const sub: { a?: number } = { a: undefined }
-  expect(getField(sub, 'a', 2)).toBe(2)
-})
-
-test('get from union keys', () => {
-  const sub: { a: number, b: string } | { a: number, c: string } = { a: 1, b: 'b' }
-  expect(getField(sub, 'b')).toBe('b')
-})

package/ts/object/hasKey.spec.ts

@@ -1,29 +0,0 @@
-import { assertType, HasKey, hasKey } from '..'
-
-describe('HasKey<T, K>', () => {
-  test('true if has key', () => {
-    type Foo = { a: 1, b: 2 }
-    assertType.isTrue(true as HasKey<Foo, 'a'>)
-  })
-
-  test('false if do not have key', () => {
-    type Foo = { a: 1, b: 2 }
-    assertType.isFalse(false as HasKey<Foo, 'c'>)
-  })
-});
-
-describe('hasKey()', () => {
-  test('true if has key', () => {
-    const subject = { a: 1, b: 2 }
-
-    expect(hasKey(subject, 'a')).toBeTruthy()
-    expect(hasKey(subject, 'b')).toBeTruthy()
-    expect(hasKey(subject, 'a', 'b')).toBeTruthy()
-  })
-  test('false if do not have key', () => {
-    const subject = { a: 1, b: 2 }
-
-    expect(hasKey(subject, 'c')).toBeFalsy()
-    expect(hasKey(subject, 'a', 'c')).toBeFalsy()
-  })
-});

package/ts/object/hasProperty.spec.ts

@@ -1,15 +0,0 @@
-import { hasProperty } from '..'
-
-test('hasProperty', () => {
-  type X = { name: string } & ({ a: 1 } | { b: 2 })
-
-  const x: X = { name: 'n', a: 1 }
-
-  if (hasProperty(x, 'a'))
-    expect(x.a).toBe(1)
-
-  const y: X = { name: 'n', b: 2 }
-
-  if (hasProperty(y, 'b'))
-    expect(y.b).toBe(2)
-})

package/ts/object/mapKey.spec.ts

@@ -1,8 +0,0 @@
-import a from 'assertron'
-import { mapKey } from '..'
-
-test('predicate key can be used as indexer of the subject', () => {
-  const subject = { a: 1, b: 2, c: 3 }
-  const actual = mapKey(subject, key => subject[key] + 1)
-  a.satisfies(actual, [2, 3, 4])
-})

package/ts/object/mapProperties.spec.ts

@@ -1,27 +0,0 @@
-import { mapProperties } from '..'
-
-test('basic usage', () => {
-  const actual = mapProperties({ a: 1, b: 2 }, (v, k) => k + String((v * 2)))
-  expect(actual).toEqual({ a: 'a2', b: 'b4' })
-})
-
-test('mixed type', () => {
-  const actual = mapProperties({ a: 1, b: 'b' }, (v, k) => k + String(v))
-  expect(actual).toEqual({ a: 'a1', b: 'bb' })
-})
-
-test('extract value from prop', () => {
-  const actual = mapProperties({ a: { foo: 'x' }, b: { foo: 'y' } }, (v) => v.foo)
-  expect(actual).toEqual({ a: 'x', b: 'y' })
-})
-
-test('parent props are not mapped', () => {
-  class Boo {
-    shared(v: number) { return v * 2 }
-    own = (v: number) => v * 3
-  }
-  const boo = new Boo()
-
-  const actual = mapProperties(boo, (v) => v(2))
-  expect(actual).toEqual({ own: 6 })
-})