wikiparser-node 1.9.3-b → 1.10.0

package/dist/index.js

@@ -0,0 +1,231 @@
+"use strict";
+/* eslint n/exports-style: 0 */
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const base_1 = require("./base");
+const debug_1 = require("./util/debug");
+const constants_1 = require("./util/constants");
+const string_1 = require("./util/string");
+const diff_1 = require("./util/diff");
+/**
+ * 从根路径require
+ * @param file 文件名
+ * @param dir 子路径
+ */
+const rootRequire = (file, dir) => require(path.isAbsolute(file) ? file : path.join('..', file.includes('/') ? '' : dir, file));
+/* NOT FOR BROWSER */
+const promises = [Promise.resolve()];
+let viewOnly = false;
+/* NOT FOR BROWSER END */
+const Parser = {
+    config: 'default',
+    i18n: undefined,
+    rules: base_1.rules,
+    /* NOT FOR BROWSER */
+    /** @implements */
+    get viewOnly() {
+        return viewOnly;
+    },
+    set viewOnly(value) {
+        if (viewOnly && !value) {
+            debug_1.Shadow.rev++;
+        }
+        viewOnly = value;
+    },
+    conversionTable: new Map(),
+    redirects: new Map(),
+    templates: new Map(),
+    warning: true,
+    debugging: false,
+    /* NOT FOR BROWSER END */
+    /** @implements */
+    getConfig() {
+        if (typeof this.config === 'string') {
+            this.config = rootRequire(this.config, 'config');
+            /* NOT FOR BROWSER */
+            const { config: { conversionTable, redirects } } = this;
+            if (conversionTable) {
+                this.conversionTable = new Map(conversionTable);
+            }
+            if (redirects) {
+                this.redirects = new Map(redirects);
+            }
+            /* NOT FOR BROWSER END */
+            return this.getConfig();
+        }
+        return {
+            ...this.config,
+            excludes: [],
+        };
+    },
+    /** @implements */
+    msg(msg, arg = '') {
+        if (typeof this.i18n === 'string') {
+            this.i18n = rootRequire(this.i18n, 'i18n');
+            return this.msg(msg, arg);
+        }
+        return msg && (this.i18n?.[msg] ?? msg).replace('$1', this.msg(arg));
+    },
+    /** @implements */
+    normalizeTitle(title, defaultNs = 0, include, config = Parser.getConfig(), halfParsed, decode = false, selfLink = false) {
+        const { Title } = require('./lib/title');
+        if (halfParsed) {
+            return new Title(title, defaultNs, config, decode, selfLink);
+        }
+        const { Token } = require('./src/index');
+        return debug_1.Shadow.run(() => {
+            const root = new Token(title, config);
+            root.type = 'root';
+            root.parseOnce(0, include).parseOnce();
+            const titleObj = new Title(root.toString(), defaultNs, config, decode, selfLink);
+            for (const key of ['main', 'fragment']) {
+                const str = titleObj[key];
+                if (str?.includes('\0')) {
+                    titleObj[key] = root.buildFromStr(str, constants_1.BuildMethod.Text);
+                }
+            }
+            /* NOT FOR BROWSER */
+            titleObj.conversionTable = this.conversionTable;
+            titleObj.redirects = this.redirects;
+            /* NOT FOR BROWSER END */
+            return titleObj;
+        });
+    },
+    /** @implements */
+    parse(wikitext, include, maxStage = constants_1.MAX_STAGE, config = Parser.getConfig()) {
+        wikitext = (0, string_1.tidy)(wikitext);
+        const { Token } = require('./src/index');
+        const root = debug_1.Shadow.run(() => {
+            const token = new Token(wikitext, config);
+            token.type = 'root';
+            try {
+                return token.parse(maxStage, include);
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    const file = path.join(__dirname, '..', 'errors', new Date().toISOString()), stage = token.getAttribute('stage');
+                    fs.writeFileSync(file, stage === constants_1.MAX_STAGE ? wikitext : token.toString());
+                    fs.writeFileSync(`${file}.err`, e.stack);
+                    fs.writeFileSync(`${file}.json`, JSON.stringify({ stage, include, config }, null, '\t'));
+                }
+                throw e;
+            }
+        });
+        /* NOT FOR BROWSER */
+        if (this.debugging) {
+            let restored = root.toString(), process = 'parsing';
+            if (restored === wikitext) {
+                const entities = { lt: '<', gt: '>', amp: '&' };
+                restored = root.print().replace(/<[^<]+?>|&([lg]t|amp);/gu, (_, s) => s ? entities[s] : '');
+                process = 'printing';
+            }
+            if (restored !== wikitext) {
+                const { 0: cur, length } = promises;
+                promises.unshift((async () => {
+                    await cur;
+                    this.error(`Original wikitext is altered when ${process}!`);
+                    return (0, diff_1.diff)(wikitext, restored, length);
+                })());
+            }
+        }
+        /* NOT FOR BROWSER END */
+        return root;
+    },
+    /* NOT FOR BROWSER */
+    /** @implements */
+    warn(msg, ...args) {
+        if (this.warning) {
+            console.warn(chalk.yellow(msg), ...args);
+        }
+    },
+    /** @implements */
+    debug(msg, ...args) {
+        if (this.debugging) {
+            console.debug(chalk.blue(msg), ...args);
+        }
+    },
+    error: diff_1.error,
+    info: diff_1.info,
+    /** @implements */
+    log(f) {
+        if (typeof f === 'function') {
+            console.log(String(f));
+        }
+    },
+    /** @implements */
+    async clearCache() {
+        const promise = (0, diff_1.cmd)('npm', ['run', 'build:core']), entries = [
+            ...Object.entries(constants_1.classes),
+            ...Object.entries(constants_1.mixins),
+            ...Object.entries(constants_1.parsers),
+        ];
+        for (const [, filePath] of entries) {
+            try {
+                delete require.cache[require.resolve(filePath)];
+            }
+            catch { }
+        }
+        await promise;
+        for (const [name, filePath] of entries) {
+            if (name in global) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                Object.assign(global, { [name]: require(filePath)[name] });
+            }
+        }
+        this.info('已重新加载Parser');
+    },
+    /** @implements */
+    isInterwiki(title, { interwiki } = Parser.getConfig()) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        /^(zh|en)\s*:/diu;
+        return interwiki.length > 0
+            ? new RegExp(String.raw `^(${interwiki.join('|')})\s*:`, 'diu')
+                .exec(title.replace(/_/gu, ' ').replace(/^\s*:?\s*/u, ''))
+            : null;
+    },
+    /** @implements */
+    reparse(date = '') {
+        const main = fs.readdirSync(path.join(__dirname, '..', 'errors'))
+            .find(name => name.startsWith(date) && name.endsWith('Z'));
+        if (!main) {
+            throw new RangeError(`找不到对应时间戳的错误记录：${date}`);
+        }
+        const file = path.join(__dirname, '..', 'errors', main), wikitext = fs.readFileSync(file, 'utf8');
+        const { stage, include, config } = require(`${file}.json`), { Token } = require('./src/index');
+        debug_1.Shadow.run(() => {
+            const halfParsed = stage < constants_1.MAX_STAGE, token = new Token(halfParsed ? wikitext : (0, string_1.tidy)(wikitext), config);
+            token.type = 'root';
+            if (halfParsed) {
+                token.setAttribute('stage', stage);
+                token.parseOnce(stage, include);
+            }
+            else {
+                token.parse(undefined, include);
+            }
+            fs.unlinkSync(file);
+            fs.unlinkSync(`${file}.err`);
+            fs.unlinkSync(`${file}.json`);
+        });
+    },
+};
+const def = {
+    default: { value: Parser },
+}, enumerable = new Set([
+    'normalizeTitle',
+    'parse',
+    /* NOT FOR BROWSER */
+    'conversionTable',
+    'redirects',
+    'warning',
+    'debugging',
+    'isInterwiki',
+]);
+for (const key in Parser) {
+    if (!enumerable.has(key)) {
+        def[key] = { enumerable: false };
+    }
+}
+Object.defineProperties(Parser, def);
+exports.default = Parser;
+module.exports = Parser;

