native-document 1.0.103 → 1.0.105

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

@@ -4,6 +4,9 @@ import Validator from "../../utils/validator";
 import { ElementCreator } from "../../wrappers/ElementCreator";
 import NativeDocumentError from "../../errors/NativeDocumentError";
 
+
+const CREATE_AND_CACHE_ACTIONS = new Set(['clear', 'push', 'unshift', 'replace']);
+
 /**
  * Renders items from an ObservableArray with optimized array-specific updates.
  * Provides index observables and handles array mutations efficiently.
@@ -64,50 +67,67 @@ export function ForEachArray(data, callback, configs = {}) {
         if(removeChild) {
             const child = cacheItem.child;
             child?.remove();
-            cache.delete(cacheItem.keyId);
+            cache.delete(item);
         }
         cacheItem.indexObserver?.cleanup();
     };
 
-    const cleanCache = (items) => {
-        if(configs.shouldKeepItemsInCache) {
-            return;
-        }
-        if(!isIndexRequired) {
-            cache.clear();
-            return;
+    const createAndCache = (item) => {
+        const child = ElementCreator.getChild(callback(item, null));
+        if(process.env.NODE_ENV === 'development') {
+            if(!child) {
+                throw new NativeDocumentError("ForEachArray child can't be null or undefined!");
+            }
         }
-        for (const [itemAsKey, _] of cache.entries()) {
-            if(items && items.contains(itemAsKey)) {
-                continue;
+        cache.set(item, { child, indexObserver: null });
+        return child;
+    };
+
+    const createWithIndexAndCache = (item, indexKey) => {
+        const indexObserver = Observable(indexKey);
+        const child = ElementCreator.getChild(callback(item, indexObserver));
+        if(process.env.NODE_ENV === 'development') {
+            if(!child) {
+                throw new NativeDocumentError("ForEachArray child can't be null or undefined!");
             }
-            removeCacheItem(itemAsKey, false);
         }
-        cache.clear();
-    }
+        cache.set(item, { child, indexObserver  });
+        return child;
+    };
 
-    const buildItem = (item, indexKey) => {
+    const getOrCreate = (item, indexKey) => {
         const cacheItem = cache.get(item);
         if(cacheItem) {
             cacheItem.indexObserver?.set(indexKey);
-            const child = cacheItem.child;
-            if(child) {
-                return child;
-            }
-            cache.delete(item);
+            return cacheItem.child;
         }
+        return createAndCache(item, indexKey);
+    };
 
-        const indexObserver = isIndexRequired ? Observable(indexKey) : null;
-        let child = ElementCreator.getChild(callback(item, indexObserver));
-        if(child) {
-            cache.set(item, {
-                child,
-                indexObserver
-            });
-            return child;
+    let buildItem = createAndCache;
+    const selectBuildStrategy = (action = null) => {
+        if(CREATE_AND_CACHE_ACTIONS.includes(action)) {
+            buildItem = isIndexRequired ? createWithIndexAndCache : createAndCache;
+            return;
         }
+        buildItem = cache.size ? getOrCreate : (isIndexRequired ? createWithIndexAndCache : createAndCache);
+    };
+
 
-        throw new NativeDocumentError("ForEachArray child can't be null or undefined!");
+    const cleanCache = (items) => {
+        if(!isIndexRequired) {
+            cache.clear();
+            return;
+        }
+        if(configs.shouldKeepItemsInCache) {
+            return;
+        }
+        for (const [itemAsKey, _] of cache.entries()) {
+            if(items && items.includes(itemAsKey)) {
+                continue;
+            }
+            removeCacheItem(itemAsKey, false);
+        }
     };
 
     const removeByItem = function(item, fragment) {
@@ -125,10 +145,10 @@ export function ForEachArray(data, callback, configs = {}) {
             return;
         }
         child.remove();
-    }
+    };
 
     const Actions = {
-        toFragment(items, startIndexFrom = 0){
+        toFragment(items){
             const fragment = document.createDocumentFragment();
             for(let i = 0, length = items.length; i < length; i++) {
                 fragment.appendChild(buildItem(items[i], lastNumberOfItems));
@@ -136,7 +156,7 @@ export function ForEachArray(data, callback, configs = {}) {
             }
             return fragment;
         },
-        add(items, delay = 2) {
+        add(items) {
             element.appendElement(Actions.toFragment(items));
         },
         replace(items) {
@@ -251,6 +271,7 @@ export function ForEachArray(data, callback, configs = {}) {
             clear();
             return;
         }
+        selectBuildStrategy(operations?.action);
 
         if(!operations?.action) {
             if(lastNumberOfItems === 0) {

package/src/core/elements/index.js

@@ -1,4 +1,4 @@
-import Anchor from "./anchor";
+import HtmlElementWrapper from "../wrappers/HtmlElementWrapper";
 
 export * from './control/for-each';
 export * from './control/for-each-array';
@@ -19,15 +19,9 @@ export * from './table';
 /**
  * Creates an empty `DocumentFragment` wrapper.
  * Useful for grouping elements without adding a DOM node.
- * @param {NdChild} children
  * @type {function(GlobalAttributes=, NdChild|NdChild[]=): DocumentFragment}
- * @returns {Anchor}
  */
