mlly

What is mlly?

The mlly npm package is a utility library for working with ES module syntax. It provides functions to analyze and manipulate module specifiers and import/export statements.

What are mlly's main functionalities?

Analyzing import/export statements

This feature allows you to analyze the import and export statements within a given piece of code. It returns an object with details about the imports and exports found.

import { analyzeModule } from 'mlly';
const code = `import { foo } from 'bar';`;
const analysis = analyzeModule(code);

Resolving import/export specifiers

This feature helps in resolving the full path of an import specifier based on the current file's location. It is useful for resolving relative paths.

import { resolveImport } from 'mlly';
const resolved = resolveImport('./foo.js', '/path/to/module.js');

Checking for dynamic imports

This feature checks if a given piece of code contains dynamic imports, which are imports that occur within the execution context rather than statically at the top of the file.

import { hasDynamicImport } from 'mlly';
const code = `const module = import('./module.js');`;
const hasDynamic = hasDynamicImport(code);

Other packages similar to mlly

es-module-lexer

This package provides a lexer for ES module syntax, allowing for the analysis of import/export statements. It is similar to mlly in that it can be used to parse and understand module structures, but it is implemented as a low-level lexer written in WebAssembly for performance.

acorn

Acorn is a JavaScript parser that can be used to analyze and manipulate JavaScript code, including ES modules. While mlly is focused on module syntax, Acorn provides a more general-purpose parsing solution that can handle a wide range of JavaScript features.

rollup

Rollup is a module bundler for JavaScript that includes features for analyzing and bundling ES modules. It is more complex and feature-rich than mlly, offering a complete solution for bundling modules for production use, whereas mlly is more focused on module analysis and manipulation.

README

🤝 mlly

Missing ECMAScript module utils for Node.js

Install

This package is ESM only. Node.js 12+ is needed to use it and it must be imported instead of required.

Install npm package:

# using yarn
yarn add mlly

# using npm
npm install mlly

Import utils:

import {} from 'mlly'

CommonJS Context

createCommonJS

This utility creates a compatible context that we loose when migrating to ECMA modules.

import { createCommonJS } from 'mlly'

const { __dirname, __filename, require } = createCommonJS(import.meta)

Resolving Modules

There are several utils exposed allow resolving another module URL or Path. (internally using wooorm/import-meta-resolve that re-exports Node.js code).

• resolve(id, resolveOptions?)
• resolvePath(id, resolveOptions?)
• createResolve(import.meta) | createResolve(base)
• resolveSync(id, resolveOptions?)
• resolvePathSync(id, resolveOptions?)

It is recommended to use resolve and createResolve since module resolution spec allows aync resolution.

import { resolve, resolvePath, createResolve } from 'mlly'

// //home/user/project/module.mjs
console.log(await resolvePath('./module.mjs', { from: import.meta.url }))

// file:///home/user/project/module.mjs
console.log(await resolve('./module.mjs', { from: import.meta.url }))

// file:///home/user/project/module.mjs
const _resolve = createResolve(import.meta)

console.log(await _resolve('./module.mjs'))

Resolve options:

• from: URL or string (default is pwd())
• conditions: Array of conditions used for resolution algorithm (default is ['node', 'import'])

Evaluating Moduls

loadModule

Dynamically loads a module by evaluating source code. (useful to bypass import cache)

import { loadModule } from 'mlly'

await loadModule('./hello.mjs', { from: import.meta.url })

evalModule

Evaluates JavaScript module code using dynamic data: import.

import { evalModule } from 'mlly'

await evalModule(`console.log("Hello World!")`)

await evalModule(`
  import { reverse } from './utils.mjs'
  console.log(reverse('!emosewa si sj'))
`, {
  from: import.meta.url
})

readModule

Resolves id using resolve and reads source code.

import { readModule } from 'mlly'

console.log(await readModule('./index.mjs', import.meta.url))

toDataURL

Convert code to data: URL using base64 encoding.

import { toDataURL } from 'mlly'

console.log(await toDataURL(`
  // This is an example
  console.log('Hello world')
`))

Path utils

fileURLToPath

Similar to url.fileURLToPath but also converts windows backslash \ to unix slash /

import { fileURLToPath } from 'mlly'

// /foo/bar.js
console.log(fileURLToPath('file:///foo/bar.js'))

// C:/path
console.log(fileURLToPath('file:///C:/path/'))

License

MIT

Changelog

0.1.1 (2021-07-22)

Features

• add eval utils and other improvements (1fe0b69)
• add resolve utils (1d1a3ac)