markuplint 3.0.0-canary.3 → 3.0.0-dev.176

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfig = exports.langs = void 0;
+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$',
+};
+exports.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)',
+};
+function createConfig(langs, mode, defaultRules) {
+    var _a;
+    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 = [...((_a = config.extends) !== null && _a !== void 0 ? _a : []), '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;
+}
+exports.createConfig = createConfig;

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

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

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultRules = void 0;
+const tslib_1 = require("tslib");
+const gray_matter_1 = tslib_1.__importDefault(require("gray-matter"));
+const node_fetch_1 = tslib_1.__importDefault(require("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';
+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]) => {
+        var _a, _b, _c, _d;
+        const json = await safeFetch(rule.$ref.replace('/main/', '/[VERSION]/'), version);
+        let severity = (_c = (_b = (_a = (Array.isArray(json.oneOf) ? json.oneOf : []).find((val) => val.properties)) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.severity) === null || _c === void 0 ? void 0 : _c.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 : (_d = json.definitions.value.default) !== null && _d !== void 0 ? _d : true;
+        rules[name] = {
+            defaultValue,
+            category,
+        };
+    }));
+    return rules;
+}
+exports.getDefaultRules = getDefaultRules;
+async function safeFetch(baseUrl, version, type = 'json') {
+    const url = baseUrl.replace('[VERSION]', `v${version}`);
+    const res = await (0, node_fetch_1.default)(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 } = (0, gray_matter_1.default)(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

@@ -5,9 +5,10 @@ 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 create_config_1 = require("./create-config");
+const get_default_rules_1 = require("./get-default-rules");
 const install_module_1 = require("./install-module");
 const writeFile = util_1.default.promisify(fs_1.default.writeFile);
 const ruleCategories = {
@@ -15,242 +16,57 @@ const ruleCategories = {
         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)({
+    const selectedLangs = 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: '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(create_config_1.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',
-                },
-            });
-        }
-    }
+    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 (0, prompt_1.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 (0, prompt_1.confirm)('Does it import the recommended config?')) {
+        ruleSettingMode = 'recommended';
+    }
+    let defaultRules = {};
+    if (ruleSettingMode !== 'recommended') {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const rulesVersion = require('../../../package.json').version;
+        defaultRules = await (0, get_default_rules_1.getDefaultRules)(rulesVersion);
     }
