@projectwallace/css-code-quality 1.0.1 → 1.0.3

package/dist/core.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} analysis
+ */
+export function calculate(analysis: ReturnType<typeof import('@projectwallace/css-analyzer').analyze>): {
+    /** @deprecated */
+    score: number;
+    violations: {
+        id: string;
+        score: number;
+        value: number;
+    }[];
+    passes: {
+        id: string;
+        score: number;
+        value: number;
+    }[];
+    performance: {
+        score: number;
+        violations: {
+            id: string;
+            score: number;
+            value: number;
+        }[];
+        passes: {
+            id: string;
+            score: number;
+            value: number;
+        }[];
+    };
+    maintainability: {
+        score: number;
+        violations: {
+            id: string;
+            score: number;
+            value: number;
+        }[];
+        passes: {
+            id: string;
+            score: number;
+            value: number;
+        }[];
+    };
+    complexity: {
+        score: number;
+        violations: {
+            id: string;
+            score: number;
+            value: number;
+        }[];
+        passes: {
+            id: string;
+            score: number;
+            value: number;
+        }[];
+    };
+};

package/dist/css-code-quality.js

@@ -0,0 +1,295 @@
+import { compareSpecificity as i, analyze as l } from "@projectwallace/css-analyzer";
+const m = [
+  // Should not contain @import rules
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => ({
+    id: "Imports",
+    score: e.atrules.import.total * 10,
+    value: e.atrules.import.total,
+    actuals: Object.keys(e.atrules.import.unique)
+  }),
+  // Should not contain empty rules
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => ({
+    id: "EmptyRules",
+    score: e.rules.empty.total,
+    value: e.rules.empty.total
+  }),
+  // Too many selectors appear multiple times
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const s = {
+      id: "SelectorDuplications",
+      score: 0,
+      value: 1 - e.selectors.uniquenessRatio
+    };
+    return e.selectors.uniquenessRatio < 0.66 && (s.score = Math.floor((1 - e.selectors.uniquenessRatio) * 10)), s;
+  },
+  // Too many declarations appear multiple times
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const s = {
+      id: "DeclarationDuplications",
+      score: 0,
+      value: 1 - e.declarations.unique.ratio
+    };
+    return e.declarations.unique.ratio < 0.66 && (s.score = Math.floor((1 - e.declarations.unique.ratio) * 10)), s;
+  },
+  // The total amount of CSS should not be too high
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => ({
+    id: "CssSize",
+    score: e.stylesheet.size > 2e5 ? 5 : 0,
+    value: e.stylesheet.size
+  }),
+  // Should not contain (too much) comments
+  // Deduct 1 point for every 250 bytes
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const { comments: s } = e.stylesheet;
+    return {
+      id: "TooMuchComments",
+      score: Math.min(10, Math.floor(s.size / 250)),
+      value: s.size
+    };
+  },
+  // Should not contain too much embedded content
+  // Deduct 1 point for every 250 bytes
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const { size: s } = e.stylesheet.embeddedContent;
+    return {
+      id: "TooMuchEmbeddedContent",
+      score: Math.min(20, Math.floor(s.total / 250)),
+      value: s.total,
+      actuals: Object.keys(e.stylesheet.embeddedContent.unique)
+    };
+  }
+], u = [
+  // Source Lines of Code should be low
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const s = {
+      id: "SourceLinesOfCode",
+      score: 0,
+      value: e.stylesheet.sourceLinesOfCode
+    };
+    if (e.stylesheet.sourceLinesOfCode > 1e4) {
+      const o = Math.floor((e.stylesheet.sourceLinesOfCode - 1e4) / 1e3);
+      s.score = Math.min(15, o);
+    }
+    return s;
+  },
+  // Average count of Selectors per RuleSet should be low
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const o = e.rules.selectors.mean, t = {
+      id: "AverageSelectorsPerRule",
+      score: 0,
+      value: o,
+      actuals: e.rules.selectors.items
+    };
+    if (o > 2) {
+      const c = Math.floor((o - 2) * 5);
+      t.score = Math.min(15, c);
+    }
+    return t;
+  },
+  // Average count of Declarations per RuleSet should be low
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const o = {
+      id: "AverageDeclarationsPerRule",
+      score: 0,
+      value: e.rules.declarations.mean,
+      actuals: e.rules.declarations.items
+    };
+    if (e.rules.declarations.mean > 5) {
+      const t = Math.floor((e.rules.declarations.mean - 5) * 5);
+      o.score = Math.min(15, t);
+    }
+    return o;
+  },
+  // Max number of Selectors per Rule should be low
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const o = {
+      id: "MaxSelectorsPerRule",
+      score: 0,
+      value: e.rules.selectors.max,
+      actuals: e.rules.selectors.items
+    };
+    if (e.rules.selectors.max > 10) {
+      const t = Math.ceil((e.rules.selectors.max - 10) * 0.5);
+      o.score = Math.min(t, 15);
+    }
+    return o;
+  },
+  // Max number of Declarations per Rule should be low
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const o = {
+      id: "MaxDeclarationsPerRule",
+      score: 0,
+      value: e.rules.declarations.max,
+      actuals: e.rules.declarations.items
+    };
+    if (e.rules.declarations.max > 10) {
+      const t = Math.ceil((e.rules.declarations.max - 10) * 0.5);
+      o.score = Math.min(15, t);
+    }
+    return o;
+  },
+  // Number of Selectors per RuleSet should not differ too much from the most common amount of
+  // Selectors per RuleSet
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const s = e.rules.selectors.mode, o = e.rules.selectors.items.filter((c) => c > s).length, t = {
+      id: "MoreThanMostCommonSelectorsPerRule",
+      score: 0,
+      value: e.rules.selectors.mode,
+      actuals: e.rules.selectors.items
+    };
+    if (o > e.rules.total * 0.1) {
+      const c = Math.floor(o * 0.01);
+      t.score = Math.min(15, c);
+    }
+    return t;
+  },
+  // Number of Declarations per RuleSet should not differ too much from the most common amount of
+  // Declarations per RuleSet
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const s = e.rules.selectors.mode, o = e.rules.declarations.items.filter((c) => c > s).length, t = {
+      id: "MoreThanMostCommonDeclarationsPerRule",
+      score: 0,
+      value: e.rules.declarations.mode,
+      actuals: e.rules.declarations.items
+    };
+    if (o > e.rules.total * 0.1) {
+      const c = Math.floor(o * 0.01);
+      t.score = Math.min(15, c);
+    }
+    return t;
+  }
+], E = [
+  // Complexity per Selector should not differ too much from the most common Complexity
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const s = e.selectors.complexity.mode, o = e.selectors.complexity.items.filter((c) => c > s).length, t = {
+      id: "MoreThanMostCommonSelectorComplexity",
+      score: 0,
+      value: e.selectors.total === 0 ? 0 : o / e.selectors.total,
+      actuals: e.selectors.complexity.items
+    };
+    if (o > e.selectors.total * 0.1) {
+      const c = Math.floor(o * 0.01);
+      t.score = Math.min(10, c);
+    }
+    return t;
+  },
+  // Specificity per Selector should not differ too much from the most common Specificity
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const s = e.selectors.specificity.mode, o = e.selectors.specificity.items.filter((c) => i(c, s) < 0).length, t = {
+      id: "MoreThanMostCommonSelectorSpecificity",
+      score: 0,
+      value: e.selectors.total === 0 ? 0 : o / e.selectors.total,
+      actuals: e.selectors.specificity.items
+    };
+    if (o > e.selectors.total * 0.1) {
+      const c = Math.floor(o * 0.01);
+      t.score = Math.min(10, c);
+    }
+    return t;
+  },
+  // Maximum Selector Complexity should be low
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const o = e.selectors.complexity.max, t = {
+      id: "MaxSelectorComplexity",
+      score: 0,
+      value: e.selectors.complexity.max,
+      actuals: e.selectors.complexity.items
+    };
+    if (o > 5) {
+      const c = Math.ceil((o - 5) * 0.5);
+      t.score = Math.min(5, c);
+    }
+    return t;
+  },
+  // Average Selector Complexity should be low
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const o = e.selectors.complexity.mean, t = {
+      id: "AverageSelectorComplexity",
+      score: 0,
+      value: o,
+      actuals: e.selectors.complexity.items
+    };
+    if (o > 2) {
+      const c = Math.ceil((o - 2) * 2);
+      t.score = Math.min(10, c);
+    }
+    return t;
+  },
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const o = e.selectors.id.ratio, t = {
+      id: "IdSelectorRatio",
+      score: 0,
+      value: o,
+      actuals: Object.keys(e.selectors.id.unique)
+    };
+    if (o > 0.01) {
+      const c = Math.floor((o - 0.01) * 10);
+      t.score = Math.min(c, 5);
+    }
+    return t;
+  },
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
+  (e) => {
+    const o = e.declarations.importants.ratio, t = {
+      id: "ImportantRatio",
+      score: 0,
+      value: o,
+      actuals: e.declarations.importants.total
+    };
+    if (o > 0.01) {
+      const c = Math.floor((o - 0.01) * 10);
+      t.score = Math.min(c, 5);
+    }
+    return t;
+  }
+];
+function r(e, s) {
+  let o = 100, t = [], c = [];
+  for (const n of s) {
+    const a = n(e);
+    a.score > 0 ? (o -= a.score, t.push(a)) : c.push(a);
+  }
+  return {
+    score: Math.max(o, 0),
+    violations: t,
+    passes: c
+  };
+}
+function d(e) {
+  const s = r(e, m), o = r(e, u), t = r(e, E);
+  return {
+    /** @deprecated */
+    score: 0,
+    violations: s.violations.concat(o.violations).concat(t.violations),
+    passes: s.passes.concat(o.passes).concat(t.passes),
+    performance: s,
+    maintainability: o,
+    complexity: t
+  };
+}
+function M(e) {
+  const s = l(e);
+  return d(s);
+}
+export {
+  M as calculate
+};