package/dist/internal.d.ts

@@ -0,0 +1,46 @@
+export type { AstNodes, } from './lib/node';
+export type * from './lib/text';
+export type { Token } from './src/index';
+export type * from './src/redirect';
+export type * from './src/link/redirectTarget';
+export type * from './src/onlyinclude';
+export type * from './src/nowiki/noinclude';
+export type * from './src/tagPair/include';
+export type * from './src/nowiki/comment';
+export type * from './src/atom';
+export type { AttributeToken } from './src/attribute';
+export type * from './src/attributes';
+export type * from './src/tagPair/ext';
+export type * from './src/hidden';
+export type * from './src/arg';
+export type * from './src/syntax';
+export type * from './src/parameter';
+export type * from './src/transclude';
+export type * from './src/heading';
+export type * from './src/html';
+export type { TdToken } from './src/table/td';
+export type * from './src/table/tr';
+export type { TableToken } from './src/table/index';
+export type * from './src/nowiki/hr';
+export type * from './src/nowiki/doubleUnderscore';
+export type * from './src/link/index';
+export type * from './src/link/category';
+export type { ImageParameterToken } from './src/imageParameter';
+export type * from './src/link/file';
+export type * from './src/link/galleryImage';
+export type * from './src/nowiki/quote';
+export type * from './src/magicLink';
+export type * from './src/extLink';
+export type * from './src/nowiki/dd';
+export type * from './src/nowiki/list';
+export type * from './src/converterFlags';
+export type * from './src/converterRule';
+export type * from './src/converter';
+export type * from './src/nowiki/index';
+export type * from './src/pre';
+export type * from './src/paramTag/index';
+export type * from './src/paramTag/inputbox';
+export type * from './src/nested';
+export type * from './src/gallery';
+export type * from './src/imagemapLink';
+export type * from './src/imagemap';

