@vadimcomanescu/nadicode-design-system 2.0.0

package/eslint-rules/nadicode/rules/no-ssr-false-on-page.js

@@ -0,0 +1,101 @@
+import { getFilename } from "../utils.js";
+
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow ssr: false in next/dynamic() calls within app route files. SSR-disabled pages render empty HTML to crawlers, destroying SEO.",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          ignore: {
+            type: "array",
+            items: { type: "string" },
+            description:
+              "Route segments to ignore (e.g. 'dashboard', 'onboarding' for auth-gated routes)",
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+  create(context) {
+    const dynamicLocalNames = new Set();
+
+    return {
+      ImportDeclaration(node) {
+        if (
+          node.source.value === "next/dynamic" &&
+          node.specifiers.length > 0
+        ) {
+          for (const spec of node.specifiers) {
+            if (spec.type === "ImportDefaultSpecifier") {
+              dynamicLocalNames.add(spec.local.name);
+            }
+          }
+        }
+      },
+
+      CallExpression(node) {
+        if (
+          node.callee.type !== "Identifier" ||
+          !dynamicLocalNames.has(node.callee.name)
+        ) {
+          return;
+        }
+
+        const filename = getFilename(context);
+
+        // Only flag route-level files (page.tsx, client.tsx, *-client.tsx)
+        if (!filename.includes("/app/")) return;
+        const basename = filename.split("/").pop() || "";
+        if (
+          !basename.endsWith("page.tsx") &&
+          !basename.endsWith("page.jsx") &&
+          !basename.endsWith("client.tsx") &&
+          !basename.endsWith("client.jsx")
+        ) {
+          return;
+        }
+
+        // Skip ignored route segments (auth-gated, special routes)
+        const ruleOptions = context.options[0] || {};
+        const ignoreSegments = ruleOptions.ignore || [];
+        for (const segment of ignoreSegments) {
+          if (
+            filename.includes(`/app/${segment}/`) ||
+            filename.includes(`/app/${segment}.`) ||
+            filename.includes(`/app/${segment}-`)
+          ) {
+            return;
+          }
+        }
+
+        const options = node.arguments[1];
+        if (!options || options.type !== "ObjectExpression") return;
+
+        const ssrProp = options.properties.find(
+          (p) =>
+            p.type === "Property" &&
+            p.key.type === "Identifier" &&
+            p.key.name === "ssr" &&
+            p.value.type === "Literal" &&
+            p.value.value === false,
+        );
+
+        if (ssrProp) {
+          context.report({
+            node: ssrProp,
+            message:
+              "Do not use ssr: false in app route files. It renders empty HTML to crawlers, breaking SEO. Import the component directly or use a client boundary instead.",
+          });
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/eslint-rules/nadicode/rules/no-unregistered-glass.js

@@ -0,0 +1,125 @@
+import {
+  getFilename,
+  isTestFile,
+  getClassTokensFromAttribute,
+  getClassTokensFromHelperCall,
+  isClassHelperCall,
+} from "../utils.js";
+
+const GLASS_RE = /\bglass-(panel|floating|overlay|tab-bar|tab-active)\b/;
+const TAB_GLASS_RE = /\bglass-tab-(bar|active)\b/;
+
+// --- Allowlist ---
+// Directories: any file under these paths may use glass freely.
+const ALLOWED_DIRECTORIES = [
+  "/src/components/blocks/",
+  "/src/components/pages/",
+  "/src/app/",
+];
+
+// Individual component files (basename match) -- allowed ALL glass classes.
+const ALLOWED_FILES = [
+  // Floating / overlay (must use glass)
+  "Dialog.tsx",
+  "AlertDialog.tsx",
+  "AnimatedDialog.tsx",
+  "Sheet.tsx",
+  "AnimatedSheet.tsx",
+  "Popover.tsx",
+  "Select.tsx",
+  "ContextMenu.tsx",
+  "DropdownMenu.tsx",
+  "Menubar.tsx",
+  "NavigationMenu.tsx",
+  "Tooltip.tsx",
+  "HoverCard.tsx",
+  "FloatingDock.tsx",
+  "SearchCommand.tsx",
+  // Intentional glass (design identity)
+  "Card.tsx",
+  "Button.tsx",
+  "ToolCallCard.tsx",
+  "ApprovalCard.tsx",
+  "ThinkingIndicator.tsx",
+  "AgentMessageBubble.tsx",
+  "HandoffIndicator.tsx",
+  "SourceCitation.tsx",
+  "MemoryInspector.tsx",
+  "Timeline.tsx",
+  "FormWizard.tsx",
+  "CheckoutFormDemo.tsx",
+  "Chart.tsx",
+  "KanbanBoard.tsx",
+];
+
+// Files allowed ONLY glass-tab-bar and glass-tab-active (not panel/floating/overlay).
+const ALLOWED_TAB_GLASS_FILES = ["Tabs.tsx", "AnimatedTabs.tsx"];
+
+function isAllowed(filename) {
+  if (ALLOWED_DIRECTORIES.some((dir) => filename.includes(dir))) return true;
+  return ALLOWED_FILES.some((name) => filename.endsWith("/" + name));
+}
+
+function isTabGlassAllowed(filename) {
+  return ALLOWED_TAB_GLASS_FILES.some((name) => filename.endsWith("/" + name));
+}
+
+function findViolatingGlass(tokens, tabGlassPermitted) {
+  for (const t of tokens) {
+    if (!GLASS_RE.test(t)) continue;
+    if (tabGlassPermitted && TAB_GLASS_RE.test(t)) continue;
+    return t;
+  }
+  return null;
+}
+
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow glass classes (glass-panel/floating/overlay) in files not registered in the glass allowlist. Register intentional glass usage in the ALLOWED_FILES / ALLOWED_DIRECTORIES constants inside this rule file.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const filename = getFilename(context);
+    if (isTestFile(filename) || isAllowed(filename)) return {};
+
+    const tabGlassPermitted = isTabGlassAllowed(filename);
+
+    function report(node, matched) {
+      context.report({
+        node,
+        message:
+          "'{{matched}}' is not allowed in this file. Glass classes are restricted to registered files. Add this file to ALLOWED_FILES or ALLOWED_DIRECTORIES in no-unregistered-glass.js if glass is intentional here.",
+        data: { matched },
+      });
+    }
+
+    return {
+      JSXAttribute(node) {
+        // Skip if the value is a class helper call (cn/cva/clsx) —
+        // the CallExpression visitor handles those to avoid double reports.
+        if (
+          node.value?.type === "JSXExpressionContainer" &&
+          isClassHelperCall(node.value.expression)
+        ) {
+          return;
+        }
+        const tokens = getClassTokensFromAttribute(node);
+        const match = findViolatingGlass(tokens, tabGlassPermitted);
+        if (match) report(node, match);
+      },
+
+      CallExpression(node) {
+        if (!isClassHelperCall(node)) return;
+        const tokens = getClassTokensFromHelperCall(node);
+        const match = findViolatingGlass(tokens, tabGlassPermitted);
+        if (match) report(node, match);
+      },
+    };
+  },
+};
+
+export default rule;

package/eslint-rules/nadicode/rules/no-unstable-cache.js

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview Disallow importing unstable_cache from next/cache.
+ *
+ * unstable_cache is deprecated in favor of the 'use cache' directive.
+ */
+
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow unstable_cache from next/cache. Migrate to 'use cache' directive with cacheLife().",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== "next/cache") return;
+
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== "ImportSpecifier") continue;
+          if (specifier.imported.name === "unstable_cache") {
+            context.report({
+              node: specifier,
+              message:
+                "unstable_cache is deprecated. Migrate to the 'use cache' directive with cacheLife() and cacheTag().",
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/eslint-rules/nadicode/rules/require-action-schema.js

@@ -0,0 +1,142 @@
+/**
+ * @fileoverview Require Zod validation in Server Action files.
+ */
+
+function hasParseCall(node) {
+  if (!node) return false;
+
+  if (node.type === "CallExpression") {
+    const callee = node.callee;
+    if (
+      callee.type === "MemberExpression" &&
+      callee.property.type === "Identifier" &&
+      (callee.property.name === "parse" || callee.property.name === "safeParse")
+    ) {
+      return true;
+    }
+  }
+
+  for (const key of Object.keys(node)) {
+    if (key === "parent") continue;
+    const child = node[key];
+
+    if (!child || typeof child !== "object") continue;
+
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        if (item && typeof item.type === "string" && hasParseCall(item)) {
+          return true;
+        }
+      }
+      continue;
+    }
+
+    if (typeof child.type === "string" && hasParseCall(child)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function isUseServerDirective(statement) {
+  return (
+    statement.type === "ExpressionStatement" &&
+    statement.expression.type === "Literal" &&
+    statement.expression.value === "use server"
+  );
+}
+
+function getFunctionBody(node) {
+  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression") {
+    return node.body;
+  }
+  if (node.type === "ArrowFunctionExpression") {
+    return node.body;
+  }
+  return null;
+}
+
+function getFunctionName(node, parent) {
+  if (node.id && node.id.name) return node.id.name;
+
+  if (
+    parent &&
+    parent.type === "VariableDeclarator" &&
+    parent.id &&
+    parent.id.type === "Identifier"
+  ) {
+    return parent.id.name;
+  }
+
+  return "<anonymous>";
+}
+
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Require Zod .parse() or .safeParse() validation in Server Action exported functions",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      Program(programNode) {
+        const body = programNode.body;
+        if (body.length === 0) return;
+
+        const hasDirective = body.some(isUseServerDirective);
+        if (!hasDirective) return;
+
+        for (const statement of body) {
+          if (statement.type === "ExportNamedDeclaration" && statement.declaration) {
+            const declaration = statement.declaration;
+
+            if (
+              declaration.type === "FunctionDeclaration" &&
+              declaration.body &&
+              !hasParseCall(declaration.body)
+            ) {
+              context.report({
+                node: declaration,
+                message:
+                  "Server Action '{{name}}' must validate input with Zod .parse() or .safeParse().",
+                data: { name: getFunctionName(declaration, null) },
+              });
+            }
+
+            if (declaration.type === "VariableDeclaration") {
+              for (const declarator of declaration.declarations) {
+                const fnBody = declarator.init ? getFunctionBody(declarator.init) : null;
+                if (!fnBody || hasParseCall(fnBody)) continue;
+
+                context.report({
+                  node: declarator,
+                  message:
+                    "Server Action '{{name}}' must validate input with Zod .parse() or .safeParse().",
+                  data: { name: getFunctionName(declarator.init, declarator) },
+                });
+              }
+            }
+          }
+
+          if (statement.type === "ExportDefaultDeclaration" && statement.declaration) {
+            const fnBody = getFunctionBody(statement.declaration);
+            if (!fnBody || hasParseCall(fnBody)) continue;
+
+            context.report({
+              node: statement.declaration,
+              message:
+                "Server Action '{{name}}' must validate input with Zod .parse() or .safeParse().",
+              data: { name: getFunctionName(statement.declaration, null) },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/eslint-rules/nadicode/rules/require-admin-sidebar-group-label.js

@@ -0,0 +1,39 @@
+import { getFilename, isAdminUiFile, isTestFile } from "../utils.js";
+
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Require SidebarGroupLabel when AdminShell uses SidebarMenu.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const filename = getFilename(context);
+
+    if (
+      !isAdminUiFile(filename) ||
+      isTestFile(filename) ||
+      !/(?:^|\/)AdminShell\.tsx$/.test(filename)
+    ) {
+      return {};
+    }
+
+    return {
+      Program(node) {
+        const source = context.sourceCode.getText(node);
+        if (!/\bSidebarMenu\b/.test(source)) return;
+        if (/\bSidebarGroupLabel\b/.test(source)) return;
+
+        context.report({
+          node,
+          message:
+            "Admin sidebar navigation must include SidebarGroupLabel for clear IA grouping.",
+        });
+      },
+    };
+  },
+};
+
+export default rule;

package/eslint-rules/nadicode/rules/require-aria-hidden-on-decorative-icon.js

@@ -0,0 +1,76 @@
+const TRIGGER_NAMES = new Set([
+  "DropdownMenuTrigger",
+  "MenubarTrigger",
+  "SelectTrigger",
+  "AccordionTrigger",
+  "NavigationMenuTrigger",
+  "CollapsibleTrigger",
+  "PopoverTrigger",
+]);
+
+function isIconElement(node) {
+  if (node.type !== "JSXElement") return false;
+  const opening = node.openingElement;
+  if (!opening || !opening.name) return false;
+  if (opening.name.type !== "JSXIdentifier") return false;
+  return opening.name.name.endsWith("Icon");
+}
+
+function hasAriaHidden(openingElement) {
+  return openingElement.attributes.some((attr) => {
+    if (attr.type !== "JSXAttribute") return false;
+    if (!attr.name || attr.name.name !== "aria-hidden") return false;
+
+    const { value } = attr;
+    if (!value) return false;
+
+    // aria-hidden="true"
+    if (value.type === "Literal" && value.value === "true") return true;
+
+    // aria-hidden={true}
+    if (
+      value.type === "JSXExpressionContainer" &&
+      value.expression.type === "Literal" &&
+      value.expression.value === true
+    ) {
+      return true;
+    }
+
+    return false;
+  });
+}
+
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        'Require aria-hidden="true" on Icon elements that are direct children of trigger components',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      JSXElement(node) {
+        const opening = node.openingElement;
+        if (!opening || !opening.name) return;
+        if (opening.name.type !== "JSXIdentifier") return;
+
+        if (!TRIGGER_NAMES.has(opening.name.name)) return;
+
+        for (const child of node.children) {
+          if (!isIconElement(child)) continue;
+          if (hasAriaHidden(child.openingElement)) continue;
+
+          context.report({
+            node: child.openingElement,
+            message:
+              'Decorative icons inside trigger components must have aria-hidden="true" to prevent screen reader noise.',
+          });
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/eslint-rules/nadicode/rules/require-aria-label-on-nav.js

@@ -0,0 +1,44 @@
+import { getFilename, isTestFile } from "../utils.js";
+
+const LABEL_ATTRS = new Set(["aria-label", "aria-labelledby"]);
+
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Require aria-label or aria-labelledby on <nav> elements. Navigation landmarks must be distinguishable by screen readers (WCAG 1.3.1, 4.1.2).",
+    },
+    schema: [],
+  },
+  create(context) {
+    const filename = getFilename(context);
+    if (isTestFile(filename)) return {};
+
+    return {
+      JSXOpeningElement(node) {
+        if (node.name.type !== "JSXIdentifier" || node.name.name !== "nav") {
+          return;
+        }
+
+        const hasLabel = node.attributes.some(
+          (attr) =>
+            attr.type === "JSXAttribute" &&
+            attr.name.type === "JSXIdentifier" &&
+            LABEL_ATTRS.has(attr.name.name) &&
+            attr.value != null,
+        );
+
+        if (!hasLabel) {
+          context.report({
+            node,
+            message:
+              '<nav> element is missing aria-label or aria-labelledby. Navigation landmarks must have accessible names so screen readers can distinguish them (WCAG 1.3.1). Add aria-label="Description of navigation".',
+          });
+        }
+      },
+    };
+  },
+};
+
+export default rule;