@flex-development/mlly 1.0.0-alpha.16 → 1.0.0-alpha.17

package/src/utils/resolve-alias.ts

@@ -1,224 +0,0 @@
-/**
- * @file resolveAlias
- * @module mlly/utils/resolveAlias
- */
-
-import type { ParsedModuleId, ResolveAliasOptions } from '#src/interfaces'
-import validateArraySet from '#src/internal/validate-array-set'
-import validateBoolean from '#src/internal/validate-boolean'
-import validateObject from '#src/internal/validate-object'
-import validateString from '#src/internal/validate-string'
-import validateURLString from '#src/internal/validate-url-string'
-import type { NodeError } from '@flex-development/errnode'
-import pathe from '@flex-development/pathe'
-import {
-  CompareResult,
-  DOT,
-  flat,
-  get,
-  includes,
-  isNIL,
-  isNull,
-  keys,
-  regexp,
-  sort,
-  type Nullable
-} from '@flex-development/tutils'
-import { URL, pathToFileURL } from 'node:url'
-import compareSubpaths from './compare-subpaths'
-import CONDITIONS from './conditions'
-import parseModuleId from './parse-module-id'
-import PATTERN_CHARACTER from './pattern-character'
-import RESOLVE_EXTENSIONS from './resolve-extensions'
-import resolveModule from './resolve-module'
-import toBareSpecifier from './to-bare-specifier'
-import toRelativeSpecifier from './to-relative-specifier'
-import toURL from './to-url'
-
-/**
- * Resolves a path alias in the given module `specifier`; does nothing if a path
- * match isn't found.
- *
- * @see {@linkcode ResolveAliasOptions}
- *
- * @async
- *
- * @param {string} specifier - Module specifier to evaluate
- * @param {ResolveAliasOptions} [options={}] - Resolution options
- * @return {Promise<string>} Resolved specifier or original module specifier
- * @throws {NodeError}
- */
-const resolveAlias = async (
-  specifier: string,
-  options: ResolveAliasOptions = {}
-): Promise<string> => {
-  const {
-    absolute = true,
-    aliases = {},
-    condition = 'default',
-    conditions = CONDITIONS,
-    cwd = pathToFileURL(DOT),
-    ext,
-    extensions = RESOLVE_EXTENSIONS,
-    parent = import.meta.url,
-    preserveSymlinks = false
-  } = options
-
-  // ensure specifier is a string
-  validateString(specifier, 'specifier')
-
-  // ensure option schemas
-  validateBoolean(absolute, 'options.absolute')
-  validateObject(aliases, 'options.aliases')
-  validateString(condition, 'options.condition')
-  validateArraySet(conditions, 'options.conditions')
-  validateURLString(cwd, 'options.cwd')
-  validateArraySet(extensions, 'options.extensions')
-  validateURLString(parent, 'options.parent')
-  validateBoolean(preserveSymlinks, 'options.preserveSymlinks')
-
-  /**
-   * Parsed module id.
-   *
-   * **Note**: Ensures {@linkcode specifier} is a valid module specifier.
-   *
-   * @const {ParsedModuleId} id
-   */
-  const id: ParsedModuleId = parseModuleId(specifier, {
-    parent: toURL(parent),
-    pkgname: false
-  })
-
-  /**
-   * Path alias in {@linkcode aliases} that maps to {@linkcode specifier}.
-   *
-   * @var {Nullable<string>} key
-   */
-  let alias: Nullable<string> = null
-
-  /**
-   * Everything after {@linkcode alias} in {@linkcode specifier}.
-   *
-   * @var {string} trail
-   */
-  let trail: string = ''
-
-  // match specifier to alias
-  for (const key of sort(keys(aliases), compareSubpaths)) {
-    /**
-     * Index of {@linkcode PATTERN_CHARACTER} in {@linkcode key}.
-     *
-     * @const {number} p
-     */
-    const pattern: number = key.indexOf(PATTERN_CHARACTER)
-
-    // no pattern character => need exact match for alias
-    if (pattern === -1 && key === id.raw) {
-      alias = key
-      break
-    }
-
-    // pattern character => need best match for alias
-    if (pattern !== -1 && id.raw.startsWith(key.slice(0, pattern))) {
-      /**
-       * Everything after pattern character (`*`) in {@linkcode key}.
-       *
-       * @const {string} trailer
-       */
-      const trailer: string = key.slice(pattern + 1)
-
-      // best match found => reset key and base
-      if (
-        id.raw.length >= key.length &&
-        id.raw.endsWith(trailer) &&
-        compareSubpaths(alias ?? '', key) === CompareResult.GREATER_THAN &&
-        key.lastIndexOf(PATTERN_CHARACTER) === pattern
-      ) {
-        alias = key
-        trail = id.raw.slice(pattern, id.raw.length - trailer.length)
-      }
-    }
-  }
-
-  // exit early if alias was not found or alias does not map any paths
-  if (isNull(alias) || isNIL(aliases[alias])) return specifier
-
-  /**
-   * URL of directory to resolve non-absolute modules from.
-   *
-   * @const {string} base
-   */
-  const base: string = toURL(cwd).href.replace(/\/$/, '') + pathe.sep
-
-  /**
-   * Resolved module URL.
-   *
-   * @var {Nullable<URL>} url
-   */
-  let url: Nullable<URL> = null
-
-  // try resolving path alias
-  for (let segment of flat([get(aliases, alias, [])])) {
-    // replace pattern character in segment with trail of specifier
-    if (includes(segment, PATTERN_CHARACTER)) {
-      segment = segment.replace(
-        new RegExp(`${regexp(PATTERN_CHARACTER)}$`),
-        trail
-      )
-    }
-
-    /**
-     * Absolute paths to modules to try resolving.
-     *
-     * @var {Set<string>} tries
-     */
-    let tries: Set<string> = new Set(
-      [
-        '',
-        ...[...extensions].map(ext => pathe.formatExt(ext)),
-        ...[...extensions].map(ext => '/index' + pathe.formatExt(ext))
-      ]
-        .map((suffix: string) => segment + suffix)
-        .filter((segment: string) => !!segment.length)
-        .map((segment: string) => new URL(segment, base).pathname)
-    )
-
-    // add attempt to resolve possible package export
-    if (segment.startsWith('node_modules')) {
-      const [trypath = ''] = [...tries]
-      tries = new Set([trypath.replace(/.*\/node_modules\//, ''), ...tries])
-    }
-
-    // find first resolvable module
-    for (const trypath of tries) {
-      try {
-        url = await resolveModule(trypath, {
-          condition,
-          conditions,
-          ext,
-          extensions,
-          parent: toURL(parent),
-          preserveSymlinks
-        })
-
-        // exit if module was resolved
-        break
-      } catch {
-        continue
-      }
-    }
-
-    // stop checking path segments if path alias was resolved
-    if (url) break
-  }
-
-  return url
-    ? absolute
-      ? url.href
-      : /\/node_modules\//.test(url.href)
-      ? toBareSpecifier(url, toURL(parent), new Set(conditions))
-      : toRelativeSpecifier(url, toURL(parent))
-    : specifier
-}
-
-export default resolveAlias

package/src/utils/resolve-aliases.ts

@@ -1,58 +0,0 @@
-/**
- * @file resolveAliases
- * @module mlly/utils/resolveAliases
- */
-
-import { SpecifierSyntaxKind } from '#src/enums'
-import type { ResolveAliasOptions } from '#src/interfaces'
-import { regexp } from '@flex-development/tutils'
-import extractStatements from './extract-statements'
-import resolveAlias from './resolve-alias'
-
-/**
- * Resolves path aliases in the given piece of source `code`.
- *
- * @see {@linkcode ResolveAliasOptions}
- * @see {@linkcode resolveAlias}
- *
- * @async
- *
- * @param {string} code - Code to evaluate
- * @param {ResolveAliasOptions} [options={}] - Resolve alias options
- * @return {Promise<string>} `code` unmodified or with path aliases resolved
- */
-const resolveAliases = async (
-  code: string,
-  options: ResolveAliasOptions = {}
-): Promise<string> => {
-  for (const statement of extractStatements(code)) {
-    if (statement.specifier) {
-      if (statement.specifier_syntax !== SpecifierSyntaxKind.DYNAMIC) {
-        /**
-         * Resolved module specifier.
-         *
-         * @const {string} specifier
-         */
-        const specifier: string = await resolveAlias(
-          statement.specifier,
-          options
-        )
-
-        // replace path alias
-        if (specifier !== statement.specifier) {
-          code = code.replace(
-            statement.code,
-            statement.code.replace(
-              new RegExp(`(?<=["'])${regexp(statement.specifier)}(?=["'])`),
-              specifier
-            )
-          )
-        }
-      }
-    }
-  }
-
-  return code
-}
-
-export default resolveAliases

package/src/utils/resolve-extensions.ts

@@ -1,33 +0,0 @@
-/**
- * @file RESOLVE_EXTENSIONS
- * @module mlly/utils/RESOLVE_EXTENSIONS
- */
-
-import type { Ext } from '@flex-development/pathe'
-
-/**
- * Default resolvable file extensions.
- *
- * @see {@linkcode Ext}
- *
- * @const {Set<Ext>} RESOLVE_EXTENSIONS
- */
-const RESOLVE_EXTENSIONS: Set<Ext> = new Set([
-  '.mjs',
-  '.mts',
-  '.cjs',
-  '.cts',
-  '.js',
-  '.ts',
-  '.jsx',
-  '.tsx',
-  '.css',
-  '.json',
-  '.node',
-  '.wasm',
-  '.d.mts',
-  '.d.cts',
-  '.d.ts'
-])
-
-export default RESOLVE_EXTENSIONS

package/src/utils/resolve-module.ts

@@ -1,181 +0,0 @@
-/**
- * @file resolveModule
- * @module mlly/utils/resolveModule
- */
-
-import type { ResolveModuleOptions } from '#src/interfaces'
-import Resolver from '#src/internal/resolver'
-import validateArraySet from '#src/internal/validate-array-set'
-import validateBoolean from '#src/internal/validate-boolean'
-import validateString from '#src/internal/validate-string'
-import validateURLString from '#src/internal/validate-url-string'
-import { ErrorCode, type NodeError } from '@flex-development/errnode'
-import { isBuiltin } from '@flex-development/is-builtin'
-import pathe from '@flex-development/pathe'
-import { cast, isFunction, type Nullable } from '@flex-development/tutils'
-import { URL, fileURLToPath } from 'node:url'
-import CONDITIONS from './conditions'
-import RESOLVE_EXTENSIONS from './resolve-extensions'
-
-/**
- * Resolves `specifier` according to the [ESM Resolver algorithm][1], mostly 😉.
- *
- * Adds support for:
- *
- * - Extensionless file and directory index resolution
- * - Replacing file extensions
- *
- * Other differences between Node.js:
- *
- * - [Subpath import][2] targets (that are strings) must be relative to the
- *   current working directory (e.g. `'./src/index.ts'`, `'./src/*.ts'`) or
- *   start with a [NPM valid package name][3]. See [`nodejs/node#40579`][4] for
- *   details.
- *
- * [1]: https://nodejs.org/api/esm.html#esm_resolver_algorithm
- * [2]: https://nodejs.org/api/packages.html#subpath-imports
- * [3]: https://regex101.com/r/BHcJfc
- * [4]: https://github.com/nodejs/node/issues/40579
- *
- * @see {@linkcode NodeError}
- * @see {@linkcode ResolveModuleOptions}
- * @see {@linkcode URL}
- *
- * @async
- *
- * @param {string} specifier - Module specifier to resolve
- * @param {ResolveModuleOptions} [options={}] - Module resolution options
- * @return {Promise<URL>} Resolved module URL
- * @throws {NodeError}
- */
-const resolveModule = async (
-  specifier: string,
-  options: ResolveModuleOptions = {}
-): Promise<URL> => {
-  const {
-    condition = 'default',
-    conditions = CONDITIONS,
-    extensions = RESOLVE_EXTENSIONS,
-    parent = import.meta.url,
-    preserveSymlinks = false
-  } = options
-
-  // ensure specifier is a string
-  validateString(specifier, 'specifier')
-
-  // ensure option schemas
-  validateString(condition, 'options.condition')
-  validateArraySet(conditions, 'options.conditions')
-  validateArraySet(extensions, 'options.extensions')
-  validateURLString(parent, 'options.parent')
-  validateBoolean(preserveSymlinks, 'options.preserveSymlinks')
-
-  /**
-   * Module resolver.
-   *
-   * @const {Resolver} resolver
-   */
-  const resolver: Resolver = new Resolver()
-
-  /**
-   * Boolean indicating only module id should be tried for resolution.
-   *
-   * @const {boolean} onetry
-   */
-  const onetry: boolean =
-    isBuiltin(specifier) ||
-    (/^\S+:/.test(specifier) && !specifier.startsWith('file:'))
-
-  /**
-   * Module ids to try resolving.
-   *
-   * @const {string[]} tries
-   */
-  const tries: string[] = onetry
-    ? []
-    : [...extensions]
-        .flatMap(ext => [
-          specifier + (ext = pathe.formatExt(ext)),
-          specifier.startsWith('#') ? specifier + '/index' : '',
-          specifier + '/index' + ext
-        ])
-        .filter(id => !!id.length)
-
-  // try @types resolution
-  if (!onetry) {
-    specifier.startsWith('@types')
-      ? tries.unshift(specifier + '/index.d.ts')
-      : tries.unshift('@types/' + specifier + '/index.d.ts')
-  }
-
-  // ensure attempt to resolve original specifier is first
-  tries.unshift(specifier)
-
-  /**
-   * Error codes to ignore when attempting to resolve {@linkcode specifier}.
-   *
-   * **Note**: If an error is thrown, it'll be reported **_after_** all module
-   * ids in {@linkcode tries} have been evaluated.
-   *
-   * @const {Set<ErrorCode>} ignore
-   */
-  const ignore: Set<ErrorCode> = new Set<ErrorCode>([
-    ErrorCode.ERR_INVALID_MODULE_SPECIFIER,
-    ErrorCode.ERR_MODULE_NOT_FOUND,
-    ErrorCode.ERR_PACKAGE_PATH_NOT_EXPORTED,
-    ErrorCode.ERR_UNSUPPORTED_DIR_IMPORT
-  ])
-
-  /**
-   * Module resolution error.
-   *
-   * @var {NodeError} error
-   */
-  let error: NodeError
-
-  /**
-   * Resolved module URL.
-   *
-   * @var {Nullable<URL>} url
-   */
-  let url: Nullable<URL> = null
-
-  // try module resolution
-  for (const id of tries) {
-    try {
-      url = resolver.resolveModule(
-        id,
-        parent,
-        condition,
-        new Set(conditions),
-        preserveSymlinks
-      )
-    } catch (e: unknown) {
-      url = null
-      if (id === specifier) error = cast(e)
-      if (!ignore.has(cast<NodeError>(e).code)) throw e
-    }
-
-    // stop resolution attempts if module was resolved
-    if (url) break
-  }
-
-  // throw if module was not resolved
-  if (!url) throw error!
-
-  // replace file extension
-  if (url.protocol === 'file:') {
-    let { ext } = options
-
-    // get replacement extension
-    ext = isFunction(ext) ? await ext(specifier, url) : ext
-
-    // replace file extension in url href and pathname
-    url.href = pathe.changeExt(url.href, ext).replace(/\/index$/, '')
-    url.pathname = fileURLToPath(url.href)
-  }
-
-  return url
-}
-
-export default resolveModule

package/src/utils/resolve-modules.ts

@@ -1,60 +0,0 @@
-/**
- * @file resolveModules
- * @module mlly/utils/resolveModules
- */
-
-import { SpecifierSyntaxKind } from '#src/enums'
-import type { ResolveModuleOptions } from '#src/interfaces'
-import { regexp } from '@flex-development/tutils'
-import type { URL } from 'node:url'
-import extractStatements from './extract-statements'
-import resolveModule from './resolve-module'
-
-/**
- * Converts all module specifiers in `code` to absolute specifiers.
- *
- * ::: info
- * Useful for converting code to [`data:` URLs][1].
- * :::
- *
- * [1]: https://nodejs.org/api/esm.html#data-imports
- *
- * @see {@linkcode ResolveModuleOptions}
- * @see https://nodejs.org/api/esm.html#terminology
- *
- * @async
- *
- * @param {string} code - Code to evaluate
- * @param {ResolveModuleOptions} [options={}] - Module resolution options
- * @return {Promise<string>} `code` with module specifiers fully resolved
- */
-const resolveModules = async (
-  code: string,
-  options: ResolveModuleOptions = {}
-): Promise<string> => {
-  for (const statement of extractStatements(code)) {
-    if (statement.specifier) {
-      if (statement.specifier_syntax !== SpecifierSyntaxKind.DYNAMIC) {
-        /**
-         * Resolved module URL.
-         *
-         * @const {URL} url
-         */
-        const url: URL = await resolveModule(statement.specifier, options)
-
-        // replace original specifier
-        code = code.replace(
-          statement.code,
-          statement.code.replace(
-            new RegExp(`(?<=["'])${regexp(statement.specifier)}(?=["'])`),
-            url.href
-          )
-        )
-      }
-    }
-  }
-
-  return code
-}
-
-export default resolveModules

package/src/utils/to-absolute-specifier.ts

@@ -1,30 +0,0 @@
-/**
- * @file toAbsoluteSpecifier
- * @module mlly/utils/toAbsoluteSpecifier
- */
-
-import type { ModuleId } from '#src/types'
-import { pathToFileURL } from 'node:url'
-import toURL from './to-url'
-
-/**
- * Converts `specifier` into an absolute specifier.
- *
- * ::: info
- * The absolute specifier will only include a file extension if `specifier`
- * includes a file extension.
- * :::
- *
- * @see {@linkcode ModuleId}
- * @see https://nodejs.org/api/esm.html#terminology
- *
- * @param {ModuleId} specifier - Module specifier to convert
- * @param {ModuleId} [cwd=pathToFileURL('./')] - Current working directory
- * @return {string} `specifier` as absolute specifier (file url)
- */
-const toAbsoluteSpecifier = (
-  specifier: ModuleId,
-  cwd: ModuleId = pathToFileURL('./')
-): string => toURL(specifier, cwd).href
-
-export default toAbsoluteSpecifier