TypeScript path.posix类代码示例

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), '');
};

 private constructor(
     relativeFlatIndexPath: string, readonly entryPoint: string,
     readonly moduleName: string|null) {
   this.flatIndexPath = path.posix.join(path.posix.dirname(entryPoint), relativeFlatIndexPath)
                            .replace(/\.js$/, '') +
       '.ts';
 }

        .map(match => {
          const relativePath = path.posix.relative(slashedDirname, match);

          return path.posix.dirname(match) === slashedDirname
            ? `./${relativePath}`
            : relativePath;
        })

		return service.resolveFile(uri.file(path.join(testDir, 'index.html'))).then(source => {
			const targetParent = uri.file(path.dirname(source.resource.fsPath));
			const target = targetParent.with({ path: path.posix.join(targetParent.path, path.posix.basename(source.resource.path)) });
			return service.copyFile(source.resource, target, true).then(copied => {
				assert.equal(copied.size, source.size);
			});
		});

  /**
   * Checks if a path points to webcomponents-lite.js and will change it to
   * webcomponents-bundle.js if it does.
   *
   * @param filePath path to transform.
   */
  private webcomponentsLiteToBundle(filePath: string) {
    const pathObject = path.posix.parse(filePath);

    if (pathObject.base === 'webcomponents-lite.js') {
      pathObject.base = 'webcomponents-bundle.js';
    }

    return path.posix.format(pathObject);
  }

export function pathFromUrl(
    root: LocalFsPath,
    // TODO(usergenic): PackageRelativeUrl are not *necessarily* always just a
    // relative path from root.  Maybe subclass as PackageRelativeUrlPath or
    // something if this function doesn't disappear after
    // https://github.com/Polymer/polymer-build/issues/324 is addressed.
    url: PackageRelativeUrl): LocalFsPath {
  return path.normalize(decodeURIComponent(path.posix.join(
             posixifyPath(root), path.posix.join('/', url)))) as LocalFsPath;
}

 toDepNameAndPath(relativePath: string): { depName: string; path: string; } {
     let depName = path.join(path.dirname(this._current.depName), relativePath);
     let depPath = path.join(path.dirname(this._current.path), relativePath);
     if (path.posix) {
         // (windows) for git cli
         // path.posix are exists after node v0.12
         depName = path.posix.join(path.dirname(this._current.depName), relativePath);
         depPath = path.posix.join(path.dirname(this._current.path), relativePath);
     }
     return {
         depName: depName,
         path: depPath,
     };
 }

 it('should list lazy routes recursively', () => {
   writeSomeRoutes();
   const {program, host, options} =
       createProgram(['src/main.ts', 'src/child.ts', 'src/child2.ts']);
   const routes = NgTools_InternalApi_NG_2.listLazyRoutes({
     program,
     host,
     angularCompilerOptions: options,
     entryModule: 'src/main#MainModule',
   });
   expect(routes).toEqual({
     './child#ChildModule': path.posix.join(testSupport.basePath, 'src/child.ts'),
     './child2#ChildModule2': path.posix.join(testSupport.basePath, 'src/child2.ts'),
   });
 });

    return this._getBundles().then((bundles) => {
      let sharedDepsBundle = (this.shell)
          ? this.urlFromPath(this.shell)
          : this.sharedBundleUrl;
      let sharedDeps = bundles.get(sharedDepsBundle) || [];
      let promises = [];

      if (this.shell) {
        let shellFile = this.analyzer.getFile(this.shell);
        console.assert(shellFile != null);
        let newShellContent = this._addSharedImportsToShell(bundles);
        shellFile.contents = new Buffer(newShellContent);
      }

      for (let fragment of this.allFragments) {
        let fragmentUrl = this.urlFromPath(fragment);
        let addedImports = (fragment === this.shell && this.shell)
            ? []
            : [path.relative(path.dirname(fragmentUrl), sharedDepsBundle)];
        let excludes = (fragment === this.shell && this.shell)
            ? []
            : sharedDeps.concat(sharedDepsBundle);

        promises.push(new Promise((resolve, reject) => {
          let vulcanize = new Vulcanize({
            abspath: null,
            fsResolver: this.analyzer.resolver,
            addedImports: addedImports,
            stripExcludes: excludes,
            inlineScripts: true,
            inlineCss: true,
            inputUrl: fragmentUrl,
          });
          vulcanize.process(null, (err, doc) => {
            if (err) {
              reject(err);
            } else {
              resolve({
                url: fragment,
                contents: doc,
              });
            }
          });
        }));
      }
      // vulcanize the shared bundle
      if (!this.shell && sharedDeps && sharedDeps.length !== 0) {
        logger.info(`generating shared bundle`);
        promises.push(this._generateSharedBundle(sharedDeps));
      }
      return Promise.all(promises).then((bundles) => {
        // convert {url,contents}[] into a Map
        let contentsMap = new Map();
        for (let bundle of bundles) {
          contentsMap.set(bundle.url, bundle.contents);
        }
        return contentsMap;
      });
    });