🤖 Merge PR #61712 prepper type definitions (new package) by @teunmooij

* feat: added prepper

* fix: linting

* chore: name

* fix: header and linting

types/prepper/index.d.ts

@@ -0,0 +1,85 @@
+// Type definitions for prepper 1.2
+// Project: https://github.com/guidesmiths/prepper
+// Definitions by: Teun Mooij <https://github.com/teunmooij>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import { EventEmitter } from 'events';
+
+export interface LogFn {
+  (message: string, error: Error, context?: any): void;
+  (message_or_error: string | Error, context?: any): void;
+  (context: any): void;
+}
+
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+
+export interface LoggerOptions {
+  sequence?: handlers.Handler;
+  handlers?: handlers.Handler[];
+  message?: string;
+  level?: LogLevel;
+  maxListeners?: number;
+}
+
+export interface Logger {
+  trace: LogFn;
+  debug: LogFn;
+  info: LogFn;
+  warn: LogFn;
+  error: LogFn;
+  fatal: LogFn;
+  log: LogFn;
+  child: (options: LoggerOptions) => Logger;
+}
+
+export class Logger extends EventEmitter implements Logger {
+  constructor(options?: LoggerOptions);
+}
+
+export namespace handlers {
+  type PropertyName = string | number | symbol;
+
+  type Event = {
+    message?: string;
+    level: LogLevel;
+    error?: { message: string; level: string; error: any };
+  } & Record<string, any>;
+
+  interface Handler extends EventEmitter {
+    /**
+     * handles the event
+     * @remarks handle must emit 'message' event, passing on the altered event
+     */
+    handle(event: Event): void;
+  }
+
+  class Merge extends EventEmitter implements Handler {
+    constructor(other: Record<string, any>, options?: { key?: PropertyName | PropertyName[]; invert?: boolean });
+    handle(event: Event): void;
+  }
+
+  class KeyFilter extends EventEmitter implements Handler {
+    constructor(other: { include?: string[]; exclude?: string[] });
+    handle(event: Event): void;
+  }
+
+  class Oversized extends EventEmitter implements Handler {
+    constructor(options: { size: number });
+    handle(event: Event): void;
+  }
+
+  class Sequence extends EventEmitter implements Handler {
+    constructor(handlers?: Handler[]);
+    handle(event: Event): void;
+  }
+
+  class Env extends EventEmitter implements Handler { handle(event: Event): void; }
+  class Noop extends EventEmitter implements Handler { handle(event: Event): void; }
+  class Repo extends EventEmitter implements Handler { handle(event: Event): void; }
+  class Tracer extends EventEmitter implements Handler { handle(event: Event): void; }
+  class Process extends EventEmitter implements Handler { handle(event: Event): void; }
+  class System extends EventEmitter implements Handler { handle(event: Event): void; }
+  class Timestamp extends EventEmitter implements Handler { handle(event: Event): void; }
+  class Flatten extends EventEmitter implements Handler { handle(event: Event): void; }
+  class Unflatten extends EventEmitter implements Handler { handle(event: Event): void; }
+}

types/prepper/prepper-tests.ts

@@ -0,0 +1,50 @@
+import { EventEmitter } from 'events';
+import { Logger, handlers } from 'prepper';
+
+const logger: Logger = new Logger({
+  handlers: [
+    new handlers.Merge({ foo: 'bar' }, { invert: true }),
+    new handlers.Oversized({ size: 100_000 }),
+    new handlers.Env(),
+    new handlers.Noop(),
+    new handlers.Repo(),
+    new handlers.Tracer(),
+    new handlers.Process(),
+    new handlers.System(),
+    new handlers.Flatten(),
+    new handlers.KeyFilter({ include: ['a', 'b'], exclude: ['a.b'] }),
+    new handlers.Unflatten(),
+  ],
+  message: 'Some default message',
+  level: 'warn',
+  maxListeners: 15,
+});
+
+const otherLogger = new Logger({
+  sequence: new handlers.Sequence([new handlers.Noop()])
+}).on('message', logger.log);
+
+class CustomHandler extends EventEmitter implements handlers.Handler {
+  handle(event: handlers.Event): void {
+    const extendedEvent = {
+      ...event,
+      foo: 'bar'
+    };
+
+    this.emit('message', extendedEvent);
+  }
+}
+
+const childLogger = otherLogger.child({
+  handlers: [
+    new handlers.Merge({ correlationId: '123' }),
+    new CustomHandler(),
+  ],
+});
+
+childLogger.trace('message');
+childLogger.debug('message', { foo: 'bar' });
+childLogger.info({ message: 'message', foo: 'bar' });
+childLogger.warn('oops');
+childLogger.error(new Error('oops'), { dump: '...' });
+childLogger.fatal('message', new Error('very oops'), { dump: '...' });

types/prepper/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "prepper-tests.ts"
+    ]
+}

types/prepper/tslint.json

@@ -0,0 +1 @@
+{ "extends": "@definitelytyped/dtslint/dt.json" }