@thingts/path - v2.0.4
    Preparing search index...

    Class AbsolutePath

    Represents an absolute filesystem path (i.e. a path starting at the root, i.e. has a leading separator), and provides methods for path resolution, manipulation and queries. AbsolutePath instances are normalized and immutable.

    AbsolutePath has the same functionality as RelativePath but with additional methods that are only valid for absolute paths: resolve(), relativeTo(), and descendsFrom().

    Note that AbsolutePath provides pure path manipulation, it does not access the filesystem in any way. (If you want to work with the filesystem, you can use the @thingts/fs-path library which extends AbsolutePath with filestem operations.)

    const p1 = new AbsolutePath('/project/demos')
    const p2 = p1.join('demo1/src', 'index.ts') // '/project/demos/demo1/src/index.ts'
    console.log(p2.descendsFrom(p1)) // true
    console.log(p2.relativeTo(p1)) // 'demo1/src/index.ts' (RelativePath)

    Implements

    Index

    Constructors

    constructor

    Accessors

    extension filename parent segments stem

    Methods

    descendsFrom equals join relativeTo replaceExtension replaceFilename replaceParent replaceStem resolve toString transformFilename

    Constructors

    • Create a new AbsolutePath from a string or another AbsolutePath.

      The path is normalized and guaranteed to be absolute. Any trailing separator is removed.

      Throws an error if the provided path is not absolute.

      Parameters

      Returns AbsolutePath

      new AbsolutePath('/project/demos') // OK
      new AbsolutePath('project/demos')  // Throws Error
      new AbsolutePath('/project//src/../demos/') // normalized => /project/demos

    Accessors

    • get extension(): string

      Returns the extension of the filename including the leading dot, as a string. If the filename has no extension, returns an empty string.

      Note that if the filename starts with a dot (e.g. .gitignore), that dot is considered part of the stem. So .gitignore has extension '' and .gitignore.bak has extension .bak

      Returns string

    • get parent(): this

      The parent directory of this path.

      Returns this

      A new instance pointing to the parent.

      new AbsolutePath('/a/b/c.txt').parent // AbsolutePath('/a/b')
      new RelativePath('a/b/c.txt').parent  // RelativePath('a/b')
    • get segments(): string[]

      The segments of this path as an array of strings.

      Returns string[]

      new AbsolutePath('/a/b/c.txt').segments // ['a', 'b', 'c.txt']
      new RelativePath('a/b/c.txt').segments  // ['a', 'b', 'c.txt']
    • get stem(): string

      Returns the stem of the filename, i.e. the part before the extension. If the filename has no extension, returns the entire filename

      Note that if the filename starts with a dot (e.g. .gitignore), that dot is considered part of the stem. So .gitignore and .gitignore.bak both have stem .gitignore

      Returns string

    Methods

    • Test whether this path is a descendant of the given ancestor path.

      Parameters

      • ancestor: string | AbsolutePath

        An AbsolutePath or string to check against.

      • Optionalopts: { includeSelf?: boolean }
        • OptionalincludeSelf?: boolean

          If true, return true when the paths are identical.

      Returns boolean

      True if this path descends from the ancestor, otherwise false.

      const p1 = new AbsolutePath('/project/demo')
      const p2 = new AbsolutePath('/project/demo/src/index.ts')
      console.log(p2.descendsFrom(p1)) // true
      console.log(p1.descendsFrom(p1)) // false
      console.log(p1.descendsFrom(p1, { includeSelf: true })) // true

    • Join additional path segments to this path.

      Accepts relative path objects and Filename segment arguments for type safety, but you can also directly pass strings for convenience. All args are stringified and interpreted as segments to be joined, regardless of whether they start with a path separator.

      Any null, undefined, or empty segments are ignored.

      Parameters

      Returns this

      A new instance with the segments appended and resulting path normalized.

      const a1 = new AbsolutePath('/project/demo')
      const a2 = a1.join('demo1/src', 'index.js') // → AbsolutePath('/project/demo/demo1/src/index.js')

      const r1 = new RelativePath('demo')
      const r2 = r1.join('demo1/src', 'index.js') // → RelativePath('demo/demo1/src/index.js')

    • Replace the filename extension, keeping the stem the same. The passed string can include or omit the leading dot; if omitted, it will be added.

      Parameters

      • newExt: string

        New extension, e.g. json or .json

      Returns this

      A new instance with the filename extension replaced.

      new AbsolutePath('/a/b/c.txt').replaceExtension('json') // '/a/b/c.json' (AbsolutePath)
      new RelativePath('a/b/c.txt').replaceExtension('.json') // '/a/b/c.json' (RelativePath)

    • Replace the filename (last segment).

      Parameters

      Returns this

      A new instance with the filename replaced.

      new AbsolutePath('/a/b/c.txt').replaceFilename('d.json') // → AbsolutePath('/a/b/d.json')
      new RelativePath('a/b/c.txt').replaceFilename('d.json')  // → RelativePath('a/b/d.json')

    • Replace the entire directory path through the parent, while keeping the current filename.

      Parameters

      • newParent: string | AbsolutePath

        Parent directory as string or another path

      Returns this

      A new path rooted at newParent with the same filename.

      new AbsolutePath('/old/file.txt').replaceParent('/new/dir') // '/new/dir/file.txt' (AbsolutePath)
      new RelativePath('old/file.txt').replaceParent('new/dir')   // 'new/dir/file.txt' (RelativePath)

    • Replace the filename stem, keeping the extension the same

      Parameters

      • newStem: string

      Returns this

      A new instance with the filename stem replaced.

      new AbsolutePath('/a/b/c.txt').replaceStem('d') // → AbsolutePath('/a/b/d.txt')
      new RelativePath('a/b/c.txt').replaceStem('d')  // → RelativePath('a/b/d.txt')

    • Resolve additional paths or components against this absolute path.

      Similar to join(), except that if any argument is absolute, the current path is discarded and resolution starts from that argument.

      Parameters

      Returns this

      A new instance of this type, representing the resolved path.

      const p1 = new AbsolutePath('/project/demos')
      const p2 = p1.resolve('demo1/src', 'index.ts')                // → AbsolutePath('/project/demos/demo1/src/index.ts')
      const p3 = p1.resolve('demo1/src', '/etc/config', 'index.ts') // → AbsolutePath('/etc/config/index.ts')

    Settings

    Member Visibility

    On This Page

    Constructors
    Accessors
    Methods