wikiparser-node 1.3.9-b → 1.3.9

package/dist/src/arg.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgToken = void 0;
+const string_1 = require("../util/string");
+const lint_1 = require("../util/lint");
+const constants_1 = require("../util/constants");
+const debug_1 = require("../util/debug");
+const Parser = require("../index");
+const index_1 = require("./index");
+const atom_1 = require("./atom");
+const hidden_1 = require("./hidden");
+/**
+ * `{{{}}}`包裹的参数
+ * @classdesc `{childNodes: [AtomToken, ?Token, ...HiddenToken]}`
+ */
+class ArgToken extends index_1.Token {
+    type = 'arg';
+    /** 预设值 */
+    get default() {
+        return this.childNodes[1]?.text() ?? false;
+    }
+    /* NOT FOR BROWSER */
+    set default(value) {
+        this.setDefault(value);
+    }
+    /* NOT FOR BROWSER END */
+    /** @param parts 以'|'分隔的各部分 */
+    constructor(parts, config = Parser.getConfig(), accum = []) {
+        super(undefined, config, accum, {
+            AtomToken: 0, Token: 1, HiddenToken: '2:',
+        });
+        for (let i = 0; i < parts.length; i++) {
+            if (i === 0) {
+                const token = new atom_1.AtomToken(parts[i], 'arg-name', config, accum, {
+                    'Stage-2': ':', '!HeadingToken': '',
+                });
+                super.insertAt(token);
+            }
+            else if (i > 1) {
+                const token = new hidden_1.HiddenToken(parts[i], config, accum, {
+                    'Stage-2': ':', '!HeadingToken': '',
+                });
+                super.insertAt(token);
+            }
+            else {
+                const token = new index_1.Token(parts[i], config, accum);
+                token.type = 'arg-default';
+                token.setAttribute('stage', 2);
+                super.insertAt(token);
+            }
+        }
+        this.protectChildren(0);
+    }
+    /** @private */
+    toString(omit) {
+        return omit && this.matchesTypes(omit) ? '' : `{{{${super.toString(omit, '|')}}}}`;
+    }
+    /** @override */
+    text() {
+        return `{{{${(0, string_1.text)(this.childNodes.slice(0, 2), '|')}}}}`;
+    }
+    /** @private */
+    getAttribute(key) {
+        return key === 'padding' ? 3 : super.getAttribute(key);
+    }
+    /** @private */
+    getGaps() {
+        return 1;
+    }
+    /** @override */
+    lint(start = this.getAbsoluteIndex()) {
+        if (!this.getAttribute('include')) {
+            return [(0, lint_1.generateForSelf)(this, { start }, 'unexpected template argument')];
+        }
+        const { childNodes: [argName, argDefault, ...rest] } = this, errors = argName.lint(start + 3);
+        if (argDefault) {
+            errors.push(...argDefault.lint(start + 4 + String(argName).length));
+        }
+        if (rest.length > 0) {
+            const rect = { start, ...this.getRootNode().posFromIndex(start) };
+            errors.push(...rest.map(child => {
+                const error = (0, lint_1.generateForChild)(child, rect, 'invisible content inside triple braces');
+                return {
+                    ...error,
+                    startIndex: error.startIndex - 1,
+                    startCol: error.startCol - 1,
+                };
+            }));
+        }
+        return errors;
+    }
+    /** @override */
+    print() {
+        return super.print({ pre: '{{{', post: '}}}', sep: '|' });
+    }
+    /** @override */
+    json() {
+        return {
+            ...super.json(),
+            default: this.default,
+        };
+    }
+    /* NOT FOR BROWSER */
+    /** @override */
+    cloneNode() {
+        const [name, ...cloned] = this.cloneChildNodes();
+        return debug_1.Shadow.run(() => {
+            const token = new ArgToken([''], this.getAttribute('config'));
+            token.firstChild.safeReplaceWith(name);
+            token.append(...cloned);
+            token.afterBuild();
+            return token;
+        });
+    }
+    /** 设置name */
+    #setName() {
+        this.setAttribute('name', this.firstChild.text().trim());
+    }
+    /** @private */
+    afterBuild() {
+        this.#setName();
+        const /** @implements */ argListener = ({ prevTarget }) => {
+            if (prevTarget === this.firstChild) {
+                this.#setName();
+            }
+        };
+        this.addEventListener(['remove', 'insert', 'replace', 'text'], argListener);
+    }
+    /** 移除无效部分 */
+    removeRedundant() {
+        debug_1.Shadow.run(() => {
+            for (let i = this.length - 1; i > 1; i--) {
+                super.removeAt(i);
+            }
+        });
+    }
+    /**
+     * @override
+     * @param i 移除位置
+     */
+    removeAt(i) {
+        if (i === 1) {
+            this.removeRedundant();
+        }
+        return super.removeAt(i);
+    }
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     */
+    insertAt(token, i = this.length) {
+        i += i < 0 ? this.length : 0;
+        if (i > 1) {
+            this.constructorError('不可插入多余的子节点');
+        }
+        else if (typeof token === 'string') {
+            this.constructorError('不可插入文本节点');
+        }
+        super.insertAt(token, i);
+        if (i === 1) {
+            token.type = 'arg-default';
+        }
+        return token;
+    }
+    /**
+     * 设置参数名
+     * @param name 新参数名
+     */
+    setName(name) {
+        const { childNodes } = Parser.parse(name, this.getAttribute('include'), 2, this.getAttribute('config'));
+        this.firstChild.replaceChildren(...childNodes);
+    }
+    /**
+     * 设置预设值
+     * @param value 预设值
+     */
+    setDefault(value) {
+        if (value === false) {
+            this.removeAt(1);
+            return;
+        }
+        const root = Parser.parse(value, this.getAttribute('include'), undefined, this.getAttribute('config')), { childNodes: [, oldDefault] } = this;
+        if (oldDefault) {
+            oldDefault.replaceChildren(...root.childNodes);
+        }
+        else {
+            root.type = 'arg-default';
+            this.insertAt(root);
+        }
+    }
+}
+exports.ArgToken = ArgToken;
+constants_1.classes['ArgToken'] = __filename;