-export const Fragment = (children) => {
-    const fragment = Anchor('Fragment');
-    fragment.append(children);
-    return fragment;
-};
+export const Fragment = HtmlElementWrapper('');
 
 
 

package/src/core/utils/validator.js

@@ -11,6 +11,13 @@ const COMMON_NODE_TYPES = {
     DOCUMENT_FRAGMENT: 11
 };
 
+const VALID_TYPES = {
+    [COMMON_NODE_TYPES.ELEMENT]: true,
+    [COMMON_NODE_TYPES.TEXT]: true,
+    [COMMON_NODE_TYPES.DOCUMENT_FRAGMENT]: true,
+    [COMMON_NODE_TYPES.COMMENT]: true
+};
+
 const Validator = {
     isObservable(value) {
         return  value?.__$isObservable;
@@ -61,12 +68,10 @@ const Validator = {
         return !(typeof value !== 'object' || value === null || Array.isArray(value) || value.constructor.name !== 'Object')
     },
     isElement(value) {
-        return value && (
-            value.nodeType === COMMON_NODE_TYPES.ELEMENT ||
-            value.nodeType === COMMON_NODE_TYPES.TEXT ||
-            value.nodeType === COMMON_NODE_TYPES.DOCUMENT_FRAGMENT ||
-            value.nodeType === COMMON_NODE_TYPES.COMMENT
-        );
+        return value && VALID_TYPES[value.nodeType];
+    },
+    isDOMNode(value) {
+        return VALID_TYPES[value.nodeType];
     },
     isFragment(value) {
         return value?.nodeType === COMMON_NODE_TYPES.DOCUMENT_FRAGMENT;

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

@@ -7,11 +7,7 @@ import Validator from "../../utils/validator";
 import ObservableChecker from "../../data/ObservableChecker";
 
 String.prototype.toNdElement = function () {
-    const formattedChild = this.resolveObservableTemplate ? this.resolveObservableTemplate() : this;
-    if(Validator.isString(formattedChild)) {
-        return ElementCreator.createStaticTextNode(null, formattedChild);
-    }
-    return ElementCreator.getChild(null, formattedChild);
+    return ElementCreator.createStaticTextNode(null, this);
 };
 
 Element.prototype.toNdElement = function () {

package/src/router/Route.js

@@ -77,13 +77,13 @@ export function Route($path, $component, $options = {}) {
      *
      * @param {string} path
      */
-    this.match = function(path)  {
+    this.match = function(path) {
         path = '/'+trim(path, '/');
         const match = getPattern().exec(path);
         if(!match) return false;
         const params = {};
 
-        match.forEach((value, index) => {
+        getPattern().exec(path).forEach((value, index) => {
             if(index < 1) return;
             const name = $paramsNames[index - 1];
             params[name] = value;

package/types/service.d.ts

@@ -20,4 +20,4 @@ interface ServiceStatic {
     ): MemoizeProxy<(...args: Args) => T>;
 }
 
-export const Cache: ServiceStatic;
+export const Service: ServiceStatic;