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

package/lib/ml-dom/document.js

@@ -1,273 +0,0 @@
-"use strict";
-var _MLDOMDocument_filename;
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const ml_config_1 = require("@markuplint/ml-config");
-const ml_spec_1 = require("@markuplint/ml-spec");
-const debug_1 = require("../debug");
-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
- */
-class MLDOMDocument {
-    /**
-     *
-     * @param ast node list of markuplint AST
-     * @param ruleset ruleset object
-     */
-    constructor(ast, ruleset, schemas, options) {
-        var _a;
-        /**
-         *
-         */
-        this.currentRule = null;
-        /**
-         *
-         */
-        this.nodeStore = new helper_1.NodeStore();
-        /**
-         * Window object for calling the `getComputedStyle` and the `getPropertyValue` that are needed by **Accessible Name and Description Computation**.
-         * But it always returns the empty object.
-         * (It may improve to possible to compute the name from the `style` attribute in the future.)
-         */
-        this.defaultView = {
-            getComputedStyle(_el) {
-                return {
-                    getPropertyValue(_propName) {
-                        return {};
-                    },
-                };
-            },
-        };
-        _MLDOMDocument_filename.set(this, void 0);
-        this.isFragment = ast.isFragment;
-        this.specs = (0, ml_spec_1.getSpec)(schemas);
-        this.endTag = (_a = options === null || options === void 0 ? void 0 : options.endTag) !== null && _a !== void 0 ? _a : 'omittable';
-        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') {
-                return this.nodeStore.getNode(astNode);
-            }
-            return (0, helper_1.createNode)(astNode, this);
-        }));
-        this._ruleMapping(ruleset, options === null || options === void 0 ? void 0 : options.tagNameCaseSensitive);
-    }
-    /**
-     * It could be used in rule, make sure it is immutable
-     */
-    get filename() {
-        return tslib_1.__classPrivateFieldGet(this, _MLDOMDocument_filename, "f");
-    }
-    get doctype() {
-        for (const node of this.nodeList) {
-            if (node instanceof tokens_1.MLDOMDoctype) {
-                return node;
-            }
-        }
-        return null;
-    }
-    get tree() {
-        const treeRoots = [];
-        let traversalNode = this.nodeList[0];
-        while (traversalNode) {
-            treeRoots.push(traversalNode);
-            traversalNode = traversalNode.nextNode;
-        }
-        return treeRoots;
-    }
-    walk(walker) {
-        /**
-         * The following pattern is used to ensure that all rules run sequentially,
-         * no matter it runs asynchronously or synchronously.
-         */
-        let _resolve;
-        let _reject;
-        const promise = new Promise((resolve, reject) => {
-            _resolve = resolve;
-            _reject = reject;
-        });
-        const loop = (index = 0) => {
-            if (index >= this.nodeList.length) {
-                _resolve();
-                return;
-            }
-            const node = this.nodeList[index];
-            const result = walker(node);
-            if (result instanceof Promise) {
-                result.then(() => loop(index + 1)).catch(_reject);
-            }
-            else {
-                loop(index + 1);
-            }
-        };
-        loop();
-        return promise;
-    }
-    walkOn(type, walker, skipWhenRuleIsDisabled = true) {
-        return this.walk(node => {
-            if (node instanceof tokens_1.MLDOMNode) {
-                if (skipWhenRuleIsDisabled && node.rule.disabled) {
-                    return;
-                }
-                if (node.is(type)) {
-                    return walker(node);
-                }
-            }
-        });
-    }
-    setRule(rule) {
-        this.currentRule = rule;
-    }
-    matchNodes(query) {
-        return this.nodeList.filter((node) => node.type === 'Element' && node.matches(query));
-    }
-    querySelectorAll(query) {
-        return this.matchNodes(query);
-    }
-    querySelector(query) {
-        return this.querySelectorAll(query)[0] || null;
-    }
-    getElementById(id) {
-        return this.querySelector(`#${id}`);
-    }
-    toString() {
-        const html = [];
-        for (const node of this.nodeList) {
-            html.push(node.raw);
-        }
-        return html.join('');
-    }
-    debugMap() {
-        return (0, debug_2.nodeListToDebugMaps)(this.nodeList, true);
-    }
-    _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) {
-            if (node.type === 'ElementCloseTag') {
-                continue;
-            }
-            if (docLog.enabled) {
-                docLog('Add rules to node <%s>', 'nodeName' in node ? node.nodeName : `#${node.type}`);
-            }
-            // global rules
-            Object.keys(ruleset.rules).forEach(ruleName => {
-                const rule = ruleset.rules[ruleName];
-                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.type === 'OmittedElement' ? node : null;
-            // node specs and special rules for node by selector
-            ruleset.nodeRules.forEach((nodeRule, i) => {
-                if (!nodeRule.rules) {
-                    return;
-                }
-                if (!selectorTarget) {
-                    return;
-                }
-                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);
-                for (const ruleName of ruleList) {
-                    const rule = nodeRule.rules[ruleName];
-                    const convertedRule = (0, ml_config_1.exchangeValueOnRule)(rule, matches.data || {});
-                    if (convertedRule === undefined) {
-                        continue;
-                    }
-                    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
-            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;
-                    }
-                    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) {
-                            return;
-                        }
-                        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,
-                            });
-                        });
-                    });
-                });
-            }
-        }
-        ruleMapper.apply();
-    }
-}
-exports.default = MLDOMDocument;
-_MLDOMDocument_filename = new WeakMap();

