Merge branch 'release/v0.28.4'

Author: holtwick

package.json

@@ -1,8 +1,8 @@
 {
   "name": "zeed",
   "type": "module",
-  "version": "0.28.3",
-  "packageManager": "pnpm@10.8.1",
+  "version": "0.28.4",
+  "packageManager": "pnpm@10.10.0",
   "description": "🌱 Simple foundation library",
   "author": {
     "name": "Dirk Holtwick",
@@ -72,18 +72,18 @@
   "devDependencies": {
     "@antfu/eslint-config": "^4.12.0",
     "@antfu/ni": "^24.3.0",
-    "@types/node": "^22.14.1",
+    "@types/node": "^22.15.3",
     "@vitejs/plugin-vue": "^5.2.3",
-    "@vitest/browser": "^3.1.1",
-    "@vitest/coverage-v8": "^3.1.1",
-    "esbuild": "^0.25.2",
-    "eslint": "^9.24.0",
-    "playwright": "^1.51.1",
+    "@vitest/browser": "^3.1.2",
+    "@vitest/coverage-v8": "^3.1.2",
+    "esbuild": "^0.25.3",
+    "eslint": "^9.25.1",
+    "playwright": "^1.52.0",
     "pnpm": "^10.7.0",
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
-    "vite": "^6.2.6",
-    "vitest": "^3.1.1"
+    "vite": "^6.3.3",
+    "vitest": "^3.1.2"
   },
   "pnpm": {
     "overrides": {

src/common/schema/rpc.spec.ts

@@ -15,15 +15,15 @@ describe('rpc.spec', () => {
     const rpcFn = object({ rpc: rpc() })
     type RpcFn = Infer<typeof rpcFn>
     expectTypeOf<RpcFn>().toMatchObjectType<{
-      rpc: () => undefined
+      rpc: () => void
     }>()
 
     const rpcFn2 = object({ rpc: rpc(object({
       a: number(),
     }), string()) })
     type RpcFn2 = Infer<typeof rpcFn2>
     expectTypeOf<RpcFn2>().toMatchObjectType<{
-      rpc: (info: { a: number }) => string
+      rpc: (info: { a: number }) => string | Promise<string>
     }>()
 
     const payloadSchema = object({
@@ -68,7 +68,7 @@ describe('rpc.spec', () => {
           a: string
           b: boolean
         }
-      }) => undefined
+      }) => void | Promise<void>
       noFunc: string
     }>()
 
@@ -79,6 +79,7 @@ describe('rpc.spec', () => {
       noFunc: 'noFunc',
       rpc(info) {
         const _ = info.id
+        // return undefined
       },
     }
 

src/common/schema/schema.spec.ts

@@ -96,6 +96,9 @@ describe('schema', () => {
           },
           "tags": Object {
             "_optional": true,
+            "_type": Object {
+              "type": "string",
+            },
             "type": "array",
           },
         },

src/common/schema/schema.ts

@@ -1,6 +1,6 @@
 // With many, many inspiration from https://github.com/badrap/valita MIT License as of 2024-09-10
 
-import { isBoolean, isFunction, isInteger, isNumber, isObject, isString } from '../data/is'
+import { isArray, isBoolean, isFunction, isInteger, isNumber, isObject, isString } from '../data/is'
 import { first } from '../data/utils'
 
 export interface TypeProps {
@@ -253,10 +253,20 @@ export function tuple<T extends [] | [Type, ...Type[]]>(items: T): ArrayType<T,
   })
 }
 
+export class TypeArrayClass<T, TT> extends TypeClass<T> {
+  constructor(
+    name: string,
+    type: TT,
+  ) {
+    super(name, isArray)
+    this._type = type
+  }
+
+  _type?: TT
+}
+
 export function array<T>(itemType: Type<T>): Type<T[]> {
-  return generic<T[]>('array', {
-    _check: v => Array.isArray(v) && v.every(item => itemType._check(item)),
-  })
+  return new TypeArrayClass<T[], Type<T>>('array', itemType)
 }
 
 // const tt = tuple([number(), string(), boolean()])
@@ -287,7 +297,7 @@ export function func<
   return new TypeFuncClass<T, Args, Ret>('function', args, ret)
 }
 
-class TypeRpcClass<T, Info, Ret> extends TypeClass<T> {
+export class TypeRpcClass<T, Info, Ret> extends TypeClass<T> {
   constructor(
     name: string,
     info?: Info,
@@ -304,9 +314,9 @@ class TypeRpcClass<T, Info, Ret> extends TypeClass<T> {
 
 export function rpc<
   Info extends Type<unknown> | undefined = undefined,
-  Ret extends Type<unknown> = ReturnType<typeof none>,
-  T = Info extends undefined ? () => Infer<Ret> : (info: Infer<Info>) => Infer<Ret>,
->(info?: Info, ret?: Ret): Type<T> {
+  Ret extends Type<unknown> = Type<void>, // ReturnType<typeof none>,
+  T = Info extends undefined ? () => Infer<Ret> : (info: Infer<Info>) => Infer<Ret> | Promise<Infer<Ret>>,
+>(info?: Info, ret?: Ret) {
   return new TypeRpcClass<T, Info, Ret>('rpc', info, ret ?? none() as Ret)
 }