@code.store/arcxp-sdk-ts 5.3.0 → 5.3.2

package/dist/index.js

@@ -7,6 +7,7 @@ import FormData from 'form-data';
 import * as ws from 'ws';
 import { TextNode, HTMLElement, CommentNode, parse } from 'node-html-parser';
 import { decode } from 'html-entities';
+import * as xmldoc from 'xmldoc';
 import encode from 'base32-encode';
 import { v5 } from 'uuid';
 import assert from 'node:assert';
@@ -889,7 +890,7 @@ const ArcAPI = (options) => {
     return API;
 };
 
-const ContentElement = {
+const ContentElement$1 = {
     divider: () => {
         return {
             type: 'divider',
@@ -1121,7 +1122,7 @@ const ContentElement = {
     },
 };
 
-const BLOCK_ELEMENT_TAGS = [
+const BLOCK_ELEMENT_TAGS$1 = [
     'ADDRESS',
     'ARTICLE',
     'ASIDE',
@@ -1160,7 +1161,7 @@ const BLOCK_ELEMENT_TAGS = [
 
 var html_constants = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    BLOCK_ELEMENT_TAGS: BLOCK_ELEMENT_TAGS
+    BLOCK_ELEMENT_TAGS: BLOCK_ELEMENT_TAGS$1
 });
 
 const socialRegExps = {
@@ -1204,27 +1205,27 @@ function createSocial(url = '') {
     const embeds = [];
     const instagram = instagramURLParser(url);
     if (instagram) {
-        embeds.push(ContentElement.instagram(instagram));
+        embeds.push(ContentElement$1.instagram(instagram));
     }
     const twitter = twitterURLParser(url);
     if (twitter) {
-        embeds.push(ContentElement.twitter(twitter));
+        embeds.push(ContentElement$1.twitter(twitter));
     }
     const tiktok = tiktokURLParser(url);
     if (tiktok) {
-        embeds.push(ContentElement.tiktok(tiktok));
+        embeds.push(ContentElement$1.tiktok(tiktok));
     }
     const youtube = youtubeURLParser(url);
     if (youtube) {
-        embeds.push(ContentElement.youtube(youtube));
+        embeds.push(ContentElement$1.youtube(youtube));
     }
     const facebookPost = facebookPostURLParser(url);
     if (facebookPost) {
-        embeds.push(ContentElement.facebook_post(facebookPost));
+        embeds.push(ContentElement$1.facebook_post(facebookPost));
     }
     const facebookVideo = facebookVideoURLParser(url);
     if (facebookVideo) {
-        embeds.push(ContentElement.facebook_video(facebookVideo));
+        embeds.push(ContentElement$1.facebook_video(facebookVideo));
     }
     return embeds;
 }
@@ -1248,7 +1249,7 @@ var ContentElements = /*#__PURE__*/Object.freeze({
     youtubeURLParser: youtubeURLParser
 });
 
-const isTextNode = (node) => {
+const isTextNode$1 = (node) => {
     return node instanceof TextNode;
 };
 const isHTMLElement = (node) => {
@@ -1282,7 +1283,7 @@ var html_utils = /*#__PURE__*/Object.freeze({
     htmlToText: htmlToText,
     isCommentNode: isCommentNode,
     isHTMLElement: isHTMLElement,
-    isTextNode: isTextNode,
+    isTextNode: isTextNode$1,
     nodeTagIn: nodeTagIn,
     nodeTagIs: nodeTagIs
 });
@@ -1311,6 +1312,7 @@ var html_utils = /*#__PURE__*/Object.freeze({
  */
 class HTMLProcessor {
     constructor() {
+        this.blockElementTags = BLOCK_ELEMENT_TAGS$1;
         this.parallelProcessing = true;
         this.handlers = {
             node: new Map(),
@@ -1430,7 +1432,7 @@ class HTMLProcessor {
             }
         });
         this.handle('text', (node) => {
-            if (isTextNode(node)) {
+            if (isTextNode$1(node)) {
                 return this.createText(node);
             }
         });
@@ -1608,23 +1610,23 @@ class HTMLProcessor {
         return [];
     }
     async handleTable(node) {
-        return [ContentElement.raw_html(node.toString())];
+        return [ContentElement$1.raw_html(node.toString())];
     }
     async handleIframe(node) {
-        return [ContentElement.raw_html(node.toString())];
+        return [ContentElement$1.raw_html(node.toString())];
     }
     async handleImage(node) {
-        return [ContentElement.raw_html(node.toString())];
+        return [ContentElement$1.raw_html(node.toString())];
     }
     async handleBreak(_) {
-        return [ContentElement.divider()];
+        return [ContentElement$1.divider()];
     }
     async createQuote(node) {
         const items = await this.handleNested(node);
-        return [ContentElement.quote(items)];
+        return [ContentElement$1.quote(items)];
     }
     async createText(node) {
-        const text = ContentElement.text(node.text);
+        const text = ContentElement$1.text(node.text);
         return [text];
     }
     filterListItems(items) {
@@ -1632,16 +1634,16 @@ class HTMLProcessor {
     }
     async createList(node, type) {
         const items = await this.handleNested(node);
-        return [ContentElement.list(type, this.filterListItems(items))];
+        return [ContentElement$1.list(type, this.filterListItems(items))];
     }
     async createHeader(node) {
         const level = +node.tagName.split('H')[1] || 3;
-        return [ContentElement.header(node.innerText, level)];
+        return [ContentElement$1.header(node.innerText, level)];
     }
     isBlockElement(node) {
         if (!isHTMLElement(node))
             return false;
-        const defaultBlockElements = new Set(BLOCK_ELEMENT_TAGS);
+        const defaultBlockElements = new Set(this.blockElementTags);
         return defaultBlockElements.has(node.tagName);
     }
     warn(metadata, message) {
@@ -1649,17 +1651,241 @@ class HTMLProcessor {
     }
 }
 
-var index$3 = /*#__PURE__*/Object.freeze({
+var index$4 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     Constants: html_constants,
     HTMLProcessor: HTMLProcessor,
     Utils: html_utils
 });
 
+const BLOCK_ELEMENT_TAGS = ['paragraph', 'line', 'header', 'ul', 'ol', 'li', 'embed', 'iframe', 'table'];
+
+var xml_constants = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BLOCK_ELEMENT_TAGS: BLOCK_ELEMENT_TAGS
+});
+
+const isXmlElement = (node) => {
+    return node?.type === 'element';
+};
+const isTextNode = (node) => {
+    return node?.type === 'text';
+};
+const nodeNameIs = (node, name) => {
+    return isXmlElement(node) && node.name === name;
+};
+const nodeNameIn = (node, names) => {
+    return isXmlElement(node) && names.includes(node.name);
+};
+
+var xml_utils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isTextNode: isTextNode,
+    isXmlElement: isXmlElement,
+    nodeNameIn: nodeNameIn,
+    nodeNameIs: nodeNameIs
+});
+
+const ContentElement = ContentElement$1;
+class XMLProcessor {
+    constructor() {
+        this.blockElementTags = BLOCK_ELEMENT_TAGS;
+        this.handlers = {
+            node: new Map(),
+            wrap: new Map(),
+        };
+    }
+    init() {
+        // wrappers are used to wrap the content of nested text nodes
+        // in a specific way
+        this.wrap('link', (node, content) => {
+            return `<a href="${node.attr.url || node.attr.href || '/'}">${content}</a>`;
+        });
+        this.wrap('header', (_node, content) => {
+            return `<h3>${content}</h3>`;
+        });
+        this.wrap('emphasize', (_node, content) => {
+            return `<i>${content}</i>`;
+        });
+        this.wrap('strong', (_node, content) => {
+            return `<b>${content}</b>`;
+        });
+        // handlers are used to handle specific nodes
+        // and return a list of content elements
+        this.handle('default', (node) => {
+            if (nodeNameIn(node, ['section', 'paragraph', 'line', 'header', 'emphasize', 'strong', 'link', 'li'])) {
+                return this.handleNested(node);
+            }
+        });
+        this.handle('text', (node) => {
+            if (isTextNode(node)) {
+                return [ContentElement.text(node.text)];
+            }
+        });
+        this.handle('list', async (node) => {
+            if (nodeNameIn(node, ['ul', 'ol'])) {
+                const listType = node.name === 'ul' ? 'unordered' : 'ordered';
+                return this.createList(node, listType);
+            }
+        });
+        this.handle('table', (node) => {
+            if (nodeNameIs(node, 'table')) {
+                return this.handleTable(node);
+            }
+        });
+    }
+    async parse(xml) {
+        const doc = new xmldoc.XmlDocument(xml);
+        const elements = await this.process(doc);
+        return elements || [];
+    }
+    handle(name, handler) {
+        if (this.handlers.node.has(name)) {
+            throw new Error(`${name} node handler already set`);
+        }
+        this.handlers.node.set(name, handler);
+    }
+    wrap(name, handler) {
+        if (this.handlers.wrap.has(name)) {
+            throw new Error(`${name} wrap handler already set`);
+        }
+        this.handlers.wrap.set(name, handler);
+    }
+    addTextAdditionalProperties(c, parent) {
+        const additionalProperties = c.additional_properties || {};
+        const parentNodeIsBlockElement = this.isBlockElement(parent);
+        c.additional_properties = {
+            ...c.additional_properties,
+            isBlockElement: additionalProperties.isBlockElement || parentNodeIsBlockElement,
+        };
+        return c;
+    }
+    wrapChildrenTextNodes(node, elements) {
+        const wrapped = [];
+        for (const c of elements) {
+            if (!isTextCE(c)) {
+                wrapped.push(c);
+                continue;
+            }
+            this.addTextAdditionalProperties(c, node);
+            const handler = this.handlers.wrap.get(node.name);
+            if (handler) {
+                wrapped.push({
+                    ...c,
+                    content: handler(node, c.content),
+                });
+            }
+            else {
+                wrapped.push(c);
+            }
+        }
+        return wrapped;
+    }
+    async handleNested(node) {
+        const children = await Promise.all(node.children.map((child) => this.process(child)));
+        const filtered = children.filter(Boolean).flat();
+        const merged = this.mergeParagraphs(filtered);
+        const wrapped = this.wrapChildrenTextNodes(node, merged);
+        return wrapped;
+    }
+    async process(node) {
+        let isKnownNode = false;
+        const elements = [];
+        for (const [name, handler] of this.handlers.node.entries()) {
+            try {
+                const result = await handler(node);
+                if (Array.isArray(result)) {
+                    // if handler returns an array of elements, it means that the node was handled properly, even if there is no elements inside
+                    isKnownNode = true;
+                    elements.push(...result);
+                    break;
+                }
+            }
+            catch (error) {
+                this.warn({ node: node.toString(), error: error.toString(), name }, 'HandlerError');
+            }
+        }
+        if (isKnownNode)
+            return elements;
+        this.warn({ node: node.toString(), type: node.type }, 'UnknownNodeError');
+    }
+    mergeParagraphs(items) {
+        const merged = [];
+        let toMerge = [];
+        const merge = () => {
+            if (!toMerge.length)
+                return;
+            const paragraph = toMerge.reduce((acc, p) => {
+                return {
+                    ...p,
+                    content: acc.content + p.content,
+                };
+            }, { type: 'text', content: '' });
+            merged.push(paragraph);
+            toMerge = [];
+        };
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            const isBlockElement = item.additional_properties?.isBlockElement;
+            if (isTextCE(item) && !isBlockElement) {
+                toMerge.push(item);
+            }
+            else {
+                merge();
+                merged.push(item);
+            }
+        }
+        merge();
+        return merged;
+    }
+    async handleTable(node) {
+        const html = node.toString({ html: true });
+        return [ContentElement.raw_html(html)];
+    }
+    async createQuote(node) {
+        const items = await this.handleNested(node);
+        return [ContentElement.quote(items)];
+    }
+    async createList(node, type) {
+        const items = await this.handleNested(node);
+        return [ContentElement.list(type, items)];
+    }
+    getNodeInnerText(node) {
+        return node.children.map((n) => this.htmlFromNode(n).innerText.trim());
+    }
+    getNodeInnerHTML(node) {
+        return node.children.map((n) => this.htmlFromNode(n).innerHTML.trim());
+    }
+    htmlFromNode(node) {
+        return parse(node.toString({ html: true }));
+    }
+    getDecodedHTMLFromInnerNodes(node) {
+        const encodedHtml = this.getNodeInnerText(node).join('');
+        const decoded = decodeHTMLEntities(encodedHtml);
+        return decoded;
+    }
+    isBlockElement(node) {
+        const defaultBlockElements = new Set(this.blockElementTags);
+        if (defaultBlockElements.has(node.name))
+            return true;
+    }
+    warn(metadata, message) {
+        console.warn(metadata, message);
+    }
+}
+
+var index$3 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    Constants: xml_constants,
+    Utils: xml_utils,
+    XMLProcessor: XMLProcessor
+});
+
 var index$2 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    ContentElement: ContentElement,
-    HTML: index$3
+    ContentElement: ContentElement$1,
+    HTML: index$4,
+    XML: index$3
 });
 
 /**