chore: fix eslint

MrAntix · Feb 2, 2024 · 91616b6 · 91616b6
1 parent 01cc390
commit 91616b6
Show file tree

Hide file tree

Showing 12 changed files with 91 additions and 91 deletions.
diff --git a/package.json b/package.json
@@ -9,7 +9,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "type": "module",
   "main": "dist/index.umd.js",
   "module": "dist/index.js",
   "typings": "dist/types/index.d.ts",

diff --git a/src/parsing/NextBuilder.ts b/src/parsing/NextBuilder.ts
@@ -4,10 +4,10 @@
  *
  * recursive
  */
- export type NextBuilder<B, exclude extends keyof B = never, include extends keyof B = never> =
+export type NextBuilder<B, exclude extends keyof B = never, include extends keyof B = never> =
  {
      [key in Exclude<keyof B, Exclude<exclude, include>>]
      : B[key] extends (...args: infer A) => NextBuilder<B, infer e, infer i>
-     ? (...args: A) => NextBuilder<B, e | Exclude<exclude, include>, i>      // cascade excludes and includes
+     ? (...args: A) => NextBuilder<B, e | Exclude<exclude, include>, i> // cascade excludes and includes
      : B[key];
  };
diff --git a/src/parsing/ParseErrors.ts b/src/parsing/ParseErrors.ts
@@ -1,5 +1,5 @@
-import { NumberEnumMap } from "./numbers/NumberEnumMap";
-import { getNumberEnumValues } from "./numbers/getNumberEnumValues";
+import { NumberEnumMap } from './numbers/NumberEnumMap';
+import { getNumberEnumValues } from './numbers/getNumberEnumValues';
 
 /**
  * Creates error objects

diff --git a/src/parsing/arrays/IArray.ts b/src/parsing/arrays/IArray.ts
@@ -11,7 +11,7 @@ export namespace IArray {
     readonly each: <U = T>(parser: IParser<U>) => NextBuilder<Parser<U>, 'of' | 'each'>
 
     readonly unique: (distinctor: (item: T) => unknown) => NextBuilder<Parser<T>, 'of' | 'each' | 'unique'>;
-    readonly minLength: (value: number, exclusive?: boolean) => NextBuilder<Parser<T>, 'of'  | 'each'| 'minLength'>;
+    readonly minLength: (value: number, exclusive?: boolean) => NextBuilder<Parser<T>, 'of' | 'each'| 'minLength'>;
     readonly maxLength: (value: number, exclusive?: boolean) => NextBuilder<Parser<T>, 'of' | 'each' | 'maxLength'>;
 
   }

diff --git a/src/parsing/dates/DATE_SETTINGS.ts b/src/parsing/dates/DATE_SETTINGS.ts
@@ -1,6 +1,8 @@
-
+/**
+ * Global date parsing settings
+ */
 export const DATE_SETTINGS = {
-  shortRE: /^(\d{1,2})[^\d\-](\d{1,2})[^\d\-](\d{2}|\d{4})$/,
+  shortRE: /^(\d{1,2})[^\d-](\d{1,2})[^\d-](\d{2}|\d{4})$/,
 
   formatDayFirst: new Date(2000, 1, 1)
     .toLocaleString('default', { day: '2-digit', month: '2-digit' })

diff --git a/src/parsing/dates/dates-parser.spec.ts b/src/parsing/dates/dates-parser.spec.ts
@@ -68,5 +68,5 @@ describe('dates-parser', () => {
     expect(result.value).toEqual(new Date(2000, 1, 1));
 
     DATE_SETTINGS.parseDayFirst = original;
-  })
+  });
 });
diff --git a/src/parsing/dictionaries/Dictionary.ts b/src/parsing/dictionaries/Dictionary.ts
@@ -1,2 +1,2 @@
 
