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

package/src/utils/find-subpath.ts

@@ -12,7 +12,18 @@ import validateURLString from '#src/internal/validate-url-string'
 import type { NodeError } from '@flex-development/errnode'
 import pathe from '@flex-development/pathe'
 import type { Exports, Imports } from '@flex-development/pkg-types'
-import { isNIL, type Nullable } from '@flex-development/tutils'
+import {
+  DOT,
+  cast,
+  isArray,
+  isNIL,
+  isObjectCurly,
+  isString,
+  sort,
+  type Nilable,
+  type Nullable,
+  type Optional
+} from '@flex-development/tutils'
 import { URL } from 'node:url'
 import compareSubpaths from './compare-subpaths'
 import CONDITIONS from './conditions'
@@ -37,14 +48,14 @@ import toURL from './to-url'
  * @see https://nodejs.org/api/packages.html#subpath-imports
  *
  * @param {string} target - Package target to find in `context`
- * @param {Exports | Imports | undefined} context - Package context
+ * @param {Nilable<Exports | Imports>} context - Package context
  * @param {FindSubpathOptions} options - Search options
  * @return {Nullable<string>} Subpath defined in `context` or `null`
  * @throws {NodeError<Error | TypeError>}
  */
 const findSubpath = (
   target: string,
-  context: Exports | Imports | undefined,
+  context: Nilable<Exports | Imports>,
   options: FindSubpathOptions
 ): Nullable<string> => {
   const {
@@ -62,9 +73,9 @@ const findSubpath = (
   validateString(target, 'target')
 
   // exit early if target is an exactish match
-  if (typeof context === 'string') {
+  if (isString(context)) {
     if (target === context || target === pathe.changeExt(context, '')) {
-      return '.'
+      return DOT
     }
   }
 
@@ -85,14 +96,14 @@ const findSubpath = (
    * [2]: https://nodejs.org/api/packages.html#imports
    *
    * @param {string} target - Package target to find in `context`
-   * @param {Exports | Imports | undefined} context - Package context
-   * @param {string} [key='.'] - Subpath in `context` being checked
+   * @param {Nilable<Exports | Imports>} context - Package context
+   * @param {string} [key=DOT] - Subpath in `context` being checked
    * @return {Nullable<string>} Subpath defined in `context` or `null`
    */
   const find = (
     target: string,
-    context: Exports | Imports | undefined,
-    key: string = '.'
+    context: Nilable<Exports | Imports>,
+    key: string = DOT
   ): Nullable<string> => {
     /**
      * Subpath defined in {@linkcode context} that maps to {@linkcode target}.
@@ -102,143 +113,133 @@ const findSubpath = (
     let subpath: Nullable<string> = null
 
     // match target to subpath
-    switch (true) {
-      case !isNIL(context) && typeof context === 'object':
-      case typeof context === 'string':
+    if (isArray(context) || isObjectCurly(context) || isString(context)) {
+      /**
+       * URL of directory containing relevant `package.json` file.
+       *
+       * @const {string} pkgdir
+       */
+      const pkgdir: string = toURL(dir).href.replace(/\/$/, '') + pathe.sep
+
+      /**
+       * URL of relevant `package.json` file.
+       *
+       * @const {URL} pkg
+       */
+      const pkg: URL = new URL('package.json', pkgdir)
+
+      // convert package context to object if using exports sugar
+      if (!internal && isExportsSugar(context, pkg, parent)) {
+        context = cast<Record<string, Exports>>({ [key]: context })
+      }
+
+      // context is now an object
+      context = cast<Record<string, Exports>>(context)
+
+      /**
+       * Subpaths defined in {@linkcode context}.
+       *
+       * **Note**: Sorted from least to greatest.
+       *
+       * @see {@linkcode compareSubpaths}
+       *
+       * @const {string[]} keys
+       */
+      const subpaths: string[] = sort(
+        getSubpaths(context, internal, pkg, parent),
+        (s1, s2) => compareSubpaths(s1, s2) * -1
+      )
+
+      // match target to subpath defined in context
+      for (const pkgsubpath of subpaths) {
         /**
-         * URL of directory containing relevant `package.json` file.
+         * Current package target being checked.
          *
-         * @const {string} pkgdir
+         * @var {Optional<Exports>} tar
          */
-        const pkgdir: string = toURL(dir).href.replace(/\/$/, '') + pathe.sep
-
-        /**
-         * URL of relevant `package.json` file.
-         *
-         * @const {URL} pkg
-         */
-        const pkg: URL = new URL('package.json', pkgdir)
-
-        // convert package context to object if using exports sugar
-        if (!internal && isExportsSugar(context, pkg, parent)) {
-          context = { [key]: context } as Record<string, Exports>
-        }
-
-        // context is now an object
-        context = context as Record<string, Exports>
-
-        /**
-         * Subpaths defined in {@linkcode context}.
-         *
-         * **Note**: Sorted from least to greatest.
-         *
-         * @see {@linkcode compareSubpaths}
-         *
-         * @const {string[]} keys
-         */
-        const subpaths: string[] = getSubpaths(
-          context,
-          internal,
-          pkg,
-          parent
-        ).sort((s1, s2) => compareSubpaths(s1, s2) * -1)
-
-        // match target to subpath defined in context
-        for (const pkgsubpath of subpaths) {
-          /**
-           * Current package target being checked.
-           *
-           * @var {Exports} tar
-           */
-          let tar: Exports = context[pkgsubpath]!
-
-          // find subpath
-          switch (true) {
-            case Array.isArray(tar):
-              tar = tar as string[]
-
-              // try matching target based first match in target array
-              for (const item of tar) {
-                subpath = find(target, item, pkgsubpath)
+        let tar: Optional<Exports> = context[pkgsubpath]
+
+        // find subpath
+        switch (true) {
+          case isArray(tar):
+            // try matching target based first match in target array
+            for (const item of cast<string[]>(tar)) {
+              subpath = find(target, item, pkgsubpath)
+              if (subpath) break
+            }
+
+            break
+          case isObjectCurly(tar):
+            tar = cast<Record<string, Exports>>(tar)
+
+            // try matching target based on export conditions
+            for (const property of Object.getOwnPropertyNames(tar)) {
+              if (property === condition || conditions.has(property)) {
+                subpath = find(target, tar[property], pkgsubpath)
                 if (subpath) break
               }
-
-              break
-            case typeof tar === 'object' && !isNIL(tar):
-              tar = tar as Record<string, Exports>
-
-              // try matching target based on export conditions
-              for (const prop of Object.getOwnPropertyNames(tar)) {
-                if (prop === condition || conditions.has(prop)) {
-                  subpath = find(target, tar[prop], pkgsubpath)
-                  if (subpath) break
-                }
-              }
-
-              break
-            case typeof tar === 'string':
-              tar = tar as string
-
-              /**
-               * {@linkcode tar} without file extension.
-               *
-               * @const {string} tar_ne
-               */
-              const tar_ne: string = pathe.changeExt(tar, '')
-
-              /**
-               * {@linkcode tar_ne} without `'/index'`.
-               *
-               * @const {string} tar_ni
-               */
-              const tar_ni: string = tar_ne.replace(/\/index$/, '')
-
-              /**
-               * Index of {@linkcode PATTERN_CHARACTER} in {@linkcode tar}.
-               *
-               * @const {number} pattern
-               */
-              const pattern: number = tar.indexOf(PATTERN_CHARACTER)
-
-              switch (true) {
-                // target is an exactish match
-                case target === tar:
-                case target === tar_ne:
-                case target === tar_ni && tar_ne.endsWith('/index'):
-                case pattern === -1 && (target === tar || target === tar_ne):
-                  subpath = pkgsubpath
-                  break
-                // pattern character => try finding best match for target
-                case pattern !== -1 && target.startsWith(tar.slice(0, pattern)):
-                  /**
-                   * Boolean indicating if {@linkcode target} ends with the
-                   * characters after the pattern character (`*`) in
-                   * {@linkcode tar}.
-                   *
-                   * @const {boolean} match
-                   */
-                  const match: boolean =
-                    target.length >= tar.length &&
-                    tar.lastIndexOf(PATTERN_CHARACTER) === pattern &&
-                    (target.endsWith(tar.slice(pattern + 1)) ||
-                      target.endsWith(tar_ne.slice(pattern + 1)))
-
-                  // set subpath if match was found
-                  if (match) subpath = pkgsubpath
-
-                  break
-              }
-
-              break
-          }
-
-          // stop searching for subpath if subpath has been found
-          if (subpath) break
+            }
+
+            break
+          case isString(tar):
+            tar = cast<string>(tar)
+
+            /**
+             * {@linkcode tar} without file extension.
+             *
+             * @const {string} tar_ne
+             */
+            const tar_ne: string = pathe.changeExt(tar, '')
+
+            /**
+             * {@linkcode tar_ne} without `'/index'`.
+             *
+             * @const {string} tar_ni
+             */
+            const tar_ni: string = tar_ne.replace(/\/index$/, '')
+
+            /**
+             * Index of {@linkcode PATTERN_CHARACTER} in {@linkcode tar}.
+             *
+             * @const {number} pattern
+             */
+            const pattern: number = tar.indexOf(PATTERN_CHARACTER)
+
+            switch (true) {
+              // target is an exactish match
+              case target === tar:
+              case target === tar_ne:
+              case target === tar_ni && tar_ne.endsWith('/index'):
+              case pattern === -1 && (target === tar || target === tar_ne):
+                subpath = pkgsubpath
+                break
+              // pattern character => try finding best match for target
+              case pattern !== -1 && target.startsWith(tar.slice(0, pattern)):
+                /**
+                 * Boolean indicating if {@linkcode target} ends with the
+                 * characters after the pattern character (`*`) in
+                 * {@linkcode tar}.
+                 *
+                 * @const {boolean} match
+                 */
+                const match: boolean =
+                  target.length >= tar.length &&
+                  tar.lastIndexOf(PATTERN_CHARACTER) === pattern &&
+                  (target.endsWith(tar.slice(pattern + 1)) ||
+                    target.endsWith(tar_ne.slice(pattern + 1)))
+
+                // set subpath if match was found
+                if (match) subpath = pkgsubpath
+
+                break
+            }
+
+            break
         }
 
-        break
-      default:
-        break
+        // stop searching for subpath if subpath has been found
+        if (subpath) break
+      }
     }
 
     return subpath

package/src/utils/get-format.ts

@@ -16,10 +16,12 @@ import {
 import { isBuiltin } from '@flex-development/is-builtin'
 import pathe, { type Ext } from '@flex-development/pathe'
 import {
+  isEmptyString,
   isUndefined,
   type EmptyString,
   type Nilable,
-  type Nullable
+  type Nullable,
+  type Optional
 } from '@flex-development/tutils'
 import type { URL } from 'node:url'
 import EXTENSION_FORMAT_MAP from './extension-format-map'
@@ -189,30 +191,34 @@ const getFormat = async (
            *
            * [1]: https://nodejs.org/api/errors.html#err_unknown_file_extension
            *
-           * @var {string?} suggestion
+           * @var {Optional<string>} suggestion
            */
-          let suggestion: string | undefined
+          let suggestion: Optional<string>
 
           // add recommended fix for ERR_UNKNOWN_FILE_EXTENSION if package is
           // esm-only and module id does not include file extension
-          if (scope && scope.pkgjson.type === Format.MODULE && ext === '') {
-            const { pkg } = scope
-
-            /**
-             * Basename of {@linkcode url.pathname}
-             *
-             * @const {string} basename
-             */
-            const basename: string = pathe.basename(url.pathname)
-
-            /**
-             * Relative path from {@linkcode pkg} to {@linkcode url.pathname}.
-             *
-             * @const {string} relative
-             */
-            const relative: string = pathe.relative(pkg, url.pathname).slice(1)
-
-            suggestion = `Loading extensionless files is not supported inside of "type":"module" package.json contexts. The package.json file ${pkg} caused this "type":"module" context. Try changing ${url.pathname} to have a file extension. Note the "bin" field of package.json can point to a file with an extension, for example {"type":"module","bin":{"${basename}":"${relative}.js"}}`
+          if (scope && scope.pkgjson.type === Format.MODULE) {
+            if (isEmptyString(ext)) {
+              const { pkg } = scope
+
+              /**
+               * Basename of {@linkcode url.pathname}
+               *
+               * @const {string} basename
+               */
+              const basename: string = pathe.basename(url.pathname)
+
+              /**
+               * Relative path from {@linkcode pkg} to {@linkcode url.pathname}.
+               *
+               * @const {string} relative
+               */
+              const relative: string = pathe
+                .relative(pkg, url.pathname)
+                .slice(1)
+
+              suggestion = `Loading extensionless files is not supported inside of "type":"module" package.json contexts. The package.json file ${pkg} caused this "type":"module" context. Try changing ${url.pathname} to have a file extension. Note the "bin" field of package.json can point to a file with an extension, for example {"type":"module","bin":{"${basename}":"${relative}.js"}}`
+            }
           }
 
           throw new ERR_UNKNOWN_FILE_EXTENSION(ext, url.pathname, suggestion)

package/src/utils/get-source.ts

@@ -13,7 +13,7 @@ import {
   ERR_UNSUPPORTED_ESM_URL_SCHEME,
   type NodeError
 } from '@flex-development/errnode'
-import { isUndefined } from '@flex-development/tutils'
+import { isUndefined, type Optional } from '@flex-development/tutils'
 import fs from 'node:fs/promises'
 import os from 'node:os'
 import type { URL } from 'node:url'
@@ -39,13 +39,13 @@ import toURL from './to-url'
  *
  * @param {ModuleId} id - Module id to evaluate
  * @param {GetSourceOptions?} [options={}] - Source code retrieval options
- * @return {Promise<Uint8Array | string | undefined>} Source code for `id`
+ * @return {Promise<Optional<Uint8Array | string>>} Source code for `id`
  * @throws {NodeError} If unsupported URL scheme is encountered
  */
 const getSource = async (
   id: ModuleId,
   options: GetSourceOptions = {}
-): Promise<Uint8Array | string | undefined> => {
+): Promise<Optional<Uint8Array | string>> => {
   const {
     experimental_network_imports: network_imports = false,
     format,
@@ -80,9 +80,9 @@ const getSource = async (
   /**
    * Source code for {@linkcode id}.
    *
-   * @var {Uint8Array | string | undefined} source
+   * @var {Optional<Uint8Array | string>} source
    */
-  let source: Uint8Array | string | undefined = ''
+  let source: Optional<Uint8Array | string> = ''
 
   // get source code based on url protocol
   switch (url.protocol) {

package/src/utils/index.ts

@@ -20,7 +20,9 @@ export { default as hasCJSSyntax } from './has-cjs-syntax'
 export { default as hasESMSyntax } from './has-esm-syntax'
 export { default as isAbsoluteSpecifier } from './is-absolute-specifier'
 export { default as isBareSpecifier } from './is-bare-specifier'
+export { default as isDirectory } from './is-directory'
 export { default as isExportsSugar } from './is-exports-sugar'
+export { default as isFile } from './is-file'
 export { default as isRelativeSpecifier } from './is-relative-specifier'
 export { default as lookupPackageScope } from './lookup-package-scope'
 export { default as parseDataURL } from './parse-data-url'

package/src/utils/is-bare-specifier.ts

@@ -5,6 +5,7 @@
 
 import validateString from '#src/internal/validate-string'
 import type { NodeError } from '@flex-development/errnode'
+import { trim } from '@flex-development/tutils'
 import isAbsoluteSpecifier from './is-absolute-specifier'
 import isRelativeSpecifier from './is-relative-specifier'
 
@@ -26,7 +27,7 @@ const isBareSpecifier = (specifier: string): boolean => {
   validateString(specifier, 'specifier')
 
   return (
-    specifier.trim().length > 0 &&
+    !!trim(specifier).length &&
     !isAbsoluteSpecifier(specifier) &&
     !isRelativeSpecifier(specifier)
   )

package/src/{internal → utils}/is-directory.ts

@@ -3,9 +3,9 @@
  * @module mlly/internal/isDirectory
  */
 
+import validateURLString from '#src/internal/validate-url-string'
 import type { ModuleId } from '#src/types'
 import fs from 'node:fs'
-import validateURLString from './validate-url-string'
 
 /**
  * Checks if a directory exists at the given module `id`.

package/src/utils/is-exports-sugar.ts

@@ -6,7 +6,15 @@
 import type { ModuleId } from '#src/types'
 import type { NodeError } from '@flex-development/errnode'
 import type { Exports } from '@flex-development/pkg-types'
-import { isNIL } from '@flex-development/tutils'
+import {
+  at,
+  cast,
+  DOT,
+  isArray,
+  isObjectCurly,
+  isString,
+  type Nilable
+} from '@flex-development/tutils'
 import validateExports from './validate-exports'
 
 /**
@@ -18,7 +26,7 @@ import validateExports from './validate-exports'
  * @see {@linkcode Exports}
  * @see {@linkcode ModuleId}
  *
- * @param {Exports | undefined} exports - Package `exports`
+ * @param {Nilable<Exports>} exports - Package `exports`
  * @param {ModuleId} pkg - URL of relevant `package.json` file
  * @param {ModuleId} parent - URL of module to resolve from
  * @return {boolean} `true` if `exports` is using exports sugar
@@ -27,7 +35,7 @@ import validateExports from './validate-exports'
  * schema is invalid
  */
 const isExportsSugar = (
-  exports: Exports | undefined,
+  exports: Nilable<Exports>,
   pkg: ModuleId,
   parent: ModuleId
 ): boolean => {
@@ -42,16 +50,15 @@ const isExportsSugar = (
 
   // check if exports sugar is being used
   switch (true) {
-    case Array.isArray(exports):
-    case typeof exports === 'string':
+    case isArray(exports):
+    case isString(exports):
       sugar = true
       break
-    case isNIL(exports):
-    case typeof exports !== 'object':
+    case !isObjectCurly(exports):
       sugar = false
       break
     default:
-      exports = exports as Record<string, Exports>
+      exports = cast<Record<string, Exports>>(exports)
 
       /*
        * Validate exports object configuration.
@@ -65,7 +72,7 @@ const isExportsSugar = (
       validateExports(exports, pkg, parent)
 
       // check for exports sugar
-      sugar = !(Object.getOwnPropertyNames(exports)[0]?.startsWith('.') ?? true)
+      sugar = !at(Object.getOwnPropertyNames(exports), 0, DOT).startsWith(DOT)
   }
 
   return sugar

package/src/{internal → utils}/is-file.ts

@@ -3,9 +3,9 @@
  * @module mlly/internal/isFile
  */
 
+import validateURLString from '#src/internal/validate-url-string'
 import type { ModuleId } from '#src/types'
 import fs from 'node:fs'
-import validateURLString from './validate-url-string'
 
 /**
  * Checks if a file exists at the given module `id`.

package/src/utils/is-relative-specifier.ts

@@ -4,8 +4,8 @@
  */
 
 import validateString from '#src/internal/validate-string'
-import type { NodeError } from '@flex-development/errnode'
 import pathe from '@flex-development/pathe'
+import { DOT, at } from '@flex-development/tutils'
 
 /**
  * Checks if the given `specifier` is a relative specifier.
@@ -19,16 +19,15 @@ import pathe from '@flex-development/pathe'
  *
  * @param {string} specifier - Specifier to evaluate
  * @return {boolean} `true` if `specifier` is relative specifier
- * @throws {NodeError<TypeError>} If `specifier` is not a string
  */
 const isRelativeSpecifier = (specifier: string): boolean => {
   validateString(specifier, 'specifier')
 
-  return specifier.startsWith('.')
-    ? specifier.length === 1 || specifier[1] === pathe.sep
+  return specifier.startsWith(DOT)
+    ? specifier.length === 1 || at(specifier, 1) === pathe.sep
       ? true
-      : specifier[1] === '.' &&
-        (specifier.length === 2 || specifier[2] === pathe.sep)
+      : at(specifier, 1) === DOT &&
+        (specifier.length === 2 || at(specifier, 2) === pathe.sep)
     : false
 }
 

package/src/utils/lookup-package-scope.ts

@@ -9,7 +9,7 @@ import type { ModuleId } from '#src/types'
 import type { NodeError } from '@flex-development/errnode'
 import pathe from '@flex-development/pathe'
 import type { PackageJson } from '@flex-development/pkg-types'
-import type { Nullable } from '@flex-development/tutils'
+import { DOT, type Nullable } from '@flex-development/tutils'
 import { pathToFileURL } from 'node:url'
 import readPackageJson from './read-package-json'
 import toURL from './to-url'
@@ -60,7 +60,7 @@ const lookupPackageScope = (
   // search for package.json
   while (dir && !dir.endsWith('node_modules')) {
     // stop search if outside of endpoint
-    if (pathe.relative(stopdir, dir).startsWith('../')) break
+    if (pathe.relative(stopdir, dir).startsWith(DOT.repeat(2) + '/')) break
 
     /**
      * Possible `package.json` object.

package/src/utils/parse-data-url.ts

@@ -9,7 +9,7 @@ import {
   type ErrInvalidUrl,
   type NodeError
 } from '@flex-development/errnode'
-import type { Nullable } from '@flex-development/tutils'
+import { cast, trim, type Nullable } from '@flex-development/tutils'
 import type { URL } from 'node:url'
 import toURL from './to-url'
 
@@ -60,11 +60,11 @@ const parseDataURL = (url: URL | string): ParsedDataUrl => {
 
   return {
     base64: !!base64,
-    data: data.trim(),
+    data: trim(data),
     href: url.href,
     mime,
     pathname: url.pathname,
-    protocol: url.protocol as ParsedDataUrl['protocol']
+    protocol: cast(url.protocol)
   }
 }