refa: adjust exports

Author: shigma

packages/cordis/src/worker/daemon.ts

@@ -8,7 +8,7 @@ export interface Config {
 
 export const name = 'daemon'
 
-export function apply(ctx: Context, config: Config = {}) {
+export function* apply(ctx: Context, config: Config = {}) {
   function handleSignal(signal: NodeJS.Signals) {
     // prevent restarting when child process is exiting
     if (config.autoRestart) {
@@ -18,15 +18,16 @@ export function apply(ctx: Context, config: Config = {}) {
     ctx.parallel('exit', signal).finally(() => process.exit())
   }
 
-  ctx.effect(function* () {
-    process.on('SIGINT', handleSignal)
-    yield () => process.off('SIGINT', handleSignal)
-    process.on('SIGTERM', handleSignal)
-    yield () => process.off('SIGTERM', handleSignal)
-  }, 'process.on(signal)')
+  process.on('SIGINT', handleSignal)
+  yield () => process.off('SIGINT', handleSignal)
+  process.on('SIGTERM', handleSignal)
+  yield () => process.off('SIGTERM', handleSignal)
 
   process.send!({ type: 'start', body: config })
-  config.heartbeatInterval && setInterval(() => {
-    process.send!({ type: 'heartbeat' })
-  }, config.heartbeatInterval)
+  if (config.heartbeatInterval) {
+    const timer = setInterval(() => {
+      process.send!({ type: 'heartbeat' })
+    }, config.heartbeatInterval)
+    yield () => clearInterval(timer)
+  }
 }

packages/core/src/context.ts

@@ -1,12 +1,10 @@
 import { Dict } from 'cosmokit'
-import EventsService from './events'
-import ReflectService from './reflect'
-import Registry from './registry'
+import { EventsService } from './events'
+import { ReflectService } from './reflect'
+import { RegistryService } from './registry'
 import { getTraceable, symbols } from './utils'
 import { Fiber } from './fiber'
 
-export { EventsService, ReflectService, Registry }
-
 export namespace Context {
   export interface Item<C extends Context> {
     name: string
@@ -46,7 +44,7 @@ export interface Context {
   root: this
   events: EventsService
   reflect: ReflectService
-  registry: Registry<this>
+  registry: RegistryService<this>
 }
 
 export class Context {
@@ -79,7 +77,7 @@ export class Context {
     self.root = self
     self.fiber = new Fiber(self, {}, Object.create(null), null, () => [])
     self.reflect = new ReflectService(self)
-    self.registry = new Registry(self)
+    self.registry = new RegistryService(self)
     self.events = new EventsService(self)
     // ignore internal effects
     self.fiber._disposables.clear()

packages/core/src/events.ts

@@ -44,7 +44,7 @@ export interface Hook extends EventOptions {
   callback: (...args: any[]) => any
 }
 
-class EventsService {
+export class EventsService {
   _hooks: Record<keyof any, Hook[]> = {}
 
   constructor(private ctx: Context) {
@@ -217,8 +217,6 @@ class EventsService {
   }
 }
 
-export default EventsService
-
 export interface Events<in C extends Context = Context> {
   'internal/plugin'(fiber: Fiber<C>): void
   'internal/status'(fiber: Fiber<C>, oldValue: FiberState): void

packages/core/src/fiber.ts

@@ -4,11 +4,8 @@ import { Inject, Plugin, resolveConfig } from './registry.js'
 import { buildOuterStack, composeError, DisposableList, getTraceable, isConstructor, isObject, symbols } from './utils.js'
 
 declare module './context' {
-  export interface Context {
+  export interface Context extends Pick<Fiber, 'effect'> {
     fiber: Fiber<this>
-    effect(execute: () => SyncEffect, label?: string): Disposable<void | Promise<void>>
-    effect(execute: () => AsyncEffect, label?: string): AsyncDisposable<Promise<void>>
-    effect(execute: () => Effect, label?: string): AsyncDisposable<void | Promise<void>>
   }
 }
 
@@ -217,6 +214,8 @@ export class Fiber<out C extends Context = Context> {
     }, runner.getOuterStack)
   }
 
+  effect(execute: () => SyncEffect, label?: string): Disposable<Promise<void>>
+  effect(execute: () => Effect, label?: string): AsyncDisposable<Promise<void>>
   effect(execute: () => Effect, label = 'anonymous'): any {
     this.assertActive()
 
@@ -392,6 +391,7 @@ export class Fiber<out C extends Context = Context> {
       await this.inertia
     }
     if (this._error) throw this._error
+    return this
   }
 
   async restart() {

packages/core/src/reflect.ts

@@ -17,12 +17,7 @@ declare module './context' {
   }
 }
 
-class ReflectService {
-  static resolveInject(ctx: Context, name: string) {
-    const internal = ctx[symbols.internal][name]
-    return [name, internal] as const
-  }
-
+export class ReflectService {
   static checkInject(ctx: Context, name: string, error: Error, key?: symbol) {
     ctx = ctx[symbols.shadow] ?? ctx
     // Case 1: built-in services and special properties
@@ -229,5 +224,3 @@ class ReflectService {
     })
   }
 }
-
-export default ReflectService

packages/core/src/registry.ts

@@ -116,7 +116,7 @@ declare module './context' {
   }
 }
 
-class Registry<out C extends Context = Context> {
+export class RegistryService<out C extends Context = Context> {
   private _counter = 0
   private _internal = new Map<Function, Plugin.Runtime<C>>()
   protected context: Context
@@ -188,7 +188,7 @@ class Registry<out C extends Context = Context> {
     return this.plugin({ inject, apply: callback, name: callback.name })
   }
 
-  plugin(plugin: Plugin<C>, config?: any, getOuterStack = buildOuterStack()): Fiber<C> & PromiseLike<Fiber<C>> {
+  plugin(plugin: Plugin<C>, config?: any, getOuterStack = buildOuterStack()) {
     // check if it's a valid plugin
     const callback = this.resolve(plugin)
     if (!callback) throw new Error('invalid plugin, expect function or object with an "apply" method, received ' + typeof plugin)
@@ -202,15 +202,11 @@ class Registry<out C extends Context = Context> {
       this._internal.set(callback, runtime)
     }
 
-    const fiber = new Fiber(this.ctx, config, Inject.resolve(plugin.inject), runtime, getOuterStack) as Fiber<C> & PromiseLike<Fiber<C>>
-    fiber.then = (onFulfilled, onRejected) => {
-      return fiber.await()
-        .finally(() => fiber.then = undefined!)
-        .then(() => fiber)
-        .then(onFulfilled, onRejected)
+    const fiber = new Fiber(this.ctx, config, Inject.resolve(plugin.inject), runtime, getOuterStack)
+    const wrapped = Object.create(fiber) as Fiber<C> & PromiseLike<Fiber<C>>
+    wrapped.then = (onFulfilled, onRejected) => {
+      return fiber.await().then(onFulfilled, onRejected)
     }
-    return fiber
+    return wrapped
   }
 }
-
-export default Registry