zile 0.0.0 → 0.0.2

package/src/Packages.test.ts

@@ -0,0 +1,222 @@
+import path from 'node:path'
+import { setupRepos } from '../test/utils.js'
+import * as Packages from './Packages.js'
+
+const cwd = path.resolve(import.meta.dirname, '..')
+
+describe('Packages.find', () => {
+  function relative(absolutePaths: string[]): string[] {
+    return absolutePaths.map((p) => `/${path.relative(cwd, p)}`)
+  }
+
+  it('finds all packages under a given `cwd`', async () => {
+    const result = await Packages.find({
+      cwd,
+    })
+
+    expect(relative(result)).toMatchInlineSnapshot(`
+      [
+        "/",
+        "/test/repos/single-entrypoint",
+        "/test/repos/multiple-entrypoint",
+        "/test/repos/error-module-resolution",
+        "/test/repos/error-missing-entry-fields",
+        "/test/repos/error-main-not-exists",
+        "/test/repos/error-exports-string-not-exists",
+        "/test/repos/error-exports-object-not-exists",
+        "/test/repos/error-bin-string-not-exists",
+        "/test/repos/error-bin-object-not-exists",
+        "/test/repos/basic-object-exports",
+        "/test/repos/basic",
+        "/src/internal",
+      ]
+    `)
+  })
+
+  it('finds all packages under an alternate `cwd`', async () => {
+    const result = await Packages.find({
+      cwd: path.resolve(import.meta.dirname, '../test'),
+    })
+
+    expect(relative(result)).toMatchInlineSnapshot(`
+      [
+        "/test/repos/single-entrypoint",
+        "/test/repos/multiple-entrypoint",
+        "/test/repos/error-module-resolution",
+        "/test/repos/error-missing-entry-fields",
+        "/test/repos/error-main-not-exists",
+        "/test/repos/error-exports-string-not-exists",
+        "/test/repos/error-exports-object-not-exists",
+        "/test/repos/error-bin-string-not-exists",
+        "/test/repos/error-bin-object-not-exists",
+        "/test/repos/basic-object-exports",
+        "/test/repos/basic",
+      ]
+    `)
+  })
+
+  it('finds packages in specific directory', async () => {
+    const result = await Packages.find({
+      cwd,
+      includes: ['test/repos/basic'],
+    })
+
+    expect(relative(result)).toMatchInlineSnapshot(`
+      [
+        "/test/repos/basic",
+      ]
+    `)
+  })
+
+  it('finds packages with pattern ending in package.json', async () => {
+    const result = await Packages.find({
+      cwd,
+      includes: ['test/repos/basic/package.json'],
+    })
+
+    expect(relative(result)).toMatchInlineSnapshot(`
+      [
+        "/test/repos/basic",
+      ]
+    `)
+  })
+
+  it('finds packages with wildcard pattern', async () => {
+    const result = await Packages.find({
+      cwd,
+      includes: ['test/repos/*'],
+    })
+
+    expect(relative(result)).toMatchInlineSnapshot(`
+      [
+        "/test/repos/single-entrypoint",
+        "/test/repos/multiple-entrypoint",
+        "/test/repos/error-module-resolution",
+        "/test/repos/error-missing-entry-fields",
+        "/test/repos/error-main-not-exists",
+        "/test/repos/error-exports-string-not-exists",
+        "/test/repos/error-exports-object-not-exists",
+        "/test/repos/error-bin-string-not-exists",
+        "/test/repos/error-bin-object-not-exists",
+        "/test/repos/basic-object-exports",
+        "/test/repos/basic",
+      ]
+    `)
+  })
+
+  it('deduplicates results from multiple patterns', async () => {
+    const result = await Packages.find({
+      cwd,
+      includes: ['test/repos/basic', 'test/repos/basic/package.json'],
+    })
+
+    expect(relative(result)).toMatchInlineSnapshot(`
+      [
+        "/test/repos/basic",
+      ]
+    `)
+  })
+
+  it('returns empty array when no packages found', async () => {
+    const result = await Packages.find({
+      cwd,
+      includes: ['nonexistent'],
+    })
+
+    expect(relative(result)).toMatchInlineSnapshot(`[]`)
+  })
+
+  it('returns absolute paths', async () => {
+    const result = await Packages.find({
+      cwd,
+      includes: ['test/repos/basic'],
+    })
+
+    expect(result.length).toBeGreaterThan(0)
+    expect(path.isAbsolute(result[0])).toBe(true)
+  })
+
+  it('uses process.cwd() when no cwd provided', async () => {
+    const originalCwd = process.cwd()
+    const testDir = path.join(cwd, 'test/repos/basic')
+    process.chdir(testDir)
+
+    const result = await Packages.find()
+
+    process.chdir(originalCwd)
+
+    expect(relative(result)).toMatchInlineSnapshot(`
+      [
+        "/test/repos/basic",
+      ]
+    `)
+  })
+
+  it('uses default includes when not provided', async () => {
+    const result = await Packages.find({
+      cwd,
+    })
+
+    expect(relative(result)).toMatchInlineSnapshot(`
+      [
+        "/",
+        "/test/repos/single-entrypoint",
+        "/test/repos/multiple-entrypoint",
+        "/test/repos/error-module-resolution",
+        "/test/repos/error-missing-entry-fields",
+        "/test/repos/error-main-not-exists",
+        "/test/repos/error-exports-string-not-exists",
+        "/test/repos/error-exports-object-not-exists",
+        "/test/repos/error-bin-string-not-exists",
+        "/test/repos/error-bin-object-not-exists",
+        "/test/repos/basic-object-exports",
+        "/test/repos/basic",
+        "/src/internal",
+      ]
+    `)
+  })
+
+  it('excludes node_modules by default', async () => {
+    const result = await Packages.find({
+      cwd,
+    })
+
+    const hasNodeModules = relative(result).some((p) => p.includes('node_modules'))
+    expect(hasNodeModules).toBe(false)
+  })
+
+  it('can include node_modules without excludes', async () => {
+    const result = await Packages.find({
+      cwd,
+      includes: ['node_modules/@types/node'],
+    })
+
+    expect(relative(result)).toMatchInlineSnapshot(`
+      [
+        "/node_modules/@types/node",
+      ]
+    `)
+  })
+
+  it('handles excludes', async () => {
+    const result = await Packages.find({
+      cwd,
+      includes: ['test/**', '!test/repos'],
+    })
+
+    expect(relative(result)).toMatchInlineSnapshot(`[]`)
+  })
+})
+
+describe('Packages.build', () => {
+  it('builds all packages', async () => {
+    const { cwd } = await setupRepos()
+
+    const result = await Packages.build({
+      cwd,
+      includes: ['**', '!**/error-*', '!**/node_modules/**'],
+    })
+
+    expect(result).toMatchSnapshot()
+  })
+})

