native-document 1.0.118 → 1.0.120

package/src/core/elements/anchor/one-child-anchor-overwriting.js

@@ -0,0 +1,66 @@
+import {Validator} from "../../../../index";
+import {ElementCreator} from "../../wrappers/ElementCreator";
+
+
+export default function oneChildAnchorOverwriting(anchor, parent) {
+
+    anchor.remove = () => {
+        anchor.append.apply(anchor, parent.childNodes);
+    };
+    anchor.getParent = () => parent;
+
+    anchor.appendChild = (child) => {
+        child = Validator.isElement(child) ? child : ElementCreator.getChild(child);
+        parent.appendChild(child);
+    };
+
+    anchor.appendChildRaw = parent.appendChild.bind(parent);
+    anchor.append = anchor.appendChild;
+    anchor.appendRaw = anchor.appendChildRaw;
+
+    anchor.insertAtStart = (child) => {
+        child = Validator.isElement(child) ? child : ElementCreator.getChild(child);
+        parent.firstChild ? parent.insertBefore(child, parent.firstChild) : parent.appendChild(child);
+    };
+    anchor.insertAtStartRaw = (child) => {
+        parent.firstChild ? parent.insertBefore(child, parent.firstChild) : parent.appendChild(child);
+    };
+
+    anchor.appendElement = anchor.appendChild;
+
+    anchor.removeChildren = () => {
+        parent.textContent = '';
+    };
+
+    anchor.replaceContent = function(content) {
+        const child = Validator.isElement(content) ? content : ElementCreator.getChild(content);
+        parent.replaceChildren(child);
+    };
+
+    anchor.replaceContentRaw = function(child) {
+        parent.replaceChildren(child);
+    };
+    anchor.setContent = anchor.replaceContent;
+
+    anchor.insertBefore = (child, anchor) => {
+        child = Validator.isElement(child) ? child : ElementCreator.getChild(child);
+        parent.insertBefore(child, anchor);
+    };
+    anchor.insertBeforeRaw = (child, anchor) => {
+        parent.insertBefore(child, anchor);
+    };
+
+    anchor.appendChildBefore = anchor.insertBefore;
+    anchor.appendChildBeforeRaw = anchor.insertBeforeRaw;
+
+    anchor.clear = anchor.remove;
+    anchor.detach = anchor.remove;
+
+    anchor.replaceChildren = function() {
+        parent.replaceChildren(...arguments);
+    };
+
+    anchor.getByIndex = (index) => {
+        return parent.childNodes[index];
+    };
+}

package/src/core/elements/control/for-each-array.js

@@ -1,4 +1,4 @@
-import Anchor from "../../elements/anchor";
+import Anchor from "../anchor/anchor";
 import {Observable} from "../../data/Observable";
 import Validator from "../../utils/validator";
 import { ElementCreator } from "../../wrappers/ElementCreator";
