Package Exports

mlly

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 CommonJS context that is missing in ECMAScript modules.

import { createCommonJS } from 'mlly'

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

Resolving Modules

`resolve`

Resolve a module by respecting ECMAScript Resolver algorithm (internally using wooorm/import-meta-resolve that exposes Node.js implementation).

Additionally supports resolving without extension and /index similar to CommonJS.

import { resolve } from 'mlly'

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

Resolve options:

from: URL or string (default is pwd())
conditions: Array of conditions used for resolution algorithm (default is ['node', 'import'])
extensions: Array of additional extensions to check if import failed (default is ['.mjs', '.cjs', '.js', '.json'])

`resolvePath`

Similar to resolve but returns a path instead of URL using fileURLToPath.

import { resolvePath } from 'mlly'

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

`createResolve`

Create a resolve function with defaults.

import { createResolve } from 'mlly'

const _resolve = createResolve({ url: import.meta.url })

// file:///home/user/project/module.mjs
console.log(await _resolve('./module.mjs'))

Example: Ponyfill import.meta.resolve:

import { createResolve } from 'mlly'

import.meta.resolve = createResolve({ url: import.meta.url })

`resolveImports`

Resolve all static and dynamic imports with relative paths to full resolved path.

import { resolveImports } from 'mlly'

// import foo from 'file:///home/user/project/bar.mjs'
console.log(await resolveImports(`import foo from './bar.mjs'`, { url: import.meta.url }))

Evaluating Moduls

`evalModule`

Transform and evaluates module code using dynamic imports.

import { evalModule } from 'mlly'

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

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

Options:

all resolve options
url: File URL

`loadModule`

Dynamically loads a module by evaluating source code.

import { loadModule } from 'mlly'

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

Options are same as evalModule.

`transformModule`

Resolves all relative imports will be resolved
All usages of import.meta.url will be replaced with url or from option

import { toDataURL } from 'mlly'
console.log(transformModule(`console.log(import.meta.url)`), { url: 'test.mjs' })

Options are same as evalModule.

Other Utils

`fileURLToPath`

Similar to url.fileURLToPath but also converts windows backslash \ to unix slash / and handles if input is already a path.

import { fileURLToPath } from 'mlly'

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

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

`normalizeid`

Ensures id has either of node:, data:, http:, https: or file: protocols.

import { ensureProtocol } from 'mlly'

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

`loadURL`

Read source contents of a URL. (currently only file protocol supported)

import { resolve, loadURL } from 'mlly'

const url = await resolve('./index.mjs', { url: import.meta.url })
console.log(await loadURL(url))

`toDataURL`

Convert code to data: URL using base64 encoding.

import { toDataURL } from 'mlly'

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

License

MIT