package/src/Packages.ts

@@ -0,0 +1,65 @@
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
+import * as Package from './Package.js'
+
+/**
+ * Builds all packages in the given working directory.
+ *
+ * @param options - Options for building packages
+ */
+export async function build(options: build.Options) {
+  const packages = await find(options)
+  return await Promise.all(packages.map((cwd) => Package.build({ cwd })))
+}
+
+export declare namespace build {
+  type Options = find.Options
+}
+
+/**
+ * Finds all packages (containing a `package.json`) matching
+ * the given working directory.
+ *
+ * @param options - Options for finding packages
+ * @returns Array of absolute paths to package directories
+ */
+export async function find(options: find.Options = {}) {
+  const cwd = options.cwd ?? process.cwd()
+  const patterns = options.includes ?? ['**', '!**/node_modules/**']
+
+  // Separate includes and excludes from patterns
+  const includes: string[] = []
+  const excludes: string[] = []
+
+  for (const pattern of patterns) {
+    if (pattern.startsWith('!')) excludes.push(pattern.slice(1))
+    else includes.push(pattern)
+  }
+
+  const packageSet = new Set<string>()
+
+  for (const pattern of includes) {
+    // Find all package.json files matching the pattern
+    const globPattern = (() => {
+      if (path.basename(pattern) === 'package.json') return pattern
+      return path.join(pattern, 'package.json')
+    })()
+
+    for await (const file of fs.glob(globPattern, { cwd, exclude: excludes })) {
+      const dir = path.dirname(file)
+      const absolutePath = path.resolve(cwd, dir)
+      packageSet.add(absolutePath)
+    }
+  }
+
+  return Array.from(packageSet)
+}
+
+export declare namespace find {
+  type Options = {
+    /** Working directory to start searching from. @default process.cwd() */
+    cwd?: string | undefined
+    /** Glob patterns to include. @default ['**'] */
+    includes?: string[] | undefined
+  }
+}