markuplint 3.0.0-dev.25 → 3.0.0-dev.300

package/lib/cli/init/create-config.js

@@ -0,0 +1,90 @@
+const extRExp = {
+    jsx: '\\.[jt]sx?$',
+    vue: '\\.vue$',
+    svelte: '\\.svelte$',
+    astro: '\\.astro$',
+    pug: '\\.pug$',
+    php: '\\.php$',
+    smarty: '\\.tpl$',
+    erb: '\\.erb$',
+    ejs: '\\.ejs$',
+    mustache: '\\.(mustache|hbs)$',
+    nunjucks: '\\.nunjucks$',
+    liquid: '\\.liquid$',
+};
+export const langs = {
+    jsx: 'React (JSX)',
+    vue: 'Vue',
+    svelte: 'Svelte',
+    astro: 'Astro',
+    pug: 'Pug',
+    php: 'PHP',
+    smarty: 'Smarty',
+    erb: 'eRuby',
+    ejs: 'EJS',
+    mustache: 'Mustache/Handlebars',
+    nunjucks: 'Nunjucks',
+    liquid: 'liquid (Shopify)',
+};
+export function createConfig(langs, mode, defaultRules) {
+    let config = {};
+    const parser = { ...config.parser };
+    for (const lang of langs) {
+        const ext = extRExp[lang];
+        if (!ext) {
+            continue;
+        }
+        parser[ext] = `@markuplint/${lang}-parser`;
+        if (lang === 'vue') {
+            config = {
+                ...config,
+                specs: {
+                    ...config.specs,
+                    '\\.vue$': '@markuplint/vue-spec',
+                },
+            };
+        }
+        if (lang === 'jsx') {
+            config = {
+                ...config,
+                specs: {
+                    ...config.specs,
+                    '\\.[jt]sx?$': '@markuplint/react-spec',
+                },
+            };
+        }
+    }
+    if (Object.keys(parser).length > 0) {
+        config.parser = parser;
+    }
+    const rules = { ...config.rules };
+    if (Array.isArray(mode)) {
+        const ruleNames = Object.keys(defaultRules);
+        for (const ruleName of ruleNames) {
+            const rule = defaultRules[ruleName];
+            if (!rule) {
+                continue;
+            }
+            if (mode.includes(rule.category)) {
+                rules[ruleName] = rule.defaultValue;
+            }
+        }
+    }
+    else if (mode === 'recommended') {
+        config.extends = [...(config.extends ?? []), 'markuplint:recommended'];
+    }
+    else {
+        const ruleNames = Object.keys(defaultRules);
+        for (const ruleName of ruleNames) {
+            const rule = defaultRules[ruleName];
+            if (!rule) {
+                continue;
+            }
+            rules[ruleName] = rule.defaultValue;
+        }
+    }
+    if (Object.keys(rules).length > 0) {
+        config.rules = rules;
+    }
+    return config;
+}

package/lib/cli/init/get-default-rules.d.ts

@@ -0,0 +1,3 @@
+export declare function getDefaultRules(version: string): Promise<{
+    [x: string]: import("./types.js").Rule;
+}>;

package/lib/cli/init/get-default-rules.js