package/dist/css-code-quality.umd.cjs

@@ -0,0 +1 @@
+(function(a,r){typeof exports=="object"&&typeof module<"u"?r(exports,require("@projectwallace/css-analyzer")):typeof define=="function"&&define.amd?define(["exports","@projectwallace/css-analyzer"],r):(a=typeof globalThis<"u"?globalThis:a||self,r(a.cssCodeQuality={},a.cssAnalyzer))})(this,function(a,r){"use strict";const l=[e=>({id:"Imports",score:e.atrules.import.total*10,value:e.atrules.import.total,actuals:Object.keys(e.atrules.import.unique)}),e=>({id:"EmptyRules",score:e.rules.empty.total,value:e.rules.empty.total}),e=>{const s={id:"SelectorDuplications",score:0,value:1-e.selectors.uniquenessRatio};return e.selectors.uniquenessRatio<.66&&(s.score=Math.floor((1-e.selectors.uniquenessRatio)*10)),s},e=>{const s={id:"DeclarationDuplications",score:0,value:1-e.declarations.unique.ratio};return e.declarations.unique.ratio<.66&&(s.score=Math.floor((1-e.declarations.unique.ratio)*10)),s},e=>({id:"CssSize",score:e.stylesheet.size>2e5?5:0,value:e.stylesheet.size}),e=>{const{comments:s}=e.stylesheet;return{id:"TooMuchComments",score:Math.min(10,Math.floor(s.size/250)),value:s.size}},e=>{const{size:s}=e.stylesheet.embeddedContent;return{id:"TooMuchEmbeddedContent",score:Math.min(20,Math.floor(s.total/250)),value:s.total,actuals:Object.keys(e.stylesheet.embeddedContent.unique)}}],u=[e=>{const s={id:"SourceLinesOfCode",score:0,value:e.stylesheet.sourceLinesOfCode};if(e.stylesheet.sourceLinesOfCode>1e4){const o=Math.floor((e.stylesheet.sourceLinesOfCode-1e4)/1e3);s.score=Math.min(15,o)}return s},e=>{const o=e.rules.selectors.mean,t={id:"AverageSelectorsPerRule",score:0,value:o,actuals:e.rules.selectors.items};if(o>2){const c=Math.floor((o-2)*5);t.score=Math.min(15,c)}return t},e=>{const o={id:"AverageDeclarationsPerRule",score:0,value:e.rules.declarations.mean,actuals:e.rules.declarations.items};if(e.rules.declarations.mean>5){const t=Math.floor((e.rules.declarations.mean-5)*5);o.score=Math.min(15,t)}return o},e=>{const o={id:"MaxSelectorsPerRule",score:0,value:e.rules.selectors.max,actuals:e.rules.selectors.items};if(e.rules.selectors.max>10){const t=Math.ceil((e.rules.selectors.max-10)*.5);o.score=Math.min(t,15)}return o},e=>{const o={id:"MaxDeclarationsPerRule",score:0,value:e.rules.declarations.max,actuals:e.rules.declarations.items};if(e.rules.declarations.max>10){const t=Math.ceil((e.rules.declarations.max-10)*.5);o.score=Math.min(15,t)}return o},e=>{const s=e.rules.selectors.mode,o=e.rules.selectors.items.filter(c=>c>s).length,t={id:"MoreThanMostCommonSelectorsPerRule",score:0,value:e.rules.selectors.mode,actuals:e.rules.selectors.items};if(o>e.rules.total*.1){const c=Math.floor(o*.01);t.score=Math.min(15,c)}return t},e=>{const s=e.rules.selectors.mode,o=e.rules.declarations.items.filter(c=>c>s).length,t={id:"MoreThanMostCommonDeclarationsPerRule",score:0,value:e.rules.declarations.mode,actuals:e.rules.declarations.items};if(o>e.rules.total*.1){const c=Math.floor(o*.01);t.score=Math.min(15,c)}return t}],m=[e=>{const s=e.selectors.complexity.mode,o=e.selectors.complexity.items.filter(c=>c>s).length,t={id:"MoreThanMostCommonSelectorComplexity",score:0,value:e.selectors.total===0?0:o/e.selectors.total,actuals:e.selectors.complexity.items};if(o>e.selectors.total*.1){const c=Math.floor(o*.01);t.score=Math.min(10,c)}return t},e=>{const s=e.selectors.specificity.mode,o=e.selectors.specificity.items.filter(c=>r.compareSpecificity(c,s)<0).length,t={id:"MoreThanMostCommonSelectorSpecificity",score:0,value:e.selectors.total===0?0:o/e.selectors.total,actuals:e.selectors.specificity.items};if(o>e.selectors.total*.1){const c=Math.floor(o*.01);t.score=Math.min(10,c)}return t},e=>{const o=e.selectors.complexity.max,t={id:"MaxSelectorComplexity",score:0,value:e.selectors.complexity.max,actuals:e.selectors.complexity.items};if(o>5){const c=Math.ceil((o-5)*.5);t.score=Math.min(5,c)}return t},e=>{const o=e.selectors.complexity.mean,t={id:"AverageSelectorComplexity",score:0,value:o,actuals:e.selectors.complexity.items};if(o>2){const c=Math.ceil((o-2)*2);t.score=Math.min(10,c)}return t},e=>{const o=e.selectors.id.ratio,t={id:"IdSelectorRatio",score:0,value:o,actuals:Object.keys(e.selectors.id.unique)};if(o>.01){const c=Math.floor((o-.01)*10);t.score=Math.min(c,5)}return t},e=>{const o=e.declarations.importants.ratio,t={id:"ImportantRatio",score:0,value:o,actuals:e.declarations.importants.total};if(o>.01){const c=Math.floor((o-.01)*10);t.score=Math.min(c,5)}return t}];function i(e,s){let o=100,t=[],c=[];for(const M of s){const n=M(e);n.score>0?(o-=n.score,t.push(n)):c.push(n)}return{score:Math.max(o,0),violations:t,passes:c}}function E(e){const s=i(e,l),o=i(e,u),t=i(e,m);return{score:0,violations:s.violations.concat(o.violations).concat(t.violations),passes:s.passes.concat(o.passes).concat(t.passes),performance:s,maintainability:o,complexity:t}}function d(e){const s=r.analyze(e);return E(s)}a.calculate=d,Object.defineProperty(a,Symbol.toStringTag,{value:"Module"})});

