@travetto/registry 7.0.0-rc.1 → 7.0.0-rc.2

package/README.md

@@ -54,13 +54,13 @@ class SampleRegistryAdapter implements RegistryAdapter<Group> {
     this.#class = cls;
   }
 
-  register(...data: Partial<Partial<Group>>[]): Group {
-    for (const d of data) {
+  register(...groups: Partial<Partial<Group>>[]): Group {
+    for (const group of groups) {
       Object.assign(this.#config, {
-        ...d,
+        ...group,
         children: [
           ...(this.#config?.children ?? []),
-          ...(d.children ?? [])
+          ...(group.children ?? [])
         ]
       });
     }
@@ -115,12 +115,12 @@ As mentioned in [Manifest](https://github.com/travetto/travetto/tree/main/module
     const next = new Map<string, Class>(classes.map(cls => [cls.Ⲑid, cls] as const));
     const sourceFile = RuntimeIndex.getSourceFile(importFile);
 
-    let prev = new Map<string, Class>();
+    let previous = new Map<string, Class>();
     if (this.#classes.has(sourceFile)) {
-      prev = new Map(this.#classes.get(sourceFile)!.entries());
+      previous = new Map(this.#classes.get(sourceFile)!.entries());
     }
 
-    const keys = new Set([...Array.from(prev.keys()), ...Array.from(next.keys())]);
+    const keys = new Set([...Array.from(previous.keys()), ...Array.from(next.keys())]);
 
     if (!this.#classes.has(sourceFile)) {
       this.#classes.set(sourceFile, new Map());
@@ -129,22 +129,22 @@ As mentioned in [Manifest](https://github.com/travetto/travetto/tree/main/module
     let changes = 0;
 
     // Determine delta based on the various classes (if being added, removed or updated)
-    for (const k of keys) {
-      if (!next.has(k)) {
+    for (const key of keys) {
+      if (!next.has(key)) {
         changes += 1;
-        this.emit({ type: 'removing', prev: prev.get(k)! });
-        this.#classes.get(sourceFile)!.delete(k);
+        this.emit({ type: 'removing', previous: previous.get(key)! });
+        this.#classes.get(sourceFile)!.delete(key);
       } else {
-        this.#classes.get(sourceFile)!.set(k, next.get(k)!);
-        if (!prev.has(k)) {
+        this.#classes.get(sourceFile)!.set(key, next.get(key)!);
+        if (!previous.has(key)) {
           changes += 1;
-          this.emit({ type: 'added', curr: next.get(k)! });
+          this.emit({ type: 'added', current: next.get(key)! });
         } else {
-          const prevHash = describeFunction(prev.get(k)!)?.hash;
-          const nextHash = describeFunction(next.get(k)!)?.hash;
+          const prevHash = describeFunction(previous.get(key)!)?.hash;
+          const nextHash = describeFunction(next.get(key)!)?.hash;
           if (prevHash !== nextHash) {
             changes += 1;
-            this.emit({ type: 'changed', curr: next.get(k)!, prev: prev.get(k)! });
+            this.emit({ type: 'changed', current: next.get(key)!, previous: previous.get(key)! });
           }
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/registry",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.2",
   "description": "Patterns and utilities for handling registration of metadata and functionality for run-time use",
   "keywords": [
     "ast-transformations",
@@ -27,11 +27,11 @@
     "directory": "module/registry"
   },
   "dependencies": {
-    "@travetto/runtime": "^7.0.0-rc.1"
+    "@travetto/runtime": "^7.0.0-rc.2"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.0.0-rc.1",
-    "@travetto/transformer": "^7.0.0-rc.1"
+    "@travetto/cli": "^7.0.0-rc.2",
+    "@travetto/transformer": "^7.0.0-rc.2"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/internal/commonjs-loader.ts

@@ -7,9 +7,9 @@ import { RetargettingProxy } from '../proxy.ts';
 
 declare module 'module' {
   // eslint-disable-next-line @typescript-eslint/naming-convention
-  function _resolveFilename(req: string, parent: typeof Module): string;
+  function _resolveFilename(request: string, parent: typeof Module): string;
   // eslint-disable-next-line @typescript-eslint/naming-convention
-  function _load(req: string, parent: typeof Module): unknown;
+  function _load(request: string, parent: typeof Module): unknown;
 }
 
 type ModuleLoader = typeof Module['_load'];
@@ -30,22 +30,22 @@ export class DynamicCommonjsLoader {
       let mod: unknown;
       try {
         mod = moduleLoad.apply(null, [request, parent]);
-      } catch (err: unknown) {
+      } catch (error: unknown) {
         const name = Module._resolveFilename!(request, parent);
-        if (err instanceof Error && Runtime.dynamic && !name.startsWith('test/')) {
-          const errMsg = err.message;
-          console.debug(`Unable to load ${name}: stubbing out with error proxy.`, errMsg);
-          const e = (): never => { throw new Error(errMsg); };
-          mod = new Proxy({}, { getOwnPropertyDescriptor: e, get: e, has: e });
+        if (error instanceof Error && Runtime.dynamic && !name.startsWith('test/')) {
+          const message = error.message;
+          console.debug(`Unable to load ${name}: stubbing out with error proxy.`, message);
+          const fail = (): never => { throw new Error(message); };
+          mod = new Proxy({}, { getOwnPropertyDescriptor: fail, get: fail, has: fail });
         } else {
-          throw err;
+          throw error;
         }
       }
 
       const file = Module._resolveFilename!(request, parent);
-      const src = RuntimeIndex.getEntry(file)?.sourceFile;
+      const source = RuntimeIndex.getEntry(file)?.sourceFile;
       // Only proxy workspace modules
-      if (src && RuntimeIndex.getModuleFromSource(src)?.workspace) {
+      if (source && RuntimeIndex.getModuleFromSource(source)?.workspace) {
         return proxyModuleLoad ? proxyModuleLoad(file, mod) : mod;
       } else {
         return mod;

package/src/internal/file-loader.ts

@@ -3,11 +3,11 @@ import { watchCompiler, WatchEvent, Runtime, RuntimeIndex } from '@travetto/runt
 
 const VALID_FILE_TYPES = new Set(['js', 'ts']);
 
-const handle = (err: Error): void => {
-  if (err && (err.message ?? '').includes('Cannot find module')) { // Handle module reloading
-    console.error('Cannot find module', { error: err });
+const handle = (error: Error): void => {
+  if (error && (error.message ?? '').includes('Cannot find module')) { // Handle module reloading
+    console.error('Cannot find module', { error });
   } else {
-    throw err;
+    throw error;
   }
 };
 
@@ -27,19 +27,19 @@ export class DynamicFileLoader {
       .on('uncaughtException', handle);
 
     // Fire off, and let it run in the bg. Restart on exit
-    for await (const ev of watchCompiler({ restartOnExit: true })) {
-      if (ev.file && RuntimeIndex.hasModule(ev.module) && VALID_FILE_TYPES.has(ManifestModuleUtil.getFileType(ev.file))) {
-        if (ev.action === 'update' || ev.action === 'delete') {
-          await loader.unload(ev.output);
+    for await (const event of watchCompiler({ restartOnExit: true })) {
+      if (event.file && RuntimeIndex.hasModule(event.module) && VALID_FILE_TYPES.has(ManifestModuleUtil.getFileType(event.file))) {
+        if (event.action === 'update' || event.action === 'delete') {
+          await loader.unload(event.output);
         }
-        if (ev.action === 'create' || ev.action === 'delete') {
+        if (event.action === 'create' || event.action === 'delete') {
           RuntimeIndex.reinitForModule(Runtime.main.name);
         }
-        if (ev.action === 'create' || ev.action === 'update') {
-          await loader.load(ev.output);
+        if (event.action === 'create' || event.action === 'update') {
+          await loader.load(event.output);
         }
 
-        yield ev;
+        yield event;
       }
     }
   }

package/src/proxy.ts

@@ -7,8 +7,8 @@ const AsyncGeneratorFunction = Object.getPrototypeOf(async function* () { });
 const GeneratorFunction = Object.getPrototypeOf(function* () { });
 const AsyncFunction = Object.getPrototypeOf(async function () { });
 
-function isFunction(o: unknown): o is Function {
-  const proto = o && Object.getPrototypeOf(o);
+function isFunction(value: unknown): value is Function {
+  const proto = value && Object.getPrototypeOf(value);
   return proto && (proto === Function.prototype || proto === AsyncFunction || proto === AsyncGeneratorFunction || proto === GeneratorFunction);
 }
 
@@ -43,19 +43,19 @@ export class RetargettingHandler<T> implements ProxyHandler<Any> {
     return classConstruct(castTo(this.target), argArray);
   }
 
-  setPrototypeOf(target: T, v: unknown): boolean {
-    return Object.setPrototypeOf(this.target, castTo(v));
+  setPrototypeOf(target: T, value: unknown): boolean {
+    return Object.setPrototypeOf(this.target, castTo(value));
   }
 
   getPrototypeOf(target: T): object | null {
     return Object.getPrototypeOf(this.target);
   }
 
-  get(target: T, prop: PropertyKey, receiver: unknown): Any {
-    if (prop === ProxyTargetSymbol) {
+  get(target: T, property: PropertyKey, receiver: unknown): Any {
+    if (property === ProxyTargetSymbol) {
       return this.target;
     }
-    let result = this.target[castKey<T>(prop)];
+    let result = this.target[castKey<T>(property)];
     if (isFunction(result) && !/^class\s/.test(Function.prototype.toString.call(result))) {
       // Bind class members to class instance instead of proxy propagating
       result = result.bind(this.target);
@@ -63,12 +63,12 @@ export class RetargettingHandler<T> implements ProxyHandler<Any> {
     return result;
   }
 
-  has(target: T, prop: PropertyKey): boolean {
-    return castTo<object>(this.target).hasOwnProperty(prop);
+  has(target: T, property: PropertyKey): boolean {
+    return castTo<object>(this.target).hasOwnProperty(property);
   }
 
-  set(target: T, prop: PropertyKey, value: unknown): boolean {
-    this.target[castKey<T>(prop)] = castTo(value);
+  set(target: T, property: PropertyKey, value: unknown): boolean {
+    this.target[castKey<T>(property)] = castTo(value);
     return true;
   }
 
@@ -79,12 +79,12 @@ export class RetargettingHandler<T> implements ProxyHandler<Any> {
       .concat(Object.getOwnPropertySymbols(this.target));
   }
 
-  deleteProperty(target: T, p: PropertyKey): boolean {
-    return delete this.target[castKey<T>(p)];
+  deleteProperty(target: T, property: PropertyKey): boolean {
+    return delete this.target[castKey<T>(property)];
   }
 
-  defineProperty(target: T, p: PropertyKey, attributes: PropertyDescriptor): boolean {
-    Object.defineProperty(this.target, p, attributes);
+  defineProperty(target: T, property: PropertyKey, attributes: PropertyDescriptor): boolean {
+    Object.defineProperty(this.target, property, attributes);
     return true;
   }
 }
@@ -99,8 +99,8 @@ export class RetargettingProxy<T> {
   /**
    * Unwrap proxy
    */
-  static unwrap<U>(el: U): U {
-    return castTo<{ [ProxyTargetSymbol]: U }>(el)?.[ProxyTargetSymbol] ?? el;
+  static unwrap<U>(value: U): U {
+    return castTo<{ [ProxyTargetSymbol]: U }>(value)?.[ProxyTargetSymbol] ?? value;
   }
 
   #handler: RetargettingHandler<T>;

package/src/service/registry.ts

@@ -11,7 +11,7 @@ class $Registry {
   #resolved = false;
   #initialized?: Promise<unknown>;
   trace = false;
-  #uid = Util.uuid();
+  #uniqueId = Util.uuid();
 
   // Lookups
   #indexes = new Map<RegistryIndexClass, RegistryIndex>();
@@ -53,22 +53,22 @@ class $Registry {
   }
 
   process(events: ChangeEvent<Class>[]): void {
-    this.#finalizeItems(events.filter(ev => 'curr' in ev).map(ev => ev.curr));
+    this.#finalizeItems(events.filter(event => 'current' in event).map(event => event.current));
 
     for (const indexCls of this.#indexOrder) { // Visit every index, in order
       const inst = this.instance(indexCls);
-      const matched = events.filter(e => inst.store.has('curr' in e ? e.curr : e.prev!));
+      const matched = events.filter(event => inst.store.has('current' in event ? event.current : event.previous!));
       if (matched.length) {
         inst.process(matched);
       }
     }
 
     Util.queueMacroTask().then(() => {
-      this.#removeItems(events.filter(ev => 'prev' in ev).map(ev => ev.prev!));
+      this.#removeItems(events.filter(event => 'previous' in event).map(event => event.previous!));
     });
 
-    for (const e of events) {
-      this.#emitter.emit('event', e);
+    for (const event of events) {
+      this.#emitter.emit('event', event);
     }
   }
 
@@ -80,12 +80,12 @@ class $Registry {
       this.#resolved = false;
 
       if (this.trace) {
-        console.debug('Initializing', { uid: this.#uid });
+        console.debug('Initializing', { uniqueId: this.#uniqueId });
       }
 
       const added = await this.#classSource.init();
-      this.process(added.map(cls => ({ type: 'added', curr: cls })));
-      this.#classSource.on(e => this.process([e]));
+      this.process(added.map(cls => ({ type: 'added', current: cls })));
+      this.#classSource.on(event => this.process([event]));
     } finally {
       this.#resolved = true;
     }
@@ -116,7 +116,7 @@ class $Registry {
    */
   async init(): Promise<unknown> {
     if (this.trace && this.#initialized) {
-      console.trace('Trying to re-initialize', { uid: this.#uid, initialized: !!this.#initialized });
+      console.trace('Trying to re-initialize', { uniqueId: this.#uniqueId, initialized: !!this.#initialized });
     }
     return this.#initialized ??= this.#init();
   }
@@ -134,7 +134,7 @@ class $Registry {
     } else {
       const inst = this.instance(matches);
       this.#emitter.on('event', (event) => {
-        if (inst.store.has('curr' in event ? event.curr : event.prev!)) {
+        if (inst.store.has('current' in event ? event.current : event.previous!)) {
           handler(event);
         }
       });
@@ -149,13 +149,13 @@ class $Registry {
     handler: (event: ChangeEvent<[Class, Function]>) => void,
     matches?: RegistryIndexClass,
   ): void {
-    const src = this.#methodSource ??= new MethodSource(this.#classSource);
+    const emitter = this.#methodSource ??= new MethodSource(this.#classSource);
     if (!matches) {
-      src.on(handler);
+      emitter.on(handler);
     } else {
       const inst = this.instance(matches);
-      src.on((event) => {
-        if (inst.store.has('curr' in event ? event.curr[0] : event.prev[0])) {
+      emitter.on((event) => {
+        if (inst.store.has('current' in event ? event.current[0] : event.previous[0])) {
           handler(event);
         }
       });

package/src/service/store.ts

@@ -5,7 +5,7 @@ import { EXPIRED_CLASS, RegistrationMethods, RegistryAdapter } from './types';
 function ExchangeExpired<R = unknown>() {
   return function (
     target: Any,
-    propertyKey: string | symbol,
+    propertyKey: string,
     descriptor: TypedPropertyDescriptor<(this: RegistryIndexStore, cls: Class) => R>
   ): void {
     if (Runtime.dynamic) {

package/src/source/class-source.ts

@@ -27,7 +27,7 @@ export class ClassSource implements ChangeSource<Class> {
   /**
    * Are we in a mode that should have enhanced debug info
    */
-  trace = Env.DEBUG.val?.includes('@travetto/registry');
+  trace = Env.DEBUG.value?.includes('@travetto/registry');
 
   /**
    * Flush classes
@@ -35,12 +35,12 @@ export class ClassSource implements ChangeSource<Class> {
   #flush(): Class[] {
     const flushed = flushPendingFunctions().filter(isClass);
     for (const cls of flushed) {
-      const src = Runtime.getSourceFile(cls);
-      if (!this.#classes.has(src)) {
-        this.#classes.set(src, new Map());
+      const source = Runtime.getSourceFile(cls);
+      if (!this.#classes.has(source)) {
+        this.#classes.set(source, new Map());
       }
-      this.#classes.get(src)!.set(cls.Ⲑid, cls);
-      this.emit({ type: 'added', curr: cls });
+      this.#classes.get(source)!.set(cls.Ⲑid, cls);
+      this.emit({ type: 'added', current: cls });
     }
     return flushed;
   }
@@ -50,7 +50,7 @@ export class ClassSource implements ChangeSource<Class> {
     if (data) {
       this.#classes.delete(file);
       for (const cls of data) {
-        this.emit({ type: 'removing', prev: cls[1] });
+        this.emit({ type: 'removing', previous: cls[1] });
       }
     }
   }
@@ -62,12 +62,12 @@ export class ClassSource implements ChangeSource<Class> {
     const next = new Map<string, Class>(classes.map(cls => [cls.Ⲑid, cls] as const));
     const sourceFile = RuntimeIndex.getSourceFile(importFile);
 
-    let prev = new Map<string, Class>();
+    let previous = new Map<string, Class>();
     if (this.#classes.has(sourceFile)) {
-      prev = new Map(this.#classes.get(sourceFile)!.entries());
+      previous = new Map(this.#classes.get(sourceFile)!.entries());
     }
 
-    const keys = new Set([...Array.from(prev.keys()), ...Array.from(next.keys())]);
+    const keys = new Set([...Array.from(previous.keys()), ...Array.from(next.keys())]);
 
     if (!this.#classes.has(sourceFile)) {
       this.#classes.set(sourceFile, new Map());
@@ -76,22 +76,22 @@ export class ClassSource implements ChangeSource<Class> {
     let changes = 0;
 
     // Determine delta based on the various classes (if being added, removed or updated)
-    for (const k of keys) {
-      if (!next.has(k)) {
+    for (const key of keys) {
+      if (!next.has(key)) {
         changes += 1;
-        this.emit({ type: 'removing', prev: prev.get(k)! });
-        this.#classes.get(sourceFile)!.delete(k);
+        this.emit({ type: 'removing', previous: previous.get(key)! });
+        this.#classes.get(sourceFile)!.delete(key);
       } else {
-        this.#classes.get(sourceFile)!.set(k, next.get(k)!);
-        if (!prev.has(k)) {
+        this.#classes.get(sourceFile)!.set(key, next.get(key)!);
+        if (!previous.has(key)) {
           changes += 1;
-          this.emit({ type: 'added', curr: next.get(k)! });
+          this.emit({ type: 'added', current: next.get(key)! });
         } else {
-          const prevHash = describeFunction(prev.get(k)!)?.hash;
-          const nextHash = describeFunction(next.get(k)!)?.hash;
+          const prevHash = describeFunction(previous.get(key)!)?.hash;
+          const nextHash = describeFunction(next.get(key)!)?.hash;
           if (prevHash !== nextHash) {
             changes += 1;
-            this.emit({ type: 'changed', curr: next.get(k)!, prev: prev.get(k)! });
+            this.emit({ type: 'changed', current: next.get(key)!, previous: previous.get(key)! });
           }
         }
       }
@@ -104,17 +104,17 @@ export class ClassSource implements ChangeSource<Class> {
    */
   #handleChanges(classes: Class[] = []): void {
     const classesByFile = new Map<string, Class[]>();
-    for (const el of classes) {
-      const imp = Runtime.getImport(el);
-      if (!classesByFile.has(imp)) {
-        classesByFile.set(imp, []);
+    for (const cls of classes) {
+      const importPath = Runtime.getImport(cls);
+      if (!classesByFile.has(importPath)) {
+        classesByFile.set(importPath, []);
       }
-      classesByFile.get(imp)!.push(el);
+      classesByFile.get(importPath)!.push(cls);
     }
 
-    for (const [imp, els] of classesByFile.entries()) {
-      if (!this.#handleFileChanges(imp, els)) {
-        this.#emitter.emit('unchanged-import', imp);
+    for (const [importPath, items] of classesByFile.entries()) {
+      if (!this.#handleFileChanges(importPath, items)) {
+        this.#emitter.emit('unchanged-import', importPath);
       }
     }
   }
@@ -122,15 +122,15 @@ export class ClassSource implements ChangeSource<Class> {
   /**
    * Emit a change event
    */
-  emit(e: ChangeEvent<Class>): void {
+  emit(event: ChangeEvent<Class>): void {
     if (this.trace) {
       console.debug('Emitting change', {
-        type: e.type,
-        curr: (e.type !== 'removing' ? e.curr?.Ⲑid : undefined),
-        prev: (e.type !== 'added' ? e.prev?.Ⲑid : undefined)
+        type: event.type,
+        current: (event.type !== 'removing' ? event.current?.Ⲑid : undefined),
+        previous: (event.type !== 'added' ? event.previous?.Ⲑid : undefined)
       });
     }
-    this.#emitter.emit('change', e);
+    this.#emitter.emit('change', event);
   }
 
   /**
@@ -139,14 +139,14 @@ export class ClassSource implements ChangeSource<Class> {
   async init(): Promise<Class[]> {
     if (Runtime.dynamic && !this.#listening) {
       this.#listening = (async (): Promise<void> => {
-        for await (const ev of await DynamicFileLoader.listen()) {
-          if (ev.action === 'delete') {
-            this.#removeFile(ev.file); // File no longer exists
+        for await (const event of await DynamicFileLoader.listen()) {
+          if (event.action === 'delete') {
+            this.#removeFile(event.file); // File no longer exists
           } else {
             this.#handleChanges(flushPendingFunctions().filter(isClass));
           }
 
-          if (ev.action === 'create') {
+          if (event.action === 'create') {
             this.#flush();
           }
         }
@@ -155,16 +155,16 @@ export class ClassSource implements ChangeSource<Class> {
 
     // Ensure everything is loaded
     for (const entry of RuntimeIndex.find({
-      module: (m) => {
-        const role = Env.TRV_ROLE.val;
+      module: (mod) => {
+        const role = Env.TRV_ROLE.value;
         return role !== 'test' && // Skip all modules when in test
-          m.roles.includes('std') &&
+          mod.roles.includes('std') &&
           (
-            !Runtime.production || m.prod ||
-            (role === 'doc' && m.roles.includes(role))
+            !Runtime.production || mod.prod ||
+            (role === 'doc' && mod.roles.includes(role))
           );
       },
-      folder: f => f === 'src' || f === '$index'
+      folder: folder => folder === 'src' || folder === '$index'
     })) {
       await Runtime.importFrom(entry.import);
     }

package/src/source/method-source.ts

@@ -16,39 +16,43 @@ export class MethodSource implements ChangeSource<[Class, Function]> {
    * Define parent change source, generally will be the class source
    */
   constructor(classSource: ChangeSource<Class>) {
-    classSource.on(e => this.onClassEvent(e));
+    classSource.on(event => this.onClassEvent(event));
   }
 
   async init(): Promise<void> { }
 
-  emit(ev: ChangeEvent<[Class, Function]>): void {
-    this.#emitter.emit('change', ev);
+  emit(event: ChangeEvent<[Class, Function]>): void {
+    this.#emitter.emit('change', event);
   }
 
   /**
    * On a class being emitted, check methods
    */
-  onClassEvent(e: ChangeEvent<Class>): void {
-    const next = (e.type !== 'removing' ? describeFunction(e.curr!)?.methods : null) ?? {};
-    const prev = (e.type !== 'added' ? describeFunction(e.prev!)?.methods : null) ?? {};
+  onClassEvent(event: ChangeEvent<Class>): void {
+    const next = (event.type !== 'removing' ? describeFunction(event.current!)?.methods : null) ?? {};
+    const previous = (event.type !== 'added' ? describeFunction(event.previous!)?.methods : null) ?? {};
 
     /**
      * Go through each method, comparing hashes.  To see added/removed and changed
      */
-    for (const k of Object.keys(next)) {
-      if ((!prev[k] || !('prev' in e)) && e.type !== 'removing') {
-        this.emit({ type: 'added', curr: [e.curr!, e.curr!.prototype[k]] });
-      } else if (next[k].hash !== prev[k].hash && e.type === 'changed') {
-        // FIXME: Why is e.prev undefined sometimes?
-        this.emit({ type: 'changed', curr: [e.curr, e.curr.prototype[k]], prev: [e.prev, e.prev.prototype[k]] });
+    for (const key of Object.keys(next)) {
+      if ((!previous[key] || !('previous' in event)) && event.type !== 'removing') {
+        this.emit({ type: 'added', current: [event.current!, event.current!.prototype[key]] });
+      } else if (next[key].hash !== previous[key].hash && event.type === 'changed') {
+        // FIXME: Why is event.previous undefined sometimes?
+        this.emit({
+          type: 'changed',
+          current: [event.current, event.current.prototype[key]],
+          previous: [event.previous, event.previous.prototype[key]]
+        });
       } else {
         // Method Unchanged
       }
     }
 
-    for (const k of Object.keys(prev)) {
-      if (!next[k] && e.type !== 'added') {
-        this.emit({ type: 'removing', prev: [e.prev, e.prev.prototype[k]] });
+    for (const key of Object.keys(previous)) {
+      if (!next[key] && event.type !== 'added') {
+        this.emit({ type: 'removing', previous: [event.previous, event.previous.prototype[key]] });
       }
     }
   }

package/src/types.ts

@@ -2,14 +2,14 @@
  * A change event
  */
 export type ChangeEvent<T> =
-  { type: 'changed', prev: T, curr: T } |
-  { type: 'added', curr: T } |
-  { type: 'removing', prev: T };
+  { type: 'changed', previous: T, current: T } |
+  { type: 'added', current: T } |
+  { type: 'removing', previous: T };
 
 /**
  * Change handler
  */
-export type ChangeHandler<T> = (e: ChangeEvent<T>) => unknown;
+export type ChangeHandler<T> = (event: ChangeEvent<T>) => unknown;
 
 /**
  * Change source