markuplint 2.0.0 → 2.1.0

package/lib/cli/init/index.mjs

@@ -0,0 +1,266 @@
+import fs from 'fs';
+import path from 'path';
+import util from 'util';
+import { mergeConfig } from '@markuplint/ml-config';
+import { head, write, error } from '../../util.mjs';
+import { confirm, confirmSequence, multiSelect } from '../prompt.mjs';
+import { installModule } from './install-module.mjs';
+const writeFile = util.promisify(fs.writeFile);
+const ruleCategories = {
+    validation: {
+        message: 'Are you going to conformance check according to HTML standard?',
+    },
+    a11y: {
+        message: 'Are you going to do with accessibility better practices?',
+    },
+    'naming-convention': {
+        message: 'Are you going to set the convention about naming?',
+    },
+    style: {
+        message: 'Are you going to check for the code styles?',
+    },
+};
+const defaultRules = {
+    'attr-duplication': {
+        category: 'validation',
+        default: true,
+    },
+    'attr-equal-space-after': {
+        category: 'style',
+        default: true,
+    },
+    'attr-equal-space-before': {
+        category: 'style',
+        default: true,
+    },
+    'attr-spacing': {
+        category: 'style',
+        default: true,
+    },
+    'attr-value-quotes': {
+        category: 'style',
+        default: true,
+    },
+    'case-sensitive-attr-name': {
+        category: 'style',
+        default: true,
+    },
+    'case-sensitive-attr-value': {
+        category: 'style',
+        default: true,
+    },
+    'case-sensitive-tag-name': {
+        category: 'style',
+        default: true,
+    },
+    'character-reference': {
+        category: 'validation',
+        default: true,
+    },
+    'class-naming': {
+        category: 'naming-convention',
+        default: false,
+        recommendedValue: '/.+/',
+    },
+    'deprecated-attr': {
+        category: 'validation',
+        default: true,
+    },
+    'deprecated-element': {
+        category: 'validation',
+        default: true,
+    },
+    'disallowed-element': {
+        category: 'validation',
+        default: false,
+    },
+    doctype: {
+        category: 'validation',
+        default: true,
+    },
+    'end-tag': {
+        category: 'style',
+        default: true,
+    },
+    'id-duplication': {
+        category: 'validation',
+        default: true,
+    },
+    indentation: {
+        category: 'style',
+        default: false,
+        recommendedValue: 2,
+    },
+    'ineffective-attr': {
+        category: 'validation',
+        default: true,
+    },
+    'invalid-attr': {
+        category: 'validation',
+        default: true,
+    },
+    'landmark-roles': {
+        category: 'a11y',
+        default: true,
+    },
+    'no-boolean-attr-value': {
+        category: 'style',
+        default: true,
+    },
+    'no-default-value': {
+        category: 'style',
+        default: true,
+    },
+    'no-hard-code-id': {
+        category: 'style',
+        default: true,
+    },
+    'no-refer-to-non-existent-id': {
+        category: 'a11y',
+        default: true,
+    },
+    'no-use-event-handler-attr': {
+        category: 'style',
+        default: true,
+    },
+    'permitted-contents': {
+        category: 'validation',
+        default: true,
+    },
+    'required-attr': {
+        category: 'validation',
+        default: true,
+    },
+    'required-element': {
+        category: 'validation',
+        default: true,
+    },
+    'required-h1': {
+        category: 'a11y',
+        default: true,
+    },
+    'wai-aria': {
+        category: 'a11y',
+        default: true,
+    },
+};
+const extRExp = {
+    jsx: '\\.[jt]sx?$',
+    vue: '\\.vue$',
+    svelte: '\\.svelte$',
+    astro: '\\.astro',
+    pug: '\\.pug$',
+    php: '\\.php$',
+    erb: '\\.erb$',
+    ejs: '\\.ejs$',
+    mustache: '\\.(mustache|handlebars)$',
+    nunjucks: '\\.nunjucks$',
+    liquid: '\\.liquid$',
+};
+export async function initialize() {
+    let config = {};
+    write(head('Initialization'));
+    write.break();
+    const langs = await multiSelect({
+        message: 'Which do you use template engines?',
+        choices: [
+            { name: 'React (JSX)', value: 'jsx' },
+            { name: 'Vue', value: 'vue' },
+            { name: 'Svelte', value: 'svelte' },
+            { name: 'Astro', value: 'astro' },
+            { name: 'Pug', value: 'pug' },
+            { name: 'PHP', value: 'php' },
+            { name: 'eRuby', value: 'erb' },
+            { name: 'EJS', value: 'ejs' },
+            { name: 'Mustache/Handlebars', value: 'mustache' },
+            { name: 'Nunjucks', value: 'nunjucks' },
+            { name: 'liquid (Shopify)', value: 'liquid' },
+        ],
+    });
+    const autoInstall = await confirm('May I install them automatically?');
+    const customize = await confirm('Do you customize rules?');
+    for (const lang of langs) {
+        config.parser = config.parser || {};
+        // @ts-ignore
+        const ext = extRExp[lang];
+        if (!ext) {
+            continue;
+        }
+        config.parser[ext] = `@markuplint/${lang}-parser`;
+        if (lang === 'vue') {
+            config = mergeConfig(config, {
+                specs: {
+                    '\\.vue$': '@markuplint/vue-spec',
+                },
+            });
+        }
+        if (lang === 'jsx') {
+            config = mergeConfig(config, {
+                specs: {
+                    '\\.[jt]sx?$': '@markuplint/react-spec',
+                },
+            });
+        }
+    }
+    if (customize) {
+        const ruleNames = Object.keys(defaultRules);
+        const categories = Object.keys(ruleCategories);
+        const res = await confirmSequence(categories.map(catName => {
+            const cat = ruleCategories[catName];
+            return {
+                message: cat.message,
+                name: catName,
+            };
+        }));
+        for (const ruleName of ruleNames) {
+            const rule = defaultRules[ruleName];
+            if (!rule) {
+                continue;
+            }
+            if (res[rule.category]) {
+                if (!config.rules) {
+                    config.rules = {};
+                }
+                config.rules[ruleName] = rule.recommendedValue || true;
+            }
+        }
+    }
+    else {
+        const recommended = await confirm('Does it import the recommended config?');
+        if (recommended) {
+            config.extends = [...(config.extends || []), 'markuplint:recommended'];
+        }
+        else {
+            config.rules = {};
+            const ruleNames = Object.keys(defaultRules);
+            for (const ruleName of ruleNames) {
+                const rule = defaultRules[ruleName];
+                config.rules[ruleName] = rule.default;
+            }
+        }
+    }
+    const filePath = path.resolve(process.cwd(), '.markuplintrc');
+    await writeFile(filePath, JSON.stringify(config, null, 2), { encoding: 'utf-8' });
+    write(`✨Created: ${filePath}`);
+    if (autoInstall) {
+        write('Install automatically');
+        const modules = ['markuplint', ...langs.map(lang => `@markuplint/${lang}-parser`)];
+        if (langs.includes('vue')) {
+            modules.push('@markuplint/vue-spec');
+        }
+        if (langs.includes('jsx')) {
+            modules.push('@markuplint/react-spec');
+        }
+        const result = await installModule(modules, true).catch(e => new Error(e));
+        if (result instanceof Error) {
+            error.exit();
+            return;
+        }
+        if (result.alreadyExists) {
+            write('Modules are installed already.');
+        }
+        else {
+            write('✨ Success');
+        }
+    }
+}

