feat(cordis): support @Inject decorator

packages/core/src/registry.ts

@@ -1,14 +1,32 @@
 import { defineProperty, Dict } from 'cosmokit'
 import { Context } from './context.ts'
 import { ForkScope, MainScope } from './scope.ts'
-import { resolveConfig, symbols } from './utils.ts'
+import { resolveConfig, symbols, withProps } from './utils.ts'
 
 function isApplicable(object: Plugin) {
   return object && typeof object === 'object' && typeof object.apply === 'function'
 }
 
 export type Inject = string[] | Dict<Inject.Meta>
 
+export function Inject(inject: Inject) {
+  return function (value: any, ctx: ClassDecoratorContext<any> | ClassMethodDecoratorContext<any>) {
+    if (ctx.kind === 'class') {
+      value.inject = inject
+    } else if (ctx.kind === 'method') {
+      ctx.addInitializer(function () {
+        const property = this[symbols.tracker]?.property
+        if (!property) throw new Error('missing context tracker')
+        ;(this[property] as Context).inject(inject, (ctx) => {
+          value.call(withProps(this, { [property]: ctx }))
+        })
+      })
+    } else {
+      throw new Error('@Inject can only be used on class or class methods')
+    }
+  }
+}
+
 export namespace Inject {
   export interface Meta {
     required: boolean

packages/core/tests/decorator.spec.ts

@@ -0,0 +1,39 @@
+import { Context, Inject, Service } from '../src'
+import { expect } from 'chai'
+import { mock } from 'node:test'
+
+describe('Decorator', () => {
+  it('@Inject on class method', () => {
+    const callback = mock.fn()
+    const dispose = mock.fn()
+
+    class Foo extends Service {
+      constructor(ctx: Context) {
+        super(ctx, 'foo', true)
+      }
+    }
+
+    class Bar extends Service {
+      constructor(ctx: Context) {
+        super(ctx, 'bar', true)
+      }
+
+      @Inject(['foo'])
+      method() {
+        callback()
+        this.ctx.on('dispose', dispose)
+      }
+    }
+
+    const root = new Context()
+    root.plugin(Bar)
+    expect(callback.mock.calls).to.have.length(0)
+    expect(dispose.mock.calls).to.have.length(0)
+    const fork = root.plugin(Foo)
+    expect(callback.mock.calls).to.have.length(1)
+    expect(dispose.mock.calls).to.have.length(0)
+    fork.dispose()
+    expect(callback.mock.calls).to.have.length(1)
+    expect(dispose.mock.calls).to.have.length(1)
+  })
+})