get associated compiled js file path

@param tsFile  path
@return string path
544954
function TS2JS(tsFile) {
  const srcFolder = path.join(__dirname, '..', 'src');
  const distFolder = path.join(__dirname, '..', 'build', 'main');

  const tsPathObj = path.parse(tsFile);

  return path.format({
    dir: tsPathObj.dir.replace(srcFolder, distFolder),
    ext: '.js',
    name: tsPathObj.name,
    root: tsPathObj.root
  });
}
69232
function getConfigPath(configPaths) {
  let conf = null;

  // Try all config paths and return for the first found one
  some(configPaths, configPath => {
    if (!configPath) return;

    // Compile config using environment variables
    const compiledConfigPath = template(configPath)(process.env);

    let resolvedConfigPath = resolve(process.cwd(), compiledConfigPath);
    const resolvedName = fileExists(resolvedConfigPath);

    if (resolvedConfigPath && resolvedName) {
      conf = resolvedName;
    }

    return conf;
  });

  return conf;
}
813626
function getOutputFile(options) {
  var outFile = options.outFile;

  if (!outFile || typeof outFile !== 'string' || (!options.data && !options.file)) {
    return null;
  }

  return path.resolve(outFile);
}
315385
private static String getJsPackage(FileDescriptor file) {
    String protoPackage = file.getPackage();
    if (!protoPackage.isEmpty()) {
      return "proto." + protoPackage;
    }
    return "proto";
  }
406469
@GwtIncompatible("Unnecessary")
  private String getMapPath(String outputFile) {
    String basePath = "";

    if (outputFile.isEmpty()) {
      // If we have a js_module_binary rule, output the maps
      // at modulename_props_map.out, etc.
      if (!config.moduleOutputPathPrefix.isEmpty()) {
        basePath = config.moduleOutputPathPrefix;
      } else {
        basePath = "jscompiler";
      }
    } else {
      // Get the path of the output file.
      File file = new File(outputFile);

      String outputFileName = file.getName();

      // Strip the .js from the name.
      if (outputFileName.endsWith(".js")) {
        outputFileName =
            outputFileName.substring(0, outputFileName.length() - 3);
      }

      String fileParent = file.getParent();
      if (fileParent == null) {
        basePath = outputFileName;
      } else {
        basePath = file.getParent() + File.separatorChar + outputFileName;
      }
    }

    return basePath;
  }
468946
function lint(applyFixes) {
    logInfo("Lint TypeScript source files");

    const tsDir = path.resolve(TS_TARGETDIR);
    const cwdLength = tsDir.length - TS_TARGETDIR.length;
    const tsSuffix = ".ts";
    const dtsSuffix = ".d.ts";
    const lintConfigFile = path.resolve("./build/tslint.json");
    const lintOptions = {
        formatter: "verbose",
        fix: applyFixes
    };

    lintFolders(tsDir);

    function lintFolders(parent) {
        fse.readdirSync(parent).forEach((file, index) => {
            let curPath = path.join(parent, file);
            if (!fse.lstatSync(curPath).isDirectory()) {
                if ((file.substr(-tsSuffix.length) === tsSuffix) &&
                    !(file.substr(-dtsSuffix.length) === dtsSuffix)) {
                    lintFile(curPath.substr(cwdLength));
                }
            } else {
                lintFolders(curPath);
            }
        });
    }

    function lintFile(file) {
        const contents = fse.readFileSync(file, "utf-8");
        const linter = new tslint.Linter(lintOptions);
        const configuration = tslint.Configuration.findConfiguration(lintConfigFile).results;
        linter.lint(file, contents, configuration);
        const result = linter.getResult();

        // For debugging, use console.log(result);
        result.errorCount > 0 && console.log(result.output);
    }
}
1009255
function compileTs(target) {
	return ssvTools.compileTsc({
		module: target,
		configPath: "./tsconfig.build.json",
		continueOnError: args.continueOnError
	});
}
915303
function tsLoaderOptions(options = {}) {
  const DefaultTsLoaderOptions = {
    compilerOptions: {
      target: 'ES5',
      sourceMap: true,
      jsx: 'React'
    }
  }

  return {
    loader: 'ts-loader',
    options: Object.assign({}, DefaultTsLoaderOptions, options)
  }
}
677512
def getJsonPath(name, moduleFile):
    
    currentFolder = os.getcwd()
    currentJsonPath = os.path.join(currentFolder, name)
    if os.path.isfile(currentJsonPath):
        return currentJsonPath
    else:
        moduleFolder = os.path.abspath(os.path.dirname(moduleFile))
        moduleJsonPath = os.path.join(moduleFolder, '.', name)
        return moduleJsonPath
862285
public String getPath() {

        // ensure the export file name ends with ".zip" in case of ZIP file export
        if ((m_path != null) && !isExportAsFiles() && !m_path.toLowerCase().endsWith(".zip")) {
            m_path += ".zip";
        }
        return m_path;
    }
1093478
function getScriptPath()
    {
        $fileName = $this->stack->pop();
        if ($this->baseDir) {
            return $this->baseDir . \DIRECTORY_SEPARATOR . $fileName;
        } else {
            return (string)$fileName;
        }
    }
309164
function compile(source_file_path) {
    let pathParsed = path.parse(source_file_path);
    let nameParsed = path.parse(pathParsed.name);

    if (nameParsed.ext == '.module') {
      return Promise.reject({
        message: 'Modules are not supposed to be loaded'
      });
    }

    var str = fs.readFileSync(source_file_path, {
      encoding: 'utf8'
    });

    return getCompiler(str, source_file_path).render();
  }
744640
public static String getPackagePath(Proto proto) {
        String javaPackage = getPackage(proto);
        return javaPackage.replace('.', '/');
    }
314798
function findExtensionsYAMLFile() {
    for (var i = 0; i < paths.srcPaths.length; i++) {
        var srcPath = path.resolve(cwd, paths.srcPaths[i]);
        var extFile = path.resolve(srcPath, 'jenkins-js-extension.yaml');
        if (fs.existsSync(extFile)) {
            return extFile;
        }
    }

    return undefined;
}
922166
public com.google.protobuf.ByteString
      getScriptPathBytes() {
    java.lang.Object ref = scriptPath_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b = 
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      scriptPath_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }
731002
function getPaths(path) {
        var appPath = path;
        if (/dev\/temp\.ts$/.test(path)) // hack used when debugging.
            appPath = 'pargv';
        var appName = path_1.basename(appPath); // get the basename from path.
        var completionsDir = path_1.join(env.HOME_PATH, "." + appName);
        if (/\.(ts|js)$/.test(appPath)) {
            appPath = "./" + appPath; // not installed as bin.
            var parsedPath = path_1.parse(appPath);
            completionsDir = parsedPath.dir; // store completions.sh at executable file path.
        }
        var bashPath = !/^win/.test(env.PLATFORM) ? /^darwin/.test(env.PLATFORM) ? '.bash_profile' : '.bashrc' : false;
        if (bashPath)
            bashPath = path_1.join(env.HOME_PATH, bashPath);
        var completionsPath = path_1.join(completionsDir, 'completions.sh');
        return {
            appName: appName,
            appPath: appPath,
            bashPath: bashPath,
            completionsDir: completionsDir,
            completionsPath: completionsPath // the completions path.
        };
    }
743253
function getCompilerName (context, filename) {
  var absolutePath = path.resolve(context, filename);
  var relativePath = path.relative(context, absolutePath);
  return 'favicons-webpack-plugin for "' + (absolutePath.length < relativePath.length ? absolutePath : relativePath) + '"';
}