markuplint 2.0.0-rc.3 → 2.1.0

package/lib/cli/init/index.js

@@ -6,6 +6,7 @@ const fs_1 = (0, tslib_1.__importDefault)(require("fs"));
 const path_1 = (0, tslib_1.__importDefault)(require("path"));
 const util_1 = (0, tslib_1.__importDefault)(require("util"));
 const ml_config_1 = require("@markuplint/ml-config");
+const util_2 = require("../../util");
 const prompt_1 = require("../prompt");
 const install_module_1 = require("./install-module");
 const writeFile = util_1.default.promisify(fs_1.default.writeFile);
@@ -28,10 +29,43 @@ const defaultRules = {
         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,
@@ -40,19 +74,28 @@ const defaultRules = {
         category: 'validation',
         default: true,
     },
+    'disallowed-element': {
+        category: 'validation',
+        default: false,
+    },
     doctype: {
         category: 'validation',
         default: true,
     },
-    'id-duplication': {
-        category: 'validation',
+    'end-tag': {
+        category: 'style',
         default: true,
     },
-    'permitted-contents': {
+    'id-duplication': {
         category: 'validation',
         default: true,
     },
-    'required-attr': {
+    indentation: {
+        category: 'style',
+        default: false,
+        recommendedValue: 2,
+    },
+    'ineffective-attr': {
         category: 'validation',
         default: true,
     },
@@ -64,52 +107,52 @@ const defaultRules = {
         category: 'a11y',
         default: true,
     },
-    'required-h1': {
-        category: 'a11y',
+    'no-boolean-attr-value': {
+        category: 'style',
         default: true,
     },
-    'wai-aria': {
-        category: 'a11y',
+    'no-default-value': {
+        category: 'style',
         default: true,
     },
-    'class-naming': {
-        category: 'naming-convention',
-        default: false,
-        recommendedValue: '/.+/',
-    },
-    'attr-equal-space-after': {
+    'no-hard-code-id': {
         category: 'style',
         default: true,
     },
-    'attr-equal-space-before': {
-        category: 'style',
+    'no-refer-to-non-existent-id': {
+        category: 'a11y',
         default: true,
     },
-    'attr-spacing': {
+    'no-use-event-handler-attr': {
         category: 'style',
         default: true,
     },
-    'attr-value-quotes': {
-        category: 'style',
+    'permitted-contents': {
+        category: 'validation',
         default: true,
     },
-    'case-sensitive-attr-name': {
-        category: 'style',
+    'required-attr': {
+        category: 'validation',
         default: true,
     },
-    'case-sensitive-tag-name': {
-        category: 'style',
+    'required-element': {
+        category: 'validation',
         default: true,
     },
-    indentation: {
-        category: 'style',
-        default: false,
-        recommendedValue: 2,
+    '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$',
@@ -120,14 +163,15 @@ const extRExp = {
 };
 async function initialize() {
     let config = {};
-    write('markuplit initialization');
-    write.break();
+    (0, util_2.write)((0, util_2.head)('Initialization'));
+    util_2.write.break();
     const langs = await (0, prompt_1.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' },
@@ -139,13 +183,8 @@ async function initialize() {
     });
     const autoInstall = await (0, prompt_1.confirm)('May I install them automatically?');
     const customize = await (0, prompt_1.confirm)('Do you customize rules?');
-    if (langs && langs.length) {
-        config.parser = {};
-    }
     for (const lang of langs) {
-        if (!config.parser) {
-            continue;
-        }
+        config.parser = config.parser || {};
         // @ts-ignore
         const ext = extRExp[lang];
         if (!ext) {
@@ -155,14 +194,14 @@ async function initialize() {
         if (lang === 'vue') {
             config = (0, ml_config_1.mergeConfig)(config, {
                 specs: {
-                    '/\\.vue$/i': '@markuplint/vue-spec',
+                    '\\.vue$': '@markuplint/vue-spec',
                 },
             });
         }
         if (lang === 'jsx') {
             config = (0, ml_config_1.mergeConfig)(config, {
                 specs: {
-                    '/\\.[jt]sx?$/i': '@markuplint/react-spec',
+                    '\\.[jt]sx?$': '@markuplint/react-spec',
                 },
             });
         }
@@ -191,18 +230,24 @@ async function initialize() {
         }
     }
     else {
-        config.rules = {};
-        const ruleNames = Object.keys(defaultRules);
-        for (const ruleName of ruleNames) {
-            const rule = defaultRules[ruleName];
-            config.rules[ruleName] = rule.default;
+        const recommended = await (0, prompt_1.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_1.default.resolve(process.cwd(), '.markuplintrc');
     await writeFile(filePath, JSON.stringify(config, null, 2), { encoding: 'utf-8' });
-    write(`✨Created: ${filePath}`);
+    (0, util_2.write)(`✨Created: ${filePath}`);
     if (autoInstall) {
-        write('Install automatically');
+        (0, util_2.write)('Install automatically');
         const modules = ['markuplint', ...langs.map(lang => `@markuplint/${lang}-parser`)];
         if (langs.includes('vue')) {
             modules.push('@markuplint/vue-spec');
@@ -212,23 +257,15 @@ async function initialize() {
         }
         const result = await (0, install_module_1.installModule)(modules, true).catch(e => new Error(e));
         if (result instanceof Error) {
-            error.exit();
+            util_2.error.exit();
             return;
         }
         if (result.alreadyExists) {
-            write('Modules are installed already.');
+            (0, util_2.write)('Modules are installed already.');
         }
         else {
-            write('✨ Success');
+            (0, util_2.write)('✨ Success');
         }
     }
 }
 exports.initialize = initialize;
-function write(message) {
-    process.stdout.write(message + '\n');
-}
-write.break = () => process.stdout.write('\n');
-function error(message) {
-    process.stderr.write(message + '\n');
-}
-error.exit = () => process.exit(1);

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.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 {};