pythonlib 1.0.2 → 2.0.0

package/dist/chunk-KKJHGY4C.js

@@ -0,0 +1,551 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/pathlib.node.ts
+var pathlib_node_exports = {};
+__export(pathlib_node_exports, {
+  Path: () => Path,
+  PosixPath: () => PosixPath,
+  PurePath: () => PurePath,
+  PurePosixPath: () => PurePosixPath,
+  PureWindowsPath: () => PureWindowsPath,
+  WindowsPath: () => WindowsPath
+});
+import {
+  access,
+  chmod,
+  link,
+  lstat,
+  mkdir,
+  readdir,
+  readFile,
+  readlink,
+  rename,
+  rmdir,
+  stat,
+  symlink,
+  unlink,
+  utimes,
+  writeFile
+} from "fs/promises";
+import {
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  parse,
+  relative,
+  resolve,
+  sep
+} from "path";
+var Path = class _Path {
+  _path;
+  /**
+   * Create a new Path instance.
+   *
+   * @param pathSegments - Path segments to join
+   */
+  constructor(...pathSegments) {
+    if (pathSegments.length === 0) {
+      this._path = ".";
+    } else {
+      this._path = join(...pathSegments);
+    }
+  }
+  /**
+   * Static factory method to create a Path.
+   */
+  static of(...pathSegments) {
+    return new _Path(...pathSegments);
+  }
+  /**
+   * The final component of the path.
+   */
+  get name() {
+    return basename(this._path);
+  }
+  /**
+   * The final component without its suffix.
+   */
+  get stem() {
+    const base = basename(this._path);
+    const ext = extname(base);
+    return ext ? base.slice(0, -ext.length) : base;
+  }
+  /**
+   * The file extension of the final component.
+   */
+  get suffix() {
+    return extname(this._path);
+  }
+  /**
+   * A list of the path's file extensions.
+   */
+  get suffixes() {
+    const name = this.name;
+    const suffixes = [];
+    let remaining = name;
+    let ext = extname(remaining);
+    while (ext) {
+      suffixes.unshift(ext);
+      remaining = remaining.slice(0, -ext.length);
+      ext = extname(remaining);
+    }
+    return suffixes;
+  }
+  /**
+   * The logical parent of the path.
+   */
+  get parent() {
+    const parent = dirname(this._path);
+    return new _Path(parent);
+  }
+  /**
+   * An immutable sequence of the path's ancestors.
+   */
+  get parents() {
+    const parents = [];
+    let current = this._path;
+    let parent = dirname(current);
+    while (parent !== current) {
+      parents.push(new _Path(parent));
+      current = parent;
+      parent = dirname(current);
+    }
+    return parents;
+  }
+  /**
+   * The individual components of the path.
+   */
+  get parts() {
+    const parsed = parse(this._path);
+    const parts = [];
+    if (parsed.root) {
+      parts.push(parsed.root);
+    }
+    if (parsed.dir) {
+      const dirParts = parsed.dir.replace(parsed.root, "").split(sep).filter(Boolean);
+      parts.push(...dirParts);
+    }
+    if (parsed.base) {
+      parts.push(parsed.base);
+    }
+    return parts;
+  }
+  /**
+   * The drive or root (on Windows, the drive letter; on Unix, empty or /).
+   */
+  get anchor() {
+    const parsed = parse(this._path);
+    return parsed.root;
+  }
+  /**
+   * The drive letter (Windows only, empty on Unix).
+   */
+  get drive() {
+    if (process.platform === "win32") {
+      const match = /^([A-Za-z]:)/.exec(this._path);
+      return match ? match[1] ?? "" : "";
+    }
+    return "";
+  }
+  /**
+   * The root of the path (/ on Unix, \\ or drive:\\ on Windows).
+   */
+  get root() {
+    const parsed = parse(this._path);
+    return parsed.root;
+  }
+  /**
+   * Whether the path is absolute.
+   */
+  isAbsolute() {
+    return isAbsolute(this._path);
+  }
+  /**
+   * Combine this path with additional segments.
+   *
+   * @param pathSegments - Path segments to join
+   * @returns A new Path
+   */
+  joinpath(...pathSegments) {
+    return new _Path(this._path, ...pathSegments);
+  }
+  /**
+   * Division operator alternative: join paths.
+   *
+   * @param other - Path segment to join
+   * @returns A new Path
+   */
+  div(other) {
+    const otherPath = other instanceof _Path ? other.toString() : other;
+    return new _Path(this._path, otherPath);
+  }
+  /**
+   * Return a string representation of the path.
+   */
+  toString() {
+    return this._path;
+  }
+  /**
+   * Return the path as a POSIX path string.
+   */
+  asPosix() {
+    return this._path.split(sep).join("/");
+  }
+  /**
+   * Return the path as a URI.
+   */
+  asUri() {
+    const absolute = resolve(this._path);
+    return `file://${absolute}`;
+  }
+  // Filesystem operations (async)
+  /**
+   * Whether the path exists.
+   */
+  async exists() {
+    try {
+      await access(this._path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Whether the path is a file.
+   */
+  async isFile() {
+    try {
+      return (await stat(this._path)).isFile();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Whether the path is a directory.
+   */
+  async isDir() {
+    try {
+      return (await stat(this._path)).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Whether the path is a symbolic link.
+   */
+  async isSymlink() {
+    try {
+      return (await lstat(this._path)).isSymbolicLink();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Read the file contents as text.
+   *
+   * @param encoding - Text encoding (default: utf-8)
+   * @returns File contents as string
+   */
+  async readText(encoding = "utf-8") {
+    return readFile(this._path, { encoding });
+  }
+  /**
+   * Write text to the file.
+   *
+   * @param data - Text to write
+   * @param encoding - Text encoding (default: utf-8)
+   */
+  async writeText(data, encoding = "utf-8") {
+    await writeFile(this._path, data, { encoding });
+  }
+  /**
+   * Read the file contents as bytes.
+   *
+   * @returns File contents as Uint8Array
+   */
+  async readBytes() {
+    return new Uint8Array(await readFile(this._path));
+  }
+  /**
+   * Write bytes to the file.
+   *
+   * @param data - Bytes to write
+   */
+  async writeBytes(data) {
+    await writeFile(this._path, data);
+  }
+  /**
+   * Create the directory (and parents if necessary).
+   *
+   * @param options - Options object
+   */
+  async mkdir(options) {
+    try {
+      await mkdir(this._path, { recursive: options?.parents ?? false });
+    } catch (err) {
+      if (!(options?.existOk && err.code === "EEXIST")) {
+        throw err;
+      }
+    }
+  }
+  /**
+   * Remove the directory.
+   */
+  async rmdir() {
+    await rmdir(this._path);
+  }
+  /**
+   * Remove the file or symbolic link.
+   */
+  async unlink() {
+    await unlink(this._path);
+  }
+  /**
+   * Rename the path to target.
+   *
+   * @param target - New path
+   * @returns The new Path
+   */
+  async rename(target) {
+    const targetPath = target instanceof _Path ? target.toString() : target;
+    await rename(this._path, targetPath);
+    return new _Path(targetPath);
+  }
+  /**
+   * Replace target with this file.
+   *
+   * @param target - Target path to replace
+   * @returns The new Path
+   */
+  async replace(target) {
+    return this.rename(target);
+  }
+  /**
+   * Make the path absolute.
+   *
+   * @returns Absolute path
+   */
+  resolve() {
+    return new _Path(resolve(this._path));
+  }
+  /**
+   * Return the absolute path.
+   *
+   * @returns Absolute path
+   */
+  absolute() {
+    return this.resolve();
+  }
+  /**
+   * Return the real path (resolving symlinks).
+   *
+   * @returns Real path
+   */
+  async readlink() {
+    return new _Path(await readlink(this._path));
+  }
+  /**
+   * Get file statistics.
+   *
+   * @returns File stat object
+   */
+  async stat() {
+    return stat(this._path);
+  }
+  /**
+   * Get symbolic link statistics.
+   *
+   * @returns Stat object for the symlink itself
+   */
+  async lstat() {
+    return lstat(this._path);
+  }
+  /**
+   * Iterate over directory contents.
+   *
+   * @returns Array of Path objects
+   */
+  async iterdir() {
+    const entries = await readdir(this._path);
+    return entries.map((name) => new _Path(this._path, name));
+  }
+  /**
+   * Glob pattern matching.
+   *
+   * @param pattern - Glob pattern
+   * @returns Array of matching Path objects
+   */
+  async glob(pattern) {
+    return this.matchGlob(pattern, false);
+  }
+  /**
+   * Recursive glob pattern matching.
+   *
+   * @param pattern - Glob pattern
+   * @returns Array of matching Path objects
+   */
+  async rglob(pattern) {
+    return this.matchGlob(pattern, true);
+  }
+  /**
+   * Internal glob matching implementation.
+   */
+  async matchGlob(pattern, recursive) {
+    const results = [];
+    const regex = this.globToRegex(pattern);
+    const walk = async (dir) => {
+      let entries;
+      try {
+        entries = await readdir(dir);
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const relativePath = relative(this._path, fullPath);
+        if (regex.test(relativePath) || regex.test(entry)) {
+          results.push(new _Path(fullPath));
+        }
+        if (recursive) {
+          try {
+            if ((await stat(fullPath)).isDirectory()) {
+              await walk(fullPath);
+            }
+          } catch {
+          }
+        }
+      }
+    };
+    await walk(this._path);
+    return results;
+  }
+  /**
+   * Convert glob pattern to regex.
+   */
+  globToRegex(pattern) {
+    const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<<GLOBSTAR>>>").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/<<<GLOBSTAR>>>/g, ".*");
+    return new RegExp(`^${regex}$`);
+  }
+  /**
+   * Create a symbolic link.
+   *
+   * @param target - Target of the symlink
+   */
+  async symlinkTo(target) {
+    const targetPath = target instanceof _Path ? target.toString() : target;
+    await symlink(targetPath, this._path);
+  }
+  /**
+   * Create a hard link.
+   *
+   * @param target - Target of the link
+   */
+  async linkTo(target) {
+    const targetPath = target instanceof _Path ? target.toString() : target;
+    await link(targetPath, this._path);
+  }
+  /**
+   * Change file permissions.
+   *
+   * @param mode - Permission mode
+   */
+  async chmod(mode) {
+    await chmod(this._path, mode);
+  }
+  /**
+   * Update access and modification times.
+   *
+   * @param atime - Access time
+   * @param mtime - Modification time
+   */
+  async touch(atime, mtime) {
+    const now = /* @__PURE__ */ new Date();
+    const accessTime = atime ?? now;
+    const modTime = mtime ?? now;
+    if (!await this.exists()) {
+      await writeFile(this._path, "");
+    }
+    await utimes(this._path, accessTime, modTime);
+  }
+  /**
+   * Check if path matches a pattern.
+   *
+   * @param pattern - Glob pattern
+   * @returns True if matches
+   */
+  match(pattern) {
+    const regex = this.globToRegex(pattern);
+    return regex.test(this.name) || regex.test(this._path);
+  }
+  /**
+   * Return path relative to another path.
+   *
+   * @param other - Base path
+   * @returns Relative path
+   */
+  relativeTo(other) {
+    const otherPath = other instanceof _Path ? other.toString() : other;
+    return new _Path(relative(otherPath, this._path));
+  }
+  /**
+   * Return a new path with a different suffix.
+   *
+   * @param suffix - New suffix
+   * @returns New Path
+   */
+  withSuffix(suffix) {
+    const parsed = parse(this._path);
+    return new _Path(join(parsed.dir, parsed.name + suffix));
+  }
+  /**
+   * Return a new path with a different name.
+   *
+   * @param name - New name
+   * @returns New Path
+   */
+  withName(name) {
+    const parent = dirname(this._path);
+    return new _Path(parent, name);
+  }
+  /**
+   * Return a new path with a different stem.
+   *
+   * @param stem - New stem
+   * @returns New Path
+   */
+  withStem(stem) {
+    const suffix = this.suffix;
+    return this.withName(stem + suffix);
+  }
+  /**
+   * Get the current working directory as a Path.
+   */
+  static cwd() {
+    return new _Path(process.cwd());
+  }
+  /**
+   * Get the home directory as a Path.
+   */
+  static home() {
+    return new _Path(process.env.HOME ?? process.env.USERPROFILE ?? "");
+  }
+};
+var PurePath = Path;
+var PurePosixPath = Path;
+var PureWindowsPath = Path;
+var PosixPath = Path;
+var WindowsPath = Path;
+
+export {
+  Path,
+  PurePath,
+  PurePosixPath,
+  PureWindowsPath,
+  PosixPath,
+  WindowsPath,
+  pathlib_node_exports
+};