nice-path 3.1.0 → 3.2.0

package/dist/index.d.ts

@@ -1,5 +1,11 @@
 /** An object that represents a filesystem path. */
 export declare class Path {
+    /** Used by {@link _isWin32DriveLetter}. */
+    protected static _WIN32_DRIVE_LETTER_REGEXP: RegExp;
+    /** Used by {@link Path.prototype.toString}. */
+    protected static _isWin32DriveLetter(pathString: string): boolean;
+    /** Filter out empty path segments except for 1-2 leading empty segments. */
+    protected static _validateSegments(segments: Array<string>, separator: string): Array<string>;
     /** Split one or more path strings into an array of path segments. */
     static splitToSegments(inputParts: Array<string> | string): Array<string>;
     /**
@@ -32,6 +38,7 @@ export declare class Path {
      * Will be either `/` or `\`.
      */
     separator: string;
+    protected __is_Path: true;
     /** Create a new Path object using the provided input(s). */
     constructor(...inputs: Array<string | Path | Array<string | Path>>);
     /**
@@ -54,14 +61,14 @@ export declare class Path {
     /**
      * Resolve all non-leading `.` and `..` segments in this path.
      */
-    normalize(): Path;
+    normalize(): this;
     /**
      * Create a new Path by appending additional path segments onto the end of
      * this Path's segments.
      *
      * The returned path will use this path's separator.
      */
-    concat(...others: Array<string | Path | Array<string | Path>>): Path;
+    concat(...others: Array<string | Path | Array<string | Path>>): this;
     /**
      * Return whether this path is absolute; that is, whether it starts with
      * either `/`, `\`, or a drive letter (ie `C:`).
@@ -72,6 +79,14 @@ export declare class Path {
      * this one.
      */
     clone(): this;
+    /**
+     * Returns a boolean indicating whether `other` is a Path instance.
+     *
+     * Works cross-context/realm/iframe/etc.
+     *
+     * @param other - Any value
+     */
+    static isPath(other: unknown): other is Path;
     /**
      * Express this path relative to `dir`.
      *
@@ -80,7 +95,7 @@ export declare class Path {
      */
     relativeTo(dir: Path | string, options?: {
         noLeadingDot?: boolean;
-    }): Path;
+    }): this;
     /**
      * Turn this path into a string by joining its segments using its separator.
      */
