@markuplint/file-resolver 4.0.0-dev.20 → 4.0.0-dev.23

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2023 Yusuke Hirao
+Copyright (c) 2017-2024 Yusuke Hirao
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/config-load-error.d.ts

@@ -0,0 +1,6 @@
+export declare class ConfigLoadError extends Error {
+    filePath: string;
+    name: string;
+    referrer: string;
+    constructor(message: string, filePath: string, referrer: string);
+}

package/lib/config-load-error.js

@@ -0,0 +1,8 @@
+export class ConfigLoadError extends Error {
+    constructor(message, filePath, referrer) {
+        super(message + ` in ${referrer}`);
+        this.name = 'ConfigLoadError';
+        this.filePath = filePath;
+        this.referrer = referrer;
+    }
+}

package/lib/config-provider.js

@@ -4,19 +4,23 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _ConfigProvider_cache, _ConfigProvider_held, _ConfigProvider_recursiveLoadKeyAndDepth, _ConfigProvider_store;
-import { createRequire } from 'node:module';
 import path from 'node:path';
 import { mergeConfig } from '@markuplint/ml-config';
-import { getPreset } from '@markuplint/ml-core';
 import { ConfigParserError } from '@markuplint/parser-utils';
 import { InvalidSelectorError, createSelector } from '@markuplint/selector';
 import { nonNullableFilter, toNoEmptyStringArrayFromStringOrArray } from '@markuplint/shared';
-import { ConfigLoadError, load as loadConfig, search } from './cosmiconfig.js';
+import { ConfigLoadError } from './config-load-error.js';
+import { load as loadConfig, search } from './cosmiconfig.js';
 import { log } from './debug.js';
+import { generalImport } from './general-import.js';
+import { getPreset } from './get-preset.js';
+import { isPluginModuleName } from './is-plugin-module-name.js';
+import { isPresetModuleName } from './is-preset-module-name.js';
+import { moduleExists } from './module-exists.js';
+import { relPathToNameOrAbsPath } from './path-to-abs-or-name.js';
 import { cacheClear, resolvePlugins } from './resolve-plugins.js';
 import { fileExists, uuid } from './utils.js';
 const cpLog = log.extend('config-provider');
