@zipify/wysiwyg 3.1.0-2 → 3.1.1

package/lib/services/NodeFactory.js

@@ -46,7 +46,7 @@ export class NodeFactory {
      * }}
      */
     static listItem(...args) {
-        const { attrs, content: children, marks } = this.#normalizeTextBlockArgs(args);
+        const { attrs, content: children, marks } = this._normalizeTextBlockArgs(args);
 
         return {
             type: NodeTypes.LIST_ITEM,
@@ -66,7 +66,7 @@ export class NodeFactory {
      * }}
      */
     static heading(level, ...args) {
-        const config = this.#textBlock(args, this.text);
+        const config = this._textBlock(args, this.text);
 
         config.attrs ??= {};
         config.attrs.level = level;
@@ -84,12 +84,12 @@ export class NodeFactory {
     static paragraph(...args) {
         return {
             type: NodeTypes.PARAGRAPH,
-            ...this.#textBlock(args, this.text)
+            ...this._textBlock(args, this.text)
         };
     }
 
-    static #textBlock(args) {
-        const { attrs, content, marks } = this.#normalizeTextBlockArgs(args);
+    static _textBlock(args) {
+        const { attrs, content, marks } = this._normalizeTextBlockArgs(args);
         const children = typeof content === 'string' ? [this.text(content)] : content;
 
         return {
@@ -99,7 +99,7 @@ export class NodeFactory {
         };
     }
 
-    static #normalizeTextBlockArgs(args) {
+    static _normalizeTextBlockArgs(args) {
         if (args.length === 1) {
             return { attrs: null, marks: null, content: args[0] };
         }

package/lib/services/StylePresetRenderer.js

@@ -2,14 +2,14 @@ import { Devices } from '../enums';
 import { ContextWindow } from './ContextWindow';
 
 export class StylePresetRenderer {
-    #baseClass;
-    #makeVariable;
-    #linkPresetId;
+    _baseClass;
+    _makeVariable;
+    _linkPresetId;
 
     constructor({ baseClass, makeVariable, linkPresetId }) {
-        this.#baseClass = baseClass;
-        this.#makeVariable = makeVariable;
-        this.#linkPresetId = linkPresetId;
+        this._baseClass = baseClass;
+        this._makeVariable = makeVariable;
+        this._linkPresetId = linkPresetId;
     }
 
     inject(hostEl, presets) {
@@ -28,15 +28,15 @@ export class StylePresetRenderer {
         let css = '';
 
         for (const preset of presets) {
-            const isLink = preset.id === this.#linkPresetId;
+            const isLink = preset.id === this._linkPresetId;
             const className = this.makePresetCssClass(preset);
 
             css += ` ${className} {`;
 
             for (const device of Devices.values) {
                 for (const setting of Object.keys(preset[device])) {
-                    const variable = this.#makeVariable({ device, preset, property: setting });
-                    const internalVariable = this.#makeInternalVariableName(setting, device);
+                    const variable = this._makeVariable({ device, preset, property: setting });
+                    const internalVariable = this._makeInternalVariableName(setting, device);
 
                     css += `${internalVariable}: var(${variable}, inherit);`;
 
@@ -56,7 +56,7 @@ export class StylePresetRenderer {
         return css;
     }
 
-    #makeInternalVariableName(setting, device) {
+    _makeInternalVariableName(setting, device) {
         const property = setting === 'color' ? 'font-color' : setting.replace(/_/i, '-');
         const prefix = device === Devices.COMMON ? '' : `-${device}`;
 
@@ -64,7 +64,7 @@ export class StylePresetRenderer {
     }
 
     makePresetHtmlClass(preset) {
-        return this.#baseClass + preset.id;
+        return this._baseClass + preset.id;
     }
 
     makePresetCssClass(preset) {

package/lib/services/__tests__/JsonSerializer.test.js

@@ -10,7 +10,7 @@ describe('decode', () => {
     test('should return null on error', () => {
         const json = JsonSerializer.decode('{ "tes');
 
-        expect(json).toBe(null);
+        expect(json).toBeNull();
     });
 });
 

package/lib/services/__tests__/Storage.test.js

@@ -20,7 +20,7 @@ describe('get item', () => {
             storage: createNativeStorage({})
         });
 
-        expect(storage.getItem('test')).toBe(null);
+        expect(storage.getItem('test')).toBeNull();
     });
 
     test('should parse json', () => {

package/lib/services/__tests__/StylePresetRenderer.test.js

@@ -51,7 +51,7 @@ describe('inject styles', () => {
         renderer.inject(host, presets);
         renderer.inject(host, presets);
 
-        expect(host.querySelectorAll('[data-zw-styles]').length).toBe(1);
+        expect(host.querySelectorAll('[data-zw-styles]')).toHaveLength(1);
     });
 });
 

package/lib/services/normalizer/BrowserDomParser.js

@@ -1,8 +1,8 @@
 export class BrowserDomParser {
-    #domParser = new DOMParser();
+    _domParser = new DOMParser();
     types = window;
 
     parse(html) {
-        return this.#domParser.parseFromString(html, 'text/html');
+        return this._domParser.parseFromString(html, 'text/html');
     }
 }

package/lib/services/normalizer/ContentNormalizer.js

@@ -4,17 +4,17 @@ import { JsonNormalizer } from './JsonNormalizer';
 
 export class ContentNormalizer {
     static build(content, options = {}) {
-        return typeof content === 'string' ? this.#buildHtml(content, options) : this.#buildJson(content);
+        return typeof content === 'string' ? this._buildHtml(content, options) : this._buildJson(content);
     }
 
-    static #buildHtml(content, options) {
+    static _buildHtml(content, options) {
         return new HtmlNormalizer({
             content,
             parser: options.parser || new BrowserDomParser()
         });
     }
 
-    static #buildJson(content) {
+    static _buildJson(content) {
         return new JsonNormalizer({ content });
     }
 

package/lib/services/normalizer/HtmlNormalizer.js

@@ -14,11 +14,11 @@ export class HtmlNormalizer extends BaseNormalizer {
         'margin-right'
     ];
 
-    #parser;
+    _parser;
 
     constructor({ content, parser }) {
         super({ content });
-        this.#parser = parser;
+        this._parser = parser;
         this.dom = null;
     }
 
@@ -28,42 +28,42 @@ export class HtmlNormalizer extends BaseNormalizer {
     }
 
     normalizeHTML() {
-        this.dom = this.#parser.parse(this.content.replace(/(\r)?\n/g, ''));
-
-        this.#removeComments();
-        this.#normalizeRootTags();
-        this.#iterateNodes(this.#normalizeBreakLines, (node) => node.tagName === 'BR');
-        this.#iterateNodes(this.#removeEmptyNodes, this.#isBlockNode);
-        this.#iterateNodes(this.#normalizeListItems, (node) => node.tagName === 'LI');
-        this.#normalizeBlockTextDecoration();
-        this.#normalizeBlockBackgroundColor();
+        this.dom = this._parser.parse(this.content.replace(/(\r)?\n/g, ''));
+
+        this._removeComments();
+        this._normalizeRootTags();
+        this._iterateNodes(this._normalizeBreakLines, (node) => node.tagName === 'BR');
+        this._iterateNodes(this._removeEmptyNodes, this._isBlockNode);
+        this._iterateNodes(this._normalizeListItems, (node) => node.tagName === 'LI');
+        this._normalizeBlockTextDecoration();
+        this._normalizeBlockBackgroundColor();
     }
 
     get normalizedHTML() {
         return this.dom.body.innerHTML;
     }
 
-    get #NodeFilter() {
-        return this.#parser.types.NodeFilter;
+    get _NodeFilter() {
+        return this._parser.types.NodeFilter;
     }
 
-    get #Node() {
-        return this.#parser.types.Node;
+    get _Node() {
+        return this._parser.types.Node;
     }
 
-    #removeComments() {
-        const iterator = this.#createNodeIterator(this.#NodeFilter.SHOW_COMMENT);
+    _removeComments() {
+        const iterator = this._createNodeIterator(this._NodeFilter.SHOW_COMMENT);
 
-        this.#runIterator(iterator, (node) => node.remove());
+        this._runIterator(iterator, (node) => node.remove());
     }
 
-    #normalizeRootTags() {
+    _normalizeRootTags() {
         const children = Array.from(this.dom.body.childNodes);
         const fragment = this.dom.createDocumentFragment();
         let capturingParagraph;
 
         for (const node of children) {
-            if (this.#isRootNode(node)) {
+            if (this._isRootNode(node)) {
                 fragment.append(node);
                 capturingParagraph = null;
                 continue;
@@ -81,21 +81,21 @@ export class HtmlNormalizer extends BaseNormalizer {
         this.dom.body.append(fragment);
     }
 
-    #createNodeIterator(whatToShow, filter) {
+    _createNodeIterator(whatToShow, filter) {
         return this.dom.createNodeIterator(this.dom.body, whatToShow, filter);
     }
 
-    #iterateNodes(handler, condition = () => true) {
+    _iterateNodes(handler, condition = () => true) {
         const checkCondition = (node) => node.tagName !== 'BODY' && condition.call(this, node);
 
-        const iterator = this.#createNodeIterator(this.#NodeFilter.SHOW_ELEMENT, {
-            acceptNode: (node) => checkCondition(node) ? this.#NodeFilter.FILTER_ACCEPT : this.#NodeFilter.FILTER_REJECT
+        const iterator = this._createNodeIterator(this._NodeFilter.SHOW_ELEMENT, {
+            acceptNode: (node) => checkCondition(node) ? this._NodeFilter.FILTER_ACCEPT : this._NodeFilter.FILTER_REJECT
         });
 
-        this.#runIterator(iterator, handler);
+        this._runIterator(iterator, handler);
     }
 
-    #runIterator(iterator, handler) {
+    _runIterator(iterator, handler) {
         let currentNode = iterator.nextNode();
 
         while (currentNode) {
@@ -104,24 +104,24 @@ export class HtmlNormalizer extends BaseNormalizer {
         }
     }
 
-    #removeEmptyNodes(node) {
+    _removeEmptyNodes(node) {
         if (!node.innerHTML.trim()) node.remove();
     }
 
-    #normalizeListItems(itemEl) {
+    _normalizeListItems(itemEl) {
         const fragment = this.dom.createDocumentFragment();
         const children = Array.from(itemEl.childNodes);
         let capturingParagraph, previousNode;
 
         const append = (node) => {
-            this.#assignElementProperties(node, itemEl, HtmlNormalizer.BLOCK_STYLES);
+            this._assignElementProperties(node, itemEl, HtmlNormalizer.BLOCK_STYLES);
             fragment.append(node);
         };
 
-        this.#assignElementProperties(itemEl, itemEl.parentElement, HtmlNormalizer.BLOCK_STYLES);
+        this._assignElementProperties(itemEl, itemEl.parentElement, HtmlNormalizer.BLOCK_STYLES);
 
         for (const node of children) {
-            if (this.#isBlockNode(node)) {
+            if (this._isBlockNode(node)) {
                 append(node);
                 capturingParagraph = null;
                 previousNode = node;
@@ -154,18 +154,18 @@ export class HtmlNormalizer extends BaseNormalizer {
         }
 
         itemEl.append(fragment);
-        this.#removeStyleProperties(itemEl, HtmlNormalizer.BLOCK_STYLES);
+        this._removeStyleProperties(itemEl, HtmlNormalizer.BLOCK_STYLES);
     }
 
-    #isBlockNode(node) {
+    _isBlockNode(node) {
         return HtmlNormalizer.BLOCK_NODE_NAMES.includes(node.tagName);
     }
 
-    #isRootNode(node) {
+    _isRootNode(node) {
         return HtmlNormalizer.ROOT_NODE_NAMES.includes(node.tagName);
     }
 
-    #assignElementProperties(target, source, properties) {
+    _assignElementProperties(target, source, properties) {
         for (const property of properties) {
             const value = source.style.getPropertyValue(property);
 
@@ -175,7 +175,7 @@ export class HtmlNormalizer extends BaseNormalizer {
         }
     }
 
-    #removeStyleProperties(element, properties) {
+    _removeStyleProperties(element, properties) {
         for (const property of properties) {
             element.style.removeProperty(property);
         }
@@ -185,8 +185,8 @@ export class HtmlNormalizer extends BaseNormalizer {
         }
     }
 
-    #normalizeBreakLines({ parentElement }) {
-        if (!this.#isBlockNode(parentElement)) return;
+    _normalizeBreakLines({ parentElement }) {
+        if (!this._isBlockNode(parentElement)) return;
         if (!parentElement.textContent) return;
 
         const fragment = this.dom.createDocumentFragment();
@@ -197,7 +197,7 @@ export class HtmlNormalizer extends BaseNormalizer {
         let capturingParagraph = parentTemplate.cloneNode();
 
         const append = (node) => {
-            this.#assignElementProperties(node, parentElement, HtmlNormalizer.BLOCK_STYLES);
+            this._assignElementProperties(node, parentElement, HtmlNormalizer.BLOCK_STYLES);
             fragment.append(node);
         };
 
@@ -215,16 +215,16 @@ export class HtmlNormalizer extends BaseNormalizer {
         parentElement.replaceWith(fragment);
     }
 
-    #normalizeBlockTextDecoration() {
+    _normalizeBlockTextDecoration() {
         const blockEls = this.dom.querySelectorAll('[style*="text-decoration"]:where(p, h1, h2, h3, h4, li)');
 
         for (const blockEl of blockEls) {
-            this.#moveTextDecorationToChildren(blockEl);
+            this._moveTextDecorationToChildren(blockEl);
         }
     }
 
-    #moveTextDecorationToChildren(blockEl) {
-        const blockDecoration = this.#parseTextDecoration(blockEl);
+    _moveTextDecorationToChildren(blockEl) {
+        const blockDecoration = this._parseTextDecoration(blockEl);
 
         blockEl.style.removeProperty('text-decoration-line');
         blockEl.style.removeProperty('text-decoration');
@@ -233,8 +233,8 @@ export class HtmlNormalizer extends BaseNormalizer {
         if (blockDecoration.none) return;
 
         for (const childNode of blockEl.childNodes) {
-            const textEl = this.#wrapTextNode(blockEl, childNode);
-            const textDecoration = this.#parseTextDecoration(textEl);
+            const textEl = this._wrapTextNode(blockEl, childNode);
+            const textDecoration = this._parseTextDecoration(textEl);
 
             const mergedDecoration = {
                 underline: textDecoration.underline || blockDecoration.underline,
@@ -251,7 +251,7 @@ export class HtmlNormalizer extends BaseNormalizer {
         }
     }
 
-    #parseTextDecoration(element) {
+    _parseTextDecoration(element) {
         const { textDecoration, textDecorationLine } = element.style;
         const decoration = textDecoration || textDecorationLine || '';
 
@@ -262,30 +262,30 @@ export class HtmlNormalizer extends BaseNormalizer {
         };
     }
 
-    #normalizeBlockBackgroundColor() {
+    _normalizeBlockBackgroundColor() {
         const blockEls = this.dom.querySelectorAll('[style*="background-color"]:where(p, h1, h2, h3, h4, li)');
 
         for (const blockEl of blockEls) {
-            this.#moveBackgroundColorToChildren(blockEl);
+            this._moveBackgroundColorToChildren(blockEl);
         }
     }
 
-    #moveBackgroundColorToChildren(blockEl) {
+    _moveBackgroundColorToChildren(blockEl) {
         const blockColor = blockEl.style.backgroundColor;
 
         blockEl.style.removeProperty('background-color');
         if (!blockEl.style.cssText) blockEl.removeAttribute('style');
 
         for (const childNode of blockEl.childNodes) {
-            const textEl = this.#wrapTextNode(blockEl, childNode);
+            const textEl = this._wrapTextNode(blockEl, childNode);
             const color = textEl.style.backgroundColor || blockColor;
 
             textEl.style.backgroundColor = color;
         }
     }
 
-    #wrapTextNode(parent, node) {
-        if (node.nodeType !== this.#Node.TEXT_NODE) return node;
+    _wrapTextNode(parent, node) {
+        if (node.nodeType !== this._Node.TEXT_NODE) return node;
 
         const span = this.dom.createElement('span');
 

package/lib/services/normalizer/JsonNormalizer.js

@@ -4,22 +4,22 @@ import { BaseNormalizer } from './BaseNormalizer';
 
 export class JsonNormalizer extends BaseNormalizer {
     normalize() {
-        this.#iterateNodes(this.#bubbleMarks);
+        this._iterateNodes(this._bubbleMarks);
         return this.content;
     }
 
-    #iterateNodes(handler) {
-        this.#iterateChildNodes(this.content, handler);
+    _iterateNodes(handler) {
+        this._iterateChildNodes(this.content, handler);
     }
 
-    #iterateChildNodes(node, handler) {
+    _iterateChildNodes(node, handler) {
         for (const child of node.content) {
-            child.content && this.#iterateChildNodes(child, handler);
+            child.content && this._iterateChildNodes(child, handler);
             handler.call(this, child);
         }
     }
 
-    #bubbleMarks(node) {
+    _bubbleMarks(node) {
         if (!node.content) return;
         if (node.type === NodeTypes.LIST) return;
 
@@ -27,56 +27,56 @@ export class JsonNormalizer extends BaseNormalizer {
             if (!child.marks) continue;
 
             for (const childMark of child.marks.slice()) {
-                if (this.#includesMark(node, childMark)) {
-                    this.#removeMark(child, childMark);
+                if (this._includesMark(node, childMark)) {
+                    this._removeMark(child, childMark);
                     continue;
                 }
 
-                if (this.#canBubbleMark(node, childMark)) {
-                    this.#removeMark(child, childMark);
-                    this.#addMark(node, childMark);
+                if (this._canBubbleMark(node, childMark)) {
+                    this._removeMark(child, childMark);
+                    this._addMark(node, childMark);
                 }
             }
         }
     }
 
-    #canBubbleMark(node, childMark) {
+    _canBubbleMark(node, childMark) {
         if (TextSettings.inlineMarks.includes(childMark.type)) return false;
-        if (this.#includesMarkType(node, childMark.type)) return false;
+        if (this._includesMarkType(node, childMark.type)) return false;
 
         for (const child of node.content) {
             if (!child.content && node.type === NodeTypes.LIST_ITEM) continue;
             if (!child.marks) return false;
-            if (!this.#includesMark(child, childMark)) return false;
+            if (!this._includesMark(child, childMark)) return false;
         }
 
         return true;
     }
 
-    #includesMark(node, checkingMark) {
+    _includesMark(node, checkingMark) {
         return node.marks?.some((mark) => isEqual(mark, checkingMark)) ?? false;
     }
 
-    #includesMarkType(node, type) {
+    _includesMarkType(node, type) {
         return node.marks?.some((mark) => mark.type === type) ?? false;
     }
 
-    #removeMark(node, mark) {
+    _removeMark(node, mark) {
         if (!node.marks) return;
 
-        const index = this.#findMarkIndexByType(node, mark.type);
+        const index = this._findMarkIndexByType(node, mark.type);
 
         if (index >= 0) node.marks.splice(index, 1);
         if (!node.marks.length) delete node.marks;
     }
 
-    #addMark(node, mark) {
-        this.#removeMark(node, mark);
+    _addMark(node, mark) {
+        this._removeMark(node, mark);
         node.marks ??= [];
         node.marks.push(mark);
     }
 
-    #findMarkIndexByType(node, type) {
+    _findMarkIndexByType(node, type) {
         return node.marks?.findIndex((mark) => mark.type === type) ?? null;
     }
 }

package/lib/utils/__tests__/convertAlignment.test.js

@@ -11,6 +11,6 @@ describe('convert alignment', () => {
     });
 
     test('should return null if cannot convert', () => {
-        expect(convertAlignment('test-test')).toBe(null);
+        expect(convertAlignment('test-test')).toBeNull();
     });
 });

package/lib/utils/__tests__/renderInlineSetting.test.js

@@ -50,7 +50,7 @@ describe('render settings', () => {
     test('should return null if no styles', () => {
         const result = renderInlineSetting({});
 
-        expect(result).toBe(null);
+        expect(result).toBeNull();
     });
 
     test('should return null if all styles empty', () => {
@@ -60,6 +60,6 @@ describe('render settings', () => {
             desktop_font_size: null
         });
 
-        expect(result).toBe(null);
+        expect(result).toBeNull();
     });
 });