Updates

src/value/parse/parse.ts

@@ -39,7 +39,7 @@ import { Clone } from '../clone/index'
 // ------------------------------------------------------------------
 // Guards
 // ------------------------------------------------------------------
-import { IsArray } from '../guard/index'
+import { IsArray, IsUndefined } from '../guard/index'
 
 // ------------------------------------------------------------------
 // Error
@@ -54,18 +54,18 @@ export class ParseError extends TypeBoxError {
 // ParseRegistry
 // ------------------------------------------------------------------
 export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | ({} & string)
-export type TParseFunction = (schema: TSchema, references: TSchema[], value: unknown) => unknown
+export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown
 
 // prettier-ignore
 export namespace ParseRegistry {
   const registry = new Map<string, TParseFunction>([
-    ['Clone', (_schema, _references, value: unknown) => Clone(value)],
-    ['Clean', (schema, references, value: unknown) => Clean(schema, references, value)],
-    ['Default', (schema, references, value: unknown) => Default(schema, references, value)],
-    ['Convert', (schema, references, value: unknown) => Convert(schema, references, value)],
-    ['Assert', (schema, references, value: unknown) => { Assert(schema, references, value); return value }],
-    ['Decode', (schema, references, value: unknown) => (HasTransform(schema, references) ? TransformDecode(schema, references, value) : value)],
-    ['Encode', (schema, references, value: unknown) => (HasTransform(schema, references) ? TransformEncode(schema, references, value) : value)],
+    ['Clone', (_type, _references, value: unknown) => Clone(value)],
+    ['Clean', (type, references, value: unknown) => Clean(type, references, value)],
+    ['Default', (type, references, value: unknown) => Default(type, references, value)],
+    ['Convert', (type, references, value: unknown) => Convert(type, references, value)],
+    ['Assert', (type, references, value: unknown) => { Assert(type, references, value); return value }],
+    ['Decode', (type, references, value: unknown) => (HasTransform(type, references) ? TransformDecode(type, references, value) : value)],
+    ['Encode', (type, references, value: unknown) => (HasTransform(type, references) ? TransformEncode(type, references, value) : value)],
   ])
   // Deletes an entry from the registry
   export function Delete(key: string): void {
@@ -98,9 +98,9 @@ export const ParseDefault = [
 // ------------------------------------------------------------------
 function ParseValue<Type extends TSchema, Result extends StaticDecode<Type> = StaticDecode<Type>>(keys: TParseOperation[], type: Type, references: TSchema[], value: unknown): Result {
   return keys.reduce((value, key) => {
-    const reducer = ParseRegistry.Get(key)
-    if (reducer === undefined) throw new TypeBoxError(`Parse: Unable to find parse operation '${key}'`)
-    return reducer(type, references, value)
+    const operation = ParseRegistry.Get(key)
+    if (IsUndefined(operation)) throw new ParseError(`Unable to find Parse operation '${key}'`)
+    return operation(type, references, value)
   }, value) as Result
 }
 
@@ -122,7 +122,7 @@ export function Parse(...args: any[]): unknown {
     args.length === 4 ? [args[0], args[1], args[2], args[3]] :
     args.length === 3 ? IsArray(args[0]) ? [args[0], args[1], [], args[2]] : [ParseDefault, args[0], args[1], args[2]] :
     args.length === 2 ? [ParseDefault, args[0], [], args[1]] :
-    (() => { throw new TypeBoxError('Parse: Invalid Arguments') })()
+    (() => { throw new ParseError('Invalid Arguments') })()
   )
   return ParseValue(reducers, schema, references, value)
 }