chore: add codely eslint linter

eslint.config.mjs

@@ -0,0 +1,3 @@
+import eslintConfigCodely from "eslint-config-codely";
+
+export default [...eslintConfigCodely.ts];

jest.config.js

@@ -1,6 +1,6 @@
 module.exports = {
-  testMatch: ["**/tests/**/*.test.ts"],
-  transform: {
-    "\\.ts$": "ts-jest",
-  },
+	testMatch: ["**/tests/**/*.test.ts"],
+	transform: {
+		"\\.ts$": "ts-jest",
+	},
 };

package.json

@@ -15,7 +15,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "lint": "eslint --ignore-path .gitignore . --ext .ts",
+    "lint": "eslint src tests eslint.config.mjs jest.config.js",
     "lint:fix": "npm run lint -- --fix",
     "test": "jest"
   },
@@ -33,14 +33,11 @@
   "homepage": "https://github.com/CodelyTV/typescript-primitives-type#readme",
   "devDependencies": {
     "@types/jest": "^27.5.2",
-    "@typescript-eslint/eslint-plugin": "^5.21.0",
-    "@typescript-eslint/parser": "^5.21.0",
-    "eslint": "^8.14.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-jest": "^26.1.5",
-    "eslint-plugin-prettier": "^4.0.0",
-    "eslint-plugin-simple-import-sort": "^7.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.15.0",
+    "@typescript-eslint/parser": "^8.15.0",
+    "eslint": "^8.56.0",
+    "eslint-config-codely": "^4.2.0",
+    "eslint-import-resolver-typescript": "^3.7.0",
     "expect-type": "^0.13.0",
     "jest": "^28.0.1",
     "prettier": "^2.6.2",

src/Primitives.ts

@@ -1,6 +1,6 @@
-/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
 type Methods<T> = {
-  [P in keyof T]: T[P] extends Function ? P : never;
+	[P in keyof T]: T[P] extends Function ? P : never;
 }[keyof T];
 
 type MethodsAndProperties<T> = { [key in keyof T]: T[key] };
@@ -10,19 +10,19 @@ type Properties<T> = Omit<MethodsAndProperties<T>, Methods<T>>;
 type PrimitiveTypes = string | number | boolean | Date | undefined | null;
 
 type ValueObjectValue<T> = T extends PrimitiveTypes
-  ? T
-  : T extends { value: infer U }
-  ? U
-  : T extends Array<{ value: infer U }>
-  ? U[]
-  : T extends Array<infer U>
-  ? Array<ValueObjectValue<U>>
-  : T extends { [K in keyof Properties<T>]: unknown }
-  ? { [K in keyof Properties<T>]: ValueObjectValue<Properties<T>[K]> }
-  : T extends unknown
-  ? T
-  : never;
+	? T
+	: T extends { value: infer U }
+		? U
+		: T extends Array<{ value: infer U }>
+			? U[]
+			: T extends Array<infer U>
+				? Array<ValueObjectValue<U>>
+				: T extends { [K in keyof Properties<T>]: unknown }
+					? { [K in keyof Properties<T>]: ValueObjectValue<Properties<T>[K]> }
+					: T extends unknown
+						? T
+						: never;
 
 export type Primitives<T> = {
-  [key in keyof Properties<T>]: ValueObjectValue<T[key]>;
+	[key in keyof Properties<T>]: ValueObjectValue<T[key]>;
 };

tests/Address.ts

@@ -3,17 +3,17 @@ import { City } from "./City";
 import { Street } from "./Street";
 
 export class Address {
-  constructor(
-    readonly street: Street,
-    readonly city: City,
-    readonly number: number
-  ) {}
+	constructor(
+		readonly street: Street,
+		readonly city: City,
+		readonly number: number,
+	) {}
 
-  toPrimitives(): Primitives<Address> {
-    return {
-      street: this.street.value,
-      city: this.city.value,
-      number: this.number,
-    };
-  }
+	toPrimitives(): Primitives<Address> {
+		return {
+			street: this.street.value,
+			city: this.city.value,
+			number: this.number,
+		};
+	}
 }

tests/Course.ts

@@ -1,16 +1,16 @@
-import { Primitives } from "../src/Primitives";
+import { Primitives } from "../src";
 import { CourseId } from "./CourseId";
 
 export class Course {
-  constructor(readonly courseId: CourseId) {}
+	constructor(readonly courseId: CourseId) {}
 
-  toPrimitives(): Primitives<Course> {
-    return {
-      courseId: this.courseId.value,
-    };
-  }
+	toPrimitives(): Primitives<Course> {
+		return {
+			courseId: this.courseId.value,
+		};
+	}
 
-  thisFunctionShouldNotBeIncludedInTheToPrimitives(): boolean {
-    return true;
-  }
+	thisFunctionShouldNotBeIncludedInTheToPrimitives(): boolean {
+		return true;
+	}
 }

tests/DeliveryInfo.ts

@@ -1,12 +1,12 @@
-import { Primitives } from "../src/Primitives";
+import { Primitives } from "../src";
 import { Address } from "./Address";
 
 export class DeliveryInfo {
-  constructor(readonly addresses: Address[]) {}
+	constructor(readonly addresses: Address[]) {}
 
-  toPrimitives(): Primitives<DeliveryInfo> {
-    return {
-      addresses: this.addresses.map((address) => address.toPrimitives()),
-    };
-  }
+	toPrimitives(): Primitives<DeliveryInfo> {
+		return {
+			addresses: this.addresses.map((address) => address.toPrimitives()),
+		};
+	}
 }

tests/Learner.ts

@@ -1,12 +1,12 @@
-import { Primitives } from "../src/Primitives";
+import { Primitives } from "../src";
 import { CourseId } from "./CourseId";
 
 export class Learner {
-  constructor(readonly enrolledCourses: CourseId[]) {}
+	constructor(readonly enrolledCourses: CourseId[]) {}
 
-  toPrimitives(): Primitives<Learner> {
-    return {
-      enrolledCourses: this.enrolledCourses.map((course) => course.value),
-    };
-  }
+	toPrimitives(): Primitives<Learner> {
+		return {
+			enrolledCourses: this.enrolledCourses.map((course) => course.value),
+		};
+	}
 }

tests/Metadata.ts

@@ -1,11 +1,11 @@
 import { Primitives } from "../src";
 
 export class Metadata {
-  constructor(public readonly data: Record<string, unknown>) {}
+	constructor(public readonly data: Record<string, unknown>) {}
 
-  toPrimitives(): Primitives<Metadata> {
-    return {
-      data: this.data,
-    };
-  }
+	toPrimitives(): Primitives<Metadata> {
+		return {
+			data: this.data,
+		};
+	}
 }

tests/Primitives.test.ts

@@ -10,84 +10,84 @@ import { User } from "./User";
 import { Video } from "./Video";
 
 describe("Primitives", () => {
-  it("should ensure to only return primitive properties excluding methods", () => {
-    type actualPrimitives = Primitives<Course>;
+	it("should ensure to only return primitive properties excluding methods", () => {
+		type actualPrimitives = Primitives<Course>;
 
-    type expectedPrimitives = {
-      readonly courseId: string;
-    };
+		type expectedPrimitives = {
+			readonly courseId: string;
+		};
 
-    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
-  });
+		expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+	});
 
-  it("should get primitive array type from value object array", () => {
-    type actualPrimitives = Primitives<Learner>;
+	it("should get primitive array type from value object array", () => {
+		type actualPrimitives = Primitives<Learner>;
 
-    type expectedPrimitives = {
-      readonly enrolledCourses: string[];
-    };
+		type expectedPrimitives = {
+			readonly enrolledCourses: string[];
+		};
 
-    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
-  });
+		expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+	});
 
-  it("should generate nested primitive object", () => {
-    type actualPrimitives = Primitives<User>;
+	it("should generate nested primitive object", () => {
+		type actualPrimitives = Primitives<User>;
 
-    type expectedPrimitives = {
-      readonly address: {
-        readonly city: string;
-        readonly street: string;
-        readonly number: number;
-      };
-    };
+		type expectedPrimitives = {
+			readonly address: {
+				readonly city: string;
+				readonly street: string;
+				readonly number: number;
+			};
+		};
 
-    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
-  });
+		expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+	});
 
-  it("should generate nested primitive type from array of value objects prop", () => {
-    type actualPrimitives = Primitives<DeliveryInfo>;
+	it("should generate nested primitive type from array of value objects prop", () => {
+		type actualPrimitives = Primitives<DeliveryInfo>;
 
-    type expectedPrimitives = {
-      readonly addresses: {
-        readonly city: string;
-        readonly street: string;
-        readonly number: number;
-      }[];
-    };
+		type expectedPrimitives = {
+			readonly addresses: {
+				readonly city: string;
+				readonly street: string;
+				readonly number: number;
+			}[];
+		};
 
-    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
-  });
+		expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+	});
 
-  it("should get primitive type in case it is not a value object", () => {
-    type actualPrimitives = Primitives<Product>;
+	it("should get primitive type in case it is not a value object", () => {
+		type actualPrimitives = Primitives<Product>;
 
-    type expectedPrimitives = {
-      readonly active: boolean;
-      readonly createdAt: Date;
-    };
+		type expectedPrimitives = {
+			readonly active: boolean;
+			readonly createdAt: Date;
+		};
 
-    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
-  });
+		expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+	});
 
-  it("should infer the optional properties", () => {
-    type actualPrimitives = Primitives<Video>;
+	it("should infer the optional properties", () => {
+		type actualPrimitives = Primitives<Video>;
 
-    type expectedPrimitives = {
-      readonly id: string;
-      readonly name: string | undefined;
-      readonly duration: number | undefined;
-    };
+		type expectedPrimitives = {
+			readonly id: string;
+			readonly name: string | undefined;
+			readonly duration: number | undefined;
+		};
 
-    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
-  });
+		expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+	});
 
-  it("should infer properties with unknown type", () => {
-    type actualPrimitives = Primitives<Metadata>;
+	it("should infer properties with unknown type", () => {
+		type actualPrimitives = Primitives<Metadata>;
 
-    type expectedPrimitives = {
-      readonly data: Record<string, unknown>;
-    };
+		type expectedPrimitives = {
+			readonly data: Record<string, unknown>;
+		};
 
-    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
-  });
+		expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+	});
 });

tests/Product.ts

@@ -1,15 +1,15 @@
 import { Primitives } from "../src";
 
 export class Product {
-  constructor(
-    public readonly active: boolean,
-    public readonly createdAt: Date
-  ) {}
+	constructor(
+		public readonly active: boolean,
+		public readonly createdAt: Date,
+	) {}
 
-  toPrimitives(): Primitives<Product> {
-    return {
-      active: this.active,
-      createdAt: this.createdAt,
-    };
-  }
+	toPrimitives(): Primitives<Product> {
+		return {
+			active: this.active,
+			createdAt: this.createdAt,
+		};
+	}
 }