@@ -0,0 +1,52 @@
+import matter from 'gray-matter';
+import fetch from 'node-fetch';
+const RULES_SCHEMA_URL = 'https://raw.githubusercontent.com/markuplint/markuplint/[VERSION]/packages/@markuplint/rules/schema.json';
+const RULES_README_URL = 'https://raw.githubusercontent.com/markuplint/markuplint/[VERSION]/packages/@markuplint/rules/src/[NAME]/README.md';
+export async function getDefaultRules(version) {
+    const json = await safeFetch(RULES_SCHEMA_URL, version);
+    const rules = {};
+    await Promise.all(Object.entries(json.definitions.rules.properties).map(async ([name, rule]) => {
+        const json = await safeFetch(rule.$ref.replace('/main/', '/[VERSION]/'), version);
+        let severity = (Array.isArray(json.oneOf) ? json.oneOf : []).find((val) => val.properties)?.properties
+            ?.severity?.default;
+        let category = json._category;
+        if (severity == null || category == null) {
+            const data = await getCatAndSeverityFromLegacy(version, name);
+            severity = data.severity;
+            category = data.category;
+        }
+        const defaultValue = severity === 'warning' ? false : json.definitions.value.default ?? true;
+        rules[name] = {
+            defaultValue,
+            category,
+        };
+    }));
+    return rules;
+}
+async function safeFetch(baseUrl, version, type = 'json') {
+    const url = baseUrl.replace('[VERSION]', `v${version}`);
+    const res = await fetch(url);
+    if (!res.ok) {
+        return safeFetch(baseUrl, '3.0.0', type);
+    }
+    if (type === 'json') {
+        return (await res.json());
+    }
+    const md = await res.text();
+    const { data } = matter(md);
+    return data;
+}
+/**
+ * Fallback fetching until 3.0.x
+ *
+ * @param version
+ * @param name
+ * @returns
+ */
+async function getCatAndSeverityFromLegacy(version, name) {
+    const data = await safeFetch(RULES_README_URL.replace('[NAME]', name), version, 'md');
+    return {
+        category: data.category,
+        severity: data.severity,
+    };
+}

package/lib/cli/init/index.js

@@ -1,267 +1,79 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initialize = void 0;
-const tslib_1 = require("tslib");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const util_1 = 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);
+import fs from 'node:fs';
+import module from 'node:module';
+import path from 'node:path';
+import util from 'node:util';
+import { head, write, error } from '../../util.js';
+import { confirm, confirmSequence, multiSelect } from '../prompt.js';
+import { createConfig, langs } from './create-config.js';
+import { getDefaultRules } from './get-default-rules.js';
+import { installModule, selectModules } from './install-module.js';
+const require = module.createRequire(import.meta.url);
+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?',
+        message: 'Do you want high accessibility?',
     },
     'naming-convention': {
         message: 'Are you going to set the convention about naming?',
     },
+    maintainability: {
+        message: 'Do you want high maintainability?',
+    },
     style: {
         message: 'Are you going to check for the code styles?',
     },
 };
-const defaultRules = {
-    'attr-duplication': {
-        category: 'validation',
-        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: 'style',
-        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,
-    },
-    'ineffective-attr': {
-        category: 'validation',
-        default: true,
-    },
-    'invalid-attr': {
-        category: 'validation',
-        default: true,
-    },
-    'label-has-control': {
-        category: 'a11y',
-        default: false,
-    },
-    'landmark-roles': {
-        category: 'a11y',
-        default: true,
-    },
-    'no-boolean-attr-value': {
-        category: 'style',
-        default: true,
-    },
-    'no-default-value': {
-        category: 'style',
-        default: true,
-    },
-    'no-empty-palpable-content': {
-        category: 'validation',
-        default: false,
-    },
-    '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,
-    },
-    'use-list': {
-        category: 'a11y',
-        default: false,
-    },
-    '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$',
-};
-async function initialize() {
-    let config = {};
-    (0, util_2.write)((0, util_2.head)('Initialization'));
-    util_2.write.break();
-    const langs = await (0, prompt_1.multiSelect)({
+export async function initialize() {
+    write(head('Initialization'));
+    write.break();
+    const selectedLangs = 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: 'Smarty', value: 'smarty' },
-            { name: 'eRuby', value: 'erb' },
-            { name: 'EJS', value: 'ejs' },
-            { name: 'Mustache/Handlebars', value: 'mustache' },
-            { name: 'Nunjucks', value: 'nunjucks' },
-            { name: 'liquid (Shopify)', value: 'liquid' },
-        ],
+        choices: Object.entries(langs).map(([key, name]) => ({ name, value: key })),
     });
