From 67925c10a36c786e538d502034c7af08397e52e9 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Tue, 29 Aug 2023 18:24:26 +0900
Subject: [PATCH] Revision 0.31.6 (#560)

---
 package-lock.json                |  4 +--
 package.json                     |  2 +-
 src/typebox.ts                   | 47 +++++++++++++++-----------------
 src/value/value.ts               |  8 +++---
 test/static/readonly-optional.ts | 19 ++++++++++++-
 test/static/transform.ts         | 33 +++++++++++++++++++++-
 6 files changed, 79 insertions(+), 34 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 3d79d5069..c9126a5d3 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.5",
+  "version": "0.31.6",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.31.5",
+      "version": "0.31.6",
       "license": "MIT",
       "devDependencies": {
         "@sinclair/hammer": "^0.17.1",
diff --git a/package.json b/package.json
index 7d45a33f4..d4ca52eea 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.5",
+  "version": "0.31.6",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/typebox.ts b/src/typebox.ts
index d4f7ca769..b89bab520 100644
--- a/src/typebox.ts
+++ b/src/typebox.ts
@@ -66,7 +66,7 @@ export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNeve
 // --------------------------------------------------------------------------
 // Modifiers
 // --------------------------------------------------------------------------
-export type TModifier = TOptional<TSchema> | TReadonly<TSchema>
+export type TReadonlyOptional<T extends TSchema> = TOptional<T> & TReadonly<T>
 export type TReadonly<T extends TSchema> = T & { [Readonly]: 'Readonly' }
 export type TOptional<T extends TSchema> = T & { [Optional]: 'Optional' }
 // --------------------------------------------------------------------------
@@ -855,37 +855,34 @@ export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLi
 // TTransform
 // --------------------------------------------------------------------------
 // prettier-ignore
-export type DecodeModifier<D extends TSchema, T extends TSchema> =
-  T extends TReadonly<T> & TOptional<T> ? TReadonly<TOptional<D>> :
-  T extends TReadonly<T> ? TReadonly<D> :
-  T extends TOptional<T> ? TOptional<D> :
-  D
-// prettier-ignore
 export type DecodeProperties<T extends TProperties> = {
   [K in keyof T]: DecodeType<T[K]>
 }
 // prettier-ignore
-export type DecodeRest<T extends TSchema[]> = T extends [infer L, ...infer R]
-  ? [DecodeType<AssertType<L>>, ...DecodeRest<AssertRest<R>>]
+export type DecodeRest<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+  ? [DecodeType<L>, ...DecodeRest<R>]
   : []
 // prettier-ignore
-export type DecodeType<T extends TSchema> =
-  T extends TTransform<infer _, infer R> ? DecodeModifier<TUnsafe<R>, T> : 
-  T extends TArray<infer S> ? DecodeModifier<TArray<DecodeType<S>>, T> :
-  T extends TAsyncIterator<infer S> ? DecodeModifier<TAsyncIterator<DecodeType<S>>, T> :
-  T extends TConstructor<infer P, infer R> ? DecodeModifier<TConstructor<AssertRest<DecodeRest<P>>, DecodeType<R>>, T> :
-  T extends TFunction<infer P, infer R> ? DecodeModifier<TFunction<AssertRest<DecodeRest<P>>, DecodeType<R>>, T> :
-  T extends TIntersect<infer S> ? DecodeModifier<TIntersect<AssertRest<DecodeRest<S>>>, T> :
-  T extends TIterator<infer S> ? DecodeModifier<TIterator<DecodeType<S>>, T> :
-  T extends TNot<infer S> ? DecodeModifier<TNot<DecodeType<S>>, T> :
-  T extends TObject<infer S> ? DecodeModifier<TObject<Evaluate<DecodeProperties<S>>>, T> :
-  T extends TPromise<infer S> ? DecodeModifier<TPromise<DecodeType<S>>, T> :
-  T extends TRecord<infer K, infer S> ? DecodeModifier<TRecord<K, DecodeType<S>>, T> :
-  T extends TRecursive<infer S> ? DecodeModifier<TRecursive<DecodeType<S>>, T> :
-  T extends TRef<infer S> ? DecodeModifier<TRef<DecodeType<S>>, T> :
-  T extends TTuple<infer S> ? DecodeModifier<TTuple<AssertRest<DecodeRest<S>>>, T> :
-  T extends TUnion<infer S> ? DecodeModifier<TUnion<AssertRest<DecodeRest<S>>>, T> :
+export type DecodeType<T extends TSchema> = (
+  T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> :
+  T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> :
+  T extends TTransform<infer _, infer R> ? TUnsafe<R> :
+  T extends TArray<infer S extends TSchema> ? Array<DecodeType<S>> :
+  T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> :
+  T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<P, DecodeType<R>> :
+  T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<P, DecodeType<R>> :
+  T extends TIntersect<infer S extends TSchema[]> ? TIntersect<S> :
+  T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> :
+  T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> :
+  T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> :
+  T extends TPromise<infer S extends TSchema> ? TPromise<DecodeType<S>> :
+  T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> :
+  T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> :
+  T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> :
+  T extends TTuple<infer S extends TSchema[]> ? TTuple<S> :
+  T extends TUnion<infer S extends TSchema[]> ? TUnion<S> :
   T
+)
 export type TransformFunction<T = any, U = any> = (value: T) => U
 export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
   Decode: TransformFunction<StaticDecode<I>, O>
diff --git a/src/value/value.ts b/src/value/value.ts
index 59b8dbe00..edeec7dae 100644
--- a/src/value/value.ts
+++ b/src/value/value.ts
@@ -78,9 +78,9 @@ export namespace Value {
     return ValueClone.Clone(value)
   }
   /** Decodes a value or throws if error */
-  export function Decode<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.StaticDecode<T>
+  export function Decode<T extends Types.TSchema, D = Types.StaticDecode<T>>(schema: T, references: Types.TSchema[], value: unknown): D
   /** Decodes a value or throws if error */
-  export function Decode<T extends Types.TSchema>(schema: T, value: unknown): Types.StaticDecode<T>
+  export function Decode<T extends Types.TSchema, D = Types.StaticDecode<T>>(schema: T, value: unknown): D
   /** Decodes a value or throws if error */
   export function Decode(...args: any[]) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
@@ -88,9 +88,9 @@ export namespace Value {
     return ValueTransform.DecodeTransform.Decode(schema, references, value, ValueCheck.Check)
   }
   /** Encodes a value or throws if error */
-  export function Encode<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: unknown): Types.StaticEncode<T>
+  export function Encode<T extends Types.TSchema, E = Types.StaticEncode<T>>(schema: T, references: Types.TSchema[], value: unknown): E
   /** Encodes a value or throws if error */
-  export function Encode<T extends Types.TSchema>(schema: T, value: unknown): Types.StaticEncode<T>
+  export function Encode<T extends Types.TSchema, E = Types.StaticEncode<T>>(schema: T, value: unknown): E
   /** Encodes a value or throws if error */
   export function Encode(...args: any[]) {
     const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]]
