type-plus 3.12.1 → 3.14.0

package/src/object/RecursiveIntersect.spec.ts

@@ -1,7 +1,7 @@
 import { RecursiveIntersect } from '..'
 
 test('add object type to types', () => {
-  type U = { u: number };
+  type U = { u: number }
 
   acceptU(addU('a'))
   acceptU(addU(1))
@@ -29,8 +29,8 @@ test('add object type to types', () => {
   // acceptU(comArr[0])
   // acceptU(comArr[0].x)
 
-  function addU<T>(x: T): RecursiveIntersect<typeof x, U> {
-    return x as any
+  function addU<T>(x: T): RecursiveIntersect<T, U> {
+    return x as any as RecursiveIntersect<T, U>
   }
 
   function acceptU(x: U) {

package/src/object/Required.spec.ts

@@ -7,7 +7,7 @@ test('make picked properties required', () => {
     c: number,
   }
 
-  const y: RequiredPick<Foo, 'a'> = { a: 1, c: 2 } as any
+  const y: RequiredPick<Foo, 'a'> = { a: 1, c: 2 }
 
   assertType.noUndefined(y.a)
   y.b = undefined
@@ -21,7 +21,7 @@ test('make not picked properties required', () => {
     c: number,
   }
 
-  const y: RequiredExcept<Foo, 'a'> = { b: 1, c: 2 } as any
+  const y: RequiredExcept<Foo, 'a'> = { b: 1, c: 2 }
 
   y.a = undefined
   assertType.noUndefined(y.b)

package/src/object/facade.ts

@@ -19,14 +19,17 @@ 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
         },
       })

package/src/object/getField.spec.ts

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

package/src/object/getField.ts

@@ -16,6 +16,6 @@ export function getField<
   TX extends Exclude<T, undefined | null>,
   K extends UnionKeys<TX>,
   DV extends Exclude<TX[K], undefined>
->(subject: T, key: K, defaultValue?: DV): DV {
-  return subject && (subject as any)[key] || defaultValue
+>(subject: T, key: K, defaultValue?: DV) {
+  return subject && (subject as unknown as { [k in K]: TX[K] | DV })[key] || defaultValue
 }

package/src/object/hasKey.ts

@@ -3,5 +3,5 @@ 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 any
+  return !keys.some(key => !subject[key]) as unknown as HasKey<T, K>
 }

package/src/object/hasProperty.spec.ts

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

package/src/object/mapProperties.spec.ts

@@ -1,12 +1,12 @@
 import { mapProperties } from '..'
 
 test('basic usage', () => {
-  const actual = mapProperties({ a: 1, b: 2 }, (v, k) => k + (v * 2))
+  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 + v)
+  const actual = mapProperties({ a: 1, b: 'b' }, (v, k) => k + String(v))
   expect(actual).toEqual({ a: 'a1', b: 'bb' })
 })
 

package/src/object/omit.spec.ts

@@ -14,12 +14,12 @@ describe('Omit', () => {
     }
 
     type Actual = Omit<Foo, 'c'>
-    const a: Actual = { a: 0, b: '' } as any
+    const a: Actual = { a: 0, b: '' }
     assertType.isNumber(a.a)
     assertType.isString(a.b)
 
     type Revert = Omit<Foo, keyof Actual>
-    const r: Revert = { c: false } as any
+    const r: Revert = { c: false }
     assertType.isBoolean(r.c)
   })
 
@@ -38,7 +38,7 @@ describe('Omit', () => {
       payload: string,
     }
 
-    const x: Omit<Action, 'id'> = {} as any
+    const x: Omit<Action, 'id'> = { type: 'return', payload: '' }
 
     const actions: Action[] = []
 
@@ -92,13 +92,13 @@ describe('Except()', () => {
     }
 
     type Actual = Except<Foo, 'c'>
-    const a: Actual = { a: 0, b: '' } as any
+    const a: Actual = { a: 0, b: '' }
     assertType.isNumber(a.a)
     assertType.isString(a.b)
 
     // tslint:disable-next-line: deprecation
     type Revert = Except<Foo, keyof Actual>
-    const r: Revert = { c: false } as any
+    const r: Revert = { c: false }
     assertType.isBoolean(r.c)
   })
 })

package/src/object/omit.ts

@@ -32,5 +32,5 @@ export function omit<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<
   return reduceByKey(subject, (p, k) => {
     if (props.indexOf(k) === -1) p[k] = subject[k]
     return p
-  }, {} as any)
+  }, {} as AnyRecord)
 }

package/src/object/pick.spec.ts

@@ -21,7 +21,7 @@ test('distributive pick', () => {
     payload: string,
   }
 
-  const x: Pick<Action, 'type' | 'payload'> = {} as any
+  const x: Pick<Action, 'type' | 'payload'> = { type: 'invoke', payload: [] }
 
   const actions: Action[] = []
 

package/src/object/pick.ts

@@ -18,7 +18,7 @@ export function pick<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<
   return reduceByKey(subject, (p, k) => {
     if (props.indexOf(k) >= 0) p[k] = subject[k]
     return p
-  }, {} as any)
+  }, {} as T)
 }
 
 /**

package/src/object/typeOverrideIncompatible.ts

@@ -5,6 +5,6 @@ export function typeOverrideIncompatible<A extends AnyRecord>() {
     return {
       ...source,
       ...override,
-    } as any
+    }
   }
 }

package/src/predicates/CanAssign.ts

@@ -1,12 +1,15 @@
 import { NotExtendable } from './Extends'
+import { IsEmptyObject } from './isEmptyObject'
 
 /**
  * Can `A` assign to `B`
  */
 export type CanAssign<A, B, Then = true, Else = false> =