-    const autoInstall = await (0, prompt_1.confirm)('May I install them automatically?');
-    const customize = await (0, prompt_1.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 = (0, ml_config_1.mergeConfig)(config, {
-                specs: {
-                    '\\.vue$': '@markuplint/vue-spec',
-                },
-            });
-        }
-        if (lang === 'jsx') {
-            config = (0, ml_config_1.mergeConfig)(config, {
-                specs: {
-                    '\\.[jt]sx?$': '@markuplint/react-spec',
-                },
-            });
-        }
-    }
+    const autoInstall = await confirm('May I install them automatically?');
+    const customize = await confirm('Do you customize rules?');
+    let ruleSettingMode = 'none';
     if (customize) {
-        const ruleNames = Object.keys(defaultRules);
         const categories = Object.keys(ruleCategories);
-        const res = await (0, prompt_1.confirmSequence)(categories.map(catName => {
+        const selectedCategories = 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;
-            }
-        }
+        ruleSettingMode = Object.entries(selectedCategories)
+            .map(([name, enabled]) => (enabled ? name : ''))
+            .filter((name) => !!name);
     }
-    else {
-        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;
-            }
-        }
+    else if (await confirm('Does it import the recommended config?')) {
+        ruleSettingMode = 'recommended';
+    }
+    let defaultRules = {};
+    if (ruleSettingMode !== 'recommended') {
+        const rulesVersion = require('../../../package.json').version;
+        defaultRules = await getDefaultRules(rulesVersion);
     }
-    const filePath = path_1.default.resolve(process.cwd(), '.markuplintrc');
+    const config = createConfig(selectedLangs, ruleSettingMode, defaultRules);
+    const filePath = path.resolve(process.cwd(), '.markuplintrc');
     await writeFile(filePath, JSON.stringify(config, null, 2), { encoding: 'utf-8' });
-    (0, util_2.write)(`✨Created: ${filePath}`);
+    write(`✨Created: ${filePath}`);
     if (autoInstall) {
-        (0, util_2.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 (0, install_module_1.installModule)(modules, true).catch(e => new Error(e));
+        write('Install automatically');
+        const modules = selectModules(selectedLangs);
+        const result = await installModule(modules, true).catch(e => new Error(e));
         if (result instanceof Error) {
-            util_2.error.exit();
+            error.exit();
             return;
         }
         if (result.alreadyExists) {
-            (0, util_2.write)('Modules are installed already.');
+            write('Modules are installed already.');
         }
         else {
-            (0, util_2.write)('✨ Success');
+            write('✨ Success');
         }
     }
 }
-exports.initialize = initialize;

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

@@ -1,5 +1,7 @@
+import type { Langs } from './types.js';
 export type InstallModuleResult = {
     success: boolean;
     alreadyExists: boolean;
 };
-export declare function installModule(module: string[], dev?: boolean): Promise<InstallModuleResult>;
+export declare function selectModules(selectedLangs: readonly Langs[]): string[];
+export declare function installModule(module: readonly string[], dev?: boolean): Promise<InstallModuleResult>;

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

@@ -1,13 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.installModule = void 0;
-const tslib_1 = require("tslib");
-const child_process_1 = require("child_process");
-const cli_color_1 = tslib_1.__importDefault(require("cli-color"));
+import { spawnSync } from 'node:child_process';
+import c from 'cli-color';
 // @ts-ignore
