@plugjs/plug/dist/plugs/copy.cjs

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

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
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);

// plugs/copy.ts
var copy_exports = {};
module.exports = __toCommonJS(copy_exports);
var import_asserts = require("../asserts.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");
(0, import_pipe.install)("copy", class Copy {
  constructor(_directory, _options = {}) {
    this._directory = _directory;
    this._options = _options;
  }
  async pipe(files, context) {
    const { mode, dirMode, overwrite = "fail", rename = (s) => s } = this._options;
    const flags = overwrite === "overwrite" ? 0 : import_fs.fsConstants.COPYFILE_EXCL;
    const dmode = parseMode(dirMode);
    const fmode = parseMode(mode);
    const directory = context.resolve(this._directory);
    const builder = import_files.Files.builder(directory);
    for (const [relative, absolute] of files.pathMappings()) {
      const target = (0, import_paths.resolveAbsolutePath)(builder.directory, rename(relative));
      if (target === absolute) {
        context.log.warn("Cowardly refusing to copy same file", (0, import_logging.$p)(absolute));
        continue;
      }
      const directory2 = (0, import_paths.getAbsoluteParent)(target);
      const firstParent = await (0, import_fs.mkdir)(directory2, { recursive: true });
      if (firstParent && dmode !== void 0) {
        (0, import_paths.assertAbsolutePath)(firstParent);
        for (let dir = directory2; ; dir = (0, import_paths.getAbsoluteParent)(dir)) {
          context.log.trace(`Setting mode ${stringifyMode(dmode)} for directory`, (0, import_logging.$p)(dir));
          await (0, import_fs.chmod)(dir, dmode);
          if (dir === firstParent) break;
        }
      }
      context.log.trace(`Copying "${(0, import_logging.$p)(absolute)}" to "${(0, import_logging.$p)(target)}"`);
      try {
        await (0, import_fs.copyFile)(absolute, target, flags);
        if (fmode !== void 0) {
          context.log.trace(`Setting mode ${stringifyMode(fmode)} for file`, (0, import_logging.$p)(target));
          await (0, import_fs.chmod)(target, fmode);
        }
        builder.add(target);
      } catch (error) {
        if (error.code === "EEXIST" && overwrite === "skip") {
          context.log.warn(`Not overwriting existing file ${(0, import_logging.$p)(target)}`);
        } else {
          throw error;
        }
      }
    }
    const result = builder.build();
    context.log.info("Copied", result.length, "files to", (0, import_logging.$p)(builder.directory));
    return result;
  }
});
function parseMode(mode) {
  if (mode === void 0) return void 0;
  if (typeof mode === "number") return mode;
  const parsed = parseInt(mode, 8);
  (0, import_asserts.assert)(!isNaN(parsed), `Invalid mode "${mode}"`);
  return parsed;
}
function stringifyMode(mode) {
  return mode.toString(8).padStart(4, "0");
}
//# sourceMappingURL=copy.cjs.map