@dryui/mcp 0.1.0

package/dist/reviewer.js

@@ -0,0 +1,744 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/utils.ts
+function buildLineOffsets(text) {
+  const offsets = [0];
+  for (let i = 0;i < text.length; i++) {
+    if (text[i] === `
+`)
+      offsets.push(i + 1);
+  }
+  return offsets;
+}
+function lineAtOffset(lineOffsets, offset) {
+  let lo = 0;
+  let hi = lineOffsets.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    const midVal = lineOffsets[mid];
+    if (midVal !== undefined && midVal <= offset)
+      lo = mid;
+    else
+      hi = mid - 1;
+  }
+  return lo + 1;
+}
+
+// src/reviewer.ts
+function extractImports(code) {
+  const imports = new Set;
+  const scriptMatch = code.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+  if (!scriptMatch)
+    return imports;
+  const scriptContent = scriptMatch[1] ?? "";
+  const importRegex = /import\s*\{([^}]+)\}\s*from\s*['"]@dryui\/(ui|primitives)['"]/g;
+  let match;
+  while ((match = importRegex.exec(scriptContent)) !== null) {
+    const raw = match[1] ?? "";
+    const names = raw.split(",");
+    for (const name of names) {
+      const trimmed = name.trim();
+      if (trimmed)
+        imports.add(trimmed);
+    }
+  }
+  return imports;
+}
+function extractTags(code) {
+  const template = code.replace(/<script[^>]*>[\s\S]*?<\/script>/g, (m) => `
+`.repeat(countNewlines(m))).replace(/<style[^>]*>[\s\S]*?<\/style>/g, (m) => `
+`.repeat(countNewlines(m)));
+  const lineOffsets = buildLineOffsets(code);
+  const tagRegex = /<([A-Z][a-zA-Z0-9]*(?:\.[A-Z][a-zA-Z0-9]*)*)\s*([^>]*?)(\/)?>/g;
+  const tags = [];
+  let match;
+  while ((match = tagRegex.exec(template)) !== null) {
+    const name = match[1] ?? "";
+    const attrsStr = match[2] ?? "";
+    const selfClosing = match[3] === "/";
+    const line = lineAtOffset(lineOffsets, match.index);
+    const props = extractPropsFromAttrs(attrsStr);
+    const hasSpread = /\{\.\.\./.test(attrsStr);
+    tags.push({ name, line, props, hasSpread, selfClosing });
+  }
+  return tags;
+}
+function extractStyles(code) {
+  const styleMatch = code.match(/<style[^>]*>([\s\S]*?)<\/style>/);
+  return styleMatch ? styleMatch[1] ?? null : null;
+}
+function countNewlines(str) {
+  let count = 0;
+  for (let i = 0;i < str.length; i++) {
+    if (str[i] === `
+`)
+      count++;
+  }
+  return count;
+}
+function stripBraceExpressions(str) {
+  let result = "";
+  let depth = 0;
+  for (let i = 0;i < str.length; i++) {
+    if (str[i] === "{") {
+      if (depth === 0)
+        result += "{}";
+      depth++;
+    } else if (str[i] === "}") {
+      depth--;
+    } else if (depth === 0) {
+      result += str[i];
+    }
+  }
+  return result;
+}
+function extractPropsFromAttrs(attrsStr) {
+  const props = [];
+  if (!attrsStr.trim())
+    return props;
+  const stripped = stripBraceExpressions(attrsStr.replace(/"[^"]*"/g, '""').replace(/'[^']*'/g, "''"));
+  const bindRegex = /\bbind:([a-zA-Z_][a-zA-Z0-9_]*)/g;
+  let m;
+  while ((m = bindRegex.exec(stripped)) !== null) {
+    const bound = m[1];
+    if (bound)
+      props.push("bind:" + bound);
+  }
+  const namedRegex = /\b([a-zA-Z_][a-zA-Z0-9_-]*)\s*=/g;
+  while ((m = namedRegex.exec(stripped)) !== null) {
+    const propName = m[1];
+    if (propName && !props.includes(propName)) {
+      props.push(propName);
+    }
+  }
+  const boolRegex = /(?<!\.)(?<![:{])\b([a-zA-Z_][a-zA-Z0-9_-]*)\b(?!\s*=)/g;
+  while ((m = boolRegex.exec(stripped)) !== null) {
+    const propName = m[1];
+    if (!propName)
+      continue;
+    if (props.includes(propName) || props.includes("bind:" + propName) || propName === "bind") {
+      continue;
+    }
+    props.push(propName);
+  }
+  return props;
+}
+var NATIVE_HTML_ATTRS = new Set([
+  "id",
+  "class",
+  "style",
+  "title",
+  "lang",
+  "dir",
+  "tabindex",
+  "hidden",
+  "role",
+  "slot",
+  "is",
+  "part",
+  "translate",
+  "draggable",
+  "contenteditable",
+  "spellcheck",
+  "autocapitalize",
+  "inputmode",
+  "enterkeyhint",
+  "children",
+  "name",
+  "value",
+  "type",
+  "placeholder",
+  "required",
+  "readonly",
+  "disabled",
+  "checked",
+  "selected",
+  "multiple",
+  "autofocus",
+  "autocomplete",
+  "pattern",
+  "min",
+  "max",
+  "step",
+  "minlength",
+  "maxlength",
+  "form",
+  "formaction",
+  "formmethod",
+  "formtarget",
+  "formnovalidate",
+  "accept",
+  "capture",
+  "list",
+  "size",
+  "href",
+  "target",
+  "rel",
+  "download",
+  "src",
+  "alt",
+  "width",
+  "height",
+  "loading",
+  "decoding",
+  "crossorigin",
+  "referrerpolicy",
+  "for",
+  "htmlFor"
+]);
+function isPropAllowed(propName) {
+  if (NATIVE_HTML_ATTRS.has(propName))
+    return true;
+  if (propName.startsWith("aria-"))
+    return true;
+  if (propName.startsWith("data-"))
+    return true;
+  if (propName.startsWith("on"))
+    return true;
+  if (propName.startsWith("bind:"))
+    return true;
+  return false;
+}
+function checkBareCompound(tags, spec) {
+  const issues = [];
+  for (const tag of tags) {
+    if (tag.name.includes("."))
+      continue;
+    const def = spec.components[tag.name];
+    if (!def?.compound)
+      continue;
+    const partNames = Object.keys(def.parts ?? {});
+    const hasRootPart = partNames.includes("Root");
+    const firstPart = partNames.find((part) => part !== "Root");
+    if (hasRootPart) {
+      issues.push({
+        severity: "error",
+        code: "bare-compound",
+        line: tag.line,
+        message: `<${tag.name}> is a compound component — use <${tag.name}.Root>`,
+        fix: `<${tag.name}.Root>`
+      });
+      continue;
+    }
+    issues.push({
+      severity: "error",
+      code: "bare-compound",
+      line: tag.line,
+      message: `<${tag.name}> is a namespaced component — use a part like <${tag.name}.${firstPart ?? "Text"}>`,
+      fix: `<${tag.name}.${firstPart ?? "Text"}>`
+    });
+  }
+  return issues;
+}
+function checkUnknownComponent(tags, imports, spec) {
+  const issues = [];
+  for (const tag of tags) {
+    const root = tag.name.split(".")[0] ?? tag.name;
+    if (imports.has(root) && !spec.components[root]) {
+      issues.push({
+        severity: "error",
+        code: "unknown-component",
+        line: tag.line,
+        message: `<${tag.name}> is not a known DryUI component`,
+        fix: null
+      });
+    }
+  }
+  return issues;
+}
+function checkInvalidPartName(tags, spec) {
+  const issues = [];
+  for (const tag of tags) {
+    if (!tag.name.includes("."))
+      continue;
+    const parts = tag.name.split(".");
+    const root = parts[0] ?? "";
+    const part = parts[1] ?? "";
+    if (!root || !part)
+      continue;
+    const def = spec.components[root];
+    if (!def?.compound || !def.parts)
+      continue;
+    if (!def.parts[part]) {
+      const validParts = Object.keys(def.parts);
+      issues.push({
+        severity: "error",
+        code: "invalid-part",
+        line: tag.line,
+        message: `<${root}.${part}> — "${part}" is not a valid part of ${root}. Valid parts: ${validParts.join(", ")}`,
+        fix: null
+      });
+    }
+  }
+  return issues;
+}
+function checkInvalidProp(tags, spec) {
+  const issues = [];
+  for (const tag of tags) {
+    const segments = tag.name.split(".");
+    const root = segments[0] ?? "";
+    const part = segments[1];
+    if (!root)
+      continue;
+    const def = spec.components[root];
+    if (!def)
+      continue;
+    let specProps;
+    if (part) {
+      specProps = def.parts?.[part]?.props;
+    } else if (!def.compound) {
+      specProps = def.props;
+    } else {
+      continue;
+    }
+    if (!specProps)
+      continue;
+    for (const prop of tag.props) {
+      const checkName = prop.startsWith("bind:") ? prop.slice(5) : prop;
+      if (isPropAllowed(prop))
+        continue;
+      if (!specProps[checkName]) {
+        issues.push({
+          severity: "error",
+          code: "invalid-prop",
+          line: tag.line,
+          message: `<${tag.name}> does not accept prop "${checkName}"`,
+          fix: null
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkMissingRequiredProp(tags, spec) {
+  const issues = [];
+  for (const tag of tags) {
+    if (tag.hasSpread)
+      continue;
+    const segments = tag.name.split(".");
+    const root = segments[0] ?? "";
+    const part = segments[1];
+    if (!root)
+      continue;
+    const def = spec.components[root];
+    if (!def)
+      continue;
+    let specProps;
+    if (part) {
+      specProps = def.parts?.[part]?.props;
+    } else if (!def.compound) {
+      specProps = def.props;
+    } else {
+      continue;
+    }
+    if (!specProps)
+      continue;
+    const tagPropNames = new Set(tag.props.map((p) => p.startsWith("bind:") ? p.slice(5) : p));
+    for (const [propName, propDef] of Object.entries(specProps)) {
+      if (propDef.required && !tagPropNames.has(propName)) {
+        if (propName === "children" && !tag.selfClosing)
+          continue;
+        issues.push({
+          severity: "error",
+          code: "missing-required-prop",
+          line: tag.line,
+          message: `<${tag.name}> is missing required prop "${propName}"`,
+          fix: `${propName}={...}`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkOrphanedPart(tags, spec) {
+  const issues = [];
+  const allNames = new Set(tags.map((t) => t.name));
+  for (const tag of tags) {
+    if (!tag.name.includes("."))
+      continue;
+    const root = tag.name.split(".")[0] ?? "";
+    if (!root)
+      continue;
+    const def = spec.components[root];
+    if (!def?.compound || !def.parts?.Root)
+      continue;
+    if (!allNames.has(`${root}.Root`)) {
+      issues.push({
+        severity: "warning",
+        code: "orphaned-part",
+        line: tag.line,
+        message: `<${tag.name}> used without <${root}.Root> in the template`,
+        fix: `Wrap in <${root}.Root>`
+      });
+    }
+  }
+  return issues;
+}
+function checkMissingLabel(tags, code) {
+  const issues = [];
+  const template = code.replace(/<script[^>]*>[\s\S]*?<\/script>/g, (m) => `
+`.repeat(countNewlines(m))).replace(/<style[^>]*>[\s\S]*?<\/style>/g, (m) => `
+`.repeat(countNewlines(m)));
+  const lineOffsets = buildLineOffsets(code);
+  for (const tag of tags) {
+    if (tag.name !== "Input" && tag.name !== "Select.Root" && tag.name !== "Combobox.Input")
+      continue;
+    const hasAriaLabel = tag.props.some((p) => p === "aria-label");
+    if (hasAriaLabel)
+      continue;
+    const tagOffset = findTagOffset(template, tag.name, tag.line, lineOffsets);
+    const wrappedByField = tagOffset !== -1 && template.lastIndexOf("<Field.Root", tagOffset) !== -1 && template.indexOf("</Field.Root>", tagOffset) !== -1;
+    if (!wrappedByField) {
+      issues.push({
+        severity: "warning",
+        code: "missing-label",
+        line: tag.line,
+        message: `<${tag.name}> may be missing an accessible label — add aria-label or wrap in <Field.Root> with <Label>`,
+        fix: 'aria-label="..."'
+      });
+    }
+  }
+  return issues;
+}
+function findTagOffset(template, tagName, targetLine, lineOffsets) {
+  const regex = new RegExp(`<${tagName.replace(".", "\\.")}[\\s/>]`, "g");
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    const line = lineAtOffset(lineOffsets, match.index);
+    if (line === targetLine)
+      return match.index;
+  }
+  return -1;
+}
+function checkMissingThumbnail(imports, spec) {
+  if (!spec.thumbnails)
+    return [];
+  const issues = [];
+  const thumbnailSet = new Set(spec.thumbnails);
+  for (const name of imports) {
+    if (!spec.components[name])
+      continue;
+    if (!thumbnailSet.has(name)) {
+      issues.push({
+        severity: "warning",
+        code: "missing-thumbnail",
+        line: 1,
+        message: `Component '${name}' has no SVG thumbnail — run 'bun run thumbnail:create ${name}'`,
+        fix: null
+      });
+    }
+  }
+  return issues;
+}
+function checkImageWithoutAlt(tags) {
+  const issues = [];
+  for (const tag of tags) {
+    if (tag.name !== "Avatar")
+      continue;
+    const hasAlt = tag.props.includes("alt");
+    const hasFallback = tag.props.includes("fallback");
+    if (!hasAlt && !hasFallback) {
+      issues.push({
+        severity: "warning",
+        code: "missing-alt",
+        line: tag.line,
+        message: '<Avatar> is missing "alt" and "fallback" props for accessibility',
+        fix: 'alt="..."'
+      });
+    }
+  }
+  return issues;
+}
+function checkCustomGridLayout(styles, code) {
+  const issues = [];
+  if (/display:\s*grid/.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /display:\s*grid/);
+    issues.push({
+      severity: "warning",
+      code: "use-grid-component",
+      line: styleLineToFileLine(localLine, startLine),
+      message: "Use DryUI's <Grid> component instead of custom CSS grid. Grid provides responsive columns, gap tokens, and breakpoint handling.",
+      fix: '<Grid --dry-grid-columns="repeat(2, 1fr)" --dry-grid-gap="var(--dry-space-4)">'
+    });
+  }
+  return issues;
+}
+function checkCustomFlexLayout(styles, code) {
+  const issues = [];
+  if (/display:\s*flex/.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /display:\s*flex/);
+    issues.push({
+      severity: "warning",
+      code: "use-flex-component",
+      line: styleLineToFileLine(localLine, startLine),
+      message: "Use DryUI's <Flex> or <Stack> component instead of custom CSS flexbox. These provide gap, alignment, and responsive behavior with theme tokens.",
+      fix: "<Flex> or <Stack>"
+    });
+  }
+  return issues;
+}
+function checkCustomFieldMarkup(code) {
+  const issues = [];
+  const template = code.replace(/<script[^>]*>[\s\S]*?<\/script>/g, (m) => `
+`.repeat(countNewlines(m))).replace(/<style[^>]*>[\s\S]*?<\/style>/g, (m) => `
+`.repeat(countNewlines(m)));
+  const lineOffsets = buildLineOffsets(code);
+  const fieldClassRegex = /class=["']field["']/g;
+  let match;
+  while ((match = fieldClassRegex.exec(template)) !== null) {
+    const line = lineAtOffset(lineOffsets, match.index);
+    issues.push({
+      severity: "warning",
+      code: "use-field-component",
+      line,
+      message: "Use <Field.Root> + <Label> instead of custom field markup. Field provides accessible labeling, error states, and consistent spacing.",
+      fix: "<Field.Root> + <Label>"
+    });
+  }
+  const manualFieldRegex = /<span[^>]*>[\s\S]*?<\/span>\s*<(?:input|select|textarea)[\s/>]/g;
+  while ((match = manualFieldRegex.exec(template)) !== null) {
+    const line = lineAtOffset(lineOffsets, match.index);
+    issues.push({
+      severity: "warning",
+      code: "use-field-component",
+      line,
+      message: "Use <Field.Root> + <Label> instead of custom field markup. Field provides accessible labeling, error states, and consistent spacing.",
+      fix: "<Field.Root> + <Label>"
+    });
+  }
+  return issues;
+}
+function checkRawStyledButton(code) {
+  const issues = [];
+  const template = code.replace(/<script[^>]*>[\s\S]*?<\/script>/g, (m) => `
+`.repeat(countNewlines(m))).replace(/<style[^>]*>[\s\S]*?<\/style>/g, (m) => `
+`.repeat(countNewlines(m)));
+  const lineOffsets = buildLineOffsets(code);
+  const rawBtnRegex = /<button\s[^>]*class=/g;
+  let match;
+  while ((match = rawBtnRegex.exec(template)) !== null) {
+    const line = lineAtOffset(lineOffsets, match.index);
+    issues.push({
+      severity: "warning",
+      code: "use-button-component",
+      line,
+      message: "Use DryUI's <Button> component instead of raw <button> with custom classes. Button provides variants, sizes, loading states, and theme-consistent styling.",
+      fix: "<Button>"
+    });
+  }
+  return issues;
+}
+function checkCustomMaxWidthCentering(styles, code) {
+  const issues = [];
+  if (/max-width/.test(styles) && /margin[^;]*auto/.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /max-width/);
+    issues.push({
+      severity: "warning",
+      code: "use-container-component",
+      line: styleLineToFileLine(localLine, startLine),
+      message: "Use DryUI's <Container> component instead of custom max-width + margin centering.",
+      fix: "<Container>"
+    });
+  }
+  return issues;
+}
+function getStyleBlockStartLine(code) {
+  const idx = code.search(/<style[^>]*>/);
+  if (idx === -1)
+    return 1;
+  const lineOffsets = buildLineOffsets(code);
+  const tagEndIdx = code.indexOf(">", idx) + 1;
+  return lineAtOffset(lineOffsets, tagEndIdx);
+}
+function styleLineToFileLine(lineInStyleBlock, styleStartLine) {
+  return styleStartLine + lineInStyleBlock - 1;
+}
+function findLineInBlock(block, regex) {
+  const lines = block.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (line !== undefined && regex.test(line))
+      return i + 1;
+  }
+  return 1;
+}
+function checkManualFlex(styles, code) {
+  const issues = [];
+  if (/display:\s*flex/.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /display:\s*flex/);
+    issues.push({
+      severity: "suggestion",
+      code: "prefer-layout",
+      line: styleLineToFileLine(localLine, startLine),
+      message: "Manual `display: flex` detected — consider using <Flex> or <Stack> instead",
+      fix: "<Flex> or <Stack>"
+    });
+  }
+  return issues;
+}
+function checkManualGrid(styles, code) {
+  const issues = [];
+  if (/display:\s*grid/.test(styles) && /grid-template-columns/.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /display:\s*grid/);
+    issues.push({
+      severity: "suggestion",
+      code: "prefer-layout",
+      line: styleLineToFileLine(localLine, startLine),
+      message: 'Manual CSS grid detected — consider using <Grid --dry-grid-columns="repeat(2, 1fr)"> instead',
+      fix: '<Grid --dry-grid-columns="repeat(2, 1fr)" --dry-grid-gap="var(--dry-space-4)">'
+    });
+  }
+  return issues;
+}
+function checkHardcodedColors(styles, code) {
+  const issues = [];
+  const colorRegex = /(?:^|;)\s*(?:color|background(?:-color)?)\s*:\s*(?!.*var\s*\()/m;
+  if (colorRegex.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /(?:color|background(?:-color)?)\s*:\s*(?!.*var\s*\()/);
+    issues.push({
+      severity: "suggestion",
+      code: "hardcoded-color",
+      line: styleLineToFileLine(localLine, startLine),
+      message: "Hardcoded color value — consider using `--dry-*` CSS custom properties for theming",
+      fix: "var(--dry-*)"
+    });
+  }
+  return issues;
+}
+function checkManualCentering(styles, code) {
+  const issues = [];
+  if (/max-width/.test(styles) && /margin:\s*[^;]*auto/.test(styles)) {
+    const startLine = getStyleBlockStartLine(code);
+    const localLine = findLineInBlock(styles, /max-width/);
+    issues.push({
+      severity: "suggestion",
+      code: "prefer-container",
+      line: styleLineToFileLine(localLine, startLine),
+      message: "Manual centering with max-width + margin auto — consider using <Container> instead",
+      fix: "<Container>"
+    });
+  }
+  return issues;
+}
+function checkCustomThemeOverrides(styles, code) {
+  if (!styles || !/--dry-/.test(styles))
+    return [];
+  return [
+    {
+      severity: "suggestion",
+      code: "theme-in-style",
+      line: getStyleBlockStartLine(code),
+      message: "Custom --dry-* variable overrides detected in <style> — run the `diagnose` tool on your theme CSS for a full health check",
+      fix: null
+    }
+  ];
+}
+function checkRawHr(code) {
+  const issues = [];
+  const template = code.replace(/<script[^>]*>[\s\S]*?<\/script>/g, (m) => `
+`.repeat(countNewlines(m))).replace(/<style[^>]*>[\s\S]*?<\/style>/g, (m) => `
+`.repeat(countNewlines(m)));
+  const hrRegex = /<hr[\s/>]/g;
+  const lineOffsets = buildLineOffsets(code);
+  let match;
+  while ((match = hrRegex.exec(template)) !== null) {
+    const line = lineAtOffset(lineOffsets, match.index);
+    issues.push({
+      severity: "suggestion",
+      code: "prefer-separator",
+      line,
+      message: "Raw <hr> element — consider using <Separator /> for consistent styling",
+      fix: "<Separator />"
+    });
+  }
+  return issues;
+}
+function reviewComponent(code, spec, filename) {
+  const imports = extractImports(code);
+  const tags = extractTags(code);
+  const styles = extractStyles(code);
+  const issues = [];
+  issues.push(...checkBareCompound(tags, spec));
+  issues.push(...checkUnknownComponent(tags, imports, spec));
+  issues.push(...checkInvalidPartName(tags, spec));
+  issues.push(...checkInvalidProp(tags, spec));
+  issues.push(...checkMissingRequiredProp(tags, spec));
+  issues.push(...checkOrphanedPart(tags, spec));
+  issues.push(...checkMissingLabel(tags, code));
+  issues.push(...checkImageWithoutAlt(tags));
+  issues.push(...checkMissingThumbnail(imports, spec));
+  issues.push(...checkCustomFieldMarkup(code));
+  issues.push(...checkRawStyledButton(code));
+  if (styles) {
+    issues.push(...checkCustomGridLayout(styles, code));
+    issues.push(...checkCustomFlexLayout(styles, code));
+    issues.push(...checkCustomMaxWidthCentering(styles, code));
+  }
+  if (styles) {
+    issues.push(...checkManualFlex(styles, code));
+    issues.push(...checkManualGrid(styles, code));
+    issues.push(...checkHardcodedColors(styles, code));
+    issues.push(...checkManualCentering(styles, code));
+    issues.push(...checkCustomThemeOverrides(styles, code));
+  }
+  issues.push(...checkRawHr(code));
+  issues.sort((a, b) => a.line - b.line);
+  const errors = issues.filter((i) => i.severity === "error").length;
+  const warnings = issues.filter((i) => i.severity === "warning").length;
+  const suggestions = issues.filter((i) => i.severity === "suggestion").length;
+  const summary = issues.length === 0 ? "No issues found" : `${errors} error${errors !== 1 ? "s" : ""}, ${warnings} warning${warnings !== 1 ? "s" : ""}, ${suggestions} suggestion${suggestions !== 1 ? "s" : ""}`;
+  return { issues, summary, ...filename ? { filename } : {} };
+}
+export {
+  reviewComponent
+};