-const detect_installed_1 = tslib_1.__importDefault(require("detect-installed"));
-const has_yarn_1 = tslib_1.__importDefault(require("has-yarn"));
-async function installModule(module, dev = false) {
+import detectInstalled from 'detect-installed';
+import hasYarn from 'has-yarn';
+export function selectModules(selectedLangs) {
+    const modules = ['markuplint', ...selectedLangs.map(lang => `@markuplint/${lang}-parser`)];
+    if (selectedLangs.includes('vue')) {
+        modules.push('@markuplint/vue-spec');
+    }
+    if (selectedLangs.includes('jsx')) {
+        modules.push('@markuplint/react-spec');
+    }
+    return modules;
+}
+export async function installModule(module, dev = false) {
     module = module.map(m => m.trim());
     const uninstallMods = [];
     try {
@@ -21,25 +27,25 @@ async function installModule(module, dev = false) {
     catch (_) {
         // void
     }
-    if (!uninstallMods.length) {
+    if (uninstallMods.length === 0) {
         return {
             success: true,
             alreadyExists: true,
         };
     }
-    const mod = (0, has_yarn_1.default)() ? 'yarn' : 'npm';
-    const installOpt = (0, has_yarn_1.default)() ? 'add' : 'install';
+    const mod = hasYarn() ? 'yarn' : 'npm';
+    const installOpt = hasYarn() ? 'add' : 'install';
     const opt = [installOpt];
     if (dev) {
         opt.push('-D');
     }
-    if (!(0, has_yarn_1.default)()) {
+    if (!hasYarn()) {
         opt.push('--legacy-peer-deps');
     }
     opt.push(...uninstallMods);
     return new Promise((resolve, reject) => {
-        process.stdout.write(cli_color_1.default.blackBright(`${mod} ${opt.join(' ')}\n`));
-        const result = (0, child_process_1.spawnSync)(mod, opt, { stdio: 'inherit' });
+        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);
@@ -52,11 +58,10 @@ async function installModule(module, dev = false) {
         });
     });
 }
-exports.installModule = installModule;
 function isInstalled(module) {
     return new Promise((resolve, reject) => {
         try {
-            (0, detect_installed_1.default)(module, {
+            detectInstalled(module, {
                 local: true,
             }).then((exists) => {
                 resolve(exists);

package/lib/cli/init/types.d.ts

@@ -0,0 +1,8 @@
+export type Langs = 'jsx' | 'vue' | 'svelte' | 'astro' | 'pug' | 'php' | 'smarty' | 'erb' | 'ejs' | 'mustache' | 'nunjucks' | 'liquid';
+export type Category = 'validation' | 'a11y' | 'naming-convention' | 'style' | 'maintainability';
+export type RuleSettingMode = readonly Category[] | 'recommended' | 'none';
+export type DefaultRules = Readonly<Record<string, Rule>>;
+export type Rule = {
+    readonly category: Category;
+    readonly defaultValue: boolean | string | number;
+};

package/lib/cli/init/types.js

@@ -0,0 +1 @@
+export {};

package/lib/cli/output.d.ts

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

package/lib/cli/output.js

@@ -1,36 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.output = void 0;
-const tslib_1 = require("tslib");
-const strip_ansi_1 = tslib_1.__importDefault(require("strip-ansi"));
-const reporter_1 = require("../reporter");
-function output(results, options) {
-    var _a;
-    const format = (_a = options.format) !== null && _a !== void 0 ? _a : 'Standard';
+import stripAnsi from 'strip-ansi';
+import { simpleReporter, standardReporter, githubReporter } from '../reporter/index.js';
+export function output(results, options) {
+    const format = options.format ?? 'Standard';
     let out;
     switch (format.toLowerCase()) {
         case 'json': {
             return;
         }
         case 'simple': {
-            out = (0, reporter_1.simpleReporter)(results, options);
+            out = simpleReporter(results, options);
+            break;
+        }
+        case 'github': {
+            out = githubReporter(results);
             break;
         }
         default: {
-            out = (0, reporter_1.standardReporter)(results, options);
+            out = standardReporter(results, options);
         }
     }
-    if (!out.length) {
+    if (out.length === 0) {
         return;
     }
     let msg = `${out.join('\n')}\n`;
-    msg = options.color ? msg : (0, strip_ansi_1.default)(msg);
+    msg = options.color ? msg : stripAnsi(msg);
     // If it has errors, Write to `stderr` and failure and exit.
-    if (results.violations.length) {
+    if (results.violations.length > 0) {
         process.stderr.write(msg);
         process.exitCode = 1;
         return;
     }
     process.stdout.write(msg);
 }
-exports.output = output;

package/lib/cli/prompt.d.ts

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