Merge branch 'release/v0.24.10'

package.json

@@ -1,7 +1,7 @@
 {
   "name": "zeed",
   "type": "module",
-  "version": "0.24.9",
+  "version": "0.24.10",
   "description": "🌱 Simple foundation library",
   "author": {
     "name": "Dirk Holtwick",

src/common/msg/emitter.spec.ts

@@ -169,6 +169,40 @@ describe('emitter', () => {
     expect(counter).toBe(100)
   })
 
+  it('should work with addEventListener', async () => {
+    interface TestMessages {
+      a: () => void
+      b: () => void
+    }
+
+    const e1 = new Emitter<TestMessages>()
+    const e2 = new Emitter<TestMessages>()
+
+    let counter = 99
+
+    e1.addEventListener('a', () => counter++)
+
+    e2.addEventListener('a', () => counter--)
+    e2.addEventListener('b', () => counter--)
+
+    void e1.emit('a')
+
+    expect(counter).toBe(100)
+
+    void e2.emit('a')
+    void e2.emit('b')
+
+    expect(counter).toBe(98)
+
+    e1.addEventListener('a', () => counter++)
+    void e1.emit('a') // twice!
+    expect(counter).toBe(100)
+
+    e1.removeAllListeners()
+    void e1.emit('a') // no listeners!
+    expect(counter).toBe(100)
+  })
+
   it('should wait on', async () => {
     expect.assertions(2)
 

src/common/msg/emitter.ts

@@ -168,6 +168,10 @@ export class Emitter<
       }, timeoutMS)
     })
   }
+
+  // For compatibility reasons
+  addEventListener = this.on.bind(this)
+  removeEventListener = this.off.bind(this)
 }
 
 declare global {

src/common/schema/env.ts

@@ -38,12 +38,9 @@ export function parseSchemaEnv<T>(schema: Type<T>, env: any = process?.env ?? {}
 
 export function stringFromSchemaEnv<T>(schema: Type<T>, prefix = '', commentOut = false): string {
   assert(isSchemaObjectFlat(schema), 'schema should be a flat object')
-
   const lines: string[] = []
-
   objectMap(schema._object!, (key, schema) => {
     lines.push(`${commentOut ? '# ' : ''}${prefix + fromCamelCase(key, '_').toUpperCase()}=${schema._default ?? ''}`)
   }) as T
-
   return lines.join('\n')
 }

src/common/schema/rpc.spec.ts

@@ -1,41 +1,14 @@
-import { string } from './schema'
+import { func, object, string } from './schema'
 import type { Infer, Type } from './schema'
 
 // see https://github.com/colinhacks/zod?tab=readme-ov-file#functions
 
 describe('rpc.spec', () => {
   it('should do something', async () => {
-    const rpcSchema = {
-      echo: string(),
-    }
-
-    type RpcRaw = typeof rpcSchema
-
-    type RpcFunc<T> = {
-      [K in keyof T]: (arg: Infer<T[K]>) => void
-    }
-
-    type Rpc = RpcFunc<RpcRaw>
-  })
-
-  it('should do something2', async () => {
-    function func(args: Type<any>[], result?: Type<any>) {
-      return {
-        args,
-        result,
-      }
-    }
-
-    const rpcSchema = {
+    const rpcSchema = object({
       echo: func([string()], string()),
-    }
-
-    type RpcRaw = typeof rpcSchema
-
-    type RpcFunc<T> = {
-      [K in keyof T]: (arg: Infer<T[K]>) => void
-    }
+    })
 
-    type Rpc = RpcFunc<RpcRaw>
+    type RpcRaw = Infer<typeof rpcSchema>
   })
 })

src/common/schema/sandbox-inherit.ts

@@ -0,0 +1,13 @@
+class TypeClass<T = unknown> {
+  optional(): TypeClass<T | undefined> {
+    return this
+  }
+}
+
+class TypeStringClass<T extends string> extends TypeClass<T> {
+
+}
+
+const o = new TypeStringClass()
+const v = o.optional()
+type t = typeof v // expect: TypeStringClass<string | undefined>

src/common/schema/sandbox.spec.ts

@@ -0,0 +1,45 @@
+/* eslint-disable ts/no-unsafe-declaration-merging */
+// // Define an interface for the instance type
+// interface MyTypeInstance {
+//   value: number
+//   test: () => number
+// }
+
+// // Constructor function
+// function MyType(this: MyTypeInstance, value: number) {
+//   this.value = value
+// }
+
+// MyType.prototype.test = function () {
+//   return this.value
+// }
+
+class MyType {
+  value: number
+  constructor(value: number) {
+    this.value = value
+  }
+}
+
+interface MyType {
+  test: () => number
+}
+
+describe('sandbox.spec', () => {
+  it('should do something', async () => {
+    // Create an instance of MyType using the 'new' keyword
+    const my = new MyType(123)
+
+    MyType.prototype.test = function () {
+      return this.value + 1
+    }
+
+    // Example usage
+    expect(my.test()).toMatchInlineSnapshot(`124`)
+    expect(my).toMatchInlineSnapshot(`
+      MyType {
+        "value": 123,
+      }
+    `)
+  })
+})

src/common/schema/sandbox.ts

@@ -38,3 +38,5 @@ function number(): Type<number> {
 
 const tt = tuple([number(), string(), boolean()])
 type ttt = Infer<typeof tt> // expected [number, string, boolean]
+
+//

src/common/schema/schema.spec.ts

@@ -10,14 +10,21 @@ describe('schema', () => {
     const lit = stringLiterals(['active', 'trialing', 'past_due', 'paused', 'deleted'])
     type ScheamLiterals = Infer<typeof lit>
     type SchemaLiteralsTest = Expect<IsEqual<ScheamLiterals, Status>> // Should pass
+    expectTypeOf<ScheamLiterals>().toMatchTypeOf<Status>()
 
     // Tuple
     const tup = tuple([number(), string(), boolean()])
     type SchemaTuple = Infer<typeof tup> // expected [number, string, boolean]
     type SchemaTupleTest = Expect<IsEqual<SchemaTuple, [number, string, boolean]>> // Should pass
+    expectTypeOf<SchemaTuple>().toMatchTypeOf<[number, string, boolean]>()
+
+    const s1 = string().optional() // .pattern(/\d+/)
+    type t1a = typeof s1
+    type t1 = Infer<typeof s1>
+    expectTypeOf<t1>().toMatchTypeOf<string | undefined>()
 
     const schema = object({
-      id: string().default(() => '123'),
+      id: string().default('123'), // default(() => '123'),
       name: string(),
       age: int().optional(),
       active: boolean(),
@@ -157,17 +164,6 @@ describe('schema', () => {
             "type": "string",
           },
           "name": Object {
-            "_union": Array [
-              Object {
-                "type": "string",
-              },
-              Object {
-                "type": "string",
-              },
-              Object {
-                "type": "string",
-              },
-            ],
             "type": "string",
           },
         },