build: fix lint errors

Author: mtth

package.json

@@ -11,7 +11,7 @@
   "scripts": {
     "clean": "pnpm -r -F !. run clean && rm -rf node_modules",
     "fix": "prettier --write 'packages/**/{src,test}/**/*.{ts,tsx}' && pnpm run lint --fix",
-    "lint": "eslint 'packages/**/{src,test}/**/*.{ts,tsx}'",
+    "lint": "eslint --no-error-on-unmatched-pattern 'packages/**/{src,test}/**/*.{ts,tsx}'",
     "test": "pnpm -r run test run --coverage"
   },
   "devDependencies": {

packages/avsc/types/index.d.ts

@@ -8,20 +8,34 @@
 
 import * as stream from 'stream';
 
-//"virtual" namespace (no JS, just types) for Avro Schema
+// "virtual" namespace (no JS, just types) for Avro Schema
 declare namespace schema {
   export type AvroSchema = DefinedType | DefinedType[];
   type DefinedType = PrimitiveType | ComplexType | LogicalType | Type | string;
-  type PrimitiveType = 'null' | 'boolean' | 'int' | 'long' | 'float' | 'double' | 'bytes' | 'string';
-  type ComplexType = NamedType | RecordType | EnumType | MapType | ArrayType | FixedType;
+  type PrimitiveType =
+    | 'null'
+    | 'boolean'
+    | 'int'
+    | 'long'
+    | 'float'
+    | 'double'
+    | 'bytes'
+    | 'string';
+  type ComplexType =
+    | NamedType
+    | RecordType
+    | EnumType
+    | MapType
+    | ArrayType
+    | FixedType;
   type LogicalType = ComplexType & LogicalTypeExtension;
 
   interface NamedType {
-    type: PrimitiveType
+    type: PrimitiveType;
   }
 
   interface RecordType {
-    type: "record" | "error";
+    type: 'record' | 'error';
     name: string;
     namespace?: string;
     doc?: string;
@@ -31,12 +45,12 @@ declare namespace schema {
       doc?: string;
       type: Schema;
       default?: any;
-      order?: "ascending" | "descending" | "ignore";
+      order?: 'ascending' | 'descending' | 'ignore';
     }[];
   }
 
   interface EnumType {
-    type: "enum";
+    type: 'enum';
     name: string;
     namespace?: string;
     aliases?: string[];
@@ -46,17 +60,17 @@ declare namespace schema {
   }
 
   interface ArrayType {
-    type: "array";
+    type: 'array';
     items: Schema;
   }
 
   interface MapType {
-    type: "map";
+    type: 'map';
     values: Schema;
   }
 
   interface FixedType {
-    type: "fixed";
+    type: 'fixed';
     name: string;
     aliases?: string[];
     size: number;
@@ -73,7 +87,6 @@ type Schema = schema.AvroSchema;
 
 type Callback<V, Err = any> = (err: Err | null, value?: V) => void;
 
-
 type Codec = (buffer: Uint8Array, callback: Callback<Uint8Array>) => void;
 
 interface CodecOptions {
@@ -84,7 +97,7 @@ interface DecoderOptions {
   noDecode: boolean;
   readerSchema: string | object | Type;
   codecs: CodecOptions;
-  parseHook: (schema: Schema) => Type
+  parseHook: (schema: Schema) => Type;
 }
 
 interface EncoderOptions {
@@ -97,27 +110,32 @@ interface EncoderOptions {
 
 /**
  * A projection function that is used when unwrapping unions.
- * This function is called at schema parsing time on each union with its branches'
- * types.
+ * This function is called at schema parsing time on each union with its
+ * branches' types.
  * If it returns a non-null (function) value, that function will be called each
  * time a value's branch needs to be inferred and should return the branch's
  * index.
  * The index muss be a number between 0 and length-1 of the passed types.
  * In this case (a branch index) the union will use an unwrapped representation.
  * Otherwise (undefined), the union will be wrapped.
  */
-type BranchProjection = (types: ReadonlyArray<Type>) =>
-  | ((val: unknown) => number)
-  | undefined;
+type BranchProjection = (
+  types: ReadonlyArray<Type>
+) => ((val: unknown) => number) | undefined;
 
 interface ForSchemaOptions {
   assertLogicalTypes: boolean;
-  logicalTypes: { [type: string]: new (schema: Schema, opts?: any) => types.LogicalType; };
+  logicalTypes: {
+    [type: string]: new (schema: Schema, opts?: any) => types.LogicalType;
+  };
   namespace: string;
   noAnonymousTypes: boolean;
   omitRecordMethods: boolean;
-  registry: { [name: string]: Type };
-  typeHook: (schema: Schema | string, opts: ForSchemaOptions) => Type | undefined;
+  registry: {[name: string]: Type};
+  typeHook: (
+    schema: Schema | string,
+    opts: ForSchemaOptions
+  ) => Type | undefined;
   wrapUnions: BranchProjection | boolean | 'auto' | 'always' | 'never';
 }
 
@@ -139,15 +157,18 @@ interface CloneOptions {
 }
 interface IsValidOptions {
   noUndeclaredFields: boolean;
-  errorHook: (path: string[], val: any, type: Type) => void
+  errorHook: (path: string[], val: any, type: Type) => void;
 }
 
 interface ImportHookPayload {
   path: string;
   type: 'idl' | 'protocol' | 'schema';
 }
 
-type ImportHookCallback = (err: any, params?: {contents: string, path: string}) => void;
+type ImportHookCallback = (
+  err: any,
+  params?: {contents: string; path: string}
+) => void;
 
 type ImportHook = (payload: ImportHookPayload, cb: ImportHookCallback) => void;
 
@@ -160,31 +181,61 @@ interface SchemaOptions {
   noDeref: boolean;
 }
 
-declare class Resolver {
-  //no public methods
-}
+interface Resolver {}
 
 //exported functions
 
-export function assembleProtocol(filePath: string, opts: Partial<AssembleOptions>, callback: Callback<object>): void;
-export function assembleProtocol(filePath: string, callback: Callback<object>): void;
-export function createFileDecoder(fileName: string, opts?: Partial<DecoderOptions>): streams.BlockDecoder;
-export function createFileEncoder(filePath: string, schema: Schema, opts?: Partial<EncoderOptions>): streams.BlockEncoder;
-export function createBlobEncoder(schema: Schema, opts?: Partial<EncoderOptions>): stream.Duplex;
-export function createBlobDecoder(blob: Blob, opts?: Partial<DecoderOptions>): streams.BlockDecoder;
+export function assembleProtocol(
+  filePath: string,
+  opts: Partial<AssembleOptions>,
+  callback: Callback<object>
+): void;
+export function assembleProtocol(
+  filePath: string,
+  callback: Callback<object>
+): void;
+export function createFileDecoder(
+  fileName: string,
+  opts?: Partial<DecoderOptions>
+): streams.BlockDecoder;
+export function createFileEncoder(
+  filePath: string,
+  schema: Schema,
+  opts?: Partial<EncoderOptions>
+): streams.BlockEncoder;
+export function createBlobEncoder(
+  schema: Schema,
+  opts?: Partial<EncoderOptions>
+): stream.Duplex;
+export function createBlobDecoder(
+  blob: Blob,
+  opts?: Partial<DecoderOptions>
+): streams.BlockDecoder;
 export function extractFileHeader(filePath: string, options?: any): any;
 export function parse(schemaOrProtocolIdl: string, options?: any): any; // TODO protocol literal or Type
-export function readProtocol(protocolIdl: string, options?: Partial<DecoderOptions>): any;
-export function readSchema(schemaIdl: string, options?: Partial<DecoderOptions>): Schema;
-
+export function readProtocol(
+  protocolIdl: string,
+  options?: Partial<DecoderOptions>
+): any;
+export function readSchema(
+  schemaIdl: string,
+  options?: Partial<DecoderOptions>
+): Schema;
 
 // TODO more specific types than `any`
 export class Type {
   clone(val: any, opts?: Partial<CloneOptions>): any;
   compare(val1: any, val2: any): number;
   compareBuffers(buf1: Uint8Array, buf2: Uint8Array): number;
   createResolver(type: Type): Resolver;
-  decode(buf: Uint8Array, pos?: number, resolver?: Resolver): { value: any, offset: number};
+  decode(
+    buf: Uint8Array,
+    pos?: number,
+    resolver?: Resolver
+  ): {
+    value: any;
+    offset: number;
+  };
   encode(val: any, buf: Uint8Array, pos?: number): number;
   equals(type: Type): boolean;
   fingerprint(algorithm?: string): Uint8Array;
@@ -209,16 +260,15 @@ export class Type {
   static isType(arg: any, ...prefix: string[]): boolean;
 }
 
-
 export namespace streams {
-
   class BlockDecoder extends stream.Duplex {
     constructor(opts?: Partial<DecoderOptions>);
     static defaultCodecs(): CodecOptions;
 
-    //should add meta-data listener, but regrettably that requires all other events to be repeated
-    //here, or else they won't show up in code-completion. To avoid clutter, the meta-data event
-    //is therefore omitted from this stream.
+    // Should add meta-data listener, but regrettably that requires all other
+    // events to be repeated here, or else they won't show up in
+    // code-completion. To avoid clutter, the meta-data event is therefore
+    // omitted from this stream.
   }
 
   class BlockEncoder extends stream.Duplex {
@@ -227,11 +277,11 @@ export namespace streams {
   }
 
   class RawDecoder extends stream.Duplex {
-    constructor(schema: Schema, opts?: { decode?: boolean });
+    constructor(schema: Schema, opts?: {decode?: boolean});
   }
 
   class RawEncoder extends stream.Duplex {
-    constructor(schema: Schema, opts?: { batchSize?: number });
+    constructor(schema: Schema, opts?: {batchSize?: number});
   }
 }
 
@@ -242,17 +292,20 @@ export namespace types {
     random(): unknown[];
   }
 
-  class BooleanType extends Type {  // TODO: Document this on the wiki
+  class BooleanType extends Type {
+    // TODO: Document this on the wiki
     constructor();
     random(): boolean;
   }
 
-  class BytesType extends Type {  // TODO: Document this on the wiki
+  class BytesType extends Type {
+    // TODO: Document this on the wiki
     constructor();
     random(): Uint8Array;
   }
 
-  class DoubleType extends Type {  // TODO: Document this on the wiki
+  class DoubleType extends Type {
+    // TODO: Document this on the wiki
     constructor();
     random(): number;
   }
@@ -301,15 +354,16 @@ export namespace types {
     random(): Record<string, unknown>;
   }
 
-  class NullType extends Type {  // TODO: Document this on the wiki
+  class NullType extends Type {
+    // TODO: Document this on the wiki
     constructor();
     random(): null;
   }
 
   class RecordType extends Type {
     constructor(schema: Schema, opts?: any);
     readonly fields: Field[];
-    readonly recordConstructor: any;  // TODO: typeof Record once Record interface/class exists
+    readonly recordConstructor: any; // TODO: typeof Record once Record interface/class exists
     field(name: string): Field;
     random(): object;
   }
@@ -322,7 +376,8 @@ export namespace types {
     type: Type;
   }
 
-  class StringType extends Type {  // TODO: Document this on the wiki
+  class StringType extends Type {
+    // TODO: Document this on the wiki
     constructor();
     random(): string;
   }