@@ -101,7 +116,7 @@ export declare class Path {
      * Return a new Path containing all of the path segments in this one except
      * for the last one; ie. the path to the directory that contains this path.
      */
-    dirname(): Path;
+    dirname(): this;
     /**
      * Return whether this path starts with the provided value, by comparing one
      * path segment at a time.
@@ -163,7 +178,7 @@ export declare class Path {
      *
      * NOTE: to remove segments, use an empty Array for `replacement`.
      */
-    replace(value: string | Path | Array<string | Path>, replacement: string | Path | Array<string | Path>): Path;
+    replace(value: string | Path | Array<string | Path>, replacement: string | Path | Array<string | Path>): this;
     /**
      * Return a new Path wherein all occurrences of the segments in `value` have
      * been replaced with the segments in `replacement`. If the segments in
@@ -172,13 +187,13 @@ export declare class Path {
      * @param value - What should be replaced
      * @param replacement - What it should be replaced with
      */
-    replaceAll(value: string | Path | Array<string | Path>, replacement: string | Path | Array<string | Path>): Path;
+    replaceAll(value: string | Path | Array<string | Path>, replacement: string | Path | Array<string | Path>): this;
     /**
      * Return a copy of this path but with the final segment replaced with `replacement`
      *
      * @param replacement - The new final segment(s) for the returned Path
      */
-    replaceLast(replacement: string | Path | Array<string | Path>): Path;
+    replaceLast(replacement: string | Path | Array<string | Path>): this;
     /**
      * Return a boolean indicating whether this Path has the same separator and
      * segments as another Path.

package/dist/index.js

@@ -1,35 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Path = void 0;
-const WIN32_DRIVE_LETTER_REGEXP = /^[A-Za-z]:$/;
-function isWin32DriveLetter(pathString) {
-    return WIN32_DRIVE_LETTER_REGEXP.test(pathString);
-}
-function validateSegments(segments, separator) {
-    return segments.filter((part, index) => {
-        // first part can be "" to represent left side of root "/"
-        // second part can be "" to support windows UNC paths
-        if (part === "" && index === 0) {
-            return true;
-        }
-        else if (part === "" &&
-            index === 1 &&
-            separator === "\\" &&
-            segments[0] === "") {
-            return true;
-        }
-        return Boolean(part);
-    });
-}
 /** An object that represents a filesystem path. */
 class Path {
+    /** Used by {@link Path.prototype.toString}. */
+    static _isWin32DriveLetter(pathString) {
+        return this._WIN32_DRIVE_LETTER_REGEXP.test(pathString);
+    }
+    /** Filter out empty path segments except for 1-2 leading empty segments. */
+    static _validateSegments(segments, separator) {
+        return segments.filter((part, index) => {
+            // first part can be "" to represent left side of root "/"
+            // second part can be "" to support windows UNC paths
+            if (part === "" && index === 0) {
+                return true;
+            }
+            else if (part === "" &&
+                index === 1 &&
+                separator === "\\" &&
+                segments[0] === "") {
+                return true;
+            }
+            return Boolean(part);
+        });
+    }
     /** Split one or more path strings into an array of path segments. */
     static splitToSegments(inputParts) {
         if (!Array.isArray(inputParts)) {
             inputParts = [inputParts];
         }
-        const separator = Path.detectSeparator(inputParts, "/");
-        return validateSegments(inputParts.map((part) => part.split(/(?:\/|\\)/g)).flat(1), separator);
+        const separator = this.detectSeparator(inputParts, "/");
+        return this._validateSegments(inputParts.map((part) => part.split(/(?:\/|\\)/g)).flat(1), separator);
     }
     /**
      * Search the provided path string or strings for a path separator character
@@ -56,18 +57,18 @@ class Path {
      * `..` segments.
      */
     static normalize(...inputs) {
-        return new Path(...inputs).normalize();
+        return new this(...inputs).normalize();
     }
     /**
      * Return whether the provided path is absolute; that is, whether it
      * starts with either `/`, `\`, or a drive letter (ie `C:`).
      */
     static isAbsolute(path) {
-        if (path instanceof Path) {
+        if (this.constructor.isPath(path)) {
             return path.isAbsolute();
         }
         else {
-            return new Path(path).isAbsolute();
+            return new this(path).isAbsolute();
         }
     }
     /** Create a new Path object using the provided input(s). */
@@ -76,8 +77,13 @@ class Path {
             .flat(1)
             .map((part) => (typeof part === "string" ? part : part.segments))
             .flat(1);
-        this.segments = Path.splitToSegments(parts);
-        this.separator = Path.detectSeparator(parts, "/");
+        this.segments = this.constructor.splitToSegments(parts);
+        this.separator = this.constructor.detectSeparator(parts, "/");
+        Object.defineProperty(this, "__is_Path", {
+            configurable: true,
+            enumerable: false,
+            value: true,
+        });
     }
     /**
      * Create a new Path object using the provided segments and, optionally,
@@ -88,9 +94,9 @@ class Path {
      * `.segments` directly, use {@link fromRaw}.
      */
     static from(segments, separator) {
-        const separatorToUse = separator || Path.detectSeparator(segments, "/");
-        const path = new Path();
-        path.segments = validateSegments(segments, separatorToUse);
+        const separatorToUse = separator || this.detectSeparator(segments, "/");
+        const path = new this();
+        path.segments = this._validateSegments(segments, separatorToUse);
         path.separator = separatorToUse;
         return path;
     }
@@ -102,7 +108,7 @@ class Path {
      * {@link from} instead.
      */
     static fromRaw(segments, separator) {
-        const path = new Path();
+        const path = new this();
         path.segments = segments;
         path.separator = separator;
         return path;
@@ -141,7 +147,7 @@ class Path {
                 }
             }
         }
-        return Path.fromRaw(newSegments, this.separator);
+        return this.constructor.fromRaw(newSegments, this.separator);
     }
     /**
      * Create a new Path by appending additional path segments onto the end of
@@ -150,8 +156,9 @@ class Path {
      * The returned path will use this path's separator.
      */
     concat(...others) {
-        const otherSegments = new Path(others.flat(1)).segments;
-        return Path.from(this.segments.concat(otherSegments), this.separator);
+        const otherSegments = new this.constructor(others.flat(1))
+            .segments;
+        return this.constructor.from(this.segments.concat(otherSegments), this.separator);
     }
     /**
      * Return whether this path is absolute; that is, whether it starts with
@@ -176,6 +183,18 @@ class Path {
         const theClone = this.constructor.fromRaw([...this.segments], this.separator);
         return theClone;
     }
+    /**
+     * Returns a boolean indicating whether `other` is a Path instance.
+     *
+     * Works cross-context/realm/iframe/etc.
+     *
+     * @param other - Any value
+     */
+    static isPath(other) {
+        return (typeof other === "object" &&
+            other !== null &&
+            other.__is_Path === true);
+    }
     /**
      * Express this path relative to `dir`.
      *
@@ -183,8 +202,8 @@ class Path {
      * @param options - Options that affect the resulting path.
      */
     relativeTo(dir, options = {}) {
-        if (!(dir instanceof Path)) {
-            dir = new Path(dir);
+        if (!this.constructor.isPath(dir)) {
+            dir = new this.constructor(dir);
         }
         const ownSegments = [...this.segments];
         const dirSegments = [...dir.segments];
@@ -194,15 +213,15 @@ class Path {
         }
         if (dirSegments.length === 0) {
             if (options.noLeadingDot) {
-                return Path.from(ownSegments, this.separator);
+                return this.constructor.from(ownSegments, this.separator);
             }
             else {
-                return Path.from([".", ...ownSegments], this.separator);
+                return this.constructor.from([".", ...ownSegments], this.separator);
             }
         }
         else {
             const dotDots = dirSegments.map((_) => "..");
-            return Path.from([...dotDots, ...ownSegments], this.separator);
+            return this.constructor.from([...dotDots, ...ownSegments], this.separator);
         }
     }
     /**
@@ -214,7 +233,7 @@ class Path {
             return "/";
         }
         else {
-            if (isWin32DriveLetter(result)) {
+            if (this.constructor._isWin32DriveLetter(result)) {
                 return result + this.separator;
             }
             else {
@@ -271,7 +290,7 @@ class Path {
      * Path B does *not* start with Path A, because `".config" !== ".config2"`.
      */
     startsWith(value) {
-        value = new Path(value);
+        value = new this.constructor(value);
         return value.segments.every((segment, index) => this.segments[index] === segment);
     }
     /**
@@ -291,7 +310,7 @@ class Path {
      * Path A does *not* end with Path B, because `"1user" !== "user"`.
      */
     endsWith(value) {
-        value = new Path(value);
+        value = new this.constructor(value);
         const valueSegmentsReversed = [...value.segments].reverse();
         const ownSegmentsReversed = [...this.segments].reverse();
         return valueSegmentsReversed.every((segment, index) => ownSegmentsReversed[index] === segment);
@@ -304,7 +323,7 @@ class Path {
      * @param fromIndex - The index into this path's segments to begin searching at. Defaults to `0`.
      */
     indexOf(value, fromIndex = 0) {
-        value = new Path(value);
+        value = new this.constructor(value);
         const ownSegmentsLength = this.segments.length;
         for (let i = fromIndex; i < ownSegmentsLength; i++) {
             if (value.segments.every((valueSegment, valueIndex) => {
@@ -337,8 +356,8 @@ class Path {
      * NOTE: to remove segments, use an empty Array for `replacement`.
      */
     replace(value, replacement) {
-        value = new Path(value);
-        replacement = new Path(replacement);
+        value = new this.constructor(value);
+        replacement = new this.constructor(replacement);
         const matchIndex = this.indexOf(value);
         if (matchIndex === -1) {
             return this.clone();
@@ -349,7 +368,7 @@ class Path {
                 ...replacement.segments,
                 ...this.segments.slice(matchIndex + value.segments.length),
             ];
-            return Path.from(newSegments, this.separator);
+            return this.constructor.from(newSegments, this.separator);
         }
     }
     /**
@@ -361,7 +380,7 @@ class Path {
      * @param replacement - What it should be replaced with
      */
     replaceAll(value, replacement) {
-        replacement = new Path(replacement);
+        replacement = new this.constructor(replacement);
         let searchIndex = 0;
         let currentPath = this;
         const ownLength = this.segments.length;
@@ -383,11 +402,11 @@ class Path {
      * @param replacement - The new final segment(s) for the returned Path
      */
     replaceLast(replacement) {
-        replacement = new Path(replacement);
+        replacement = new this.constructor(replacement);
         const segments = [...this.segments];
         segments.pop();
         segments.push(...replacement.segments);
-        return Path.from(segments, this.separator);
+        return this.constructor.from(segments, this.separator);
     }
     /**
      * Return a boolean indicating whether this Path has the same separator and
@@ -396,8 +415,8 @@ class Path {
      * To check only segments and not separator, use {@link Path.prototype.hasEqualSegments}.
      */
     equals(other) {
-        if (!(other instanceof Path)) {
-            other = new Path(other);
+        if (!this.constructor.isPath(other)) {
+            other = new this.constructor(other);
         }
         return other.separator === this.separator && this.hasEqualSegments(other);
     }
@@ -406,8 +425,8 @@ class Path {
      * another Path. **Separator is not checked; use {@link Path.prototype.equals} for that.**
      */
     hasEqualSegments(other) {
-        if (!(other instanceof Path)) {
-            other = new Path(other);
+        if (!this.constructor.isPath(other)) {
+            other = new this.constructor(other);
         }
         return (this.segments.length === other.segments.length &&
             this.segments.every((segment, index) => {
@@ -416,3 +435,5 @@ class Path {
     }
 }
 exports.Path = Path;
+/** Used by {@link _isWin32DriveLetter}. */
+Path._WIN32_DRIVE_LETTER_REGEXP = /^[A-Za-z]:$/;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nice-path",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {