Optimization Work

example/index.ts

@@ -1,40 +1,19 @@
-import { TypeSystem } from '@sinclair/typebox/system'
-import { TypeCompiler } from '@sinclair/typebox/compiler'
-import { Value, ValuePointer } from '@sinclair/typebox/value'
-import { Type, TypeGuard, Kind, Static, TSchema } from '@sinclair/typebox'
+import { Type } from '@sinclair/typebox'
 
-// -----------------------------------------------------------
-// Create: Type
-// -----------------------------------------------------------
-
-const T = Type.Object({
+const K = Type.TemplateLiteral('p${0|1}${0|1}${0|1}${0|1}${0|1}${0|1}')
+const T = Type.Mapped(K, _ => Type.Object({ 
   x: Type.Number(),
   y: Type.Number(),
-  z: Type.Number(),
-})
-
-type T = Static<typeof T>
-
-console.log(T)
-
-// -----------------------------------------------------------
-// Create: Value
-// -----------------------------------------------------------
-
-const V = Value.Create(T)
-
-console.log(V)
-
-// -----------------------------------------------------------
-// Compile: Type
-// -----------------------------------------------------------
-
-const C = TypeCompiler.Compile(T)
-
-console.log(C.Code())
-
-// -----------------------------------------------------------
-// Check: Value
-// -----------------------------------------------------------
-
-console.log(C.Check(V))
+  z: Type.Number()
+}))
+
+const S = Date.now()
+for(let i = 0; i < 1000; i++) {
+  const K = Type.TemplateLiteral('p${0|1}${0|1}${0|1}${0|1}${0|1}${0|1}')
+  const T = Type.Mapped(K, _ => Type.Object({ 
+    x: Type.Number(),
+    y: Type.Number(),
+    z: Type.Number()
+  }))
+}
+console.log(Date.now() - S)

src/type/clone/value.ts

@@ -41,9 +41,14 @@ function RegExpType(value: RegExp) {
   return new RegExp(value.source, value.flags)
 }
 function ObjectType(value: Record<keyof any, unknown>) {
-  const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {})
-  const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key as any]) }), {})
-  return { ...clonedProperties, ...clonedSymbols }
+  const result = {} as Record<PropertyKey, unknown>
+  for(const key of Object.getOwnPropertyNames(value)) {
+    result[key] = Visit(value[key])
+  }
+  for(const key of Object.getOwnPropertySymbols(value)) {
+    result[key] = Visit(value[key])
+  }
+  return result
 }
 // prettier-ignore
 function Visit(value: unknown): any {

src/type/composite/composite.ts

@@ -51,8 +51,9 @@ type TCompositeKeys<T extends TSchema[], Acc extends PropertyKey[] = []> = (
 // prettier-ignore
 function CompositeKeys<T extends TSchema[]>(T: [...T]): TCompositeKeys<T> {
   return SetDistinct(T.reduce((Acc, L) => {
-    return ([...Acc, ...KeyOfPropertyKeys(L)]) as never
-  }, [])) as never
+    Acc.push(...KeyOfPropertyKeys(L))
+    return Acc
+  }, [] as PropertyKey[])) as never
 }
 // ------------------------------------------------------------------
 // FilterNever
@@ -81,8 +82,9 @@ type TCompositeProperty<T extends TSchema[], K extends PropertyKey, Acc extends
 // prettier-ignore
 function CompositeProperty<T extends TSchema[], K extends PropertyKey>(T: [...T], K: K): TCompositeProperty<T, K> {
   return FilterNever(T.reduce((Acc, L) => {
-    return [...Acc, ...IndexFromPropertyKeys(L, [K])] as never
-  }, [])) as never
+    Acc.push(...IndexFromPropertyKeys(L, [K]))  
+    return Acc
+  }, [] as TSchema[])) as never
 }
 // ------------------------------------------------------------------
 // CompositeProperties