package/dist/src/atom.d.ts

@@ -0,0 +1,12 @@
+import * as Parser from '../index';
+import { Token } from './index';
+declare type AtomTypes = 'arg-name' | 'attr-key' | 'attr-value' | 'ext-attr-dirty' | 'html-attr-dirty' | 'table-attr-dirty' | 'converter-flag' | 'converter-rule-variant' | 'converter-rule-to' | 'converter-rule-from' | 'invoke-function' | 'invoke-module' | 'template-name' | 'link-target' | 'param-line';
+/** 不会被继续解析的plain Token */
+export declare class AtomToken extends Token {
+    type: AtomTypes;
+    /** @class */
+    constructor(wikitext: string | undefined, type: AtomTypes, config?: Parser.Config, accum?: Token[], acceptable?: Acceptable);
+    /** @override */
+    cloneNode(): this;
+}
+export {};

package/dist/src/atom.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtomToken = void 0;
+const debug_1 = require("../util/debug");
+const constants_1 = require("../util/constants");
+const Parser = require("../index");
+const index_1 = require("./index");
+/** 不会被继续解析的plain Token */
+class AtomToken extends index_1.Token {
+    /** @class */
+    constructor(wikitext, type, config = Parser.getConfig(), accum = [], acceptable) {
+        super(wikitext, config, accum, acceptable);
+        this.type = type;
+    }
+    /* NOT FOR BROWSER */
+    /** @override */
+    cloneNode() {
+        const cloned = this.cloneChildNodes(), config = this.getAttribute('config'), acceptable = this.getAttribute('acceptable');
+        return debug_1.Shadow.run(() => {
+            const token = new AtomToken(undefined, this.type, config, [], acceptable);
+            token.append(...cloned);
+            return token;
+        });
+    }
+}
+exports.AtomToken = AtomToken;
+constants_1.classes['AtomToken'] = __filename;

