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

package/lib/ml-dom/node/dom-token-list.d.ts

@@ -0,0 +1,33 @@
+import type { MLAttr } from './attr';
+import type { RuleInfo } from '@markuplint/ml-config';
+declare type Scope = {
+    raw: string;
+    startOffset: number;
+    startLine: number;
+    startCol: number;
+    rule: RuleInfo<any, any>;
+};
+export declare class MLDomTokenList extends Array<string> implements DOMTokenList {
+    #private;
+    get value(): string;
+    constructor(tokens: string, ownerAttrs: MLAttr<any, any>[]);
+    add(...tokens: string[]): void;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDomTokenList`
+     */
+    allTokens(): Scope[];
+    contains(token: string): boolean;
+    forEach(callbackfn: (value: string, index: number, parent: any) => void, thisArg?: any): void;
+    item(index: number): string | null;
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDomTokenList`
+     */
+    pick(token: string): Scope | null;
+    remove(...tokens: string[]): void;
+    replace(token: string, newToken: string): boolean;
+    supports(token: string): boolean;
+    toggle(token: string, force?: boolean): boolean;
+    toString(): string;
+    private _pick;
+}
+export {};

package/lib/ml-dom/node/dom-token-list.js

@@ -0,0 +1,137 @@
+"use strict";
+var _MLDomTokenList_set, _MLDomTokenList_origin, _MLDomTokenList_ownerAttrs;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MLDomTokenList = void 0;
+const tslib_1 = require("tslib");
+const parser_utils_1 = require("@markuplint/parser-utils");
+const unexpected_call_error_1 = tslib_1.__importDefault(require("./unexpected-call-error"));
+class MLDomTokenList extends Array {
+    constructor(tokens, ownerAttrs) {
+        const list = tokens
+            .split(/\s+/)
+            .map(t => t.trim())
+            .filter(t => !!t);
+        super(...list);
+        _MLDomTokenList_set.set(this, void 0);
+        _MLDomTokenList_origin.set(this, void 0);
+        /**
+         * In some cases, an author specifies multiple attributes or directives.
+         * The reference is not always one.
+         */
+        _MLDomTokenList_ownerAttrs.set(this, void 0);
+        tslib_1.__classPrivateFieldSet(this, _MLDomTokenList_origin, tokens, "f");
+        tslib_1.__classPrivateFieldSet(this, _MLDomTokenList_ownerAttrs, ownerAttrs, "f");
+        tslib_1.__classPrivateFieldSet(this, _MLDomTokenList_set, new Set(list), "f");
+    }
+    get value() {
+        return this.join(' ');
+    }
+    add(...tokens) {
+        for (const token of tokens) {
+            if (tslib_1.__classPrivateFieldGet(this, _MLDomTokenList_set, "f").has(token)) {
+                continue;
+            }
+            tslib_1.__classPrivateFieldGet(this, _MLDomTokenList_set, "f").add(token);
+            this.push(token);
+        }
+        tslib_1.__classPrivateFieldSet(this, _MLDomTokenList_origin, tslib_1.__classPrivateFieldGet(this, _MLDomTokenList_origin, "f") + tokens.join(' '), "f");
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDomTokenList`
+     */
+    allTokens() {
+        let offset = 0;
+        const tokens = Array.from(this);
+        const locs = [];
+        while (tokens.length) {
+            const token = tokens.shift();
+            if (!token) {
+                break;
+            }
+            const loc = this._pick(token, offset);
+            if (!loc) {
+                offset = 0;
+                continue;
+            }
+            offset = loc._searchedIndex;
+            locs.push({
+                raw: loc.raw,
+                startOffset: loc.startOffset,
+                startLine: loc.startLine,
+                startCol: loc.startCol,
+                rule: loc.rule,
+            });
+        }
+        return locs;
+    }
+    contains(token) {
+        return tslib_1.__classPrivateFieldGet(this, _MLDomTokenList_set, "f").has(token);
+    }
+    forEach(callbackfn, thisArg) {
+        this.forEach.bind(this)((v, i) => callbackfn(v, i, thisArg !== null && thisArg !== void 0 ? thisArg : this));
+    }
+    item(index) {
+        var _a;
+        return (_a = this[index]) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * @implements `@markuplint/ml-core` API: `MLDomTokenList`
+     */
+    pick(token) {
+        const r = this._pick(token);
+        if (!r) {
+            return null;
+        }
+        return {
+            raw: r.raw,
+            startOffset: r.startOffset,
+            startLine: r.startLine,
+            startCol: r.startCol,
+            rule: r.rule,
+        };
+    }
+    remove(...tokens) {
+        throw new unexpected_call_error_1.default('Not supported "remove" method');
+    }
+    replace(token, newToken) {
+        throw new unexpected_call_error_1.default('Not supported "replace" method');
+    }
+    supports(token) {
+        throw new unexpected_call_error_1.default('Not supported "supports" method');
+    }
+    toggle(token, force) {
+        throw new unexpected_call_error_1.default('Not supported "toggle" method');
+    }
+    toString() {
+        return this.value;
+    }
+    _pick(token, _offset = 0) {
+        var _a, _b, _c, _d, _e, _f;
+        token = token.trim().split(/\s+/g)[0];
+        if (!token) {
+            return null;
+        }
+        for (const ownerAttr of tslib_1.__classPrivateFieldGet(this, _MLDomTokenList_ownerAttrs, "f")) {
+            if (ownerAttr.isDynamicValue) {
+                continue;
+            }
+            const startOffset = tslib_1.__classPrivateFieldGet(this, _MLDomTokenList_origin, "f").indexOf(token, _offset);
+            if (startOffset === -1) {
+                continue;
+            }
+            const startLine = (0, parser_utils_1.getLine)(tslib_1.__classPrivateFieldGet(this, _MLDomTokenList_origin, "f"), startOffset);
+            const startCol = (0, parser_utils_1.getCol)(tslib_1.__classPrivateFieldGet(this, _MLDomTokenList_origin, "f"), startOffset);
+            return {
+                raw: token,
+                startOffset: ((_b = (_a = ownerAttr.valueNode) === null || _a === void 0 ? void 0 : _a.startOffset) !== null && _b !== void 0 ? _b : 0) + startOffset,
+                startLine: ((_d = (_c = ownerAttr.valueNode) === null || _c === void 0 ? void 0 : _c.startLine) !== null && _d !== void 0 ? _d : 0) + (startLine - 1),
+                startCol: ((_f = (_e = ownerAttr.valueNode) === null || _e === void 0 ? void 0 : _e.startCol) !== null && _f !== void 0 ? _f : 0) + (startCol - 1),
+                rule: ownerAttr.rule,
+                _searchedIndex: startOffset,
+            };
+        }
+        return null;
+    }
+}
+exports.MLDomTokenList = MLDomTokenList;
+_MLDomTokenList_set = new WeakMap(), _MLDomTokenList_origin = new WeakMap(), _MLDomTokenList_ownerAttrs = new WeakMap();