@muloka/figma-console-mcp 0.5.0 → 0.5.2

package/dist/cloudflare/apps/design-system-dashboard/scoring/naming-semantics.js

@@ -1,308 +0,0 @@
-/**
- * Naming & Semantics Scorer (weight: 0.20)
- *
- * Checks whether design system names describe intent rather than appearance.
- * Evaluates variable naming, component naming, variant naming, and boolean
- * naming conventions against semantic best practices.
- */
-import { buildCollectionNameMap, clamp, getSeverity } from "./types.js";
-/** Maximum examples to include in a finding. */
-const MAX_EXAMPLES = 5;
-/** Color words that indicate visual (non-semantic) naming. */
-const VISUAL_COLOR_WORDS = [
-    "red",
-    "blue",
-    "green",
-    "yellow",
-    "orange",
-    "purple",
-    "pink",
-    "black",
-    "white",
-    "gray",
-    "grey",
-    "cyan",
-    "magenta",
-    "teal",
-    "indigo",
-    "violet",
-    "brown",
-    "lime",
-    "amber",
-    "emerald",
-    "rose",
-    "sky",
-    "slate",
-    "zinc",
-    "stone",
-    "neutral",
-];
-/** Visual variant values that should be replaced with semantic ones. */
-const VISUAL_VARIANT_VALUES = [
-    "red",
-    "blue",
-    "green",
-    "yellow",
-    "orange",
-    "purple",
-    "pink",
-    "black",
-    "white",
-    "gray",
-    "grey",
-    "cyan",
-];
-/** Semantic variant values that indicate good naming. */
-const SEMANTIC_VARIANT_VALUES = [
-    "primary",
-    "secondary",
-    "tertiary",
-    "danger",
-    "warning",
-    "success",
-    "info",
-    "error",
-    "disabled",
-    "default",
-    "accent",
-    "muted",
-    "destructive",
-    "outline",
-    "ghost",
-    "link",
-];
-const PASCAL_CASE_RE = /^[A-Z][a-zA-Z0-9]*$/;
-const BOOLEAN_PREFIX_RE = /^(is|has|can|should|will|did|was|with|show|hide|enable|disable)/i;
-/**
- * Extract the leaf segment from a variable name.
- * e.g. "color/action/primary" -> "primary", "color.blue.500" -> "500"
- */
-function getLeafName(name) {
-    const parts = name.split(/[/.]/);
-    return parts[parts.length - 1];
-}
-/**
- * Check if a name contains visual color words in its leaf segments.
- */
-function containsVisualColorWord(name) {
-    const leaf = getLeafName(name).toLowerCase();
-    return VISUAL_COLOR_WORDS.some((word) => leaf === word || leaf.startsWith(`${word}-`));
-}
-/**
- * Score variable naming for semantic quality.
- * Variables should use semantic names (color.action.primary) rather than
- * visual names (color.blue.500).
- */
-function scoreVariableNaming(data) {
-    const colorVars = data.variables.filter((v) => v.resolvedType === "COLOR");
-    if (colorVars.length === 0) {
-        return {
-            id: "naming-variable-semantic",
-            label: "Variable naming",
-            score: 100,
-            severity: "info",
-            tooltip: "Variables should describe intent (e.g. color/action/primary) rather than appearance (e.g. color/blue/500). Semantic names survive theme changes.",
-            details: "No color variables to evaluate.",
-        };
-    }
-    const collectionNames = buildCollectionNameMap(data.collections);
-    const visualVars = colorVars.filter((v) => containsVisualColorWord(v.name));
-    const semanticRatio = 1 - visualVars.length / colorVars.length;
-    const score = clamp(semanticRatio * 100);
-    return {
-        id: "naming-variable-semantic",
-        label: "Variable naming",
-        score,
-        severity: getSeverity(score),
-        tooltip: "Variables should describe intent (e.g. color/action/primary) rather than appearance (e.g. color/blue/500). Semantic names survive theme changes.",
-        details: visualVars.length > 0
-            ? `${visualVars.length} of ${colorVars.length} color variables use visual names instead of semantic names.`
-            : `All ${colorVars.length} color variables use semantic names.`,
-        examples: visualVars.length > 0
-            ? visualVars.slice(0, MAX_EXAMPLES).map((v) => v.name)
-            : undefined,
-        locations: visualVars.length > 0
-            ? visualVars.slice(0, MAX_EXAMPLES).map((v) => ({
-                name: v.name,
-                collection: collectionNames.get(v.variableCollectionId),
-                type: "variable",
-            }))
-            : undefined,
-    };
-}
-/**
- * Score component naming for consistency.
- * Components should use PascalCase and avoid mixed abbreviations.
- */
-function scoreComponentNaming(data) {
-    const components = data.components;
-    if (components.length === 0) {
-        return {
-            id: "naming-component-casing",
-            label: "Component naming",
-            score: 100,
-            severity: "info",
-            tooltip: "Component names should use consistent PascalCase (e.g. Button, IconStar). Consistent casing improves discoverability.",
-            details: "No components to evaluate.",
-        };
-    }
-    let pascalCount = 0;
-    const nonPascalComps = [];
-    for (const comp of components) {
-        // Component names may use path separators; check each segment
-        const segments = comp.name.split("/").map((s) => s.trim());
-        const allPascal = segments.every((seg) => PASCAL_CASE_RE.test(seg));
-        if (allPascal) {
-            pascalCount++;
-        }
-        else {
-            nonPascalComps.push(comp.name);
-        }
-    }
-    const ratio = pascalCount / components.length;
-    const score = clamp(ratio * 100);
-    return {
-        id: "naming-component-casing",
-        label: "Component naming",
-        score,
-        severity: getSeverity(score),
-        tooltip: "Component names should use consistent PascalCase (e.g. Button, IconStar). Consistent casing improves discoverability.",
-        details: `${pascalCount} of ${components.length} components use consistent PascalCase naming.`,
-        examples: nonPascalComps.length > 0
-            ? nonPascalComps.slice(0, MAX_EXAMPLES)
-            : undefined,
-    };
-}
-/**
- * Score variant naming for semantic quality.
- * Variant values should be semantic (primary, danger) rather than
- * visual (blue, red). Also checks for consistent size naming.
- */
-function scoreVariantNaming(data) {
-    // Components with variants have a componentSetId (Plugin API),
-    // containing_frame.containingComponentSet (REST API), or component_set_id (file JSON)
-    const variantComponents = data.components.filter((c) => c.componentSetId ||
-        c.containing_frame?.containingComponentSet ||
-        c.component_set_id);
-    if (variantComponents.length === 0) {
-        return {
-            id: "naming-variant-semantic",
-            label: "Variant naming",
-            score: 100,
-            severity: "info",
-            tooltip: "Variant values should use semantic terms (primary, danger) rather than visual ones (red, blue). This decouples design from implementation.",
-            details: "No variant components to evaluate.",
-        };
-    }
-    // Extract variant info from component names (e.g., "Button/Primary" or "Size=Small, Color=Primary")
-    let semanticCount = 0;
-    let visualCount = 0;
-    const visualVariantComps = [];
-    for (const comp of variantComponents) {
-        const nameLower = comp.name.toLowerCase();
-        const hasVisual = VISUAL_VARIANT_VALUES.some((v) => nameLower === v ||
-            nameLower.includes(`=${v}`) ||
-            nameLower.includes(`, ${v}`));
-        const hasSemantic = SEMANTIC_VARIANT_VALUES.some((v) => nameLower === v ||
-            nameLower.includes(`=${v}`) ||
-            nameLower.includes(`, ${v}`));
-        if (hasSemantic)
-            semanticCount++;
-        if (hasVisual) {
-            visualCount++;
-            visualVariantComps.push(comp.name);
-        }
-    }
-    const totalEvaluated = semanticCount + visualCount;
-    if (totalEvaluated === 0) {
-        return {
-            id: "naming-variant-semantic",
-            label: "Variant naming",
-            score: 75,
-            severity: "warning",
-            tooltip: "Variant values should use semantic terms (primary, danger) rather than visual ones (red, blue). This decouples design from implementation.",
-            details: "Variant values could not be classified as semantic or visual.",
-        };
-    }
-    const ratio = semanticCount / totalEvaluated;
-    const score = clamp(ratio * 100);
-    return {
-        id: "naming-variant-semantic",
-        label: "Variant naming",
-        score,
-        severity: getSeverity(score),
-        tooltip: "Variant values should use semantic terms (primary, danger) rather than visual ones (red, blue). This decouples design from implementation.",
-        details: visualCount > 0
-            ? `${visualCount} variant values use visual names. Prefer semantic names like "primary", "danger".`
-            : "Variant values use semantic naming conventions.",
-        examples: visualVariantComps.length > 0
-            ? visualVariantComps.slice(0, MAX_EXAMPLES)
-            : undefined,
-    };
-}
-/**
- * Score boolean variable naming.
- * Boolean variables should follow is-, has-, can- prefix patterns.
- */
-function scoreBooleanNaming(data) {
-    const boolVars = data.variables.filter((v) => v.resolvedType === "BOOLEAN");
-    if (boolVars.length === 0) {
-        return {
-            id: "naming-boolean-prefix",
-            label: "Boolean naming",
-            score: 100,
-            severity: "info",
-            tooltip: "Boolean variables should start with is, has, can, show, or similar prefixes (e.g. isDisabled). This makes their purpose immediately clear.",
-            details: "No boolean variables to evaluate.",
-        };
-    }
-    const collectionNames = buildCollectionNameMap(data.collections);
-    const missingPrefix = boolVars.filter((v) => {
-        const leaf = getLeafName(v.name);
-        return !BOOLEAN_PREFIX_RE.test(leaf);
-    });
-    const correctCount = boolVars.length - missingPrefix.length;
-    const ratio = correctCount / boolVars.length;
-    const score = clamp(ratio * 100);
-    return {
-        id: "naming-boolean-prefix",
-        label: "Boolean naming",
-        score,
-        severity: getSeverity(score),
-        tooltip: "Boolean variables should start with is, has, can, show, or similar prefixes (e.g. isDisabled). This makes their purpose immediately clear.",
-        details: missingPrefix.length > 0
-            ? `${missingPrefix.length} of ${boolVars.length} boolean variables lack is*/has*/can* prefixes.`
-            : `All ${boolVars.length} boolean variables use proper prefixes.`,
-        examples: missingPrefix.length > 0
-            ? missingPrefix.slice(0, MAX_EXAMPLES).map((v) => v.name)
-            : undefined,
-        locations: missingPrefix.length > 0
-            ? missingPrefix.slice(0, MAX_EXAMPLES).map((v) => ({
-                name: v.name,
-                collection: collectionNames.get(v.variableCollectionId),
-                type: "variable",
-            }))
-            : undefined,
-    };
-}
-/**
- * Naming & Semantics category scorer.
- * Returns the average score across all naming checks.
- */
-export function scoreNamingSemantics(data) {
-    const findings = [
-        scoreVariableNaming(data),
-        scoreComponentNaming(data),
-        scoreVariantNaming(data),
-        scoreBooleanNaming(data),
-    ];
-    const score = clamp(findings.reduce((sum, f) => sum + f.score, 0) / findings.length);
-    return {
-        id: "naming-semantics",
-        label: "Naming & Semantics",
-        shortLabel: "Naming",
-        score,
-        weight: 0.2,
-        findings,
-    };
-}

