fix(thumbnail): [PKG-TOOL-THUMB-04] supply public types and installed module entries

packages/artplayer-tool-thumbnail/src/emitter.ts

@@ -1,26 +1,27 @@
 // Locally adapted from tiny-emitter; upstream reference 2.1.0. See THIRD_PARTY_NOTICES.
 type EventMap<Events> = { [Name in keyof Events]: readonly unknown[] }
+type EventArgs<Events extends EventMap<Events>, Name extends PropertyKey, Custom extends unknown[]> = Name extends keyof Events ? [...Events[Name]] : Custom
 type Listener<Args extends unknown[]> = ((...args: Args) => unknown) & { _?: (...args: Args) => unknown }
 interface Registration<Args extends unknown[]> {
   fn: Listener<Args>
   ctx: unknown
 }
-type Registry<Events extends EventMap<Events>> = { [Name in keyof Events]?: Registration<[...Events[Name]]>[] }
+type Registry = Partial<Record<PropertyKey, Registration<never[]>[]>>
 
 export default class Emitter<Events extends EventMap<Events> = Record<PropertyKey, unknown[]>> {
-  declare e?: Registry<Events>
+  declare e?: Registry
 
-  on<Name extends keyof Events, Context>(name: Name, fn: (this: Context, ...args: [...Events[Name]]) => unknown, ctx?: Context): this {
-    const e: Registry<Events> = this.e || (this.e = {});
-    (e[name] || (e[name] = [])).push({ fn, ctx })
+  on<Name extends PropertyKey, Custom extends unknown[], Context>(name: Name, fn: (this: Context, ...args: EventArgs<Events, Name, Custom>) => unknown, ctx?: Context): this {
+    const e: Registry = this.e || (this.e = {});
+    (e[name] || (e[name] = [] as Registration<never[]>[])).push({ fn, ctx })
     return this
   }
 
-  once<Name extends keyof Events, Context>(name: Name, fn: (this: Context, ...args: [...Events[Name]]) => unknown, ctx?: Context): this {
+  once<Name extends PropertyKey, Custom extends unknown[], Context>(name: Name, fn: (this: Context, ...args: EventArgs<Events, Name, Custom>) => unknown, ctx?: Context): this {
     // eslint-disable-next-line ts/no-this-alias -- Preserve the owning emitter independently of callback ctx.
     const self = this
-    const callback: Listener<[...Events[Name]]> = fn
-    function listener(...args: [...Events[Name]]) {
+    const callback: Listener<EventArgs<Events, Name, Custom>> = fn
+    function listener(...args: EventArgs<Events, Name, Custom>) {
       self.off(name, listener)
       callback.apply(ctx, args)
     }
@@ -28,19 +29,20 @@ export default class Emitter<Events extends EventMap<Events> = Record<PropertyKe
     return this.on(name, listener, ctx)
   }
 
-  emit<Name extends keyof Events>(name: Name, ...data: [...Events[Name]]): this {
-    const e: Registry<Events> = this.e || (this.e = {})
+  emit<Name extends PropertyKey, Custom extends unknown[]>(name: Name, ...data: EventArgs<Events, Name, Custom>): this {
+    const e: Registry = this.e || (this.e = {})
     const evtArr = (e[name] || []).slice()
     for (let i = 0; i < evtArr.length; i += 1) {
-      evtArr[i]!.fn.apply(evtArr[i]!.ctx, data)
+      // The registry erases heterogeneous listener tuples; emit checks its own payload.
+      (evtArr[i]!.fn as Listener<typeof data>).apply(evtArr[i]!.ctx, data)
     }
     return this
   }
 
-  off<Name extends keyof Events>(name: Name, callback?: Listener<[...Events[Name]]>): this {
-    const e: Registry<Events> = this.e || (this.e = {})
+  off<Name extends PropertyKey, Custom extends unknown[]>(name: Name, callback?: Listener<EventArgs<Events, Name, Custom>>): this {
+    const e: Registry = this.e || (this.e = {})
     const evts = e[name]
-    const liveEvents: Registration<[...Events[Name]]>[] = []
+    const liveEvents: Registration<never[]>[] = []
     if (evts && callback) {
       for (let i = 0, len = evts.length; i < len; i += 1) {
         if (evts[i]!.fn !== callback && evts[i]!.fn._ !== callback)