package/lib/ml-dom/helper/index.d.ts

@@ -1,4 +0,0 @@
-export { createNode } from './create-node';
-export { default as NodeStore } from './node-store';
-export { MappedNode } from './mapped-nodes';
-export { createSelector } from './selector';

package/lib/ml-dom/helper/index.js

@@ -1,12 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSelector = exports.NodeStore = exports.createNode = void 0;
-var create_node_1 = require("./create-node");
-Object.defineProperty(exports, "createNode", { enumerable: true, get: function () { return create_node_1.createNode; } });
-var node_store_1 = require("./node-store");
-Object.defineProperty(exports, "NodeStore", { enumerable: true, get: function () { return __importDefault(node_store_1).default; } });
-var selector_1 = require("./selector");
-Object.defineProperty(exports, "createSelector", { enumerable: true, get: function () { return selector_1.createSelector; } });

package/lib/ml-dom/helper/mapped-nodes.d.ts

@@ -1,52 +0,0 @@
-import type {
-	MLDOMAttribute,
-	MLDOMComment,
-	MLDOMDoctype,
-	MLDOMElement,
-	MLDOMElementCloseTag,
-	MLDOMNode,
-	MLDOMOmittedElement,
-	MLDOMPreprocessorSpecificBlock,
-	MLDOMText,
-	MLDOMToken,
-} from '../tokens';
-import type {
-	MLASTAbstructNode,
-	MLASTAttr,
-	MLASTComment,
-	MLASTDoctype,
-	MLASTElement,
-	MLASTElementCloseTag,
-	MLASTNode,
-	MLASTOmittedElement,
-	MLASTParentNode,
-	MLASTPreprocessorSpecificBlock,
-	MLASTText,
-	MLToken,
-} from '@markuplint/ml-ast/';
-import type { RuleConfigValue } from '@markuplint/ml-config';
-export declare type MappedNode<N, T extends RuleConfigValue, O = null> = N extends MLASTElement
-	? MLDOMElement<T, O>
-	: N extends MLASTElementCloseTag
-	? MLDOMElementCloseTag<T, O>
-	: N extends MLASTOmittedElement
-	? MLDOMOmittedElement<T, O>
-	: N extends MLASTParentNode
-	? MLDOMElement<T, O> | MLDOMOmittedElement<T, O>
-	: N extends MLASTComment
-	? MLDOMComment<T, O>
-	: N extends MLASTText
-	? MLDOMText<T, O>
-	: N extends MLASTDoctype
-	? MLDOMDoctype<T, O>
-	: N extends MLASTNode
-	? MLDOMNode<T, O, MLASTNode>
-	: N extends MLASTPreprocessorSpecificBlock
-	? MLDOMPreprocessorSpecificBlock<T, O>
-	: N extends MLASTAbstructNode
-	? MLDOMNode<T, O, MLASTAbstructNode>
-	: N extends MLASTAttr
-	? MLDOMAttribute
-	: N extends MLToken
-	? MLDOMToken<MLToken>
-	: never;

package/lib/ml-dom/helper/mapped-nodes.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,20 +0,0 @@
-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,
-	tagNameCaseSensitive?: boolean,
-): SelectorMatches;
-export {};

package/lib/ml-dom/helper/match-selector.js

