Oxc Minify

Common errors

• Error: The 'filename' argument must be of type string. Received type undefined

  cause The `filename` parameter in `minifySync` or `minify` was not provided or was `undefined`.
  fix Always provide a string for the `filename` argument, even if it's a placeholder like `'input.js'`.

• SyntaxError: Expected an identifier but found 'class'

  cause Input code contains syntax errors that `oxc-minify`'s parser cannot handle, potentially due to unsupported syntax or malformed code.
  fix Ensure the input `sourceText` is valid JavaScript/TypeScript. `oxc-minify` expects semantically correct code and may not gracefully handle all malformed inputs.

• TypeError: Cannot read properties of undefined (reading 'code')

  cause The `minifySync` or `minify` function might have thrown an error, causing `result` to be undefined, and then you tried to access `result.code`.
  fix Wrap your minification call in a `try...catch` block for `minifySync` or use `.catch()` for `minify` to handle potential errors during the minification process.

Warnings

• breaking The `allocator` module's `Box` and `Vec` methods were renamed, which can affect custom Rust-based extensions or deeper integrations.
  Fix: Review your Rust FFI bindings or custom allocator usage to align with the new method names in `oxc_allocator`.
• breaking The `oxc_str` crate underwent multiple breaking changes, including the removal of identity `FromIn` impl for `Ident` and re-exports of string types from `oxc_span`, along with the introduction of a new `static_ident!` macro.
  Fix: Update any code relying on `oxc_str` or `oxc_span` string type re-exports according to the new API and macro usage.
• gotcha Oxc Minify is currently alpha software and may produce incorrect results or not fully optimize code as expected. It lacks some advanced minification techniques like constant inlining and dead code removal.
  Fix: Thoroughly test minified output in your target environment. Monitor the Oxc project's GitHub releases for updates on feature completeness and stability. Avoid using in production without extensive validation.
• gotcha To maximize performance, `oxc-minify` assumes the input code is semantically correct. It uses a fast parsing mode that skips checks for semantic errors related to symbols and scopes.
  Fix: Ensure your input code is syntactically and semantically valid before passing it to `oxc-minify`. Use linters or other parsers (e.g., `oxc-parser` in full mode) for prior validation if semantic correctness is not guaranteed.
• breaking Oxlint's internal `span` and `str` crate re-exports were removed, potentially impacting applications that directly interfaced with these internal Rust crates.
  Fix: Adjust any direct Rust-level integrations to align with the revised module structure and exports.

Install

• npm install oxc-minify npm
• yarn add oxc-minify yarn
• pnpm add oxc-minify pnpm

Imports

• minifySync
  wrong:

  const { minifySync } = require('oxc-minify');

  correct:

  import { minifySync } from 'oxc-minify';

  The documentation primarily shows ESM `import` syntax. While CommonJS might work for some versions/environments, ESM is the officially demonstrated approach. Ensure your project is configured for ESM.
• minify
  wrong:

  import minify from 'oxc-minify'; // Not a default export

  correct:

  import { minify } from 'oxc-minify';

  `minify` is the asynchronous version, useful for I/O-bound or concurrent tasks. Both `minify` and `minifySync` are named exports.
• MinifyOptions

  import type { MinifyOptions } from 'oxc-minify';

  Import types separately using `import type` for TypeScript projects.

Quickstart

This example demonstrates both synchronous and asynchronous minification of a JavaScript code string, showcasing common options for compression, mangling, and code generation, along with sourcemap generation.

import { minifySync } from "oxc-minify";

const filename = "test.js";
const code = "const x = 'a' + 'b'; console.log(x); function sum(a, b) { return a + b; } console.log(sum(1,2));";
const options = {
  compress: {
    target: "esnext",
    // Example of a common compression option
    inline: 2 // Inline small functions where possible
  },
  mangle: {
    toplevel: false,
    // Example of a common mangling option
    properties: false // Do not mangle properties for now
  },
  codegen: {
    removeWhitespace: true,
    // Example of a common code generation option
    quote: 'single' // Use single quotes for strings
  },
  sourcemap: true,
};

// Synchronous minification
const resultSync = minifySync(filename, code, options);
console.log('Synchronous result:');
console.log(resultSync.code);
// console.log(resultSync.map); // Source map can be logged if needed

// Asynchronous minification (uncomment to use)
// (async () => {
//   const resultAsync = await minify(filename, code, options);
//   console.log('\nAsynchronous result:');
//   console.log(resultAsync.code);
//   // console.log(resultAsync.map);
// })();