@plugjs/plug 0.0.10 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plugjs/plug",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "type": "commonjs",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",

package/src/files.ts

@@ -1,5 +1,5 @@
 import { assert } from './assert.js'
-import { AbsolutePath, assertRelativeChildPath, getAbsoluteParent, isFile, resolveAbsolutePath } from './paths.js'
+import { AbsolutePath, assertRelativeChildPath, getAbsoluteParent, resolveFile, resolveAbsolutePath } from './paths.js'
 import { mkdir, writeFile } from './utils/asyncfs.js'
 
 /** The {@link FilesBuilder} interface defines a builder for {@link Files}. */
@@ -102,7 +102,7 @@ export class Files {
           const relative = assertRelativeChildPath(instance.directory, file)
           const resolved = resolveAbsolutePath(instance.directory, file)
 
-          assert(isFile(resolved), `File "${resolved}" does not exist`)
+          assert(resolveFile(resolved), `File "${resolved}" does not exist`)
           set.add(relative)
         }
 

package/src/fork.ts

@@ -3,7 +3,7 @@ import { assert, failure } from './assert.js'
 import { runAsync } from './async.js'
 import { Files } from './files.js'
 import { $gry, $p, LogOptions, logOptions } from './log.js'
-import { AbsolutePath, isFile, requireFilename } from './paths.js'
+import { AbsolutePath, resolveFile, requireFilename } from './paths.js'
 import { install, Plug, PlugName } from './pipe.js'
 import { Run, RunImpl } from './run.js'
 
