TypeScript posix.isAbsolute方法代碼示例

export default function() {
  // These testcases are specific to one uncommon behaviour in path module. Few
  // of the functions in path module, treat '' strings as current working
  // directory. This test makes sure that the behaviour is intact between commits.
  // See: https://github.com/nodejs/node/pull/2106

  var pwd = process.cwd();

  // join will internally ignore all the zero-length strings and it will return
  // '.' if the joined string is a zero-length string.
  assert.equal(path.posix.join(''), '.');
  assert.equal(path.posix.join('', ''), '.');
  assert.equal(path.join(pwd), pwd);
  assert.equal(path.join(pwd, ''), pwd);

  // normalize will return '.' if the input is a zero-length string
  assert.equal(path.posix.normalize(''), '.');
  assert.equal(path.normalize(pwd), pwd);

  // Since '' is not a valid path in any of the common environments, return false
  assert.equal(path.posix.isAbsolute(''), false);

  // resolve, internally ignores all the zero-length strings and returns the
  // current working directory
  assert.equal(path.resolve(''), pwd);
  assert.equal(path.resolve('', ''), pwd);

  // relative, internally calls resolve. So, '' is actually the current directory
  assert.equal(path.relative('', pwd), '');
  assert.equal(path.relative(pwd, ''), '');
  assert.equal(path.relative(pwd, pwd), '');
};

 /**
  * Format an import from the current document to the given JS URL. If an
  * original HTML import URL is given, attempt to match the format of that
  * import URL as much as possible. For example, if the original import URL was
  * an absolute path, return an absolute path as well.
  *
  * TODO(fks): Make this run on Windows/Non-Unix systems (#236)
  */
 private formatImportUrl(
     toUrl: ConvertedDocumentUrl, originalHtmlImportUrl?: string,
     forcePath = false): string {
   // Return an absolute URL path if the original HTML import was absolute.
   // TODO(fks) 11-06-2017: Still return true absolute paths when using
   // bare/named imports?
   if (originalHtmlImportUrl && path.posix.isAbsolute(originalHtmlImportUrl)) {
     const formattedUrl = '/' + toUrl.slice('./'.length);
     return this.webcomponentsLiteToBundle(formattedUrl);
   }
   // If the import is contained within a single package (internal), return
   // a path-based import.
   if (this.urlHandler.isImportInternal(this.convertedUrl, toUrl)) {
     return this.urlHandler.getPathImportUrl(this.convertedUrl, toUrl);
   }
   // Otherwise, return the external import URL formatted for names or paths.
   if (forcePath || this.conversionSettings.npmImportStyle === 'path') {
     const formattedUrl =
         this.urlHandler.getPathImportUrl(this.convertedUrl, toUrl);
     return this.webcomponentsLiteToBundle(formattedUrl);
   } else {
     const formattedUrl = this.urlHandler.getNameImportUrl(toUrl);
     return this.webcomponentsLiteToBundle(formattedUrl);
   }
 }

  resolve(url: string): string {
    let urlObject = parseUrl(url);
    let pathname = pathlib.normalize(decodeURIComponent(urlObject.pathname));

    if (!this._isValid(urlObject, pathname)) {
      throw new Error(`Invalid URL ${url}`);
    }

    // If the path points to a sibling directory, resolve it to the
    // component directory
    if (pathname.startsWith('../')) {
      pathname = pathlib.join(this.componentDir,pathname.substring(3));
    }

    // make all paths relative to the root directory
    if (pathlib.isAbsolute(pathname)) {
      pathname = pathname.substring(1);
    }
    return pathname;
  }

 private shouldMapPaths(remotePath: string): boolean {
     // Map paths only if localRoot/remoteRoot are set, and the remote path is absolute on some system
     return !!this._localRoot && !!this._remoteRoot && (path.posix.isAbsolute(remotePath) || path.win32.isAbsolute(remotePath) || utils.isFileUrl(remotePath));
 }