package/dist/lib/element.d.ts

@@ -0,0 +1,125 @@
+import { AstNode } from './node';
+import type { LintError, AST } from '../base';
+import type { AstNodes, AstText, Token } from '../internal';
+/** 类似HTMLElement */
+export declare abstract class AstElement extends AstNode {
+    #private;
+    readonly name?: string;
+    readonly data: undefined;
+    /** 子节点总数 */
+    get length(): number;
+    set length(n: number);
+    /** 全部非文本子节点 */
+    get children(): Token[];
+    /** 首位非文本子节点 */
+    get firstElementChild(): Token | undefined;
+    /** 末位非文本子节点 */
+    get lastElementChild(): Token | undefined;
+    /** 非文本子节点总数 */
+    get childElementCount(): number;
+    /** 父节点 */
+    get parentElement(): Token | undefined;
+    /** AstElement.prototype.text()的getter写法 */
+    get outerText(): string;
+    /** 不可见 */
+    get hidden(): boolean;
+    /** 内部高度 */
+    get clientHeight(): number | undefined;
+    /** 内部宽度 */
+    get clientWidth(): number | undefined;
+    constructor();
+    /** 合并相邻的文本子节点 */
+    normalize(): void;
+    /**
+     * 移除子节点
+     * @param i 移除位置
+     */
+    removeAt(i: number): AstNodes;
+    /**
+     * 插入子节点
+     * @param node 待插入的子节点
+     * @param i 插入位置
+     * @throws `RangeError` 不能插入祖先或子节点
+     */
+    insertAt<T extends AstNodes>(node: T, i?: number): T;
+    /**
+     * 最近的祖先节点
+     * @param selector 选择器
+     */
+    closest<T = Token>(selector: string): T | undefined;
+    /**
+     * 符合选择器的第一个后代节点
+     * @param selector 选择器
+     */
+    querySelector<T = Token>(selector: string): T | undefined;
+    /**
+     * 符合选择器的所有后代节点
+     * @param selector 选择器
+     */
+    querySelectorAll<T = Token>(selector: string): T[];
+    /**
+     * 在末尾批量插入子节点
+     * @param elements 插入节点
+     */
+    append(...elements: (AstNodes | string)[]): void;
+    /**
+     * 批量替换子节点
+     * @param elements 新的子节点
+     */
+    replaceChildren(...elements: (AstNodes | string)[]): void;
+    /**
+     * 修改文本子节点
+     * @param str 新文本
+     * @param i 子节点位置
+     * @throws `RangeError` 对应位置的子节点不是文本节点
+     */
+    setText(str: string, i?: number): string;
+    /**
+     * 保存为JSON
+     * @param file 文件名
+     * @param start
+     */
+    json(file?: string, start?: number): AST;
+    /**
+     * 检查是否符合选择器
+     * @param selector 选择器
+     */
+    matches<T>(selector?: string): this is T;
+    /**
+     * 类型选择器
+     * @param types
+     */
+    getElementByTypes<T = Token>(types: string): T | undefined;
+    /**
+     * id选择器
+     * @param id id名
+     */
+    getElementById<T = Token>(id: string): T | undefined;
+    /**
+     * 类选择器
+     * @param className 类名之一
+     */
+    getElementsByClassName<T = Token>(className: string): T[];
+    /**
+     * 标签名选择器
+     * @param tag 标签名
+     */
+    getElementsByTagName<T = Token>(tag: string): T[];
+    /**
+     * 在开头批量插入子节点
+     * @param elements 插入节点
+     */
+    prepend(...elements: (AstNodes | string)[]): void;
+    /**
+     * 移除子节点
+     * @param node 子节点
+     */
+    removeChild<T extends AstNodes>(node: T): T;
+    /**
+     * 在指定位置前插入子节点
+     * @param child 插入节点
+     * @param reference 指定位置处的子节点
+     */
+    insertBefore(child: string, reference?: AstNodes): AstText;
+    insertBefore<T extends AstNodes>(child: T, reference?: AstNodes): T;
+}