@@ -95,9 +97,11 @@ type TCompositeProperties<T extends TSchema[], K extends PropertyKey[], Acc = {}
 )
 // prettier-ignore
 function CompositeProperties<T extends TSchema[], K extends PropertyKey[] = []>(T: [...T], K: [...K]): TCompositeProperties<T, K> {
-  return K.reduce((Acc, L) => {
-   return { ...Acc, [L]: IntersectEvaluated(CompositeProperty(T, L)) }
-  }, {}) as never
+  const Acc = {} as never
+  for(const L of K) {
+    Acc[L] = IntersectEvaluated(CompositeProperty(T, L))
+  }
+  return Acc
 }
 // ------------------------------------------------------------------
 // Composite

src/type/indexed/indexed-from-mapped-result.ts

@@ -47,9 +47,11 @@ function FromProperties<
   T extends TSchema,
   P extends TProperties
 >(T: T, P: P, options: SchemaOptions): TFromProperties<T, P> {
-  return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
-    return {...Acc, [K2]: Index(T, IndexPropertyKeys(P[K2]), options) }
-  }, {}) as TFromProperties<T, P>
+  const Acc = {} as Record<PropertyKey, TSchema>
+  for(const K2 of Object.getOwnPropertyNames(P)) {
+    Acc[K2] = Index(T, IndexPropertyKeys(P[K2]), options)
+  }
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedResult

src/type/intersect/intersect-evaluated.ts

@@ -41,11 +41,7 @@ import { IntersectCreate } from './intersect-create'
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
-import { 
-  IsOptional,
-  IsTransform,
-} from '../guard/type'
+import { IsOptional, IsTransform } from '../guard/type'
 
 // ------------------------------------------------------------------
 // IsIntersectOptional

src/type/mapped/mapped.ts

@@ -133,9 +133,9 @@ type TMappedKeyToUnknownMappedResultProperties<P extends PropertyKey[], Acc exte
 )
 // prettier-ignore
 function MappedKeyToUnknownMappedResultProperties<P extends PropertyKey[]>(P: [...P]): TMappedKeyToUnknownMappedResultProperties<P> {
-  return P.reduce((Acc, L) => {
-    return { ...Acc, [L]: Literal(L as TLiteralValue) }
-  }, {} as TProperties) as TMappedKeyToUnknownMappedResultProperties<P>
+  const Acc = {} as Record<PropertyKey, TSchema>
+  for(const L of P) Acc[L] = Literal(L as TLiteralValue)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // MappedKeyToMappedResultProperties
@@ -189,9 +189,9 @@ type FromProperties<K extends PropertyKey, T extends TProperties, R extends TPro
 }>> = R
 // prettier-ignore
 function FromProperties<K extends PropertyKey, T extends TProperties>(K: K, T: T): FromProperties<K, T> {
-  return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K2) => {
-    return { ...Acc, [K2]: FromSchemaType(K, T[K2]) }
-  }, {}) as FromProperties<K, T>
+  const Acc = {} as Record<PropertyKey, TSchema>
+  for(const K2 of globalThis.Object.getOwnPropertyNames(T)) Acc[K2] = FromSchemaType(K, T[K2])
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // FromMappedPropertyKey
@@ -250,10 +250,10 @@ export type TMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema
     : Acc
 )
 // prettier-ignore
-export function MappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T, Acc: TProperties = {}): TMappedFunctionReturnType<K, T> {
-  return K.reduce((Acc, L) => {
-    return { ...Acc, [L]: FromSchemaType(L, T) }
-  }, {} as TProperties) as TMappedFunctionReturnType<K, T>
+export function MappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T): TMappedFunctionReturnType<K, T> {
+  const Acc = {} as Record<PropertyKey, TSchema>
+  for(const L of K) Acc[L] = FromSchemaType(L, T)
+  return Acc as never
 }
 // ------------------------------------------------------------------
 // TMappedFunction