diff --git a/test/static/readonly-optional.ts b/test/static/readonly-optional.ts
index 3191dcd75..aca58d0ba 100644
--- a/test/static/readonly-optional.ts
+++ b/test/static/readonly-optional.ts
@@ -1,5 +1,5 @@
 import { Expect } from './assert'
-import { Type, TSchema } from '@sinclair/typebox'
+import { Type, TSchema, TReadonlyOptional } from '@sinclair/typebox'
 
 {
   const T = Type.Object({
@@ -9,3 +9,20 @@ import { Type, TSchema } from '@sinclair/typebox'
     readonly A?: string
   }>()
 }
+{
+  const T = Type.ReadonlyOptional(Type.String())
+  function test(_: TReadonlyOptional<TSchema>) {}
+  test(T)
+}
+{
+  const T = Type.Readonly(Type.String())
+  function test(_: TReadonlyOptional<TSchema>) {}
+  // @ts-expect-error
+  test(T)
+}
+{
+  const T = Type.Optional(Type.String())
+  function test(_: TReadonlyOptional<TSchema>) {}
+  // @ts-expect-error
+  test(T)
+}
\ No newline at end of file
diff --git a/test/static/transform.ts b/test/static/transform.ts
index 3e02df125..e6770917e 100644
--- a/test/static/transform.ts
+++ b/test/static/transform.ts
@@ -1,4 +1,4 @@
-import { Type, Static, StaticDecode, TObject, TNumber } from '@sinclair/typebox'
+import { Type, TSchema, Static, StaticDecode, TObject, TNumber } from '@sinclair/typebox'
 import { Expect } from './assert'
 {
   // string > number
@@ -214,3 +214,34 @@ import { Expect } from './assert'
   Expect(T).ToStaticDecode<{ x: '1' }>()
   Expect(T).ToStaticDecode<{ x: undefined }>()
 }
+{ // should decode within generic function context
+  // https://github.com/sinclairzx81/typebox/issues/554
+  // prettier-ignore
+  const ArrayOrSingle = <T extends TSchema>(schema: T) =>
+    Type.Transform(Type.Union([schema, Type.Array(schema)]))
+      .Decode((value) => (Array.isArray(value) ? value : [value]))
+      .Encode((value) => (value.length === 1 ? value[0] : value) as Static<T>[]);
+  const T = ArrayOrSingle(Type.String())
+  Expect(T).ToStaticDecode<string[]>()
+}
+{
+  // should correctly decode record keys
+  // https://github.com/sinclairzx81/typebox/issues/555
+  // prettier-ignore
+  const T = Type.Object({
+    x: Type.Optional(Type.Record(Type.Number(), Type.String()))
+  })
+  type A = StaticDecode<typeof T>
+  type Test<A, E> = E extends A ? true : false
+  type E1 = Test<A, {}>
+  type E2 = Test<A, { x: undefined }>
+  type E3 = Test<A, { x: { 1: '' } }>
+  type E4 = Test<A, { x: { 1: 1 } }>
+  type E5 = Test<A, { x: { x: 1 } }>
+  // assignment
+  const E1: E1 = true
+  const E2: E2 = true
+  const E3: E3 = true
+  const E4: E4 = false
+  const E5: E5 = true
+}