feat: support ctx.localize()

package.json

@@ -37,7 +37,7 @@
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
     "chai-shape": "^1.0.0",
-    "dtsc": "^1.1.0",
+    "dtsc": "^1.1.1",
     "esbuild": "^0.14.39",
     "esbuild-register": "^3.3.2",
     "jest-mock": "^28.1.0",

src/app.ts

@@ -7,7 +7,7 @@ export class App extends Context {
   counter = 0
 
   constructor(config?: App.Config) {
-    super({ filter: () => true } as any)
+    super({ filter: () => true, mapping: Object.create(null) } as any)
     this.app = this
     this.options = Registry.validate(App, config)
     for (const key of Object.getOwnPropertySymbols(Context.internal)) {

src/context.ts

@@ -37,6 +37,14 @@ export class Context {
     return Object.assign(Object.create(this), meta)
   }
 
+  localize(names: string[]) {
+    const mapping = Object.create(this.mapping)
+    for (const name of names) {
+      mapping[name] = Symbol(name)
+    }
+    return this.extend({ mapping })
+  }
+
   any() {
     return this.extend({ filter: () => true })
   }
@@ -84,9 +92,10 @@ export namespace Context {
     app: App
     state: Plugin.State
     filter: Filter
+    mapping: {}
   }
 
-  export const internal = {}
+  export const internal = Object.create(null)
 
   export function service(name: keyof any, options: ServiceOptions = {}) {
     if (Object.prototype.hasOwnProperty.call(Context.prototype, name)) return
@@ -95,17 +104,25 @@ export namespace Context {
 
     Object.defineProperty(Context.prototype, name, {
       get(this: Context) {
-        const value = this.app[privateKey]
+        const key = this.mapping[name] || privateKey
+        const value = this.app[key]
         if (!value) return
         defineProperty(value, Context.current, this)
         return value
       },
       set(this: Context, value) {
-        const oldValue = this.app[privateKey]
+        const key = this.mapping[name] || privateKey
+        const oldValue = this.app[key]
         if (oldValue === value) return
-        this.app[privateKey] = value
+        this.app[key] = value
         if (typeof name !== 'string') return
-        this.emit('internal/service', name, oldValue)
+
+        // trigger event
+        const self: Context = Object.create(this)
+        self[Context.filter] = (ctx) => {
+          return this.mapping[name] === ctx.mapping[name]
+        }
+        this.emit(self, 'internal/service', name, oldValue)
       },
     })
 

src/lifecycle.ts

@@ -230,7 +230,7 @@ export interface Events {
   'fork': Plugin.Function
   'dispose'(): Awaitable<void>
   'internal/warn'(format: any, ...param: any[]): void
-  'internal/service'(name: string, oldValue: any): void
+  'internal/service'(this: Context, name: string, oldValue: any): void
   'internal/update'(state: Plugin.Fork, config: any): void
   'internal/hook'(name: string, listener: Function, prepend: boolean): () => boolean
 }

tests/service.spec.ts

@@ -98,4 +98,38 @@ describe('Service', () => {
     expect(stop.mock.calls).to.have.length(1)
     expect(fork.mock.calls).to.have.length(2)
   })
+
+  it('localize context', async () => {
+    const app = new App()
+    const ctx = app.localize(['foo'])
+
+    const outer = jest.fn()
+    const inner = jest.fn()
+    app.on('internal/service', outer)
+    ctx.on('internal/service', inner)
+
+    app.foo = { bar: 100 }
+    expect(app.foo).to.deep.equal({ bar: 100 })
+    expect(ctx.foo).to.be.not.ok
+    expect(outer.mock.calls).to.have.length(1)
+    expect(inner.mock.calls).to.have.length(0)
+
+    ctx.foo = { bar: 200 }
+    expect(app.foo).to.deep.equal({ bar: 100 })
+    expect(ctx.foo).to.deep.equal({ bar: 200 })
+    expect(outer.mock.calls).to.have.length(1)
+    expect(inner.mock.calls).to.have.length(1)
+
+    app.foo = null
+    expect(app.foo).to.be.not.ok
+    expect(ctx.foo).to.deep.equal({ bar: 200 })
+    expect(outer.mock.calls).to.have.length(2)
+    expect(inner.mock.calls).to.have.length(1)
+
+    ctx.foo = null
+    expect(app.foo).to.be.not.ok
+    expect(ctx.foo).to.be.not.ok
+    expect(outer.mock.calls).to.have.length(2)
+    expect(inner.mock.calls).to.have.length(2)
+  })
 })