@awesome-fe/translate/dom/asciidoctor/html-adoc/tiny-html-converter/base-tiny-node-renderer.js

Translation utils

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BaseTinyNodeRenderer = void 0;
const adoc_1 = require("../../utils/adoc");
const match_some_1 = require("../../adoc-builder/renderers/utils/match-some");
const lodash_1 = require("lodash");
function valueToText(value) {
    if (typeof value === 'number' || typeof value === 'string') {
        return `${value}`;
    }
    else if (!value || !value.toString()) {
        return '';
    }
    else if ('length' in value) {
        return JSON.stringify(Array.from(value).map(it => {
            if (it instanceof Object) {
                return (0, lodash_1.omit)(it, '$$id');
            }
            else {
                return it;
            }
        }));
    }
    else if (typeof value === 'object') {
        return JSON.stringify((0, lodash_1.omit)(value, '$$id'));
    }
}
class BaseTinyNodeRenderer {
    ignoredAttributeNames = [];
    tagName = 'UNKNOWN';
    selfClosingTag = false;
    getTagName(node) {
        return this.tagName;
    }
    render(node) {
        if (this.selfClosingTag) {
            return `<${this.getTagName(node)}${this.renderAttributes(node)}/>`;
        }
        else {
            return `<${this.getTagName(node)}${this.renderAttributes(node)}>${this.getContent(node) ?? ''}</${this.getTagName(node)}>`;
        }
    }
    renderAttributes(node) {
        function shouldIgnore(name, node) {
            return name === 'style' || adoc_1.adoc.isDocument(node) && !(0, match_some_1.matchSome)(name, [
                'doctitle',
                'authorcount',
                'firstname',
                'authorinitials',
                'middlename',
                'lastname',
                'author',
                'email',
                'authors',
                /firstname_(\d+)/,
                /authorinitials_(\d+)/,
                /lastname_(\d+)/,
                /author_(\d+)/,
                /author_(\d+)/,
                /authorinitials_(\d+)/,
                /firstname_(\d+)/,
                /middlename_(\d+)/,
                /lastname_(\d+)/,
                /email_(\d+)/,
                'revnumber',
                'revdate',
                ...node.attributes_modified.hash.$$keys,
            ]);
        }
        const result = [
            {
                name: 'name',
                prefix: 'adoc',
                value: node.getNodeName(),
            },
            ...this.getAttributesViaSetter(node),
            ...this.getAttributesViaProperty(node).filter(it => !shouldIgnore(it.name, node)),
        ]
            .filter(it => !!it)
            .map(({ name, value, prefix }) => {
            const valueText = valueToText(value).replace(/"/g, '&quot;');
            if (typeof value === 'string') {
                return `${prefix}-${name}="${valueText}"`;
            }
            else if (value === undefined || value === null || typeof value === 'object' && value.toString() === '' || typeof value === 'number' && value === 0) {
                return '';
            }
            else {
                return `${prefix}-${name}="${valueText}" type-${prefix}-${name}="${typeof value}"`;
            }
        }).filter(it => !!it).join(' ');
        return result && ` ${result}`;
    }
    getAttributesViaProperty(node) {
        const normalAttributes = Object.entries(node.getAttributes())
            .filter(([name]) => !(0, match_some_1.matchSome)(name, ['$positional', ...this.ignoredAttributeNames]))
            .map(([name, value]) => ({ name, value, prefix: 'data' }))
            .filter(it => it.value !== undefined);
        if (adoc_1.adoc.isInline(node)) {
            return [
                ...normalAttributes,
                { name: 'type', value: node.getType(), prefix: 'prop' },
                { name: 'alt', value: node.getAlt(), prefix: 'prop' },
                { name: 'target', value: node.getTarget(), prefix: 'prop' },
            ].filter(it => it.value !== undefined);
        }
        else {
            return normalAttributes;
        }
    }
    getAttributesViaSetter(node) {
        function getSetterNames(obj) {
            if (!obj) {
                return [];
            }
            return (0, lodash_1.uniq)([...Object.getOwnPropertyNames(obj), ...getSetterNames(Object.getPrototypeOf(obj))]);
        }
        const setters = getSetterNames(node)
            .filter(it => /^set([A-Z])\w+/.test(it))
            .filter(it => !adoc_1.adoc.isDocument(node) || it !== 'setTitle')
            .filter(it => !['setAttribute', 'setHeaderAttribute', 'setSourcemap'].includes(it));
        return setters.map(it => {
            const name = it.replace(/^set([A-Z]\w*)/, '$1');
            const value = node[`get${name}`]?.();
            return { name, value, prefix: 'attr' };
        }).filter(it => !!it?.value);
    }
    getContent(node) {
        if (adoc_1.adoc.isAbstractBlock(node)) {
            return node.getContent();
        }
        else if (adoc_1.adoc.isInline(node)) {
            return node.getText();
        }
    }
}
exports.BaseTinyNodeRenderer = BaseTinyNodeRenderer;
//# sourceMappingURL=base-tiny-node-renderer.js.map