package/dist/index.d.ts

@@ -1,53 +1,55 @@
-/** @param {string} css */
-export function calculate(css: string): {
-    score: number;
-    violations: {
-        score: number;
-        value: number;
-        id: string;
-    }[];
-    passes: {
-        score: number;
-        value: number;
-        id: string;
-    }[];
-    performance: {
-        score: number;
-        violations: {
-            score: number;
-            value: number;
-            id: string;
-        }[];
-        passes: {
-            score: number;
-            value: number;
-            id: string;
-        }[];
-    };
-    maintainability: {
-        score: number;
-        violations: {
-            score: number;
-            value: number;
-            id: string;
-        }[];
-        passes: {
-            score: number;
-            value: number;
-            id: string;
-        }[];
-    };
-    complexity: {
-        score: number;
-        violations: {
-            score: number;
-            value: number;
-            id: string;
-        }[];
-        passes: {
-            score: number;
-            value: number;
-            id: string;
-        }[];
-    };
-};
+/**
+ * @param {string} css
+ */
+export function calculate(css: string): {
+    score: number;
+    violations: {
+        id: string;
+        score: number;
+        value: number;
+    }[];
+    passes: {
+        id: string;
+        score: number;
+        value: number;
+    }[];
+    performance: {
+        score: number;
+        violations: {
+            id: string;
+            score: number;
+            value: number;
+        }[];
+        passes: {
+            id: string;
+            score: number;
+            value: number;
+        }[];
+    };
+    maintainability: {
+        score: number;
+        violations: {
+            id: string;
+            score: number;
+            value: number;
+        }[];
+        passes: {
+            id: string;
+            score: number;
+            value: number;
+        }[];
+    };
+    complexity: {
+        score: number;
+        violations: {
+            id: string;
+            score: number;
+            value: number;
+        }[];
+        passes: {
+            id: string;
+            score: number;
+            value: number;
+        }[];
+    };
+};

