Improve types

Author: ehmicky

types/main.test-d.ts

@@ -1,4 +1,4 @@
-import modernErrors from 'modern-errors'
+import ModernError from 'modern-errors'
 import plugin, { Options, HttpResponse } from 'modern-errors-http'
 import {
   expectType,
@@ -7,71 +7,116 @@ import {
   expectError,
 } from 'tsd'
 
-const BaseError = modernErrors([plugin])
-const error = new BaseError('', { cause: '' })
+const BaseError = ModernError.subclass('BaseError', { plugins: [plugin] })
+const error = new BaseError('')
 const httpResponse = error.httpResponse()
 
-modernErrors([plugin], { http: {} })
+ModernError.subclass('TestError', { plugins: [plugin], http: {} })
 error.httpResponse({})
 expectAssignable<Options>({})
 expectError(error.httpResponse(undefined))
 expectNotAssignable<Options>(undefined)
-expectError(modernErrors([plugin], { http: true }))
+expectError(
+  ModernError.subclass('TestError', { plugins: [plugin], http: true }),
+)
 expectError(error.httpResponse(true))
 expectNotAssignable<Options>(true)
-expectError(modernErrors([plugin], { http: { unknown: true } }))
+expectError(
+  ModernError.subclass('TestError', {
+    plugins: [plugin],
+    http: { unknown: true },
+  }),
+)
 expectError(error.httpResponse({ unknown: true }))
 expectNotAssignable<Options>({ unknown: true })
 
-modernErrors([plugin], { http: { type: '' } })
+ModernError.subclass('TestError', { plugins: [plugin], http: { type: '' } })
 error.httpResponse({ type: '' })
 expectAssignable<Options>({ type: '' })
-expectError(modernErrors([plugin], { http: { type: true } }))
+expectError(
+  ModernError.subclass('TestError', {
+    plugins: [plugin],
+    http: { type: true },
+  }),
+)
 expectError(error.httpResponse({ type: true }))
 expectNotAssignable<Options>({ type: true })
 
-modernErrors([plugin], { http: { status: 200 } })
+ModernError.subclass('TestError', { plugins: [plugin], http: { status: 200 } })
 error.httpResponse({ status: 200 })
 expectAssignable<Options>({ status: 200 })
-expectError(modernErrors([plugin], { http: { status: true } }))
+expectError(
+  ModernError.subclass('TestError', {
+    plugins: [plugin],
+    http: { status: true },
+  }),
+)
 expectError(error.httpResponse({ status: true }))
 expectNotAssignable<Options>({ status: true })
 
-modernErrors([plugin], { http: { title: '' } })
+ModernError.subclass('TestError', { plugins: [plugin], http: { title: '' } })
 error.httpResponse({ title: '' })
 expectAssignable<Options>({ title: '' })
-expectError(modernErrors([plugin], { http: { title: true } }))
+expectError(
+  ModernError.subclass('TestError', {
+    plugins: [plugin],
+    http: { title: true },
+  }),
+)
 expectError(error.httpResponse({ title: true }))
 expectNotAssignable<Options>({ title: true })
 
-modernErrors([plugin], { http: { detail: '' } })
+ModernError.subclass('TestError', { plugins: [plugin], http: { detail: '' } })
 error.httpResponse({ detail: '' })
 expectAssignable<Options>({ detail: '' })
-expectError(modernErrors([plugin], { http: { detail: true } }))
+expectError(
+  ModernError.subclass('TestError', {
+    plugins: [plugin],
+    http: { detail: true },
+  }),
+)
 expectError(error.httpResponse({ detail: true }))
 expectNotAssignable<Options>({ detail: true })
 
-modernErrors([plugin], { http: { instance: '' } })
+ModernError.subclass('TestError', { plugins: [plugin], http: { instance: '' } })
 error.httpResponse({ instance: '' })
 expectAssignable<Options>({ instance: '' })
-expectError(modernErrors([plugin], { http: { instance: true } }))
+expectError(
+  ModernError.subclass('TestError', {
+    plugins: [plugin],
+    http: { instance: true },
+  }),
+)
 expectError(error.httpResponse({ instance: true }))
 expectNotAssignable<Options>({ instance: true })
 
-modernErrors([plugin], { http: { stack: '' } })
+ModernError.subclass('TestError', { plugins: [plugin], http: { stack: '' } })
 error.httpResponse({ stack: '' })
 expectAssignable<Options>({ stack: '' })
-expectError(modernErrors([plugin], { http: { stack: true } }))
+expectError(
+  ModernError.subclass('TestError', {
+    plugins: [plugin],
+    http: { stack: true },
+  }),
+)
 expectError(error.httpResponse({ stack: true }))
 expectNotAssignable<Options>({ stack: true })
 
-modernErrors([plugin], { http: { extra: {} } })
+ModernError.subclass('TestError', { plugins: [plugin], http: { extra: {} } })
 error.httpResponse({ extra: {} })
 expectAssignable<Options>({ extra: {} })
-modernErrors([plugin], { http: { extra: { prop: true } } })
+ModernError.subclass('TestError', {
+  plugins: [plugin],
+  http: { extra: { prop: true } },
+})
 error.httpResponse({ extra: { prop: true } })
 expectAssignable<Options>({ extra: { prop: true } })
-expectError(modernErrors([plugin], { http: { extra: true } }))
+expectError(
+  ModernError.subclass('TestError', {
+    plugins: [plugin],
+    http: { extra: true },
+  }),
+)
 expectError(error.httpResponse({ extra: true }))
 expectNotAssignable<Options>({ extra: true })