@markuplint/file-resolver 4.0.0-alpha.1 → 4.0.0-alpha.10

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2019 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/auto-load-rules.js

@@ -20,8 +20,8 @@ export async function autoLoadRules(ruleset) {
                 seed = null;
             }
         }
-        catch (e) {
-            errors.push(e);
+        catch (error) {
+            errors.push(error);
         }
         if (seed) {
             const rule = new MLRule({
@@ -39,8 +39,8 @@ export async function autoLoadRules(ruleset) {
                 seed = null;
             }
         }
-        catch (e) {
-            errors.push(e);
+        catch (error) {
+            errors.push(error);
         }
         if (seed) {
             const rule = new MLRule({
@@ -54,8 +54,8 @@ export async function autoLoadRules(ruleset) {
     }
     return {
         // Clone
-        rules: rules.slice(),
+        rules: [...rules],
         // Clone
-        errors: errors.slice(),
+        errors: [...errors],
     };
 }

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.d.ts

@@ -4,12 +4,15 @@ import type { Config } from '@markuplint/ml-config';
 import type { Nullable } from '@markuplint/shared';
 export declare class ConfigProvider {
     #private;
+    recursiveLoad(key: string, cache: boolean, referrer: string, depth?: number): Promise<{
+        stack: Set<string>;
+        errs: Error[];
+    }>;
     resolve(targetFile: Readonly<MLFile>, names: readonly Nullable<string>[], cache?: boolean): Promise<ConfigSet>;
     search(targetFile: Readonly<MLFile>): Promise<string | null>;
     set(config: Config, key?: string): string;
     private _load;
     private _mergeConfigs;
     private _pathResolve;
-    private _recursiveLoad;
     private _validateConfig;
 }

package/lib/config-provider.js

@@ -1,16 +1,26 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    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 { __classPrivateFieldGet } from "tslib";
-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 } 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 require = createRequire(import.meta.url);
+const cpLog = log.extend('config-provider');
 const KEY_SEPARATOR = '__ML_CONFIG_MERGE__';
 export class ConfigProvider {
     constructor() {
@@ -19,6 +29,44 @@ export class ConfigProvider {
         _ConfigProvider_recursiveLoadKeyAndDepth.set(this, new Map());
         _ConfigProvider_store.set(this, new Map());
     }
+    async recursiveLoad(key, cache, referrer, depth = 1) {
+        const stack = new Set();
+        const errs = [];
+        const ancestorDepth = __classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").get(key);
+        if (ancestorDepth != null && ancestorDepth < depth) {
+            return {
+                stack,
+                errs: [new CircularReferenceError(`Circular reference detected: ${key}`)],
+            };
+        }
+        __classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").set(key, depth);
+        let config = __classPrivateFieldGet(this, _ConfigProvider_store, "f").get(key);
+        if (!config) {
+            config = await this._load(key, cache, referrer);
+        }
+        if (!config) {
+            return { stack, errs: [] };
+        }
+        if (config instanceof ConfigLoadError) {
+            stack.add(config.filePath);
+            return {
+                stack,
+                errs: [config],
+            };
+        }
+        const depKeys = config.extends === null ? null : toNoEmptyStringArrayFromStringOrArray(config.extends);
+        if (depKeys) {
+            for (const depKey of depKeys) {
+                const keys = await this.recursiveLoad(depKey, cache, key, depth + 1);
+                for (const key of keys.stack) {
+                    stack.add(key);
+                }
+                errs.push(...keys.errs);
+            }
+        }
+        stack.add(key);
+        return { stack, errs };
+    }
     async resolve(targetFile, names, cache = true) {
         if (!cache) {
             __classPrivateFieldGet(this, _ConfigProvider_store, "f").clear();
@@ -31,8 +79,8 @@ export class ConfigProvider {
         if (currentConfig) {
             return currentConfig;
         }
-        let configSet = await this._mergeConfigs(keys, cache);
-        const filePath = Array.from(configSet.files).reverse()[0];
+        let configSet = await this._mergeConfigs(keys, cache, targetFile.path);
+        const filePath = [...configSet.files].reverse()[0];
         if (!filePath) {
             throw new ConfigParserError('Config file not found', {
                 filePath: targetFile.path,
@@ -42,7 +90,7 @@ export class ConfigProvider {
         configSet.errs.push(...errors);
         const plugins = await resolvePlugins(configSet.config.plugins);
         if (__classPrivateFieldGet(this, _ConfigProvider_held, "f").size > 0) {
-            const extendHelds = Array.from(__classPrivateFieldGet(this, _ConfigProvider_held, "f").values());
+            const extendHelds = [...__classPrivateFieldGet(this, _ConfigProvider_held, "f").values()];
             for (const held of extendHelds) {
                 const [, prefix, namespace, name] = held.match(/^([a-z]+:)([^/]+)(?:\/(.+))?$/) ?? [];
                 switch (prefix) {
@@ -56,7 +104,7 @@ export class ConfigProvider {
                     }
                 }
             }
-            configSet = await this._mergeConfigs([...keys, ...extendHelds], cache);
+            configSet = await this._mergeConfigs([...keys, ...extendHelds], cache, targetFile.path);
             __classPrivateFieldGet(this, _ConfigProvider_held, "f").clear();
         }
         // Resolves `overrides`
@@ -80,16 +128,21 @@ export class ConfigProvider {
         return result;
     }
     async search(targetFile) {
-        if (!(await targetFile.dirExists())) {
+        const isExists = await targetFile.dirExists();
+        cpLog('search: %s', targetFile.path);
+        cpLog('isExists: %s', isExists);
+        if (!isExists) {
             return null;
         }
         const res = await search(targetFile.path, false);
+        cpLog('searched config: %O', res);
         if (!res) {
             return null;
         }
         const { filePath, config } = res;
         const pathResolvedConfig = await this._pathResolve(config, filePath);
         __classPrivateFieldGet(this, _ConfigProvider_store, "f").set(filePath, pathResolvedConfig);
+        cpLog('Store key: %s', filePath);
         return filePath;
     }
     set(config, key) {
@@ -97,51 +150,51 @@ export class ConfigProvider {
         __classPrivateFieldGet(this, _ConfigProvider_store, "f").set(key, config);
         return key;
     }
-    async _load(filePath, cache) {
+    async _load(filePath, cache, referrer) {
         const entity = __classPrivateFieldGet(this, _ConfigProvider_store, "f").get(filePath);
         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 null;
+            return;
         }
         if (!(await moduleExists(filePath)) && !path.isAbsolute(filePath)) {
             throw new TypeError(`${filePath} is not an absolute path`);
         }
-        const config = await load(filePath, cache);
-        if (!config) {
-            return null;
+        const config = await load(filePath, cache, referrer);
+        if (config instanceof ConfigLoadError) {
+            return config;
         }
         const pathResolvedConfig = await this._pathResolve(config, filePath);
         __classPrivateFieldGet(this, _ConfigProvider_store, "f").set(filePath, pathResolvedConfig);
         return pathResolvedConfig;
     }
-    async _mergeConfigs(keys, cache) {
+    async _mergeConfigs(keys, cache, referrer) {
         const resolvedKeys = new Set();
         const errs = [];
         for (const key of keys) {
             __classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").clear();
-            const keySet = await this._recursiveLoad(key, cache);
+            const keySet = await this.recursiveLoad(key, cache, referrer);
             for (const k of keySet.stack) {
                 resolvedKeys.add(k);
             }
-            if (keySet.errs) {
-                errs.push(...keySet.errs);
-            }
+            errs.push(...keySet.errs);
         }
-        const configs = Array.from(resolvedKeys)
-            .map(name => __classPrivateFieldGet(this, _ConfigProvider_store, "f").get(name))
-            .filter(nonNullableFilter);
+        const configs = [...resolvedKeys].map(name => __classPrivateFieldGet(this, _ConfigProvider_store, "f").get(name)).filter(nonNullableFilter);
         let resultConfig = {};
         for (const config of configs) {
+            if (config instanceof ConfigLoadError) {
+                errs.push(config);
+                continue;
+            }
             resultConfig = mergeConfig(resultConfig, config);
         }
         return {
@@ -154,167 +207,51 @@ 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),
         };
     }
-    async _recursiveLoad(key, cache, depth = 1) {
-        const stack = new Set();
-        const errs = [];
-        const ancestorDepth = __classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").get(key);
-        if (ancestorDepth != null && ancestorDepth < depth) {
-            return {
-                stack,
-                errs: [new CircularReferenceError(`Circular reference detected: ${key}`)],
-            };
-        }
-        __classPrivateFieldGet(this, _ConfigProvider_recursiveLoadKeyAndDepth, "f").set(key, depth);
-        let config = __classPrivateFieldGet(this, _ConfigProvider_store, "f").get(key) ?? null;
-        if (!config) {
-            config = await this._load(key, cache);
-        }
-        if (!config) {
-            return { stack, errs: null };
-        }
-        const depKeys = config.extends !== null ? toNoEmptyStringArrayFromStringOrArray(config.extends) : null;
-        if (depKeys) {
-            for (const depKey of depKeys) {
-                const keys = await this._recursiveLoad(depKey, cache, depth + 1);
-                for (const key of keys.stack) {
-                    stack.add(key);
-                }
-                if (keys.errs) {
-                    errs.push(...keys.errs);
-                }
-            }
-        }
-        stack.add(key);
-        return { stack, errs };
-    }
     _validateConfig(config, filePath) {
         const errors = [];
-        config.nodeRules?.forEach(rule => {
-            if (rule.selector) {
-                try {
-                    createSelector(rule.selector);
-                }
-                catch (error) {
-                    if (error instanceof InvalidSelectorError) {
-                        errors.push(new ConfigParserError(error.message, {
-                            filePath,
-                            raw: rule.selector,
-                        }));
+        if (config.nodeRules)
+            for (const rule of config.nodeRules) {
+                if (rule.selector) {
+                    try {
+                        createSelector(rule.selector);
+                    }
+                    catch (error) {
+                        if (error instanceof InvalidSelectorError) {
+                            errors.push(new ConfigParserError(error.message, {
+                                filePath,
+                                raw: rule.selector,
+                            }));
+                        }
                     }
                 }
             }
-        });
         return errors;
     }
 }
 _ConfigProvider_cache = new WeakMap(), _ConfigProvider_held = new WeakMap(), _ConfigProvider_recursiveLoadKeyAndDepth = new WeakMap(), _ConfigProvider_store = new WeakMap();
-async function load(filePath, cache) {
+async function load(filePath, cache, referrer) {
     if (!fileExists(filePath) && (await moduleExists(filePath))) {
-        const mod = await import(filePath);
-        const config = mod?.default ?? null;
+        const config = (await generalImport(filePath)) ?? new ConfigLoadError('Module is not found', filePath, referrer);
         return config;
     }
-    const res = await loadConfig(filePath, !cache);
-    if (!res) {
-        return null;
-    }
-    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;
-            }
+    const res = await loadConfig(filePath, !cache, referrer).catch((error) => {
+        if (error instanceof ConfigLoadError) {
+            return error;
         }
-        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);
+        throw error;
+    });
+    if (res instanceof ConfigLoadError) {
+        return res;
     }
-    catch (err) {
-        if (err instanceof Error) {
-            if (/^Parse failure/i.test(err.message)) {
-                return true;
-            }
-        }
-        try {
-            require.resolve(name);
-        }
-        catch (err) {
-            if (
-            // @ts-ignore
-            'code' in err &&
-                // @ts-ignore
-                err.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 err &&
-                // @ts-ignore
-                err.code === 'MODULE_NOT_FOUND') {
-                return false;
-            }
-            throw err;
-        }
-    }
-    return true;
-}
-function isPreset(name) {
-    return /^markuplint:/i.test(name);
-}
-function isPlugin(name) {
-    return /^plugin:/i.test(name);
+    return res.config;
 }
 class CircularReferenceError extends ReferenceError {
     constructor() {

package/lib/cosmiconfig.d.ts

@@ -1,11 +1,12 @@
 import type { LoaderSync } from 'cosmiconfig';
+import { ConfigLoadError } from './config-load-error.js';
 type CosmiConfig = ReturnType<LoaderSync>;
-export declare function search<T = CosmiConfig>(dir: string, cacheClear: boolean): Promise<{
+export declare function search<T = CosmiConfig>(filePath: string, cacheClear: boolean): Promise<{
     filePath: string;
     config: T;
 } | null>;
-export declare function load<T = CosmiConfig>(filePath: string, cacheClear: boolean): Promise<{
+export declare function load<T = CosmiConfig>(filePath: string, cacheClear: boolean, referrer: string): Promise<ConfigLoadError | {
     filePath: string;
     config: T;
-} | null>;
+}>;
 export {};

package/lib/cosmiconfig.js

@@ -1,11 +1,12 @@
 import path from 'node:path';
 import { ConfigParserError } from '@markuplint/parser-utils';
 import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
-import { TypeScriptLoader } from 'cosmiconfig-typescript-loader';
 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', {
     loaders: {
-        '.ts': TypeScriptLoader(),
         noExt: ((path, content) => {
             try {
                 return jsonc.parse(content);
@@ -18,13 +19,16 @@ const explorer = cosmiconfig('markuplint', {
             }
         }),
     },
+    searchStrategy: 'project',
 });
-export async function search(dir, cacheClear) {
+export async function search(filePath, cacheClear) {
     if (cacheClear) {
         explorer.clearCaches();
     }
-    dir = path.dirname(dir);
-    const result = await explorer.search(dir).catch(cacheConfigError(dir));
+    const dir = path.dirname(filePath);
+    searchLog('Search dir: %s', dir);
+    const result = await explorer.search(dir).catch(cacheConfigError(dir, filePath));
+    searchLog('Search result: %O', result);
     if (!result || result.isEmpty) {
         return null;
     }
@@ -33,36 +37,31 @@ export async function search(dir, cacheClear) {
         config: result.config,
     };
 }
-export async function load(filePath, cacheClear) {
+export async function load(filePath, cacheClear, referrer) {
     if (cacheClear) {
         explorer.clearCaches();
     }
-    const result = await explorer.load(filePath).catch(cacheConfigError(filePath));
+    const result = await explorer.load(filePath).catch(cacheConfigError(filePath, referrer));
     if (!result || result.isEmpty) {
-        return null;
+        return new ConfigLoadError('Config file is empty', filePath, referrer);
     }
     return {
         filePath: result.filepath,
         config: result.config,
     };
 }
-class ConfigLoadError extends Error {
-    constructor(message, filePath) {
-        super(message + ` in ${filePath}`);
-        this.name = 'ConfigLoadError';
-    }
-}
-function cacheConfigError(fileOrDirPath) {
+function cacheConfigError(fileOrDirPath, referrer) {
     return (reason) => {
         if (reason instanceof Error) {
             switch (reason.name) {
-                case 'YAMLException':
+                case 'YAMLException': {
                     throw new ConfigParserError(reason.message, {
                         // @ts-ignore
                         filePath: reason.filepath ?? fileOrDirPath,
                     });
+                }
             }
-            throw new ConfigLoadError(reason.message, fileOrDirPath);
+            throw new ConfigLoadError(reason.message, fileOrDirPath, referrer);
         }
         throw reason;
     };

package/lib/debug.d.ts

@@ -0,0 +1,3 @@
+import debug from 'debug';
+export type Log = debug.Debugger;
+export declare const log: debug.Debugger;

package/lib/debug.js

@@ -0,0 +1,2 @@
+import debug from 'debug';
+export const log = debug('ml-fr');

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/ml-file/get-files.d.ts

@@ -6,4 +6,4 @@ import type { MLFile } from './ml-file.js';
  *
  * @param filePathOrGlob
  */
-export declare function getFiles(filePathOrGlob: string): Promise<MLFile[]>;
+export declare function getFiles(filePathOrGlob: string, ignoreGlob?: string): Promise<MLFile[]>;

package/lib/ml-file/get-files.js

@@ -1,4 +1,5 @@
 import { glob } from 'glob';
+import { minimatch } from 'minimatch';
 import { getFile } from './get-file.js';
 /**
  * Get files
@@ -7,7 +8,8 @@ import { getFile } from './get-file.js';
  *
  * @param filePathOrGlob
  */
-export async function getFiles(filePathOrGlob) {
+export async function getFiles(filePathOrGlob, ignoreGlob) {
     const fileList = await glob(filePathOrGlob, {}).catch(() => []);
-    return fileList.map(fileName => getFile(fileName));
+    const filtered = fileList.filter(fileName => !minimatch(fileName, ignoreGlob ?? ''));
+    return filtered.map(fileName => getFile(fileName));
 }

package/lib/ml-file/ml-file.js

@@ -1,5 +1,15 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var _MLFile_basename, _MLFile_code, _MLFile_dirname, _MLFile_stat, _MLFile_type;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import ignore from 'ignore';
@@ -96,7 +106,7 @@ export class MLFile {
         __classPrivateFieldSet(this, _MLFile_code, code, "f");
     }
     async _fetch() {
-        const code = await fs.readFile(this.path, { encoding: 'utf-8' });
+        const code = await fs.readFile(this.path, { encoding: 'utf8' });
         __classPrivateFieldSet(this, _MLFile_code, code, "f");
         return code;
     }
@@ -113,15 +123,15 @@ async function stat(filePath) {
     try {
         return await fs.stat(filePath);
     }
-    catch (err) {
+    catch (error) {
         if (
         // @ts-ignore
-        'code' in err &&
+        'code' in error &&
             // @ts-ignore
-            err.code === 'ENOENT') {
+            error.code === 'ENOENT') {
             return null;
         }
-        throw err;
+        throw error;
     }
 }
 function pathNormalize(filePath, relative = false) {

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-files.d.ts

@@ -1,3 +1,3 @@
 import type { MLFile } from './ml-file/index.js';
 import type { Target } from './types.js';
-export declare function resolveFiles(targetList: readonly Readonly<Target>[]): Promise<MLFile[]>;
+export declare function resolveFiles(targetList: readonly Readonly<Target>[], ignoreGlob?: string): Promise<MLFile[]>;

package/lib/resolve-files.js

@@ -1,9 +1,9 @@
 import { getAnonymousFile, getFiles } from './ml-file/index.js';
-export async function resolveFiles(targetList) {
+export async function resolveFiles(targetList, ignoreGlob) {
     const res = [];
     for (const target of targetList) {
         if (typeof target === 'string') {
-            const file = await getFiles(target);
+            const file = await getFiles(target, ignoreGlob);
             res.push(...file);
             continue;
         }

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) {
@@ -10,6 +11,7 @@ export async function resolveParser(file, parserConfig, parserOptions) {
     let parserModName = '@markuplint/html-parser';
     let matched = false;
     for (const pattern of Object.keys(parserConfig)) {
+        // eslint-disable-next-line unicorn/prefer-regexp-test
         if (path.basename(file.path).match(toRegexp(pattern))) {
             const modName = parserConfig[pattern];
             if (!modName) {
@@ -33,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) {
@@ -5,7 +8,7 @@ export async function resolvePlugins(pluginPaths) {
     }
     const plugins = await Promise.all(pluginPaths.map(p => importPlugin(p)));
     // Clone
-    return plugins.slice();
+    return [...plugins];
 }
 export function cacheClear() {
     cache.clear();
@@ -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, '')
-            .replace(/\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(e => e);
-    if ('code' in res && res === 'MODULE_NOT_FOUND') {
-        return null;
-    }
-    return res.default;
-}

package/lib/resolve-rules.js

@@ -7,30 +7,30 @@ export async function resolveRules(plugins, ruleset, importPreset,
  */
 autoLoad) {
     const rules = importPreset ? await importPresetRules() : [];
-    plugins.forEach(plugin => {
+    for (const plugin of plugins) {
         if (!plugin.rules) {
-            return;
+            continue;
         }
-        Object.entries(plugin.rules).forEach(([name, seed]) => {
+        for (const [name, seed] of Object.entries(plugin.rules)) {
             const rule = new MLRule({
                 name: `${plugin.name}/${name}`,
                 ...seed,
             });
             rules.push(rule);
-        });
-    });
+        }
+    }
     if (autoLoad) {
         const { rules: additionalRules } = await autoLoadRules(ruleset);
-        additionalRules.forEach(rule => {
+        for (const rule of additionalRules) {
             rules.push(rule);
-        });
+        }
     }
     // Clone
-    return rules.slice();
+    return [...rules];
 }
 async function importPresetRules() {
     if (cachedPresetRules) {
-        return cachedPresetRules.slice();
+        return [...cachedPresetRules];
     }
     const modName = '@markuplint/rules';
     const mod = await import(modName);
@@ -44,5 +44,5 @@ async function importPresetRules() {
     });
     cachedPresetRules = ruleList;
     // Clone
-    return ruleList.slice();
+    return [...ruleList];
 }

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();
 /**
@@ -41,6 +42,7 @@ export async function resolveSpecs(filePath, specConfig) {
         }
         else {
             for (const pattern of Object.keys(specConfig)) {
+                // eslint-disable-next-line unicorn/prefer-regexp-test
                 if (path.basename(filePath).match(toRegexp(pattern))) {
                     const specModName = specConfig[pattern];
                     if (!specModName) {
@@ -65,8 +67,10 @@ async function importSpecs(specModName) {
             return spec;
         }
     }
-    const spec = (await import(specModName)).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/lib/utils.js

@@ -9,7 +9,7 @@ export function fileExists(filePath) {
     return fs.existsSync(filePath);
 }
 export function toRegexp(pattern) {
-    const matched = pattern.match(/^\/(.+)\/([ig]*)$/i);
+    const matched = pattern.match(/^\/(.+)\/([gi]*)$/i);
     if (matched && matched[1]) {
         return new RegExp(matched[1], matched[2]);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/file-resolver",
-	"version": "4.0.0-alpha.1",
+	"version": "4.0.0-alpha.10",
 	"description": "The file resolver of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -24,24 +24,23 @@
 		"clean": "tsc --build --clean"
 	},
 	"devDependencies": {
-		"@types/node": "20.4.5"
+		"@types/node": "20.11.10"
 	},
 	"dependencies": {
-		"@markuplint/html-parser": "4.0.0-alpha.1",
-		"@markuplint/ml-ast": "4.0.0-alpha.1",
-		"@markuplint/ml-config": "4.0.0-alpha.1",
-		"@markuplint/ml-core": "4.0.0-alpha.1",
-		"@markuplint/ml-spec": "4.0.0-alpha.1",
-		"@markuplint/parser-utils": "4.0.0-alpha.1",
-		"@markuplint/selector": "4.0.0-alpha.1",
-		"@markuplint/shared": "4.0.0-alpha.1",
-		"cosmiconfig": "^8.2.0",
-		"cosmiconfig-typescript-loader": "^5.0.0",
-		"glob": "^10.3.2",
-		"ignore": "^5.2.4",
+		"@markuplint/html-parser": "4.0.0-alpha.10",
+		"@markuplint/ml-ast": "4.0.0-alpha.10",
+		"@markuplint/ml-config": "4.0.0-alpha.10",
+		"@markuplint/ml-core": "4.0.0-alpha.10",
+		"@markuplint/ml-spec": "4.0.0-alpha.10",
+		"@markuplint/parser-utils": "4.0.0-alpha.10",
+		"@markuplint/selector": "4.0.0-alpha.10",
+		"@markuplint/shared": "4.0.0-alpha.10",
+		"cosmiconfig": "^9.0.0",
+		"debug": "^4.3.4",
+		"glob": "^10.3.6",
+		"ignore": "^5.3.0",
 		"jsonc": "^2.0.0",
-		"minimatch": "^9.0.3",
-		"tslib": "^2.6.1"
+		"minimatch": "^9.0.3"
 	},
-	"gitHead": "22502ee22a378ae766033d687dbc0443e5ed35dc"
+	"gitHead": "b41153ea665aa8f091daf6114a06047f4ccb8350"
 }