From 3719b3eaff59fafe077bc47cf8ada4940f9499f2 Mon Sep 17 00:00:00 2001
From: sinclairzx81 <haydn.developer@gmail.com>
Date: Sun, 21 Apr 2024 01:28:28 +0900
Subject: [PATCH] Revision 0.32.22 (#840)

* Support Optional and Readonly Function Arguments

* Version
---
 package-lock.json                   |  4 ++--
 package.json                        |  2 +-
 src/type/constructor/constructor.ts | 25 +++++++++++++++++--------
 src/type/function/function.ts       | 26 ++++++++++++++++++--------
 test/static/constructor.ts          | 20 ++++++++++++++++++++
 test/static/function.ts             | 22 ++++++++++++++++++++++
 6 files changed, 80 insertions(+), 19 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 2dde718..5249c5e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.21",
+  "version": "0.32.22",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@sinclair/typebox",
-      "version": "0.32.21",
+      "version": "0.32.22",
       "license": "MIT",
       "devDependencies": {
         "@arethetypeswrong/cli": "^0.13.2",
diff --git a/package.json b/package.json
index ad32abe..0340aa4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.21",
+  "version": "0.32.22",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
diff --git a/src/type/constructor/constructor.ts b/src/type/constructor/constructor.ts
index 948d0aa..9983862 100644
--- a/src/type/constructor/constructor.ts
+++ b/src/type/constructor/constructor.ts
@@ -29,28 +29,37 @@ THE SOFTWARE.
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Static } from '../static/index'
 import type { Ensure } from '../helpers/index'
+import type { TReadonlyOptional } from '../readonly-optional/index'
+import type { TReadonly } from '../readonly/index'
+import type { TOptional } from '../optional/index'
 import { CloneType, CloneRest } from '../clone/type'
 import { Kind } from '../symbols/index'
 
 // ------------------------------------------------------------------
-// TConstructorStatic
+// StaticConstructor
 // ------------------------------------------------------------------
-type ConstructorStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>
+type StaticReturnType<U extends TSchema, P extends unknown[]> = Static<U, P>
 // prettier-ignore
-type ConstructorStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = 
+type StaticParameter<T extends TSchema, P extends unknown[]> =
+  T extends TReadonlyOptional<T> ? [Readonly<Static<T, P>>?] :
+  T extends TReadonly<T> ? [Readonly<Static<T, P>>] :
+  T extends TOptional<T> ? [Static<T, P>?] :
+  [Static<T, P>]
+// prettier-ignore
+type StaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? ConstructorStaticParameters<R, P, [...Acc, Static<L, P>]>
+    ? StaticParameters<R, P, [...Acc, ...StaticParameter<L, P>]>
     : Acc
-// prettier-ignore
-type ConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (
-  Ensure<new (...param: ConstructorStaticParameters<T, P>) => ConstructorStaticReturnType<U, P>>
 )
+// prettier-ignore
+type StaticConstructor<T extends TSchema[], U extends TSchema, P extends unknown[]> =
+  Ensure<new (...params: StaticParameters<T, P>) => StaticReturnType<U, P>>
 // ------------------------------------------------------------------
 // TConstructor
 // ------------------------------------------------------------------
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Constructor'
-  static: ConstructorStatic<T, U, this['params']>
+  static: StaticConstructor<T, U, this['params']>
   type: 'Constructor'
   parameters: T
   returns: U
diff --git a/src/type/function/function.ts b/src/type/function/function.ts
index 6f594df..340e5ba 100644
--- a/src/type/function/function.ts
+++ b/src/type/function/function.ts
@@ -29,28 +29,38 @@ THE SOFTWARE.
 import type { TSchema, SchemaOptions } from '../schema/index'
 import type { Static } from '../static/index'
 import type { Ensure } from '../helpers/index'
+import type { TReadonlyOptional } from '../readonly-optional/index'
+import type { TReadonly } from '../readonly/index'
+import type { TOptional } from '../optional/index'
 import { CloneType, CloneRest } from '../clone/type'
 import { Kind } from '../symbols/index'
 
 // ------------------------------------------------------------------
-// FunctionStatic
+// StaticFunction
 // ------------------------------------------------------------------
-type FunctionStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>
+type StaticReturnType<U extends TSchema, P extends unknown[]> = Static<U, P>
 // prettier-ignore
-type FunctionStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = 
+type StaticParameter<T extends TSchema, P extends unknown[]> =
+  T extends TReadonlyOptional<T> ? [Readonly<Static<T, P>>?] :
+  T extends TReadonly<T> ? [Readonly<Static<T, P>>] :
+  T extends TOptional<T> ? [Static<T, P>?] :
+  [Static<T, P>]
+// prettier-ignore
+type StaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = (
   T extends [infer L extends TSchema, ...infer R extends TSchema[]]
-    ? FunctionStaticParameters<R, P, [...Acc, Static<L, P>]>
+    ? StaticParameters<R, P, [...Acc, ...StaticParameter<L, P>]>
     : Acc
-// prettier-ignore
-type FunctionStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (
-  Ensure<(...param: FunctionStaticParameters<T, P>) => FunctionStaticReturnType<U, P>>
 )
+// prettier-ignore
+type StaticFunction<T extends TSchema[], U extends TSchema, P extends unknown[]> =
+  Ensure<(...params: StaticParameters<T, P>) => StaticReturnType<U, P>>
+
 // ------------------------------------------------------------------
 // TFunction
 // ------------------------------------------------------------------
 export interface TFunction<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
   [Kind]: 'Function'
-  static: FunctionStatic<T, U, this['params']>
+  static: StaticFunction<T, U, this['params']>
   type: 'Function'
   parameters: T
   returns: U
diff --git a/test/static/constructor.ts b/test/static/constructor.ts
index c91d398..59e435c 100644
--- a/test/static/constructor.ts
+++ b/test/static/constructor.ts
@@ -13,6 +13,26 @@ import { Type } from '@sinclair/typebox'
   }))
   Expect(T).ToStatic<new (param_0: number, param_1: string) => { method: new (param_0: number, param_1: string) => boolean }>()
 }
