chore(core): Release by scope and update ESLint's member-ordering rule (#107)

Author: JoseLion

.eslintrc.json

@@ -81,8 +81,8 @@
         "static-method",
         "abstract-method",
         "protected-method",
-        "private-method",
-        "public-method"
+        "public-method",
+        "private-method"
       ],
       "interfaces": { "order": "alphabetically" },
       "typeLiterals": { "order": "alphabetically" }

packages/core/.releaserc.json

@@ -4,7 +4,9 @@
     "main"
   ],
   "plugins": [
-    "@semantic-release/commit-analyzer",
+    ["@semantic-release/commit-analyzer", {
+      "releaseRules": [{ "scope": "!core", "release": false }]
+    }],
     "@semantic-release/release-notes-generator",
     "semantic-release-yarn",
     "@semantic-release/github"

packages/core/package.json

@@ -22,6 +22,7 @@
   "engines": {
     "node": ">=16"
   },
+  "packageManager": "yarn@3.6.1",
   "scripts": {
     "build": "tsc -p tsconfig.prod.json",
     "check": "yarn compile && yarn test --forbid-only",

packages/core/src/lib/Assertion.ts

@@ -95,18 +95,6 @@ export class Assertion<T> {
     return this.normalized();
   }
 
-  private proxyInverter(isInverted: boolean): ProxyHandler<this>["get"] {
-    return (target, p) => {
-      const key = isKeyOf(target, p) ? p : undefined;
-
-      if (key === "inverted") {
-        return isInverted;
-      }
-
-      return key ? target[key] : undefined;
-    };
-  }
-
   /**
    * Check if the value matches the given predicate.
    *
@@ -535,4 +523,16 @@ export class Assertion<T> {
       message: `Expected <${prettify(this.actual)}> to be of type "${typeName}"`,
     });
   }
+
+  private proxyInverter(isInverted: boolean): ProxyHandler<this>["get"] {
+    return (target, p) => {
+      const key = isKeyOf(target, p) ? p : undefined;
+
+      if (key === "inverted") {
+        return isInverted;
+      }
+
+      return key ? target[key] : undefined;
+    };
+  }
 }

packages/core/src/lib/FunctionAssertion.ts

@@ -28,15 +28,6 @@ export class FunctionAssertion<T extends AnyFunction> extends Assertion<T> {
     super(actual);
   }
 
-  private captureError<X>(): X | typeof NoThrow {
-    try {
-      this.actual();
-      return NoThrow;
-    } catch (error) {
-      return error as X;
-    }
-  }
-
   /**
    * Check if the function throws when called. Optionally, you can check that
    * the thrown error is strictly equal to an `Error` instance by passing it as
@@ -192,4 +183,13 @@ export class FunctionAssertion<T extends AnyFunction> extends Assertion<T> {
       ? new typeFactory.Factory(captured)
       : new Assertion(captured) as A;
   }
+
+  private captureError<X>(): X | typeof NoThrow {
+    try {
+      this.actual();
+      return NoThrow;
+    } catch (error) {
+      return error as X;
+    }
+  }
 }

packages/core/src/lib/ObjectAssertion.ts

@@ -17,12 +17,6 @@ export class ObjectAssertion<T extends Struct> extends Assertion<T> {
     super(actual);
   }
 
-  private hasOwnProp(prop: PropertyKey | undefined): boolean {
-    return prop !== undefined
-      ? Object.prototype.hasOwnProperty.call(this.actual, prop)
-      : false;
-  }
-
   /**
    * Check if the object is empty. That is, when the object doesn't have any
    * properties.
@@ -458,4 +452,10 @@ export class ObjectAssertion<T extends Struct> extends Assertion<T> {
       invertedError,
     });
   }
+
+  private hasOwnProp(prop: PropertyKey | undefined): boolean {
+    return prop !== undefined
+      ? Object.prototype.hasOwnProperty.call(this.actual, prop)
+      : false;
+  }
 }