@domql/element 2.5.200 → 3.0.1

package/dist/cjs/set.js

@@ -19,74 +19,146 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var set_exports = {};
 __export(set_exports, {
   default: () => set_default,
+  removeContent: () => removeContent,
   reset: () => reset,
-  resetElement: () => resetElement,
-  set: () => set
+  resetContent: () => resetContent,
+  set: () => set,
+  setContent: () => setContent,
+  setContentKey: () => setContentKey,
+  updateContent: () => updateContent
 });
 module.exports = __toCommonJS(set_exports);
 var import_utils = require("@domql/utils");
-var import_options = require("./cache/options.js");
 var import_create = require("./create.js");
-var import_mixins = require("./mixins/index.js");
-var import_content = require("./mixins/content.js");
 var import_event = require("@domql/event");
-const resetElement = async (params, element, options) => {
-  if (!options.preventRemove) (0, import_content.removeContent)(element, options);
+const setContentKey = (element, opts = {}) => {
   const { __ref: ref } = element;
-  await (0, import_create.create)(params, element, ref.contentElementKey || "content", {
-    ignoreChildExtend: true,
-    ...import_mixins.registry.defaultOptions,
-    ...import_options.OPTIONS.create,
-    ...options
-  });
+  const contentElementKey = opts.contentElementKey;
+  if (!ref.contentElementKey || contentElementKey !== ref.contentElementKey) {
+    ref.contentElementKey = contentElementKey || "content";
+  }
+  return ref.contentElementKey;
 };
-const reset = (options) => {
+const reset = async (options) => {
   const element = void 0;
-  (0, import_create.create)(element, element.parent, void 0, {
-    ignoreChildExtend: true,
-    ...import_mixins.registry.defaultOptions,
-    ...import_options.OPTIONS.create,
+  await (0, import_create.create)(element, element.parent, void 0, {
+    ignoreChildExtends: true,
+    ...import_utils.OPTIONS.defaultOptions,
+    ...import_utils.OPTIONS.create,
     ...options
   });
 };
+const resetContent = async (params, element, opts) => {
+  var _a;
+  const contentElementKey = setContentKey(element, opts);
+  if ((_a = element[contentElementKey]) == null ? void 0 : _a.node) removeContent(element, opts);
+  const contentElem = await (0, import_create.create)(
+    params,
+    element,
+    contentElementKey || "content",
+    {
+      ignoreChildExtends: true,
+      ...import_utils.OPTIONS.defaultOptions,
+      ...import_utils.OPTIONS.create,
+      ...opts
+    }
+  );
+  if (contentElementKey !== "content") opts.contentElementKey = "content";
+  return contentElem;
+};
+const updateContent = async function(params, opts) {
+  const element = this;
+  const contentElementKey = setContentKey(element, opts);
+  if (!element[contentElementKey]) return;
+  if (element[contentElementKey].update) {
+    await element[contentElementKey].update(params, opts);
+  }
+};
+async function setContent(param, element, opts) {
+  const content = await (0, import_utils.execPromise)(param, element);
+  if (content && element) {
+    set.call(element, content, opts);
+  }
+}
+const removeContent = function(el, opts = {}) {
+  var _a;
+  const element = el || this;
+  const contentElementKey = setContentKey(element, opts);
+  if (opts.contentElementKey !== "content") {
+    opts.contentElementKey = "content";
+  }
+  const content = element[contentElementKey];
+  if (!content) return;
+  if (content.tag === "fragment" && ((_a = content.__ref) == null ? void 0 : _a.__children)) {
+    content.__ref.__children.forEach((key) => {
+      const child = content[key];
+      if (child.node && child.node.parentNode) {
+        child.node.parentNode.removeChild(child.node);
+      }
+      if ((0, import_utils.isFunction)(child.remove)) {
+        child.remove();
+      }
+    });
+  } else {
+    if (content.node && content.node.parentNode) {
+      content.node.parentNode.removeChild(content.node);
+    }
+    if ((0, import_utils.isFunction)(content.remove)) {
+      content.remove();
+    }
+  }
+  delete element[contentElementKey];
+};
 const set = async function(params, options = {}, el) {
   var _a;
   const element = el || this;
   const { __ref: ref } = element;
-  const content = (0, import_utils.setContentKey)(element, options);
+  const contentElementKey = setContentKey(element, options);
+  const content = element[contentElementKey];
   const __contentRef = content && content.__ref;
   const lazyLoad = element.props && element.props.lazyLoad;
-  const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection;
-  if (options.preventContentUpdate === true && !hasCollection) return;
-  if (ref.__noCollectionDifference || __contentRef && __contentRef.__cached && (0, import_utils.deepContains)(params, content)) {
+  const hasChildren = element.children;
+  if (options.preventContentUpdate === true && !hasChildren) return;
+  const childHasChanged = !ref.__noChildrenDifference;
+  const childrenIsDifferentFromCache = childHasChanged && __contentRef && Object.keys(params).length === Object.keys(content).length && (0, import_utils.deepContains)(params, content);
+  if ((content == null ? void 0 : content.update) && !childHasChanged && !childrenIsDifferentFromCache) {
     if (!options.preventBeforeUpdateListener && !options.preventListeners) {
-      const beforeUpdateReturns = await (0, import_event.triggerEventOnUpdate)("beforeUpdate", params, element, options);
+      const beforeUpdateReturns = await (0, import_event.triggerEventOnUpdate)(
+        "beforeUpdate",
+        params,
+        element,
+        options
+      );
       if (beforeUpdateReturns === false) return element;
     }
-    if (content == null ? void 0 : content.update) content.update();
-    if (!options.preventUpdateListener) await (0, import_event.triggerEventOn)("update", element, options);
+    await content.update(params);
+    if (!options.preventUpdateListener && !options.preventListeners) {
+      await (0, import_event.triggerEventOn)("update", element, options);
+    }
     return;
   }
-  if (params) {
-    let { childExtend, props } = params;
-    if (!props) props = params.props = {};
-    if (!childExtend && element.childExtend) {
-      params.childExtend = element.childExtend;
-      props.ignoreChildExtend = true;
+  if (!params) return element;
+  let { childExtends, props, tag } = params;
+  if (!props) props = params.props = {};
+  if (tag === "fragment") {
+    if (!childExtends && element.childExtends) {
+      params.childExtends = element.childExtends;
+      props.ignoreChildExtends = true;
     }
     if (!(props == null ? void 0 : props.childProps) && ((_a = element.props) == null ? void 0 : _a.childProps)) {
       props.childProps = element.props.childProps;
       props.ignoreChildProps = true;
     }
-    if (lazyLoad) {
-      window.requestAnimationFrame(async () => {
-        await resetElement(params, element, options);
-        if (!options.preventUpdateListener) {
-          (0, import_event.triggerEventOn)("lazyLoad", element, options);
-        }
-      });
-    } else await resetElement(params, element, options);
   }
-  return element;
+  if (lazyLoad) {
+    window.requestAnimationFrame(async () => {
+      await resetContent(params, element, options);
+      if (!options.preventUpdateListener) {
+        await (0, import_event.triggerEventOn)("lazyLoad", element, options);
+      }
+    });
+  } else {
+    await resetContent(params, element, options);
+  }
 };
 var set_default = set;

package/dist/cjs/update.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var update_exports = {};
 __export(update_exports, {
@@ -24,63 +34,75 @@ __export(update_exports, {
 module.exports = __toCommonJS(update_exports);
 var import_utils = require("@domql/utils");
 var import_event = require("@domql/event");
-var import_methods = require("./methods/index.js");
-var import_props = require("./props/index.js");
 var import_state = require("@domql/state");
 var import_create = require("./create.js");
 var import_iterate = require("./iterate.js");
 var import_mixins = require("./mixins/index.js");
 var import_applyParam = require("./utils/applyParam.js");
-var import_options = require("./cache/options.js");
 var import_utils2 = require("./utils/index.js");
-const snapshot = {
-  snapshotId: import_utils.createSnapshotId
-};
+var import_set = require("./set.js");
+var import_children = __toESM(require("./children.js"), 1);
 const UPDATE_DEFAULT_OPTIONS = {
   stackChanges: false,
   cleanExec: true,
   preventRecursive: false,
   currentSnapshot: false,
   calleeElement: false,
-  excludes: import_utils2.METHODS_EXL
+  exclude: import_utils2.METHODS_EXL
 };
 const update = async function(params = {}, opts) {
   const calleeElementCache = opts == null ? void 0 : opts.calleeElement;
-  const options = (0, import_utils.deepClone)((0, import_utils.isObject)(opts) ? (0, import_utils2.deepMerge)(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS, { exclude: ["calleeElement"] });
+  const options = (0, import_utils.deepClone)(
+    (0, import_utils.isObject)(opts) ? (0, import_utils.deepMerge)(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS,
+    { exclude: ["calleeElement"] }
+  );
   options.calleeElement = calleeElementCache;
   const element = this;
-  const { parent, node, key } = element;
-  const { excludes, preventInheritAtCurrentState } = options;
   let ref = element.__ref;
   if (!ref) ref = element.__ref = {};
-  const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(element, options);
+  const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = (0, import_utils.captureSnapshot)(
+    element,
+    options
+  );
   if (snapshotHasUpdated) return;
-  if (!options.preventListeners) await (0, import_event.triggerEventOnUpdate)("startUpdate", params, element, options);
-  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element) return;
-  if (!excludes) (0, import_utils.merge)(options, UPDATE_DEFAULT_OPTIONS);
+  if (!options.preventListeners) {
+    await (0, import_event.triggerEventOnUpdate)("startUpdate", params, element, options);
+  }
+  const { parent, node, key } = element;
+  const { exclude, preventInheritAtCurrentState } = options;
+  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element) {
+    return;
+  }
+  if (!exclude) (0, import_utils.merge)(options, UPDATE_DEFAULT_OPTIONS);
   if ((0, import_utils.isString)(params) || (0, import_utils.isNumber)(params)) {
     params = { text: params };
   }
+  params = (0, import_utils.propertizeElement)(params);
   const inheritState = await inheritStateUpdates(element, options);
   if (inheritState === false) return;
-  const ifFails = checkIfOnUpdate(element, parent, options);
+  const ifFails = await checkIfOnUpdate(element, parent, options);
   if (ifFails) return;
   if (ref.__if && !options.preventPropsUpdate) {
     const hasParentProps = parent.props && (parent.props[key] || parent.props.childProps);
-    const hasFunctionInProps = ref.__props.filter((v) => (0, import_utils.isFunction)(v));
+    const hasFunctionInProps = ref.__propsStack.filter((v) => (0, import_utils.isFunction)(v));
     const props = params.props || hasParentProps || hasFunctionInProps.length;
-    if (props) (0, import_props.updateProps)(props, element, parent);
+    if (props) (0, import_utils.updateProps)(props, element, parent);
   }
   if (!options.preventBeforeUpdateListener && !options.preventListeners) {
-    const beforeUpdateReturns = await (0, import_event.triggerEventOnUpdate)("beforeUpdate", params, element, options);
+    const beforeUpdateReturns = await (0, import_event.triggerEventOnUpdate)(
+      "beforeUpdate",
+      params,
+      element,
+      options
+    );
     if (beforeUpdateReturns === false) return element;
   }
-  (0, import_utils.overwriteDeep)(element, params, { exclude: import_utils2.METHODS_EXL });
+  (0, import_utils.overwriteDeep)(element, params);
   (0, import_iterate.throughExecProps)(element);
   (0, import_iterate.throughUpdatedExec)(element, { ignore: UPDATE_DEFAULT_OPTIONS });
   (0, import_iterate.throughUpdatedDefine)(element);
   if (!options.isForced && !options.preventListeners) {
-    (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
+    await (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
   }
   if (!ref.__if) return false;
   if (!node) {
@@ -97,19 +119,22 @@ const update = async function(params = {}, opts) {
     preventUpdateAfterCount
   } = options;
   if (preventUpdateAfter) {
-    if ((0, import_utils.isNumber)(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount) return;
-    else if (options.preventUpdateAfterCount === void 0) options.preventUpdateAfterCount = 1;
-    else options.preventUpdateAfterCount++;
+    if ((0, import_utils.isNumber)(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount) {
+      return;
+    } else if (options.preventUpdateAfterCount === void 0) {
+      options.preventUpdateAfterCount = 1;
+    } else options.preventUpdateAfterCount++;
   }
   for (const param in element) {
     const prop = element[param];
     if (!Object.hasOwnProperty.call(element, param)) continue;
     const isInPreventUpdate = (0, import_utils.isArray)(preventUpdate) && preventUpdate.includes(param);
     const isInPreventDefineUpdate = (0, import_utils.isArray)(preventDefineUpdate) && preventDefineUpdate.includes(param);
-    const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection;
-    if ((0, import_utils.isUndefined)(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || preventContentUpdate && param === "content" && !hasCollection || (preventStateUpdate && param) === "state" || (0, import_methods.isMethod)(param, element) || (0, import_utils.isObject)(import_mixins.REGISTRY[param]) || (0, import_utils.isVariant)(param)) continue;
+    if ((0, import_utils.isUndefined)(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || (preventStateUpdate && param) === "state" || (0, import_utils.isMethod)(param, element) || (0, import_utils.isObject)(import_mixins.REGISTRY[param])) {
+      continue;
+    }
     if (preventStateUpdate === "once") options.preventStateUpdate = false;
-    const isElement = (0, import_applyParam.applyParam)(param, element, options);
+    const isElement = await (0, import_applyParam.applyParam)(param, element, options);
     if (isElement) {
       const { hasDefine, hasContextDefine } = isElement;
       const canUpdate = (0, import_utils.isObject)(prop) && !hasDefine && !hasContextDefine && !preventRecursive;
@@ -118,48 +143,51 @@ const update = async function(params = {}, opts) {
       if (options.onEachUpdate) {
         options.onEachUpdate(param, element, element.state, element.context);
       }
-      const childUpdateCall = () => update.call(prop, params[prop], {
+      const childUpdateCall = async () => await update.call(prop, params[prop], {
         ...options,
         currentSnapshot: snapshotOnCallee,
         calleeElement
       });
-      lazyLoad ? import_utils.window.requestAnimationFrame(() => {
-        childUpdateCall();
-        if (!options.preventUpdateListener) {
-          (0, import_event.triggerEventOn)("lazyLoad", element, options);
-        }
-      }) : childUpdateCall();
+      if (lazyLoad) {
+        import_utils.window.requestAnimationFrame(async () => {
+          await childUpdateCall();
+          if (!options.preventUpdateListener) {
+            await (0, import_event.triggerEventOn)("lazyLoad", element, options);
+          }
+        });
+      } else await childUpdateCall();
     }
   }
-  if (!preventUpdateListener) (0, import_event.triggerEventOn)("update", element, options);
-};
-const captureSnapshot = (element, options) => {
-  const ref = element.__ref;
-  const { currentSnapshot, calleeElement } = options;
-  const isCallee = calleeElement === element;
-  if (!calleeElement || isCallee) {
-    const createdStanpshot = snapshot.snapshotId();
-    ref.__currentSnapshot = createdStanpshot;
-    return [createdStanpshot, element];
-  }
-  const snapshotOnCallee = calleeElement.__ref.__currentSnapshot;
-  if (currentSnapshot < snapshotOnCallee) {
-    return [snapshotOnCallee, calleeElement, true];
-  }
-  return [snapshotOnCallee, calleeElement];
+  if (!preventContentUpdate) {
+    const children = params.children || element.children;
+    const content = children ? await (0, import_children.default)(children, element, opts) : element.children || params.content;
+    if (content) {
+      await (0, import_set.setContent)(content, element, options);
+    }
+  }
+  if (!preventUpdateListener) {
+    await (0, import_event.triggerEventOn)("update", element, options);
+  }
 };
-const checkIfOnUpdate = (element, parent, options) => {
+const checkIfOnUpdate = async (element, parent, options) => {
   var _a, _b, _c;
-  if (!(0, import_utils.isFunction)(element.if) && !(0, import_utils.isFunction)((_a = element.props) == null ? void 0 : _a.if) || !parent) return;
+  if (!(0, import_utils.isFunction)(element.if) && !(0, import_utils.isFunction)((_a = element.props) == null ? void 0 : _a.if) || !parent) {
+    return;
+  }
   const ref = element.__ref;
-  const ifPassed = (element.if || ((_b = element.props) == null ? void 0 : _b.if))(element, element.state, element.context, options);
+  const ifPassed = (element.if || ((_b = element.props) == null ? void 0 : _b.if))(
+    element,
+    element.state,
+    element.context,
+    options
+  );
   const itWasFalse = ref.__if !== true;
   if (ifPassed) {
     ref.__if = true;
     if (itWasFalse) {
       delete element.__hash;
       delete element.__text;
-      delete element.extend;
+      delete element.extends;
       if (!ref.__hasRootState) {
         delete element.state;
       }
@@ -173,9 +201,11 @@ const checkIfOnUpdate = (element, parent, options) => {
         delete element.node;
       }
       const contentKey = ref.contentElementKey;
-      if (element.$collection || element.$stateCollection || element.$propsCollection) {
+      if (element.children) {
         element.removeContent();
-      } else if ((_c = element[contentKey]) == null ? void 0 : _c.parseDeep) element[contentKey] = element[contentKey].parseDeep();
+      } else if ((_c = element[contentKey]) == null ? void 0 : _c.parseDeep) {
+        element[contentKey] = element[contentKey].parseDeep();
+      }
       const previousElement = element.previousElement();
       const previousNode = previousElement == null ? void 0 : previousElement.node;
       const hasPrevious = previousNode == null ? void 0 : previousNode.parentNode;
@@ -188,9 +218,19 @@ const checkIfOnUpdate = (element, parent, options) => {
       };
       delete element.__ref;
       delete element.parent;
-      const createdElement = (0, import_create.create)(element, parent, element.key, import_options.OPTIONS.create, attachOptions);
+      const createdElement = await (0, import_create.create)(
+        element,
+        parent,
+        element.key,
+        import_utils.OPTIONS.create,
+        attachOptions
+      );
       if (options.preventUpdate !== true && element.on && (0, import_utils.isFunction)(element.on.update)) {
-        (0, import_event.applyEvent)(element.on.update, createdElement, createdElement.state);
+        await (0, import_event.applyEvent)(
+          element.on.update,
+          createdElement,
+          createdElement.state
+        );
       }
       return createdElement;
     }
@@ -212,23 +252,38 @@ const inheritStateUpdates = async (element, options) => {
   const shouldForceFunctionState = (0, import_utils.isFunction)(stateKey) && !isHoisted && execStateFunction;
   if (shouldForceFunctionState) {
     const execState = (0, import_utils.exec)(stateKey, element);
-    state.set(execState, { ...options, preventUpdate: true, preventStateUpdateListener: false, updatedByStateFunction: true });
+    state.set(execState, {
+      ...options,
+      preventUpdate: true,
+      preventStateUpdateListener: false,
+      updatedByStateFunction: true
+    });
     return;
   }
-  const keyInParentState = (0, import_state.findInheritedState)(element, element.parent);
+  const keyInParentState = (0, import_utils.findInheritedState)(element, element.parent);
   if (!keyInParentState || options.preventInheritedStateUpdate) return;
   if (!options.preventBeforeStateUpdateListener && !options.preventListeners) {
-    const initStateReturns = await (0, import_event.triggerEventOnUpdate)("beforeStateUpdate", keyInParentState, element, options);
+    const initStateReturns = await (0, import_event.triggerEventOnUpdate)(
+      "beforeStateUpdate",
+      keyInParentState,
+      element,
+      options
+    );
     if (initStateReturns === false) return element;
   }
-  const newState = createStateUpdate(element, parent, options);
+  const newState = await createStateUpdate(element, parent, options);
   if (!options.preventStateUpdateListener && !options.preventListeners) {
-    await (0, import_event.triggerEventOnUpdate)("stateUpdate", newState.parse(), element, options);
+    await (0, import_event.triggerEventOnUpdate)(
+      "stateUpdate",
+      newState.parse(),
+      element,
+      options
+    );
   }
 };
-const createStateUpdate = (element, parent, options) => {
+const createStateUpdate = async (element, parent, options) => {
   const __stateChildren = element.state.__children;
-  const newState = (0, import_state.createState)(element, parent);
+  const newState = await (0, import_state.createState)(element, parent);
   element.state = newState;
   for (const child in __stateChildren) {
     if (newState[child]) newState.__children[child] = __stateChildren[child];

package/dist/cjs/utils/applyParam.js

@@ -23,7 +23,7 @@ __export(applyParam_exports, {
 module.exports = __toCommonJS(applyParam_exports);
 var import_utils = require("@domql/utils");
 var import_mixins = require("../mixins/index.js");
-const applyParam = (param, element, options) => {
+const applyParam = async (param, element, options) => {
   const { node, context, __ref: ref } = element;
   const prop = element[param];
   const { onlyUpdate } = options;
@@ -36,7 +36,7 @@ const applyParam = (param, element, options) => {
   const hasOnlyUpdate = onlyUpdate ? onlyUpdate === param || element.lookup(onlyUpdate) : true;
   if (isGlobalTransformer && !hasContextDefine && hasOnlyUpdate) {
     if ((0, import_utils.isFunction)(isGlobalTransformer)) {
-      isGlobalTransformer(prop, element, node, options);
+      await isGlobalTransformer(prop, element, node, options);
       return;
     }
   }

package/dist/cjs/utils/index.js

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -11,10 +15,10 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utils_exports = {};
+__export(utils_exports, {
+  METHODS_EXL: () => METHODS_EXL
+});
 module.exports = __toCommonJS(utils_exports);
-__reExport(utils_exports, require("./object.js"), module.exports);
-__reExport(utils_exports, require("./extendUtils.js"), module.exports);
-__reExport(utils_exports, require("./component.js"), module.exports);
+const METHODS_EXL = [];

package/dist/cjs/utils/onlyResolveExtends.js

@@ -24,19 +24,15 @@ module.exports = __toCommonJS(onlyResolveExtends_exports);
 var import_utils = require("@domql/utils");
 var import__ = require("..");
 var import_mixins = require("../mixins/index.js");
-var import__2 = require(".");
-var import_methods = require("../methods");
 var import_set = require("../methods/set");
 var import_state = require("@domql/state");
 var import_render = require("@domql/render");
-var import_props = require("../props");
 var import_iterate = require("../iterate");
 const onlyResolveExtends = (element, parent, key, options) => {
   const { __ref } = element;
   element.tag = (0, import_render.detectTag)(element);
   {
     const { __ref: ref2 } = element;
-    if (!ref2.__cached) ref2.__cached = {};
     if (!ref2.__defineCache) ref2.__defineCache = {};
     if (!ref2.__exec) ref2.__exec = {};
     if (!ref2.__execProps) ref2.__execProps = {};
@@ -58,14 +54,15 @@ const onlyResolveExtends = (element, parent, key, options) => {
   if (element.node && ref.__if) {
     parent[key || element.key] = element;
   }
-  (0, import_props.createProps)(element, parent, options);
-  (0, import__2.applyVariant)(element, parent);
+  (0, import_utils.initProps)(element, parent, options);
   if (element.tag !== "string" && element.tag !== "fragment") {
     (0, import_iterate.throughInitialDefine)(element);
     (0, import_iterate.throughInitialExec)(element);
     for (const param in element) {
       const prop = element[param];
-      if ((0, import_utils.isUndefined)(prop) || (0, import_methods.isMethod)(param, element) || (0, import_utils.isObject)(import_mixins.REGISTRY[param]) || (0, import__2.isVariant)(param)) continue;
+      if ((0, import_utils.isUndefined)(prop) || (0, import_utils.isMethod)(param, element) || (0, import_utils.isObject)(import_mixins.REGISTRY[param])) {
+        continue;
+      }
       const hasDefine = element.define && element.define[param];
       const contextHasDefine = element.context && element.context.define && element.context.define[param];
       const optionsHasDefine = options.define && options.define[param];

package/dist/esm/__tests__/checkIfOnUpdate.test.js

@@ -0,0 +1,73 @@
+import { update } from "../update";
+describe("checkIfOnUpdate via update()", () => {
+  let element, parent, options;
+  beforeEach(() => {
+    parent = {
+      node: document.createElement("div"),
+      props: {},
+      state: {}
+    };
+    element = {
+      __ref: {
+        __if: void 0,
+        __state: null,
+        __hasRootState: false,
+        __execProps: {},
+        contentElementKey: "content"
+      },
+      parent,
+      props: {},
+      state: {
+        update: (el, st) => {
+          return st;
+        }
+      },
+      context: {
+        defaultExtends: {}
+      },
+      node: document.createElement("div"),
+      if: () => true,
+      previousElement: () => {
+        return {};
+      },
+      nextElement: () => {
+        return {};
+      },
+      removeContent: () => {
+        return true;
+      }
+    };
+    options = {};
+  });
+  it("uses props.if when element.if missing", async () => {
+    delete element.if;
+    element.props.if = () => false;
+    await update.call(element, {}, options);
+    expect(element.node).toEqual(document.createElement("div"));
+  });
+  it("retains state when __hasRootState=true", async () => {
+    element.__ref.__hasRootState = true;
+    element.state.critical = true;
+    element.__ref.__if = false;
+    await update.call(element, {}, options);
+    expect(element.state.critical).toBe(true);
+    expect(element.state.preserved).toBeUndefined();
+  });
+  it("processes nested content with parseDeep", async () => {
+    element.content = {
+      parseDeep: () => ({ parsed: true }),
+      existing: "data"
+    };
+    await update.call(element, {}, options);
+    expect(element.content.parsed).toBe(true);
+    expect(element.content.existing).toBeUndefined();
+  });
+  it("reattaches after previous sibling", async () => {
+    const prevNode = document.createElement("span");
+    parent.node.appendChild(prevNode);
+    await update.call(element, {}, options);
+    const newElement = parent.node.children[0];
+    expect(newElement).toEqual(document.createElement("span"));
+    expect(newElement.previousSibling).toBe(null);
+  });
+});