+{
+  // readonly-optional
+  const T = Type.Constructor([Type.ReadonlyOptional(Type.Array(Type.Number()))], Type.Number())
+  Expect(T).ToStaticDecode<new (param_0?: readonly number[]) => number>()
+}
+{
+  // readonly
+  const T = Type.Constructor([Type.Readonly(Type.Array(Type.Number()))], Type.Number())
+  Expect(T).ToStaticDecode<new (param_0: readonly number[]) => number>()
+}
+{
+  // optional 1
+  const T = Type.Constructor([Type.Optional(Type.Number())], Type.Number())
+  Expect(T).ToStaticDecode<new (param_0?: number) => number>()
+}
+{
+  // optional 2
+  const T = Type.Constructor([Type.Number(), Type.Optional(Type.Number())], Type.Number())
+  Expect(T).ToStaticDecode<new (param_0: number, param_1?: number) => number>()
+}
 {
   // decode 2
   const S = Type.Transform(Type.Integer())
diff --git a/test/static/function.ts b/test/static/function.ts
index a204187..1ae3404 100644
--- a/test/static/function.ts
+++ b/test/static/function.ts
@@ -14,6 +14,28 @@ import { Type } from '@sinclair/typebox'
   }))
   Expect(T).ToStatic<(param_0: number, param_1: string) => { method: (param_0: number, param_1: string) => boolean }>()
 }
+{
+  // readonly-optional
+  const T = Type.Function([Type.ReadonlyOptional(Type.Array(Type.Number()))], Type.Number())
+  Expect(T).ToStaticDecode<(param_0?: readonly number[]) => number>()
+}
+{
+  // readonly
+  const T = Type.Function([Type.Readonly(Type.Array(Type.Number()))], Type.Number())
+  Expect(T).ToStaticDecode<(param_0: readonly number[]) => number>()
+}
+{
+  // optional 1
+  const T = Type.Function([Type.Optional(Type.Number())], Type.Number())
+  Expect(T).ToStaticDecode<(param_0?: number) => number>()
+}
+{
+  // optional 2
+  const T = Type.Function([Type.Number(), Type.Optional(Type.Number())], Type.Number())
+  Expect(T).ToStaticDecode<(param_0: number, param_1?: number) => number>()
+}
+const F = Type.Constructor([Type.Readonly(Type.Array(Type.String()))], Type.Number())
+
 {
   // decode 2
   const S = Type.Transform(Type.Integer())