@@ -36,6 +36,9 @@ export function ForEachArray(data, callback, configs = {}) {
 
     const clear = (items) => {
         element.removeChildren();
+        clearCacheOnly(items)
+    };
+    const clearCacheOnly = (items) => {
         cleanCache(items);
         lastNumberOfItems = 0;
     };
@@ -114,21 +117,23 @@ export function ForEachArray(data, callback, configs = {}) {
     };
 
 
-    const cleanCache = (items) => {
-        if(!isIndexRequired) {
-            cache.clear();
-            return;
-        }
-        if(configs.shouldKeepItemsInCache) {
-            return;
-        }
-        for (const [itemAsKey, _] of cache.entries()) {
-            if(items && items.includes(itemAsKey)) {
-                continue;
+    let cleanCache;
+
+    if(!isIndexRequired) {
+        cleanCache = cache.clear.bind(cache);
+    }
+    else if(configs.shouldKeepItemsInCache) {
+        cleanCache = () => {};
+    } else {
+        cleanCache = (items) => {
+            for (const [itemAsKey, _] of cache.entries()) {
+                if(items && items.includes(itemAsKey)) {
+                    continue;
+                }
+                removeCacheItem(itemAsKey, false);
             }
-            removeCacheItem(itemAsKey, false);
-        }
-    };
+        };
+    }
 
     const removeByItem = (item, fragment) => {
         const cacheItem = cache.get(item);
@@ -148,7 +153,7 @@ export function ForEachArray(data, callback, configs = {}) {
     };
 
     const Actions = {
-        toFragment(items){
+        toFragment: (items) =>{
             const fragment = document.createDocumentFragment();
             for(let i = 0, length = items.length; i < length; i++) {
                 fragment.appendChild(buildItem(items[i], lastNumberOfItems));
@@ -156,14 +161,19 @@ export function ForEachArray(data, callback, configs = {}) {
             }
             return fragment;
         },
-        add(items) {
-            element.appendElement(Actions.toFragment(items));
+        add: (items) => {
+            element.appendChildRaw(Actions.toFragment(items));
+        },
+        replace: (items) => {
+            clearCacheOnly(items);
+            element.replaceContentRaw(Actions.toFragment(items));
         },
-        replace(items) {
-            clear(items);
-            Actions.add(items);
+        set: () => {
+            const items = data.val();
+            clearCacheOnly(items);
+            element.replaceContentRaw(Actions.toFragment(items));
         },
-        reOrder(items) {
+        reOrder: (items) => {
             let child = null;
             const fragment = document.createDocumentFragment();
             for(const item of items) {
@@ -173,24 +183,13 @@ export function ForEachArray(data, callback, configs = {}) {
                 }
             }
             child = null;
-            element.appendElement(fragment, blockEnd);
+            element.appendElementRaw(fragment);
         },
-        removeOne(element, index) {
+        removeOne: (element, index) => {
             removeCacheItem(element, true);
         },
         clear,
-        merge(items) {
-            Actions.add(items);
-        },
-        push(items) {
-            let delay = 0;
-            if(configs.pushDelay) {
-                delay = configs.pushDelay(items) ?? 0;
-            }
-
-            Actions.add(items, delay);
-        },
-        populate([target, iteration, callback]) {
+        populate: ([target, iteration, callback]) => {
             const fragment = document.createDocumentFragment();
             for (let i = 0; i < iteration; i++) {
                 const data = callback(i);
@@ -198,13 +197,13 @@ export function ForEachArray(data, callback, configs = {}) {
                 fragment.append(buildItem(data, i));
                 lastNumberOfItems++;
             }
-            element.appendChild(fragment);
+            element.appendChildRaw(fragment);
             fragment.replaceChildren();
         },
-        unshift(values){
-            element.insertBefore(Actions.toFragment(values), blockStart.nextSibling);
+        unshift: (values) => {
+            element.insertAtStartRaw(Actions.toFragment(values));
         },
-        splice(args, deleted) {
+        splice: (args, deleted) => {
             const [start, deleteCount, ...values] = args;
             let elementBeforeFirst = null;
             const garbageFragment = document.createDocumentFragment();
@@ -227,27 +226,27 @@ export function ForEachArray(data, callback, configs = {}) {
             garbageFragment.replaceChildren();
 
             if(values && values.length && elementBeforeFirst) {
-                element.insertBefore(Actions.toFragment(values), elementBeforeFirst.nextSibling);
+                element.insertBeforeRaw(Actions.toFragment(values), elementBeforeFirst.nextSibling);
             }
 
         },
-        reverse(_, reversed) {
+        reverse: (_, reversed) => {
             Actions.reOrder(reversed);
         },
-        sort(_, sorted) {
+        sort: (_, sorted) => {
             Actions.reOrder(sorted);
         },
-        remove(_, deleted) {
+        remove: (_, deleted)=> {
             Actions.removeOne(deleted);
         },
-        pop(_, deleted) {
+        pop: (_, deleted) => {
             Actions.removeOne(deleted);
         },
-        shift(_, deleted) {
+        shift: (_, deleted) => {
             Actions.removeOne(deleted);
         },
-        swap(args, elements) {
-            const parent = blockEnd.parentNode;
+        swap: (args, elements) => {
+            const parent = element.getParent();
 
             let childA = getItemChild(elements[0]);
             let childB = getItemChild(elements[1]);
@@ -262,37 +261,22 @@ export function ForEachArray(data, callback, configs = {}) {
             childB = null;
         }
     };
+    Actions.merge = Actions.add;
+    Actions.push = Actions.add;
 
-    const buildContent = (items, _, operations) => {
-        if(operations?.action === 'clear' || !items.length) {
-            if(lastNumberOfItems === 0) {
-                return;
-            }
-            clear();
-            return;
-        }
-        selectBuildStrategy(operations?.action);
+    const buildContent = (items, _, operations = {}) => {
+        selectBuildStrategy(operations.action);
 
-        if(!operations?.action) {
-            if(lastNumberOfItems === 0) {
-                Actions.add(items);
-                return;
-            }
-            Actions.replace(items);
-        }
-        else if(Actions[operations.action]) {
+        if(Actions[operations.action]) {
             Actions[operations.action](operations.args, operations.result);
         }
-
         updateIndexObservers(items, 0);
     };
 
     if(data.val().length) {
         buildContent(data.val(), null, {action: null});
     }
-    if(Validator.isObservable(data)) {
-        data.subscribe(buildContent);
-    }
+    data.subscribe(buildContent);
 
     return element;
 }

package/src/core/elements/control/for-each.js

@@ -1,6 +1,6 @@
 import {Observable} from "../../data/Observable";
 import Validator from "../../utils/validator";
-import Anchor from "../../elements/anchor";
+import Anchor from "../anchor/anchor";
 import DebugManager from "../../utils/debug-manager";
 import {getKey} from "../../utils/helpers";
 import { ElementCreator } from "../../wrappers/ElementCreator";

package/src/core/elements/control/show-if.js

@@ -1,7 +1,7 @@
 import { Observable } from "../../data/Observable";
 import Validator from "../../utils/validator";
 import DebugManager from "../../utils/debug-manager.js";
-import Anchor from "../../elements/anchor";
+import Anchor from "../anchor/anchor";
 import {ElementCreator} from "../../wrappers/ElementCreator";
 
 /**

package/src/core/elements/control/switch.js

@@ -1,6 +1,6 @@
 import NativeDocumentError from "../../errors/NativeDocumentError";
 import Validator from "../../utils/validator";
-import Anchor from "../../elements/anchor";
+import Anchor from "../anchor/anchor";
 import {ElementCreator} from "../../wrappers/ElementCreator";
 
 

package/src/core/wrappers/ElementCreator.js

@@ -1,4 +1,4 @@
-import Anchor from "../elements/anchor";
+import Anchor from "../elements/anchor/anchor";
 import Validator from "../utils/validator";
 import AttributesWrapper, { bindClassAttribute, bindStyleAttribute } from "./AttributesWrapper";
 import PluginsManager from "../utils/plugins-manager";

package/src/core/wrappers/HtmlElementWrapper.js

@@ -1,5 +1,5 @@
 import Validator from "../utils/validator";
-import Anchor from "../elements/anchor";
+import Anchor from "../elements/anchor/anchor";
 import {ElementCreator} from "./ElementCreator";
 import './NdPrototype';
 import {normalizeComponentArgs} from "../utils/args-types";
@@ -10,9 +10,10 @@ import {normalizeComponentArgs} from "../utils/args-types";
  * @returns {Text}
  */
 export const createTextNode = (value) => {
-    return (Validator.isObservable(value))
-        ? ElementCreator.createObservableNode(null, value)
-        : ElementCreator.createStaticTextNode(null, value);
+    if(value) {
+        return value.toNdElement();
+    }
+    return ElementCreator.createTextNode();
 };
 
 

package/src/core/wrappers/SingletonView.js

@@ -1,4 +1,4 @@
-import Anchor from "../elements/anchor";
+import Anchor from "../elements/anchor/anchor";
 
 
 export function SingletonView($viewCreator) {

package/src/core/wrappers/prototypes/nd-element-extensions.js

@@ -9,6 +9,10 @@ String.prototype.toNdElement = function () {
     return ElementCreator.createStaticTextNode(null, this);
 };
 
+Number.prototype.toNdElement = function () {
+    return ElementCreator.createStaticTextNode(null, this.toString());
+};
+
 Element.prototype.toNdElement = function () {
     return this;
 };

package/src/core/wrappers/template-cloner/NodeCloner.js

@@ -50,8 +50,9 @@ NodeCloner.prototype.resolve = function() {
         const methods = Object.keys(this.$ndMethods);
         if(methods.length === 1) {
             const methodName = methods[0];
+            const callback = this.$ndMethods[methodName];
             steps.push((clonedNode, data) => {
-                clonedNode.nd[methodName](this.$ndMethods[methodName].bind(clonedNode, ...data));
+                clonedNode.nd[methodName](callback.bind(clonedNode, ...data));
             });
         } else {
             steps.push((clonedNode, data) => {