document-ir 0.0.6

package/esm/IdentityTransformer.js

@@ -0,0 +1,688 @@
+export class IdentityTransformer {
+    async beforeBlock() {
+    }
+    async afterBlock() {
+    }
+    async beforeInline() {
+    }
+    async afterInline() {
+    }
+    async chooseChildren(nodes) {
+        const children = [];
+        for (const child of nodes) {
+            const resultNode = await this.choose(child);
+            if (resultNode) {
+                children.push(resultNode);
+            }
+        }
+        return children;
+    }
+    async block(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "block",
+            content,
+        };
+    }
+    async blockQuote(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "block-quote",
+            content,
+        };
+    }
+    async bold(node) {
+        await this.beforeInline();
+        const content = await this.chooseChildren(node.content);
+        await this.afterInline();
+        return {
+            type: "bold",
+            content,
+        };
+    }
+    async break_(_node) {
+        await this.beforeBlock();
+        await this.afterBlock();
+        return {
+            type: "break",
+        };
+    }
+    async bubble(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "bubble",
+            orientation: node.orientation || "left",
+            content,
+        };
+    }
+    async center(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "center",
+            content,
+        };
+    }
+    async code(node) {
+        await this.beforeInline();
+        const content = await this.chooseChildren(node.content);
+        await this.afterInline();
+        return {
+            type: "code",
+            content,
+        };
+    }
+    async columns(node) {
+        const columns = [];
+        for (const column of node.columns) {
+            await this.beforeBlock();
+            columns.push(await this.chooseChildren(column));
+            await this.afterBlock();
+        }
+        return {
+            type: "columns",
+            columns,
+            "column-count": node["column-count"],
+        };
+    }
+    async definition(node) {
+        await this.beforeBlock();
+        const abbreviation = await this.chooseChildren(node.abbreviation);
+        await this.afterBlock();
+        await this.beforeBlock();
+        const title = await this.chooseChildren(node.title);
+        await this.afterBlock();
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "definition",
+            abbreviation,
+            title,
+            content,
+            key: node.key,
+        };
+    }
+    async definitionList(node) {
+        await this.beforeBlock();
+        const children = [];
+        for (const child of node.content) {
+            const resultNode = await this.definition(child);
+            if (resultNode) {
+                children.push(resultNode);
+            }
+        }
+        await this.afterBlock();
+        return {
+            type: "definition-list",
+            content: children,
+        };
+    }
+    async definitionReference(node) {
+        await this.beforeInline();
+        const abbreviation = await this.chooseChildren(node.definition.abbreviation);
+        await this.afterInline();
+        return {
+            type: "definition-reference",
+            definition: {
+                abbreviation,
+                key: node.definition.key,
+            },
+            content: await this.chooseChildren(node.content),
+        };
+    }
+    // deno-lint-ignore require-await
+    async embed(node) {
+        return {
+            type: "embed",
+            content: {
+                ...node.content,
+            },
+        };
+    }
+    // deno-lint-ignore require-await
+    async emoji(node) {
+        return {
+            type: "emoji",
+            url: node.url,
+            alt: node.alt,
+        };
+    }
+    async figure(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "figure",
+            content,
+        };
+    }
+    async figureCaption(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "figure-caption",
+            content,
+        };
+    }
+    async figureImage(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "figure-image",
+            alt: node.alt || "",
+            blurhash: node.blurhash || "",
+            height: node.height,
+            width: node.width,
+            image: node.image,
+            url: node.url,
+            content,
+            hero: node.hero,
+        };
+    }
+    async formattedText(node) {
+        await this.beforeBlock();
+        await this.afterBlock();
+        return {
+            type: "formatted-text",
+            text: node.text || "",
+            language: node.language,
+        };
+    }
+    async header(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "header",
+            content,
+            level: node.level || 2,
+        };
+    }
+    async highTechAlert(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        await this.beforeBlock();
+        const warning = await this.chooseChildren(node.warning);
+        await this.afterBlock();
+        return {
+            type: "high-tech-alert",
+            content,
+            warning,
+        };
+    }
+    async horizontalRule(_node) {
+        await this.beforeBlock();
+        await this.afterBlock();
+        return {
+            type: "horizontal-rule",
+        };
+    }
+    async image(node) {
+        await this.beforeBlock();
+        await this.afterBlock();
+        return {
+            type: "image",
+            alt: node.alt || "",
+            blurhash: node.blurhash,
+            height: node.height,
+            width: node.width,
+            image: node.image,
+            url: node.url,
+            hero: node.hero,
+        };
+    }
+    async italic(node) {
+        await this.beforeInline();
+        const content = await this.chooseChildren(node.content);
+        await this.afterInline();
+        return {
+            type: "italic",
+            content,
+        };
+    }
+    async link(node) {
+        await this.beforeInline();
+        const content = await this.chooseChildren(node.content);
+        await this.afterInline();
+        return {
+            type: "link",
+            content,
+            url: node.url,
+            title: node.title,
+        };
+    }
+    async array(node) {
+        return {
+            type: "array",
+            content: await this.chooseChildren(node.content),
+        };
+    }
+    async note(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "note",
+            content,
+        };
+    }
+    async list(node) {
+        const content = [];
+        for (const item of node.content) {
+            await this.beforeBlock();
+            const children = await this.chooseChildren(item.content);
+            await this.afterBlock();
+            if (children && children.length > 0) {
+                content.push({
+                    type: "list-item",
+                    content: children,
+                });
+            }
+        }
+        return {
+            type: "list",
+            style: node.style || "unordered",
+            content,
+        };
+    }
+    async paragraph(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "paragraph",
+            content,
+        };
+    }
+    async quote(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "quote",
+            icon: node.icon,
+            name: node.name,
+            content,
+            url: node.url,
+            orientation: node.orientation,
+        };
+    }
+    async redacted(node) {
+        if (node.style == "block") {
+            await this.beforeBlock();
+        }
+        else {
+            await this.beforeInline();
+        }
+        const content = await this.chooseChildren(node.content);
+        if (node.style == "block") {
+            await this.afterBlock();
+        }
+        else {
+            await this.afterInline();
+        }
+        return {
+            type: "redacted",
+            style: node.style,
+            content,
+        };
+    }
+    async region(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "region",
+            mode: node.mode,
+            regions: node.regions,
+            content,
+        };
+    }
+    // deno-lint-ignore require-await
+    async script(node) {
+        return {
+            type: "script",
+            "mime-type": node["mime-type"] || "text/javascript",
+            source: node.source,
+        };
+    }
+    async secret(node) {
+        await this.beforeInline();
+        const content = await this.chooseChildren(node.content);
+        await this.afterInline();
+        return {
+            type: "secret",
+            content,
+        };
+    }
+    async smaller(node) {
+        await this.beforeInline();
+        const content = await this.chooseChildren(node.content);
+        await this.afterInline();
+        return {
+            type: "smaller",
+            content,
+        };
+    }
+    async sticker(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "sticker",
+            orientation: node.orientation,
+            character: node.character,
+            name: node.name,
+            size: node.size,
+            content,
+        };
+    }
+    async strikeThrough(node) {
+        await this.beforeInline();
+        const content = await this.chooseChildren(node.content);
+        await this.afterInline();
+        return {
+            type: "strike-through",
+            content,
+        };
+    }
+    // deno-lint-ignore require-await
+    async text(node) {
+        return {
+            type: "text",
+            text: node.text,
+        };
+    }
+    async table(node) {
+        const content = [];
+        for (const row of node.content) {
+            const cells = [];
+            let emptyCount = 0;
+            for (const cell of row) {
+                await this.beforeBlock();
+                const children = await this.chooseChildren(cell.content);
+                await this.afterBlock();
+                if (children && children.length == 0) {
+                    emptyCount++;
+                }
+                cells.push({
+                    type: "table-cell",
+                    header: cell.header,
+                    span: [cell.span[0] || 1, cell.span[1] || 1],
+                    content: children,
+                });
+            }
+            if (cells.length > 0 && emptyCount != cells.length) {
+                content.push(cells);
+            }
+        }
+        return {
+            type: "table",
+            content,
+        };
+    }
+    async social(node) {
+        await this.beforeBlock();
+        await this.afterBlock();
+        return {
+            type: node.type,
+            id: node.id,
+        };
+    }
+    async underline(node) {
+        await this.beforeInline();
+        const content = await this.chooseChildren(node.content);
+        await this.afterInline();
+        return {
+            type: "underline",
+            content,
+        };
+    }
+    async video(node) {
+        await this.beforeBlock();
+        const content = node.content && await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "video",
+            alt: node.alt,
+            blurhash: node.blurhash,
+            mp4: node.mp4,
+            poster: node.poster,
+            autoplay: node.autoplay,
+            content,
+            height: node.height,
+            loop: node.loop,
+            muted: node.muted,
+            webm: node.webm,
+            width: node.width,
+        };
+    }
+    async warning(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        return {
+            type: "warning",
+            content,
+        };
+    }
+    async card(node) {
+        let content;
+        if (node.content) {
+            await this.beforeBlock();
+            const cardContent = await this.chooseChildren(node.content.content);
+            if (cardContent && cardContent.length > 0) {
+                content = {
+                    type: "card-content",
+                    content: cardContent,
+                };
+            }
+            await this.afterBlock();
+        }
+        let attribution;
+        if (node.attribution) {
+            attribution = {
+                type: "card-attribution",
+                archiveUrl: node.attribution.archiveUrl,
+                date: node.attribution.date,
+                url: node.attribution.url,
+            };
+            if (node.attribution.title) {
+                await this.beforeBlock();
+                const title = await this.chooseChildren(node.attribution.title);
+                await this.afterBlock();
+                attribution.title = title;
+            }
+        }
+        let header;
+        if (node.header) {
+            await this.beforeBlock();
+            const title = await this.chooseChildren(node.header.title);
+            await this.afterBlock();
+            header = {
+                type: "card-header",
+                title,
+                backgroundBlurhash: node.header.backgroundBlurhash,
+                backgroundColor: node.header.backgroundColor,
+                backgroundImage: node.header.backgroundImage,
+                imageUrl: node.header.imageUrl,
+                imageBlurhash: node.header.imageBlurhash,
+                url: node.header.url,
+                username: node.header.username,
+                usernameDomain: node.header.usernameDomain,
+            };
+        }
+        let media;
+        if (node.media) {
+            const mediaContent = [];
+            for (const mediaNode of node.media.content) {
+                await this.beforeBlock();
+                const transformedNode = await this.choose(mediaNode);
+                if (transformedNode) {
+                    if (transformedNode.type == "image" ||
+                        transformedNode.type == "video" ||
+                        transformedNode.type == "embed") {
+                        mediaContent.push(transformedNode);
+                    }
+                }
+                await this.afterBlock();
+            }
+            if (mediaContent.length > 0) {
+                media = {
+                    type: "card-media",
+                    content: mediaContent,
+                };
+            }
+        }
+        return {
+            type: "card",
+            content,
+            attribution,
+            header,
+            media,
+            original: node.original,
+        };
+    }
+    async choose(node) {
+        if (!node || !node.type) {
+            throw new Error(`Unexpected node, no type: ${JSON.stringify(node)}`);
+        }
+        try {
+            switch (node.type) {
+                case "block":
+                    return await this.block(node);
+                case "block-quote":
+                    return await this.blockQuote(node);
+                case "bold":
+                    return await this.bold(node);
+                case "break":
+                    return await this.break_(node);
+                case "bubble":
+                    return await this.bubble(node);
+                case "card":
+                    return await this.card(node);
+                case "center":
+                    return await this.center(node);
+                case "code":
+                    return await this.code(node);
+                case "columns":
+                    return await this.columns(node);
+                case "definition":
+                    return await this.definition(node);
+                case "definition-list":
+                    return await this.definitionList(node);
+                case "definition-reference":
+                    return await this.definitionReference(node);
+                case "embed":
+                    return await this.embed(node);
+                case "emoji":
+                    return await this.emoji(node);
+                case "figure":
+                    return await this.figure(node);
+                case "figure-caption":
+                    return await this.figureCaption(node);
+                case "figure-image":
+                    return await this.figureImage(node);
+                case "formatted-text":
+                    return await this.formattedText(node);
+                case "header":
+                    return await this.header(node);
+                case "high-tech-alert":
+                    return await this.highTechAlert(node);
+                case "horizontal-rule":
+                    return await this.horizontalRule(node);
+                case "image":
+                    return await this.image(node);
+                case "italic":
+                    return await this.italic(node);
+                case "link":
+                    return await this.link(node);
+                case "array":
+                    return await this.array(node);
+                case "note":
+                    return await this.note(node);
+                case "list":
+                    return await this.list(node);
+                case "paragraph":
+                    return await this.paragraph(node);
+                case "quote":
+                    return await this.quote(node);
+                case "redacted":
+                    return await this.redacted(node);
+                case "region":
+                    return await this.region(node);
+                case "script":
+                    return await this.script(node);
+                case "secret":
+                    return await this.secret(node);
+                case "smaller":
+                    return await this.smaller(node);
+                case "sticker":
+                    return await this.sticker(node);
+                case "strike-through":
+                    return await this.strikeThrough(node);
+                case "table":
+                    return await this.table(node);
+                case "text":
+                    return await this.text(node);
+                case "toot":
+                case "tweet":
+                case "vimeo":
+                case "youtube":
+                    return await this.social(node);
+                case "underline":
+                    return await this.underline(node);
+                case "video":
+                    return await this.video(node);
+                case "warning":
+                    return await this.warning(node);
+            }
+        }
+        catch (e) {
+            console.log(`Got exception while processing node: ${JSON.stringify(node)}`);
+            throw e;
+        }
+        //@ts-ignore fall through
+        console.error(`Unsupported type ${node.type}`);
+        return null;
+    }
+    async document(node) {
+        await this.beforeBlock();
+        const content = await this.chooseChildren(node.content);
+        await this.afterBlock();
+        await this.beforeBlock();
+        const definitions = node.definitions &&
+            (await this.chooseChildren(node.definitions)).filter((x) => x.type == "definition");
+        await this.afterBlock();
+        const result = {
+            type: "document",
+            title: node.title,
+            author: node.author,
+            content,
+            hidden: node.hidden,
+            noindex: node.noindex,
+            description: node.description,
+            image: node.image,
+            guid: node.guid,
+            "pub-date": node["pub-date"],
+            date: node.date,
+            url: node.url,
+            definitions,
+        };
+        return result;
+    }
+    async transform(node) {
+        return await this.document(node);
+    }
+}

package/esm/IdentityTransformer_test.d.ts

@@ -0,0 +1 @@
+export {};