@@ -220,7 +220,7 @@ if ((process.argv[1] === requireFilename(__fileurl)) && (process.send)) {
     /* Contextualize this run, and go! */
     const result = runAsync(run, taskName, async () => {
       /* Check that we have a proper script file name */
-      assert(isFile(scriptFile), `Script file ${$p(scriptFile)} not found`)
+      assert(resolveFile(scriptFile), `Script file ${$p(scriptFile)} not found`)
       const script = await import(scriptFile)
 
       /* Figure out the constructor, in the "default" chain */

package/src/helpers.ts

@@ -1,8 +1,15 @@
+import {
+  AbsolutePath,
+  commonPath,
+  getCurrentWorkingDirectory,
+  resolveDirectory,
+  resolveFile,
+} from './paths.js'
+
 import { assert } from './assert.js'
 import { currentRun } from './async.js'
 import { Files, FilesBuilder } from './files.js'
 import { $p, log, LogLevelString } from './log.js'
-import { AbsolutePath, commonPath, getCurrentWorkingDirectory, isDirectory } from './paths.js'
 import { Pipe } from './pipe.js'
 import { FindOptions } from './run.js'
 import { rm } from './utils/asyncfs.js'
@@ -22,7 +29,7 @@ export async function rmrf(directory: string): Promise<void> {
   assert(dir !== run.buildDir,
       `Cowardly refusing to wipe build file directory ${$p(dir)}`)
 
-  if (! isDirectory(dir)) {
+  if (! resolveDirectory(dir)) {
     log.info('Directory', $p(dir), 'not found')
     return
   }
@@ -114,3 +121,13 @@ export function pipe(files: Files | Promise<Files>): Pipe & Promise<Files> {
   assert(run, 'Unable to create pipes outside a running task')
   return run.pipe(files)
 }
+
+/** Return an absolute path of the file if it exist on disk */
+export function isFile(...paths: string[]): AbsolutePath | undefined {
+  return resolveFile(resolve(...paths))
+}
+
+/** Return an absolute path of the file if it exist on disk */
+export function isDirectory(...paths: string[]): AbsolutePath | undefined {
+  return resolveDirectory(resolve(...paths))
+}

package/src/paths.ts

@@ -133,7 +133,7 @@ export function requireResolve(__fileurl: string, module: string): AbsolutePath
 
     for (const check of checks) {
       const resolved = fileURLToPath(new URL(check, url)) as AbsolutePath
-      if (isFile(resolved)) {
+      if (resolveFile(resolved)) {
         module = check
         break
       }
@@ -187,7 +187,7 @@ export function commonPath(path: AbsolutePath, ...paths: string[]): AbsolutePath
  * Resolves the specified path as an {@link AbsolutePath} and checks it is a
  * _file_, returning `undefined` if it is not.
  */
-export function isFile(path: AbsolutePath, ...paths: string[]): AbsolutePath | undefined {
+export function resolveFile(path: AbsolutePath, ...paths: string[]): AbsolutePath | undefined {
   const file = resolveAbsolutePath(path, ...paths)
   try {
     const stat = statSync(file)
@@ -202,7 +202,7 @@ export function isFile(path: AbsolutePath, ...paths: string[]): AbsolutePath | u
  * Resolves the specified path as an {@link AbsolutePath} and checks it is a
  * _directory_, returning `undefined` if it is not.
  */
-export function isDirectory(path: AbsolutePath, ...paths: string[]): AbsolutePath | undefined {
+export function resolveDirectory(path: AbsolutePath, ...paths: string[]): AbsolutePath | undefined {
   const directory = resolveAbsolutePath(path, ...paths)
   try {
     const stat = statSync(directory)

package/src/plugs/esbuild/fix-extensions.ts

@@ -1,7 +1,7 @@
 import path from 'node:path'
 
 import { Plugin } from 'esbuild'
-import { assertAbsolutePath, isFile, resolveAbsolutePath } from '../../paths.js'
+import { assertAbsolutePath, resolveFile, resolveAbsolutePath } from '../../paths.js'
 import { stat } from '../../utils/asyncfs.js'
 
 /**
@@ -61,7 +61,7 @@ export function fixExtensions(): Plugin {
 
         /* First of all, check if the _real_ filename exists */
         const resolved = resolveAbsolutePath(resolveDir, args.path)
-        if (isFile(resolved)) return { path: args.path, external: true }
+        if (resolveFile(resolved)) return { path: args.path, external: true }
 
         /*
          * Thank you TypeScript 4.7!!! If the file is ".js", ".mjs" or ".cjs" we
@@ -73,7 +73,7 @@ export function fixExtensions(): Plugin {
           const [ , name, ext ] = match
           const tspath = name + ext.replace('js', 'ts')
           const tsfile = resolveAbsolutePath(resolveDir, tspath)
-          if (isFile(tsfile)) {
+          if (resolveFile(tsfile)) {
             const newext = ext === '.mjs' ? mjs : ext === '.cjs' ? cjs : js
             return { path: name + newext, external: true }
           }

package/src/plugs/eslint/runner.ts

@@ -2,7 +2,7 @@ import { ESLint as RealESLint } from 'eslint'
 import { assert, failure } from '../../assert.js'
 import { Files } from '../../files.js'
 import { $p, ERROR, NOTICE, WARN } from '../../log.js'
-import { getCurrentWorkingDirectory, isDirectory, isFile, resolveAbsolutePath } from '../../paths.js'
+import { getCurrentWorkingDirectory, resolveDirectory, resolveFile, resolveAbsolutePath } from '../../paths.js'
 import { Plug } from '../../pipe.js'
 import { Run } from '../../run.js'
 import { readFile } from '../../utils/asyncfs.js'
@@ -34,11 +34,11 @@ export default class ESLint implements Plug<undefined> {
     const { directory, configFile } = this._options
 
     const cwd = directory ? run.resolve(directory) : getCurrentWorkingDirectory()
-    assert(isDirectory(cwd), `ESLint directory ${$p(cwd)} does not exist`)
+    assert(resolveDirectory(cwd), `ESLint directory ${$p(cwd)} does not exist`)
 
     const overrideConfigFile = configFile ? run.resolve(configFile) : undefined
     if (overrideConfigFile) {
-      assert(isFile(overrideConfigFile), `ESLint configuration ${$p(overrideConfigFile)} does not exist`)
+      assert(resolveFile(overrideConfigFile), `ESLint configuration ${$p(overrideConfigFile)} does not exist`)
     }
 
     /* Create our ESLint instance */

package/src/plugs/exec.ts

@@ -6,7 +6,7 @@ import { assert } from '../assert.js'
 import { currentRun } from '../async.js'
 import { Files } from '../files.js'
 import { $p, logOptions } from '../log.js'
-import { AbsolutePath, getCurrentWorkingDirectory, isDirectory } from '../paths.js'
+import { AbsolutePath, getCurrentWorkingDirectory, resolveDirectory } from '../paths.js'
 import { install, Plug } from '../pipe.js'
 import { Run } from '../run.js'
 import { parseOptions, ParseOptions } from '../utils/options.js'
@@ -156,18 +156,18 @@ async function spawnChild(
   } = options
 
   const childCwd = cwd ? run.resolve(cwd) : getCurrentWorkingDirectory()
-  assert(isDirectory(childCwd), `Current working directory ${$p(childCwd)} does not exist`)
+  assert(resolveDirectory(childCwd), `Current working directory ${$p(childCwd)} does not exist`)
 
   // Figure out the PATH environment variable
   const childPaths: AbsolutePath[] = []
 
   // The `.../node_modules/.bin` path relative to the current working dir */
   const baseNodePath = run.resolve('@node_modules', '.bin')
-  if (isDirectory(baseNodePath)) childPaths.push(baseNodePath)
+  if (resolveDirectory(baseNodePath)) childPaths.push(baseNodePath)
 
   // The `.../node_bodules/.bin` path relative to the buildDir */
   const buildNodePath = run.resolve('./node_modules', '.bin')
-  if (isDirectory(buildNodePath)) childPaths.push(buildNodePath)
+  if (resolveDirectory(buildNodePath)) childPaths.push(buildNodePath)
 
   // Any other paths either from `process.env` or `env` (which overrides it)
   const extraPath = env.PATH || process.env.PATH

package/src/plugs/tsc/runner.ts

@@ -3,7 +3,7 @@ import ts from 'typescript' // TypeScript does NOT support ESM modules
 import { failure } from '../../assert.js'
 import { Files } from '../../files.js'
 import { $p, log } from '../../log.js'
-import { AbsolutePath, isFile } from '../../paths.js'
+import { AbsolutePath, resolveFile } from '../../paths.js'
 import { Plug } from '../../pipe.js'
 import { Run } from '../../run.js'
 import { parseOptions, ParseOptions } from '../../utils/options.js'
@@ -39,9 +39,9 @@ export default class Tsc implements Plug<Files> {
      * The "tsconfig" file is either specified, or (if existing) first checked
      * alongside the sources, otherwise checked in the current directory.
      */
-    const sourcesConfig = isFile(files.directory, 'tsconfig.json')
+    const sourcesConfig = resolveFile(files.directory, 'tsconfig.json')
     const tsconfig = this._tsconfig ? run.resolve(this._tsconfig) :
-      sourcesConfig || isFile(run.resolve('tsconfig.json'))
+      sourcesConfig || resolveFile(run.resolve('tsconfig.json'))
 
     /* Root directory must always exist */
     let rootDir: AbsolutePath