package/package.json

@@ -1,8 +1,14 @@
 {
   "name": "@projectwallace/css-code-quality",
   "description": "Calculate the Code Quality score of your CSS based on a range of different quality guards",
-  "version": "1.0.1",
-  "repository": "git@github.com:projectwallace/css-code-quality.git",
+  "version": "1.0.3",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:projectwallace/css-code-quality.git"
+  },
+  "homepage": "https://github.com/projectwallace/css-code-quality",
+  "issues": "https://github.com/projectwallace/css-code-quality/issues",
+  "license": "MIT",
   "author": {
     "email": "bart@projectwallace.com",
     "name": "Bart Veneman"
@@ -14,39 +20,43 @@
     "quality",
     "complexity",
     "performance",
-    "maintainability"
+    "maintainability",
+    "score"
   ],
   "files": [
     "dist",
-    "src"
+    "src",
+    "!src/**/*.test.js"
   ],
   "type": "module",
   "source": "src/index.js",
-  "main": "./dist/css-code-quality.cjs",
-  "module": "./dist/css-code-quality.module.js",
-  "unpkg": "./dist/css-code-quality.umd.js",
+  "main": "./dist/css-code-quality.umd.cjs",
+  "module": "./dist/css-code-quality.js",
+  "unpkg": "./dist/css-code-quality.umd.cjs",
   "exports": {
     ".": {
-      "import": "./dist/css-code-quality.modern.js",
-      "require": "./dist/css-code-quality.cjs",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/css-code-quality.js",
+      "require": "./dist/css-code-quality.umd.cjs"
     },
     "./core": {
+      "types": "./dist/core.d.ts",
       "import": "./src/core.js"
     }
   },
   "types": "./dist/index.d.ts",
   "scripts": {
     "test": "uvu",
-    "lint": "oxlint",
-    "build": "microbundle"
+    "build": "vite build",
+    "check": "tsc --noEmit"
   },
   "dependencies": {
     "@projectwallace/css-analyzer": "^5.14.0"
   },
   "devDependencies": {
-    "microbundle": "^0.15.1",
-    "oxlint": "^0.2.13",
-    "uvu": "^0.5.6"
+    "typescript": "^5.4.5",
+    "uvu": "^0.5.6",
+    "vite": "^5.2.12",
+    "vite-plugin-dts": "^3.9.1"
   }
 }