package/dist/cloudflare/apps/design-system-dashboard/scoring/token-architecture.js

@@ -1,349 +0,0 @@
-/**
- * Token Architecture Scorer (weight: 0.20)
- *
- * Evaluates the depth and organization of the token system.
- * Checks collection organization, mode coverage, alias usage,
- * token tier depth, type distribution, and description coverage.
- */
-import { buildCollectionNameMap, clamp, getSeverity } from "./types.js";
-/** Maximum examples to include in a finding. */
-const MAX_EXAMPLES = 5;
-/**
- * Check if a value entry is a variable alias reference.
- */
-function isAlias(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        value.type === "VARIABLE_ALIAS");
-}
-/** Check if variable data was unavailable (vs. genuinely empty). */
-function variableDataUnavailable(data) {
-    return (data.dataAvailability !== undefined && !data.dataAvailability.variables);
-}
-/** Message explaining why variable data is missing. */
-function variableUnavailableMessage(data) {
-    const reason = data.dataAvailability?.variableError ||
-        "Figma Enterprise plan or Desktop Bridge plugin required";
-    return `Variable data unavailable: ${reason}. Score reflects missing data, not actual design system quality.`;
-}
-/**
- * Score collection organization.
- * Variables should be organized into collections.
- */
-function scoreCollectionOrganization(data) {
-    const count = data.collections.length;
-    if (count === 0 && variableDataUnavailable(data)) {
-        return {
-            id: "token-collection-org",
-            label: "Collection organization",
-            score: 0,
-            severity: "info",
-            tooltip: "Variables should be grouped into collections by concern (colors, spacing, typography). More collections = better organization.",
-            details: variableUnavailableMessage(data),
-        };
-    }
-    let score;
-    if (count >= 3) {
-        score = 100;
-    }
-    else if (count === 2) {
-        score = 80;
-    }
-    else if (count === 1) {
-        score = 50;
-    }
-    else {
-        score = 0;
-    }
-    return {
-        id: "token-collection-org",
-        label: "Collection organization",
-        score: clamp(score),
-        severity: getSeverity(score),
-        tooltip: "Variables should be grouped into collections by concern (colors, spacing, typography). More collections = better organization.",
-        details: count === 0
-            ? "No variable collections found. Organize variables into collections."
-            : `${count} collection${count === 1 ? "" : "s"} found.`,
-    };
-}
-/**
- * Score mode coverage.
- * Collections should have multiple modes (e.g., light/dark).
- */
-function scoreModeCoverage(data) {
-    if (data.collections.length === 0) {
-        return {
-            id: "token-mode-coverage",
-            label: "Mode coverage",
-            score: 0,
-            severity: variableDataUnavailable(data) ? "info" : "fail",
-            tooltip: "Collections should support multiple modes (e.g. Light/Dark). This enables theming without duplicating tokens.",
-            details: variableDataUnavailable(data)
-                ? variableUnavailableMessage(data)
-                : "No collections found to evaluate mode coverage.",
-        };
-    }
-    const maxModes = Math.max(...data.collections.map((c) => c.modes?.length ?? 0));
-    let score;
-    if (maxModes >= 2) {
-        score = 100;
-    }
-    else if (maxModes === 1) {
-        score = 50;
-    }
-    else {
-        score = 0;
-    }
-    return {
-        id: "token-mode-coverage",
-        label: "Mode coverage",
-        score: clamp(score),
-        severity: getSeverity(score),
-        tooltip: "Collections should support multiple modes (e.g. Light/Dark). This enables theming without duplicating tokens.",
-        details: maxModes >= 2
-            ? `Collections support up to ${maxModes} modes (e.g., light/dark).`
-            : maxModes === 1
-                ? "Collections have only 1 mode. Consider adding light/dark modes."
-                : "No modes detected in collections.",
-    };
-}
-/**
- * Score alias usage.
- * Higher alias percentage indicates better token layering.
- */
-function scoreAliasUsage(data) {
-    if (data.variables.length === 0) {
-        return {
-            id: "token-alias-usage",
-            label: "Alias usage",
-            score: 0,
-            severity: variableDataUnavailable(data) ? "info" : "fail",
-            tooltip: "Semantic tokens should reference primitive tokens via aliases rather than hard-coding values. Aliases enable single-source-of-truth updates.",
-            details: variableDataUnavailable(data)
-                ? variableUnavailableMessage(data)
-                : "No variables to evaluate alias usage.",
-        };
-    }
-    const collectionNames = buildCollectionNameMap(data.collections);
-    let aliasCount = 0;
-    let totalValues = 0;
-    const rawValueVars = [];
-    for (const variable of data.variables) {
-        if (!variable.valuesByMode)
-            continue;
-        let hasAnyAlias = false;
-        for (const modeValues of Object.values(variable.valuesByMode)) {
-            totalValues++;
-            if (isAlias(modeValues)) {
-                aliasCount++;
-                hasAnyAlias = true;
-            }
-        }
-        if (!hasAnyAlias) {
-            rawValueVars.push(variable);
-        }
-    }
-    if (totalValues === 0) {
-        return {
-            id: "token-alias-usage",
-            label: "Alias usage",
-            score: 0,
-            severity: "fail",
-            tooltip: "Semantic tokens should reference primitive tokens via aliases rather than hard-coding values. Aliases enable single-source-of-truth updates.",
-            details: "No variable values found to evaluate.",
-        };
-    }
-    const ratio = aliasCount / totalValues;
-    const score = clamp(ratio * 100);
-    return {
-        id: "token-alias-usage",
-        label: "Alias usage",
-        score,
-        severity: getSeverity(score),
-        tooltip: "Semantic tokens should reference primitive tokens via aliases rather than hard-coding values. Aliases enable single-source-of-truth updates.",
-        details: `${aliasCount} of ${totalValues} values are aliases (${Math.round(ratio * 100)}%). Higher alias usage indicates better token layering.`,
-        examples: rawValueVars.length > 0 ? rawValueVars.slice(0, MAX_EXAMPLES).map((v) => v.name) : undefined,
-        locations: rawValueVars.length > 0
-            ? rawValueVars.slice(0, MAX_EXAMPLES).map((v) => ({
-                name: v.name,
-                collection: collectionNames.get(v.variableCollectionId),
-                type: "variable",
-            }))
-            : undefined,
-    };
-}
-/**
- * Build a map of variable ID to variable for alias chain tracing.
- */
-function buildVariableMap(variables) {
-    const map = new Map();
-    for (const v of variables) {
-        if (v.id) {
-            map.set(v.id, v);
-        }
-    }
-    return map;
-}
-/**
- * Trace the depth of an alias chain starting from a given variable.
- * Returns the number of tiers (1 = raw value, 2 = one alias hop, etc.).
- */
-function traceAliasDepth(variable, variableMap, visited) {
-    if (!variable.valuesByMode)
-        return 1;
-    const values = Object.values(variable.valuesByMode);
-    let maxDepth = 1;
-    for (const value of values) {
-        if (isAlias(value)) {
-            const targetId = value.id;
-            if (visited.has(targetId))
-                continue; // Prevent circular references
-            const target = variableMap.get(targetId);
-            if (target) {
-                visited.add(targetId);
-                const depth = 1 + traceAliasDepth(target, variableMap, visited);
-                maxDepth = Math.max(maxDepth, depth);
-            }
-        }
-    }
-    return maxDepth;
-}
-/**
- * Score token tier depth.
- * Deeper alias chains indicate more sophisticated token architecture.
- */
-function scoreTokenTierDepth(data) {
-    if (data.variables.length === 0) {
-        return {
-            id: "token-tier-depth",
-            label: "Token tier depth",
-            score: 0,
-            severity: variableDataUnavailable(data) ? "info" : "fail",
-            tooltip: "A layered token system (primitive -> semantic -> component) enables scalable theming. 3+ tiers indicates mature architecture.",
-            details: variableDataUnavailable(data)
-                ? variableUnavailableMessage(data)
-                : "No variables to evaluate tier depth.",
-        };
-    }
-    const variableMap = buildVariableMap(data.variables);
-    let maxDepth = 1;
-    for (const variable of data.variables) {
-        const visited = new Set();
-        if (variable.id)
-            visited.add(variable.id);
-        const depth = traceAliasDepth(variable, variableMap, visited);
-        maxDepth = Math.max(maxDepth, depth);
-    }
-    let score;
-    if (maxDepth >= 3) {
-        score = 100;
-    }
-    else if (maxDepth === 2) {
-        score = 67;
-    }
-    else {
-        score = 33;
-    }
-    return {
-        id: "token-tier-depth",
-        label: "Token tier depth",
-        score: clamp(score),
-        severity: getSeverity(score),
-        tooltip: "A layered token system (primitive -> semantic -> component) enables scalable theming. 3+ tiers indicates mature architecture.",
-        details: `Maximum alias chain depth: ${maxDepth} tier${maxDepth === 1 ? "" : "s"}. 3+ tiers indicates a well-layered token architecture.`,
-    };
-}
-/**
- * Score type distribution across variables.
- * A healthy system includes COLOR, FLOAT, and STRING variables.
- */
-function scoreTypeDistribution(data) {
-    if (data.variables.length === 0) {
-        return {
-            id: "token-type-distribution",
-            label: "Type distribution",
-            score: 0,
-            severity: variableDataUnavailable(data) ? "info" : "fail",
-            tooltip: "A complete token system includes COLOR, FLOAT, and STRING variables. Missing types indicate gaps in the design language.",
-            details: variableDataUnavailable(data)
-                ? variableUnavailableMessage(data)
-                : "No variables to evaluate type distribution.",
-        };
-    }
-    const expectedTypes = ["COLOR", "FLOAT", "STRING"];
-    const presentTypes = new Set(data.variables.map((v) => v.resolvedType));
-    const matchCount = expectedTypes.filter((t) => presentTypes.has(t)).length;
-    const score = clamp((matchCount / expectedTypes.length) * 100);
-    return {
-        id: "token-type-distribution",
-        label: "Type distribution",
-        score,
-        severity: getSeverity(score),
-        tooltip: "A complete token system includes COLOR, FLOAT, and STRING variables. Missing types indicate gaps in the design language.",
-        details: `${matchCount} of ${expectedTypes.length} expected types (COLOR, FLOAT, STRING) present. Found: ${[...presentTypes].join(", ") || "none"}.`,
-    };
-}
-/**
- * Score description coverage for variables.
- * Well-documented variables should have non-empty descriptions.
- */
-function scoreDescriptionCoverage(data) {
-    if (data.variables.length === 0) {
-        return {
-            id: "token-description-coverage",
-            label: "Description coverage",
-            score: 0,
-            severity: variableDataUnavailable(data) ? "info" : "fail",
-            tooltip: "Variables should have descriptions explaining their purpose and usage context. Descriptions help consumers choose the right token.",
-            details: variableDataUnavailable(data)
-                ? variableUnavailableMessage(data)
-                : "No variables to evaluate description coverage.",
-        };
-    }
-    const collectionNames = buildCollectionNameMap(data.collections);
-    const withDesc = data.variables.filter((v) => v.description && v.description.trim().length > 0);
-    const withoutDesc = data.variables.filter((v) => !v.description || v.description.trim().length === 0);
-    const ratio = withDesc.length / data.variables.length;
-    const score = clamp(ratio * 100);
-    return {
-        id: "token-description-coverage",
-        label: "Description coverage",
-        score,
-        severity: getSeverity(score),
-        tooltip: "Variables should have descriptions explaining their purpose and usage context. Descriptions help consumers choose the right token.",
-        details: `${withDesc.length} of ${data.variables.length} variables have descriptions (${Math.round(ratio * 100)}%).`,
-        examples: withoutDesc.length > 0
-            ? withoutDesc.slice(0, MAX_EXAMPLES).map((v) => v.name)
-            : undefined,
-        locations: withoutDesc.length > 0
-            ? withoutDesc.slice(0, MAX_EXAMPLES).map((v) => ({
-                name: v.name,
-                collection: collectionNames.get(v.variableCollectionId),
-                type: "variable",
-            }))
-            : undefined,
-    };
-}
-/**
- * Token Architecture category scorer.
- * Returns the average score across all token architecture checks.
- */
-export function scoreTokenArchitecture(data) {
-    const findings = [
-        scoreCollectionOrganization(data),
-        scoreModeCoverage(data),
-        scoreAliasUsage(data),
-        scoreTokenTierDepth(data),
-        scoreTypeDistribution(data),
-        scoreDescriptionCoverage(data),
-    ];
-    const score = clamp(findings.reduce((sum, f) => sum + f.score, 0) / findings.length);
-    return {
-        id: "token-architecture",
-        label: "Token Architecture",
-        shortLabel: "Tokens",
-        score,
-        weight: 0.2,
-        findings,
-    };
-}

