yomichan/ext/js/display/structured-content-generator.js

/*
 * Copyright (C) 2021  Yomichan Authors
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

class StructuredContentGenerator {
    constructor(mediaLoader, document) {
        this._mediaLoader = mediaLoader;
        this._document = document;
    }

    createStructuredContent(content, dictionary) {
        if (typeof content === 'string') {
            return this._createTextNode(content);
        }
        if (!(typeof content === 'object' && content !== null)) {
            return null;
        }
        if (Array.isArray(content)) {
            const fragment = this._createDocumentFragment();
            for (const item of content) {
                const child = this.createStructuredContent(item, dictionary);
                if (child !== null) { fragment.appendChild(child); }
            }
            return fragment;
        }
        const {tag} = content;
        switch (tag) {
            case 'br':
                return this._createStructuredContentElement(tag, content, dictionary, 'simple', false, false);
            case 'ruby':
            case 'rt':
            case 'rp':
                return this._createStructuredContentElement(tag, content, dictionary, 'simple', true, false);
            case 'table':
                return this._createStructuredContentTableElement(tag, content, dictionary);
            case 'thead':
            case 'tbody':
            case 'tfoot':
            case 'tr':
                return this._createStructuredContentElement(tag, content, dictionary, 'table', true, false);
            case 'th':
            case 'td':
                return this._createStructuredContentElement(tag, content, dictionary, 'table-cell', true, true);
            case 'div':
            case 'span':
                return this._createStructuredContentElement(tag, content, dictionary, 'simple', true, true);
            case 'img':
                return this.createDefinitionImage(content, dictionary);
        }
        return null;
    }

    createDefinitionImage(data, dictionary) {
        const {
            path,
            width,
            height,
            preferredWidth,
            preferredHeight,
            title,
            pixelated,
            imageRendering,
            appearance,
            background,
            collapsed,
            collapsible,
            verticalAlign,
            sizeUnits
        } = data;

        const hasPreferredWidth = (typeof preferredWidth === 'number');
        const hasPreferredHeight = (typeof preferredHeight === 'number');
        const aspectRatio = (
            hasPreferredWidth && hasPreferredHeight ?
            preferredWidth / preferredHeight :
            width / height
        );
        const usedWidth = (
            hasPreferredWidth ?
            preferredWidth :
            (hasPreferredHeight ? preferredHeight * aspectRatio : width)
        );

        const node = this._createElement('a', 'gloss-image-link');
        node.target = '_blank';
        node.rel = 'noreferrer noopener';

        const imageContainer = this._createElement('span', 'gloss-image-container');
        node.appendChild(imageContainer);

        const aspectRatioSizer = this._createElement('span', 'gloss-image-aspect-ratio-sizer');
        imageContainer.appendChild(aspectRatioSizer);

        const imageBackground = this._createElement('span', 'gloss-image-background icon');
        imageContainer.appendChild(imageBackground);

        const image = this._createElement('img', 'gloss-image');
        image.alt = '';
        imageContainer.appendChild(image);

        const overlay = this._createElement('span', 'gloss-image-container-overlay');
        imageContainer.appendChild(overlay);

        const linkText = this._createElement('span', 'gloss-image-link-text');
        linkText.textContent = 'Image';
        node.appendChild(linkText);

        node.dataset.path = path;
        node.dataset.dictionary = dictionary;
        node.dataset.imageLoadState = 'not-loaded';
        node.dataset.hasAspectRatio = 'true';
        node.dataset.imageRendering = typeof imageRendering === 'string' ? imageRendering : (pixelated ? 'pixelated' : 'auto');
        node.dataset.appearance = typeof appearance === 'string' ? appearance : 'auto';
        node.dataset.background = typeof background === 'boolean' ? `${background}` : 'true';
        node.dataset.collapsed = typeof collapsed === 'boolean' ? `${collapsed}` : 'false';
        node.dataset.collapsible = typeof collapsible === 'boolean' ? `${collapsible}` : 'true';
        if (typeof verticalAlign === 'string') {
            node.dataset.verticalAlign = verticalAlign;
        }
        if (typeof sizeUnits === 'string' && (hasPreferredWidth || hasPreferredHeight)) {
            node.dataset.sizeUnits = sizeUnits;
        }

        imageContainer.style.width = `${usedWidth}em`;
        if (typeof title === 'string') {
            imageContainer.title = title;
        }

        aspectRatioSizer.style.paddingTop = `${aspectRatio * 100.0}%`;

        if (this._mediaLoader !== null) {
            this._mediaLoader.loadMedia(
                path,
                dictionary,
                (url) => this._setImageData(node, image, imageBackground, url, false),
                () => this._setImageData(node, image, imageBackground, null, true)
            );
        }

        return node;
    }

    // Private

    _createElement(tagName, className) {
        const node = this._document.createElement(tagName);
        node.className = className;
        return node;
    }

    _createTextNode(data) {
        return this._document.createTextNode(data);
    }

    _createDocumentFragment() {
        return this._document.createDocumentFragment();
    }

    _setImageData(node, image, imageBackground, url, unloaded) {
        if (url !== null) {
            image.src = url;
            node.href = url;
            node.dataset.imageLoadState = 'loaded';
            imageBackground.style.setProperty('--image', `url("${url}")`);
        } else {
            image.removeAttribute('src');
            node.removeAttribute('href');
            node.dataset.imageLoadState = unloaded ? 'unloaded' : 'load-error';
            imageBackground.style.removeProperty('--image');
        }
    }

    _createStructuredContentTableElement(tag, content, dictionary) {
        const container = this._createElement('div', 'gloss-sc-table-container');
        const table = this._createStructuredContentElement(tag, content, dictionary, 'table', true, false);
        container.appendChild(table);
        return container;
    }

    _createStructuredContentElement(tag, content, dictionary, type, hasChildren, hasStyle) {
        const node = this._createElement(tag, `gloss-sc-${tag}`);
        switch (type) {
            case 'table-cell':
                {
                    const {colSpan, rowSpan} = content;
                    if (typeof colSpan === 'number') { node.colSpan = colSpan; }
                    if (typeof rowSpan === 'number') { node.rowSpan = rowSpan; }
                }
                break;
        }
        if (hasStyle) {
            const {style} = content;
            if (typeof style === 'object' && style !== null) {
                this._setStructuredContentElementStyle(node, style);
            }
        }
        if (hasChildren) {
            const child = this.createStructuredContent(content.content, dictionary);
            if (child !== null) { node.appendChild(child); }
        }
        return node;
    }

    _setStructuredContentElementStyle(node, contentStyle) {
        const {style} = node;
        const {fontStyle, fontWeight, fontSize, textDecorationLine, verticalAlign} = contentStyle;
        if (typeof fontStyle === 'string') { style.fontStyle = fontStyle; }
        if (typeof fontWeight === 'string') { style.fontWeight = fontWeight; }
        if (typeof fontSize === 'string') { style.fontSize = fontSize; }
        if (typeof verticalAlign === 'string') { style.verticalAlign = verticalAlign; }
        if (typeof textDecorationLine === 'string') {
            style.textDecoration = textDecorationLine;
        } else if (Array.isArray(textDecorationLine)) {
            style.textDecoration = textDecorationLine.join(' ');
        }
    }
}