@domql/element 2.5.124 → 2.5.125

package/create.js

@@ -24,7 +24,8 @@ import {
   isNode,
   isUndefined,
   generateKey,
-  deepCloneWithExtend
+  deepCloneWithExtend,
+  detectInfiniteLoop
 } from '@domql/utils'
 
 import OPTIONS from './cache/options'
@@ -35,7 +36,6 @@ import {
   applyVariant,
   checkIfKeyIsComponent,
   createValidDomqlObjectFromSugar,
-  detectInfiniteLoop,
   isVariant
 } from './utils/component'
 

package/dist/cjs/create.js

@@ -176,7 +176,7 @@ const renderElement = (element, parent, options, attachOptions) => {
   visitedElements.set(element, true);
   const { __ref: ref, key } = element;
   try {
-    const isInfiniteLoopDetected = (0, import_component.detectInfiniteLoop)(ref.__path);
+    const isInfiniteLoopDetected = (0, import_utils.detectInfiniteLoop)(ref.__path);
     if (ref.__uniqId || isInfiniteLoopDetected)
       return;
     (0, import_node.default)(element, options);

package/dist/cjs/update.js

@@ -36,12 +36,12 @@ var import_event = require("@domql/event");
 var import_methods = require("./methods");
 var import_props = require("./props");
 var import_state = require("@domql/state");
-var import_utils2 = require("./utils");
 var import_create = __toESM(require("./create"), 1);
 var import_iterate = require("./iterate");
 var import_mixins = require("./mixins");
 var import_applyParam = require("./utils/applyParam");
 var import_options = __toESM(require("./cache/options"), 1);
+var import_utils2 = require("./utils");
 const snapshot = {
   snapshotId: import_utils.createSnapshotId
 };

package/dist/cjs/utils/component.js

@@ -25,7 +25,6 @@ __export(component_exports, {
   checkIfKeyIsComponent: () => checkIfKeyIsComponent,
   checkIfKeyIsProperty: () => checkIfKeyIsProperty,
   createValidDomqlObjectFromSugar: () => createValidDomqlObjectFromSugar,
-  detectInfiniteLoop: () => detectInfiniteLoop,
   extendizeByKey: () => extendizeByKey,
   hasVariantProp: () => hasVariantProp,
   isVariant: () => isVariant,
@@ -175,26 +174,3 @@ const applyVariant = (element) => {
   });
   return element;
 };
-const detectInfiniteLoop = (arr) => {
-  const maxRepeats = 10;
-  let pattern = [];
-  let repeatCount = 0;
-  for (let i = 0; i < arr.length; i++) {
-    if (pattern.length < 2) {
-      pattern.push(arr[i]);
-    } else {
-      if (arr[i] === pattern[i % 2]) {
-        repeatCount++;
-      } else {
-        pattern = [arr[i - 1], arr[i]];
-        repeatCount = 1;
-      }
-      if (repeatCount >= maxRepeats * 2) {
-        if (ENV === "test" || ENV === "development") {
-          console.warn("Warning: Potential infinite loop detected due to repeated sequence:", pattern);
-        }
-        return true;
-      }
-    }
-  }
-};

package/dist/cjs/utils/object.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var object_exports = {};
 __export(object_exports, {
+  METHODS: () => METHODS,
   METHODS_EXL: () => METHODS_EXL,
   clone: () => clone,
   deepClone: () => deepClone,
@@ -32,13 +33,59 @@ __export(object_exports, {
 });
 module.exports = __toCommonJS(object_exports);
 var import_utils = require("@domql/utils");
-var import_state = require("@domql/state");
 var import_props = require("../props");
-var import_methods = require("../methods");
+const IGNORE_STATE_PARAMS = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "destroy",
+  "add",
+  "toggle",
+  "remove",
+  "apply",
+  "set",
+  "reset",
+  "replace",
+  "quietReplace",
+  "quietUpdate",
+  "applyReplace",
+  "applyFunction",
+  "rootUpdate",
+  "parentUpdate",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "root"
+];
+const METHODS = [
+  "set",
+  "reset",
+  "update",
+  "remove",
+  "updateContent",
+  "removeContent",
+  "lookup",
+  "lookdown",
+  "lookdownAll",
+  "setNodeStyles",
+  "spotByPath",
+  "keys",
+  "parse",
+  "setProps",
+  "parseDeep",
+  "variables",
+  "if",
+  "log",
+  "nextElement",
+  "previousElement"
+];
 const METHODS_EXL = (0, import_utils.joinArrays)(
   ["node", "state", "context", "extend", "__element"],
-  import_methods.METHODS,
-  import_state.IGNORE_STATE_PARAMS,
+  METHODS,
+  IGNORE_STATE_PARAMS,
   import_props.IGNORE_PROPS_PARAMS
 );
 const deepMerge = (element, extend, exclude = METHODS_EXL) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/element",
-  "version": "2.5.124",
+  "version": "2.5.125",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
@@ -31,7 +31,7 @@
     "@domql/state": "latest",
     "@domql/utils": "latest"
   },
-  "gitHead": "5f3ff2f3def04f339521125dbbfec3d6577ac395",
+  "gitHead": "20b6bab140fa7d75aaac85afa237cd906c60e89c",
   "devDependencies": {
     "@babel/core": "^7.12.0"
   }

package/update.js

@@ -19,12 +19,12 @@ import { isMethod } from './methods'
 import { updateProps } from './props'
 import { createState, findInheritedState } from '@domql/state'
 
-import { METHODS_EXL, deepClone, isVariant, deepMerge } from './utils'
 import create from './create'
 import { throughUpdatedDefine, throughUpdatedExec } from './iterate'
 import { registry } from './mixins'
 import { applyParam } from './utils/applyParam'
 import OPTIONS from './cache/options'
+import { METHODS_EXL, deepClone, isVariant, deepMerge } from './utils'
 
 const snapshot = {
   snapshotId: createSnapshotId
@@ -80,6 +80,7 @@ const update = function (params = {}, opts) {
   }
 
   const overwriteChanges = overwriteDeep(element, params, METHODS_EXL)
+  // const overwriteChanges = overwriteDeep(element, params)
   const execChanges = throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS })
   const definedChanges = throughUpdatedDefine(element)
 

package/utils/component.js

@@ -165,33 +165,3 @@ export const applyVariant = (element) => {
 
   return element
 }
-
-export const detectInfiniteLoop = arr => {
-  const maxRepeats = 10 // Maximum allowed repetitions
-  let pattern = []
-  let repeatCount = 0
-
-  for (let i = 0; i < arr.length; i++) {
-    if (pattern.length < 2) {
-      // Build the initial pattern with two consecutive elements
-      pattern.push(arr[i])
-    } else {
-      // Check if the current element follows the repeating pattern
-      if (arr[i] === pattern[i % 2]) {
-        repeatCount++
-      } else {
-        // If there's a mismatch, reset the pattern and repeat counter
-        pattern = [arr[i - 1], arr[i]]
-        repeatCount = 1 // Reset to 1 because we start a new potential pattern
-      }
-
-      // If the pattern repeats more than `maxRepeats`, throw a warning
-      if (repeatCount >= maxRepeats * 2) {
-        if (ENV === 'test' || ENV === 'development') {
-          console.warn('Warning: Potential infinite loop detected due to repeated sequence:', pattern)
-        }
-        return true
-      }
-    }
-  }
-}

package/utils/object.js

@@ -1,9 +1,40 @@
 'use strict'
 
 import { isArray, isObject, isObjectLike, joinArrays, deepCloneWithExtend } from '@domql/utils'
-import { IGNORE_STATE_PARAMS } from '@domql/state'
 import { IGNORE_PROPS_PARAMS } from '../props'
-import { METHODS } from '../methods'
+
+// breaks server build
+// import { IGNORE_STATE_PARAMS } from '@domql/state'
+// import { METHODS } from '../methods'
+
+const IGNORE_STATE_PARAMS = [
+  'update', 'parse', 'clean', 'create', 'destroy', 'add', 'toggle', 'remove', 'apply', 'set', 'reset',
+  'replace', 'quietReplace', 'quietUpdate', 'applyReplace', 'applyFunction',
+  'rootUpdate', 'parentUpdate', 'parent', '__element', '__depends', '__ref', '__children', 'root'
+]
+
+export const METHODS = [
+  'set',
+  'reset',
+  'update',
+  'remove',
+  'updateContent',
+  'removeContent',
+  'lookup',
+  'lookdown',
+  'lookdownAll',
+  'setNodeStyles',
+  'spotByPath',
+  'keys',
+  'parse',
+  'setProps',
+  'parseDeep',
+  'variables',
+  'if',
+  'log',
+  'nextElement',
+  'previousElement'
+]
 
 export const METHODS_EXL = joinArrays(
   ['node', 'state', 'context', 'extend', '__element'],