package/dist/cloudflare/apps/design-system-dashboard/scoring/types.js

@@ -1,40 +0,0 @@
-/**
- * Design System Dashboard — Shared Types
- *
- * Defines the JSON contract between the scoring engine (server-side),
- * the server registration (tools), and the UI (client-side rendering).
- */
-/** Build a map of collection ID → collection name for location context. */
-export function buildCollectionNameMap(collections) {
-    const map = new Map();
-    for (const col of collections) {
-        if (col.id && col.name)
-            map.set(col.id, col.name);
-    }
-    return map;
-}
-// ---------------------------------------------------------------------------
-// Thresholds and helpers
-// ---------------------------------------------------------------------------
-export const THRESHOLDS = {
-    GOOD: 90,
-    NEEDS_WORK: 50,
-};
-export function getStatus(score) {
-    if (score >= THRESHOLDS.GOOD)
-        return "good";
-    if (score >= THRESHOLDS.NEEDS_WORK)
-        return "needs-work";
-    return "poor";
-}
-export function getSeverity(score) {
-    if (score >= THRESHOLDS.GOOD)
-        return "pass";
-    if (score >= THRESHOLDS.NEEDS_WORK)
-        return "warning";
-    return "fail";
-}
-/** Clamp a number to 0-100. */
-export function clamp(value) {
-    return Math.max(0, Math.min(100, Math.round(value)));
-}