-  boolean extends A ?
-  boolean extends B ? Then : Else :
-  A extends B ? Then : Else
+  IsEmptyObject<A> extends true
+  ? Record<string, unknown> extends B ? Then : Else
+  : boolean extends A
+  ? (boolean extends B ? Then : Else)
+  : A extends B ? Then : Else
 
 
 export type IsAssign<A, B, Then = true, Else = false> = CanAssign<A, B, Then, Else>

package/src/predicates/index.ts

@@ -4,6 +4,7 @@ export * from './Extends'
 export * from './If'
 export * from './isType'
 export * from './logical'
+export * from './isEmptyObject'
 
 import { IsExtend } from './Extends'
 

package/src/predicates/isEmptyObject.spec.ts

@@ -0,0 +1,15 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import { IsEmptyObject } from '..'
+import { isType } from './isType'
+
+test('true for {}', () => {
+  isType.t<IsEmptyObject<{}>>()
+})
+test('false for everything else', () => {
+  isType.f<IsEmptyObject<undefined>>()
+  isType.f<IsEmptyObject<false>>()
+  isType.f<IsEmptyObject<0>>()
+  isType.f<IsEmptyObject<''>>()
+  isType.f<IsEmptyObject<{ a: 1 }>>()
+})
+

package/src/predicates/isEmptyObject.ts

@@ -0,0 +1,2 @@
+/* eslint-disable @typescript-eslint/ban-types */
+export type IsEmptyObject<T> = T extends {} ? {} extends T ? true : false : false

package/src/predicates/isType.spec.ts

@@ -27,7 +27,7 @@ describe('isType()', () => {
         assertType<boolean>(s)
     })
     test('exclude type if type guard fails', () => {
-      const s: string | number = 1 as any
+      const s: string | number = 1
       if (isType<string>(s, s => typeof s === 'string')) {
         assertType<string>(s)
       }
@@ -44,7 +44,7 @@ describe('isType()', () => {
     })
     test('Class as validator fails', () => {
       class Foo { a() { } }
-      const s: Foo | number = 1 as any
+      const s: Foo | number = 1
       if (isType(s, Foo)) {
         assertType<Foo>(s)
       }

package/src/predicates/isType.ts

@@ -1,10 +1,10 @@
-import { isConstructor } from '../class'
+import { AnyConstructor, isConstructor } from '../class'
 import { Equal } from './Equal'
 
 export function isType<T>(subject: T): subject is T
 export function isType<T>(subject: unknown, validator: (s: T) => boolean): subject is T
-export function isType<T extends new (...args: any) => any>(subject: unknown, constructor: T): subject is InstanceType<T>
-export function isType(subject: any, validator?: any) {
+export function isType<T extends AnyConstructor>(subject: unknown, constructor: T): subject is InstanceType<T>
+export function isType(subject: unknown, validator?: AnyConstructor | ((s: unknown) => boolean)) {
   if (validator) {
     if (isConstructor(validator))
       return subject instanceof validator
@@ -14,13 +14,11 @@ export function isType(subject: any, validator?: any) {
   return true
 }
 
-const sym = Symbol()
-
-isType.t = function <T extends true>(subject: T = sym as any) {
-  return (subject as any) === sym || subject === true
+isType.t = function <T extends true>(subject?: T) {
+  return subject === undefined || subject === true
 }
-isType.f = function <T extends false>(subject: T = sym as any) {
-  return (subject as any) === sym || subject === false
+isType.f = function <T extends false>(subject?: T) {
+  return subject === undefined || subject === false
 }
 
 /**

package/src/promise/PromiseValue.spec.ts

@@ -1,6 +1,6 @@
 import { assertType, PromiseValue } from '..'
 
 test('extract value from Promise', () => {
-  const y: PromiseValue<Promise<string>> = '' as any
+  const y: PromiseValue<Promise<string>> = ''
   assertType.isString(y)
 })

package/src/promise/isPromise.ts

@@ -1,3 +1,4 @@
-export function isPromise<R = any>(subject: any): subject is Promise<R> {
-  return !!subject && typeof subject.then === 'function'
+export function isPromise<R = any>(subject: unknown): subject is Promise<R> {
+  // @ts-ignore
+  return !!subject && typeof subject['then'] === 'function'
 }

package/src/promise/mapSeries.ts

@@ -1,9 +1,5 @@
 export function mapSeries<R, T = any>(values: T[], fn: (value: T) => Promise<R>): Promise<R[]> {
-  const results: R[] = []
-  return values.reduce((p, v) => {
-    return p.then(() => fn(v)).then((r: any) => {
-      results.push(r)
-      return results
-    })
-  }, Promise.resolve() as any)
+  return values.reduce(
+    (p, v) => p.then(r => fn(v).then(v => (r.push(v), r))),
+    Promise.resolve<R[]>([]))
 }

package/src/type-checker/AnyType.ts

@@ -9,5 +9,5 @@ export const any: Any = { type: 'any', value: undefined }
 export const anySpec: TypeSpec<Any> = {
   type: any,
   toAnalysis: (options, value, _subject) => ({ type: 'any', value }),
-  toNative: (value) => value as any
+  toNative: (value) => value
 }

package/src/types/satisfy.accept.ts

@@ -29,7 +29,9 @@ const eslint = T.object.create({
 
 baseline('fixtures/eslint', ({ caseName, caseFolder }) => {
   test(`eslint ${caseName}`, () => {
-    const config = JSON.parse(fs.readFileSync(`${path.join(caseFolder, caseName)}`, 'utf-8'))
+    const config: unknown = JSON.parse(
+      fs.readFileSync(`${path.join(caseFolder, caseName)}`, 'utf-8')
+    )
 
     if (!T.satisfy(eslint, config)) fail('should satisfy')
   })