@eslint-config-snapshot/api 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @eslint-config-snapshot/api
 
+## 1.1.0
+
+### Minor Changes
+
+- Minor release: improve skipped workspace messaging and OSS compatibility documentation.
+
 ## 1.0.0
 
 ### Major Changes

package/dist/index.cjs

@@ -104,27 +104,117 @@ function normalizeSeverity(value) {
 
 // src/workspace.ts
 var import_get_packages = require("@manypkg/get-packages");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_promises = require("fs/promises");
 var import_node_path = __toESM(require("path"), 1);
 var import_picomatch = __toESM(require("picomatch"), 1);
 async function discoverWorkspaces(options) {
   const cwd = options?.cwd ? import_node_path.default.resolve(options.cwd) : process.cwd();
   const workspaceInput = options?.workspaceInput ?? { mode: "discover" };
   if (workspaceInput.mode === "manual") {
-    const rootAbs2 = import_node_path.default.resolve(workspaceInput.rootAbs ?? cwd);
+    const rootAbs = import_node_path.default.resolve(workspaceInput.rootAbs ?? cwd);
     return {
-      rootAbs: rootAbs2,
+      rootAbs,
       workspacesRel: sortUnique(workspaceInput.workspaces)
     };
   }
-  const { rootDir, packages } = await (0, import_get_packages.getPackages)(cwd);
-  const workspacesAbs = packages.map((pkg) => pkg.dir);
-  const rootAbs = rootDir ? import_node_path.default.resolve(rootDir) : lowestCommonAncestor(workspacesAbs);
-  const workspacesRel = sortUnique(workspacesAbs.map((entry) => normalizePath(import_node_path.default.relative(rootAbs, entry))));
+  try {
+    const { rootDir, packages } = await (0, import_get_packages.getPackages)(cwd);
+    const workspacesAbs = packages.map((pkg) => pkg.dir);
+    const rootAbs = rootDir ? import_node_path.default.resolve(rootDir) : lowestCommonAncestor(workspacesAbs);
+    const workspacesRel = sortUnique(workspacesAbs.map((entry) => normalizePath(import_node_path.default.relative(rootAbs, entry))));
+    if (workspacesRel.length > 1 || workspacesRel.length === 1 && workspacesRel[0] !== ".") {
+      return {
+        rootAbs,
+        workspacesRel
+      };
+    }
+    const packageJsonFallback2 = await discoverWorkspacesFromPackageJson(cwd);
+    if (packageJsonFallback2 && packageJsonFallback2.workspacesRel.length > 0) {
+      return packageJsonFallback2;
+    }
+    if (workspacesRel.length > 0) {
+      return {
+        rootAbs,
+        workspacesRel
+      };
+    }
+  } catch {
+  }
+  const packageJsonFallback = await discoverWorkspacesFromPackageJson(cwd);
+  if (packageJsonFallback) {
+    return packageJsonFallback;
+  }
+  return {
+    rootAbs: cwd,
+    workspacesRel: ["."]
+  };
+}
+async function discoverWorkspacesFromPackageJson(cwd) {
+  const packageJsonPath = import_node_path.default.join(cwd, "package.json");
+  const packageJsonRaw = await safeReadFile(packageJsonPath);
+  if (!packageJsonRaw) {
+    return null;
+  }
+  const parsed = safeJsonParse(packageJsonRaw);
+  if (!isObjectRecord(parsed) || Array.isArray(parsed)) {
+    return null;
+  }
+  const workspaceGlobs = extractWorkspaceGlobs(parsed);
+  if (workspaceGlobs.length === 0) {
+    return null;
+  }
+  const workspacePackageJsonGlobs = workspaceGlobs.map((entry) => normalizePath(import_node_path.default.posix.join(entry, "package.json")));
+  const foundPackageJsonFiles = await (0, import_fast_glob.default)(workspacePackageJsonGlobs, {
+    cwd,
+    onlyFiles: true,
+    dot: true,
+    unique: true,
+    ignore: ["**/node_modules/**"]
+  });
+  const workspacesRel = sortUnique(foundPackageJsonFiles.map((entry) => normalizePath(import_node_path.default.posix.dirname(entry))));
+  if (workspacesRel.length === 0) {
+    return {
+      rootAbs: cwd,
+      workspacesRel: ["."]
+    };
+  }
   return {
-    rootAbs,
+    rootAbs: cwd,
     workspacesRel
   };
 }
+async function safeReadFile(filePath) {
+  try {
+    return await (0, import_promises.readFile)(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function safeJsonParse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function isObjectRecord(value) {
+  return value !== null && typeof value === "object";
+}
+function extractWorkspaceGlobs(packageJson) {
+  const workspaces = packageJson.workspaces;
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter((entry) => typeof entry === "string");
+  }
+  if (!workspaces || typeof workspaces !== "object" || Array.isArray(workspaces)) {
+    return [];
+  }
+  const packages = workspaces.packages;
+  if (Array.isArray(packages)) {
+    return packages.filter((entry) => typeof entry === "string");
+  }
+  return [];
+}
 function assignGroupsByMatch(workspacesRel, groups) {
   const sortedWorkspaces = sortUnique([...workspacesRel]);
   const assignments = /* @__PURE__ */ new Map();
@@ -186,11 +276,11 @@ function lowestCommonAncestor(paths) {
 
 // src/sampling.ts
 var import_debug = __toESM(require("debug"), 1);
-var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_fast_glob2 = __toESM(require("fast-glob"), 1);
 var debugSampling = (0, import_debug.default)("eslint-config-snapshot:sampling");
 async function sampleWorkspaceFiles(workspaceAbs, config) {
   const startedAt = Date.now();
-  const all = await (0, import_fast_glob.default)(config.includeGlobs, {
+  const all = await (0, import_fast_glob2.default)(config.includeGlobs, {
     cwd: workspaceAbs,
     ignore: config.excludeGlobs,
     onlyFiles: true,
@@ -727,7 +817,7 @@ function normalizeRuleEntry(raw) {
 }
 
 // src/snapshot.ts
-var import_promises = require("fs/promises");
+var import_promises2 = require("fs/promises");
 var import_node_path3 = __toESM(require("path"), 1);
 function aggregateRules(ruleMaps) {
   const aggregated = /* @__PURE__ */ new Map();
@@ -763,16 +853,16 @@ function buildSnapshot(groupId, workspaces, rules) {
   };
 }
 async function writeSnapshotFile(snapshotDirAbs, snapshot) {
-  await (0, import_promises.mkdir)(snapshotDirAbs, { recursive: true });
+  await (0, import_promises2.mkdir)(snapshotDirAbs, { recursive: true });
   const filePath = import_node_path3.default.join(snapshotDirAbs, `${snapshot.groupId}.json`);
-  await (0, import_promises.mkdir)(import_node_path3.default.dirname(filePath), { recursive: true });
+  await (0, import_promises2.mkdir)(import_node_path3.default.dirname(filePath), { recursive: true });
   const payload = JSON.stringify(snapshot, null, 2);
-  await (0, import_promises.writeFile)(filePath, `${payload}
+  await (0, import_promises2.writeFile)(filePath, `${payload}
 `, "utf8");
   return filePath;
 }
 async function readSnapshotFile(fileAbs) {
-  const raw = await (0, import_promises.readFile)(fileAbs, "utf8");
+  const raw = await (0, import_promises2.readFile)(fileAbs, "utf8");
   return JSON.parse(raw);
 }
 function toVariantKey(entry) {

package/dist/index.js

@@ -47,27 +47,117 @@ function normalizeSeverity(value) {
 
 // src/workspace.ts
 import { getPackages } from "@manypkg/get-packages";
+import fg from "fast-glob";
+import { readFile } from "fs/promises";
 import path from "path";
 import picomatch from "picomatch";
 async function discoverWorkspaces(options) {
   const cwd = options?.cwd ? path.resolve(options.cwd) : process.cwd();
   const workspaceInput = options?.workspaceInput ?? { mode: "discover" };
   if (workspaceInput.mode === "manual") {
-    const rootAbs2 = path.resolve(workspaceInput.rootAbs ?? cwd);
+    const rootAbs = path.resolve(workspaceInput.rootAbs ?? cwd);
     return {
-      rootAbs: rootAbs2,
+      rootAbs,
       workspacesRel: sortUnique(workspaceInput.workspaces)
     };
   }
-  const { rootDir, packages } = await getPackages(cwd);
-  const workspacesAbs = packages.map((pkg) => pkg.dir);
-  const rootAbs = rootDir ? path.resolve(rootDir) : lowestCommonAncestor(workspacesAbs);
-  const workspacesRel = sortUnique(workspacesAbs.map((entry) => normalizePath(path.relative(rootAbs, entry))));
+  try {
+    const { rootDir, packages } = await getPackages(cwd);
+    const workspacesAbs = packages.map((pkg) => pkg.dir);
+    const rootAbs = rootDir ? path.resolve(rootDir) : lowestCommonAncestor(workspacesAbs);
+    const workspacesRel = sortUnique(workspacesAbs.map((entry) => normalizePath(path.relative(rootAbs, entry))));
+    if (workspacesRel.length > 1 || workspacesRel.length === 1 && workspacesRel[0] !== ".") {
+      return {
+        rootAbs,
+        workspacesRel
+      };
+    }
+    const packageJsonFallback2 = await discoverWorkspacesFromPackageJson(cwd);
+    if (packageJsonFallback2 && packageJsonFallback2.workspacesRel.length > 0) {
+      return packageJsonFallback2;
+    }
+    if (workspacesRel.length > 0) {
+      return {
+        rootAbs,
+        workspacesRel
+      };
+    }
+  } catch {
+  }
+  const packageJsonFallback = await discoverWorkspacesFromPackageJson(cwd);
+  if (packageJsonFallback) {
+    return packageJsonFallback;
+  }
+  return {
+    rootAbs: cwd,
+    workspacesRel: ["."]
+  };
+}
+async function discoverWorkspacesFromPackageJson(cwd) {
+  const packageJsonPath = path.join(cwd, "package.json");
+  const packageJsonRaw = await safeReadFile(packageJsonPath);
+  if (!packageJsonRaw) {
+    return null;
+  }
+  const parsed = safeJsonParse(packageJsonRaw);
+  if (!isObjectRecord(parsed) || Array.isArray(parsed)) {
+    return null;
+  }
+  const workspaceGlobs = extractWorkspaceGlobs(parsed);
+  if (workspaceGlobs.length === 0) {
+    return null;
+  }
+  const workspacePackageJsonGlobs = workspaceGlobs.map((entry) => normalizePath(path.posix.join(entry, "package.json")));
+  const foundPackageJsonFiles = await fg(workspacePackageJsonGlobs, {
+    cwd,
+    onlyFiles: true,
+    dot: true,
+    unique: true,
+    ignore: ["**/node_modules/**"]
+  });
+  const workspacesRel = sortUnique(foundPackageJsonFiles.map((entry) => normalizePath(path.posix.dirname(entry))));
+  if (workspacesRel.length === 0) {
+    return {
+      rootAbs: cwd,
+      workspacesRel: ["."]
+    };
+  }
   return {
-    rootAbs,
+    rootAbs: cwd,
     workspacesRel
   };
 }
+async function safeReadFile(filePath) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function safeJsonParse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function isObjectRecord(value) {
+  return value !== null && typeof value === "object";
+}
+function extractWorkspaceGlobs(packageJson) {
+  const workspaces = packageJson.workspaces;
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter((entry) => typeof entry === "string");
+  }
+  if (!workspaces || typeof workspaces !== "object" || Array.isArray(workspaces)) {
+    return [];
+  }
+  const packages = workspaces.packages;
+  if (Array.isArray(packages)) {
+    return packages.filter((entry) => typeof entry === "string");
+  }
+  return [];
+}
 function assignGroupsByMatch(workspacesRel, groups) {
   const sortedWorkspaces = sortUnique([...workspacesRel]);
   const assignments = /* @__PURE__ */ new Map();
@@ -129,11 +219,11 @@ function lowestCommonAncestor(paths) {
 
 // src/sampling.ts
 import createDebug from "debug";
-import fg from "fast-glob";
+import fg2 from "fast-glob";
 var debugSampling = createDebug("eslint-config-snapshot:sampling");
 async function sampleWorkspaceFiles(workspaceAbs, config) {
   const startedAt = Date.now();
-  const all = await fg(config.includeGlobs, {
+  const all = await fg2(config.includeGlobs, {
     cwd: workspaceAbs,
     ignore: config.excludeGlobs,
     onlyFiles: true,
@@ -670,7 +760,7 @@ function normalizeRuleEntry(raw) {
 }
 
 // src/snapshot.ts
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
 import path3 from "path";
 function aggregateRules(ruleMaps) {
   const aggregated = /* @__PURE__ */ new Map();
@@ -715,7 +805,7 @@ async function writeSnapshotFile(snapshotDirAbs, snapshot) {
   return filePath;
 }
 async function readSnapshotFile(fileAbs) {
-  const raw = await readFile(fileAbs, "utf8");
+  const raw = await readFile2(fileAbs, "utf8");
   return JSON.parse(raw);
 }
 function toVariantKey(entry) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eslint-config-snapshot/api",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "type": "module",
   "repository": {
     "type": "git",

package/src/workspace.ts

@@ -1,4 +1,6 @@
 import { getPackages } from '@manypkg/get-packages'
+import fg from 'fast-glob'
+import { readFile } from 'node:fs/promises'
 import path from 'node:path'
 import picomatch from 'picomatch'
 
@@ -44,17 +46,122 @@ export async function discoverWorkspaces(options?: {
     }
   }
 
-  const { rootDir, packages } = await getPackages(cwd)
-  const workspacesAbs = packages.map((pkg) => pkg.dir)
-  const rootAbs = rootDir ? path.resolve(rootDir) : lowestCommonAncestor(workspacesAbs)
-  const workspacesRel = sortUnique(workspacesAbs.map((entry) => normalizePath(path.relative(rootAbs, entry))))
+  try {
+    const { rootDir, packages } = await getPackages(cwd)
+    const workspacesAbs = packages.map((pkg) => pkg.dir)
+    const rootAbs = rootDir ? path.resolve(rootDir) : lowestCommonAncestor(workspacesAbs)
+    const workspacesRel = sortUnique(workspacesAbs.map((entry) => normalizePath(path.relative(rootAbs, entry))))
+    if (workspacesRel.length > 1 || (workspacesRel.length === 1 && workspacesRel[0] !== '.')) {
+      return {
+        rootAbs,
+        workspacesRel
+      }
+    }
+
+    const packageJsonFallback = await discoverWorkspacesFromPackageJson(cwd)
+    if (packageJsonFallback && packageJsonFallback.workspacesRel.length > 0) {
+      return packageJsonFallback
+    }
+
+    if (workspacesRel.length > 0) {
+      return {
+        rootAbs,
+        workspacesRel
+      }
+    }
+  } catch {
+    // Fallback to package.json workspace patterns when package manager metadata is unavailable.
+  }
+
+  const packageJsonFallback = await discoverWorkspacesFromPackageJson(cwd)
+  if (packageJsonFallback) {
+    return packageJsonFallback
+  }
+
+  return {
+    rootAbs: cwd,
+    workspacesRel: ['.']
+  }
+}
+
+async function discoverWorkspacesFromPackageJson(cwd: string): Promise<WorkspaceDiscovery | null> {
+  const packageJsonPath = path.join(cwd, 'package.json')
+  const packageJsonRaw = await safeReadFile(packageJsonPath)
+  if (!packageJsonRaw) {
+    return null
+  }
+
+  const parsed = safeJsonParse(packageJsonRaw)
+  if (!isObjectRecord(parsed) || Array.isArray(parsed)) {
+    return null
+  }
+
+  const workspaceGlobs = extractWorkspaceGlobs(parsed)
+  if (workspaceGlobs.length === 0) {
+    return null
+  }
+
+  const workspacePackageJsonGlobs = workspaceGlobs.map((entry) => normalizePath(path.posix.join(entry, 'package.json')))
+  const foundPackageJsonFiles = await fg(workspacePackageJsonGlobs, {
+    cwd,
+    onlyFiles: true,
+    dot: true,
+    unique: true,
+    ignore: ['**/node_modules/**']
+  })
+
+  const workspacesRel = sortUnique(foundPackageJsonFiles.map((entry) => normalizePath(path.posix.dirname(entry))))
+  if (workspacesRel.length === 0) {
+    return {
+      rootAbs: cwd,
+      workspacesRel: ['.']
+    }
+  }
 
   return {
-    rootAbs,
+    rootAbs: cwd,
     workspacesRel
   }
 }
 
+async function safeReadFile(filePath: string): Promise<string | null> {
+  try {
+    return await readFile(filePath, 'utf8')
+  } catch {
+    return null
+  }
+}
+
+function safeJsonParse(raw: string): unknown {
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return null
+  }
+}
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object'
+}
+
+function extractWorkspaceGlobs(packageJson: Record<string, unknown>): string[] {
+  const workspaces = packageJson.workspaces
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter((entry): entry is string => typeof entry === 'string')
+  }
+
+  if (!workspaces || typeof workspaces !== 'object' || Array.isArray(workspaces)) {
+    return []
+  }
+
+  const packages = (workspaces as { packages?: unknown }).packages
+  if (Array.isArray(packages)) {
+    return packages.filter((entry): entry is string => typeof entry === 'string')
+  }
+
+  return []
+}
+
 export function assignGroupsByMatch(workspacesRel: readonly string[], groups: readonly GroupDefinition[]): GroupAssignment[] {
   const sortedWorkspaces = sortUnique([...workspacesRel])
   const assignments = new Map<string, string[]>()

package/test/workspace.test.ts

@@ -1,6 +1,9 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
 import { describe, expect, it } from 'vitest'
 
-import { assignGroupsByMatch } from '../src/index.js'
+import { assignGroupsByMatch, discoverWorkspaces } from '../src/index.js'
 
 describe('assignGroupsByMatch', () => {
   it('assigns by first matching group and supports negatives', () => {
@@ -23,3 +26,46 @@ describe('assignGroupsByMatch', () => {
     )
   })
 })
+
+describe('discoverWorkspaces', () => {
+  it('falls back to package.json workspaces when package manager metadata is unavailable', async () => {
+    const root = await mkdtemp(path.join(tmpdir(), 'snapshot-workspaces-'))
+    await writeFile(
+      path.join(root, 'package.json'),
+      JSON.stringify(
+        {
+          name: 'fixture',
+          private: true,
+          workspaces: ['packages/*']
+        },
+        null,
+        2
+      )
+    )
+    await mkdir(path.join(root, 'packages/a'), { recursive: true })
+    await mkdir(path.join(root, 'packages/b'), { recursive: true })
+    await writeFile(path.join(root, 'packages/a/package.json'), JSON.stringify({ name: 'a', version: '1.0.0' }, null, 2))
+    await writeFile(path.join(root, 'packages/b/package.json'), JSON.stringify({ name: 'b', version: '1.0.0' }, null, 2))
+
+    try {
+      const discovery = await discoverWorkspaces({ cwd: root })
+      expect(discovery.rootAbs).toBe(root)
+      expect(discovery.workspacesRel).toEqual(['packages/a', 'packages/b'])
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  it('falls back to current directory when workspace discovery cannot find matches', async () => {
+    const root = await mkdtemp(path.join(tmpdir(), 'snapshot-workspaces-empty-'))
+    await writeFile(path.join(root, 'package.json'), JSON.stringify({ name: 'fixture', private: true, workspaces: ['packages/*'] }, null, 2))
+
+    try {
+      const discovery = await discoverWorkspaces({ cwd: root })
+      expect(discovery.rootAbs).toBe(root)
+      expect(discovery.workspacesRel).toEqual(['.'])
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+})