@reliverse/pathkit 1.0.6 → 1.1.0

package/package.json

@@ -1,11 +1,30 @@
 {
-  "description": "@reliverse/pathkit is a slash‑consistent, cross‑platform path manipulation—drop‑in for node:path, always POSIX forward slash. @reliverse/pathkit-plus is a utility library which extends the core library with a set of functions for manipulating file paths.",
+  "dependencies": {},
+  "description": "@reliverse/pathkit is a slash‑consistent, cross‑platform path manipulation, with POSIX forward slash, drop‑in for node:path and unjs/pathe. This library extends the node:path module with a set of functions for manipulating file paths.",
+  "homepage": "https://docs.reliverse.org",
   "license": "MIT",
   "name": "@reliverse/pathkit",
   "type": "module",
-  "version": "1.0.6",
-  "dependencies": {},
-  "devDependencies": {},
+  "version": "1.1.0",
+  "devDependencies": {
+    "@biomejs/biome": "1.9.4",
+    "@eslint/js": "^9.27.0",
+    "@reliverse/dler": "^1.3.6",
+    "@reliverse/relifso": "^1.2.10",
+    "@reliverse/relinka": "^1.4.5",
+    "@reliverse/rematch": "^1.1.0",
+    "@stylistic/eslint-plugin": "^4.2.0",
+    "@types/bun": "^1.2.13",
+    "@types/node": "^22.15.21",
+    "eslint": "^9.27.0",
+    "eslint-plugin-no-relative-import-paths": "^1.6.1",
+    "eslint-plugin-perfectionist": "^4.13.0",
+    "knip": "^5.57.0",
+    "magic-string": "^0.30.17",
+    "p-map": "^7.0.3",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.32.1"
+  },
   "exports": {
     ".": "./bin/mod.js"
   },

package/bin/delete-me.d.ts

@@ -1 +0,0 @@
-export declare const deleteMe = "delete-me";

package/bin/delete-me.js

@@ -1 +0,0 @@
-export const deleteMe = "delete-me";

package/bin/pathkit-impl/impl.d.ts

@@ -1,9 +0,0 @@
-export * from "./internal/path.js";
-/**
- * The platform-specific file delimiter.
- *
- * Equals to `";"` in windows and `":"` in all other platforms.
- */
-export declare const delimiter: ";" | ":";
-export declare const posix: import("path").PlatformPath;
-export declare const win32: import("path").PlatformPath;

package/bin/pathkit-impl/impl.js

@@ -1,16 +0,0 @@
-import * as _path from "./internal/path.js";
-export * from "./internal/path.js";
-export const delimiter = /* @__PURE__ */ (() => globalThis.process?.platform === "win32" ? ";" : ":")();
-const _platforms = { posix: void 0, win32: void 0 };
-const mix = (del = delimiter) => {
-  return new Proxy(_path, {
-    get(_, prop) {
-      if (prop === "delimiter") return del;
-      if (prop === "posix") return posix;
-      if (prop === "win32") return win32;
-      return _platforms[prop] || _path[prop];
-    }
-  });
-};
-export const posix = /* @__PURE__ */ mix(":");
-export const win32 = /* @__PURE__ */ mix(";");

package/bin/pathkit-impl/internal/path.d.ts

@@ -1,26 +0,0 @@
-import type path from "node:path";
-/**
- * Constant for path separator.
- *
- * Always equals to `"/"`.
- */
-export declare const sep = "/";
-export declare const normalize: typeof path.normalize;
-export declare const join: typeof path.join;
-export declare const resolve: typeof path.resolve;
-/**
- * Resolves a string path, resolving '.' and '.' segments and allowing paths above the root.
- *
- * @param path - The path to normalise.
- * @param allowAboveRoot - Whether to allow the resulting path to be above the root directory.
- * @returns the normalised path string.
- */
-export declare function normalizeString(path: string, allowAboveRoot: boolean): string;
-export declare const isAbsolute: typeof path.isAbsolute;
-export declare const toNamespacedPath: typeof path.toNamespacedPath;
-export declare const extname: typeof path.extname;
-export declare const relative: typeof path.relative;
-export declare const dirname: typeof path.dirname;
-export declare const format: typeof path.format;
-export declare const basename: typeof path.basename;
-export declare const parse: typeof path.parse;

package/bin/pathkit-impl/internal/path.js

@@ -1,208 +0,0 @@
-import { deleteMe } from "../../delete-me.js";
-import { normalizeWindowsPath } from "./win.js";
-const _UNC_REGEX = /^[/\\]{2}/;
-const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
-const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
-const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
-const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
-export const sep = "/";
-export const normalize = (path) => {
-  if (path.length === 0) {
-    return ".";
-  }
-  path = normalizeWindowsPath(path);
-  const isUNCPath = _UNC_REGEX.exec(path);
-  const isPathAbsolute = isAbsolute(path);
-  const trailingSeparator = path.endsWith("/");
-  path = normalizeString(path, !isPathAbsolute);
-  if (path.length === 0) {
-    if (isPathAbsolute) {
-      return "/";
-    }
-    return trailingSeparator ? "./" : ".";
-  }
-  if (trailingSeparator) {
-    path += "/";
-  }
-  if (_DRIVE_LETTER_RE.test(path)) {
-    path += "/";
-  }
-  if (isUNCPath) {
-    if (!isPathAbsolute) {
-      return `//./${path}`;
-    }
-    return `//${path}`;
-  }
-  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
-};
-export const join = (...segments) => {
-  let path = "";
-  for (const seg of segments) {
-    if (!seg) {
-      continue;
-    }
-    if (path.length > 0) {
-      const pathTrailing = path.endsWith("/");
-      const segLeading = seg.startsWith("/");
-      const both = pathTrailing && segLeading;
-      if (both) {
-        path += seg.slice(1);
-      } else {
-        path += pathTrailing || segLeading ? seg : `/${seg}`;
-      }
-    } else {
-      path += seg;
-    }
-  }
-  return normalize(path);
-};
-function cwd() {
-  if (typeof process !== "undefined" && typeof process.cwd === "function") {
-    return process.cwd().replace(/\\/g, "/");
-  }
-  return "/";
-}
-export const resolve = (...arguments_) => {
-  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-    const path = index >= 0 ? arguments_[index] : cwd();
-    if (!path || path.length === 0) {
-      continue;
-    }
-    resolvedPath = `${path}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute(path);
-  }
-  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
-    return `/${resolvedPath}`;
-  }
-  return resolvedPath.length > 0 ? resolvedPath : ".";
-};
-export function normalizeString(path, allowAboveRoot) {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let char = null;
-  for (let index = 0; index <= path.length; ++index) {
-    if (index < path.length) {
-      char = path[index];
-    } else if (char === "/") {
-      break;
-    } else {
-      char = "/";
-    }
-    if (char === "/") {
-      if (lastSlash === index - 1 || dots === 1) {
-      } else if (dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || !res.endsWith(".") || res[res.length - 2] !== ".") {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex === -1) {
-              res = "";
-              lastSegmentLength = 0;
-            } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-            }
-            lastSlash = index;
-            dots = 0;
-            continue;
-          }
-          if (res.length > 0) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = index;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          res += res.length > 0 ? "/.." : "..";
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (res.length > 0) {
-          res += `/${path.slice(lastSlash + 1, index)}`;
-        } else {
-          res = path.slice(lastSlash + 1, index);
-        }
-        lastSegmentLength = index - lastSlash - 1;
-      }
-      lastSlash = index;
-      dots = 0;
-    } else if (char === "." && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
-    }
-  }
-  return res;
-}
-export const isAbsolute = (p) => _IS_ABSOLUTE_RE.test(p);
-export const toNamespacedPath = (p) => normalizeWindowsPath(p);
-export const extname = (p) => {
-  if (p === "..") return "";
-  const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
-  return match?.[1] || "";
-};
-export const relative = (from, to) => {
-  const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
-  const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
-  if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
-    return _to.join("/");
-  }
-  const _fromCopy = [..._from];
-  for (const segment of _fromCopy) {
-    if (_to[0] !== segment) {
-      break;
-    }
-    _from.shift();
-    _to.shift();
-  }
-  return [..._from.map(() => ".."), ..._to].join("/");
-};
-export const dirname = (p) => {
-  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
-  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
-    segments[0] += "/";
-  }
-  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
-};
-export const format = (p) => {
-  const ext = p.ext ? p.ext.startsWith(".") ? p.ext : `.${p.ext}` : "";
-  const segments = [p.root, p.dir, p.base ?? (p.name ?? "") + ext].filter(
-    Boolean
-  );
-  return normalizeWindowsPath(
-    segments.length > 0 ? resolve(...segments) : segments.join("/")
-  );
-};
-export const basename = (p, extension) => {
-  const segments = normalizeWindowsPath(p).split("/");
-  let lastSegment = "";
-  for (let i = segments.length - 1; i >= 0; i--) {
-    const val = segments[i];
-    if (val) {
-      lastSegment = val;
-      break;
-    }
-  }
-  return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
-};
-export const parse = (p) => {
-  const root = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
-  const base = basename(p);
-  const extension = extname(base);
-  return {
-    root,
-    dir: dirname(p),
-    base,
-    ext: extension,
-    name: base.slice(0, base.length - extension.length)
-  };
-};
-console.log("deleteMe", deleteMe);

package/bin/pathkit-impl/internal/win.d.ts

@@ -1 +0,0 @@
-export declare function normalizeWindowsPath(input?: string): string;

package/bin/pathkit-impl/internal/win.js

@@ -1,7 +0,0 @@
-const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
-export function normalizeWindowsPath(input = "") {
-  if (!input) {
-    return input;
-  }
-  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
-}

package/bin/pathkit-impl/utils.d.ts

@@ -1,30 +0,0 @@
-/**
- * Normalises alias mappings, ensuring that more specific aliases are resolved before less specific ones.
- * This function also ensures that aliases do not resolve to themselves cyclically.
- *
- * @param _aliases - A set of alias mappings where each key is an alias and its value is the actual path it points to.
- * @returns a set of normalised alias mappings.
- */
-export declare function normalizeAliases(_aliases: Record<string, string>): Record<string, string>;
-/**
- * Resolves a path string to its alias if applicable, otherwise returns the original path.
- * This function normalises the path, resolves the alias and then joins it to the alias target if necessary.
- *
- * @param path - The path string to resolve.
- * @param aliases - A set of alias mappings to use for resolution.
- * @returns the resolved path as a string.
- */
-export declare function resolveAlias(path: string, aliases: Record<string, string>): any;
-/**
- * Resolves a path string to its possible alias.
- *
- * Returns an array of possible alias resolutions (could be empty), sorted by specificity (longest first).
- */
-export declare function reverseResolveAlias(path: string, aliases: Record<string, string>): string[];
-/**
- * Extracts the filename from a given path, excluding any directory paths and the file extension.
- *
- * @param path - The full path of the file from which to extract the filename.
- * @returns the filename without the extension, or `undefined` if the filename cannot be extracted.
- */
-export declare function filename(path: string): string | undefined;

package/bin/pathkit-impl/utils.js

@@ -1,75 +0,0 @@
-import { join } from "./internal/path.js";
-import { normalizeWindowsPath } from "./internal/win.js";
-const pathSeparators = /* @__PURE__ */ new Set(["/", "\\", void 0]);
-const normalizedAliasSymbol = Symbol.for("pathkit:normalizedAlias");
-const SLASH_RE = /[/\\]/;
-export function normalizeAliases(_aliases) {
-  if (_aliases[normalizedAliasSymbol]) {
-    return _aliases;
-  }
-  const aliases = Object.fromEntries(
-    Object.entries(_aliases).sort(([a], [b]) => _compareAliases(a, b))
-  );
-  for (const key in aliases) {
-    for (const alias in aliases) {
-      if (alias === key || key.startsWith(alias)) {
-        continue;
-      }
-      if (aliases[key]?.startsWith(alias) && pathSeparators.has(aliases[key][alias.length])) {
-        aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
-      }
-    }
-  }
-  Object.defineProperty(aliases, normalizedAliasSymbol, {
-    value: true,
-    enumerable: false
-  });
-  return aliases;
-}
-export function resolveAlias(path, aliases) {
-  const _path = normalizeWindowsPath(path);
-  aliases = normalizeAliases(aliases);
-  for (const [alias, to] of Object.entries(aliases)) {
-    if (!_path.startsWith(alias)) {
-      continue;
-    }
-    const _alias = hasTrailingSlash(alias) ? alias.slice(0, -1) : alias;
-    if (hasTrailingSlash(_path[_alias.length])) {
-      return join(to, _path.slice(alias.length));
-    }
-  }
-  return _path;
-}
-export function reverseResolveAlias(path, aliases) {
-  const _path = normalizeWindowsPath(path);
-  aliases = normalizeAliases(aliases);
-  const matches = [];
-  for (const [to, alias] of Object.entries(aliases)) {
-    if (!_path.startsWith(alias)) {
-      continue;
-    }
-    const _alias = hasTrailingSlash(alias) ? alias.slice(0, -1) : alias;
-    if (hasTrailingSlash(_path[_alias.length])) {
-      matches.push(join(to, _path.slice(alias.length)));
-    }
-  }
-  return matches.sort((a, b) => b.length - a.length);
-}
-export function filename(path) {
-  const base = path.split(SLASH_RE).pop();
-  if (!base) {
-    return void 0;
-  }
-  const separatorIndex = base.lastIndexOf(".");
-  if (separatorIndex <= 0) {
-    return base;
-  }
-  return base.slice(0, separatorIndex);
-}
-function _compareAliases(a, b) {
-  return b.split("/").length - a.split("/").length;
-}
-function hasTrailingSlash(path = "/") {
-  const lastChar = path[path.length - 1];
-  return lastChar === "/" || lastChar === "\\";
-}