domql 1.6.21 → 1.6.23

package/dist/cjs/element/create.js

@@ -36,22 +36,24 @@ var import_render = require("@domql/render");
 var import_methods = require("@domql/methods");
 var import_classlist = require("@domql/classlist");
 var import_node = require("@domql/node");
+var import_state = require("@domql/state");
+var import_props = require("@domql/props");
 var import_node2 = __toESM(require("./node"));
 var import_extend = require("./extend");
 var import_set = __toESM(require("./set"));
-var import_state = __toESM(require("./state"));
-var import_props = __toESM(require("./props"));
 var import_update = __toESM(require("./update"));
 var import_methods2 = require("./methods");
 var import_mixins = require("./mixins");
 var import_iterate = require("./iterate");
 var import_options = __toESM(require("./options"));
-var import_component = require("../utils/component");
+var import_component = require("./utils/component");
 var import_remove = require("./remove");
 const ENV = "development";
 const create = (element, parent, key, options = import_options.default.create || {}) => {
-  if (options && !import_options.default.create)
+  if (options && !import_options.default.create) {
     import_options.default.create = options;
+    import_options.default.create.context = element.context || options.context;
+  }
   if (element === void 0) {
     if (ENV === "test" || ENV === "development") {
       console.warn(key, "element is undefined in", parent && parent.__ref && parent.__ref.path);
@@ -96,8 +98,9 @@ const create = (element, parent, key, options = import_options.default.create ||
     (0, import_component.applyComponentFromContext)(element, parent, options);
   (0, import_extend.applyExtend)(element, parent, options);
   element.key = assignedKey;
-  if (options.onlyResolveExtends)
+  if (options.onlyResolveExtends) {
     return resolveExtends(element, parent, options);
+  }
   if (Object.keys(options).length) {
     import_mixins.registry.defaultOptions = options;
     if (options.ignoreChildExtend)
@@ -105,24 +108,24 @@ const create = (element, parent, key, options = import_options.default.create ||
   }
   addCaching(element, parent);
   addMethods(element, parent);
-  element.state = (0, import_state.default)(element, parent);
+  element.state = (0, import_state.createState)(element, parent);
   checkIf(element, parent);
   if (element.node && __ref.__if) {
     return (0, import_render.assignNode)(element, parent, assignedKey);
   }
   if (__ref.__if)
-    (0, import_props.default)(element, parent);
-  const initReturns = (0, import_event.triggerEventOn)("init", element);
+    (0, import_props.createProps)(element, parent);
+  const initReturns = (0, import_event.triggerEventOn)("init", element, options);
   if (initReturns === false)
     return element;
-  (0, import_event.triggerEventOn)("beforeClassAssign", element);
+  (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
   (0, import_classlist.assignClass)(element);
   (0, import_node2.default)(element, options);
   if (!__ref.__if)
     return element;
   (0, import_render.assignNode)(element, parent, key);
-  (0, import_event.triggerEventOn)("renderRouter", element);
-  (0, import_event.triggerEventOn)("render", element);
+  (0, import_event.triggerEventOn)("renderRouter", element, options);
+  (0, import_event.triggerEventOn)("render", element, options);
   if (parent.__ref && parent.__ref.__children)
     parent.__ref.__children.push(element.key);
   return element;
@@ -163,46 +166,48 @@ const applyContext = (element, parent, options) => {
     element.context = parent.context || options.context || import_tree.ROOT.context;
 };
 const checkIf = (element, parent) => {
-  const { __ref } = element;
+  const { __ref: ref } = element;
   if ((0, import_utils.isFunction)(element.if)) {
     const ifPassed = element.if(element, element.state);
     if (!ifPassed) {
       const ifFragment = (0, import_node.cacheNode)({ tag: "fragment" });
-      __ref.__ifFragment = (0, import_render.appendNode)(ifFragment, parent.node);
-      delete __ref.__if;
+      ref.__ifFragment = (0, import_render.appendNode)(ifFragment, parent.node);
+      delete ref.__if;
     } else
-      __ref.__if = true;
+      ref.__if = true;
   } else
-    __ref.__if = true;
+    ref.__if = true;
 };
 const addCaching = (element, parent) => {
-  const { __ref } = element;
-  let { __ref: __parentRef } = parent;
+  const { __ref: ref } = element;
+  let { __ref: parentRef } = parent;
   if (!element.transform)
     element.transform = {};
-  if (!__ref.__cached)
-    __ref.__cached = {};
-  if (!__ref.__exec)
-    __ref.__exec = {};
-  if (!__ref.__class)
-    __ref.__class = {};
-  if (!__ref.__classNames)
-    __ref.__classNames = {};
-  if (!__ref.__attr)
-    __ref.__attr = {};
-  if (!__ref.__changes)
-    __ref.__changes = [];
-  if (!__ref.__children)
-    __ref.__children = [];
+  if (!ref.__cached)
+    ref.__cached = {};
+  if (!ref.__defineCache)
+    ref.__defineCache = {};
+  if (!ref.__exec)
+    ref.__exec = {};
+  if (!ref.__class)
+    ref.__class = {};
+  if (!ref.__classNames)
+    ref.__classNames = {};
+  if (!ref.__attr)
+    ref.__attr = {};
+  if (!ref.__changes)
+    ref.__changes = [];
+  if (!ref.__children)
+    ref.__children = [];
   const hasRoot = parent && parent.key === ":root";
-  if (!__ref.__root)
-    __ref.__root = hasRoot ? element : __parentRef.__root;
+  if (!ref.__root)
+    ref.__root = hasRoot ? element : parentRef.__root;
   if (ENV === "test" || ENV === "development") {
-    if (!__parentRef)
-      __parentRef = parent.__ref = {};
-    if (!__parentRef.__path)
-      __parentRef.__path = [];
-    __ref.__path = __parentRef.__path.concat(element.key);
+    if (!parentRef)
+      parentRef = parent.ref = {};
+    if (!parentRef.__path)
+      parentRef.__path = [];
+    ref.__path = parentRef.__path.concat(element.key);
   }
 };
 const resolveExtends = (element, parent, options) => {
@@ -216,9 +221,9 @@ const resolveExtends = (element, parent, options) => {
     element.props = {};
   if (!element.state)
     element.state = {};
-  element = (0, import_props.default)(element, parent);
-  (0, import_state.default)(element, parent, { skip: true });
-  (0, import_iterate.throughInitialExec)(element);
+  element = (0, import_props.createProps)(element, parent);
+  (0, import_state.createState)(element, parent, { skip: true });
+  (0, import_iterate.throughInitialExec)(element, options.propsExcludedFromExec);
   for (const param in element) {
     const prop = element[param];
     if ((0, import_methods.isMethod)(param) || (0, import_utils.isObject)(import_mixins.registry[param]) || prop === void 0)

package/dist/cjs/element/extend.js

@@ -22,14 +22,14 @@ __export(extend_exports, {
 });
 module.exports = __toCommonJS(extend_exports);
 var import_utils = require("@domql/utils");
-var import_utils2 = require("../utils");
+var import_utils2 = require("./utils");
 const ENV = "development";
 const applyExtend = (element, parent, options = {}) => {
   if ((0, import_utils.isFunction)(element))
     element = (0, import_utils.exec)(element, parent);
   let { extend, props, context, __ref } = element;
   const COMPONENTS = context && context.components || options.components;
-  if ((0, import_utils.isString)(extend))
+  if ((0, import_utils.isString)(extend) && COMPONENTS)
     extend = COMPONENTS[extend];
   const extendStack = (0, import_utils2.getExtendStack)(extend);
   if (ENV !== "test" || ENV !== "development")

package/dist/cjs/element/iterate.js

@@ -25,61 +25,65 @@ __export(iterate_exports, {
 });
 module.exports = __toCommonJS(iterate_exports);
 var import_utils = require("@domql/utils");
-var import_utils2 = require("../utils");
+var import_utils2 = require("./utils");
 var import_methods = require("@domql/methods");
-const throughInitialExec = (element) => {
-  const { __ref } = element;
-  const { __exec } = __ref;
+const throughInitialExec = (element, exclude = {}) => {
+  const { __ref: ref } = element;
   for (const param in element) {
+    if (exclude[param])
+      continue;
     const prop = element[param];
     if ((0, import_utils.isFunction)(prop) && !(0, import_methods.isMethod)(param)) {
-      __exec[param] = prop;
+      ref.__exec[param] = prop;
       element[param] = prop(element, element.state);
     }
   }
 };
-const throughUpdatedExec = (element, options) => {
-  const { __ref } = element;
-  const { __exec, __cached } = __ref;
+const throughUpdatedExec = (element, options = { excludes: import_utils2.METHODS_EXL }) => {
+  const { __ref: ref } = element;
   const changes = {};
-  for (const param in __exec) {
+  for (const param in ref.__exec) {
     const prop = element[param];
-    const newExec = __exec[param](element, element.state);
-    if (prop && prop.node && ((0, import_utils.isString)(newExec) || (0, import_utils.isNumber)(newExec))) {
+    const isDefinedParam = ref.__defineCache[param];
+    if (isDefinedParam)
+      continue;
+    const newExec = ref.__exec[param](element, element.state);
+    const execReturnsString = (0, import_utils.isString)(newExec) || (0, import_utils.isNumber)(newExec);
+    if (prop && prop.node && execReturnsString) {
       (0, import_utils2.overwrite)(prop, { text: newExec }, options);
     } else if (newExec !== prop) {
-      __cached[param] = changes[param] = prop;
+      ref.__cached[param] = changes[param] = prop;
       element[param] = newExec;
     }
   }
   return changes;
 };
 const throughInitialDefine = (element) => {
-  const { define, context, __ref } = element;
-  const { __exec, __cached } = __ref;
-  let obj = {};
+  const { define, context, __ref: ref } = element;
+  let defineObj = {};
+  const hasGlobalDefine = context && (0, import_utils.isObject)(context.define);
   if ((0, import_utils.isObject)(define))
-    obj = { ...define };
-  if (context && (0, import_utils.isObject)(context.define))
-    obj = { ...obj, ...context.define };
-  for (const param in obj) {
-    let prop = element[param];
-    if ((0, import_utils.isFunction)(prop) && !(0, import_methods.isMethod)(param)) {
-      __exec[param] = prop;
-      const execParam2 = prop = (0, import_utils.exec)(prop, element);
-      if (execParam2)
-        element[param] = execParam2;
+    defineObj = { ...define };
+  if (hasGlobalDefine)
+    defineObj = { ...defineObj, ...context.define };
+  for (const param in defineObj) {
+    let elementProp = element[param];
+    if ((0, import_utils.isFunction)(elementProp) && !(0, import_methods.isMethod)(param)) {
+      ref.__exec[param] = elementProp;
+      const execParam2 = elementProp = (0, import_utils.exec)(elementProp, element);
+      if (execParam2) {
+        elementProp = element[param] = execParam2.parse ? execParam2.parse() : execParam2;
+        ref.__defineCache[param] = elementProp;
+      }
     }
-    __cached[param] = prop;
-    const execParam = obj[param](prop, element, element.state);
+    const execParam = defineObj[param](elementProp, element, element.state);
     if (execParam)
       element[param] = execParam;
   }
   return element;
 };
 const throughUpdatedDefine = (element) => {
-  const { context, define, __ref } = element;
-  const { __exec, __cached } = __ref;
+  const { context, define, __ref: ref } = element;
   const changes = {};
   let obj = {};
   if ((0, import_utils.isObject)(define))
@@ -87,10 +91,10 @@ const throughUpdatedDefine = (element) => {
   if ((0, import_utils.isObject)(context && context.define))
     obj = { ...obj, ...context.define };
   for (const param in obj) {
-    const execParam = __exec[param];
+    const execParam = ref.__exec[param];
     if (execParam)
-      __cached[param] = execParam(element, element.state);
-    const cached = (0, import_utils.exec)(__cached[param], element);
+      ref.__defineCache[param] = execParam(element, element.state);
+    const cached = (0, import_utils.exec)(ref.__defineCache[param], element);
     const newExecParam = obj[param](cached, element, element.state);
     if (newExecParam)
       element[param] = newExecParam;

package/dist/cjs/element/methods.js

@@ -58,7 +58,7 @@ const parse = function(excl = []) {
     if (v === "state") {
       if (element.__ref && element.__ref.__hasRootState)
         return;
-      if ((0, import_utils.isFunction)(val == null ? void 0 : val.parse))
+      if ((0, import_utils.isFunction)(val && val.parse))
         val = val.parse();
     } else if (v === "props") {
       const { __element, update: update2, ...props } = element[v];

package/dist/cjs/element/node.js

@@ -38,24 +38,24 @@ var import_mixins = require("./mixins");
 var import_applyParam = require("./applyParam");
 const ENV = "development";
 const createNode = (element, options) => {
-  let { node, tag, __ref } = element;
+  let { node, tag, __ref: ref } = element;
   let isNewNode;
   if (!node) {
     isNewNode = true;
-    if (!__ref.__if)
+    if (!ref.__if)
       return element;
     if (tag === "shadow") {
       node = element.node = element.parent.node.attachShadow({ mode: "open" });
     } else
       node = element.node = (0, import_node.cacheNode)(element);
-    (0, import_event.triggerEventOn)("attachNode", element);
+    (0, import_event.triggerEventOn)("attachNode", element, options);
   }
   if (ENV === "test" || ENV === "development" || options.alowRefReference) {
     node.ref = element;
     if ((0, import_utils.isFunction)(node.setAttribute))
       node.setAttribute("key", element.key);
   }
-  if (!__ref.__if)
+  if (!ref.__if)
     return element;
   if (element.tag !== "string" || element.tag !== "fragment") {
     (0, import_iterate.throughInitialDefine)(element);

package/dist/cjs/element/update.js

@@ -32,13 +32,14 @@ var import_utils = require("@domql/utils");
 var import_event = require("@domql/event");
 var import_methods = require("@domql/methods");
 var import_key = require("@domql/key");
-var import_utils2 = require("../utils");
+var import_props = require("@domql/props");
+var import_state = require("@domql/state");
+var import_utils2 = require("./utils");
 var import_create = __toESM(require("./create"));
 var import_iterate = require("./iterate");
 var import_mixins = require("./mixins");
-var import_props = require("./props");
-var import_state = __toESM(require("./state"));
 var import_applyParam = require("./applyParam");
+var import_options = __toESM(require("./options"));
 const snapshot = {
   snapshotId: import_key.createSnapshotId
 };
@@ -47,46 +48,53 @@ const UPDATE_DEFAULT_OPTIONS = {
   cleanExec: true,
   preventRecursive: false,
   currentSnapshot: false,
-  calleeElement: false
+  calleeElement: false,
+  excludes: import_utils2.METHODS_EXL
 };
 const update = function(params = {}, options = UPDATE_DEFAULT_OPTIONS) {
   const element = this;
   const { parent, node, key } = element;
-  let __ref = element.__ref;
-  if (!__ref)
-    __ref = element.__ref = {};
+  const { excludes, preventInheritAtCurrentState } = options;
+  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element)
+    return;
+  if (!excludes)
+    (0, import_utils.merge)(options, UPDATE_DEFAULT_OPTIONS);
+  let ref = element.__ref;
+  if (!ref)
+    ref = element.__ref = {};
   const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(element, options);
   if (snapshotHasUpdated)
     return;
   if ((0, import_utils.isString)(params) || (0, import_utils.isNumber)(params)) {
     params = { text: params };
   }
-  const ifFails = checkIfOnUpdate(element, options);
+  const ifFails = checkIfOnUpdate(element, parent, options);
   if (ifFails)
     return;
   const inheritState = inheritStateUpdates(element, options);
   if (inheritState === false)
     return;
-  if (__ref.__if && !options.preventPropsUpdate) {
+  if (ref.__if && !options.preventPropsUpdate) {
     const hasParentProps = parent.props && (parent.props[key] || parent.props.childProps);
-    const hasFunctionInProps = element.__ref.__props.filter((v) => (0, import_utils.isFunction)(v));
+    const hasFunctionInProps = ref.__props.filter((v) => (0, import_utils.isFunction)(v));
     const props = params.props || hasParentProps || hasFunctionInProps.length;
     if (props)
       (0, import_props.updateProps)(props, element, parent);
   }
   if (!options.preventInitUpdateListener) {
-    const initUpdateReturns = (0, import_event.triggerEventOn)("initUpdate", element, params);
+    const initUpdateReturns = (0, import_event.triggerEventOnUpdate)("initUpdate", params, element, options);
     if (initUpdateReturns === false)
       return element;
   }
-  const overwriteChanges = (0, import_utils2.overwriteDeep)(params, element);
-  const execChanges = (0, import_iterate.throughUpdatedExec)(element, UPDATE_DEFAULT_OPTIONS);
+  (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
+  const overwriteChanges = (0, import_utils.overwriteDeep)(element, params, import_utils2.METHODS_EXL);
+  const execChanges = (0, import_iterate.throughUpdatedExec)(element, { ignore: UPDATE_DEFAULT_OPTIONS });
   const definedChanges = (0, import_iterate.throughUpdatedDefine)(element);
   if (options.stackChanges && element.__stackChanges) {
-    const stackChanges = (0, import_utils2.merge)(definedChanges, (0, import_utils2.merge)(execChanges, overwriteChanges));
+    const stackChanges = (0, import_utils.merge)(definedChanges, (0, import_utils.merge)(execChanges, overwriteChanges));
     element.__stackChanges.push(stackChanges);
   }
-  if (!__ref.__if)
+  if (!ref.__if)
     return false;
   if (!node) {
     return;
@@ -115,41 +123,41 @@ const update = function(params = {}, options = UPDATE_DEFAULT_OPTIONS) {
     }
   }
   if (!options.preventUpdateListener)
-    (0, import_event.triggerEventOn)("update", element);
+    (0, import_event.triggerEventOn)("update", element, options);
 };
 const captureSnapshot = (element, options) => {
-  const __ref = element.__ref;
+  const ref = element.__ref;
   const { currentSnapshot, calleeElement } = options;
   const isCallee = calleeElement === element;
   if (!calleeElement || isCallee) {
     const createdStanpshot = snapshot.snapshotId();
-    __ref.__currentSnapshot = createdStanpshot;
+    ref.__currentSnapshot = createdStanpshot;
     return [createdStanpshot, element];
   }
-  const snapshotOnCallee = calleeElement.__ref.__currentSnapshot;
+  const snapshotOnCallee = ref.__currentSnapshot;
   if (currentSnapshot < snapshotOnCallee) {
     return [snapshotOnCallee, calleeElement, true];
   }
   return [snapshotOnCallee, calleeElement];
 };
-const checkIfOnUpdate = (element, options) => {
+const checkIfOnUpdate = (element, parent, options) => {
   if (!(0, import_utils.isFunction)(element.if))
     return;
-  const __ref = element.__ref;
-  const ifPassed = element.if(element, element.state);
-  const itWasFalse = __ref.__if !== true;
+  const ref = element.__ref;
+  const ifPassed = element.if(element, element.state, element.context);
+  const itWasFalse = ref.__if !== true;
   if (ifPassed) {
-    __ref.__if = true;
+    ref.__if = true;
     if (itWasFalse) {
       delete element.__hash;
       delete element.extend;
-      if (!__ref.__hasRootState) {
+      if (!ref.__hasRootState) {
         delete element.state;
       }
-      if (__ref.__state) {
-        element.state = __ref.__state;
+      if (ref.__state) {
+        element.state = ref.__state;
       }
-      const created = (0, import_create.default)(element, element.parent, element.key);
+      const created = (0, import_create.default)(element, parent, element.key, import_options.default.create);
       if (!options.preventUpdate && element.on && (0, import_utils.isFunction)(element.on.update)) {
         (0, import_event.applyEvent)(element.on.update, created, created.state);
       }
@@ -157,26 +165,52 @@ const checkIfOnUpdate = (element, options) => {
     }
   } else if (element.node && !ifPassed) {
     element.node.remove();
-    delete __ref.__if;
+    delete ref.__if;
   }
 };
 const inheritStateUpdates = (element, options) => {
-  const { __ref } = element;
-  const stateKey = __ref.__state;
-  const { parent } = element;
-  if (!stateKey && !__ref.__hasRootState) {
-    element.state = (parent == null ? void 0 : parent.state) || {};
+  const { __ref: ref } = element;
+  const stateKey = ref.__state;
+  const { parent, state } = element;
+  if (options.preventpdateTriggerStateUpdate)
+    return;
+  if (!stateKey && !ref.__hasRootState) {
+    element.state = parent && parent.state || {};
     return;
   }
-  const parentState = (parent == null ? void 0 : parent.state) || {};
+  const { isHoisted, execStateFunction, stateFunctionOverwrite } = options;
+  const shouldForceStateUpdate = (0, import_utils.isFunction)(stateKey) && (!isHoisted && execStateFunction && stateFunctionOverwrite);
+  if (shouldForceStateUpdate) {
+    const execState = (0, import_utils.exec)(stateKey, element);
+    state.set(execState, {
+      ...options,
+      preventUpdate: true
+    });
+    return;
+  }
+  const parentState = parent && parent.state || {};
   const keyInParentState = parentState[stateKey];
-  if (!keyInParentState)
+  if (!keyInParentState || options.preventInheritedStateUpdate)
     return;
-  const initStateReturns = (0, import_event.triggerEventOn)("initStateUpdated", element, keyInParentState);
-  if (initStateReturns === false)
-    return element;
-  const newState = (0, import_state.default)(element, parent);
+  if (!options.preventInitStateUpdateListener) {
+    const initStateReturns = (0, import_event.triggerEventOnUpdate)("initStateUpdated", keyInParentState, element, options);
+    if (initStateReturns === false)
+      return element;
+  }
+  const newState = createStateUpdate(element, parent, options);
+  if (!options.preventStateUpdateListener) {
+    (0, import_event.triggerEventOnUpdate)("stateUpdated", newState.parse(), element, options);
+  }
+};
+const createStateUpdate = (element, parent, options) => {
+  const __stateChildren = element.state.__children;
+  const newState = (0, import_state.createState)(element, parent);
   element.state = newState;
-  (0, import_event.triggerEventOn)("stateUpdated", element, newState.parse());
+  for (const child in __stateChildren) {
+    if (newState[child])
+      newState.__children[child] = __stateChildren[child];
+    __stateChildren[child].parent = newState;
+  }
+  return newState;
 };
 var update_default = update;