feat(lib): createParseConfigHost

Signed-off-by: Lexus Drumgold <[email protected]>

Author: unicornware

README.md

@@ -82,6 +82,7 @@ import {
 This package exports the following identifiers:
 
 - [`createModuleResolutionHost`](./src/lib/create-module-resolution-host.mts)
+- [`createParseConfigHost`](./src/lib/create-parse-config-host.mts)
 - [`isResolvedTsconfig`](./src/lib/is-resolved-tsconfig.mts)
 - [`isTsconfigHost`](./src/lib/is-tsconfig-host.mts)
 - [`loadTsconfig`](./src/lib/load-tsconfig.mts)

src/__snapshots__/index.e2e.snap

@@ -3,6 +3,7 @@
 exports[`e2e:tsconfig-utils > should expose public api 1`] = `
 [
   "createModuleResolutionHost",
+  "createParseConfigHost",
   "isResolvedTsconfig",
   "isTsconfigHost",
   "loadTsconfig",

src/interfaces/options-load-tsconfig.mts

@@ -23,9 +23,7 @@ interface LoadTsconfigOptions extends ReadTsconfigOptions {
    *    'compilerOptions.paths.*',
    *    'compilerOptions.paths.*.*',
    *    'compilerOptions.rootDir',
-   *    'exclude.*',
-   *    'files.*',
-   *    'include.*'
+   *    'files.*'
    *  ])
    */
   relativePaths?: Set<string> | readonly string[] | null | undefined

src/lib/__snapshots__/load-tsconfig.snap

@@ -50,9 +50,9 @@ exports[`unit:lib/loadTsconfig > should return resolved tsconfig object 1`] = `
       "verbatimModuleSyntax": true,
     },
     "exclude": [
-      "./coverage",
-      "./dist",
-      "./node_modules",
+      "coverage",
+      "dist",
+      "node_modules",
     ],
     "include": [
       "**/**.json",

src/lib/__tests__/create-parse-config-host.spec.mts

@@ -0,0 +1,74 @@
+/**
+ * @file Unit Tests - createParseConfigHost
+ * @module tsconfig-utils/lib/tests/unit/createParseConfigHost
+ */
+
+import fs from '#internal/fs'
+import testSubject from '#lib/create-parse-config-host'
+import * as mlly from '@flex-development/mlly'
+import type { ParseConfigHost } from '@flex-development/tsconfig-utils'
+import { alphabetize, identity } from '@flex-development/tutils'
+import ts from 'typescript'
+import tsconfig from '../../../tsconfig.json' with { type: 'json' }
+
+describe('unit:lib/createParseConfigHost', () => {
+  let subject: ParseConfigHost
+
+  beforeAll(() => {
+    subject = testSubject()
+  })
+
+  describe('host', () => {
+    describe('readDirectory', () => {
+      it.each<Parameters<ParseConfigHost['readDirectory']>>([
+        [
+          new URL('src', mlly.cwd()),
+          ['.cjs', '.cts', '.js', '.json', '.mjs', '.mts', '.ts'],
+          tsconfig.exclude,
+          tsconfig.include,
+          0
+        ],
+        [
+          mlly.cwd(),
+          ['.cjs', '.cts', '.js', '.json', '.mjs', '.mts', '.ts'],
+          tsconfig.exclude,
+          tsconfig.include
+        ],
+        [
+          mlly.cwd(),
+          ['.mjs', '.mts', '.ts'],
+          tsconfig.exclude,
+          tsconfig.include,
+          1
+        ]
+      ])('should return list of files under directory at `id` (%#)', (
+        id,
+        extensions,
+        exclude,
+        include,
+        depth
+      ) => {
+        // Arrange
+        const expected: readonly string[] = alphabetize(ts.sys.readDirectory(
+          fs.realpath(id),
+          extensions ? [...extensions] : undefined,
+          exclude ? [...exclude] : undefined,
+          include ? [...include] : undefined,
+          depth ?? undefined
+        ), identity)
+
+        // Act
+        const result = subject.readDirectory(
+          id,
+          extensions,
+          exclude,
+          include,
+          depth
+        )
+
+        // Expect
+        expect(result).to.be.an('array').and.be.frozen.and.eql(expected)
+      })
+    })
+  })
+})

src/lib/create-module-resolution-host.mts

@@ -115,7 +115,8 @@ function createModuleResolutionHost(
       id = pathe.toPath(id)
 
       names = fs.readdir(id).filter(x => {
-        return directoryExists(pathe.join(id as string, x))
+        ok(typeof id === 'string', 'expected `id` to be a string')
+        return directoryExists(pathe.join(id, x))
       })
     }
 

src/lib/create-parse-config-host.mts

@@ -0,0 +1,268 @@
+/**
+ * @file createParseConfigHost
+ * @module tsconfig-utils/lib/createParseConfigHost
+ */
+
+import dfs from '#internal/fs'
+import createModuleResolutionHost from '#lib/create-module-resolution-host'
+import type { ModuleId } from '@flex-development/mlly'
+import pathe from '@flex-development/pathe'
+import type {
+  FileSystem,
+  ModuleResolutionHost,
+  ParseConfigHost
+} from '@flex-development/tsconfig-utils'
+import { alphabetize, fork, identity } from '@flex-development/tutils'
+import { ok } from 'devlop'
+
+export default createParseConfigHost
+
+/**
+ * Union of path types.
+ *
+ * @internal
+ */
+type PathType = 'directory' | 'file'
+
+/**
+ * Create a parse config host.
+ *
+ * @see {@linkcode FileSystem}
+ * @see {@linkcode ParseConfigHost}
+ *
+ * @this {void}
+ *
+ * @param {FileSystem | null | undefined} [fs]
+ *  File system API
+ * @return {ParseConfigHost}
+ *  Parse config host object
+ */
+function createParseConfigHost(
+  this: void,
+  fs?: FileSystem | null | undefined
+): ParseConfigHost {
+  fs ??= dfs
+
+  /**
+   * Module resolution host object.
+   *
+   * @const {ModuleResolutionHost} host
+   */
+  const host: ModuleResolutionHost = createModuleResolutionHost(fs)
+
+  return {
+    directoryExists: host.directoryExists,
+    fileExists: host.fileExists,
+    getCurrentDirectory: pathe.cwd,
+    getDirectories: host.getDirectories,
+    readDirectory,
+    readFile: host.readFile,
+    realpath: host.realpath,
+    useCaseSensitiveFileNames: false
+  }
+
+  /**
+   * Get a list of files in a directory.
+   *
+   * @this {void}
+   *
+   * @param {ModuleId} id
+   *  The directory path or URL to read
+   * @param {Set<string> | ReadonlyArray<string> | undefined} [extensions]
+   *  List of file extensions to filter for
+   * @param {Set<string> | ReadonlyArray<string> | undefined} [exclude]
+   *  List of of glob patterns matching files to exclude
+   * @param {Set<string> | ReadonlyArray<string> | undefined} [include]
+   *  List of of glob patterns matching files to include
+   * @param {number | null | undefined} [depth]
+   *  Maximum search depth (inclusive)
+   * @return {ReadonlyArray<string>}
+   *  List of files under directory at `id`
+   */
+  function readDirectory(
+    this: void,
+    id: ModuleId,
+    extensions: Set<string> | readonly string[] | undefined,
+    exclude: Set<string> | readonly string[] | undefined,
+    include: Set<string> | readonly string[] | undefined,
+    depth?: number | null | undefined
+  ): readonly string[] {
+    id = host.realpath(id)
+
+    /**
+     * Record of glob patterns matching directories and files to exclude.
+     *
+     * @const {Record<PathType, Set<string>>} ignore
+     */
+    const ignore: Record<PathType, Set<string>> = {
+      directory: new Set<string>(),
+      file: new Set<string>()
+    }
+
+    /**
+     * List of matched files.
+     *
+     * @const {string[]} matched
+     */
+    const matched: string[] = []
+
+    /**
+     * Record of glob patterns matching directories and files to include.
+     *
+     * @const {Record<PathType, Set<string>>} matchers
+     */
+    const matchers: Record<PathType, Set<string>> = {
+      directory: new Set<string>(),
+      file: new Set<string>()
+    }
+
+    /**
+     * Visited paths.
+     *
+     * @const {Set<string>} visited
+     */
+    const visited: Set<string> = new Set<string>()
+
+    pstore(ignore, exclude)
+    pstore(matchers, include)
+
+    if (!matchers.directory.size) matchers.directory.add('**/*')
+
+    matchers.directory.add('bower_components')
+    matchers.directory.add('node_modules')
+    matchers.directory.add('jspm_packages')
+
+    visit(id, '', depth)
+
+    return Object.freeze(alphabetize(matched, identity))
+
+    /**
+     * Check if `x` is a matched directory or file.
+     *
+     * @this {void}
+     *
+     * @param {string} x
+     *  The path to match
+     * @param {PathType} type
+     *  Path type
+     * @return {boolean}
+     *  `true` if `x` matches include pattern and is not excluded
+     */
+    function filter(this: void, x: string, type: PathType): boolean {
+      return pathe.matchesGlob(x, [...matchers[type]], {
+        dot: type === 'file',
+        ignore: [...ignore[type]]
+      })
+    }
+
+    /**
+     * Store glob paterns in `record`.
+     *
+     * If the last path segment in a pattern does not contain a file extension
+     * or wildcard character (`'*'`), it is treated as a directory pattern.
+     *
+     * @this {void}
+     *
+     * @param {Record<PathType, Set<string>>} record
+     *  Glob pattern record
+     * @param {Set<string> | ReadonlyArray<string> | undefined} patterns
+     *  List of user glob patterns
+     * @return {undefined}
+     */
+    function pstore(
+      this: void,
+      record: Record<PathType, Set<string>>,
+      patterns: Set<string> | readonly string[] | undefined = []
+    ): undefined {
+      for (const pattern of patterns) {
+        /**
+         * Last segment of {@linkcode pattern}.
+         *
+         * @const {string} segment
+         */
+        const segment: string = pathe.basename(pattern)
+
+        if (!pathe.extname(segment) && !segment.includes('*')) {
+          record.directory.add(pattern)
+        } else {
+          record.file.add(pattern)
+        }
+      }
+
+      return void this
+    }
+
+    /**
+     * Visit the directory at `path` and store matched files.
+     *
+     * @this {void}
+     *
+     * @param {string} path
+     *  Absolute directory path
+     * @param {string} relpath
+     *  Relative directory path
+     * @param {number | null | undefined} depth
+     *  Maximum search depth (inclusive)
+     * @return {undefined}
+     */
+    function visit(
+      this: void,
+      path: string,
+      relpath: string,
+      depth: number | null | undefined
+    ): undefined {
+      ok(fs, 'expected `fs`')
+
+      if (host.directoryExists(path) && !visited.has(path)) {
+        visited.add(path)
+
+        /**
+         * List where the first item is a list of files under {@linkcode path},
+         * and the last item a list of subdirectories.
+         *
+         * @const {[string[], string[]]} pack
+         */
+        const pack: [string[], string[]] = fork(
+          fs.readdir(path),
+          x => host.fileExists(pathe.join(path, x))
+        )
+
+        for (const file of pack[0]) {
+          /**
+           * File matched?
+           *
+           * @var {boolean} match
+           */
+          let match: boolean = filter(pathe.join(relpath, file), 'file')
+
+          if (extensions) {
+            extensions = [...extensions].map(pathe.formatExt)
+            match = match && extensions.includes(pathe.extname(file))
+          }
+
+          if (match) matched.push(pathe.join(path, file))
+        }
+
+        if (depth) {
+          depth--
+          if (!depth) return void depth
+        }
+
+        for (const subdirectory of pack[1]) {
+          /**
+           * Relative subdirectory path.
+           *
+           * @const {string} subdir
+           */
+          const subdir: string = pathe.join(relpath, subdirectory)
+
+          if (filter(subdir, 'directory')) {
+            visit(pathe.join(path, subdirectory), subdir, depth)
+          }
+        }
+      }
+
+      return void path
+    }
+  }
+}