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

package/dist/lib/is-array-index.mjs

@@ -0,0 +1,11 @@
+function isArrayIndex(value) {
+  if (typeof value === "string") {
+    const num = +value;
+    return value === `${num}` && num >= 0 && num < 4294967295;
+  }
+  return false;
+}
+var is_array_index_default = isArrayIndex;
+export {
+  is_array_index_default as default
+};

package/dist/lib/is-bare-specifier.d.mts

@@ -0,0 +1,23 @@
+/**
+ * @file isBareSpecifier
+ * @module mlly/lib/isBareSpecifier
+ */
+import type { ModuleId } from '@flex-development/mlly';
+/**
+ * Check if `specifier` is a *bare specifier*.
+ *
+ * ::: warning
+ * Only checks specifier syntax. Does **not** guarantee the specifier references
+ * a file that exists.
+ * :::
+ *
+ * @see {@linkcode ModuleId}
+ * @see https://nodejs.org/api/esm.html#terminology
+ *
+ * @param {ModuleId} specifier
+ *  Specifier to check
+ * @return {boolean}
+ *  `true` if `specifier` is bare specifier, `false` otherwise
+ */
+declare function isBareSpecifier(specifier: ModuleId): boolean;
+export default isBareSpecifier;

package/dist/lib/is-bare-specifier.mjs

@@ -0,0 +1,11 @@
+import isAbsoluteSpecifier from "#lib/is-absolute-specifier";
+import isRelativeSpecifier from "#lib/is-relative-specifier";
+import { isBuiltin } from "@flex-development/is-builtin";
+function isBareSpecifier(specifier) {
+  if (isBuiltin(specifier)) return true;
+  return typeof specifier === "string" && !!specifier.length && !isAbsoluteSpecifier(specifier) && !isRelativeSpecifier(specifier);
+}
+var is_bare_specifier_default = isBareSpecifier;
+export {
+  is_bare_specifier_default as default
+};

package/dist/lib/is-directory.d.mts

@@ -0,0 +1,22 @@
+/**
+ * @file isDirectory
+ * @module mlly/lib/isDirectory
+ */
+import type { FileSystem, ModuleId } from '@flex-development/mlly';
+/**
+ * Check if a directory exists at the given module `id`.
+ *
+ * @see {@linkcode FileSystem}
+ * @see {@linkcode ModuleId}
+ *
+ * @async
+ *
+ * @param {ModuleId} id
+ *  Module id to check
+ * @param {FileSystem | null | undefined} fs
+ *  File system API
+ * @return {Promise<boolean>}
+ *  `true` if directory exists at `id`, `false` otherwise
+ */
+declare function isDirectory(id: ModuleId, fs?: FileSystem | null | undefined): Promise<boolean>;
+export default isDirectory;

package/dist/lib/is-directory.mjs

