added updated eslint rules.

Author: Morgul

.eslintrc.js

@@ -14,7 +14,6 @@ module.exports = {
     },
     rules: {
         // Bad Practices
-        '@typescript-eslint/camelcase': 'on',
         '@typescript-eslint/no-explicit-any': 'off',
         'curly': 'error',
         'no-await-in-loop': 'error',

package.json

@@ -7,7 +7,8 @@
   "scripts": {
     "prepublish": "npm run build",
     "build": "tsc",
-    "test": "ts-mocha -p tsconfig.json test/**/*.spec.ts"
+    "test": "ts-mocha -p tsconfig.json test/**/*.spec.ts",
+    "lint": "eslint --ext *.ts src/*.ts test/*.ts"
   },
   "keywords": [
     "json",

src/trivialperms.ts

@@ -15,7 +15,11 @@ class TPManager
 {
     groups : Map<string, TPGroup> = new Map();
 
-    _userHasPerm(user : TPUser, perm : string) : boolean
+    //------------------------------------------------------------------------------------------------------------------
+    // Internal
+    //------------------------------------------------------------------------------------------------------------------
+
+    private _userHasPerm(user : TPUser, perm : string) : boolean
     {
         return checkPerm(user.permissions ?? [], perm);
     }
@@ -37,7 +41,7 @@ class TPManager
         }
 
         const group = new TPGroup(groupDef.name, groupDef.permissions);
-        this.groups.set(groupDef.name,  group);
+        this.groups.set(groupDef.name, group);
 
         return group;
     }
@@ -76,7 +80,7 @@ class TPManager
             {
                 if(group)
                 {
-                    return group.hasPerm(perm)
+                    return group.hasPerm(perm);
                 }
 
                 return false;

src/utils.ts

@@ -12,9 +12,9 @@ export function checkPerm(permissions : string[], perm : string) : boolean
     return permissions.some((permission) =>
     {
         return permission === '*'
-            || permission === '*/*'             // Legacy form
-            || permission === `*/${ perm }`     // Legacy form
-            || permission === perm
+            || permission === '*/*' // Legacy form
+            || permission === `*/${ perm }` // Legacy form
+            || permission === perm;
     });
 }
 

test/group.spec.ts

@@ -9,7 +9,7 @@ import { TPGroup } from '../src/group';
 
 describe('TPGroup', () =>
 {
-    let groupInst, god, godLegacy;
+    let groupInst; let god; let godLegacy;
     beforeEach(() =>
     {
         groupInst = new TPGroup('test', [

test/trivialperms.spec.ts

@@ -10,59 +10,59 @@ import { TPGroupDef } from '../src/interfaces/group';
 
 describe('TrivialPermissions', () =>
 {
-    let batman, stark, mel, leo, azira, crowley;
+    let batman; let stark; let mel; let leo; let azira; let crowley;
     beforeEach(() =>
     {
         batman = {
             name: 'batman',
-            groups: ['Administrators']
+            groups: [ 'Administrators' ]
         };
 
         stark = {
             name: 'tstark',
-            permissions: ['*'],
-            groups: ['Users']
+            permissions: [ '*' ],
+            groups: [ 'Users' ]
         };
 
         leo = {
             name: 'lblume',
-            groups: ['Users']
+            groups: [ 'Users' ]
         };
 
         mel = {
             name: 'projektMelody',
-            groups: ['Users', 'Authors']
+            groups: [ 'Users', 'Authors' ]
         };
 
         azira = {
             name: 'aziraphale',
-            permissions: ['*/canView']
-        }
+            permissions: [ '*/canView' ]
+        };
 
         crowley = {
             name: 'bentleyLover666',
-            permissions: ['*/*']
-        }
+            permissions: [ '*/*' ]
+        };
 
         tp.loadGroups([
             {
-                name: "Administrators",
+                name: 'Administrators',
                 permissions: [
-                    "*"
+                    '*'
                 ]
             },
             {
-                name: "Authors",
+                name: 'Authors',
                 permissions: [
-                    "canViewPosts",
-                    "canAddPosts",
-                    "canEditPosts"
+                    'canViewPosts',
+                    'canAddPosts',
+                    'canEditPosts'
                 ]
             },
             {
-                name: "Users",
+                name: 'Users',
                 permissions: [
-                    "canViewPosts"
+                    'canViewPosts'
                 ]
             }
         ]);
@@ -79,7 +79,7 @@ describe('TrivialPermissions', () =>
         it('can define a group', () =>
         {
             tp.defineGroup({
-                name: "Test",
+                name: 'Test',
                 permissions: []
             });
 
@@ -88,7 +88,7 @@ describe('TrivialPermissions', () =>
 
         it('throws an error if your group does not have a `name` property', () =>
         {
-            function define()
+            function define() : void
             {
                 // WE ARE INTENTIONALLY BREAKING TYPESCRIPT TO TEST THIS
                 tp.defineGroup({} as unknown as TPGroupDef);
@@ -101,23 +101,23 @@ describe('TrivialPermissions', () =>
         {
             tp.loadGroups([
                 {
-                    name: "Test1",
+                    name: 'Test1',
                     permissions: [
-                        "*"
+                        '*'
                     ]
                 },
                 {
-                    name: "Test2",
+                    name: 'Test2',
                     permissions: [
-                        "canView",
-                        "canAdd",
-                        "canEdit"
+                        'canView',
+                        'canAdd',
+                        'canEdit'
                     ]
                 },
                 {
-                    name: "Test3",
+                    name: 'Test3',
                     permissions: [
-                        "canView"
+                        'canView'
                     ]
                 }
             ]);
@@ -149,7 +149,7 @@ describe('TrivialPermissions', () =>
         it('returns false when checking the groups of a user if the group is not registered', () =>
         {
             const user = {
-                groups: ['Users', 'Fakes']
+                groups: [ 'Users', 'Fakes' ]
             };
 
             expect(tp.hasGroup(user, 'Fakes')).to.equal(false);