Options
All
  • Public
  • Public/Protected
  • All
Menu

Class URI

Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986. This class is a simple parser which creates the basic component parts (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation and encoding.

      foo://example.com:8042/over/there?name=ferret#nose
      \_/   \______________/\_________/ \_________/ \__/
       |           |            |            |        |
    scheme     authority       path        query   fragment
       |   _____________________|__
      / \ /                        \
      urn:example:animal:ferret:nose

Hierarchy

  • URI

Implements

Index

Properties

Readonly authority

authority: string

authority is the 'www.msft.com' part of 'http://www.msft.com/some/path?query#fragment'. The part between the first double slashes and the next slash.

Readonly fragment

fragment: string

fragment is the 'fragment' part of 'http://www.msft.com/some/path?query#fragment'.

Readonly path

path: string

path is the '/some/path' part of 'http://www.msft.com/some/path?query#fragment'.

Readonly query

query: string

query is the 'query' part of 'http://www.msft.com/some/path?query#fragment'.

Readonly scheme

scheme: string

scheme is the 'http' part of 'http://www.msft.com/some/path?query#fragment'. The part before the first colon.

Accessors

fsPath

  • get fsPath(): string
  • Returns a string representing the corresponding file system path of this URI. Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the platform specific path separator.

    • Will not validate the path for invalid characters and semantics.
    • Will not look at the scheme of this URI.
    • The result shall not be used for display purposes but for accessing a file on disk.

    The difference to URI#path is the use of the platform specific separator and the handling of UNC paths. See the below sample of a file-uri with an authority (UNC path).

    const u = URI.parse('file://server/c$/folder/file.txt')
    u.authority === 'server'
    u.path === '/shares/c$/file.txt'
    u.fsPath === '\\server\c$\folder\file.txt'

    Using URI#path to read a file (using fs-apis) would not be enough because parts of the path, namely the server name, would be missing. Therefore URI#fsPath exists - it's sugar to ease working with URIs that represent files on disk (file scheme).

    Returns string

Methods

toJSON

toString

  • toString(skipEncoding?: boolean): string
  • Creates a string representation for this URI. It's guaranteed that calling URI.parse with the result of this function creates an URI which is equal to this URI.

    • The result shall not be used for display purposes but for externalization or transport.
    • The result will be encoded using the percentage encoding and encoding happens mostly ignore the scheme-specific encoding rules.

    Parameters

    • Optional skipEncoding: boolean

      Do not encode the result, default is false

    Returns string

with

  • with(change: { authority?: string | null; fragment?: string | null; path?: string | null; query?: string | null; scheme?: string }): URI
  • Parameters

    • change: { authority?: string | null; fragment?: string | null; path?: string | null; query?: string | null; scheme?: string }
      • Optional authority?: string | null
      • Optional fragment?: string | null
      • Optional path?: string | null
      • Optional query?: string | null
      • Optional scheme?: string

    Returns URI

Static file

  • file(path: string): URI
  • Creates a new URI from a file system path, e.g. c:\my\files, /usr/home, or \\server\share\some\path.

    The difference between URI#parse and URI#file is that the latter treats the argument as path, not as stringified-uri. E.g. URI.file(path) is not the same as URI.parse('file://' + path) because the path might contain characters that are interpreted (# and ?). See the following sample:

    const good = URI.file('/coding/c#/project1');
    good.scheme === 'file';
    good.path === '/coding/c#/project1';
    good.fragment === '';
    const bad = URI.parse('file://' + '/coding/c#/project1');
    bad.scheme === 'file';
    bad.path === '/coding/c'; // path is now broken
    bad.fragment === '/project1';

    Parameters

    • path: string

      A file system path (see URI#fsPath)

    Returns URI

Static from

  • from(components: { authority?: string; fragment?: string; path?: string; query?: string; scheme: string }): URI
  • Parameters

    • components: { authority?: string; fragment?: string; path?: string; query?: string; scheme: string }
      • Optional authority?: string
      • Optional fragment?: string
      • Optional path?: string
      • Optional query?: string
      • scheme: string

    Returns URI

Static isUri

  • isUri(thing: any): thing is URI
  • Parameters

    • thing: any

    Returns thing is URI

Static joinPath

  • joinPath(uri: URI, ...pathFragment: string[]): URI
  • Join a URI path with path fragments and normalizes the resulting path.

    Parameters

    • uri: URI

      The input URI.

    • Rest ...pathFragment: string[]

      The path fragment to add to the URI path.

    Returns URI

    The resulting URI.

Static parse

  • parse(value: string, _strict?: boolean): URI
  • Creates a new URI from a string, e.g. http://www.msft.com/some/path, file:///usr/home, or scheme:with/path.

    Parameters

    • value: string

      A string which represents an URI (see URI#toString).

    • Optional _strict: boolean

    Returns URI

Static revive

  • Parameters

    Returns URI

  • Parameters

    Returns URI | undefined

  • Parameters

    Returns URI | null

  • Parameters

    Returns URI | undefined | null

Generated using TypeDoc