@plugjs/plug/dist/helpers.mjs

PlugJS Build System ===================

// helpers.ts
import { mkdtempSync, readFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { BuildFailure, assert, assertPromises } from "./asserts.mjs";
import { requireContext } from "./async.mjs";
import { Files } from "./files.mjs";
import { rm } from "./fs.mjs";
import { $gry, $p, $plur, $wht, $ylw, log } from "./logging.mjs";
import {
  commonPath,
  getAbsoluteParent,
  getCurrentWorkingDirectory,
  resolveDirectory,
  resolveFile
} from "./paths.mjs";
import { PipeImpl } from "./pipe.mjs";
import { RunBuild } from "./plugs/build.mjs";
import { JsoncError, parseJsonc } from "./utils.mjs";
import { execChild } from "./utils/exec.mjs";
import { parseOptions } from "./utils/options.mjs";
import { walk } from "./utils/walk.mjs";
function context() {
  return requireContext();
}
function find(...args) {
  const { params: globs, options } = parseOptions(args, {});
  const context2 = requireContext();
  return new PipeImpl(context2, Promise.resolve().then(async () => {
    const directory = options.directory ? context2.resolve(options.directory) : getCurrentWorkingDirectory();
    const builder = Files.builder(directory);
    for await (const file of walk(directory, globs, options)) {
      builder.add(file);
    }
    return builder.build();
  }));
}
async function invokeBuild(buildFile, tasksOrOptions, maybeOptions) {
  const [tasks, options = {}] = typeof tasksOrOptions === "string" ? [[tasksOrOptions], maybeOptions] : Array.isArray(tasksOrOptions) ? [tasksOrOptions, maybeOptions] : typeof tasksOrOptions === "object" ? [["default"], tasksOrOptions] : [["default"], {}];
  if (tasks.length === 0) tasks.push("default");
  const { coverageDir, forceModule, ...props } = options;
  const forkOptions = { coverageDir, forceModule };
  const context2 = requireContext();
  const file = context2.resolve(buildFile);
  const dir = getAbsoluteParent(file);
  const files = Files.builder(dir).add(file).build();
  return new RunBuild(tasks, props, forkOptions).pipe(files, context2).then(() => void 0);
}
async function rmrf(directory) {
  const context2 = requireContext();
  const dir = context2.resolve(directory);
  assert(
    dir !== getCurrentWorkingDirectory(),
    `Cowardly refusing to wipe current working directory ${$p(dir)}`
  );
  assert(
    dir !== context2.resolve("@"),
    `Cowardly refusing to wipe build file directory ${$p(dir)}`
  );
  if (!resolveDirectory(dir)) {
    log.info("Directory", $p(dir), "not found");
    return;
  }
  log.notice("Removing directory", $p(dir), "recursively");
  await rm(dir, { recursive: true });
}
function merge(pipes) {
  const context2 = requireContext();
  return new PipeImpl(context2, Promise.resolve().then(async () => {
    if (pipes.length === 0) return new Files();
    const awaited = await assertPromises(pipes);
    const results = awaited.filter((result) => result.length);
    if (results.length === 0) return new Files();
    const [firstDir, ...otherDirs] = results.map((f) => f.directory);
    const directory = commonPath(firstDir, ...otherDirs);
    return Files.builder(directory).merge(...results).build();
  }));
}
function noop() {
  const context2 = requireContext();
  return new PipeImpl(context2, Promise.resolve(new Files()));
}
function using(...args) {
  const { options, params } = parseOptions(args, { directory: "." });
  const context2 = requireContext();
  const directory = context2.resolve(options.directory);
  const files = Files.builder(directory).add(...params).build();
  return new PipeImpl(context2, Promise.resolve(files));
}
function resolve(...paths) {
  return requireContext().resolve(...paths);
}
function isFile(...paths) {
  const path = requireContext().resolve(...paths);
  return resolveFile(path);
}
function isDirectory(...paths) {
  const path = requireContext().resolve(...paths);
  return resolveDirectory(path);
}
function mkdtemp() {
  const prefix = join(tmpdir(), "plugjs-");
  const path = mkdtempSync(prefix);
  return resolve(path);
}
function exec(cmd, ...args) {
  const { params, options } = parseOptions(args);
  return execChild(cmd, params, options, requireContext());
}
function parseJson(file, strict = false) {
  const jsonFile = requireContext().resolve(file);
  let jsonText;
  try {
    jsonText = readFileSync(jsonFile, "utf-8");
  } catch (error) {
    if (error.code === "ENOENT") log.fail(`File ${$p(jsonFile)} not found`);
    if (error.code === "EACCES") log.fail(`File ${$p(jsonFile)} can not be accessed`);
    log.fail(`Error reading ${$p(jsonFile)}`, error);
  }
  try {
    return parseJsonc(jsonText, {
      disallowComments: strict,
      allowTrailingComma: !strict
    });
  } catch (error) {
    if (error instanceof JsoncError) {
      const errors = error.errors;
      log.error(`Found ${$plur(errors.length, "error", "errors")} parsing ${$p(jsonFile)}`);
      for (const e of errors) {
        log.error(`  ${$wht(e.code)} ${$gry("at line")} ${$ylw(e.line)}${$gry(", column")} ${$ylw(e.column)}`);
      }
      throw new BuildFailure();
    } else throw error;
  }
}
export {
  context,
  exec,
  find,
  invokeBuild,
  isDirectory,
  isFile,
  merge,
  mkdtemp,
  noop,
  parseJson,
  resolve,
  rmrf,
  using
};
//# sourceMappingURL=helpers.mjs.map