-export type Dictionary<T> = { [k: string]: T; };
+export interface Dictionary<T> { [k: string]: T; }
diff --git a/src/parsing/dictionaries/parseAllDictionary.ts b/src/parsing/dictionaries/parseAllDictionary.ts
@@ -10,26 +10,26 @@ import { Dictionary } from './Dictionary';
  * @returns IParseResult<Dictionary<T>>
  */
 export function parseAllDictionary<T>(
-    parse: IParse<T>
+  parse: IParse<T>
 ): IParse<Dictionary<T>> {
 
-    return value => {
-        if (value == null) return createParseResult(null);
+  return value => {
+    if (value == null) return createParseResult(null);
 
-        return Object.keys(value).reduce<IParseResult<Dictionary<T>>>(
-            (r, n) => {
+    return Object.keys(value).reduce<IParseResult<Dictionary<T>>>(
+      (r, n) => {
 
-                const result = parse(value[n]);
-                const errors = result.success
-                    ? r.errors
-                    : { ...r.errors, [n]: result.errors };
+        const result = parse(value[n]);
+        const errors = result.success
+          ? r.errors
+          : { ...r.errors, [n]: result.errors };
 
-                return createParseResult(
-                    { ...r.value, [n]: result.value },
-                    errors
-                );
-
-            }, createParseResult<Dictionary<T>>({})
+        return createParseResult(
+          { ...r.value, [n]: result.value },
+          errors
         );
-    };
+
+      }, createParseResult<Dictionary<T>>({})
+    );
+  };
 }
diff --git a/src/parsing/json/JsonParser.ts b/src/parsing/json/JsonParser.ts
@@ -7,13 +7,13 @@ import { provideParseJson } from './provideParseJson';
 
 export class JsonParser<T> implements IJson.Parser<T> {
 
-    constructor(
+  constructor(
         private parent: IParser<unknown>,
         private parseCurrent: IParse<T> = provideParseJson<T>()
-    ) { }
+  ) { }
 
-    readonly parse = parseChain<T>(this.parent, this.parseCurrent);
+  readonly parse = parseChain<T>(this.parent, this.parseCurrent);
 
-    readonly for = <T>(schema: ComplexSchema<T>): IComplex.Parser<T> => new ComplexParser(this, schema);
-    readonly use = <T>(parser: IParser<T>) => ({ parse: parseChain<T>(this, parser.parse) });
+  readonly for = <T>(schema: ComplexSchema<T>): IComplex.Parser<T> => new ComplexParser(this, schema);
+  readonly use = <T>(parser: IParser<T>) => ({ parse: parseChain<T>(this, parser.parse) });
 }
diff --git a/src/parsing/json/json-parser.spec.ts b/src/parsing/json/json-parser.spec.ts
@@ -2,50 +2,50 @@ import { Is } from '../../Is';
 import { ParseErrors } from '../ParseErrors';
 
 describe('json-parser', () => {
-    const parser = Is.required.json;
+  const parser = Is.required.json;
 
-    it('success', () => {
-        const value = '{}';
-        const result = parser.parse(value);
+  it('success', () => {
+    const value = '{}';
+    const result = parser.parse(value);
 
-        expect(result.errors).toEqual(ParseErrors.empty);
-        expect(result.value).toEqual({});
-    });
+    expect(result.errors).toEqual(ParseErrors.empty);
+    expect(result.value).toEqual({});
+  });
 
-    it('failure', () => {
-        const value = '{';
-        const result = parser.parse(value);
+  it('failure', () => {
+    const value = '{';
+    const result = parser.parse(value);
 
-        expect(result.errors).toEqual(ParseErrors.json);
-        expect(result.value).toBe(null);
-    });
+    expect(result.errors).toEqual(ParseErrors.json);
+    expect(result.value).toBe(null);
+  });
 
-    it('required', () => {
+  it('required', () => {
 
-        const result = parser.parse(null);
+    const result = parser.parse(null);
 
-        expect(result.errors).toEqual(ParseErrors.required);
-    });
+    expect(result.errors).toEqual(ParseErrors.required);
+  });
 
-    it('not required', () => {
-        const requiredParser = Is.json;
+  it('not required', () => {
+    const requiredParser = Is.json;
 
-        const result = requiredParser.parse(null);
+    const result = requiredParser.parse(null);
 
-        expect(result.errors).toEqual(ParseErrors.empty);
-    });
+    expect(result.errors).toEqual(ParseErrors.empty);
+  });
 
-    describe('and complex', () => {
-        const complexParser = parser.for({
-            date: Is.required.date
-        });
+  describe('and complex', () => {
+    const complexParser = parser.for({
+      date: Is.required.date
+    });
 
-        it('success', () => {
-            const value = '{"date":"1 Jan 2000"}';
-            const result = complexParser.parse(value);
+    it('success', () => {
+      const value = '{"date":"1 Jan 2000"}';
+      const result = complexParser.parse(value);
 
-            expect(result.errors).toEqual(ParseErrors.empty);
-            expect(result.value).toEqual({ "date": new Date('2000-01-01T00:00:00.000Z') });
-        });
-    })
+      expect(result.errors).toEqual(ParseErrors.empty);
+      expect(result.value).toEqual({ 'date': new Date('2000-01-01T00:00:00.000Z') });
+    });
+  });
 });
diff --git a/src/parsing/json/provideParseJson.ts b/src/parsing/json/provideParseJson.ts
@@ -3,22 +3,21 @@ import { IParseResult } from '../IParseResult';
 import { ParseErrors } from '../ParseErrors';
 import { createParseResult } from '../createParseResult';
 
-
 export function provideParseJson<T>() {
 
-    return (value: T): IParseResult<T> => {
-        if (isNullOrEmpty(value))
-            return createParseResult(null);
+  return (value: T): IParseResult<T> => {
+    if (isNullOrEmpty(value))
+      return createParseResult(null);
 
-        if (isStringType(value))
-            try {
-                const parsed = JSON.parse(value);
+    if (isStringType(value))
+      try {
+        const parsed = JSON.parse(value);
 
-                return createParseResult(parsed as T);
-            } catch (error) {
-                console.warn(error);
-            }
+        return createParseResult(parsed as T);
+      } catch (error) {
+        console.warn(error);
+      }
 
-        return createParseResult(null, ParseErrors.json);
-    };
+    return createParseResult(null, ParseErrors.json);
+  };
 }
diff --git a/src/predicates/isObject.spec.ts b/src/predicates/isObject.spec.ts
@@ -1,19 +1,19 @@
-import { isObject } from "./isObject";
+import { isObject } from './isObject';
 
 describe('isObject', () => {
-    [
-        { value: null, expected: false },
-        { value: undefined, expected: false },
-        { value: 1234, expected: false },
-        { value: 'STRING', expected: false },
-        { value: true, expected: false },
-        { value: [], expected: false },
-        { value: {}, expected: true },
-        { value: { a: 1 }, expected: true }
-    ].forEach(({ value: value, expected }) => {
+  [
+    { value: null, expected: false },
+    { value: undefined, expected: false },
+    { value: 1234, expected: false },
+    { value: 'STRING', expected: false },
+    { value: true, expected: false },
+    { value: [], expected: false },
+    { value: {}, expected: true },
+    { value: { a: 1 }, expected: true }
+  ].forEach(({ value: value, expected }) => {
 
-        it(`should return ${expected} for ${JSON.stringify(value)}`, () => {
-            expect(isObject(value)).toBe(expected);
-        });
+    it(`should return ${expected} for ${JSON.stringify(value)}`, () => {
+      expect(isObject(value)).toBe(expected);
     });
+  });
 });
-Original file line number
+Diff line change
@@ Expand Up / @@ -68,5 +68,5 @@ describe('dates-parser', () => { @@
         expect(result.value).toEqual(new Date(2000, 1, 1));
         DATE_SETTINGS.parseDayFirst = original;
-      })
+      });
     });
Original file line number	Diff line number	Diff line change
		@@ -1,2 +1,2 @@

		export type Dictionary<T> = { [k: string]: T; };
		export interface Dictionary<T> { [k: string]: T; }