package/dist/src/attribute.d.ts

@@ -0,0 +1,88 @@
+import * as Parser from '../index';
+import { Token } from './index';
+import { AtomToken } from './atom';
+import type { LintError } from '../base';
+import type { AttributesToken } from '../internal';
+export type AttributeTypes = 'ext-attr' | 'html-attr' | 'table-attr';
+declare const AttributeToken_base: ((abstract new (...args: any[]) => {
+    removeAt(): never;
+    insertAt(token: string, i?: number | undefined): Parser.AstText;
+    insertAt<T extends Parser.AstNodes>(token: T, i?: number | undefined): T;
+    readonly length: number;
+    toString(omit?: Set<string> | undefined, separator?: string | undefined): string;
+    text(separator?: string | undefined): string;
+    lint(start?: number | undefined): Parser.LintError[];
+    afterBuild(): void;
+    getAttribute<T_1 extends string>(key: T_1): TokenAttributeGetter<T_1>;
+    setAttribute<T_2 extends string>(key: T_2, value: TokenAttributeSetter<T_2>): void;
+    addEventListener(events: string | string[], listener: AstListener): void;
+    replaceChildren(...elements: (string | Parser.AstNodes)[]): void;
+    constructorError(msg: string): never;
+}) & {
+    readonly fixed: true;
+}) & typeof Parser.Token;
+/**
+ * 扩展和HTML标签属性
+ * @classdesc `{childNodes: [AtomToken, Token|AtomToken]}`
+ */
+export declare class AttributeToken extends AttributeToken_base {
+    #private;
+    type: AttributeTypes;
+    readonly name: string;
+    readonly tag: string;
+    readonly childNodes: [AtomToken, Token];
+    abstract get children(): [AtomToken, Token];
+    abstract get firstChild(): AtomToken;
+    abstract get firstElementChild(): AtomToken;
+    abstract get lastChild(): Token;
+    abstract get lastElementChild(): Token;
+    abstract get parentNode(): AttributesToken | undefined;
+    abstract get parentElement(): AttributesToken | undefined;
+    abstract get nextSibling(): AtomToken | this | undefined;
+    abstract get nextElementSibling(): AtomToken | this | undefined;
+    abstract get previousSibling(): AtomToken | this | undefined;
+    abstract get previousElementSibling(): AtomToken | this | undefined;
+    /** 引号是否匹配 */
+    get balanced(): boolean;
+    set balanced(value: boolean);
+    /** getValue()的getter */
+    get value(): string | true;
+    set value(value: string | true);
+    /**
+     * @param type 标签类型
+     * @param tag 标签名
+     * @param key 属性名
+     * @param equal 等号
+     * @param value 属性值
+     * @param quotes 引号
+     */
+    constructor(type: AttributeTypes, tag: string, key: string, equal?: string, value?: string, quotes?: readonly [string?, string?], config?: Parser.Config, accum?: Token[]);
+    /** @override */
+    text(): string;
+    /** @override */
+    lint(start?: number): LintError[];
+    /** 获取属性值 */
+    getValue(): string | true;
+    /** @override */
+    print(): string;
+    /** @override */
+    cloneNode(): this;
+    /** 转义等号 */
+    escape(): void;
+    /** 闭合引号 */
+    close(): void;
+    /**
+     * 设置属性值
+     * @param value 参数值
+     * @throws `RangeError` 扩展标签属性不能包含 ">"
+     * @throws `RangeError` 同时包含单引号和双引号
+     */
+    setValue(value: string | boolean): void;
+    /**
+     * 修改属性名
+     * @param key 新属性名
+     * @throws `Error` title和alt属性不能更名
+     */
+    rename(key: string): void;
+}
+export {};