wikiparser-node 1.12.3-b → 1.12.3

package/dist/lib/element.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstElement = void 0;
+const string_1 = require("../util/string");
+const debug_1 = require("../util/debug");
+const node_1 = require("./node");
+/* NOT FOR BROWSER */
+const fs = require("fs");
+const path = require("path");
+const constants_1 = require("../util/constants");
+const selector_1 = require("../parser/selector");
+/**
+ * 将选择器转化为类型谓词
+ * @param selector 选择器
+ */
+const getCondition = (selector) => {
+    /* NOT FOR BROWSER */
+    if (/[^a-z\-,\s]/u.test(selector)) {
+        return (0, selector_1.checkToken)(selector);
+    }
+    /* NOT FOR BROWSER END */
+    const types = new Set(selector.split(',').map(str => str.trim()));
+    return (({ type }) => types.has(type));
+};
+/** 类似HTMLElement */
+class AstElement extends node_1.AstNode {
+    /** 子节点总数 */
+    get length() {
+        return this.childNodes.length;
+    }
+    /* NOT FOR BROWSER */
+    set length(n) {
+        if (n >= 0 && n < this.length) {
+            for (let i = this.length - 1; i >= n; i--) {
+                this.removeAt(i);
+            }
+        }
+    }
+    /** 全部非文本子节点 */
+    get children() {
+        return this.childNodes.filter((child) => child.type !== 'text');
+    }
+    /** 首位非文本子节点 */
+    get firstElementChild() {
+        return this.childNodes.find((child) => child.type !== 'text');
+    }
+    /** 末位非文本子节点 */
+    get lastElementChild() {
+        return this.children[this.childElementCount - 1];
+    }
+    /** 非文本子节点总数 */
+    get childElementCount() {
+        return this.children.length;
+    }
+    /** 父节点 */
+    get parentElement() {
+        return this.parentNode;
+    }
+    /** AstElement.prototype.text()的getter写法 */
+    get outerText() {
+        return this.text();
+    }
+    /** 不可见 */
+    get hidden() {
+        return this.text() === '';
+    }
+    /** 内部高度 */
+    get clientHeight() {
+        const { innerText } = this;
+        return typeof innerText === 'string' ? innerText.split('\n').length : undefined;
+    }
+    /** 内部宽度 */
+    get clientWidth() {
+        const { innerText } = this;
+        if (typeof innerText === 'string') {
+            const lines = innerText.split('\n');
+            return lines.at(-1).length;
+        }
+        return undefined;
+    }
+    constructor() {
+        super();
+        this.seal('name');
+    }
+    /* NOT FOR BROWSER END */
+    /** @private */
+    text(separator) {
+        return (0, string_1.text)(this.childNodes, separator);
+    }
+    /** 合并相邻的文本子节点 */
+    normalize() {
+        const childNodes = [...this.childNodes];
+        /**
+         * 移除子节点
+         * @param i 移除位置
+         */
+        const remove = (i) => {
+            childNodes[i].setAttribute('parentNode', undefined);
+            childNodes.splice(i, 1);
+        };
+        for (let i = childNodes.length - 1; i >= 0; i--) {
+            const { type, data } = childNodes[i];
+            if (type !== 'text' || this.getGaps(i - 1)) {
+                //
+            }
+            else if (data === '') {
+                remove(i);
+                /* NOT FOR BROWSER */
+            }
+            else {
+                const prev = childNodes[i - 1];
+                if (prev?.type === 'text') {
+                    prev.setAttribute('data', prev.data + data);
+                    remove(i);
+                }
+                /* NOT FOR BROWSER END */
+            }
+        }
+        this.setAttribute('childNodes', childNodes);
+    }
+    /**
+     * 移除子节点
+     * @param i 移除位置
+     */
+    removeAt(i) {
+        /* NOT FOR BROWSER */
+        this.verifyChild(i);
+        /* NOT FOR BROWSER END */
+        return (0, debug_1.setChildNodes)(this, i, 1)[0];
+    }
+    /**
+     * 插入子节点
+     * @param node 待插入的子节点
+     * @param i 插入位置
+     * @throws `RangeError` 不能插入祖先或子节点
+     */
+    insertAt(node, i = this.length) {
+        /* NOT FOR BROWSER */
+        if (node.contains(this)) {
+            throw new RangeError('Cannot insert an ancestor node!');
+        }
+        else if (this.childNodes.includes(node)) {
+            throw new RangeError('Cannot insert its own child node!');
+        }
+        this.verifyChild(i, 1);
+        node.parentNode?.removeChild(node);
+        /* NOT FOR BROWSER END */
+        (0, debug_1.setChildNodes)(this, i, 0, [node]);
+        return node;
+    }
+    /**
+     * 最近的祖先节点
+     * @param selector 选择器
+     */
+    closest(selector) {
+        const condition = getCondition(selector);
+        let { parentNode } = this;
+        while (parentNode) {
+            if (condition(parentNode)) {
+                return parentNode;
+            }
+            ({ parentNode } = parentNode);
+        }
+        return undefined;
+    }
+    /**
+     * 符合条件的第一个后代节点
+     * @param condition 条件
+     */
+    #getElementBy(condition) {
+        for (const child of this.childNodes) {
+            if (child.type === 'text') {
+                continue;
+            }
+            else if (condition(child)) {
+                return child;
+            }
+            const descendant = child.#getElementBy(condition);
+            if (descendant) {
+                return descendant;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * 符合选择器的第一个后代节点
+     * @param selector 选择器
+     */
+    querySelector(selector) {
+        const condition = getCondition(selector);
+        return this.#getElementBy(condition);
+    }
+    /**
+     * 符合条件的所有后代节点
+     * @param condition 条件
+     */
+    #getElementsBy(condition) {
+        const descendants = [];
+        for (const child of this.childNodes) {
+            if (child.type === 'text') {
+                continue;
+            }
+            else if (condition(child)) {
+                descendants.push(child);
+            }
+            descendants.push(...child.#getElementsBy(condition));
+        }
+        return descendants;
+    }
+    /**
+     * 符合选择器的所有后代节点
+     * @param selector 选择器
+     */
+    querySelectorAll(selector) {
+        const condition = getCondition(selector);
+        return this.#getElementsBy(condition);
+    }
+    /**
+     * 在末尾批量插入子节点
+     * @param elements 插入节点
+     */
+    append(...elements) {
+        for (const element of elements) {
+            this.insertAt(element);
+        }
+    }
+    /**
+     * 批量替换子节点
+     * @param elements 新的子节点
+     */
+    replaceChildren(...elements) {
+        for (let i = this.length - 1; i >= 0; i--) {
+            this.removeAt(i);
+        }
+        this.append(...elements);
+    }
+    /**
+     * 修改文本子节点
+     * @param str 新文本
+     * @param i 子节点位置
+     * @throws `RangeError` 对应位置的子节点不是文本节点
+     */
+    setText(str, i = 0) {
+        i += i < 0 ? this.length : 0;
+        /* NOT FOR BROWSER */
+        this.verifyChild(i);
+        /* NOT FOR BROWSER END */
+        const oldText = this.childNodes[i];
+        if (oldText.type === 'text') { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+            const { data } = oldText;
+            oldText.replaceData(str);
+            return data;
+        }
+        /* NOT FOR BROWSER */
+        throw new RangeError(`The child node at position ${i} is ${oldText.constructor.name}!`);
+    }
+    /** @private */
+    toString(skip, separator = '') {
+        return this.childNodes.map(child => child.toString(skip)).join(separator);
+    }
+    /** @private */
+    lint(start = this.getAbsoluteIndex(), re) {
+        const errors = [];
+        for (let i = 0, cur = start + this.getAttribute('padding'); i < this.length; i++) {
+            const child = this.childNodes[i];
+            errors.push(...child.lint(cur, re));
+            cur += child.toString().length + this.getGaps(i);
+        }
+        return errors;
+    }
+    /** @private */
+    print(opt = {}) {
+        const cl = opt.class;
+        return this.toString()
+            ? `${cl === '' ? '' : `<span class="wpb-${cl ?? this.type}">`}${(0, string_1.print)(this.childNodes, opt)}${cl === '' ? '' : '</span>'}`
+            : '';
+    }
+    /**
+     * 保存为JSON
+     * @param file 文件名
+     * @param start
+     */
+    json(file, start = this.getAbsoluteIndex()) {
+        const json = {
+            ...this,
+            type: this.type,
+            range: [start, start + this.toString().length],
+            childNodes: [],
+        };
+        for (let i = 0, cur = start + this.getAttribute('padding'); i < this.length; i++) {
+            const child = this.childNodes[i], { length } = child.toString();
+            json.childNodes.push(child.type === 'text'
+                ? { data: child.data, range: [cur, cur + length] }
+                : child.json(undefined, cur));
+            cur += length + this.getGaps(i);
+        }
+        /* NOT FOR BROWSER */
+        if (typeof file === 'string') {
+            fs.writeFileSync(path.join(__dirname, '..', '..', 'printed', file + (file.endsWith('.json') ? '' : '.json')), JSON.stringify(json, null, 2));
+        }
+        /* NOT FOR BROWSER END */
+        return json;
+    }
+    /* NOT FOR BROWSER */
+    /**
+     * 检查是否符合选择器
+     * @param selector 选择器
+     */
+    matches(selector) {
+        return selector === undefined || getCondition(selector)(this);
+    }
+    /**
+     * 类型选择器
+     * @param types
+     */
+    getElementByTypes(types) {
+        const typeSet = new Set(types.split(',').map(str => str.trim()));
+        return this.#getElementBy((({ type }) => typeSet.has(type)));
+    }
+    /**
+     * id选择器
+     * @param id id名
+     */
+    getElementById(id) {
+        return this.#getElementBy((token => 'id' in token && token.id === id));
+    }
+    /**
+     * 类选择器
+     * @param className 类名之一
+     */
+    getElementsByClassName(className) {
+        return this.#getElementsBy((token => 'classList' in token && token.classList.has(className)));
+    }
+    /**
+     * 标签名选择器
+     * @param tag 标签名
+     */
+    getElementsByTagName(tag) {
+        return this.#getElementsBy((({ type, name }) => name === tag && (type === 'html' || type === 'ext')));
+    }
+    /**
+     * 在开头批量插入子节点
+     * @param elements 插入节点
+     */
+    prepend(...elements) {
+        for (let i = 0; i < elements.length; i++) {
+            this.insertAt(elements[i], i);
+        }
+    }
+    /**
+     * 获取子节点的位置
+     * @param node 子节点
+     * @throws `RangeError` 找不到子节点
+     */
+    #getChildIndex(node) {
+        const i = this.childNodes.indexOf(node);
+        if (i === -1) {
+            throw new RangeError('Not a child node!');
+        }
+        return i;
+    }
+    /**
+     * 移除子节点
+     * @param node 子节点
+     */
+    removeChild(node) {
+        return this.removeAt(this.#getChildIndex(node));
+    }
+    insertBefore(child, reference) {
+        return reference === undefined
+            ? this.insertAt(child)
+            : this.insertAt(child, this.#getChildIndex(reference));
+    }
+}
+exports.AstElement = AstElement;
+constants_1.classes['AstElement'] = __filename;

package/dist/lib/node.d.ts

@@ -0,0 +1,173 @@
+import type { LintError, AstNode as AstNodeBase, TokenTypes } from '../base';
+import type { AstText, Token } from '../internal';
+export type AstNodes = AstText | Token;
+export interface Dimension {
+    readonly height: number;
+    readonly width: number;
+}
+export interface Position {
+    readonly top: number;
+    readonly left: number;
+}
+export interface CaretPosition {
+    readonly offsetNode: AstNodes;
+    readonly offset: number;
+}
+/** 类似Node */
+export declare abstract class AstNode implements AstNodeBase {
+    #private;
+    data?: string | undefined;
+    readonly childNodes: readonly AstNodes[];
+    abstract get type(): TokenTypes | 'text';
+    abstract set type(value: TokenTypes | 'text');
+    /** 可见部分 */
+    text(): string;
+    lint(): LintError[];
+    print(): string;
+    /** 首位子节点 */
+    get firstChild(): AstNodes | undefined;
+    /** 末位子节点 */
+    get lastChild(): AstNodes | undefined;
+    /** 父节点 */
+    get parentNode(): Token | undefined;
+    /** 后一个兄弟节点 */
+    get nextSibling(): AstNodes | undefined;
+    /** 前一个兄弟节点 */
+    get previousSibling(): AstNodes | undefined;
+    /** 行数 */
+    get offsetHeight(): number;
+    /** 最后一行的列数 */
+    get offsetWidth(): number;
+    /** 后一个非文本兄弟节点 */
+    get nextElementSibling(): Token | undefined;
+    /** 前一个非文本兄弟节点 */
+    get previousElementSibling(): Token | undefined;
+    /** 后一个可见的兄弟节点 */
+    get nextVisibleSibling(): AstNodes | undefined;
+    /** 前一个可见的兄弟节点 */
+    get previousVisibleSibling(): AstNodes | undefined;
+    /** 是否具有根节点 */
+    get isConnected(): boolean;
+    /** 后方是否还有其他节点（不含后代） */
+    get eof(): boolean | undefined;
+    /** 相对于父容器的行号 */
+    get offsetTop(): number;
+    /** 相对于父容器的列号 */
+    get offsetLeft(): number;
+    /** 位置、大小和padding */
+    get style(): Position & Dimension & {
+        padding: number;
+    };
+    /** 字体样式 */
+    get font(): {
+        bold: boolean;
+        italic: boolean;
+    };
+    /** 是否粗体 */
+    get bold(): boolean;
+    /** 是否斜体 */
+    get italic(): boolean;
+    constructor();
+    /** 获取根节点 */
+    getRootNode(): Token | this;
+    /**
+     * 将字符位置转换为行列号
+     * @param index 字符位置
+     */
+    posFromIndex(index: number): Position | undefined;
+    /**
+     * 获取当前节点的相对字符位置，或其第`j`个子节点的相对字符位置
+     * @param j 子节点序号
+     */
+    getRelativeIndex(j?: number): number;
+    /** 获取当前节点的绝对位置 */
+    getAbsoluteIndex(): number;
+    /**
+     * 是否是某种类型的节点
+     * @param type 节点类型
+     */
+    is<T extends Token>(type: string): this is T;
+    /**
+     * 是否是全同节点
+     * @param node 待比较的节点
+     * @throws `assert.AssertionError`
+     */
+    isEqualNode(node: AstNode): boolean;
+    /**
+     * 在后方批量插入兄弟节点
+     * @param nodes 插入节点
+     */
+    after(...nodes: (AstNodes | string)[]): void;
+    /**
+     * 在前方批量插入兄弟节点
+     * @param nodes 插入节点
+     */
+    before(...nodes: (AstNodes | string)[]): void;
+    /** 移除当前节点 */
+    remove(): void;
+    /**
+     * 将当前节点批量替换为新的节点
+     * @param nodes 插入节点
+     */
+    replaceWith(...nodes: (AstNodes | string)[]): void;
+    /**
+     * 是自身或后代节点
+     * @param node 待检测节点
+     */
+    contains(node: AstNode): boolean;
+    /**
+     * 添加事件监听
+     * @param types 事件类型
+     * @param listener 监听函数
+     * @param options 选项
+     * @param options.once 仅执行一次
+     */
+    addEventListener(types: string | string[], listener: (...args: any[]) => void, options?: {
+        once?: boolean;
+    }): void;
+    /**
+     * 移除事件监听
+     * @param types 事件类型
+     * @param listener 监听函数
+     */
+    removeEventListener(types: string | string[], listener: (...args: any[]) => void): void;
+    /**
+     * 移除事件的所有监听
+     * @param types 事件类型
+     */
+    removeAllEventListeners(types: string | string[]): void;
+    /**
+     * 列举事件监听
+     * @param type 事件类型
+     */
+    listEventListeners(type: string): Function[];
+    /**
+     * 触发事件
+     * @param e 事件对象
+     * @param data 事件数据
+     */
+    dispatchEvent(e: Event, data: unknown): void;
+    /** 获取所有祖先节点 */
+    getAncestors(): Token[];
+    /**
+     * 比较和另一个节点的相对位置
+     * @param other 待比较的节点
+     * @throws `RangeError` 不在同一个语法树
+     */
+    compareDocumentPosition(other: AstNodes): number;
+    /**
+     * 将行列号转换为字符位置
+     * @param top 行号
+     * @param left 列号
+     */
+    indexFromPos(top: number, left: number): number | undefined;
+    /** 获取当前节点的行列位置和大小 */
+    getBoundingClientRect(): Dimension & Position;
+    /** 销毁 */
+    destroy(): void;
+    /**
+     * 获取某一行的wikitext
+     * @param n 行号
+     */
+    getLine(n: number): string | undefined;
+}