@plugjs/plug
Version:
PlugJS Build System ===================
183 lines (181 loc) • 7.65 kB
JavaScript
;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// helpers.ts
var helpers_exports = {};
__export(helpers_exports, {
context: () => context,
exec: () => exec,
find: () => find,
invokeBuild: () => invokeBuild,
isDirectory: () => isDirectory,
isFile: () => isFile,
merge: () => merge,
mkdtemp: () => mkdtemp,
noop: () => noop,
parseJson: () => parseJson,
resolve: () => resolve,
rmrf: () => rmrf,
using: () => using
});
module.exports = __toCommonJS(helpers_exports);
var import_node_fs = require("node:fs");
var import_node_os = require("node:os");
var import_node_path = require("node:path");
var import_asserts = require("./asserts.cjs");
var import_async = require("./async.cjs");
var import_files = require("./files.cjs");
var import_fs = require("./fs.cjs");
var import_logging = require("./logging.cjs");
var import_paths = require("./paths.cjs");
var import_pipe = require("./pipe.cjs");
var import_build = require("./plugs/build.cjs");
var import_utils = require("./utils.cjs");
var import_exec = require("./utils/exec.cjs");
var import_options = require("./utils/options.cjs");
var import_walk = require("./utils/walk.cjs");
function context() {
return (0, import_async.requireContext)();
}
function find(...args) {
const { params: globs, options } = (0, import_options.parseOptions)(args, {});
const context2 = (0, import_async.requireContext)();
return new import_pipe.PipeImpl(context2, Promise.resolve().then(async () => {
const directory = options.directory ? context2.resolve(options.directory) : (0, import_paths.getCurrentWorkingDirectory)();
const builder = import_files.Files.builder(directory);
for await (const file of (0, import_walk.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 = (0, import_async.requireContext)();
const file = context2.resolve(buildFile);
const dir = (0, import_paths.getAbsoluteParent)(file);
const files = import_files.Files.builder(dir).add(file).build();
return new import_build.RunBuild(tasks, props, forkOptions).pipe(files, context2).then(() => void 0);
}
async function rmrf(directory) {
const context2 = (0, import_async.requireContext)();
const dir = context2.resolve(directory);
(0, import_asserts.assert)(
dir !== (0, import_paths.getCurrentWorkingDirectory)(),
`Cowardly refusing to wipe current working directory ${(0, import_logging.$p)(dir)}`
);
(0, import_asserts.assert)(
dir !== context2.resolve("@"),
`Cowardly refusing to wipe build file directory ${(0, import_logging.$p)(dir)}`
);
if (!(0, import_paths.resolveDirectory)(dir)) {
import_logging.log.info("Directory", (0, import_logging.$p)(dir), "not found");
return;
}
import_logging.log.notice("Removing directory", (0, import_logging.$p)(dir), "recursively");
await (0, import_fs.rm)(dir, { recursive: true });
}
function merge(pipes) {
const context2 = (0, import_async.requireContext)();
return new import_pipe.PipeImpl(context2, Promise.resolve().then(async () => {
if (pipes.length === 0) return new import_files.Files();
const awaited = await (0, import_asserts.assertPromises)(pipes);
const results = awaited.filter((result) => result.length);
if (results.length === 0) return new import_files.Files();
const [firstDir, ...otherDirs] = results.map((f) => f.directory);
const directory = (0, import_paths.commonPath)(firstDir, ...otherDirs);
return import_files.Files.builder(directory).merge(...results).build();
}));
}
function noop() {
const context2 = (0, import_async.requireContext)();
return new import_pipe.PipeImpl(context2, Promise.resolve(new import_files.Files()));
}
function using(...args) {
const { options, params } = (0, import_options.parseOptions)(args, { directory: "." });
const context2 = (0, import_async.requireContext)();
const directory = context2.resolve(options.directory);
const files = import_files.Files.builder(directory).add(...params).build();
return new import_pipe.PipeImpl(context2, Promise.resolve(files));
}
function resolve(...paths) {
return (0, import_async.requireContext)().resolve(...paths);
}
function isFile(...paths) {
const path = (0, import_async.requireContext)().resolve(...paths);
return (0, import_paths.resolveFile)(path);
}
function isDirectory(...paths) {
const path = (0, import_async.requireContext)().resolve(...paths);
return (0, import_paths.resolveDirectory)(path);
}
function mkdtemp() {
const prefix = (0, import_node_path.join)((0, import_node_os.tmpdir)(), "plugjs-");
const path = (0, import_node_fs.mkdtempSync)(prefix);
return resolve(path);
}
function exec(cmd, ...args) {
const { params, options } = (0, import_options.parseOptions)(args);
return (0, import_exec.execChild)(cmd, params, options, (0, import_async.requireContext)());
}
function parseJson(file, strict = false) {
const jsonFile = (0, import_async.requireContext)().resolve(file);
let jsonText;
try {
jsonText = (0, import_node_fs.readFileSync)(jsonFile, "utf-8");
} catch (error) {
if (error.code === "ENOENT") import_logging.log.fail(`File ${(0, import_logging.$p)(jsonFile)} not found`);
if (error.code === "EACCES") import_logging.log.fail(`File ${(0, import_logging.$p)(jsonFile)} can not be accessed`);
import_logging.log.fail(`Error reading ${(0, import_logging.$p)(jsonFile)}`, error);
}
try {
return (0, import_utils.parseJsonc)(jsonText, {
disallowComments: strict,
allowTrailingComma: !strict
});
} catch (error) {
if (error instanceof import_utils.JsoncError) {
const errors = error.errors;
import_logging.log.error(`Found ${(0, import_logging.$plur)(errors.length, "error", "errors")} parsing ${(0, import_logging.$p)(jsonFile)}`);
for (const e of errors) {
import_logging.log.error(` ${(0, import_logging.$wht)(e.code)} ${(0, import_logging.$gry)("at line")} ${(0, import_logging.$ylw)(e.line)}${(0, import_logging.$gry)(", column")} ${(0, import_logging.$ylw)(e.column)}`);
}
throw new import_asserts.BuildFailure();
} else throw error;
}
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
context,
exec,
find,
invokeBuild,
isDirectory,
isFile,
merge,
mkdtemp,
noop,
parseJson,
resolve,
rmrf,
using
});
//# sourceMappingURL=helpers.cjs.map