@e-mc/document 0.0.1

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@e-mc/document",
+  "version": "0.0.1",
+  "description": "Document constructor for e-mc.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anpham6/e-mc.git",
+    "directory": "src/document"
+  },
+  "keywords": [
+    "squared",
+    "squared-functions"
+  ],
+  "author": "An Pham <anpham6@gmail.com>",
+  "license": "BSD 3-Clause",
+  "homepage": "https://github.com/anpham6/e-mc#readme",
+  "dependencies": {
+    "@e-mc/core": "0.0.1",
+    "@e-mc/db": "0.0.1",
+    "chalk": "4.1.2",
+    "htmlparser2": "^8.0.1",
+    "jimp": "^0.22.7",
+    "js-yaml": "^4.1.0",
+    "picomatch": "^2.3.1"
+  }
+}

package/parse/document.d.ts

@@ -0,0 +1,237 @@
+import type { XmlTagNode as IXmlTagNode, TagAppend, TagData } from '../../types/lib/squared';
+
+// @ts-ignore
+import type { ParserOptions } from 'htmlparser2';
+// @ts-ignore
+import type { AnyNode, Element } from 'domhandler';
+
+export interface IGNORE_FLAG {
+    NONE: 0;
+    INTERIOR: 1;
+    LOCATOR: 2;
+}
+
+export interface ParserAction {
+    parser?: ParserOptions;
+    outDom?: AnyNode[];
+}
+
+export interface SourceIndex {
+    startIndex: number;
+    endIndex: number;
+}
+
+export interface SourceContent extends SourceIndex {
+    outerXml: string;
+    type?: "node" | "comment" | "cdata" | "block";
+}
+
+export interface SourceTagNode extends SourceContent, TagData {
+    id?: string;
+    ignoreCase?: boolean;
+}
+
+export interface XmlTagNode extends IXmlTagNode, Partial<SourceIndex> {}
+
+export type AttributeMap = Map<string, unknown>;
+export type AttributeList = [string, unknown][];
+export type TagOffsetMap = ObjectMap<Undef<number>>;
+export type WriteResult = [string, string, Null<Error>?];
+export type SaveResult = [string, Null<Error>?];
+export type XmlWriterOptions = ParserAction;
+
+export interface ParserResult extends Partial<TagData>, ParserAction {
+    element: Null<Element>;
+    error: Null<Error>;
+}
+
+export interface ReplaceOptions extends SourceIndex {
+    append?: TagAppend;
+    remove?: boolean;
+}
+
+export interface FindElementOptions extends ParserAction {
+    document?: string;
+    id?: string;
+    locatorAttr?: string;
+    tagCount?: number;
+}
+
+export interface TagOffsetOptions extends ParserAction {
+    ignoreCase?: boolean;
+    ignoreTagName?: string;
+    ignoreTagGroup?: string[];
+}
+
+export interface TagNodeOptions {
+    tagVoid?: boolean;
+}
+
+export interface TagNodeByIdOptions extends TagNodeOptions {
+    tagName?: string;
+}
+
+export interface XmlElementOptions extends TagNodeOptions, ParserAction {}
+
+export interface DomWriterOptions extends ParserAction {
+    normalize?: boolean | string;
+    ignoreTagGroup?: string[];
+    escapeEntities?: boolean;
+    stripComments?: boolean | string;
+}
+
+export interface ReplaceMatchOptions {
+    pattern?: RegExp;
+    trimLeading?: boolean;
+    trimTrailing?: boolean;
+}
+
+export interface NormalizeOptions {
+    newline?: string;
+    ignoreChar?: string;
+    ignoreTagGroup?: string[];
+    escapeEntities?: boolean;
+}
+
+export class IXmlBase {
+    newline: string;
+    readonly documentName: string;
+    write(...args: unknown[]): unknown;
+    save(...args: unknown[]): unknown;
+    reset(): void;
+    get nameOfId(): string;
+    get patternId(): RegExp;
+    get modified(): boolean;
+}
+
+export class IXmlWriter extends IXmlBase {
+    elements: XmlTagNode[];
+    parser?: ParserOptions;
+    ignoreTagName?: string;
+    ignoreTagGroup?: string[];
+    readonly rootName?: string;
+    readonly ignoreCaseTagName?: boolean;
+    init(offsetMap?: TagOffsetMap): void;
+    getInvalidArea(): Undef<SourceContent[]>;
+    ignoreFlag(...values: number[]): void;
+    insertNodes(nodes?: XmlTagNode[]): void;
+    fromNode(node: XmlTagNode, append?: TagAppend): IXmlElement;
+    newElement(node: XmlTagNode): IXmlElement;
+    append(node: XmlTagNode): Null<IXmlElement>;
+    write(element: IXmlElement): boolean;
+    save(): string;
+    close(): string;
+    update(node: XmlTagNode, outerXml: string, append?: TagAppend, offsetMap?: Null<TagOffsetMap>): void;
+    increment(nodes: XmlTagNode[], offset?: number): void;
+    decrement(node: XmlTagNode, offset?: number, remove?: boolean): XmlTagNode[];
+    renameTag(node: XmlTagNode, tagName: string): void;
+    indexTag(tagName: string, append?: TagAppend, offset?: number): void;
+    resetTag(tagName: string): void;
+    ignoreTag(value: string): void;
+    resetPosition(startIndex?: number): void;
+    getElementById(id: string, ignoreCase?: boolean, options?: TagNodeByIdOptions): Undef<SourceTagNode>;
+    getElementsByTagName(tagName: string, ignoreCase?: boolean, options?: TagNodeOptions): SourceTagNode[];
+    setRawString(targetXml: string, outerXml: string): string;
+    getRawString(index: SourceIndex): string;
+    spliceRawString(content: SourceContent, reset?: boolean): string;
+    getComments(): Null<SourceContent[]>;
+    hasErrors(): boolean;
+    get newId(): string;
+    get patternIgnore(): Null<RegExp>;
+    set source(value);
+    get source(): string;
+}
+
+export interface XmlWriterConstructor {
+    readonly PATTERN_ATTRNAME: string;
+    readonly PATTERN_ATTRVALUE: string;
+    readonly PATTERN_TAGNAME: string;
+    readonly PATTERN_TAGOPEN: string;
+    readonly PATTERN_QUOTEVALUE: string;
+    readonly PATTERN_COMMENT: string;
+    readonly PATTERN_TRAILINGSPACE: string;
+    replaceMatch(match: RegExpMatchArray, source: string, content: NumString, options: ReplaceMatchOptions): string;
+    replaceMatch(match: RegExpMatchArray, source: string, content?: NumString, pattern?: RegExp): string;
+    escapeXmlString(value: string, ampersand?: boolean): string;
+    escapeAttributes(source: string): string;
+    getNewlineString(leading: string, trailing: string, newline?: string): string;
+    findCloseTag(source: string, startIndex?: number): number;
+    findElement(source: string, node: XmlTagNode, options?: FindElementOptions): ParserResult;
+    getTagOffset(source: string, options?: TagOffsetOptions): TagOffsetMap;
+    getTagOffset(source: string, replacement?: string, options?: TagOffsetOptions): TagOffsetMap;
+    getNodeId(node: XmlTagNode, document: string): string;
+    getNameOfId(document: string): string;
+    getCommentsAndCDATA(source: string, tagPattern: unknown, ignoreCase: boolean, stripXml: true): string;
+    getCommentsAndCDATA(source: string, tagPattern?: StringOfArray | [Undef<string>, Undef<string[]>], ignoreCase?: boolean, stripXml?: boolean): SourceContent[];
+    isEqual(node: XmlTagNode, other: XmlTagNode, ignoreCase: boolean): boolean;
+    isEqual(node: XmlTagNode, other: XmlTagNode, documentName?: string, ignoreCase?: boolean): boolean;
+    isIndex(value: Undef<number>): value is number;
+    isCount(value: Undef<number>): value is number;
+    isSpace(ch: string): boolean;
+    readonly prototype: IXmlWriter;
+    new(documentName: string, source: string, elements: XmlTagNode[], options?: XmlWriterOptions): IXmlWriter;
+}
+
+export class IXmlElement extends IXmlBase {
+    TAG_VOID: string[];
+    parser?: ParserOptions;
+    readonly node: XmlTagNode;
+    setAppend(value?: TagAppend): void;
+    parseOuterXml(value?: string, tagVoid?: boolean): [string, string, boolean];
+    getTagOffset(replacement?: string, options?: TagOffsetOptions): Undef<TagOffsetMap>;
+    setAttribute(name: string, value: string): void;
+    getAttribute(name: string): Optional<string>;
+    removeAttribute(...names: string[]): void;
+    hasAttribute(name: string): boolean;
+    hasModifiedContent(): boolean;
+    write(source: string, invalid?: SourceIndex[]): WriteResult;
+    save(source: string, invalid?: SourceIndex[]): SaveResult;
+    replace(source: string, options: ReplaceOptions): WriteResult;
+    findIndexOf(source: string): Undef<SourceIndex>;
+    getOuterContent(): [string, AttributeList, string];
+    getInnerOffset(tagName: string): number;
+    hasPosition(): boolean;
+    set id(value: string);
+    get id(): string;
+    set tagName(value: string);
+    get tagName(): string;
+    get tagVoid(): boolean;
+    set innerXml(value: string);
+    get innerXml(): string;
+    get outerXml(): string;
+    set remove(value);
+    get remove(): boolean;
+    get append(): Undef<TagAppend>;
+    set tagOffset(value: Undef<TagOffsetMap>);
+    get tagOffset(): Undef<TagOffsetMap>;
+    get ignoreCase(): boolean;
+}
+
+export interface XmlElementConstructor {
+    writeAttributes(attrs: AttributeMap | AttributeList, escapeEntities?: boolean): string;
+    readonly prototype: IXmlElement;
+    new(documentName: string, node: XmlTagNode, attributes?: PlainObject, options?: XmlElementOptions): IXmlElement;
+    new(documentName: string, node: XmlTagNode, attributes?: PlainObject, tagVoid?: boolean, parser?: ParserOptions): IXmlElement;
+}
+
+export class IDomWriter extends IXmlWriter {
+    documentElement: Null<XmlTagNode>;
+    readonly initOpts: DomWriterOptions;
+}
+
+export interface DomWriterConstructor extends XmlWriterConstructor {
+    hasInnerXml(tagName: string): boolean;
+    normalize(source: string, options: NormalizeOptions): string;
+    normalize(source: string, newline?: string, ignoreChar?: string, escapeEntities?: boolean): string;
+    getDocumentElement(source: string, parser?: ParserOptions): ParserResult;
+    getElementsByTagName(tagName: string | ((name: string) => boolean), nodes: ArrayOf<AnyNode>, recurse?: boolean, limit?: number): Element[];
+    readonly prototype: IDomWriter;
+    new(documentName: string, source: string, elements: XmlTagNode[], options?: DomWriterOptions): IDomWriter;
+    new(documentName: string, source: string, elements: XmlTagNode[], normalize?: boolean | string, escapeEntities?: boolean, parser?: ParserOptions): IDomWriter;
+}
+
+export class IHtmlElement extends IXmlElement {}
+
+export interface HtmlElementConstructor extends XmlElementConstructor {
+    new(documentName: string, node: XmlTagNode, attributes?: PlainObject, options?: ParserAction): IHtmlElement;
+}