+    const config = (0, create_config_1.createConfig)(selectedLangs, ruleSettingMode, defaultRules);
     const filePath = path_1.default.resolve(process.cwd(), '.markuplintrc');
     await writeFile(filePath, JSON.stringify(config, null, 2), { encoding: 'utf-8' });
     (0, util_2.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 modules = (0, install_module_1.selectModules)(selectedLangs);
         const result = await (0, install_module_1.installModule)(modules, true).catch(e => new Error(e));
         if (result instanceof Error) {
             util_2.error.exit();

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

@@ -1,5 +1,7 @@
+import type { Langs } from './types';
 export type InstallModuleResult = {
-    success: boolean;
-    alreadyExists: boolean;
+	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,12 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.installModule = void 0;
+exports.installModule = exports.selectModules = void 0;
 const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
 const cli_color_1 = tslib_1.__importDefault(require("cli-color"));
 // @ts-ignore
 const detect_installed_1 = tslib_1.__importDefault(require("detect-installed"));
 const has_yarn_1 = tslib_1.__importDefault(require("has-yarn"));
+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;
+}
+exports.selectModules = selectModules;
 async function installModule(module, dev = false) {
     module = module.map(m => m.trim());
     const uninstallMods = [];
@@ -21,7 +32,7 @@ async function installModule(module, dev = false) {
     catch (_) {
         // void
     }
-    if (!uninstallMods.length) {
+    if (uninstallMods.length === 0) {
         return {
             success: true,
             alreadyExists: true,
@@ -33,6 +44,9 @@ async function installModule(module, dev = false) {
     if (dev) {
         opt.push('-D');
     }
+    if (!(0, has_yarn_1.default)()) {
+        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`));

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

@@ -0,0 +1,20 @@
+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,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cli/output.d.ts

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

package/lib/cli/output.js

@@ -16,17 +16,21 @@ function output(results, options) {
             out = (0, reporter_1.simpleReporter)(results, options);
             break;
         }
+        case 'github': {
+            out = (0, reporter_1.githubReporter)(results);
+            break;
+        }
         default: {
             out = (0, reporter_1.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);
     // 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;

package/lib/cli/prompt.d.ts

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

package/lib/cli/search/index.d.ts

@@ -1,2 +1,2 @@
 import type { CLIOptions } from '../bootstrap';
-export default function (files: string[], options: CLIOptions, selectors: string): Promise<void>;
+export default function (files: readonly string[], options: CLIOptions, selectors: string): Promise<void>;

package/lib/cli/search/index.js

@@ -17,8 +17,9 @@ async function default_1(files, options, selectors) {
                     verify({ document }) {
                         const nodes = document.querySelectorAll(selectors);
                         locations.push(...Array.from(nodes).map(node => {
+                            var _a;
                             return {
-                                file: document.filename || '_NO_FILE_',
+                                file: (_a = document.filename) !== null && _a !== void 0 ? _a : '_NO_FILE_',
                                 line: node.startLine,
                                 col: node.startCol,
                             };

package/lib/global-settings.d.ts

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

package/lib/i18n.js

@@ -1,5 +1,4 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.i18n = void 0;
 const tslib_1 = require("tslib");
@@ -12,14 +11,16 @@ async function getLocale() {
     return cachedLocale;
 }
 async function i18n(locale) {
-    locale = locale || (await getLocale()) || 'en';
-    const langCode = locale.split('-')[0];
-    const localeSet = langCode
-        ? await (_a = `@markuplint/i18n/locales/${langCode}`, Promise.resolve().then(() => tslib_1.__importStar(require(_a)))).catch(() => null)
-        : null;
+    var _a, _b;
+    locale = (_a = locale !== null && locale !== void 0 ? locale : (await getLocale())) !== null && _a !== void 0 ? _a : 'en';
+    const langCode = (_b = locale.split('-')[0]) !== null && _b !== void 0 ? _b : locale;
+    const loadLocaleSet = await Promise.resolve(`${`@markuplint/i18n/locales/${langCode}`}`).then(s => tslib_1.__importStar(require(s))).catch(() => null);
+    const localeSet = loadLocaleSet !== null && loadLocaleSet !== void 0 ? loadLocaleSet : 
+    // @ts-ignore
+    (await Promise.resolve().then(() => tslib_1.__importStar(require('@markuplint/i18n/locales/en'))));
     return {
-        locale: langCode,
         ...localeSet,
+        locale: loadLocaleSet ? langCode : 'en',
     };
 }
 exports.i18n = i18n;

package/lib/reporter/github-reporter.d.ts

@@ -0,0 +1,2 @@
+import type { MLResultInfo } from '../types';
+export declare function githubReporter(results: MLResultInfo): string[];

package/lib/reporter/github-reporter.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.githubReporter = void 0;
+const util_1 = require("../util");
+function githubReporter(results) {
+    const out = [];
+    for (const violation of results.violations) {
+        const command = severityToCommand(violation.severity);
+        const meg = (0, util_1.messageToString)(violation.message, violation.reason);
+        out.push(`::${command} file=${results.filePath},line=${violation.line},col=${violation.col}::${meg} (${violation.ruleId})`);
+    }
+    return out;
+}
+exports.githubReporter = githubReporter;
+function severityToCommand(severity) {
+    switch (severity) {
+        case 'info':
+            return 'notice';
+        case 'error':
+        case 'warning':
+            return severity;
+    }
+}

package/lib/reporter/index.d.ts

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