@domql/element 2.4.1 → 2.4.2

package/dist/cjs/update.js

@@ -1,223 +0,0 @@
-"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)
-    __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))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  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, {
-  default: () => update_default
-});
-module.exports = __toCommonJS(update_exports);
-var import_utils = require("@domql/utils");
-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("./applyParam");
-var import_options = __toESM(require("./cache/options"), 1);
-const snapshot = {
-  snapshotId: import_utils.createSnapshotId
-};
-const UPDATE_DEFAULT_OPTIONS = {
-  stackChanges: false,
-  cleanExec: true,
-  preventRecursive: false,
-  currentSnapshot: false,
-  calleeElement: false,
-  excludes: import_utils2.METHODS_EXL
-};
-const update = function(params = {}, options = UPDATE_DEFAULT_OPTIONS) {
-  const element = this;
-  const { parent, node, key } = element;
-  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, parent, options);
-  if (ifFails)
-    return;
-  const inheritState = inheritStateUpdates(element, options);
-  if (inheritState === false)
-    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 props = params.props || hasParentProps || hasFunctionInProps.length;
-    if (props)
-      (0, import_props.updateProps)(props, element, parent);
-  }
-  if (!options.isForced) {
-    (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
-  }
-  if (!options.preventInitUpdateListener) {
-    const initUpdateReturns = (0, import_event.triggerEventOnUpdate)("initUpdate", params, element, options);
-    if (initUpdateReturns === false)
-      return element;
-  }
-  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_utils.merge)(definedChanges, (0, import_utils.merge)(execChanges, overwriteChanges));
-    element.__stackChanges.push(stackChanges);
-  }
-  if (!ref.__if)
-    return false;
-  if (!node) {
-    return;
-  }
-  for (const param in element) {
-    const prop = element[param];
-    const hasOnlyUpdateFalsy = options.onlyUpdate && (options.onlyUpdate !== param || !element.lookup(options.onlyUpdate));
-    const isInPreventUpdate = (0, import_utils.isArray)(options.preventUpdate) && options.preventUpdate.includes(param);
-    const isInPreventDefineUpdate = (0, import_utils.isArray)(options.preventDefineUpdate) && options.preventDefineUpdate.includes(param);
-    if ((0, import_utils.isUndefined)(prop) || hasOnlyUpdateFalsy || isInPreventUpdate || isInPreventDefineUpdate || options.preventDefineUpdate === true || options.preventDefineUpdate === param || options.preventContentUpdate && param === "content" || (options.preventStateUpdate && param) === "state" || (0, import_methods.isMethod)(param) || (0, import_utils.isObject)(import_mixins.registry[param]) || (0, import_utils2.isVariant)(param))
-      continue;
-    if (options.preventStateUpdate === "once")
-      options.preventStateUpdate = false;
-    const isElement = (0, import_applyParam.applyParam)(param, element, options);
-    if (isElement) {
-      const { hasDefine, hasContextDefine } = isElement;
-      const canUpdate = (0, import_utils.isObject)(prop) && !hasDefine && !hasContextDefine && !options.preventRecursive;
-      if (!canUpdate)
-        continue;
-      const childUpdateCall = () => update.call(prop, params[prop], {
-        ...options,
-        currentSnapshot: snapshotOnCallee,
-        calleeElement
-      });
-      if (element.props && element.props.lazyLoad || options.lazyLoad) {
-        import_utils.window.requestAnimationFrame(() => childUpdateCall());
-      } else
-        childUpdateCall();
-    }
-  }
-  if (!options.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 = ref.__currentSnapshot;
-  if (currentSnapshot < snapshotOnCallee) {
-    return [snapshotOnCallee, calleeElement, true];
-  }
-  return [snapshotOnCallee, calleeElement];
-};
-const checkIfOnUpdate = (element, parent, options) => {
-  if (!(0, import_utils.isFunction)(element.if) || !element.state || !parent)
-    return;
-  const ref = element.__ref;
-  const ifPassed = element.if(element, element.state, element.context, options);
-  const itWasFalse = ref.__if !== true;
-  if (ifPassed) {
-    ref.__if = true;
-    if (itWasFalse) {
-      delete element.__hash;
-      delete element.extend;
-      if (!ref.__hasRootState) {
-        delete element.state;
-      }
-      if (ref.__state) {
-        element.state = ref.__state;
-      }
-      const created = (0, import_create.default)(element, parent, element.key, import_options.default.create);
-      if (options.preventUpdate !== true && element.on && (0, import_utils.isFunction)(element.on.update)) {
-        (0, import_event.applyEvent)(element.on.update, created, created.state);
-      }
-      return created;
-    }
-  } else if (element.node && !ifPassed) {
-    element.node.remove();
-    delete ref.__if;
-  }
-};
-const inheritStateUpdates = (element, options) => {
-  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 { 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 || options.preventInheritedStateUpdate)
-    return;
-  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;
-  for (const child in __stateChildren) {
-    if (newState[child])
-      newState.__children[child] = __stateChildren[child];
-    __stateChildren[child].parent = newState;
-  }
-  return newState;
-};
-var update_default = update;