@visulima/fs 2.3.5 → 2.3.7

package/dist/packem_shared/index-ngvEMjBI.cjs

@@ -0,0 +1,110 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const INDENT_REGEX = /^(?:( )+|\t+)/;
+const INDENT_TYPE_SPACE = "space";
+const INDENT_TYPE_TAB = "tab";
+function makeIndentsMap(string, ignoreSingleSpaces) {
+  const indents = /* @__PURE__ */ new Map();
+  let previousSize = 0;
+  let previousIndentType;
+  let key;
+  for (const line of string.split(/\n/g)) {
+    if (!line) {
+      continue;
+    }
+    let indent;
+    let indentType;
+    let use;
+    let weight;
+    let entry;
+    const matches = line.match(INDENT_REGEX);
+    if (matches === null) {
+      previousSize = 0;
+      previousIndentType = "";
+    } else {
+      indent = matches[0].length;
+      indentType = matches[1] ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+      if (ignoreSingleSpaces && indentType === INDENT_TYPE_SPACE && indent === 1) {
+        continue;
+      }
+      if (indentType !== previousIndentType) {
+        previousSize = 0;
+      }
+      previousIndentType = indentType;
+      use = 1;
+      weight = 0;
+      const indentDifference = indent - previousSize;
+      previousSize = indent;
+      if (indentDifference === 0) {
+        use = 0;
+        weight = 1;
+      } else {
+        const absoluteIndentDifference = indentDifference > 0 ? indentDifference : -indentDifference;
+        key = encodeIndentsKey(indentType, absoluteIndentDifference);
+      }
+      entry = indents.get(key);
+      entry = entry === undefined ? [1, 0] : [entry[0] + use, entry[1] + weight];
+      indents.set(key, entry);
+    }
+  }
+  return indents;
+}
+__name(makeIndentsMap, "makeIndentsMap");
+function encodeIndentsKey(indentType, indentAmount) {
+  const typeCharacter = indentType === INDENT_TYPE_SPACE ? "s" : "t";
+  return typeCharacter + String(indentAmount);
+}
+__name(encodeIndentsKey, "encodeIndentsKey");
+function decodeIndentsKey(indentsKey) {
+  const keyHasTypeSpace = indentsKey[0] === "s";
+  const type = keyHasTypeSpace ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+  const amount = Number(indentsKey.slice(1));
+  return { type, amount };
+}
+__name(decodeIndentsKey, "decodeIndentsKey");
+function getMostUsedKey(indents) {
+  let result;
+  let maxUsed = 0;
+  let maxWeight = 0;
+  for (const [key, [usedCount, weight]] of indents) {
+    if (usedCount > maxUsed || usedCount === maxUsed && weight > maxWeight) {
+      maxUsed = usedCount;
+      maxWeight = weight;
+      result = key;
+    }
+  }
+  return result;
+}
+__name(getMostUsedKey, "getMostUsedKey");
+function makeIndentString(type, amount) {
+  const indentCharacter = type === INDENT_TYPE_SPACE ? " " : "	";
+  return indentCharacter.repeat(amount);
+}
+__name(makeIndentString, "makeIndentString");
+function detectIndent(string) {
+  if (typeof string !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  let indents = makeIndentsMap(string, true);
+  if (indents.size === 0) {
+    indents = makeIndentsMap(string, false);
+  }
+  const keyOfMostUsedIndent = getMostUsedKey(indents);
+  let type;
+  let amount = 0;
+  let indent = "";
+  if (keyOfMostUsedIndent !== undefined) {
+    ({ type, amount } = decodeIndentsKey(keyOfMostUsedIndent));
+    indent = makeIndentString(type, amount);
+  }
+  return {
+    amount,
+    type,
+    indent
+  };
+}
+__name(detectIndent, "detectIndent");
+
+exports.detectIndent = detectIndent;

package/dist/packem_shared/is-stats-identical-BfdEfO6i.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const isStatsIdentical = /* @__PURE__ */ __name((sourceStat, destinationStat) => !!destinationStat.ino && !!destinationStat.dev && destinationStat.ino === sourceStat.ino && destinationStat.dev === sourceStat.dev, "isStatsIdentical");
+
+exports.isStatsIdentical = isStatsIdentical;

package/dist/packem_shared/is-stats-identical-ByTYZ2Aw.mjs

@@ -0,0 +1,5 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const isStatsIdentical = /* @__PURE__ */ __name((sourceStat, destinationStat) => !!destinationStat.ino && !!destinationStat.dev && destinationStat.ino === sourceStat.ino && destinationStat.dev === sourceStat.dev, "isStatsIdentical");
+
+export { isStatsIdentical as i };

package/dist/packem_shared/isAccessible-Bonsm1Ez.mjs

@@ -0,0 +1,20 @@
+import { access } from 'node:fs/promises';
+import { toPath } from '@visulima/path/utils';
+import { F_OK } from './F_OK-JER1LjUr.mjs';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function isAccessible(path, mode = F_OK) {
+  assertValidFileOrDirectoryPath(path);
+  path = toPath(path);
+  try {
+    await access(path, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isAccessible, "isAccessible");
+
+export { isAccessible as default };

package/dist/packem_shared/isAccessible-ZNVGsSb7.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+const promises = require('node:fs/promises');
+const utils = require('@visulima/path/utils');
+const F_OK = require('./F_OK-CWSqQIdF.cjs');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function isAccessible(path, mode = F_OK.F_OK) {
+  assertValidFileOrDirectoryPath(path);
+  path = utils.toPath(path);
+  try {
+    await promises.access(path, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isAccessible, "isAccessible");
+
+module.exports = isAccessible;

package/dist/packem_shared/isAccessibleSync-3gnUWUwX.mjs

@@ -0,0 +1,20 @@
+import { accessSync } from 'node:fs';
+import { toPath } from '@visulima/path/utils';
+import { F_OK } from './F_OK-JER1LjUr.mjs';
+import assertValidFileOrDirectoryPath from './assertValidFileOrDirectoryPath-BWWgA1wj.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function isAccessibleSync(path, mode = F_OK) {
+  assertValidFileOrDirectoryPath(path);
+  path = toPath(path);
+  try {
+    accessSync(path, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isAccessibleSync, "isAccessibleSync");
+
+export { isAccessibleSync as default };

package/dist/packem_shared/isAccessibleSync-VWjQa-US.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const utils = require('@visulima/path/utils');
+const F_OK = require('./F_OK-CWSqQIdF.cjs');
+const assertValidFileOrDirectoryPath = require('./assertValidFileOrDirectoryPath-BMbgA-eI.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function isAccessibleSync(path, mode = F_OK.F_OK) {
+  assertValidFileOrDirectoryPath(path);
+  path = utils.toPath(path);
+  try {
+    node_fs.accessSync(path, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isAccessibleSync, "isAccessibleSync");
+
+module.exports = isAccessibleSync;

package/dist/packem_shared/move-DgF7Ul9L.mjs

@@ -0,0 +1,114 @@
+import { cwd } from 'node:process';
+import { toPath } from '@visulima/path/utils';
+import { mkdir, rename as rename$1, copyFile, unlink } from 'node:fs/promises';
+import { dirname, resolve } from '@visulima/path';
+import isAccessible from './isAccessible-Bonsm1Ez.mjs';
+import { mkdirSync, renameSync as renameSync$1, copyFileSync, unlinkSync } from 'node:fs';
+import isAccessibleSync from './isAccessibleSync-3gnUWUwX.mjs';
+
+var __defProp$3 = Object.defineProperty;
+var __name$3 = (target, value) => __defProp$3(target, "name", { value, configurable: true });
+class SameDirectoryError extends Error {
+  static {
+    __name$3(this, "SameDirectoryError");
+  }
+  constructor(source, destination) {
+    super(`Source directory "${dirname(source)}" does not match destination directory "${dirname(destination)}"`);
+    this.name = "SameDirectoryError";
+  }
+}
+const validateSameDirectory = /* @__PURE__ */ __name$3((source, destination) => {
+  if (!source || !destination) {
+    throw new Error("Source and destination paths must not be empty");
+  }
+  if (dirname(source) !== dirname(destination)) {
+    throw new SameDirectoryError(source, destination);
+  }
+}, "validateSameDirectory");
+
+var __defProp$2 = Object.defineProperty;
+var __name$2 = (target, value) => __defProp$2(target, "name", { value, configurable: true });
+const internalMoveFile = /* @__PURE__ */ __name$2(async (sourcePath, destinationPath, { cwd, directoryMode, overwrite, validateDirectory }) => {
+  if (cwd) {
+    sourcePath = resolve(cwd, sourcePath);
+    destinationPath = resolve(cwd, destinationPath);
+  }
+  if (validateDirectory) {
+    validateSameDirectory(sourcePath, destinationPath);
+  }
+  if (!overwrite && await isAccessible(destinationPath)) {
+    throw new Error(`The destination file exists: ${destinationPath}`);
+  }
+  await mkdir(dirname(destinationPath), {
+    mode: directoryMode,
+    recursive: true
+  });
+  try {
+    await rename$1(sourcePath, destinationPath);
+  } catch (error) {
+    if (error.code === "EXDEV") {
+      await copyFile(sourcePath, destinationPath);
+      await unlink(sourcePath);
+    } else {
+      throw error;
+    }
+  }
+}, "internalMoveFile");
+
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+const internalMoveFileSync = /* @__PURE__ */ __name$1((sourcePath, destinationPath, { cwd, directoryMode, overwrite, validateDirectory }) => {
+  if (cwd) {
+    sourcePath = resolve(cwd, sourcePath);
+    destinationPath = resolve(cwd, destinationPath);
+  }
+  if (validateDirectory) {
+    validateSameDirectory(sourcePath, destinationPath);
+  }
+  if (!overwrite && isAccessibleSync(destinationPath)) {
+    throw new Error(`The destination file exists: ${destinationPath}`);
+  }
+  mkdirSync(dirname(destinationPath), {
+    mode: directoryMode,
+    recursive: true
+  });
+  try {
+    renameSync$1(sourcePath, destinationPath);
+  } catch (error) {
+    if (error.code === "EXDEV") {
+      copyFileSync(sourcePath, destinationPath);
+      unlinkSync(sourcePath);
+    } else {
+      throw error;
+    }
+  }
+}, "internalMoveFileSync");
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const move = /* @__PURE__ */ __name(async (sourcePath, destinationPath, options = {}) => {
+  const internalOptions = {
+    overwrite: true,
+    validateDirectory: false,
+    ...options,
+    cwd: options.cwd ? toPath(options.cwd) : cwd()
+  };
+  await internalMoveFile(sourcePath, destinationPath, internalOptions);
+}, "move");
+const moveSync = /* @__PURE__ */ __name((sourcePath, destinationPath, options) => {
+  const internalOptions = { overwrite: true, validateDirectory: false, ...options };
+  internalOptions.cwd = internalOptions.cwd ? toPath(internalOptions.cwd) : cwd();
+  internalMoveFileSync(sourcePath, destinationPath, internalOptions);
+}, "moveSync");
+const rename = /* @__PURE__ */ __name(async (source, destination, options) => {
+  const internalOptions = { overwrite: true, ...options, validateDirectory: true };
+  internalOptions.cwd = internalOptions.cwd ? toPath(internalOptions.cwd) : cwd();
+  await internalMoveFile(source, destination, internalOptions);
+}, "rename");
+const renameSync = /* @__PURE__ */ __name((source, destination, options) => {
+  const internalOptions = { overwrite: true, ...options, validateDirectory: true };
+  internalOptions.cwd = internalOptions.cwd ? toPath(internalOptions.cwd) : cwd();
+  internalMoveFileSync(source, destination, internalOptions);
+}, "renameSync");
+
+export { move, moveSync, rename, renameSync };

package/dist/packem_shared/move-Dh925GL9.cjs

@@ -0,0 +1,121 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const node_process = require('node:process');
+const utils = require('@visulima/path/utils');
+const promises = require('node:fs/promises');
+const path = require('@visulima/path');
+const isAccessible = require('./isAccessible-ZNVGsSb7.cjs');
+const node_fs = require('node:fs');
+const isAccessibleSync = require('./isAccessibleSync-VWjQa-US.cjs');
+
+var __defProp$3 = Object.defineProperty;
+var __name$3 = (target, value) => __defProp$3(target, "name", { value, configurable: true });
+class SameDirectoryError extends Error {
+  static {
+    __name$3(this, "SameDirectoryError");
+  }
+  constructor(source, destination) {
+    super(`Source directory "${path.dirname(source)}" does not match destination directory "${path.dirname(destination)}"`);
+    this.name = "SameDirectoryError";
+  }
+}
+const validateSameDirectory = /* @__PURE__ */ __name$3((source, destination) => {
+  if (!source || !destination) {
+    throw new Error("Source and destination paths must not be empty");
+  }
+  if (path.dirname(source) !== path.dirname(destination)) {
+    throw new SameDirectoryError(source, destination);
+  }
+}, "validateSameDirectory");
+
+var __defProp$2 = Object.defineProperty;
+var __name$2 = (target, value) => __defProp$2(target, "name", { value, configurable: true });
+const internalMoveFile = /* @__PURE__ */ __name$2(async (sourcePath, destinationPath, { cwd, directoryMode, overwrite, validateDirectory }) => {
+  if (cwd) {
+    sourcePath = path.resolve(cwd, sourcePath);
+    destinationPath = path.resolve(cwd, destinationPath);
+  }
+  if (validateDirectory) {
+    validateSameDirectory(sourcePath, destinationPath);
+  }
+  if (!overwrite && await isAccessible(destinationPath)) {
+    throw new Error(`The destination file exists: ${destinationPath}`);
+  }
+  await promises.mkdir(path.dirname(destinationPath), {
+    mode: directoryMode,
+    recursive: true
+  });
+  try {
+    await promises.rename(sourcePath, destinationPath);
+  } catch (error) {
+    if (error.code === "EXDEV") {
+      await promises.copyFile(sourcePath, destinationPath);
+      await promises.unlink(sourcePath);
+    } else {
+      throw error;
+    }
+  }
+}, "internalMoveFile");
+
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+const internalMoveFileSync = /* @__PURE__ */ __name$1((sourcePath, destinationPath, { cwd, directoryMode, overwrite, validateDirectory }) => {
+  if (cwd) {
+    sourcePath = path.resolve(cwd, sourcePath);
+    destinationPath = path.resolve(cwd, destinationPath);
+  }
+  if (validateDirectory) {
+    validateSameDirectory(sourcePath, destinationPath);
+  }
+  if (!overwrite && isAccessibleSync(destinationPath)) {
+    throw new Error(`The destination file exists: ${destinationPath}`);
+  }
+  node_fs.mkdirSync(path.dirname(destinationPath), {
+    mode: directoryMode,
+    recursive: true
+  });
+  try {
+    node_fs.renameSync(sourcePath, destinationPath);
+  } catch (error) {
+    if (error.code === "EXDEV") {
+      node_fs.copyFileSync(sourcePath, destinationPath);
+      node_fs.unlinkSync(sourcePath);
+    } else {
+      throw error;
+    }
+  }
+}, "internalMoveFileSync");
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const move = /* @__PURE__ */ __name(async (sourcePath, destinationPath, options = {}) => {
+  const internalOptions = {
+    overwrite: true,
+    validateDirectory: false,
+    ...options,
+    cwd: options.cwd ? utils.toPath(options.cwd) : node_process.cwd()
+  };
+  await internalMoveFile(sourcePath, destinationPath, internalOptions);
+}, "move");
+const moveSync = /* @__PURE__ */ __name((sourcePath, destinationPath, options) => {
+  const internalOptions = { overwrite: true, validateDirectory: false, ...options };
+  internalOptions.cwd = internalOptions.cwd ? utils.toPath(internalOptions.cwd) : node_process.cwd();
+  internalMoveFileSync(sourcePath, destinationPath, internalOptions);
+}, "moveSync");
+const rename = /* @__PURE__ */ __name(async (source, destination, options) => {
+  const internalOptions = { overwrite: true, ...options, validateDirectory: true };
+  internalOptions.cwd = internalOptions.cwd ? utils.toPath(internalOptions.cwd) : node_process.cwd();
+  await internalMoveFile(source, destination, internalOptions);
+}, "rename");
+const renameSync = /* @__PURE__ */ __name((source, destination, options) => {
+  const internalOptions = { overwrite: true, ...options, validateDirectory: true };
+  internalOptions.cwd = internalOptions.cwd ? utils.toPath(internalOptions.cwd) : node_process.cwd();
+  internalMoveFileSync(source, destination, internalOptions);
+}, "renameSync");
+
+exports.move = move;
+exports.moveSync = moveSync;
+exports.rename = rename;
+exports.renameSync = renameSync;