@@ -1,233 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchSelector = void 0;
-const ml_config_1 = require("@markuplint/ml-config");
-const selector_1 = require("./selector");
-function matchSelector(el, selector, tagNameCaseSensitive) {
-    if (!selector) {
-        return {
-            matched: false,
-        };
-    }
-    if (typeof selector === 'string') {
-        const sel = (0, selector_1.createSelector)(selector, tagNameCaseSensitive);
-        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 = {
-            nodeName: selector.nodeName,
-            attrName: selector.attrName,
-            attrValue: selector.attrValue,
-        };
-    }
-    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.getParentElement();
-                while (ancestor) {
-                    const matches = target.match(ancestor);
-                    if (matches.matched) {
-                        return mergeMatches(matches, unitCheck, ' ');
-                    }
-                    ancestor = ancestor.getParentElement();
-                }
-                return {
-                    matched: false,
-                };
-            }
-            // Child combinator
-            case '>': {
-                const parentNode = el.getParentElement();
-                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);
-    }
-    from(target, combinator) {
-        this._combinatedFrom = { target, combinator };
-    }
-}
-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.nodeName);
-        if (matchedNodeName) {
-            delete matchedNodeName.$0;
-        }
-        else {
-            matched = false;
-        }
-        data = {
-            ...data,
-            ...matchedNodeName,
-        };
-        tagSelector = el.nodeName;
-        specificity[2] = 1;
-    }
-    if (selector.attrName) {
-        const selectorAttrName = selector.attrName;
-        const matchedAttrNameList = el.attributes.map(attr => {
-            const attrName = attr.getName().potential;
-            const matchedAttrName = (0, ml_config_1.regexSelectorMatches)(selectorAttrName, attrName);
-            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 = el.attributes.map(attr => {
-            const attrName = attr.getName().potential;
-            const attrValue = attr.getValue().potential;
-            const matchedAttrValue = (0, ml_config_1.regexSelectorMatches)(selectorAttrValue, attrValue);
-            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/ml-dom/helper/node-store.d.ts

@@ -1,12 +0,0 @@
-import type MLDOMNode from '../tokens/node';
-import type { MappedNode } from './mapped-nodes';
-import type { MLASTAbstructNode } from '@markuplint/ml-ast';
-import type { RuleConfigValue } from '@markuplint/ml-config';
-export default class NodeStore {
-	#private;
-	setNode<A extends MLASTAbstructNode, T extends RuleConfigValue, O = null>(
-		astNode: A,
-		node: MLDOMNode<T, O, A>,
-	): void;
-	getNode<N extends MLASTAbstructNode, T extends RuleConfigValue, O = null>(astNode: N): MappedNode<N, T, O>;
-}

package/lib/ml-dom/helper/node-store.js

@@ -1,28 +0,0 @@
-"use strict";
-var _NodeStore_store;
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const parser_utils_1 = require("@markuplint/parser-utils");
-class NodeStore {
-    constructor() {
-        _NodeStore_store.set(this, new Map());
-    }
-    setNode(astNode, node) {
-        tslib_1.__classPrivateFieldGet(this, _NodeStore_store, "f").set(astNode.uuid, node);
-    }
-    getNode(astNode) {
-        // console.log(`Get: ${astNode.uuid} -> ${astNode.raw.trim()}(${astNode.type})`);
-        const node = tslib_1.__classPrivateFieldGet(this, _NodeStore_store, "f").get(astNode.uuid);
-        if (!node) {
-            throw new parser_utils_1.ParserError('Broke mapping nodes.', {
-                line: astNode.startLine,
-                col: astNode.startCol,
-                raw: astNode.raw,
-                nodeName: astNode.nodeName,
-            });
-        }
-        return node;
-    }
-}
-exports.default = NodeStore;
-_NodeStore_store = new WeakMap();

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

@@ -1,11 +0,0 @@
-import type MLDOMAbstractElement from '../tokens/abstract-element';
-export declare type Specificity = [number, number, number];
-export declare function createSelector(selector: string, tagNameCaseSensitive?: boolean): Selector;
-export declare function compareSpecificity(a: Specificity, b: Specificity): 0 | 1 | -1;
-declare type TargetElement = MLDOMAbstractElement<any, any>;
-declare class Selector {
-	#private;
-	constructor(selector: string, tagNameCaseSensitive: boolean);
-	match(el: TargetElement, caller?: TargetElement | null): Specificity | false;
-}
-export {};