package/src/complexity.js

@@ -3,6 +3,7 @@ import { compareSpecificity } from '@projectwallace/css-analyzer'
 export const guards = [
 
   // Complexity per Selector should not differ too much from the most common Complexity
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
   result => {
     const mode = result.selectors.complexity.mode
     const selectorsAboveMode = result.selectors.complexity.items
@@ -25,6 +26,7 @@ export const guards = [
   },
 
   // Specificity per Selector should not differ too much from the most common Specificity
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
   result => {
     const mode = result.selectors.specificity.mode
     const selectorsAboveMode = result.selectors.specificity.items
@@ -47,6 +49,7 @@ export const guards = [
   },
 
   // Maximum Selector Complexity should be low
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
   result => {
     const MAX_SELECTOR_COMPLEXITY = 5
     const actual = result.selectors.complexity.max
@@ -68,6 +71,7 @@ export const guards = [
   },
 
   // Average Selector Complexity should be low
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
   result => {
     const ALLOWED_COMPLEXITY = 2
     const actual = result.selectors.complexity.mean
@@ -88,6 +92,7 @@ export const guards = [
     return outcome
   },
 
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
   result => {
     const ALLOWED = 0.01
     const actual = result.selectors.id.ratio
@@ -106,6 +111,7 @@ export const guards = [
     return outcome
   },
 
+  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
   result => {
     const ALLOWED = 0.01
     const actual = result.declarations.importants.ratio

package/src/core.js

@@ -2,13 +2,16 @@ import { guards as performanceGuards } from './performance.js'
 import { guards as maintainabilityGuards } from './maintainability.js'
 import { guards as complexityGuards } from './complexity.js'
 
-function calculateScore({ result, guards }) {
+/**
+ * @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result
+ * @param {performanceGuards | maintainabilityGuards | complexityGuards} guards
+ */
+function calculateScore(result, guards) {
 	let score = 100
 	let violations = []
 	let passes = []
 
 	for (const guard of guards) {
-		/** @type {{score: number, value: number, id: string}} */
 		const outcome = guard(result)
 
 		if (outcome.score > 0) {
@@ -26,11 +29,13 @@ function calculateScore({ result, guards }) {
 	}
 }
 
-/** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} analysis */
+/**
+ * @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} analysis
+ */
 export function calculate(analysis) {
-	const performance = calculateScore({ result: analysis, guards: performanceGuards })
-	const maintainability = calculateScore({ result: analysis, guards: maintainabilityGuards })
-	const complexity = calculateScore({ result: analysis, guards: complexityGuards })
+	const performance = calculateScore(analysis, performanceGuards)
+	const maintainability = calculateScore(analysis, maintainabilityGuards)
+	const complexity = calculateScore(analysis, complexityGuards)
 
 	return {
 		/** @deprecated */

package/src/index.js

@@ -1,7 +1,9 @@
 import { analyze } from '@projectwallace/css-analyzer'
 import { calculate as calculateFromAnalysis } from './core.js'
 
-/** @param {string} css */
+/**
+ * @param {string} css
+ */
 export function calculate(css) {
 	const analysis = analyze(css)
 	return calculateFromAnalysis(analysis)