@gjsify/path 0.0.1 → 0.1.1

package/README.md

@@ -1,3 +1,27 @@
-# @gjsify/path [![License: ISC](https://img.shields.io/badge/License-ISC-yellow.svg)](https://opensource.org/licenses/ISC)
+# @gjsify/path
 
-path core module for [gjs](https://gitlab.gnome.org/GNOME/gjs) forked from [@cgjs/path](https://github.com/cgjs/cgjs/tree/master/packages/path)
+GJS implementation of the Node.js `path` module. Provides full POSIX and Win32 path utilities.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/path
+# or
+yarn add @gjsify/path
+```
+
+## Usage
+
+```typescript
+import { join, resolve, basename, dirname, extname } from '@gjsify/path';
+
+console.log(join('/home', 'user', 'file.txt'));
+console.log(resolve('relative/path'));
+console.log(basename('/home/user/file.txt')); // 'file.txt'
+```
+
+## License
+
+MIT

package/lib/esm/constants.js

@@ -0,0 +1,20 @@
+const CHAR_DOT = 46;
+const CHAR_FORWARD_SLASH = 47;
+const CHAR_BACKWARD_SLASH = 92;
+const CHAR_COLON = 58;
+const CHAR_QUESTION_MARK = 63;
+const CHAR_LOWERCASE_A = 97;
+const CHAR_LOWERCASE_Z = 122;
+const CHAR_UPPERCASE_A = 65;
+const CHAR_UPPERCASE_Z = 90;
+export {
+  CHAR_BACKWARD_SLASH,
+  CHAR_COLON,
+  CHAR_DOT,
+  CHAR_FORWARD_SLASH,
+  CHAR_LOWERCASE_A,
+  CHAR_LOWERCASE_Z,
+  CHAR_QUESTION_MARK,
+  CHAR_UPPERCASE_A,
+  CHAR_UPPERCASE_Z
+};

package/lib/esm/index.js

@@ -0,0 +1,52 @@
+import * as posix from "./posix.js";
+import * as win32 from "./win32.js";
+const {
+  resolve,
+  normalize,
+  isAbsolute,
+  join,
+  relative,
+  toNamespacedPath,
+  dirname,
+  basename,
+  extname,
+  format,
+  parse,
+  sep,
+  delimiter
+} = posix;
+var index_default = {
+  resolve: posix.resolve,
+  normalize: posix.normalize,
+  isAbsolute: posix.isAbsolute,
+  join: posix.join,
+  relative: posix.relative,
+  toNamespacedPath: posix.toNamespacedPath,
+  dirname: posix.dirname,
+  basename: posix.basename,
+  extname: posix.extname,
+  format: posix.format,
+  parse: posix.parse,
+  sep: posix.sep,
+  delimiter: posix.delimiter,
+  posix,
+  win32
+};
+export {
+  basename,
+  index_default as default,
+  delimiter,
+  dirname,
+  extname,
+  format,
+  isAbsolute,
+  join,
+  normalize,
+  parse,
+  posix,
+  relative,
+  resolve,
+  sep,
+  toNamespacedPath,
+  win32
+};

package/lib/esm/posix.js

@@ -0,0 +1,339 @@
+import { CHAR_DOT, CHAR_FORWARD_SLASH } from "./constants.js";
+import {
+  assertPath,
+  isPosixPathSeparator,
+  normalizeString,
+  _format
+} from "./util.js";
+const sep = "/";
+const delimiter = ":";
+function posixCwd() {
+  if (typeof globalThis.process?.cwd === "function") {
+    return globalThis.process.cwd();
+  }
+  try {
+    const GLib = globalThis.imports?.gi?.GLib;
+    if (GLib?.get_current_dir) {
+      return GLib.get_current_dir();
+    }
+  } catch {
+  }
+  return "/";
+}
+function resolve(...pathSegments) {
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    let path;
+    if (i >= 0) {
+      path = pathSegments[i];
+      assertPath(path);
+      if (path.length === 0) continue;
+    } else {
+      path = posixCwd();
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator);
+  if (resolvedAbsolute) {
+    if (resolvedPath.length > 0) {
+      return `/${resolvedPath}`;
+    }
+    return "/";
+  } else if (resolvedPath.length > 0) {
+    return resolvedPath;
+  }
+  return ".";
+}
+function normalize(path) {
+  assertPath(path);
+  if (path.length === 0) return ".";
+  const isAbsolutePath = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;
+  let normalized = normalizeString(path, !isAbsolutePath, "/", isPosixPathSeparator);
+  if (normalized.length === 0 && !isAbsolutePath) {
+    normalized = ".";
+  }
+  if (normalized.length > 0 && trailingSeparator) {
+    normalized += "/";
+  }
+  if (isAbsolutePath) {
+    return `/${normalized}`;
+  }
+  return normalized;
+}
+function isAbsolute(path) {
+  assertPath(path);
+  return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+}
+function join(...paths) {
+  if (paths.length === 0) return ".";
+  let joined;
+  for (let i = 0; i < paths.length; ++i) {
+    const arg = paths[i];
+    assertPath(arg);
+    if (arg.length > 0) {
+      if (joined === void 0) {
+        joined = arg;
+      } else {
+        joined += `/${arg}`;
+      }
+    }
+  }
+  if (joined === void 0) return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  assertPath(from);
+  assertPath(to);
+  if (from === to) return "";
+  from = resolve(from);
+  to = resolve(to);
+  if (from === to) return "";
+  let fromStart = 1;
+  const fromEnd = from.length;
+  const fromLen = fromEnd - fromStart;
+  let toStart = 1;
+  const toLen = to.length - toStart;
+  const length = fromLen < toLen ? fromLen : toLen;
+  let lastCommonSep = -1;
+  let i = 0;
+  for (; i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
+          return to.slice(toStart + i + 1);
+        } else if (i === 0) {
+          return to.slice(toStart + i);
+        }
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
+          lastCommonSep = i;
+        } else if (i === 0) {
+          lastCommonSep = 0;
+        }
+      }
+      break;
+    }
+    const fromCode = from.charCodeAt(fromStart + i);
+    const toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode) break;
+    if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i;
+  }
+  let out = "";
+  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+    if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+      if (out.length === 0) {
+        out += "..";
+      } else {
+        out += "/..";
+      }
+    }
+  }
+  if (out.length > 0) {
+    return out + to.slice(toStart + lastCommonSep);
+  }
+  toStart += lastCommonSep;
+  if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) {
+    ++toStart;
+  }
+  return to.slice(toStart);
+}
+function toNamespacedPath(path) {
+  return path;
+}
+function dirname(path) {
+  assertPath(path);
+  if (path.length === 0) return ".";
+  const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  let end = -1;
+  let matchedSlash = true;
+  for (let i = path.length - 1; i >= 1; --i) {
+    if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else {
+      matchedSlash = false;
+    }
+  }
+  if (end === -1) return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1) return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== void 0) assertPath(ext);
+  assertPath(path);
+  let start = 0;
+  let end = -1;
+  let matchedSlash = true;
+  if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path) return "";
+    let extIdx = ext.length - 1;
+    let firstNonSlashEnd = -1;
+    for (let i = path.length - 1; i >= 0; --i) {
+      const code = path.charCodeAt(i);
+      if (code === CHAR_FORWARD_SLASH) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1) {
+          matchedSlash = false;
+          firstNonSlashEnd = i + 1;
+        }
+        if (extIdx >= 0) {
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1) {
+              end = i;
+            }
+          } else {
+            extIdx = -1;
+            end = firstNonSlashEnd;
+          }
+        }
+      }
+    }
+    if (start === end) end = firstNonSlashEnd;
+    else if (end === -1) end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (let i = path.length - 1; i >= 0; --i) {
+      if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1) {
+        matchedSlash = false;
+        end = i + 1;
+      }
+    }
+    if (end === -1) return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  let startDot = -1;
+  let startPart = 0;
+  let end = -1;
+  let matchedSlash = true;
+  let preDotState = 0;
+  for (let i = path.length - 1; i >= 0; --i) {
+    const code = path.charCodeAt(i);
+    if (code === CHAR_FORWARD_SLASH) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1) {
+      matchedSlash = false;
+      end = i + 1;
+    }
+    if (code === CHAR_DOT) {
+      if (startDot === -1) {
+        startDot = i;
+      } else if (preDotState !== 1) {
+        preDotState = 1;
+      }
+    } else if (startDot !== -1) {
+      preDotState = -1;
+    }
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    return "";
+  }
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object") {
+    throw new TypeError(
+      'The "pathObject" argument must be of type Object. Received type ' + typeof pathObject
+    );
+  }
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  const ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0) return ret;
+  const isAbsolutePath = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  let start;
+  if (isAbsolutePath) {
+    ret.root = "/";
+    start = 1;
+  } else {
+    start = 0;
+  }
+  let startDot = -1;
+  let startPart = 0;
+  let end = -1;
+  let matchedSlash = true;
+  let i = path.length - 1;
+  let preDotState = 0;
+  for (; i >= start; --i) {
+    const code = path.charCodeAt(i);
+    if (code === CHAR_FORWARD_SLASH) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1) {
+      matchedSlash = false;
+      end = i + 1;
+    }
+    if (code === CHAR_DOT) {
+      if (startDot === -1) startDot = i;
+      else if (preDotState !== 1) preDotState = 1;
+    } else if (startDot !== -1) {
+      preDotState = -1;
+    }
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1) {
+      if (startPart === 0 && isAbsolutePath) {
+        ret.base = ret.name = path.slice(1, end);
+      } else {
+        ret.base = ret.name = path.slice(startPart, end);
+      }
+    }
+  } else {
+    if (startPart === 0 && isAbsolutePath) {
+      ret.name = path.slice(1, startDot);
+      ret.base = path.slice(1, end);
+    } else {
+      ret.name = path.slice(startPart, startDot);
+      ret.base = path.slice(startPart, end);
+    }
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0) {
+    ret.dir = path.slice(0, startPart - 1);
+  } else if (isAbsolutePath) {
+    ret.dir = "/";
+  }
+  return ret;
+}
+export {
+  basename,
+  delimiter,
+  dirname,
+  extname,
+  format,
+  isAbsolute,
+  join,
+  normalize,
+  parse,
+  relative,
+  resolve,
+  sep,
+  toNamespacedPath
+};

package/lib/esm/util.js

@@ -0,0 +1,113 @@
+import {
+  CHAR_DOT,
+  CHAR_FORWARD_SLASH,
+  CHAR_BACKWARD_SLASH
+} from "./constants.js";
+function assertPath(path) {
+  if (typeof path !== "string") {
+    throw new TypeError(
+      'The "path" argument must be of type string. Received type ' + typeof path
+    );
+  }
+}
+function isPosixPathSeparator(code) {
+  return code === CHAR_FORWARD_SLASH;
+}
+function isPathSeparator(code) {
+  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+}
+function isWindowsDeviceRoot(code) {
+  return code >= 65 && code <= 90 || // A-Z
+  code >= 97 && code <= 122;
+}
+function normalizeString(path, allowAboveRoot, separator, isPathSep) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let code;
+  for (let i = 0; i <= path.length; ++i) {
+    if (i < path.length) {
+      code = path.charCodeAt(i);
+    } else if (isPathSep(code)) {
+      break;
+    } else {
+      code = CHAR_FORWARD_SLASH;
+    }
+    if (isPathSep(code)) {
+      if (lastSlash === i - 1 || dots === 1) {
+      } else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || res.charCodeAt(res.length - 2) !== CHAR_DOT) {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf(separator);
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
+            }
+            lastSlash = i;
+            dots = 0;
+            continue;
+          } else if (res.length === 2 || res.length === 1) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0) {
+            res += `${separator}..`;
+          } else {
+            res = "..";
+          }
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += separator + path.slice(lastSlash + 1, i);
+        } else {
+          res = path.slice(lastSlash + 1, i);
+        }
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === CHAR_DOT && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  if (pathObject === null || typeof pathObject !== "object") {
+    throw new TypeError(
+      'The "pathObject" argument must be of type Object. Received type ' + typeof pathObject
+    );
+  }
+  const dir = pathObject.dir || pathObject.root;
+  const base = pathObject.base || (pathObject.name || "") + formatExt(pathObject.ext);
+  if (!dir) {
+    return base;
+  }
+  if (dir === pathObject.root) {
+    return dir + base;
+  }
+  return dir + sep + base;
+}
+function formatExt(ext) {
+  return ext ? `${ext[0] === "." ? "" : "."}${ext}` : "";
+}
+export {
+  _format,
+  assertPath,
+  isPathSeparator,
+  isPosixPathSeparator,
+  isWindowsDeviceRoot,
+  normalizeString
+};