@@ -0,0 +1,13 @@
+import dfs from "#internal/fs";
+async function isDirectory(id, fs) {
+  try {
+    if (typeof id === "string" && id.startsWith("file:")) id = new URL(id);
+    return (await (fs ?? dfs).stat(id)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+var is_directory_default = isDirectory;
+export {
+  is_directory_default as default
+};

package/dist/lib/is-file.d.mts

@@ -0,0 +1,22 @@
+/**
+ * @file isFile
+ * @module mlly/lib/isFile
+ */
+import type { FileSystem, ModuleId } from '@flex-development/mlly';
+/**
+ * Check if a file exists at the given module `id`.
+ *
+ * @see {@linkcode FileSystem}
+ * @see {@linkcode ModuleId}
+ *
+ * @async
+ *
+ * @param {ModuleId} id
+ *  Module id to check
+ * @param {FileSystem | null | undefined} fs
+ *  File system API
+ * @return {Promise<boolean>}
+ *  `true` if file exists at `id`, `false` otherwise
+ */
+declare function isFile(id: ModuleId, fs?: FileSystem | null | undefined): Promise<boolean>;
+export default isFile;

package/dist/lib/is-file.mjs

@@ -0,0 +1,13 @@
+import dfs from "#internal/fs";
+async function isFile(id, fs) {
+  try {
+    if (typeof id === "string" && id.startsWith("file:")) id = new URL(id);
+    return (await (fs ?? dfs).stat(id)).isFile();
+  } catch {
+    return false;
+  }
+}
+var is_file_default = isFile;
+export {
+  is_file_default as default
+};

package/dist/lib/is-imports-subpath.d.mts

@@ -0,0 +1,19 @@
+/**
+ * @file isImportsSubpath
+ * @module mlly/lib/isImportsSubpath
+ */
+import type { ModuleId } from '@flex-development/mlly';
+import type { ImportsSubpath } from '@flex-development/pkg-types';
+/**
+ * Check if `specifier` is an `imports` subpath.
+ *
+ * @see {@linkcode ModuleId}
+ * @see https://nodejs.org/api/packages.html#subpath-imports
+ *
+ * @param {ModuleId} specifier
+ *  Specifier to check
+ * @return {specifier is ImportsSubpath}
+ *  `true` if `specifier` is `imports` subpath, `false` otherwise
+ */
+declare function isImportsSubpath(specifier: ModuleId): specifier is ImportsSubpath;
+export default isImportsSubpath;

package/dist/lib/is-imports-subpath.mjs

@@ -0,0 +1,8 @@
+import chars from "#internal/chars";
+function isImportsSubpath(specifier) {
+  return typeof specifier === "string" && specifier[0] === chars.hash;
+}
+var is_imports_subpath_default = isImportsSubpath;
+export {
+  is_imports_subpath_default as default
+};

package/dist/lib/is-relative-specifier.d.mts

@@ -0,0 +1,21 @@
+/**
+ * @file isRelativeSpecifier
+ * @module mlly/lib/isRelativeSpecifier
+ */
+/**
+ * Check if `specifier` is a *relative specifier*.
+ *
+ * ::: warning
+ * Only checks specifier syntax. Does **not** guarantee the specifier references
+ * a file that exists.
+ * :::
+ *
+ * @see https://nodejs.org/api/esm.html#terminology
+ *
+ * @param {unknown} specifier
+ *  Specifier to check
+ * @return {boolean}
+ *  `true` if `specifier` is relative specifier, `false` otherwise
+ */
+declare function isRelativeSpecifier(specifier: unknown): boolean;
+export default isRelativeSpecifier;

package/dist/lib/is-relative-specifier.mjs

@@ -0,0 +1,16 @@
+import pathe from "@flex-development/pathe";
+function isRelativeSpecifier(specifier) {
+  if (typeof specifier === "string") {
+    if (specifier[0] === pathe.dot) {
+      if (specifier.length === 1 || specifier[1] === pathe.sep) return true;
+      if (specifier[1] === pathe.dot && (specifier.length === 2 || specifier[2] === pathe.sep)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var is_relative_specifier_default = isRelativeSpecifier;
+export {
+  is_relative_specifier_default as default
+};

package/dist/lib/lookup-package-scope.d.mts

@@ -0,0 +1,26 @@
+/**
+ * @file lookupPackageScope
+ * @module mlly/lib/lookupPackageScope
+ */
+import type { FileSystem, ModuleId } from '@flex-development/mlly';
+/**
+ * Get the package scope URL for the given module `url`.
+ *
+ * Implements the `LOOKUP_PACKAGE_SCOPE` algorithm.
+ *
+ * @see {@linkcode FileSystem}
+ * @see {@linkcode ModuleId}
+ *
+ * @async
+ *
+ * @param {ModuleId} url
+ *  URL of module to get package scope for
+ * @param {ModuleId | null | undefined} [end]
+ *  URL of directory to end search, defaults to {@linkcode root}
+ * @param {FileSystem | null | undefined} [fs]
+ *  File system API
+ * @return {Promise<URL | null>}
+ *  URL of nearest directory containing `package.json` file or `null`
+ */
+declare function lookupPackageScope(url: ModuleId, end?: ModuleId | null | undefined, fs?: FileSystem | null | undefined): Promise<URL | null>;
+export default lookupPackageScope;

package/dist/lib/lookup-package-scope.mjs

@@ -0,0 +1,16 @@
+import isFile from "#lib/is-file";
+import root from "#lib/root";
+import pathe from "@flex-development/pathe";
+async function lookupPackageScope(url, end, fs) {
+  let scopeUrl = new URL(url);
+  while (String(scopeUrl) !== String(end ?? root)) {
+    scopeUrl = /[/\\]$/.test(scopeUrl.pathname) ? new URL(pathe.dot + pathe.dot, scopeUrl) : new URL(pathe.dot, scopeUrl);
+    if (/node_modules[/\\]$/.test(scopeUrl.pathname)) break;
+    if (await isFile(new URL("package.json", scopeUrl), fs)) return scopeUrl;
+  }
+  return null;
+}
+var lookup_package_scope_default = lookupPackageScope;
+export {
+  lookup_package_scope_default as default
+};

package/dist/lib/pattern-key-compare.d.mts

@@ -0,0 +1,31 @@
+/**
+ * @file patternKeyCompare
+ * @module mlly/lib/patternKeyCompare
+ */
+import type { PatternKeyCompareResult } from '@flex-development/mlly';
+/**
+ * Compares two strings that may contain a wildcard character (`'*'`) and
+ * returns a value indicating their order:
+ *
+ * - `-1`: `a` should come before `b`
+ * - `0`: `a` and `b` are equal
+ * - `1`: `a` should come after `b`
+ *
+ * Implements the `PATTERN_KEY_COMPARE` algorithm.
+ *
+ * @see {@linkcode PatternKeyCompareResult}
+ *
+ * @param {string} a
+ *  First string to compare
+ * @param {string} b
+ *  Second string to compare
+ * @return {PatternKeyCompareResult}
+ *  Comparsion result
+ */
+declare function patternKeyCompare(a: string, b: string): PatternKeyCompareResult;
+declare namespace patternKeyCompare {
+    var EQUAL: 0;
+    var GREATER_THAN: 1;
+    var LESS_THAN: -1;
+}
+export default patternKeyCompare;

package/dist/lib/pattern-key-compare.mjs

@@ -0,0 +1,18 @@
+import chars from "#internal/chars";
+import { ok } from "devlop";
+function patternKeyCompare(a, b) {
+  let aPatternIndex = a.indexOf(chars.asterisk);
+  let bPatternIndex = b.indexOf(chars.asterisk);
+  ok(aPatternIndex === a.lastIndexOf(chars.asterisk), 'expected a single "*"');
+  ok(bPatternIndex === b.lastIndexOf(chars.asterisk), 'expected a single "*"');
+  const baseLenA = aPatternIndex === patternKeyCompare.LESS_THAN ? a.length : aPatternIndex + 1;
+  const baseLenB = bPatternIndex === patternKeyCompare.LESS_THAN ? b.length : bPatternIndex + 1;
+  return baseLenA > baseLenB ? patternKeyCompare.LESS_THAN : baseLenB > baseLenA ? patternKeyCompare.GREATER_THAN : aPatternIndex === -1 ? patternKeyCompare.GREATER_THAN : bPatternIndex === -1 ? patternKeyCompare.LESS_THAN : a.length > b.length ? patternKeyCompare.LESS_THAN : b.length > a.length ? patternKeyCompare.GREATER_THAN : patternKeyCompare.EQUAL;
+}
+patternKeyCompare.EQUAL = 0;
+patternKeyCompare.GREATER_THAN = 1;
+patternKeyCompare.LESS_THAN = -1;
+var pattern_key_compare_default = patternKeyCompare;
+export {
+  pattern_key_compare_default as default
+};

package/dist/lib/pattern-match.d.mts

@@ -0,0 +1,19 @@
+/**
+ * @file patternMatch
+ * @module mlly/lib/patternMatch
+ */
+import type { PatternMatch } from '@flex-development/mlly';
+/**
+ * Get a subpath pattern match for `matchKey`.
+ *
+ * @see {@linkcode PatternMatch}
+ *
+ * @param {string} matchKey
+ *  The string to expand
+ * @param {unknown} matchObject
+ *  Object containing match keys
+ * @return {PatternMatch | null}
+ *  List containing key of `matchObject` and subpath pattern match or `null`
+ */
+declare function patternMatch(matchKey: string, matchObject: unknown): PatternMatch | null;
+export default patternMatch;

package/dist/lib/pattern-match.mjs

@@ -0,0 +1,36 @@
+import chars from "#internal/chars";
+import patternKeyCompare from "#lib/pattern-key-compare";
+import { ok } from "devlop";
+function patternMatch(matchKey, matchObject) {
+  if (typeof matchObject === "object" && matchObject) {
+    if (Object.prototype.hasOwnProperty.call(matchObject, matchKey) && !matchKey.includes(chars.asterisk)) {
+      return [matchKey, null];
+    }
+    const expansionKeys = Object.getOwnPropertyNames(matchObject).filter((expansionKey) => {
+      const patternIndex = expansionKey.indexOf(chars.asterisk);
+      return patternIndex >= 0 && patternIndex === expansionKey.lastIndexOf(chars.asterisk);
+    }).sort(patternKeyCompare);
+    for (const expansionKey of expansionKeys) {
+      const patternIndex = expansionKey.indexOf(chars.asterisk);
+      const patternBase = expansionKey.slice(0, patternIndex);
+      ok(patternIndex >= 0, "expected `patternIndex >= 0`");
+      if (matchKey !== patternBase && matchKey.startsWith(patternBase)) {
+        const patternTrailer = expansionKey.slice(patternIndex + 1);
+        if (!patternTrailer.length || matchKey.endsWith(patternTrailer) && (matchKey.length >= expansionKey.length || matchKey === patternBase + patternTrailer)) {
+          return [
+            expansionKey,
+            matchKey.slice(
+              patternBase.length,
+              matchKey.length - patternTrailer.length
+            )
+          ];
+        }
+      }
+    }
+  }
+  return null;
+}
+var pattern_match_default = patternMatch;
+export {
+  pattern_match_default as default
+};

package/dist/lib/read-package-json.d.mts

@@ -0,0 +1,35 @@
+/**
+ * @file readPackageJson
+ * @module mlly/lib/readPackageJson
+ */
+import type { FileSystem, ModuleId } from '@flex-development/mlly';
+import type { PackageJson } from '@flex-development/pkg-types';
+/**
+ * Read a `package.json` file.
+ *
+ * Implements the `READ_PACKAGE_JSON` algorithm.
+ *
+ * @see {@linkcode ErrInvalidPackageConfig}
+ * @see {@linkcode FileSystem}
+ * @see {@linkcode ModuleId}
+ * @see {@linkcode PackageJson}
+ *
+ * @async
+ *
+ * @param {ModuleId} id
+ *  URL of package directory, `package.json` file, or module in the same
+ *  directory as a `package.json` file
+ * @param {string | null | undefined} [specifier]
+ *  Module specifier that initiated reading of `package.json` file.\
+ *  Should be a `file:` URL if `parent` is a not a URL
+ * @param {ModuleId | null | undefined} [parent]
+ *  URL of parent module
+ * @param {FileSystem | null | undefined} [fs]
+ *  File system API
+ * @return {Promise<PackageJson | null>}
+ *  Parsed file contents or `null`
+ * @throws {ErrInvalidPackageConfig}
+ *  If `package.json` file does not parse as valid JSON
+ */
+declare function readPackageJson(id: ModuleId, specifier?: string | null | undefined, parent?: ModuleId | null | undefined, fs?: FileSystem | null | undefined): Promise<PackageJson | null>;
+export default readPackageJson;

package/dist/lib/read-package-json.mjs

@@ -0,0 +1,29 @@
+import dfs from "#internal/fs";
+import isFile from "#lib/is-file";
+import {
+  ERR_INVALID_PACKAGE_CONFIG
+} from "@flex-development/errnode";
+import pathe from "@flex-development/pathe";
+async function readPackageJson(id, specifier, parent, fs) {
+  const url = new URL("package.json", id);
+  if (await isFile(url, fs)) {
+    const data = String(await (fs ?? dfs).readFile(url));
+    try {
+      return JSON.parse(data);
+    } catch (e) {
+      const cause = e;
+      const error = new ERR_INVALID_PACKAGE_CONFIG(
+        url.pathname,
+        parent && specifier ? `"${specifier}" from ${pathe.fileURLToPath(parent)}` : specifier && pathe.fileURLToPath(specifier),
+        cause.message
+      );
+      error.cause = cause;
+      throw error;
+    }
+  }
+  return null;
+}
+var read_package_json_default = readPackageJson;
+export {
+  read_package_json_default as default
+};

package/dist/lib/resolve-alias.d.mts

@@ -0,0 +1,19 @@
+/**
+ * @file resolveAlias
+ * @module mlly/lib/resolveAlias
+ */
+import type { ResolveAliasOptions } from '@flex-development/mlly';
+export default resolveAlias;
+/**
+ * Resolve an aliased `specifier`.
+ *
+ * @see {@linkcode ResolveAliasOptions}
+ *
+ * @param {string} specifier
+ *  The module specifier to resolve
+ * @param {ResolveAliasOptions | null | undefined} [options]
+ *  Alias resolution options
+ * @return {string | null }
+ *  Specifier of aliased module or `null` if path alias match is not found
+ */
+declare function resolveAlias(specifier: string, options?: ResolveAliasOptions | null | undefined): string | null;

package/dist/lib/resolve-alias.mjs

@@ -0,0 +1,50 @@
+import chars from "#internal/chars";
+import cwd from "#lib/cwd";
+import isRelativeSpecifier from "#lib/is-relative-specifier";
+import patternMatch from "#lib/pattern-match";
+import toRelativeSpecifier from "#lib/to-relative-specifier";
+import pathe from "@flex-development/pathe";
+var resolve_alias_default = resolveAlias;
+function resolveAlias(specifier, options) {
+  let aliased = null;
+  if (options) {
+    if (typeof options.aliases === "object" && options.aliases) {
+      const match = patternMatch(
+        specifier,
+        options.aliases
+      );
+      if (match) {
+        aliased = resolveAliasTarget(options.aliases[match[0]], match[1]);
+        if (typeof aliased === "string") {
+          const url = new URL(aliased, options.cwd ?? cwd());
+          if (options.absolute) {
+            aliased = url.href;
+          } else if (options.parent) {
+            aliased = toRelativeSpecifier(url, options.parent);
+          }
+        }
+      }
+    }
+  }
+  return aliased;
+}
+function resolveAliasTarget(target, patternMatch2) {
+  if (typeof target === "string") {
+    let match = typeof patternMatch2 === "string" ? target.replace(chars.asterisk, patternMatch2) : target;
+    if (!isRelativeSpecifier(match)) match = pathe.dot + pathe.sep + match;
+    return match;
+  }
+  if (Array.isArray(target)) {
+    for (const targetValue of target) {
+      const resolved = resolveAliasTarget(
+        targetValue,
+        patternMatch2
+      );
+      if (typeof resolved === "string") return resolved;
+    }
+  }
+  return null;
+}
+export {
+  resolve_alias_default as default
+};

package/dist/lib/resolve-module.d.mts

@@ -0,0 +1,37 @@
+/**
+ * @file resolveModule
+ * @module mlly/lib/resolveModule
+ */
+import type { ModuleId, ResolveModuleOptions } from '@flex-development/mlly';
+export default resolveModule;
+/**
+ * Resolve a module `specifier` according to the [ESM Resolver algorithm][esm],
+ * mostly 😉.
+ *
+ * Adds support for:
+ *
+ * - Changing file extensions
+ * - Directory index resolution
+ * - Extensionless file resolution
+ * - Path alias resolution
+ * - Scopeless `@types/*` resolution (i.e. `unist` -> `@types/unist`)
+ *
+ * [esm]: https://nodejs.org/api/esm.html#esm_resolver_algorithm
+ *
+ * @see {@linkcode ModuleId}
+ * @see {@linkcode NodeError}
+ * @see {@linkcode ResolveModuleOptions}
+ *
+ * @async
+ *
+ * @param {string} specifier
+ *  The module specifier to resolve
+ * @param {ModuleId} parent
+ *  URL of parent module
+ * @param {ResolveModuleOptions | null | undefined} [options]
+ *  Resolution options
+ * @return {Promise<URL>}
+ *  Resolved URL
+ * @throws {NodeError}
+ */
+declare function resolveModule(specifier: string, parent: ModuleId, options?: ResolveModuleOptions | null | undefined): Promise<URL>;

package/dist/lib/resolve-module.mjs

@@ -0,0 +1,75 @@
+import defaultExtensions from "#lib/default-extensions";
+import resolveAlias from "#lib/resolve-alias";
+import { moduleResolve } from "#lib/resolver";
+import {
+  codes,
+  isNodeError
+} from "@flex-development/errnode";
+import pathe from "@flex-development/pathe";
+var resolve_module_default = resolveModule;
+async function resolveModule(specifier, parent, options) {
+  try {
+    return changeExt(await moduleResolve(
+      resolveAlias(specifier, { ...options, parent }) ?? specifier,
+      parent,
+      options?.conditions,
+      options?.mainFields,
+      options?.preserveSymlinks,
+      options?.fs
+    ), specifier, options?.ext);
+  } catch (e) {
+    const ignore = /* @__PURE__ */ new Set([
+      codes.ERR_MODULE_NOT_FOUND,
+      codes.ERR_UNSUPPORTED_DIR_IMPORT
+    ]);
+    if (isNodeError(e) && ignore.has(e.code)) {
+      const extensions = [
+        ...options?.extensions ?? defaultExtensions
+      ];
+      let tries = [];
+      if (e.code === codes.ERR_MODULE_NOT_FOUND && !e.url) {
+        tries = [
+          specifier.startsWith("@types/") ? specifier : "@types/" + specifier
+        ].flatMap((specifier2) => [
+          specifier2,
+          specifier2 + pathe.sep + "index.d.ts",
+          specifier2 + pathe.sep + "index.d.mts",
+          specifier2 + pathe.sep + "index.d.cts"
+        ]);
+      }
+      if (e.code === codes.ERR_MODULE_NOT_FOUND && e.url) {
+        tries = extensions.map((ext) => specifier + pathe.formatExt(ext));
+      }
+      if (e.code === codes.ERR_UNSUPPORTED_DIR_IMPORT) {
+        tries = extensions.map((ext) => {
+          return specifier + pathe.sep + "index" + pathe.formatExt(ext);
+        });
+      }
+      for (const attempt of tries) {
+        try {
+          return changeExt(await moduleResolve(
+            attempt,
+            parent,
+            options?.conditions,
+            options?.mainFields,
+            options?.preserveSymlinks,
+            options?.fs
+          ), specifier, options?.ext);
+        } catch {
+          continue;
+        }
+      }
+    }
+    throw e;
+  }
+}
+function changeExt(url, specifier, ext) {
+  if (url.protocol === "file:" && ext !== void 0) {
+    url.href = typeof ext === "function" ? pathe.changeExt(url.href, ext(url, specifier)) : pathe.changeExt(url.href, ext);
+    url = new URL(pathe.toPosix(url.href).replace(/\/index$/, pathe.sep));
+  }
+  return url;
+}
+export {
+  resolve_module_default as default
+};