@nadicodeai/ui 12.1.105 → 12.1.107

package/dist/eslint/index.js

@@ -58,6 +58,7 @@ import { tableCellInsetOwner } from "./rules/table-cell-inset-owner.js";
 import { tabsSelectionIsControlled } from "./rules/tabs-selection-is-controlled.js";
 import { tooltipOnlyArrow } from "./rules/tooltip-only-arrow.js";
 import { tooltipTriggerAccessibleName } from "./rules/tooltip-trigger-accessible-name.js";
+import { workspaceDeclaresImports } from "./rules/workspace-declares-imports.js";
 import { strictDesignSystemSelectors } from "./strict-design-system.js";
 
 /**
@@ -202,6 +203,7 @@ const plugin = {
     "tabs-selection-is-controlled": tabsSelectionIsControlled,
     "tooltip-only-arrow": tooltipOnlyArrow,
     "tooltip-trigger-accessible-name": tooltipTriggerAccessibleName,
+    "workspace-declares-imports": workspaceDeclaresImports,
   },
 };
 

package/dist/eslint/rules/workspace-declares-imports.js

@@ -0,0 +1,163 @@
+import { existsSync, readFileSync } from "node:fs";
+import { builtinModules } from "node:module";
+import { dirname, join, relative, sep } from "node:path";
+
+const DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies",
+];
+
+const BUILTINS = new Set(builtinModules);
+
+export const DECLARED_DEPENDENCIES_SETTING = "nadicodeai/declared-dependencies";
+
+const manifests = new Map();
+const scopes = new Map();
+
+function readManifest(directory) {
+  const path = join(directory, "package.json");
+  return existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : undefined;
+}
+
+function manifestIn(directory) {
+  if (!manifests.has(directory)) manifests.set(directory, readManifest(directory));
+  return manifests.get(directory);
+}
+
+function declaredBy(manifest) {
+  return new Set(DEPENDENCY_FIELDS.flatMap((field) => Object.keys(manifest[field] ?? {})));
+}
+
+function sortedNames(manifest) {
+  return [...declaredBy(manifest)].sort();
+}
+
+export function declaredDependencies(rootDirectory) {
+  const root = readManifest(rootDirectory);
+  const workspaces = {};
+  for (const path of [...workspacePaths(root)].sort()) {
+    const manifest = readManifest(join(rootDirectory, path));
+    if (manifest !== undefined) {
+      workspaces[path] = { name: manifest.name, declared: sortedNames(manifest) };
+    }
+  }
+  return { root: sortedNames(root), workspaces };
+}
+
+function workspacePaths(manifest) {
+  const list = Array.isArray(manifest.workspaces)
+    ? manifest.workspaces
+    : (manifest.workspaces?.packages ?? []);
+  return new Set(list.map((path) => path.replace(/\/$/, "")));
+}
+
+function computeScope(directory) {
+  const candidates = [];
+  for (let current = directory; ; current = dirname(current)) {
+    const manifest = manifestIn(current);
+    if (manifest?.workspaces !== undefined) {
+      const listed = workspacePaths(manifest);
+      const workspace = candidates.find((candidate) =>
+        listed.has(relative(current, candidate).split(sep).join("/")),
+      );
+      if (workspace === undefined) return undefined;
+      const own = manifestIn(workspace);
+      const path = relative(current, workspace).split(sep).join("/");
+      return {
+        workspacePath: path,
+        workspaceName: own.name ?? path,
+        ownName: own.name,
+        rootDeclared: declaredBy(manifest),
+        workspaceDeclared: declaredBy(own),
+      };
+    }
+    if (manifest !== undefined) candidates.push(current);
+    if (dirname(current) === current) return undefined;
+  }
+}
+
+function scopeOf(directory) {
+  if (!scopes.has(directory)) scopes.set(directory, computeScope(directory));
+  return scopes.get(directory);
+}
+
+function declaredNamesOf(scope, given) {
+  const entry = given?.workspaces?.[scope.workspacePath];
+  if (entry === undefined || !Array.isArray(given.root)) return scope;
+  return {
+    ownName: entry.name,
+    workspaceName: entry.name ?? scope.workspacePath,
+    rootDeclared: new Set(given.root),
+    workspaceDeclared: new Set(entry.declared),
+  };
+}
+
+function packageNameOf(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("node:")) {
+    return undefined;
+  }
+  const [first, second = ""] = specifier.split("/");
+  const name = first.startsWith("@") ? `${first}/${second}` : first;
+  return BUILTINS.has(name) ? undefined : name;
+}
+
+function specifierOf(node) {
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- ESTree types Literal.value as string | number | boolean | RegExp | bigint | null; only typeof picks the string.
+  return node?.type === "Literal" && typeof node.value === "string" ? node.value : undefined;
+}
+
+export const workspaceDeclaresImports = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Require a workspace to declare each package it imports that the root package.json declares",
+    },
+    schema: [],
+    messages: {
+      undeclared:
+        '"{{name}}" is declared by the root package.json but not by {{workspace}}. Declare it in the workspace that imports it, so a root bump is attributed to that workspace.',
+    },
+  },
+  create(context) {
+    const found = scopeOf(dirname(context.filename));
+    if (found === undefined) return {};
+    const scope = declaredNamesOf(found, context.settings[DECLARED_DEPENDENCIES_SETTING]);
+
+    function check(source) {
+      const specifier = specifierOf(source);
+      if (specifier === undefined) return;
+      const name = packageNameOf(specifier);
+      if (
+        name === undefined ||
+        name === scope.ownName ||
+        !scope.rootDeclared.has(name) ||
+        scope.workspaceDeclared.has(name)
+      ) {
+        return;
+      }
+      context.report({
+        node: source,
+        messageId: "undeclared",
+        data: { name, workspace: scope.workspaceName },
+      });
+    }
+
+    return {
+      ImportDeclaration: (node) => check(node.source),
+      ExportNamedDeclaration: (node) => check(node.source),
+      ExportAllDeclaration: (node) => check(node.source),
+      ImportExpression: (node) => check(node.source),
+      TSExternalModuleReference: (node) => check(node.expression),
+      TSImportType: (node) =>
+        check(node.argument?.type === "TSLiteralType" ? node.argument.literal : node.argument),
+      CallExpression: (node) => {
+        if (node.callee.type === "Identifier" && node.callee.name === "require") {
+          check(node.arguments[0]);
+        }
+      },
+    };
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nadicodeai/ui",
-  "version": "12.1.105",
+  "version": "12.1.107",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -80,7 +80,7 @@
     "@base-ui/react": "^1.9.0",
     "@iconify-icons/logos": "^2.0.2",
     "@iconify/react": "^6.0.2",
-    "@nadicodeai/design-system": "12.1.105",
+    "@nadicodeai/design-system": "12.1.107",
     "@tanstack/react-table": "^9.2.8",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
@@ -124,8 +124,8 @@
     "eslint": "^9.39.4",
     "jsdom": "^30.1.2",
     "postcss": "^8.5.29",
-    "react": "19.3.0",
-    "react-dom": "19.3.0",
+    "react": "19.3.1",
+    "react-dom": "19.3.1",
     "shadcn": "4.21.0",
     "tailwindcss": "^4.3.3",
     "typescript": "^6",