-const require = createRequire(import.meta.url);
 const KEY_SEPARATOR = '__ML_CONFIG_MERGE__';
 export class ConfigProvider {
     constructor() {
@@ -151,14 +155,14 @@ export class ConfigProvider {
         if (entity) {
             return entity;
         }
-        if (isPreset(filePath)) {
+        if (isPresetModuleName(filePath)) {
             const [, name] = filePath.match(/^markuplint:(.+)$/i) ?? [];
             const config = await getPreset(name ?? filePath);
             const pathResolvedConfig = await this._pathResolve(config, filePath);
             __classPrivateFieldGet(this, _ConfigProvider_store, "f").set(filePath, pathResolvedConfig);
             return pathResolvedConfig;
         }
-        if (isPlugin(filePath)) {
+        if (isPluginModuleName(filePath)) {
             __classPrivateFieldGet(this, _ConfigProvider_held, "f").add(filePath);
             return;
         }
@@ -203,12 +207,12 @@ export class ConfigProvider {
         const dir = path.dirname(filePath);
         return {
             ...config,
-            extends: await pathResolve(dir, config.extends),
-            plugins: await pathResolve(dir, config.plugins, ['name']),
-            parser: await pathResolve(dir, config.parser),
-            specs: await pathResolve(dir, config.specs),
-            excludeFiles: await pathResolve(dir, config.excludeFiles),
-            overrides: await pathResolve(dir, config.overrides, undefined, true),
+            extends: await relPathToNameOrAbsPath(dir, config.extends),
+            plugins: await relPathToNameOrAbsPath(dir, config.plugins, ['name']),
+            parser: await relPathToNameOrAbsPath(dir, config.parser),
+            specs: await relPathToNameOrAbsPath(dir, config.specs),
+            excludeFiles: await relPathToNameOrAbsPath(dir, config.excludeFiles),
+            overrides: await relPathToNameOrAbsPath(dir, config.overrides, undefined, true),
         };
     }
     _validateConfig(config, filePath) {
@@ -235,8 +239,7 @@ export class ConfigProvider {
 _ConfigProvider_cache = new WeakMap(), _ConfigProvider_held = new WeakMap(), _ConfigProvider_recursiveLoadKeyAndDepth = new WeakMap(), _ConfigProvider_store = new WeakMap();
 async function load(filePath, cache, referrer) {
     if (!fileExists(filePath) && (await moduleExists(filePath))) {
-        const mod = await import(filePath);
-        const config = mod?.default ?? new ConfigLoadError('Module is not found', filePath, referrer);
+        const config = (await generalImport(filePath)) ?? new ConfigLoadError('Module is not found', filePath, referrer);
         return config;
     }
     const res = await loadConfig(filePath, !cache, referrer).catch((error) => {
@@ -250,92 +253,6 @@ async function load(filePath, cache, referrer) {
     }
     return res.config;
 }
-async function pathResolve(dir, filePath, resolveProps, resolveKey = false) {
-    if (filePath == null) {
-        // @ts-ignore
-        return undefined;
-    }
-    if (typeof filePath === 'string') {
-        // @ts-ignore
-        return resolve(dir, filePath);
-    }
-    if (Array.isArray(filePath)) {
-        // @ts-ignore
-        return Promise.all(filePath.map(fp => pathResolve(dir, fp, resolveProps)));
-    }
-    const res = {};
-    for (const [key, fp] of Object.entries(filePath)) {
-        let _key = key;
-        if (resolveKey) {
-            _key = await resolve(dir, key);
-        }
-        if (typeof fp === 'string') {
-            if (!resolveProps) {
-                res[_key] = await resolve(dir, fp);
-            }
-            else if (resolveProps.includes(key)) {
-                res[_key] = await resolve(dir, fp);
-            }
-            else {
-                res[_key] = fp;
-            }
-        }
-        else {
-            res[_key] = fp;
-        }
-    }
-    // @ts-ignore
-    return res;
-}
-async function resolve(dir, pathOrModName) {
-    if ((await moduleExists(pathOrModName)) || isPreset(pathOrModName) || isPlugin(pathOrModName)) {
-        return pathOrModName;
-    }
-    const bangAndPath = /^(!)(.*)/.exec(pathOrModName) ?? [];
-    const bang = bangAndPath[1] ?? '';
-    const pathname = bangAndPath[2] ?? pathOrModName;
-    const absPath = path.resolve(dir, pathname);
-    return bang + absPath;
-}
-async function moduleExists(name) {
-    try {
-        await import(name);
-    }
-    catch (error) {
-        if (error instanceof Error && /^parse failure/i.test(error.message)) {
-            return true;
-        }
-        try {
-            require.resolve(name);
-        }
-        catch (error) {
-            if (
-            // @ts-ignore
-            'code' in error &&
-                // @ts-ignore
-                error.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
-                // Even if there are issues with the fields,
-                // assume that the module exists and return true.
-                return true;
-            }
-            if (
-            // @ts-ignore
-            'code' in error &&
-                // @ts-ignore
-                error.code === 'MODULE_NOT_FOUND') {
-                return false;
-            }
-            throw error;
-        }
-    }
-    return true;
-}
-function isPreset(name) {
-    return /^markuplint:/i.test(name);
-}
-function isPlugin(name) {
-    return /^plugin:/i.test(name);
-}
 class CircularReferenceError extends ReferenceError {
     constructor() {
         super(...arguments);

package/lib/cosmiconfig.d.ts

@@ -1,4 +1,5 @@
 import type { LoaderSync } from 'cosmiconfig';
+import { ConfigLoadError } from './config-load-error.js';
 type CosmiConfig = ReturnType<LoaderSync>;
 export declare function search<T = CosmiConfig>(filePath: string, cacheClear: boolean): Promise<{
     filePath: string;
@@ -8,10 +9,4 @@ export declare function load<T = CosmiConfig>(filePath: string, cacheClear: bool
     filePath: string;
     config: T;
 }>;
-export declare class ConfigLoadError extends Error {
-    filePath: string;
-    name: string;
-    referrer: string;
-    constructor(message: string, filePath: string, referrer: string);
-}
 export {};

package/lib/cosmiconfig.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { ConfigParserError } from '@markuplint/parser-utils';
 import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
 import { jsonc } from 'jsonc';
+import { ConfigLoadError } from './config-load-error.js';
 import { log } from './debug.js';
 const searchLog = log.extend('search');
 const explorer = cosmiconfig('markuplint', {
@@ -49,14 +50,6 @@ export async function load(filePath, cacheClear, referrer) {
         config: result.config,
     };
 }
-export class ConfigLoadError extends Error {
-    constructor(message, filePath, referrer) {
-        super(message + ` in ${referrer}`);
-        this.name = 'ConfigLoadError';
-        this.filePath = filePath;
-        this.referrer = referrer;
-    }
-}
 function cacheConfigError(fileOrDirPath, referrer) {
     return (reason) => {
         if (reason instanceof Error) {

package/lib/force-import-json-in-module.d.ts

@@ -0,0 +1 @@
+export declare function forceImportJsonInModule(modPath: string): Promise<any>;

package/lib/force-import-json-in-module.js

@@ -0,0 +1,31 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { log } from './debug.js';
+const fLog = log.extend('force-import-json-in-module');
+export async function forceImportJsonInModule(modPath) {
+    const error = await import(modPath).catch(error => error);
+    if (error instanceof Error) {
+        fLog('Error in forceImportJsonInModule: %O', error);
+        if (!('code' in error)) {
+            throw error;
+        }
+        if (error.code !== 'ERR_IMPORT_ASSERTION_TYPE_MISSING') {
+            throw error;
+        }
+        const searchPath = /module\s"([^"]+)"\sneeds/i.exec(error.message);
+        const absPath = searchPath?.[1] ?? null;
+        fLog('Extract path: %s', absPath);
+        if (!absPath) {
+            throw error;
+        }
+        const normalizePath = absPath
+            .replace(/^file:\/\//, '')
+            .replaceAll('/', path.sep)
+            // Windows
+            .replace(/^[/\\][a-z]:/i, '');
+        fLog('Find JSON file path: %s', normalizePath);
+        const fileContent = await readFile(normalizePath, { encoding: 'utf8' });
+        return JSON.parse(fileContent);
+    }
+    return error.default ?? error;
+}

package/lib/general-import.d.ts

@@ -0,0 +1 @@
+export declare function generalImport<T>(name: string): Promise<T | null>;

package/lib/general-import.js

@@ -0,0 +1,40 @@
+import { createRequire } from 'node:module';
+import { log } from './debug.js';
+const gLog = log.extend('general-import');
+const cache = new Map();
+const require = createRequire(import.meta.url);
+export async function generalImport(name) {
+    if (cache.has(name)) {
+        return cache.get(name);
+    }
+    try {
+        const imported = await import(name);
+        const mod = imported?.default ?? imported ?? null;
+        cache.set(name, mod);
+        return mod;
+    }
+    catch (error) {
+        if (
+        // @ts-ignore
+        'code' in error &&
+            // @ts-ignore
+            error.code === 'ERR_IMPORT_ASSERTION_TYPE_MISSING') {
+            try {
+                const mod = require(name) ?? null;
+                cache.set(name, mod);
+                return mod;
+            }
+            catch (error) {
+                if (error instanceof Error && /^parse failure/i.test(error.message)) {
+                    gLog('Error in `createRequire(import.meta.url)()`: %O', error);
+                    cache.set(name, null);
+                    return null;
+                }
+                gLog('Error in generalImport: %O', error);
+            }
+        }
+        gLog('Error in `import()`: %O', error);
+        cache.set(name, null);
+        return null;
+    }
+}

package/lib/get-preset.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from '@markuplint/ml-config';
+export declare function getPreset(name: string): Promise<Config>;

package/lib/get-preset.js

@@ -0,0 +1,13 @@
+import { forceImportJsonInModule } from './force-import-json-in-module.js';
+const cache = new Map();
+export async function getPreset(name) {
+    if (cache.has(name)) {
+        return cache.get(name);
+    }
+    const json = await forceImportJsonInModule(`@markuplint/config-presets/preset.${name}.json`);
+    if (json instanceof Error) {
+        throw new ReferenceError(`Preset markuplint:${name} is not found`);
+    }
+    cache.set(name, json);
+    return json;
+}

package/lib/is-plugin-module-name.d.ts

@@ -0,0 +1 @@
+export declare function isPluginModuleName(name: string): boolean;

package/lib/is-plugin-module-name.js

@@ -0,0 +1,3 @@
+export function isPluginModuleName(name) {
+    return /^plugin:/i.test(name);
+}

package/lib/is-preset-module-name.d.ts

@@ -0,0 +1 @@
+export declare function isPresetModuleName(name: string): boolean;

package/lib/is-preset-module-name.js

@@ -0,0 +1,3 @@
+export function isPresetModuleName(name) {
+    return /^markuplint:/i.test(name);
+}

package/lib/module-exists.d.ts

@@ -0,0 +1 @@
+export declare function moduleExists(name: string): Promise<boolean>;

package/lib/module-exists.js

@@ -0,0 +1,49 @@
+import { createRequire } from 'node:module';
+import { log } from './debug.js';
+const require = createRequire(import.meta.url);
+const mLog = log.extend('module-exists');
+export async function moduleExists(name) {
+    try {
+        await import(name);
+    }
+    catch (error) {
+        if (
+        // @ts-ignore
+        'code' in error &&
+            // @ts-ignore
+            error.code === 'ERR_IMPORT_ASSERTION_TYPE_MISSING') {
+            // It exists, but it is may be a JSON file.
+            mLog('Return true, but it caught Error in `import()`: %O', error);
+            return true;
+        }
+        if (error instanceof Error && /^parse failure/i.test(error.message)) {
+            // It exists, but it failed to parse.
+            mLog('Return true, but it caught Error in `import()`: %O', error);
+            return true;
+        }
+        try {
+            require.resolve(name);
+        }
+        catch (error) {
+            if (
+            // @ts-ignore
+            'code' in error &&
+                // @ts-ignore
+                error.code === 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+                // Even if there are issues with the fields,
+                // assume that the module exists and return true.
+                mLog('Return true, but it caught Error in `require.resolve()`: %O', error);
+                return true;
+            }
+            if (
+            // @ts-ignore
+            'code' in error &&
+                // @ts-ignore
+                error.code === 'MODULE_NOT_FOUND') {
+                return false;
+            }
+            throw error;
+        }
+    }
+    return true;
+}

package/lib/path-to-abs-or-name.d.ts

@@ -0,0 +1 @@
+export declare function relPathToNameOrAbsPath<T extends string | readonly (string | Record<string, unknown>)[] | Readonly<Record<string, unknown>> | undefined>(dir: string, filePath?: T, resolveProps?: readonly string[], resolveKey?: boolean): Promise<T>;

package/lib/path-to-abs-or-name.js

@@ -0,0 +1,38 @@
+import { resolveNameOrAbsPath } from './resolve-name-or-abs-path.js';
+export async function relPathToNameOrAbsPath(dir, filePath, resolveProps, resolveKey = false) {
+    if (filePath == null) {
+        // @ts-ignore
+        return undefined;
+    }
+    if (typeof filePath === 'string') {
+        // @ts-ignore
+        return resolveNameOrAbsPath(dir, filePath);
+    }
+    if (Array.isArray(filePath)) {
+        // @ts-ignore
+        return Promise.all(filePath.map(fp => relPathToNameOrAbsPath(dir, fp, resolveProps)));
+    }
+    const res = {};
+    for (const [key, fp] of Object.entries(filePath)) {
+        let _key = key;
+        if (resolveKey) {
+            _key = await resolveNameOrAbsPath(dir, key);
+        }
+        if (typeof fp === 'string') {
+            if (!resolveProps) {
+                res[_key] = await resolveNameOrAbsPath(dir, fp);
+            }
+            else if (resolveProps.includes(key)) {
+                res[_key] = await resolveNameOrAbsPath(dir, fp);
+            }
+            else {
+                res[_key] = fp;
+            }
+        }
+        else {
+            res[_key] = fp;
+        }
+    }
+    // @ts-ignore
+    return res;
+}

package/lib/resolve-name-or-abs-path.d.ts

@@ -0,0 +1 @@
+export declare function resolveNameOrAbsPath(dir: string, pathOrModName: string): Promise<string>;

package/lib/resolve-name-or-abs-path.js

@@ -0,0 +1,14 @@
+import path from 'node:path';
+import { isPluginModuleName } from './is-plugin-module-name.js';
+import { isPresetModuleName } from './is-preset-module-name.js';
+import { moduleExists } from './module-exists.js';
+export async function resolveNameOrAbsPath(dir, pathOrModName) {
+    if ((await moduleExists(pathOrModName)) || isPresetModuleName(pathOrModName) || isPluginModuleName(pathOrModName)) {
+        return pathOrModName;
+    }
+    const bangAndPath = /^(!)(.*)/.exec(pathOrModName) ?? [];
+    const bang = bangAndPath[1] ?? '';
+    const pathname = bangAndPath[2] ?? pathOrModName;
+    const absPath = path.resolve(dir, pathname);
+    return bang + absPath;
+}

package/lib/resolve-parser.d.ts

@@ -1,9 +1,9 @@
 import type { MLFile } from './ml-file/index.js';
-import type { MLMarkupLanguageParser, ParserOptions } from '@markuplint/ml-ast';
+import type { MLMarkupLanguageParser, MLParser, ParserOptions } from '@markuplint/ml-ast';
 import type { ParserConfig } from '@markuplint/ml-config';
 export declare function resolveParser(file: Readonly<MLFile>, parserConfig?: ParserConfig, parserOptions?: ParserOptions): Promise<{
     parserModName: string;
-    parser: MLMarkupLanguageParser;
+    parser: MLParser | MLMarkupLanguageParser;
     parserOptions: ParserOptions;
     matched: boolean;
 }>;

package/lib/resolve-parser.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { generalImport } from './general-import.js';
 import { toRegexp } from './utils.js';
 const parsers = new Map();
 export async function resolveParser(file, parserConfig, parserOptions) {
@@ -34,6 +35,13 @@ async function importParser(parserModName) {
     if (entity) {
         return entity;
     }
-    const parser = await import(parserModName);
-    return parser;
+    const parserMod = await generalImport(parserModName);
+    if (!parserMod) {
+        throw new Error(`Parser module "${parserModName}" is not found.`);
+    }
+    // TODO: To be dropped in v5
+    if (!('parser' in parserMod)) {
+        return parserMod;
+    }
+    return parserMod.parser;
 }

package/lib/resolve-plugins.js

@@ -1,3 +1,6 @@
+import { log } from './debug.js';
+import { generalImport } from './general-import.js';
+const pLog = log.extend('resolve-plugins');
 const cache = new Map();
 export async function resolvePlugins(pluginPaths) {
     if (!pluginPaths) {
@@ -14,32 +17,32 @@ async function importPlugin(pluginPath) {
     const config = getPluginConfig(pluginPath);
     const cached = cache.get(config.name);
     if (cached) {
+        pLog('Return from cache: %s', config.name);
         return cached;
     }
-    const pluginCreator = await failSafeImport(config.name);
-    if (!pluginCreator) {
-        return {
-            name: config.name,
+    const pluginCreator = await generalImport(config.name);
+    let name = config.name;
+    let plugin = null;
+    if (typeof pluginCreator?.create === 'function' || pluginCreator?.name) {
+        plugin = {
+            name: pluginCreator.name,
+            ...pluginCreator.create(config.settings),
         };
+        name = plugin.name ?? name;
     }
-    const plugin = {
-        name: pluginCreator.name,
-        ...pluginCreator.create(config.settings),
-    };
-    cache.set(plugin.name, plugin);
-    let name = plugin.name;
-    if (!name) {
-        name = config.name
-            .toLowerCase()
-            .replace(/^(?:markuplint-rule-|@markuplint\/rule-)/i, '')
-            .replaceAll(/\s+|[./\\]/g, '-');
-        // eslint-disable-next-line no-console
-        console.info(`The plugin name became "${name}"`);
+    else if (pluginCreator) {
+        pLog('Invalid plugin: %s', config.name);
     }
-    return {
+    name = name
+        .toLowerCase()
+        .replace(/^(?:markuplint-rule-|@markuplint\/rule-)/i, '')
+        .replaceAll(/\s+|[./\\]/g, '-');
+    const result = {
         ...plugin,
         name,
     };
+    cache.set(name, result);
+    return result;
 }
 function getPluginConfig(pluginPath) {
     if (typeof pluginPath === 'string') {
@@ -47,10 +50,3 @@ function getPluginConfig(pluginPath) {
     }
     return pluginPath;
 }
-async function failSafeImport(name) {
-    const res = await import(name).catch(error => error);
-    if ('code' in res && res === 'MODULE_NOT_FOUND') {
-        return null;
-    }
-    return res.default;
-}

package/lib/resolve-specs.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { generalImport } from './general-import.js';
 import { toRegexp } from './utils.js';
 const caches = new Map();
 /**
@@ -66,9 +67,10 @@ async function importSpecs(specModName) {
             return spec;
         }
     }
-    const mod = await import(specModName);
-    const spec = mod.default;
-    // @ts-ignore
+    const spec = await generalImport(specModName);
+    if (!spec) {
+        throw new Error(`Spec "${specModName}" is not found.`);
+    }
     caches.set(specModName, spec);
     return spec;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/file-resolver",
-	"version": "4.0.0-dev.20+6b35da16",
+	"version": "4.0.0-dev.23+d6f2aa9bc",
 	"description": "The file resolver of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -24,17 +24,17 @@
 		"clean": "tsc --build --clean"
 	},
 	"devDependencies": {
-		"@types/node": "20.10.5"
+		"@types/node": "20.11.5"
 	},
 	"dependencies": {
-		"@markuplint/html-parser": "4.0.0-dev.20+6b35da16",
-		"@markuplint/ml-ast": "4.0.0-dev.20+6b35da16",
-		"@markuplint/ml-config": "4.0.0-dev.20+6b35da16",
-		"@markuplint/ml-core": "4.0.0-dev.20+6b35da16",
-		"@markuplint/ml-spec": "4.0.0-dev.20+6b35da16",
-		"@markuplint/parser-utils": "4.0.0-dev.20+6b35da16",
-		"@markuplint/selector": "4.0.0-dev.20+6b35da16",
-		"@markuplint/shared": "4.0.0-dev.20+6b35da16",
+		"@markuplint/html-parser": "4.0.0-dev.23+d6f2aa9bc",
+		"@markuplint/ml-ast": "4.0.0-dev.23+d6f2aa9bc",
+		"@markuplint/ml-config": "4.0.0-dev.23+d6f2aa9bc",
+		"@markuplint/ml-core": "4.0.0-dev.23+d6f2aa9bc",
+		"@markuplint/ml-spec": "4.0.0-dev.23+d6f2aa9bc",
+		"@markuplint/parser-utils": "4.0.0-dev.23+d6f2aa9bc",
+		"@markuplint/selector": "4.0.0-dev.23+d6f2aa9bc",
+		"@markuplint/shared": "4.0.0-dev.23+d6f2aa9bc",
 		"cosmiconfig": "^9.0.0",
 		"debug": "^4.3.4",
 		"glob": "^10.3.6",
@@ -42,5 +42,5 @@
 		"jsonc": "^2.0.0",
 		"minimatch": "^9.0.3"
 	},
-	"gitHead": "6b35da161d94f784953d0adecc2d28502052d92a"
+	"gitHead": "d6f2aa9bc287768466f23b5340e4e0eecfa30d59"
 }