package/parse/dom.d.ts

@@ -0,0 +1,9 @@
+import type { IGNORE_FLAG, DomWriterConstructor, HtmlElementConstructor } from './document';
+
+declare namespace dom {
+    const IGNORE_FLAG: IGNORE_FLAG;
+    const DomWriter: DomWriterConstructor;
+    const HtmlElement: HtmlElementConstructor;
+}
+
+export = dom;

package/parse/dom.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IGNORE_FLAG = exports.HtmlElement = exports.DomWriter = void 0;
+const htmlparser2 = require("htmlparser2");
+const domhandler = require("domhandler");
+const domutils = require("domutils");
+const types_1 = require("../../types");
+const util_1 = require("../util");
+const index_1 = require("./index");
+Object.defineProperty(exports, "IGNORE_FLAG", { enumerable: true, get: function () { return index_1.IGNORE_FLAG; } });
+const Parser = htmlparser2.Parser;
+const DomHandler = domhandler.DomHandler;
+const TAG_VOID = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
+const REGEXP_VOID = TAG_VOID.map(tagName => new RegExp(`(\\s*)</${tagName}\\s*>` + index_1.XmlWriter.PATTERN_TRAILINGSPACE, 'gi'));
+const REGEXP_TAGNAME = new RegExp(`^${index_1.XmlWriter.PATTERN_TAGNAME}$`);
+const PARSER_OPTIONS = Object.freeze({ xmlMode: false, decodeEntities: false });
+class DomWriter extends index_1.XmlWriter {
+    static hasInnerXml(tagName) {
+        return !TAG_VOID.includes(tagName);
+    }
+    static normalize(source, newline, ignoreChar = '', escapeEntities) {
+        let ignoreTagGroup;
+        if ((0, types_1.isObject)(newline)) {
+            ({ newline, ignoreChar = '', ignoreTagGroup, escapeEntities } = newline);
+        }
+        for (const tag of REGEXP_VOID) {
+            source = source.replace(tag, (...capture) => index_1.XmlWriter.getNewlineString(capture[1], capture[2], newline));
+        }
+        const tagGroup = [];
+        if (ignoreTagGroup) {
+            for (let i = 0, length = ignoreTagGroup.length; i < length; i += 2) {
+                const start = ignoreTagGroup[i];
+                if (start[0] === '<') {
+                    tagGroup.push(new RegExp('^' + (0, types_1.escapePattern)(start)));
+                }
+                const end = ignoreTagGroup[i + 1];
+                if (end?.[end.length - 1] === '>') {
+                    tagGroup.push(new RegExp((0, types_1.escapePattern)(start) + '$'));
+                }
+            }
+        }
+        const pattern = new RegExp(`<(?:!--[\\S\\s]*?--|([^\\s<>/${ignoreChar}]+)(${index_1.XmlWriter.PATTERN_TAGOPEN}*?)(\\s*\\/?\\s*)|\\/([^\\s>]+)(\\s*))>`, 'g');
+        let match;
+        while (match = pattern.exec(source)) {
+            let tag;
+            if (match[1]) {
+                if (!REGEXP_TAGNAME.test(match[1])) {
+                    if (match[0][1] === '!') {
+                        if (match[1].toUpperCase() === '!DOCTYPE') {
+                            continue;
+                        }
+                        tag = '<!--' + match[1].substring(1) + match[2] + '-->';
+                    }
+                    else if (tagGroup.length === 0 || !tagGroup.some(item => item.test(match[0]))) {
+                        tag = index_1.XmlWriter.escapeXmlString(match[0]);
+                    }
+                }
+                else {
+                    const trailing = match[match.length - 3];
+                    if (escapeEntities) {
+                        const outerTag = '<' + match[1] + match[2] + '>';
+                        tag = index_1.XmlWriter.escapeAttributes(outerTag);
+                        if (!trailing && tag === outerTag) {
+                            continue;
+                        }
+                    }
+                    else if (trailing) {
+                        tag = '<' + match[1] + match[2] + '>';
+                    }
+                }
+            }
+            else if (match[7]) {
+                if (!REGEXP_TAGNAME.test(match[7])) {
+                    tag = `<!--${match[7]}-->`;
+                }
+                else if (match[8]) {
+                    tag = `</${match[8]}>`;
+                }
+            }
+            if (tag) {
+                source = source.substring(0, match.index) + tag + source.substring(match.index + match[0].length);
+                pattern.lastIndex += tag.length - match[0].length;
+            }
+        }
+        pattern.lastIndex = 0;
+        return source;
+    }
+    static getDocumentElement(source, parser) {
+        const result = { element: null, error: null };
+        new Parser(new DomHandler((err, dom) => {
+            if (!err) {
+                result.element = domutils.findOne(elem => elem.tagName === "html" /* VALUES.ROOT */, dom);
+            }
+            else {
+                result.error = err;
+            }
+        }, { withStartIndices: true, withEndIndices: true }), { decodeEntities: false, ...parser, xmlMode: false }).end(source);
+        return result;
+    }
+    static getElementsByTagName(tagName, nodes, recurse, limit) {
+        return domutils.getElementsByTagName(tagName, nodes, recurse, limit);
+    }
+    constructor(documentName, source, elements, options, escapeEntities, parser) {
+        let normalize, stripComments, ignoreTagGroup;
+        if ((0, types_1.isObject)(options)) {
+            ({ normalize, escapeEntities, stripComments, ignoreTagGroup, parser } = options);
+        }
+        else {
+            options = { normalize: options, escapeEntities, parser };
+        }
+        parser || (parser = { ...PARSER_OPTIONS });
+        super(documentName, source, elements, { parser });
+        this.documentElement = null;
+        this.ignoreTagName = "title|style|script" /* VALUES.IGNORE_TAGNAME */;
+        this.rootName = "html" /* VALUES.ROOT */;
+        this.ignoreCaseTagName = true;
+        const items = [];
+        let outerXml = '', documentElement, offsetMap, startIndex = -1;
+        for (const item of elements) {
+            if (!item.ignoreCase) {
+                item.tagName = item.tagName.toLowerCase();
+                item.ignoreCase = true;
+            }
+            if (item.tagName === "html" /* VALUES.ROOT */) {
+                items.push(item);
+                if (!documentElement && item.innerXml) {
+                    documentElement = item;
+                }
+            }
+        }
+        const setNewline = (value) => this.newline = (0, util_1.getNewline)(value);
+        if (!documentElement) {
+            setNewline(source);
+            if (normalize) {
+                source = DomWriter.normalize(source, { newline: this.newline, ignoreChar: typeof normalize === 'string' ? normalize : '', ignoreTagGroup, escapeEntities });
+            }
+            else if (escapeEntities) {
+                source = index_1.XmlWriter.escapeAttributes(source);
+            }
+        }
+        else {
+            setNewline(documentElement.innerXml);
+        }
+        const html = /<html[\s>]/i.exec(source);
+        if (html) {
+            const endIndex = index_1.XmlWriter.findCloseTag(source, html.index);
+            if (endIndex !== -1) {
+                startIndex = html.index;
+                outerXml = source.substring(startIndex, endIndex + 1);
+            }
+        }
+        if (documentElement) {
+            let leading;
+            if (startIndex === -1) {
+                leading = '<!DOCTYPE html>' + this.newline;
+                startIndex = leading.length;
+                outerXml = '<html>';
+                leading += outerXml;
+            }
+            else {
+                leading = source.substring(0, startIndex + outerXml.length);
+            }
+            source = documentElement.innerXml;
+            if (escapeEntities) {
+                source = index_1.XmlWriter.escapeAttributes(source);
+            }
+            source = leading + this.newline + source + this.newline + '</html>';
+            this.documentElement = documentElement;
+        }
+        else {
+            const trailing = items.filter(item => item.textContent);
+            if (trailing.length) {
+                const match = /<\/body\s*>/i.exec(source);
+                if (match) {
+                    const textContent = trailing.reduce((a, b) => a + b.textContent, '');
+                    offsetMap = index_1.XmlWriter.getTagOffset(textContent, { ignoreCase: this.ignoreCaseTagName, ignoreTagName: this.ignoreTagName, parser: this.parser });
+                    source = source.substring(0, match.index) + textContent + source.substring(match.index);
+                    trailing.forEach(item => delete item.textContent);
+                }
+            }
+        }
+        if (stripComments) {
+            source = DomWriter.getCommentsAndCDATA(source, '', true, true);
+        }
+        this.source = source;
+        this.initOpts = options;
+        if (outerXml) {
+            const endIndex = startIndex + outerXml.length - 1;
+            for (const item of items) {
+                item.startIndex = startIndex;
+                item.endIndex = endIndex;
+                item.outerXml = outerXml;
+            }
+        }
+        this.init(offsetMap);
+    }
+    save() {
+        if (this.modified && this.documentElement) {
+            let innerXml;
+            for (const item of this.elements) {
+                if (item.tagName === "html" /* VALUES.ROOT */) {
+                    if (!innerXml && index_1.XmlWriter.isIndex(item.endIndex)) {
+                        innerXml = this.source.substring(item.endIndex + 1, this.source.length - 7).trim();
+                    }
+                    item.innerXml = innerXml;
+                }
+            }
+        }
+        return super.save();
+    }
+    close() {
+        if (this.documentElement || this._appendCount > 0) {
+            this.source = this.source.replace(new RegExp(this.patternId, 'g'), '');
+        }
+        return super.close();
+    }
+    newElement(node) {
+        return new HtmlElement(this.documentName, node);
+    }
+    get nameOfId() {
+        return index_1.XmlWriter.getNameOfId(this.documentName);
+    }
+}
+exports.DomWriter = DomWriter;
+class HtmlElement extends index_1.XmlElement {
+    constructor(documentName, node, attributes, options = {}) {
+        options.parser || (options.parser = { ...PARSER_OPTIONS });
+        super(documentName, node, attributes, { ...options, tagVoid: TAG_VOID.includes(node.tagName) });
+        this.TAG_VOID = TAG_VOID;
+    }
+    getTagOffset(source) {
+        switch (this.node.append?.tagName || this.tagName) {
+            case 'html':
+            case 'title':
+            case 'style':
+            case 'script':
+                return;
+            default:
+                return super.getTagOffset(source, { ignoreCase: this.ignoreCase, ignoreTagName: "title|style|script" /* VALUES.IGNORE_TAGNAME */, parser: this.parser });
+        }
+    }
+    findIndexOf(source) {
+        const { element } = index_1.XmlWriter.findElement(source, this.node, { document: this.documentName, id: this.id, locatorAttr: 'id', parser: this.parser });
+        if (element) {
+            return { startIndex: element.startIndex, endIndex: element.endIndex };
+        }
+    }
+    get outerXml() {
+        const [tagName, items, innerXml] = this.getOuterContent();
+        return '<' + tagName + HtmlElement.writeAttributes(items) + '>' + (DomWriter.hasInnerXml(tagName) && tagName !== "html" /* VALUES.ROOT */ ? (tagName === 'title' ? index_1.XmlWriter.escapeXmlString(innerXml) : innerXml) + `</${tagName}>` : '');
+    }
+    get nameOfId() {
+        return index_1.XmlWriter.getNameOfId(this.documentName);
+    }
+}
+exports.HtmlElement = HtmlElement;

package/parse/index.d.ts

@@ -0,0 +1,9 @@
+import type { IGNORE_FLAG, XmlWriterConstructor, XmlElementConstructor } from './document';
+
+declare namespace parse {
+    const IGNORE_FLAG: IGNORE_FLAG;
+    const XmlWriter: XmlWriterConstructor;
+    const XmlElement: XmlElementConstructor;
+}
+
+export = parse;