@projectwallace/css-code-quality 3.1.0 → 3.1.1

package/dist/core-C_C2rXxI.js

@@ -0,0 +1,286 @@
+import { compareSpecificity } from "@projectwallace/css-analyzer";
+//#region src/performance.ts
+const guards$2 = [
+	(result) => ({
+		id: "Imports",
+		score: result.atrules.import.total * 10,
+		value: result.atrules.import.total,
+		actuals: Object.keys(result.atrules.import.unique)
+	}),
+	(result) => ({
+		id: "EmptyRules",
+		score: result.rules.empty.total,
+		value: result.rules.empty.total
+	}),
+	(result) => {
+		const outcome = {
+			id: "SelectorDuplications",
+			score: 0,
+			value: 1 - result.selectors.uniquenessRatio
+		};
+		if (result.selectors.uniquenessRatio < .66) outcome.score = Math.floor((1 - result.selectors.uniquenessRatio) * 10);
+		return outcome;
+	},
+	(result) => {
+		const outcome = {
+			id: "DeclarationDuplications",
+			score: 0,
+			value: 1 - result.declarations.uniquenessRatio
+		};
+		if (result.declarations.uniquenessRatio < .66) outcome.score = Math.floor((1 - result.declarations.uniquenessRatio) * 10);
+		return outcome;
+	},
+	(result) => ({
+		id: "CssSize",
+		score: result.stylesheet.size > 2e5 ? 5 : 0,
+		value: result.stylesheet.size
+	}),
+	(result) => {
+		const { comments } = result.stylesheet;
+		return {
+			id: "TooMuchComments",
+			score: Math.min(10, Math.floor(comments.size / 250)),
+			value: comments.size
+		};
+	},
+	(result) => {
+		const { size } = result.stylesheet.embeddedContent;
+		return {
+			id: "TooMuchEmbeddedContent",
+			score: Math.min(20, Math.floor(size.total / 250)),
+			value: size.total
+		};
+	}
+];
+//#endregion
+//#region src/maintainability.ts
+const guards$1 = [
+	(result) => {
+		const outcome = {
+			id: "SourceLinesOfCode",
+			score: 0,
+			value: result.stylesheet.sourceLinesOfCode
+		};
+		if (result.stylesheet.sourceLinesOfCode > 1e4) {
+			const score = Math.floor((result.stylesheet.sourceLinesOfCode - 1e4) / 1e3);
+			outcome.score = Math.min(15, score);
+		}
+		return outcome;
+	},
+	(result) => {
+		const ALLOWED_SELECTORS_PER_RULESET = 2;
+		const actual = result.rules.selectors.mean;
+		const outcome = {
+			id: "AverageSelectorsPerRule",
+			score: 0,
+			value: actual,
+			actuals: result.rules.selectors.items
+		};
+		if (actual > ALLOWED_SELECTORS_PER_RULESET) {
+			const score = Math.floor((actual - ALLOWED_SELECTORS_PER_RULESET) * 5);
+			outcome.score = Math.min(15, score);
+		}
+		return outcome;
+	},
+	(result) => {
+		const ALLOWED_DECLARATIONS_PER_RULESET = 5;
+		const outcome = {
+			id: "AverageDeclarationsPerRule",
+			score: 0,
+			value: result.rules.declarations.mean,
+			actuals: result.rules.declarations.items
+		};
+		if (result.rules.declarations.mean > ALLOWED_DECLARATIONS_PER_RULESET) {
+			const score = Math.floor((result.rules.declarations.mean - ALLOWED_DECLARATIONS_PER_RULESET) * 5);
+			outcome.score = Math.min(15, score);
+		}
+		return outcome;
+	},
+	(result) => {
+		const MAX_SELECTORS_PER_RULESET = 10;
+		const max = result.rules.selectors.max;
+		const outcome = {
+			id: "MaxSelectorsPerRule",
+			score: 0,
+			value: max,
+			actuals: result.rules.selectors.items
+		};
+		if (max > MAX_SELECTORS_PER_RULESET) {
+			const score = Math.ceil((max - MAX_SELECTORS_PER_RULESET) * .5);
+			outcome.score = Math.min(score, 15);
+		}
+		return outcome;
+	},
+	(result) => {
+		const MAX_DECLARATIONS_PER_RULESET = 10;
+		const max = result.rules.declarations.max || 0;
+		const outcome = {
+			id: "MaxDeclarationsPerRule",
+			score: 0,
+			value: max,
+			actuals: result.rules.declarations.items
+		};
+		if (max > MAX_DECLARATIONS_PER_RULESET) {
+			const score = Math.ceil((max - MAX_DECLARATIONS_PER_RULESET) * .5);
+			outcome.score = Math.min(15, score);
+		}
+		return outcome;
+	},
+	(result) => {
+		const mode = result.rules.selectors.mode;
+		const rulesHavingMoreThanMode = result.rules.selectors.items.filter((item) => item > mode).length;
+		const outcome = {
+			id: "MoreThanMostCommonSelectorsPerRule",
+			score: 0,
+			value: result.rules.selectors.mode,
+			actuals: result.rules.selectors.items
+		};
+		if (rulesHavingMoreThanMode > result.rules.total * .1) {
+			const score = Math.floor(rulesHavingMoreThanMode * .01);
+			outcome.score = Math.min(15, score);
+		}
+		return outcome;
+	},
+	(result) => {
+		const mode = result.rules.selectors.mode;
+		const rulesHavingMoreThanMode = result.rules.declarations.items.filter((item) => item > mode).length;
+		const outcome = {
+			id: "MoreThanMostCommonDeclarationsPerRule",
+			score: 0,
+			value: result.rules.declarations.mode,
+			actuals: result.rules.declarations.items
+		};
+		if (rulesHavingMoreThanMode > result.rules.total * .1) {
+			const score = Math.floor(rulesHavingMoreThanMode * .01);
+			outcome.score = Math.min(15, score);
+		}
+		return outcome;
+	}
+];
+//#endregion
+//#region src/complexity.ts
+const guards = [
+	(result) => {
+		const mode = result.selectors.complexity.mode;
+		const selectorsAboveMode = result.selectors.complexity.items.filter((c) => c > mode).length;
+		const outcome = {
+			id: "MoreThanMostCommonSelectorComplexity",
+			score: 0,
+			value: result.selectors.total === 0 ? 0 : selectorsAboveMode / result.selectors.total,
+			actuals: result.selectors.complexity.items
+		};
+		if (selectorsAboveMode > result.selectors.total * .1) {
+			const score = Math.floor(selectorsAboveMode * .01);
+			outcome.score = Math.min(10, score);
+		}
+		return outcome;
+	},
+	(result) => {
+		const mode = result.selectors.specificity.mode;
+		const selectorsAboveMode = result.selectors.specificity.items.filter((c) => compareSpecificity(c, mode) < 0).length;
+		const outcome = {
+			id: "MoreThanMostCommonSelectorSpecificity",
+			score: 0,
+			value: result.selectors.total === 0 ? 0 : selectorsAboveMode / result.selectors.total,
+			actuals: result.selectors.specificity.items
+		};
+		if (selectorsAboveMode > result.selectors.total * .1) {
+			const score = Math.floor(selectorsAboveMode * .01);
+			outcome.score = Math.min(10, score);
+		}
+		return outcome;
+	},
+	(result) => {
+		const MAX_SELECTOR_COMPLEXITY = 5;
+		const actual = result.selectors.complexity.max;
+		const outcome = {
+			id: "MaxSelectorComplexity",
+			score: 0,
+			value: result.selectors.complexity.max,
+			actuals: result.selectors.complexity.items
+		};
+		if (actual > MAX_SELECTOR_COMPLEXITY) {
+			const score = Math.ceil((actual - MAX_SELECTOR_COMPLEXITY) * .5);
+			outcome.score = Math.min(5, score);
+		}
+		return outcome;
+	},
+	(result) => {
+		const ALLOWED_COMPLEXITY = 2;
+		const actual = result.selectors.complexity.mean;
+		const outcome = {
+			id: "AverageSelectorComplexity",
+			score: 0,
+			value: actual,
+			actuals: result.selectors.complexity.items
+		};
+		if (actual > ALLOWED_COMPLEXITY) {
+			const score = Math.ceil((actual - ALLOWED_COMPLEXITY) * 2);
+			outcome.score = Math.min(10, score);
+		}
+		return outcome;
+	},
+	(result) => {
+		const ALLOWED = .01;
+		const actual = result.selectors.id.ratio;
+		const outcome = {
+			id: "IdSelectorRatio",
+			score: 0,
+			value: actual,
+			actuals: Object.keys(result.selectors.id.unique)
+		};
+		if (actual > ALLOWED) {
+			const score = Math.floor((actual - ALLOWED) * 10);
+			outcome.score = Math.min(score, 5);
+		}
+		return outcome;
+	},
+	(result) => {
+		const ALLOWED = .01;
+		const actual = result.declarations.importants.ratio;
+		const outcome = {
+			id: "ImportantRatio",
+			score: 0,
+			value: actual,
+			actuals: result.declarations.importants.total
+		};
+		if (actual > ALLOWED) {
+			const score = Math.floor((actual - ALLOWED) * 10);
+			outcome.score = Math.min(score, 5);
+		}
+		return outcome;
+	}
+];
+//#endregion
+//#region src/core.ts
+function calculateScore(result, guards) {
+	let score = 100;
+	const violations = [];
+	const passes = [];
+	for (const guard of guards) {
+		const outcome = guard(result);
+		if (outcome.score > 0) {
+			score -= outcome.score;
+			violations.push(outcome);
+		} else passes.push(outcome);
+	}
+	return {
+		score: Math.max(score, 0),
+		violations,
+		passes
+	};
+}
+function calculate(analysis) {
+	const performance = calculateScore(analysis, guards$2);
+	const maintainability = calculateScore(analysis, guards$1);
+	const complexity = calculateScore(analysis, guards);
+	return {
+		violations: performance.violations.concat(maintainability.violations).concat(complexity.violations),
+		passes: performance.passes.concat(maintainability.passes).concat(complexity.passes),
+		performance,
+		maintainability,
+		complexity
+	};
+}
+//#endregion
+export { calculate as t };

