feat: add array type

Author: holtwick

src/common/msg/rpc.spec.ts

@@ -73,8 +73,8 @@ describe('rpc async', () => {
     await new Promise(resolve => setTimeout(resolve, 100))
     expect(Bob.getCount()).toBe(1)
 
-    c1.close()
-    c2.close()
+    c1.dispose()
+    c2.dispose()
 
     expect(log).toMatchInlineSnapshot(`
       Array [
@@ -146,8 +146,8 @@ describe('rpc async', () => {
     await new Promise(resolve => setTimeout(resolve, 100))
     expect(Bob.getCount()).toBe(1)
 
-    c1.close()
-    c2.close()
+    c1.dispose()
+    c2.dispose()
   })
 
   it('timeout async', async (done) => {

src/common/schema/rpc.spec.ts

@@ -1,4 +1,5 @@
 import type { Infer } from './schema'
+import { useRPC } from '../msg/rpc'
 import { boolean, func, object, string } from './schema'
 
 // see https://github.com/colinhacks/zod?tab=readme-ov-file#functions
@@ -63,4 +64,36 @@ describe('rpc.spec', () => {
       }
     `)
   })
+
+  it('should use a schema for useRPC', async () => {
+    const rpcSchema = object({
+      echo: func(
+        [string(), boolean()],
+        string().optional(),
+      ).props({
+        rpcDesc: 'Just echo the string',
+      }),
+      noFunc: string(),
+    })
+
+    type RpcRaw = Infer<typeof rpcSchema>
+
+    expectTypeOf<RpcRaw>().toMatchObjectType<{
+      echo: (args_0: string, args_1: boolean) => string | undefined
+      noFunc: string
+    }>()
+
+    const bob = useRPC<RpcRaw>({
+      echo: (a: string, b: boolean) => {
+        return a + b
+      },
+      noFunc: 'noFunc',
+    }, {
+      post: () => { },
+      on: () => { },
+    })
+
+    const r = await bob.echo('hello', true)
+    expect(r).toEqual('hellotrue')
+  })
 })

src/common/schema/schema.spec.ts

@@ -1,7 +1,7 @@
 import type { Infer } from './schema'
 import type { Expect, IsEqual } from './test'
 import { cloneJsonObject } from '../data'
-import { boolean, float, int, literal, number, object, string, stringLiterals, tuple, union } from './schema'
+import { array, boolean, float, int, literal, number, object, string, stringLiterals, tuple, union } from './schema'
 
 describe('schema', () => {
   it('create schema', async () => {
@@ -28,6 +28,7 @@ describe('schema', () => {
       name: string(),
       age: int().optional(),
       active: boolean(),
+      tags: array(string()).optional(),
       // status: stringLiterals(['active', 'trialing', 'past_due', 'paused', 'deleted']),
       // status: string<Status>(),
       obj: object({
@@ -45,6 +46,7 @@ describe('schema', () => {
       } | undefined
       name: string
       active: boolean
+      tags?: string[]
       lit: 'active' | 'trialing' | 'past_due' | 'paused' | 'deleted'
     }>> // Should pass
 
@@ -86,6 +88,10 @@ describe('schema', () => {
             "_optional": true,
             "type": "object",
           },
+          "tags": Object {
+            "_optional": true,
+            "type": "array",
+          },
         },
         "type": "object",
       }

src/common/schema/schema.ts

@@ -241,6 +241,12 @@ export function tuple<T extends [] | [Type, ...Type[]]>(items: T): ArrayType<T,
   })
 }
 
+export function array<T>(itemType: Type<T>): Type<T[]> {
+  return generic<T[]>('array', {
+    _check: v => Array.isArray(v) && v.every(item => itemType._check(item)),
+  })
+}
+
 // const tt = tuple([number(), string(), boolean()])
 // type ttt = Infer<typeof tt> // expected [number, string, boolean]