@plugjs/plug/dist/paths.cjs

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

"use strict";
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);

// paths.ts
var paths_exports = {};
__export(paths_exports, {
  assertAbsolutePath: () => assertAbsolutePath,
  assertRelativeChildPath: () => assertRelativeChildPath,
  commonPath: () => commonPath,
  dirnameFromUrl: () => dirnameFromUrl,
  filenameFromUrl: () => filenameFromUrl,
  getAbsoluteParent: () => getAbsoluteParent,
  getCurrentWorkingDirectory: () => getCurrentWorkingDirectory,
  isAbsolutePath: () => isAbsolutePath,
  requireFilename: () => requireFilename,
  requireResolve: () => requireResolve,
  resolveAbsolutePath: () => resolveAbsolutePath,
  resolveDirectory: () => resolveDirectory,
  resolveFile: () => resolveFile,
  resolveRelativeChildPath: () => resolveRelativeChildPath
});
module.exports = __toCommonJS(paths_exports);
var import_node_fs = require("node:fs");
var import_node_module = require("node:module");
var import_node_path = require("node:path");
var import_node_url = require("node:url");
var import_asserts = require("./asserts.cjs");
function resolveAbsolutePath(directory, ...paths) {
  assertAbsolutePath(directory);
  return (0, import_node_path.resolve)(directory, ...paths);
}
function resolveRelativeChildPath(directory, ...paths) {
  const abs = resolveAbsolutePath(directory, ...paths);
  const rel = (0, import_node_path.relative)(directory, abs);
  return (0, import_node_path.isAbsolute)(rel) || rel === ".." || rel.startsWith(`..${import_node_path.sep}`) ? void 0 : rel;
}
function assertRelativeChildPath(directory, ...paths) {
  const relative2 = resolveRelativeChildPath(directory, ...paths);
  (0, import_asserts.assert)(relative2, `Path "${(0, import_node_path.join)(...paths)}" not relative to "${directory}"`);
  return relative2;
}
function isAbsolutePath(path) {
  return (0, import_node_path.isAbsolute)(path);
}
function assertAbsolutePath(p) {
  (0, import_asserts.assert)((0, import_node_path.isAbsolute)(p), `Path "${p}" not absolute`);
}
function getAbsoluteParent(path) {
  assertAbsolutePath(path);
  return (0, import_node_path.dirname)(path);
}
function getCurrentWorkingDirectory() {
  const cwd = process.cwd();
  assertAbsolutePath(cwd);
  return cwd;
}
function commonPath(path, ...paths) {
  assertAbsolutePath(path);
  const components = (0, import_node_path.normalize)(path).split(import_node_path.sep);
  let length = components.length;
  for (const current of paths) {
    const absolute = resolveAbsolutePath(path, current);
    const parts = absolute.split(import_node_path.sep);
    for (let i = 0; i < length; i++) {
      if (components[i] !== parts[i]) {
        length = i;
        break;
      }
    }
    (0, import_asserts.assert)(length, "No common ancestors amongst paths");
  }
  const common = components.slice(0, length).join(import_node_path.sep);
  assertAbsolutePath(common);
  return common;
}
function resolveFilename(__fileurl) {
  const file = __fileurl.startsWith("file:") ? (0, import_node_url.fileURLToPath)(__fileurl) : __fileurl;
  assertAbsolutePath(file);
  return file;
}
function filenameFromUrl(__fileurl) {
  const file = resolveFilename(__fileurl);
  (0, import_asserts.assert)(resolveFile(file), `Unable to resolve "${__fileurl}" as a file`);
  return file;
}
function dirnameFromUrl(__fileurl) {
  const dir = getAbsoluteParent(resolveFilename(__fileurl));
  (0, import_asserts.assert)(resolveDirectory(dir), `Unable to resolve "${__fileurl}" as a directory`);
  return dir;
}
function requireFilename(__fileurl, ...paths) {
  const file = resolveFilename(__fileurl);
  assertAbsolutePath(file);
  if (!paths.length) return file;
  const directory = getAbsoluteParent(file);
  return resolveAbsolutePath(directory, ...paths);
}
function requireResolve(__fileurl, module2) {
  const file = resolveFilename(__fileurl);
  if (module2.match(/^\.\.?\//)) {
    const url = (0, import_node_url.pathToFileURL)(file);
    const ext = (0, import_node_path.extname)(file);
    const checks = [`${module2}`, `${module2}${ext}`, `${module2}/index${ext}`];
    for (const check of checks) {
      const resolved = (0, import_node_url.fileURLToPath)(new URL(check, url));
      if (resolveFile(resolved)) {
        module2 = check;
        break;
      }
    }
  }
  const require2 = (0, import_node_module.createRequire)(file);
  const required = require2.resolve(module2);
  assertAbsolutePath(required);
  return required;
}
function resolveFile(path, ...paths) {
  const file = resolveAbsolutePath(path, ...paths);
  try {
    const stat = (0, import_node_fs.statSync)(file);
    if (stat.isFile()) return file;
  } catch (error) {
    if (error.code !== "ENOENT") throw error;
  }
  return void 0;
}
function resolveDirectory(path, ...paths) {
  const directory = resolveAbsolutePath(path, ...paths);
  try {
    const stat = (0, import_node_fs.statSync)(directory);
    if (stat.isDirectory()) return directory;
  } catch (error) {
    if (error.code !== "ENOENT") throw error;
  }
  return void 0;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  assertAbsolutePath,
  assertRelativeChildPath,
  commonPath,
  dirnameFromUrl,
  filenameFromUrl,
  getAbsoluteParent,
  getCurrentWorkingDirectory,
  isAbsolutePath,
  requireFilename,
  requireResolve,
  resolveAbsolutePath,
  resolveDirectory,
  resolveFile,
  resolveRelativeChildPath
});
//# sourceMappingURL=paths.cjs.map