@markuplint/ml-core 2.0.0-dev.26 → 2.0.0-rc.5

package/lib/convert-ruleset.d.ts

@@ -1,3 +1,3 @@
 import type { Config } from '@markuplint/ml-config';
 import Ruleset from './ruleset';
-export declare function convertRuleset(config: Config): Ruleset;
+export declare function convertRuleset(config?: Config): Ruleset;

package/lib/convert-ruleset.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertRuleset = void 0;
 const tslib_1 = require("tslib");
 const ruleset_1 = (0, tslib_1.__importDefault)(require("./ruleset"));
-function convertRuleset(config) {
+function convertRuleset(config = {}) {
     return new ruleset_1.default(config);
 }
 exports.convertRuleset = convertRuleset;

package/lib/debug.js

@@ -3,10 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enableDebug = exports.log = void 0;
 const tslib_1 = require("tslib");
 const debug_1 = (0, tslib_1.__importDefault)(require("debug"));
+const CLI_NS = 'markuplint-cli';
 exports.log = (0, debug_1.default)('ml-core');
 function enableDebug() {
-    if (!debug_1.default.enabled('ml-core')) {
-        debug_1.default.enable('ml-core*');
+    if (!exports.log.enabled) {
+        debug_1.default.enable(`${exports.log.namespace}*`);
+        (0, exports.log)(`Debug enable: ${exports.log.namespace}`);
+        if (!debug_1.default.enabled(CLI_NS)) {
+            debug_1.default.enable(`${exports.log.namespace}*,${CLI_NS}*`);
+            (0, exports.log)(`Debug enable: ${exports.log.namespace}, ${CLI_NS}`);
+        }
     }
 }
 exports.enableDebug = enableDebug;

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export { RuleInfo, RuleConfig, RuleConfigValue } from '@markuplint/ml-config';
+export { getAttrSpecs } from '@markuplint/ml-spec';
 export * from './convert-ruleset';
 export * from './ml-core';
 export * from './ml-rule';

package/lib/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.enableDebug = exports.getIndent = exports.Ruleset = exports.MLParseError = void 0;
+exports.enableDebug = exports.getIndent = exports.Ruleset = exports.MLParseError = exports.getAttrSpecs = void 0;
 const tslib_1 = require("tslib");
+var ml_spec_1 = require("@markuplint/ml-spec");
+Object.defineProperty(exports, "getAttrSpecs", { enumerable: true, get: function () { return ml_spec_1.getAttrSpecs; } });
 (0, tslib_1.__exportStar)(require("./convert-ruleset"), exports);
 (0, tslib_1.__exportStar)(require("./ml-core"), exports);
 (0, tslib_1.__exportStar)(require("./ml-rule"), exports);

package/lib/ml-core.d.ts

@@ -5,10 +5,11 @@ import MLParseError from './ml-error/ml-parse-error';
 export declare type MLCoreParams = {
     sourceCode: string;
     filename: string;
+    debug?: boolean;
 } & MLFabric;
 export declare class MLCore {
     #private;
-    constructor({ parser, sourceCode, ruleset, rules, locale, schemas, parserOptions, filename }: MLCoreParams);
+    constructor({ parser, sourceCode, ruleset, rules, locale, schemas, parserOptions, filename, debug }: MLCoreParams);
     get document(): MLParseError | Document<RuleConfigValue, unknown>;
     verify(fix?: boolean): Promise<Violation[]>;
     setCode(sourceCode: string): void;

package/lib/ml-core.js

@@ -6,9 +6,10 @@ const tslib_1 = require("tslib");
 const debug_1 = require("./debug");
 const ml_dom_1 = require("./ml-dom");
 const ml_parse_error_1 = (0, tslib_1.__importDefault)(require("./ml-error/ml-parse-error"));
+const _1 = require(".");
 const resultLog = debug_1.log.extend('result');
 class MLCore {
-    constructor({ parser, sourceCode, ruleset, rules, locale, schemas, parserOptions, filename }) {
+    constructor({ parser, sourceCode, ruleset, rules, locale, schemas, parserOptions, filename, debug }) {
         var _a, _b, _c;
         _MLCore_filename.set(this, void 0);
         _MLCore_document.set(this, void 0);
@@ -33,6 +34,9 @@ class MLCore {
         (0, tslib_1.__classPrivateFieldSet)(this, _MLCore_ast, (0, tslib_1.__classPrivateFieldGet)(this, _MLCore_parser, "f").parse((0, tslib_1.__classPrivateFieldGet)(this, _MLCore_sourceCode, "f"), 0, 0, 0, (0, tslib_1.__classPrivateFieldGet)(this, _MLCore_ignoreFrontMatter, "f")), "f");
         (0, tslib_1.__classPrivateFieldSet)(this, _MLCore_filename, filename, "f");
         (0, tslib_1.__classPrivateFieldSet)(this, _MLCore_rules, rules, "f");
+        if (debug) {
+            (0, _1.enableDebug)();
+        }
         this._createDocument();
     }
     get document() {
@@ -54,8 +58,8 @@ class MLCore {
             return violations;
         }
         for (const rule of (0, tslib_1.__classPrivateFieldGet)(this, _MLCore_rules, "f")) {
-            const ruleInfo = rule.optimizeOption((0, tslib_1.__classPrivateFieldGet)(this, _MLCore_ruleset, "f").rules[rule.name] || false);
-            if (ruleInfo.disabled) {
+            const ruleInfo = rule.getRuleInfo((0, tslib_1.__classPrivateFieldGet)(this, _MLCore_ruleset, "f"), rule.name);
+            if (ruleInfo.disabled && ruleInfo.nodeRules.length === 0 && ruleInfo.childNodeRules.length === 0) {
                 continue;
             }
             (0, debug_1.log)('%s Rule: verify', rule.name);
@@ -81,18 +85,20 @@ class MLCore {
             }
             (0, debug_1.log)('%s Rule: verify end', rule.name);
         }
-        const { e, w, i } = violations.reduce((c, v) => {
-            if (v.severity === 'error')
-                c.e += 1;
-            if (v.severity === 'warning')
-                c.w += 1;
-            if (v.severity === 'info')
-                c.i += 1;
-            return c;
-        }, { e: 0, w: 0, i: 0 });
-        resultLog('Error: %d', e);
-        resultLog('Warning: %d', w);
-        resultLog('Info: %d', i);
+        if (resultLog.enabled) {
+            const { e, w, i } = violations.reduce((c, v) => {
+                if (v.severity === 'error')
+                    c.e += 1;
+                if (v.severity === 'warning')
+                    c.w += 1;
+                if (v.severity === 'info')
+                    c.i += 1;
+                return c;
+            }, { e: 0, w: 0, i: 0 });
+            resultLog('Error: %d', e);
+            resultLog('Warning: %d', w);
+            resultLog('Info: %d', i);
+        }
         (0, debug_1.log)('verify: end');
         return violations;
     }
@@ -119,7 +125,10 @@ class MLCore {
     }
     _createDocument() {
         try {
-            (0, tslib_1.__classPrivateFieldSet)(this, _MLCore_document, new ml_dom_1.Document((0, tslib_1.__classPrivateFieldGet)(this, _MLCore_ast, "f"), (0, tslib_1.__classPrivateFieldGet)(this, _MLCore_ruleset, "f"), (0, tslib_1.__classPrivateFieldGet)(this, _MLCore_schemas, "f"), (0, tslib_1.__classPrivateFieldGet)(this, _MLCore_filename, "f")), "f");
+            (0, tslib_1.__classPrivateFieldSet)(this, _MLCore_document, new ml_dom_1.Document((0, tslib_1.__classPrivateFieldGet)(this, _MLCore_ast, "f"), (0, tslib_1.__classPrivateFieldGet)(this, _MLCore_ruleset, "f"), (0, tslib_1.__classPrivateFieldGet)(this, _MLCore_schemas, "f"), {
+                filename: (0, tslib_1.__classPrivateFieldGet)(this, _MLCore_filename, "f"),
+                tagNameCaseSensitive: (0, tslib_1.__classPrivateFieldGet)(this, _MLCore_parser, "f").tagNameCaseSensitive,
+            }), "f");
         }
         catch (err) {
             if (err instanceof ml_parse_error_1.default) {

package/lib/ml-dom/document.d.ts

@@ -42,7 +42,10 @@ export default class MLDOMDocument<T extends RuleConfigValue, O = null> {
      * @param ast node list of markuplint AST
      * @param ruleset ruleset object
      */
-    constructor(ast: MLASTDocument, ruleset: Ruleset, schemas: readonly [MLMLSpec, ...ExtendedSpec[]], filename?: string);
+    constructor(ast: MLASTDocument, ruleset: Ruleset, schemas: readonly [MLMLSpec, ...ExtendedSpec[]], options?: {
+        filename?: string;
+        tagNameCaseSensitive?: boolean;
+    });
     get doctype(): MLDOMDoctype<T, O> | null;
     get tree(): AnonymousNode<T, O>[];
     walk(walker: Walker<T, O>): Promise<void>;
@@ -60,5 +63,5 @@ export default class MLDOMDocument<T extends RuleConfigValue, O = null> {
     matchNodes(query: string): MLDOMElement<T, O>[];
     toString(): string;
     debugMap(): string[];
-    private _init;
+    private _ruleMapping;
 }

package/lib/ml-dom/document.js

@@ -9,9 +9,11 @@ const helper_1 = require("./helper");
 const debug_2 = require("./helper/debug");
 const match_selector_1 = require("./helper/match-selector");
 const walkers_1 = require("./helper/walkers");
+const rule_mapper_1 = require("./rule-mapper");
 const tokens_1 = require("./tokens");
 const log = debug_1.log.extend('ml-dom');
 const docLog = log.extend('document');
+const ruleLog = docLog.extend('rule');
 /**
  * markuplint DOM Document
  */
@@ -21,7 +23,7 @@ class MLDOMDocument {
      * @param ast node list of markuplint AST
      * @param ruleset ruleset object
      */
-    constructor(ast, ruleset, schemas, filename) {
+    constructor(ast, ruleset, schemas, options) {
         /**
          *
          */
@@ -33,7 +35,7 @@ class MLDOMDocument {
         _MLDOMDocument_filename.set(this, void 0);
         this.isFragment = ast.isFragment;
         this.specs = (0, ml_spec_1.getSpec)(schemas);
-        (0, tslib_1.__classPrivateFieldSet)(this, _MLDOMDocument_filename, filename, "f");
+        (0, tslib_1.__classPrivateFieldSet)(this, _MLDOMDocument_filename, options === null || options === void 0 ? void 0 : options.filename, "f");
         // console.log(ast.nodeList.map((n, i) => `${i}: ${n.uuid} "${n.raw.trim()}"(${n.type})`));
         this.nodeList = Object.freeze(ast.nodeList.map(astNode => {
             if (astNode.type === 'endtag') {
@@ -41,7 +43,7 @@ class MLDOMDocument {
             }
             return (0, helper_1.createNode)(astNode, this);
         }));
-        this._init(ruleset);
+        this._ruleMapping(ruleset, options === null || options === void 0 ? void 0 : options.tagNameCaseSensitive);
     }
     /**
      * It could be used in rule, make sure it is immutable
@@ -122,78 +124,124 @@ class MLDOMDocument {
     debugMap() {
         return (0, debug_2.nodeListToDebugMaps)(this.nodeList, true);
     }
-    _init(ruleset) {
-        docLog('Initialize');
+    _ruleMapping(ruleset, tagNameCaseSensitive) {
+        docLog('Rule Mapping');
+        const ruleMapper = new rule_mapper_1.RuleMapper(this.nodeList);
         // add rules to node
         for (const node of this.nodeList) {
-            docLog('Add rules to node <%s>', 'nodeName' in node ? node.nodeName : `#${node.type}`);
+            if (node.type === 'ElementCloseTag') {
+                continue;
+            }
+            if (docLog.enabled) {
+                docLog('Add rules to node <%s>', 'nodeName' in node ? node.nodeName : `#${node.type}`);
+            }
             // global rules
-            for (const ruleName of Object.keys(ruleset.rules)) {
+            Object.keys(ruleset.rules).forEach(ruleName => {
                 const rule = ruleset.rules[ruleName];
-                node.rules[ruleName] = rule;
-            }
-            if (node.type !== 'Element' && node.type !== 'ElementCloseTag') {
+                ruleMapper.set(node, ruleName, {
+                    from: 'rules',
+                    specificity: [0, 0, 0],
+                    rule,
+                });
+            });
+            if (node.type !== 'Element' && node.type !== 'OmittedElement' && node.type !== 'Text') {
                 continue;
             }
-            const selectorTarget = node.type === 'Element' ? node : node.startTag;
+            const selectorTarget = node.type === 'Element' || node.type === 'OmittedElement' ? node : null;
             // node specs and special rules for node by selector
-            for (const nodeRule of ruleset.nodeRules) {
+            ruleset.nodeRules.forEach((nodeRule, i) => {
                 if (!nodeRule.rules) {
-                    continue;
+                    return;
                 }
-                const selector = nodeRule.selector || nodeRule.tagName || nodeRule.regexSelector;
-                if (!selector) {
-                    continue;
+                if (!selectorTarget) {
+                    return;
                 }
-                const matched = (0, match_selector_1.matchSelector)(selectorTarget, selector);
-                if (!matched) {
-                    continue;
+                const selector = nodeRule.selector || nodeRule.regexSelector || nodeRule.tagName;
+                const matches = 
+                /**
+                 * Forward v1.x compatibility
+                 */
+                nodeRule.tagName && /^#text$/i.test(nodeRule.tagName) && node.type === 'Text'
+                    ? {
+                        matched: true,
+                        selector: '#text',
+                        specificity: [0, 0, 0],
+                    }
+                    : /**
+                       * v2.0.0 or later
+                       */
+                        (0, match_selector_1.matchSelector)(selectorTarget, selector, tagNameCaseSensitive);
+                if (!matches.matched) {
+                    return;
+                }
+                if (docLog.enabled) {
+                    docLog('Matched nodeRule: <%s>(%s)', 'nodeName' in node ? node.nodeName : node.type, matches.selector || '*');
                 }
                 const ruleList = Object.keys(nodeRule.rules);
-                docLog('Matched nodeRule: <%s>(%s) <- Rules: %o', node.nodeName, matched.__node || 'No Selector', ruleList);
-                // special rules
                 for (const ruleName of ruleList) {
                     const rule = nodeRule.rules[ruleName];
-                    const convertedRule = (0, ml_config_1.exchangeValueOnRule)(rule, matched);
+                    const convertedRule = (0, ml_config_1.exchangeValueOnRule)(rule, matches.data || {});
                     if (convertedRule === undefined) {
                         continue;
                     }
-                    node.rules[ruleName] = convertedRule;
+                    const globalRule = ruleset.rules[ruleName];
+                    const mergedRule = globalRule ? (0, ml_config_1.mergeRule)(globalRule, convertedRule) : convertedRule;
+                    ruleLog('↑ nodeRule (%s): %O', ruleName, mergedRule);
+                    ruleMapper.set(node, ruleName, {
+                        from: 'nodeRules',
+                        specificity: matches.specificity,
+                        rule: mergedRule,
+                    });
                 }
-            }
-        }
-        // overwrite rule to child node
-        for (const nodeRule of ruleset.childNodeRules) {
-            if (!nodeRule.rules) {
-                break;
-            }
-            for (const ruleName of Object.keys(nodeRule.rules)) {
-                const rule = nodeRule.rules[ruleName];
-                for (const node of this.nodeList) {
-                    if (node.type !== 'Element') {
-                        continue;
+            });
+            // overwrite rule to child node
+            if (selectorTarget && ruleset.childNodeRules.length) {
+                const descendants = [];
+                (0, walkers_1.syncWalk)(selectorTarget.childNodes, childNode => {
+                    descendants.push(childNode);
+                    if (childNode.type === 'Element' && childNode.closeTag) {
+                        descendants.push(childNode.closeTag);
+                    }
+                });
+                const children = selectorTarget.childNodes;
+                ruleset.childNodeRules.forEach((nodeRule, i) => {
+                    if (!nodeRule.rules) {
+                        return;
+                    }
+                    const nodeRuleRules = nodeRule.rules;
+                    const selector = nodeRule.selector || nodeRule.tagName || nodeRule.regexSelector;
+                    if (!selector) {
+                        return;
+                    }
+                    const matches = (0, match_selector_1.matchSelector)(selectorTarget, selector, tagNameCaseSensitive);
+                    if (!matches.matched) {
+                        return;
                     }
-                    const matched = (0, match_selector_1.matchSelector)(node, nodeRule.selector || nodeRule.regexSelector);
-                    if (matched) {
-                        const convertedRule = (0, ml_config_1.exchangeValueOnRule)(rule, matched);
+                    if (docLog.enabled) {
+                        docLog('Matched childNodeRule: <%s>(%s), inheritance: %o', selectorTarget.nodeName, matches.selector || '*', !!nodeRule.inheritance);
+                    }
+                    const targetDescendants = nodeRule.inheritance ? descendants : children;
+                    Object.keys(nodeRuleRules).forEach(ruleName => {
+                        const rule = nodeRuleRules[ruleName];
+                        const convertedRule = (0, ml_config_1.exchangeValueOnRule)(rule, matches.data || {});
                         if (convertedRule === undefined) {
-                            continue;
+                            return;
                         }
-                        docLog('Matched childNodeRule: <%s>(%s) <- Rule: %s', node.nodeName, matched.__node || 'No Selector', ruleName);
-                        if (nodeRule.inheritance) {
-                            (0, walkers_1.syncWalk)(node.childNodes, childNode => {
-                                childNode.rules[ruleName] = convertedRule;
+                        const globalRule = ruleset.rules[ruleName];
+                        const mergedRule = globalRule ? (0, ml_config_1.mergeRule)(globalRule, convertedRule) : convertedRule;
+                        ruleLog('↑ childNodeRule (%s): %O', ruleName, mergedRule);
+                        targetDescendants.forEach(descendant => {
+                            ruleMapper.set(descendant, ruleName, {
+                                from: 'childNodeRules',
+                                specificity: matches.specificity,
+                                rule: mergedRule,
                             });
-                        }
-                        else {
-                            for (const childNode of node.childNodes) {
-                                childNode.rules[ruleName] = convertedRule;
-                            }
-                        }
-                    }
-                }
+                        });
+                    });
+                });
             }
         }
+        ruleMapper.apply();
     }
 }
 exports.default = MLDOMDocument;

package/lib/ml-dom/helper/match-selector.d.ts

@@ -1,5 +1,16 @@
 import type MLDOMAbstractElement from '../tokens/abstract-element';
+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;
+};
 declare type TargetElement = MLDOMAbstractElement<any, any>;
-export declare function matchSelector(el: TargetElement, selector: string | RegexSelector | undefined): Record<string, string> | null;
+export declare function matchSelector(el: TargetElement, selector: string | RegexSelector | undefined, tagNameCaseSensitive?: boolean): SelectorMatches;
 export {};