abs-paths: js api and tests

Author: evanw

lib/shared/common.ts

@@ -174,6 +174,7 @@ function pushCommonFlags(flags: string[], options: CommonOptions, keys: OptionKe
   let keepNames = getFlag(options, keys, 'keepNames', mustBeBoolean)
   let platform = getFlag(options, keys, 'platform', mustBeString)
   let tsconfigRaw = getFlag(options, keys, 'tsconfigRaw', mustBeStringOrObject)
+  let absPaths = getFlag(options, keys, 'absPaths', mustBeArrayOfStrings)
 
   if (legalComments) flags.push(`--legal-comments=${legalComments}`)
   if (sourceRoot !== void 0) flags.push(`--source-root=${sourceRoot}`)
@@ -194,6 +195,7 @@ function pushCommonFlags(flags: string[], options: CommonOptions, keys: OptionKe
   if (ignoreAnnotations) flags.push(`--ignore-annotations`)
   if (drop) for (let what of drop) flags.push(`--drop:${validateStringValue(what, 'drop')}`)
   if (dropLabels) flags.push(`--drop-labels=${validateAndJoinStringArray(dropLabels, 'drop label')}`)
+  if (absPaths) flags.push(`--abs-paths=${validateAndJoinStringArray(absPaths, 'abs paths')}`)
   if (mangleProps) flags.push(`--mangle-props=${jsRegExpToGoRegExp(mangleProps)}`)
   if (reserveProps) flags.push(`--reserve-props=${jsRegExpToGoRegExp(reserveProps)}`)
   if (mangleQuoted !== void 0) flags.push(`--mangle-quoted=${mangleQuoted}`)

lib/shared/types.ts

@@ -4,6 +4,7 @@ export type Loader = 'base64' | 'binary' | 'copy' | 'css' | 'dataurl' | 'default
 export type LogLevel = 'verbose' | 'debug' | 'info' | 'warning' | 'error' | 'silent'
 export type Charset = 'ascii' | 'utf8'
 export type Drop = 'console' | 'debugger'
+export type AbsPaths = 'code' | 'log' | 'metafile'
 
 interface CommonOptions {
   /** Documentation: https://esbuild.github.io/api/#sourcemap */
@@ -75,6 +76,8 @@ interface CommonOptions {
   /** Documentation: https://esbuild.github.io/api/#keep-names */
   keepNames?: boolean
 
+  /** Documentation: https://esbuild.github.io/api/#abs-paths */
+  absPaths?: AbsPaths[]
   /** Documentation: https://esbuild.github.io/api/#color */
   color?: boolean
   /** Documentation: https://esbuild.github.io/api/#log-level */

scripts/js-api-tests.js

@@ -143,6 +143,108 @@ let buildTests = {
     assert.strictEqual(require(bOut).y, true)
   },
 
+  async absPathsCodeTest({ esbuild, testDir }) {
+    let srcDir = path.join(testDir, 'src');
+    let outfile = path.join(testDir, 'out', 'result.js');
+    let entry = path.join(srcDir, 'entry.js');
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.writeFileSync(entry, `x = typeof y == "null"`);
+
+    const { metafile, warnings, outputFiles } = await esbuild.build({
+      entryPoints: [entry],
+      outfile,
+      bundle: true,
+      write: false,
+      metafile: true,
+      format: 'cjs',
+      logLevel: 'silent',
+      absPaths: ['code'],
+    })
+    const cwd = process.cwd()
+    const makePath = absPath => path.relative(cwd, absPath).split(path.sep).join('/')
+
+    assert.strictEqual(outputFiles.length, 1)
+    assert.deepStrictEqual(outputFiles[0].path, outfile)
+    assert.deepStrictEqual(outputFiles[0].text, `// ${entry}\nx = typeof y == "null";\n`)
+
+    assert.deepStrictEqual(Object.keys(metafile.inputs), [makePath(entry)])
+    assert.deepStrictEqual(Object.keys(metafile.outputs), [makePath(outfile)])
+    assert.strictEqual(metafile.inputs[makePath(entry)].imports.length, 0)
+    assert.strictEqual(metafile.outputs[makePath(outfile)].entryPoint, makePath(entry))
+
+    assert.strictEqual(warnings.length, 1)
+    assert.strictEqual(warnings[0].text, 'The "typeof" operator will never evaluate to "null"')
+    assert.strictEqual(warnings[0].location.file, makePath(entry))
+  },
+
+  async absPathsLogTest({ esbuild, testDir }) {
+    let srcDir = path.join(testDir, 'src');
+    let outfile = path.join(testDir, 'out', 'result.js');
+    let entry = path.join(srcDir, 'entry.js');
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.writeFileSync(entry, `x = typeof y == "null"`);
+
+    const { metafile, warnings, outputFiles } = await esbuild.build({
+      entryPoints: [entry],
+      outfile,
+      bundle: true,
+      write: false,
+      metafile: true,
+      format: 'cjs',
+      logLevel: 'silent',
+      absPaths: ['log'],
+    })
+    const cwd = process.cwd()
+    const makePath = absPath => path.relative(cwd, absPath).split(path.sep).join('/')
+
+    assert.strictEqual(outputFiles.length, 1)
+    assert.deepStrictEqual(outputFiles[0].path, outfile)
+    assert.deepStrictEqual(outputFiles[0].text, `// ${makePath(entry)}\nx = typeof y == "null";\n`)
+
+    assert.deepStrictEqual(Object.keys(metafile.inputs), [makePath(entry)])
+    assert.deepStrictEqual(Object.keys(metafile.outputs), [makePath(outfile)])
+    assert.strictEqual(metafile.inputs[makePath(entry)].imports.length, 0)
+    assert.strictEqual(metafile.outputs[makePath(outfile)].entryPoint, makePath(entry))
+
+    assert.strictEqual(warnings.length, 1)
+    assert.strictEqual(warnings[0].text, 'The "typeof" operator will never evaluate to "null"')
+    assert.strictEqual(warnings[0].location.file, entry)
+  },
+
+  async absPathsMetafileTest({ esbuild, testDir }) {
+    let srcDir = path.join(testDir, 'src');
+    let outfile = path.join(testDir, 'out', 'result.js');
+    let entry = path.join(srcDir, 'entry.js');
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.writeFileSync(entry, `x = typeof y == "null"`);
+
+    const { metafile, warnings, outputFiles } = await esbuild.build({
+      entryPoints: [entry],
+      outfile,
+      bundle: true,
+      write: false,
+      metafile: true,
+      format: 'cjs',
+      logLevel: 'silent',
+      absPaths: ['metafile'],
+    })
+    const cwd = process.cwd()
+    const makePath = absPath => path.relative(cwd, absPath).split(path.sep).join('/')
+
+    assert.strictEqual(outputFiles.length, 1)
+    assert.deepStrictEqual(outputFiles[0].path, outfile)
+    assert.deepStrictEqual(outputFiles[0].text, `// ${makePath(entry)}\nx = typeof y == "null";\n`)
+
+    assert.deepStrictEqual(Object.keys(metafile.inputs), [entry])
+    assert.deepStrictEqual(Object.keys(metafile.outputs), [outfile])
+    assert.strictEqual(metafile.inputs[entry].imports.length, 0)
+    assert.strictEqual(metafile.outputs[outfile].entryPoint, entry)
+
+    assert.strictEqual(warnings.length, 1)
+    assert.strictEqual(warnings[0].text, 'The "typeof" operator will never evaluate to "null"')
+    assert.strictEqual(warnings[0].location.file, makePath(entry))
+  },
+
   async aliasValidity({ esbuild }) {
     const valid = async alias => {
       const result = await esbuild.build({