feat: add readNearest* and findNearest* utilities (#3)

danielroe · pi0 · web-flow · commit fe5997eac05c · 2021-10-26T20:15:31.000+02:00
Co-authored-by: Pooya Parsa &lt;pyapar@gmail.com&gt;
diff --git a/README.md b/README.md
@@ -34,6 +34,24 @@ import { writePackageJSON } from 'pkg-types'
 await writePackageJSON('path/to/package.json', pkg)
 ```
 
+### `findNearestPackageJSON`
+
+```js
+import { findNearestPackageJSON } from 'pkg-types'
+const filename = await findNearestPackageJSON()
+// or
+const packageJson = await findNearestPackageJSON('/fully/resolved/path/to/folder')
+```
+
+### `readNearestPackageJSON`
+
+```js
+import { readNearestPackageJSON } from 'pkg-types'
+const filename = await readNearestPackageJSON()
+// or
+const packageJson = await readNearestPackageJSON('/fully/resolved/path/to/folder')
+```
+
 ### `readTSConfig`
 
 ```js
@@ -50,6 +68,35 @@ import { writeTSConfig } from 'pkg-types'
 await writeTSConfig('path/to/tsconfig.json', tsconfig)
 ```
 
+### `findNearestTSConfig`
+
+```js
+import { findNearestTSConfig } from 'pkg-types'
+const filename = await findNearestTSConfig()
+// or
+const tsconfig = await findNearestTSConfig('/fully/resolved/path/to/folder')
+```
+
+### `readNearestTSConfig`
+
+```js
+import { readNearestTSConfig } from 'pkg-types'
+const filename = await readNearestTSConfig()
+// or
+const tsconfig = await readNearestTSConfig('/fully/resolved/path/to/folder')
+```
+
+### `findNearestFile`
+
+```js
+import { findNearestFile } from 'pkg-types'
+const filename = await findNearestFile('README.md', {
+  startingFrom: id,
+  rootPattern: /^node_modules$/,
+  matcher: filename => filename.endsWith('.md'),
+})
+```
+
 ## Types
 
 **Note:** In order to make types working, you need to install `typescript` as a devDependency.
diff --git a/package.json b/package.json
@@ -17,10 +17,11 @@
     "build": "unbuild",
     "release": "standard-version && npm publish && git push --follow-tags",
     "test": "mocha -r jiti/register ./test/**/*.test.*",
-    "test:types": "tsc --noEmit --module esnext --moduleResolution node ./test/*.test.ts"
+    "test:types": "tsc --noEmit --module esnext --skipLibCheck --moduleResolution node ./test/*.test.ts"
   },
   "dependencies": {
-    "jsonc-parser": "^3.0.0"
+    "jsonc-parser": "^3.0.0",
+    "pathe": "^0.2.0"
   },
   "devDependencies": {
     "@types/chai": "^4.2.22",
diff --git a/src/fs.ts b/src/fs.ts
@@ -0,0 +1,82 @@
+import { statSync } from 'fs'
+import { join, resolve } from 'pathe'
+import { PackageJson, readPackageJSON, readTSConfig, TSConfig } from '.'
+
+export interface FindNearestFileOptions {
+  /**
+   * The starting directory for the search.
+   * @default . (same as `process.cwd()`)
+   */
+  startingFrom?: string
+  /**
+   * A pattern to match a path segment above which you don't want to ascend
+   * @default /^node_modules$/
+   */
+  rootPattern?: RegExp
+  /**
+   * A matcher that can evaluate whether the given path is a valid file (for example,
+   * by testing whether the file path exists.
+   *
+   * @default fs.statSync(path).isFile()
+   */
+  test?: (filePath: string) => boolean | null | Promise<boolean | null>
+}
+
+const defaultFindOptions: Required<FindNearestFileOptions> = {
+  startingFrom: '.',
+  rootPattern: /^node_modules$/,
+  test: (filePath: string) => {
+    try {
+      if (statSync(filePath).isFile()) { return true }
+    } catch { }
+    return null
+  }
+}
+
+export async function findNearestFile (filename: string, _options: FindNearestFileOptions = {}) {
+  const options = { ...defaultFindOptions, ..._options }
+  const basePath = resolve(options.startingFrom)
+  const leadingSlash = basePath[0] === '/'
+  const segments = basePath.split('/').filter(Boolean)
+
+  // Restore leading slash
+  if (leadingSlash) {
+    segments[0] = '/' + segments[0]
+  }
+
+  // Limit to node_modules scope if it exists
+  let root = segments.findIndex(r => r.match(options.rootPattern))
+  if (root === -1) root = 0
+
+  for (let i = segments.length; i > root; i--) {
+    const filePath = join(...segments.slice(0, i), filename)
+    if (await options.test(filePath)) { return filePath }
+  }
+
+  return null
+}
+
+export async function findNearestPackageJSON (id: string = process.cwd()): Promise<string | null> {
+  return findNearestFile('package.json', { startingFrom: id })
+}
+
+export async function findNearestTSConfig (id: string = process.cwd()): Promise<string | null> {
+  return findNearestFile('tsconfig.json', { startingFrom: id })
+}
+
+export async function readNearestPackageJSON (id?: string): Promise<PackageJson | null> {
+  const filePath = await findNearestPackageJSON(id)
+
+  if (!filePath) { return null }
+
+  return readPackageJSON(filePath)
+}
+
+export async function readNearestTSConfig (id?: string): Promise<TSConfig | null> {
+  const filePath = await findNearestTSConfig(id)
+
+  if (!filePath) { return null }
+
+  return readTSConfig(filePath)
+}
+
diff --git a/src/index.ts b/src/index.ts
@@ -3,6 +3,7 @@ import { promises as fsp } from 'fs'
 import type { PackageJson, TSConfig } from './types'
 
 export * from './types'
+export * from './fs'
 
 export function definePackageJSON(pkg: PackageJson): PackageJson {
   return pkg
diff --git a/test/fs.test.ts b/test/fs.test.ts
@@ -0,0 +1,57 @@
+import { fileURLToPath } from 'url'
+import { dirname, resolve } from 'path'
+import { expect } from 'chai'
+import {
+  readNearestPackageJSON,
+  readNearestTSConfig,
+  findNearestPackageJSON,
+  findNearestTSConfig,
+  PackageJson,
+  TSConfig,
+} from '../src'
+
+
+const fixtureDir = resolve(dirname(fileURLToPath(import.meta.url)), 'fixture')
+
+const rFixture = (...p: string[]) => resolve(fixtureDir, ...p)
+
+const tests = {
+  'tsconfig.json': [readNearestTSConfig, findNearestTSConfig],
+  'package.json': [readNearestPackageJSON, findNearestPackageJSON]
+} as const
+for (const filename in tests) {
+  const [read, find] = tests[filename as 'tsconfig.json']
+  describe(find.name, () => {
+    it('finds a package.json in root directory', async () => {
+      const pkgPath = await find(rFixture('.'))
+      expect(pkgPath).to.equal(rFixture(filename))
+    })
+    it('handles non-existent paths', async () => {
+      const pkgPath = await find(rFixture('further', 'dir', 'file.json'))
+      expect(pkgPath).to.equal(rFixture(filename))
+    })
+    it('works all the way up the tree', async () => {
+      const pkgPath = await find('/a/full/nonexistent/path')
+      expect(pkgPath).to.equal(null)
+    })
+    it('stops at `node_modules`', async () => {
+      const pkgPath = await find(rFixture('further', 'node_modules', 'file.json'))
+      expect(pkgPath).to.equal(null)
+    })
+    it(`finds the working directory ${filename}`, async () => {
+      const pkgPath = await find()
+      expect(pkgPath).to.equal(rFixture('../..', filename))
+    })
+  })
+
+  describe(read.name, () => {
+    it('correctly reads a package', async () => {
+      const data = await read(rFixture(filename))
+      if (filename === 'package.json') {
+        expect((data as PackageJson).name).to.equal('foo')
+      } else {
+        expect((data as TSConfig).include).to.contain('src')
+      }
+    })
+  })
+}