package/lib/cli/init/install-module.d.mts

@@ -0,0 +1,5 @@
+export declare type InstallModuleResult = {
+    success: boolean;
+    alreadyExists: boolean;
+};
+export declare function installModule(module: string[], dev?: boolean): Promise<InstallModuleResult>;

package/lib/cli/init/install-module.d.ts

@@ -1,5 +1,5 @@
 export declare type InstallModuleResult = {
-	success: boolean;
-	alreadyExists: boolean;
+    success: boolean;
+    alreadyExists: boolean;
 };
 export declare function installModule(module: string[], dev?: boolean): Promise<InstallModuleResult>;

package/lib/cli/init/install-module.mjs

@@ -0,0 +1,61 @@
+import { spawnSync } from 'child_process';
+import c from 'cli-color';
+// @ts-ignore
+import detectInstalled from 'detect-installed';
+import hasYarn from 'has-yarn';
+export async function installModule(module, dev = false) {
+    module = module.map(m => m.trim());
+    const uninstallMods = [];
+    try {
+        for (const mod of module) {
+            const installed = await isInstalled(mod);
+            if (!installed) {
+                uninstallMods.push(mod);
+            }
+        }
+    }
+    catch (_) {
+        // void
+    }
+    if (!uninstallMods.length) {
+        return {
+            success: true,
+            alreadyExists: true,
+        };
+    }
+    const mod = hasYarn() ? 'yarn' : 'npm';
+    const installOpt = hasYarn() ? 'add' : 'install';
+    const opt = [installOpt];
+    if (dev) {
+        opt.push('-D');
+    }
+    opt.push(...uninstallMods);
+    return new Promise((resolve, reject) => {
+        process.stdout.write(c.blackBright(`${mod} ${opt.join(' ')}\n`));
+        const result = spawnSync(mod, opt, { stdio: 'inherit' });
+        if (result.error || result.status !== 0) {
+            const message = 'Error running command.';
+            const error = new Error(message);
+            error.stack = message;
+            reject(error);
+        }
+        resolve({
+            success: true,
+            alreadyExists: false,
+        });
+    });
+}
+async function isInstalled(module) {
+    return new Promise((resolve, reject) => {
+        try {
+            detectInstalled(module, {
+                local: true,
+            }).then((exists) => {
+                resolve(exists);
+            });
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}

package/lib/cli/output.d.mts

@@ -0,0 +1,3 @@
+import type { MLResultInfo } from '../types.mjs';
+import type { CLIOptions } from './bootstrap.mjs';
+export declare function output(results: MLResultInfo, options: CLIOptions): Promise<void>;

package/lib/cli/output.mjs

@@ -0,0 +1,31 @@
+import stripAnsi from 'strip-ansi';
+import { simpleReporter, standardReporter } from '../reporter/index.mjs';
+export async function output(results, options) {
+    const format = options.format ?? 'Standard';
+    let out;
+    switch (format.toLowerCase()) {
+        case 'json': {
+            process.stdout.write(JSON.stringify(results.violations, null, 2));
+            return;
+        }
+        case 'simple': {
+            out = simpleReporter(results, options);
+            break;
+        }
+        default: {
+            out = standardReporter(results, options);
+        }
+    }
+    if (!out.length) {
+        return;
+    }
+    let msg = `${out.join('\n')}\n`;
+    msg = options.color ? msg : stripAnsi(msg);
+    // If it has errors, Write to `stderr` and failure and exit.
+    if (results.violations.length) {
+        process.stderr.write(msg);
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write(msg);
+}

package/lib/cli/prompt.d.mts

@@ -0,0 +1,18 @@
+declare type SelectQuestion<T> = {
+    message: string;
+    choices: {
+        name: string;
+        value: T;
+    }[];
+};
+export declare function select<T>(question: SelectQuestion<T>): Promise<T>;
+export declare function multiSelect<T>(question: SelectQuestion<T>): Promise<T[]>;
+export declare function input<T extends string = string>(question: string, validation?: RegExp): Promise<T>;
+export declare function confirm(question: string, options?: {
+    initial?: boolean;
+}): Promise<boolean>;
+export declare function confirmSequence<T extends string = string>(questions: {
+    message: string;
+    name: T;
+}[]): Promise<Record<T, boolean>>;
+export {};

package/lib/cli/prompt.d.ts

@@ -1,23 +1,18 @@
 declare type SelectQuestion<T> = {
-	message: string;
-	choices: {
-		name: string;
-		value: T;
-	}[];
+    message: string;
+    choices: {
+        name: string;
+        value: T;
+    }[];
 };
 export declare function select<T>(question: SelectQuestion<T>): Promise<T>;
 export declare function multiSelect<T>(question: SelectQuestion<T>): Promise<T[]>;
 export declare function input<T extends string = string>(question: string, validation?: RegExp): Promise<T>;
-export declare function confirm(
-	question: string,
-	options?: {
-		initial?: boolean;
-	},
-): Promise<boolean>;
-export declare function confirmSequence<T extends string = string>(
-	questions: {
-		message: string;
-		name: T;
-	}[],
-): Promise<Record<T, boolean>>;
+export declare function confirm(question: string, options?: {
+    initial?: boolean;
+}): Promise<boolean>;
+export declare function confirmSequence<T extends string = string>(questions: {
+    message: string;
+    name: T;
+}[]): Promise<Record<T, boolean>>;
 export {};

package/lib/cli/prompt.mjs

@@ -0,0 +1,68 @@
+import c from 'cli-color';
+import enquirer from 'enquirer';
+const { prompt } = enquirer;
+export async function select(question) {
+    const res = await prompt({
+        ...question,
+        name: '__Q__',
+        type: 'select',
+        result(resName) {
+            // @ts-ignore
+            return this.options.choices.find(c => c.name === resName)?.value;
+        },
+    });
+    // @ts-ignore
+    return res['__Q__'];
+}
+export async function multiSelect(question) {
+    const res = await prompt({
+        ...question,
+        name: '__Q__',
+        type: 'multiselect',
+        result(names) {
+            // @ts-ignore
+            const map = this.map(names);
+            // @ts-ignore
+            const values = names.map(name => map[name]);
+            return values;
+        },
+    });
+    // @ts-ignore
+    return res['__Q__'];
+}
+export async function input(question, validation) {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const _res = await prompt({
+            message: question,
+            name: '__Q__',
+            type: 'input',
+        });
+        // @ts-ignore
+        const res = _res['__Q__'];
+        if (validation && !validation.test(res)) {
+            process.stdout.write(c.yellow('Oops! The name that you type is an invalid format.\n'));
+            continue;
+        }
+        return res;
+    }
+}
+export async function confirm(question, options) {
+    const res = await prompt({
+        message: question,
+        name: '__Q__',
+        type: 'confirm',
+        initial: !!options?.initial,
+    });
+    // @ts-ignore
+    return !!res['__Q__'];
+}
+export async function confirmSequence(questions) {
+    const res = await prompt(questions.map(question => {
+        return {
+            ...question,
+            type: 'confirm',
+        };
+    }));
+    return res;
+}

package/lib/debug.d.mts

@@ -0,0 +1,3 @@
+import debug from 'debug';
+export declare const log: debug.Debugger;
+export declare function verbosely(): void;

package/lib/debug.mjs

@@ -0,0 +1,10 @@
+import { enableDebug } from '@markuplint/ml-core';
+import debug from 'debug';
+export const log = debug('markuplint-cli');
+export function verbosely() {
+    if (!log.enabled) {
+        debug.enable(`${log.namespace}*`);
+        log(`Debug enable: ${log.namespace}`);
+    }
+    enableDebug();
+}

package/lib/global-settings.d.mts

@@ -0,0 +1,5 @@
+export declare type GlobalSettings = {
+    locale: string;
+};
+export declare function setGlobal(settings: Partial<GlobalSettings>): void;
+export declare function getGlobal(): Readonly<Partial<GlobalSettings>>;

package/lib/global-settings.d.ts

@@ -1,5 +1,5 @@
 export declare type GlobalSettings = {
-	locale: string;
+    locale: string;
 };
 export declare function setGlobal(settings: Partial<GlobalSettings>): void;
 export declare function getGlobal(): Readonly<Partial<GlobalSettings>>;

package/lib/global-settings.mjs

@@ -0,0 +1,10 @@
+let globalSettings = {};
+export function setGlobal(settings) {
+    globalSettings = {
+        ...globalSettings,
+        ...settings,
+    };
+}
+export function getGlobal() {
+    return globalSettings;
+}

package/lib/i18n.d.mts

@@ -0,0 +1,6 @@
+export declare function i18n(locale?: string): Promise<{
+    locale: string;
+    listFormat?: import("packages/@markuplint/i18n/src/types.js").ListFormat | undefined;
+    keywords?: import("packages/@markuplint/i18n/src/types.js").LocalesKeywords | undefined;
+    sentences?: import("packages/@markuplint/i18n/src/types.js").LocalesKeywords | undefined;
+}>;

package/lib/i18n.d.ts

@@ -1,6 +1,6 @@
 export declare function i18n(locale?: string): Promise<{
-	locale: string;
-	listFormat?: import('packages/@markuplint/i18n/src/types').ListFormat | undefined;
-	keywords?: import('packages/@markuplint/i18n/src/types').LocalesKeywords | undefined;
-	sentences?: import('packages/@markuplint/i18n/src/types').LocalesKeywords | undefined;
+    locale: string;
+    listFormat?: import("packages/@markuplint/i18n/src/types").ListFormat | undefined;
+    keywords?: import("packages/@markuplint/i18n/src/types").LocalesKeywords | undefined;
+    sentences?: import("packages/@markuplint/i18n/src/types").LocalesKeywords | undefined;
 }>;

package/lib/i18n.mjs

@@ -0,0 +1,19 @@
+import { osLocale } from 'os-locale';
+let cachedLocale = null;
+async function getLocale() {
+    if (!cachedLocale) {
+        cachedLocale = await osLocale({ spawn: true });
+    }
+    return cachedLocale;
+}
+export async function i18n(locale) {
+    locale = locale || (await getLocale()) || 'en';
+    const langCode = locale.split('-')[0];
+    const localeSet = langCode
+        ? await import(`@markuplint/i18n/locales/${langCode}`).catch(() => null)
+        : null;
+    return {
+        locale: langCode,
+        ...localeSet,
+    };
+}

package/lib/index.d.mts

@@ -0,0 +1,8 @@
+export { MLEngine } from './api/index.mjs';
+export * from './i18n.mjs';
+export * from './testing-tool/index.mjs';
+export * from './types.mjs';
+/**
+ * @deprecated
+ */
+export * from './v1.mjs';

package/lib/index.mjs

@@ -0,0 +1,8 @@
+export { MLEngine } from './api/index.mjs';
+export * from './i18n.mjs';
+export * from './testing-tool/index.mjs';
+export * from './types.mjs';
+/**
+ * @deprecated
+ */
+export * from './v1.mjs';

package/lib/reporter/index.d.mts

@@ -0,0 +1,2 @@
+export * from './standard-reporter.mjs';
+export * from './simple-reporter.mjs';

package/lib/reporter/index.mjs

@@ -0,0 +1,2 @@
+export * from './standard-reporter.mjs';
+export * from './simple-reporter.mjs';

package/lib/reporter/simple-reporter.d.mts

@@ -0,0 +1,3 @@
+import type { CLIOptions } from '../cli/bootstrap.mjs';
+import type { MLResultInfo } from '../types.mjs';
+export declare function simpleReporter(results: MLResultInfo, options: CLIOptions): string[];

package/lib/reporter/simple-reporter.mjs

@@ -0,0 +1,30 @@
+import c from 'cli-color';
+import { markuplint, messageToString, p, w } from '../util.mjs';
+const loggerError = c.red;
+const loggerWarning = c.xterm(208);
+export function simpleReporter(results, options) {
+    const sizes = {
+        line: 0,
+        col: 0,
+        meg: 0,
+    };
+    for (const violation of results.violations) {
+        sizes.line = Math.max(sizes.line, violation.line.toString(10).length);
+        sizes.col = Math.max(sizes.col, violation.col.toString(10).length);
+        const meg = messageToString(violation.message, violation.reason);
+        sizes.meg = Math.max(sizes.meg, w(meg));
+    }
+    const out = [];
+    if (results.violations.length) {
+        out.push(`<${markuplint}> ${c.underline(results.filePath)}: ${loggerError('✗')}`);
+        for (const violation of results.violations) {
+            const s = violation.severity === 'error' ? loggerError('✖') : loggerWarning('⚠️');
+            const meg = messageToString(violation.message, violation.reason);
+            out.push(`  ${c.cyan(`${p(violation.line, sizes.line, true)}:${p(violation.col, sizes.col)}`)} ${s}  ${p(meg, sizes.meg)} ${c.xterm(8)(violation.ruleId)} `);
+        }
+    }
+    else if (!options.problemOnly) {
+        out.push(`<${markuplint}> ${c.underline(results.filePath)}: ${c.green('✓')}`);
+    }
+    return out;
+}

package/lib/reporter/standard-reporter.d.mts

@@ -0,0 +1,3 @@
+import type { CLIOptions } from '../cli/bootstrap.mjs';
+import type { MLResultInfo } from '../types.mjs';
+export declare function standardReporter(results: MLResultInfo, options: CLIOptions): string[];