chore: prefer use type over interface with eslint

Author: Kit-p

.eslintrc.json

@@ -5,6 +5,7 @@
   "extends": ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
   "rules": {
     "@typescript-eslint/consistent-type-imports": "error",
+    "@typescript-eslint/consistent-type-definitions": ["error", "type"],
     "@typescript-eslint/no-unused-vars": [
       "error",
       {

src/parse.ts

@@ -5,17 +5,17 @@ import { decompress } from 'lz4js';
 export type ParseTypeGuardFunction<T> = (obj: any) => obj is T;
 export type ParseReviverFunction = (this: any, key: string, value: any) => any;
 
-export interface ParseOptions {
+export type ParseOptions = {
   extended?: boolean | { enable: boolean; relaxed?: boolean };
   unminify?: boolean | { enable: boolean; keyMap?: Record<string, string> };
   decompress?: boolean | { enable: boolean };
-}
+};
 
-interface _ParseOptions {
+type _ParseOptions = {
   extended: { enable: boolean; relaxed: boolean };
   unminify: { enable: boolean; keyMap?: Record<string, string> };
   decompress: { enable: boolean };
-}
+};
 
 const defaultOptions: _ParseOptions = {
   extended: { enable: false, relaxed: true },

src/stringify.ts

@@ -14,17 +14,17 @@ export type StringifyReplacerFunction = (
   value: any,
 ) => any;
 
-export interface StringifyOptions {
+export type StringifyOptions = {
   extended?: boolean | { enable: boolean; relaxed?: boolean };
   minify?: boolean | { enable: boolean; keyMap?: Record<string, string> };
   compress?: boolean | { enable: boolean };
-}
+};
 
-interface _StringifyOptions {
+type _StringifyOptions = {
   extended: { enable: boolean; relaxed: boolean };
   minify: { enable: boolean; keyMap: Record<string, string> | undefined };
   compress: { enable: boolean };
-}
+};
 
 const defaultOptions: _StringifyOptions = {
   extended: { enable: false, relaxed: true },

test/parse.test.ts

@@ -175,10 +175,10 @@ describe('[parse] decompress', () => {
 });
 
 describe('[parse] type guard', () => {
-  interface TestObject {
+  type TestObject = {
     a: number;
     b: string;
-  }
+  };
 
   const typeGuard = (obj: any): obj is TestObject => {
     return typeof obj?.a === 'number' && typeof obj?.b === 'string';