package/dist/core.d.ts

@@ -1,92 +1,24 @@
-/** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} analysis */
-export function calculate(analysis: ReturnType<typeof import('@projectwallace/css-analyzer').analyze>): {
-    violations: ({
-        id: string;
-        score: number;
-        value: any;
-        actuals: string[];
-    } | {
-        id: string;
-        score: number;
-        value: number;
-    })[];
-    passes: ({
-        id: string;
-        score: number;
-        value: any;
-        actuals: string[];
-    } | {
-        id: string;
-        score: number;
-        value: number;
-    })[];
-    performance: {
-        score: number;
-        violations: ({
-            id: string;
-            score: number;
-            value: any;
-            actuals: string[];
-        } | {
-            id: string;
-            score: number;
-            value: number;
-        })[];
-        passes: ({
-            id: string;
-            score: number;
-            value: any;
-            actuals: string[];
-        } | {
-            id: string;
-            score: number;
-            value: number;
-        })[];
-    };
-    maintainability: {
-        score: number;
-        violations: ({
-            id: string;
-            score: number;
-            value: any;
-            actuals: string[];
-        } | {
-            id: string;
-            score: number;
-            value: number;
-        })[];
-        passes: ({
-            id: string;
-            score: number;
-            value: any;
-            actuals: string[];
-        } | {
-            id: string;
-            score: number;
-            value: number;
-        })[];
-    };
-    complexity: {
-        score: number;
-        violations: ({
-            id: string;
-            score: number;
-            value: any;
-            actuals: string[];
-        } | {
-            id: string;
-            score: number;
-            value: number;
-        })[];
-        passes: ({
-            id: string;
-            score: number;
-            value: any;
-            actuals: string[];
-        } | {
-            id: string;
-            score: number;
-            value: number;
-        })[];
-    };
+import { n as GuardResult, t as Analysis } from "./types-DuxX7Pm1.js";
+
+//#region src/core.d.ts
+declare function calculate(analysis: Analysis): {
+  violations: GuardResult[];
+  passes: GuardResult[];
+  performance: {
+    score: number;
+    violations: GuardResult[];
+    passes: GuardResult[];
+  };
+  maintainability: {
+    score: number;
+    violations: GuardResult[];
+    passes: GuardResult[];
+  };
+  complexity: {
+    score: number;
+    violations: GuardResult[];
+    passes: GuardResult[];
+  };
 };
+//#endregion
+export { calculate };

package/dist/core.js

@@ -1,289 +1,2 @@
-import { compareSpecificity as i } from "@projectwallace/css-analyzer";
-const l = [
-  // 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.uniquenessRatio
-    };
-    return e.declarations.uniquenessRatio < 0.66 && (s.score = Math.floor((1 - e.declarations.uniquenessRatio) * 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
-    };
-  }
-], m = [
-  // 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) => {
-    let o = e.rules.selectors.max || 0;
-    const t = {
-      id: "MaxSelectorsPerRule",
-      score: 0,
-      value: o,
-      actuals: e.rules.selectors.items
-    };
-    if (o > 10) {
-      const c = Math.ceil((o - 10) * 0.5);
-      t.score = Math.min(c, 15);
-    }
-    return t;
-  },
-  // Max number of Declarations per Rule should be low
-  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
-  (e) => {
-    const o = e.rules.declarations.max || 0, t = {
-      id: "MaxDeclarationsPerRule",
-      score: 0,
-      value: o,
-      actuals: e.rules.declarations.items
-    };
-    if (o > 10) {
-      const c = Math.ceil((o - 10) * 0.5);
-      t.score = Math.min(15, c);
-    }
-    return t;
-  },
-  // 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;
-  }
-], u = [
-  // 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, t = e.selectors.specificity.items.filter((a) => i(a, s) < 0).length, c = {
-      id: "MoreThanMostCommonSelectorSpecificity",
-      score: 0,
-      value: e.selectors.total === 0 ? 0 : t / e.selectors.total,
-      actuals: e.selectors.specificity.items
-    };
-    if (t > e.selectors.total * 0.1) {
-      const a = Math.floor(t * 0.01);
-      c.score = Math.min(10, a);
-    }
-    return c;
-  },
-  // Maximum Selector Complexity should be low
-  /** @param {ReturnType<import('@projectwallace/css-analyzer').analyze>} result */
-  (e) => {
-    const o = e.selectors.complexity.max || 0, 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 n(e, s) {
-  let o = 100, t = [], c = [];
-  for (const a of s) {
-    const r = a(e);
-    r.score > 0 ? (o -= r.score, t.push(r)) : c.push(r);
-  }
-  return {
-    score: Math.max(o, 0),
-    violations: t,
-    passes: c
-  };
-}
-function L(e) {
-  const s = n(e, l), o = n(e, m), t = n(e, u);
-  return {
-    violations: s.violations.concat(o.violations).concat(t.violations),
-    passes: s.passes.concat(o.passes).concat(t.passes),
-    performance: s,
-    maintainability: o,
-    complexity: t
-  };
-}
-export {
-  L as calculate
-};
+import { t as calculate } from "./core-C_C2rXxI.js";
+export { calculate };

package/dist/index.d.ts

@@ -1,94 +1,24 @@
-/**
- * @param {string} css
- */
-export function calculate(css: string): {
-    violations: ({
-        id: string;
-        score: number;
-        value: any;
-        actuals: string[];
-    } | {
-        id: string;
-        score: number;
-        value: number;
-    })[];
-    passes: ({
-        id: string;
-        score: number;
-        value: any;
-        actuals: string[];
-    } | {
-        id: string;
-        score: number;
-        value: number;
-    })[];
-    performance: {
-        score: number;
-        violations: ({
-            id: string;
-            score: number;
-            value: any;
-            actuals: string[];
-        } | {
-            id: string;
-            score: number;
-            value: number;
-        })[];
-        passes: ({
-            id: string;
-            score: number;
-            value: any;
-            actuals: string[];
-        } | {
-            id: string;
-            score: number;
-            value: number;
-        })[];
-    };
-    maintainability: {
-        score: number;
-        violations: ({
-            id: string;
-            score: number;
-            value: any;
-            actuals: string[];
-        } | {
-            id: string;
-            score: number;
-            value: number;
-        })[];
-        passes: ({
-            id: string;
-            score: number;
-            value: any;
-            actuals: string[];
-        } | {
-            id: string;
-            score: number;
-            value: number;
-        })[];
-    };
-    complexity: {
-        score: number;
-        violations: ({
-            id: string;
-            score: number;
-            value: any;
-            actuals: string[];
-        } | {
-            id: string;
-            score: number;
-            value: number;
-        })[];
-        passes: ({
-            id: string;
-            score: number;
-            value: any;
-            actuals: string[];
-        } | {
-            id: string;
-            score: number;
-            value: number;
-        })[];
-    };
+import { n as GuardResult } from "./types-DuxX7Pm1.js";
+
+//#region src/index.d.ts
+declare function calculate(css: string): {
+  violations: GuardResult[];
+  passes: GuardResult[];
+  performance: {
+    score: number;
+    violations: GuardResult[];
+    passes: GuardResult[];
+  };
+  maintainability: {
+    score: number;
+    violations: GuardResult[];
+    passes: GuardResult[];
+  };
+  complexity: {
+    score: number;
+    violations: GuardResult[];
+    passes: GuardResult[];
+  };
 };
+//#endregion
+export { calculate };

package/dist/index.js

@@ -1,9 +1,8 @@
-import { analyze as c } from "@projectwallace/css-analyzer";
-import { calculate as l } from "./core.js";
-function e(a) {
-  const t = c(a);
-  return l(t);
+import { t as calculate$1 } from "./core-C_C2rXxI.js";
+import { analyze } from "@projectwallace/css-analyzer";
+//#region src/index.ts
+function calculate(css) {
+	return calculate$1(analyze(css));
 }
-export {
-  e as calculate
-};
+//#endregion
+export { calculate };

package/dist/types-DuxX7Pm1.d.ts

@@ -0,0 +1,12 @@
+import { analyze } from "@projectwallace/css-analyzer";
+
+//#region src/types.d.ts
+type Analysis = ReturnType<typeof analyze>;
+type GuardResult = {
+  id: string;
+  score: number;
+  value: number;
+  actuals?: unknown;
+};
+//#endregion
+export { GuardResult as n, Analysis as t };

package/package.json

@@ -1,59 +1,63 @@
 {
-  "name": "@projectwallace/css-code-quality",
-  "description": "Calculate the Code Quality score of your CSS based on a range of different quality guards",
-  "version": "3.1.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://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"
-  },
-  "keywords": [
-    "css",
-    "codequality",
-    "codesniffer",
-    "quality",
-    "complexity",
-    "performance",
-    "maintainability",
-    "score"
-  ],
-  "engines": {
-    "node": ">=16.0.0"
-  },
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./core": {
-      "types": "./dist/core.d.ts",
-      "import": "./dist/core.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "test": "uvu",
-    "build": "vite build",
-    "check": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@projectwallace/css-analyzer": "^8.0.2"
-  },
-  "devDependencies": {
-    "typescript": "^5.9.3",
-    "uvu": "^0.5.6",
-    "vite": "^6.4.1",
-    "vite-plugin-dts": "^4.5.4"
-  }
+	"name": "@projectwallace/css-code-quality",
+	"version": "3.1.1",
+	"description": "Calculate the Code Quality score of your CSS based on a range of different quality guards",
+	"keywords": [
+		"codequality",
+		"codesniffer",
+		"complexity",
+		"css",
+		"maintainability",
+		"performance",
+		"quality",
+		"score"
+	],
+	"homepage": "https://github.com/projectwallace/css-code-quality",
+	"license": "MIT",
+	"author": {
+		"name": "Bart Veneman",
+		"email": "bart@projectwallace.com"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com:projectwallace/css-code-quality.git"
+	},
+	"files": [
+		"dist"
+	],
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./core": {
+			"types": "./dist/core.d.ts",
+			"import": "./dist/core.js"
+		}
+	},
+	"scripts": {
+		"test": "vitest run --coverage",
+		"build": "tsdown",
+		"check": "tsc --noEmit",
+		"lint": "oxlint && oxfmt --check"
+	},
+	"dependencies": {
+		"@projectwallace/css-analyzer": "^9.3.0"
+	},
+	"devDependencies": {
+		"@vitest/coverage-v8": "^4.0.18",
+		"oxfmt": "^0.36.0",
+		"oxlint": "^1.51.0",
+		"publint": "^0.3.18",
+		"tsdown": "^0.21.0",
+		"typescript": "^5.9.3",
+		"vitest": "^4.0.18"
+	},
+	"engines": {
+		"node": ">=16.0.0"
+	},
+	"issues": "https://github.com/projectwallace/css-code-quality/issues"
 }

package/readme.md

@@ -37,10 +37,10 @@ npm install @projectwallace/css-code-quality
 ## Usage
 
 ```js
-import { calculate } from "@projectwallace/css-code-quality";
+import { calculate } from '@projectwallace/css-code-quality'
 
-let css = `my_css { /* ... */ }`;
-let result = calculate(css);
+let css = `my_css { /* ... */ }`
+let result = calculate(css)
 
 /*
 The result shape looks something like this: