@markuplint/ml-core 2.3.0 → 3.0.0-alpha.0

package/lib/ml-rule/ml-rule-context.js

@@ -5,10 +5,9 @@ exports.MLRuleContext = void 0;
 const tslib_1 = require("tslib");
 const i18n_1 = require("@markuplint/i18n");
 class MLRuleContext {
-    constructor(document, locale, rule) {
+    constructor(document, locale) {
         _MLRuleContext_reports.set(this, []);
         this.document = document;
-        this.globalRule = rule;
         this.translate = (0, i18n_1.translator)(locale);
         this.locale = locale.locale;
     }
@@ -18,19 +17,26 @@ class MLRuleContext {
             message: finish(report.message),
         }));
     }
-    report(report) {
-        tslib_1.__classPrivateFieldGet(this, _MLRuleContext_reports, "f").push(report);
-    }
     provide() {
         return {
             document: this.document,
             translate: this.translate,
             t: this.translate,
-            globalRule: this.globalRule,
             reports: this.reports,
             report: this.report.bind(this),
         };
     }
+    report(report) {
+        if (typeof report === 'function') {
+            const r = report(this.translate);
+            if (r) {
+                tslib_1.__classPrivateFieldGet(this, _MLRuleContext_reports, "f").push(r);
+                return true;
+            }
+            return false;
+        }
+        tslib_1.__classPrivateFieldGet(this, _MLRuleContext_reports, "f").push(report);
+    }
 }
 exports.MLRuleContext = MLRuleContext;
 _MLRuleContext_reports = new WeakMap();

package/lib/ml-rule/ml-rule.d.ts

@@ -1,30 +1,30 @@
 import type { Ruleset } from '..';
-import type Document from '../ml-dom/document';
+import type { MLDocument } from '../ml-dom/node/document';
 import type { RuleSeed } from './types';
 import type { LocaleSet } from '@markuplint/i18n';
-import type { GlobalRuleInfo, RuleConfig, RuleConfigValue, RuleInfo, Rules, Severity, Violation } from '@markuplint/ml-config';
+import type { GlobalRuleInfo, RuleConfig, RuleConfigValue, RuleInfo, Severity, Violation } from '@markuplint/ml-config';
 export declare class MLRule<T extends RuleConfigValue, O = null> {
     #private;
-    readonly name: string;
+    readonly defaultOptions: O;
     readonly defaultServerity: Severity;
     readonly defaultValue: T;
-    readonly defaultOptions: O;
+    readonly name: string;
     /**
      * The following getter is unused internally,
      * only for extending from 3rd party library
      */
-    protected get v(): RuleSeed<T, O>['verify'];
+    protected get f(): RuleSeed<T, O>['fix'];
     /**
      * The following getter is unused internally,
      * only for extending from 3rd party library
      */
-    protected get f(): RuleSeed<T, O>['fix'];
+    protected get v(): RuleSeed<T, O>['verify'];
     constructor(o: RuleSeed<T, O> & {
         name: string;
     });
-    verify(document: Document<T, O>, locale: LocaleSet, globalRule: RuleInfo<T, O>, fix: boolean): Promise<Violation[]>;
     getRuleInfo(ruleSet: Ruleset, ruleName: string): GlobalRuleInfo<T, O>;
-    _optimize(rules: Rules | undefined, ruleName: string): RuleInfo<T, O>;
     optimizeOption(configSettings: T | RuleConfig<T, O> | undefined): RuleInfo<T, O>;
+    verify(document: MLDocument<T, O>, locale: LocaleSet, fix: boolean): Promise<Violation[]>;
+    private _optimize;
 }
 export declare type AnyMLRule = MLRule<RuleConfigValue, unknown>;

package/lib/ml-rule/ml-rule.js

@@ -1,5 +1,5 @@
 "use strict";
-var _MLRule_v, _MLRule_f;
+var _MLRule_f, _MLRule_v;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MLRule = void 0;
 const tslib_1 = require("tslib");
@@ -7,8 +7,8 @@ const ml_rule_context_1 = require("./ml-rule-context");
 class MLRule {
     constructor(o) {
         var _a, _b;
-        _MLRule_v.set(this, void 0);
         _MLRule_f.set(this, void 0);
+        _MLRule_v.set(this, void 0);
         this.name = o.name;
         this.defaultServerity = o.defaultServerity || 'error';
         this.defaultValue = (_a = o.defaultValue) !== null && _a !== void 0 ? _a : true;
@@ -20,65 +20,15 @@ class MLRule {
      * The following getter is unused internally,
      * only for extending from 3rd party library
      */
-    get v() {
-        return tslib_1.__classPrivateFieldGet(this, _MLRule_v, "f");
+    get f() {
+        return tslib_1.__classPrivateFieldGet(this, _MLRule_f, "f");
     }
     /**
      * The following getter is unused internally,
      * only for extending from 3rd party library
      */
-    get f() {
-        return tslib_1.__classPrivateFieldGet(this, _MLRule_f, "f");
-    }
-    async verify(document, locale, globalRule, fix) {
-        if (!tslib_1.__classPrivateFieldGet(this, _MLRule_v, "f")) {
-            return [];
-        }
-        document.setRule(this);
-        const context = new ml_rule_context_1.MLRuleContext(document, locale, globalRule);
-        const providableContext = context.provide();
-        await tslib_1.__classPrivateFieldGet(this, _MLRule_v, "f").call(this, providableContext);
-        if (tslib_1.__classPrivateFieldGet(this, _MLRule_f, "f") && fix) {
-            await tslib_1.__classPrivateFieldGet(this, _MLRule_f, "f").call(this, providableContext);
-        }
-        const violation = context.reports.map(report => {
-            if ('scope' in report) {
-                let line = report.scope.startLine;
-                let col = report.scope.startCol;
-                let raw = report.scope.raw;
-                if ('line' in report) {
-                    line = report.line;
-                    col = report.col;
-                    raw = report.raw;
-                }
-                const violation = {
-                    severity: report.scope.rule.severity,
-                    message: report.message,
-                    line,
-                    col,
-                    raw,
-                    ruleId: this.name,
-                };
-                if (report.scope.rule.reason || globalRule.reason) {
-                    violation.reason = report.scope.rule.reason || globalRule.reason;
-                }
-                return violation;
-            }
-            const violation = {
-                severity: globalRule.severity,
-                message: report.message,
-                line: report.line,
-                col: report.col,
-                raw: report.raw,
-                ruleId: this.name,
-            };
-            if (globalRule.reason) {
-                violation.reason = globalRule.reason;
-            }
-            return violation;
-        });
-        document.setRule(null);
-        return violation;
+    get v() {
+        return tslib_1.__classPrivateFieldGet(this, _MLRule_v, "f");
     }
     getRuleInfo(ruleSet, ruleName) {
         const info = this._optimize(ruleSet.rules, ruleName);
@@ -88,11 +38,6 @@ class MLRule {
             childNodeRules: ruleSet.childNodeRules.map(r => this._optimize(r.rules, ruleName)).filter(r => !r.disabled),
         };
     }
-    _optimize(rules, ruleName) {
-        const rule = (rules && rules[ruleName]) || false;
-        const info = this.optimizeOption(rule);
-        return info;
-    }
     optimizeOption(configSettings) {
         if (configSettings === undefined || typeof configSettings === 'boolean') {
             return {
@@ -132,6 +77,61 @@ class MLRule {
             reason: undefined,
         };
     }
+    async verify(document, locale, fix) {
+        if (!tslib_1.__classPrivateFieldGet(this, _MLRule_v, "f")) {
+            return [];
+        }
+        document.setRule(this);
+        const context = new ml_rule_context_1.MLRuleContext(document, locale);
+        const providableContext = context.provide();
+        await tslib_1.__classPrivateFieldGet(this, _MLRule_v, "f").call(this, providableContext);
+        if (tslib_1.__classPrivateFieldGet(this, _MLRule_f, "f") && fix) {
+            await tslib_1.__classPrivateFieldGet(this, _MLRule_f, "f").call(this, providableContext);
+        }
+        const violation = context.reports.map(report => {
+            if ('scope' in report) {
+                let line = report.scope.startLine;
+                let col = report.scope.startCol;
+                let raw = report.scope.raw;
+                if ('line' in report && report.line != null) {
+                    line = report.line;
+                    col = report.col;
+                    raw = report.raw;
+                }
+                const violation = {
+                    severity: report.scope.rule.severity,
+                    message: report.message,
+                    line,
+                    col,
+                    raw,
+                    ruleId: this.name,
+                };
+                if (report.scope.rule.reason || document.rule.reason) {
+                    violation.reason = report.scope.rule.reason || document.rule.reason;
+                }
+                return violation;
+            }
+            const violation = {
+                severity: document.rule.severity,
+                message: report.message,
+                line: report.line,
+                col: report.col,
+                raw: report.raw,
+                ruleId: this.name,
+            };
+            if (document.rule.reason) {
+                violation.reason = document.rule.reason;
+            }
+            return violation;
+        });
+        document.setRule(null);
+        return violation;
+    }
+    _optimize(rules, ruleName) {
+        const rule = (rules && rules[ruleName]) || false;
+        const info = this.optimizeOption(rule);
+        return info;
+    }
 }
 exports.MLRule = MLRule;
-_MLRule_v = new WeakMap(), _MLRule_f = new WeakMap();
+_MLRule_f = new WeakMap(), _MLRule_v = new WeakMap();

package/lib/ml-rule/types.d.ts

@@ -1,5 +1,7 @@
+import type { Attr, Element } from '../ml-dom';
 import type { MLRuleContext } from './ml-rule-context';
-import type { RuleConfigValue, Severity } from '@markuplint/ml-config';
+import type { Translator } from '@markuplint/i18n';
+import type { Report, RuleConfigValue, Severity } from '@markuplint/ml-config';
 export declare type RuleSeed<T extends RuleConfigValue = boolean, O = null> = {
     defaultServerity?: Severity;
     defaultValue?: T;
@@ -7,4 +9,12 @@ export declare type RuleSeed<T extends RuleConfigValue = boolean, O = null> = {
     verify(context: ReturnType<MLRuleContext<T, O>['provide']>): void | Promise<void>;
     fix?(context: ReturnType<MLRuleContext<T, O>['provide']>): void | Promise<void>;
 };
+export declare type Checker<T extends RuleConfigValue, O = null, P extends Record<string, unknown> = {}> = (params: P) => CheckerReport<T, O>;
+export declare type ElementChecker<T extends RuleConfigValue, O = null, P extends Record<string, unknown> = {}> = (params: P & {
+    el: Element<T, O>;
+}) => CheckerReport<T, O>;
+export declare type AttrChecker<T extends RuleConfigValue, O = null, P extends Record<string, unknown> = {}> = (params: P & {
+    attr: Attr<T, O>;
+}) => CheckerReport<T, O>;
+export declare type CheckerReport<T extends RuleConfigValue, O = null> = (t: Translator) => Report<T, O> | undefined | null;
 export declare type AnyRuleSeed = RuleSeed<any, any>;

package/lib/ruleset/index.d.ts

@@ -1,7 +1,7 @@
 import type { ChildNodeRule, Config, NodeRule, Rules } from '@markuplint/ml-config';
 export default class Ruleset {
-    readonly rules: Readonly<Rules>;
-    readonly nodeRules: ReadonlyArray<NodeRule>;
     readonly childNodeRules: ReadonlyArray<ChildNodeRule>;
+    readonly nodeRules: ReadonlyArray<NodeRule>;
+    readonly rules: Readonly<Rules>;
     constructor(config: Config);
 }

package/lib/selector/is-pure-html-element.d.ts

@@ -0,0 +1 @@
+export declare function isPureHTMLElement(el: Element): boolean;

package/lib/selector/is-pure-html-element.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPureHTMLElement = void 0;
+function isPureHTMLElement(el) {
+    return el.localName !== el.nodeName;
+}
+exports.isPureHTMLElement = isPureHTMLElement;

package/lib/selector/match-selector.d.ts

@@ -0,0 +1,14 @@
+import type { Specificity } from './selector';
+import type { RegexSelector } from '@markuplint/ml-config';
+export declare type SelectorMatches = SelectorMatched | SelectorUnmatched;
+declare type SelectorMatched = {
+	matched: true;
+	selector: string;
+	specificity: Specificity;
+	data?: Record<string, string>;
+};
+declare type SelectorUnmatched = {
+	matched: false;
+};
+export declare function matchSelector(el: Element, selector: string | RegexSelector | undefined): SelectorMatches;
+export {};

package/lib/selector/match-selector.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchSelector = void 0;
+const ml_config_1 = require("@markuplint/ml-config");
+const is_pure_html_element_1 = require("./is-pure-html-element");
+const selector_1 = require("./selector");
+function matchSelector(el, selector) {
+    if (!selector) {
+        return {
+            matched: false,
+        };
+    }
+    if (typeof selector === 'string') {
+        const sel = (0, selector_1.createSelector)(selector);
+        const specificity = sel.match(el);
+        if (specificity) {
+            return {
+                matched: true,
+                selector,
+                specificity,
+            };
+        }
+        return {
+            matched: false,
+        };
+    }
+    return regexSelect(el, selector);
+}
+exports.matchSelector = matchSelector;
+function regexSelect(el, selector) {
+    let edge = new SelectorTarget(selector);
+    let edgeSelector = selector.combination;
+    while (edgeSelector) {
+        const child = new SelectorTarget(edgeSelector);
+        child.from(edge, edgeSelector.combinator);
+        edge = child;
+        edgeSelector = edgeSelector.combination;
+    }
+    return edge.match(el);
+}
+class SelectorTarget {
+    constructor(selector) {
+        this._combinatedFrom = null;
+        this._selector = selector;
+    }
+    from(target, combinator) {
+        this._combinatedFrom = { target, combinator };
+    }
+    match(el) {
+        const unitCheck = this._matchWithoutCombinateChecking(el);
+        if (!unitCheck.matched) {
+            return unitCheck;
+        }
+        if (!this._combinatedFrom) {
+            return unitCheck;
+        }
+        const { target, combinator } = this._combinatedFrom;
+        switch (combinator) {
+            // Descendant combinator
+            case ' ': {
+                let ancestor = el.parentElement;
+                while (ancestor) {
+                    const matches = target.match(ancestor);
+                    if (matches.matched) {
+                        return mergeMatches(matches, unitCheck, ' ');
+                    }
+                    ancestor = ancestor.parentElement;
+                }
+                return {
+                    matched: false,
+                };
+            }
+            // Child combinator
+            case '>': {
+                const parentNode = el.parentElement;
+                if (!parentNode) {
+                    return { matched: false };
+                }
+                const matches = target.match(parentNode);
+                if (matches.matched) {
+                    return mergeMatches(matches, unitCheck, ' > ');
+                }
+                return { matched: false };
+            }
+            // Next-sibling combinator
+            case '+': {
+                if (!el.previousElementSibling) {
+                    return { matched: false };
+                }
+                const matches = target.match(el.previousElementSibling);
+                if (matches.matched) {
+                    return mergeMatches(matches, unitCheck, ' + ');
+                }
+                return { matched: false };
+            }
+            // Subsequent-sibling combinator
+            case '~': {
+                let prev = el.previousElementSibling;
+                while (prev) {
+                    const matches = target.match(prev);
+                    if (matches.matched) {
+                        return mergeMatches(matches, unitCheck, ' ~ ');
+                    }
+                    prev = prev.previousElementSibling;
+                }
+                return { matched: false };
+            }
+            // Prev-sibling combinator
+            case ':has(+)': {
+                if (!el.nextElementSibling) {
+                    return { matched: false };
+                }
+                const matches = target.match(el.nextElementSibling);
+                if (matches.matched) {
+                    return mergeMatches(matches, unitCheck, ':has(+ ', true);
+                }
+                return { matched: false };
+            }
+            // Subsequent-sibling (in front) combinator
+            case ':has(~)': {
+                let next = el.nextElementSibling;
+                while (next) {
+                    const matches = target.match(next);
+                    if (matches.matched) {
+                        return mergeMatches(matches, unitCheck, ':has(~ ', true);
+                    }
+                    next = next.nextElementSibling;
+                }
+                return { matched: false };
+            }
+            default: {
+                throw new Error(`Unsupported ${this._combinatedFrom.combinator} combinator in selector`);
+            }
+        }
+    }
+    _matchWithoutCombinateChecking(el) {
+        return uncombinatedRegexSelect(el, this._selector);
+    }
+}
+function uncombinatedRegexSelect(el, selector) {
+    let matched = true;
+    let data = {};
+    let tagSelector = '';
+    const specificity = [0, 0, 0];
+    const specifiedAttr = new Map();
+    if (selector.nodeName) {
+        const matchedNodeName = (0, ml_config_1.regexSelectorMatches)(selector.nodeName, el.localName, (0, is_pure_html_element_1.isPureHTMLElement)(el));
+        if (matchedNodeName) {
+            delete matchedNodeName.$0;
+        }
+        else {
+            matched = false;
+        }
+        data = {
+            ...data,
+            ...matchedNodeName,
+        };
+        tagSelector = el.localName;
+        specificity[2] = 1;
+    }
+    if (selector.attrName) {
+        const selectorAttrName = selector.attrName;
+        const matchedAttrNameList = Array.from(el.attributes).map(attr => {
+            const attrName = attr.name;
+            const matchedAttrName = (0, ml_config_1.regexSelectorMatches)(selectorAttrName, attrName, (0, is_pure_html_element_1.isPureHTMLElement)(el));
+            if (matchedAttrName) {
+                delete matchedAttrName.$0;
+                data = {
+                    ...data,
+                    ...matchedAttrName,
+                };
+                specifiedAttr.set(attrName, '');
+            }
+            return matchedAttrName;
+        });
+        if (!matchedAttrNameList.some(_ => !!_)) {
+            matched = false;
+        }
+    }
+    if (selector.attrValue) {
+        const selectorAttrValue = selector.attrValue;
+        const matchedAttrValueList = Array.from(el.attributes).map(attr => {
+            const attrName = attr.name;
+            const attrValue = attr.value;
+            const matchedAttrValue = (0, ml_config_1.regexSelectorMatches)(selectorAttrValue, attrValue, (0, is_pure_html_element_1.isPureHTMLElement)(el));
+            if (matchedAttrValue) {
+                delete matchedAttrValue.$0;
+                data = {
+                    ...data,
+                    ...matchedAttrValue,
+                };
+                specifiedAttr.set(attrName, attrValue);
+            }
+            return matchedAttrValue;
+        });
+        if (!matchedAttrValueList.some(_ => !!_)) {
+            matched = false;
+        }
+    }
+    const attrSelector = Array.from(specifiedAttr.entries())
+        .map(([name, value]) => {
+        return `[${name}${value ? `="${value}"` : ''}]`;
+    })
+        .join('');
+    specificity[1] += specifiedAttr.size;
+    if (matched) {
+        return {
+            matched,
+            selector: `${tagSelector}${attrSelector}`,
+            specificity,
+            data,
+        };
+    }
+    return { matched };
+}
+function mergeMatches(a, b, sep, close = false) {
+    return {
+        matched: true,
+        selector: `${a.selector}${sep}${b.selector}${close ? ')' : ''}`,
+        specificity: [
+            a.specificity[0] + b.specificity[0],
+            a.specificity[1] + b.specificity[1],
+            a.specificity[2] + b.specificity[2],
+        ],
+        data: {
+            ...a.data,
+            ...b.data,
+        },
+    };
+}

package/lib/selector/selector.d.ts

@@ -0,0 +1,9 @@
+export declare type Specificity = [number, number, number];
+export declare function createSelector(selector: string): Selector;
+export declare function compareSpecificity(a: Specificity, b: Specificity): 1 | 0 | -1;
+declare class Selector {
+	#private;
+	constructor(selector: string);
+	match(el: Element, caller?: ParentNode | null): Specificity | false;
+}
+export {};