@domql/element 2.5.184 → 2.5.186

package/dist/esm/update.js

@@ -0,0 +1,255 @@
+import {
+  window,
+  exec,
+  isArray,
+  isFunction,
+  isNumber,
+  isObject,
+  isString,
+  isUndefined,
+  merge,
+  isVariant,
+  overwriteDeep,
+  createSnapshotId,
+  deepClone
+} from "@domql/utils";
+import { applyEvent, triggerEventOn, triggerEventOnUpdate } from "@domql/event";
+import { isMethod } from "./methods/index.js";
+import { updateProps } from "./props/index.js";
+import { createState, findInheritedState } from "@domql/state";
+import { create } from "./create.js";
+import { throughExecProps, throughUpdatedDefine, throughUpdatedExec } from "./iterate.js";
+import { REGISTRY } from "./mixins/index.js";
+import { applyParam } from "./utils/applyParam.js";
+import { OPTIONS } from "./cache/options.js";
+import { METHODS_EXL, deepMerge } from "./utils/index.js";
+const snapshot = {
+  snapshotId: createSnapshotId
+};
+const UPDATE_DEFAULT_OPTIONS = {
+  stackChanges: false,
+  cleanExec: true,
+  preventRecursive: false,
+  currentSnapshot: false,
+  calleeElement: false,
+  excludes: METHODS_EXL
+};
+const update = function(params = {}, opts) {
+  const calleeElementCache = opts == null ? void 0 : opts.calleeElement;
+  const options = deepClone(isObject(opts) ? 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);
+  if (snapshotHasUpdated)
+    return;
+  if (!options.preventListeners)
+    triggerEventOnUpdate("startUpdate", params, element, options);
+  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element)
+    return;
+  if (!excludes)
+    merge(options, UPDATE_DEFAULT_OPTIONS);
+  if (isString(params) || isNumber(params)) {
+    params = { text: params };
+  }
+  const inheritState = inheritStateUpdates(element, options);
+  if (inheritState === false)
+    return;
+  const ifFails = 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) => isFunction(v));
+    const props = params.props || hasParentProps || hasFunctionInProps.length;
+    if (props)
+      updateProps(props, element, parent);
+  }
+  if (!options.preventBeforeUpdateListener && !options.preventListeners) {
+    const beforeUpdateReturns = triggerEventOnUpdate("beforeUpdate", params, element, options);
+    if (beforeUpdateReturns === false)
+      return element;
+  }
+  overwriteDeep(element, params, { exclude: METHODS_EXL });
+  throughExecProps(element);
+  throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS });
+  throughUpdatedDefine(element);
+  if (!options.isForced && !options.preventListeners) {
+    triggerEventOn("beforeClassAssign", element, options);
+  }
+  if (!ref.__if)
+    return false;
+  if (!node) {
+    return;
+  }
+  const {
+    preventUpdate,
+    preventDefineUpdate,
+    preventContentUpdate,
+    preventStateUpdate,
+    preventRecursive,
+    preventUpdateListener,
+    preventUpdateAfter,
+    preventUpdateAfterCount
+  } = options;
+  if (preventUpdateAfter) {
+    if (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 (element.Iframe && element.Overlay && element.ComponentFrameCanvas && param === "Iframe") {
+      console.log("isframe");
+    }
+    if (!Object.hasOwnProperty.call(element, param))
+      continue;
+    const isInPreventUpdate = isArray(preventUpdate) && preventUpdate.includes(param);
+    const isInPreventDefineUpdate = isArray(preventDefineUpdate) && preventDefineUpdate.includes(param);
+    const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection;
+    if (isUndefined(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || preventContentUpdate && param === "content" && !hasCollection || (preventStateUpdate && param) === "state" || isMethod(param, element) || isObject(REGISTRY[param]) || isVariant(param))
+      continue;
+    if (preventStateUpdate === "once")
+      options.preventStateUpdate = false;
+    const isElement = applyParam(param, element, options);
+    if (isElement) {
+      const { hasDefine, hasContextDefine } = isElement;
+      const canUpdate = isObject(prop) && !hasDefine && !hasContextDefine && !preventRecursive;
+      if (!canUpdate)
+        continue;
+      const lazyLoad = element.props.lazyLoad || options.lazyLoad;
+      if (options.onEachUpdate) {
+        options.onEachUpdate(param, element, element.state, element.context);
+      }
+      const childUpdateCall = () => update.call(prop, params[prop], {
+        ...options,
+        currentSnapshot: snapshotOnCallee,
+        calleeElement
+      });
+      lazyLoad ? window.requestAnimationFrame(() => childUpdateCall()) : childUpdateCall();
+    }
+  }
+  if (!preventUpdateListener)
+    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];
+};
+const checkIfOnUpdate = (element, parent, options) => {
+  var _a, _b, _c;
+  if (!isFunction(element.if) && !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 itWasFalse = ref.__if !== true;
+  if (ifPassed) {
+    ref.__if = true;
+    if (itWasFalse) {
+      delete element.__hash;
+      delete element.__text;
+      delete element.extend;
+      if (!ref.__hasRootState) {
+        delete element.state;
+      }
+      if (ref.__state) {
+        element.state = ref.__state;
+      } else if (!ref.__hasRootState) {
+        delete element.state;
+      }
+      if (element.node) {
+        element.node.remove();
+        delete element.node;
+      }
+      const contentKey = ref.contentElementKey;
+      if (element.$collection || element.$stateCollection || element.$propsCollection) {
+        element.removeContent();
+      } 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;
+      const nextElement = element.nextElement();
+      const nextNode = nextElement == null ? void 0 : nextElement.node;
+      const hasNext = nextNode == null ? void 0 : nextNode.parentNode;
+      const attachOptions = (hasPrevious || hasNext) && {
+        position: hasPrevious ? "after" : hasNext ? "before" : null,
+        node: hasPrevious && previousNode || hasNext && nextNode
+      };
+      delete element.__ref;
+      delete element.parent;
+      const createdElement = create(element, parent, element.key, OPTIONS.create, attachOptions);
+      if (options.preventUpdate !== true && element.on && isFunction(element.on.update)) {
+        applyEvent(element.on.update, createdElement, createdElement.state);
+      }
+      return createdElement;
+    }
+  } 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;
+  const { preventUpdateTriggerStateUpdate, isHoisted, execStateFunction } = options;
+  if (preventUpdateTriggerStateUpdate)
+    return;
+  if (!stateKey && !ref.__hasRootState) {
+    element.state = parent && parent.state || {};
+    return;
+  }
+  const shouldForceFunctionState = isFunction(stateKey) && !isHoisted && execStateFunction;
+  if (shouldForceFunctionState) {
+    const execState = exec(stateKey, element);
+    state.set(execState, { ...options, preventUpdate: true, preventStateUpdateListener: false, updatedByStateFunction: true });
+    return;
+  }
+  const keyInParentState = findInheritedState(element, element.parent);
+  if (!keyInParentState || options.preventInheritedStateUpdate)
+    return;
+  if (!options.preventBeforeStateUpdateListener && !options.preventListeners) {
+    const initStateReturns = triggerEventOnUpdate("beforeStateUpdate", keyInParentState, element, options);
+    if (initStateReturns === false)
+      return element;
+  }
+  const newState = createStateUpdate(element, parent, options);
+  if (!options.preventStateUpdateListener && !options.preventListeners) {
+    triggerEventOnUpdate("stateUpdate", newState.parse(), element, options);
+  }
+};
+const createStateUpdate = (element, parent, options) => {
+  const __stateChildren = element.state.__children;
+  const newState = createState(element, parent);
+  element.state = newState;
+  for (const child in __stateChildren) {
+    if (newState[child])
+      newState.__children[child] = __stateChildren[child];
+    Object.getPrototypeOf(__stateChildren[child]).parent = newState;
+  }
+  return newState;
+};
+var update_default = update;
+export {
+  update_default as default,
+  update
+};

package/dist/esm/utils/applyParam.js

@@ -0,0 +1,25 @@
+import { isFunction } from "@domql/utils";
+import { REGISTRY } from "../mixins/index.js";
+const applyParam = (param, element, options) => {
+  const { node, context, __ref: ref } = element;
+  const prop = element[param];
+  const { onlyUpdate } = options;
+  const DOMQLProperty = REGISTRY[param];
+  const DOMQLPropertyFromContext = context && context.registry && context.registry[param];
+  const isGlobalTransformer = DOMQLPropertyFromContext || DOMQLProperty;
+  const hasDefine = element.define && element.define[param];
+  const hasContextDefine = context && context.define && context.define[param];
+  if (!ref.__if)
+    return;
+  const hasOnlyUpdate = onlyUpdate ? onlyUpdate === param || element.lookup(onlyUpdate) : true;
+  if (isGlobalTransformer && !hasContextDefine && hasOnlyUpdate) {
+    if (isFunction(isGlobalTransformer)) {
+      isGlobalTransformer(prop, element, node, options);
+      return;
+    }
+  }
+  return { hasDefine, hasContextDefine };
+};
+export {
+  applyParam
+};

package/dist/esm/utils/component.js

@@ -0,0 +1,65 @@
+import {
+  isObject,
+  isString,
+  overwriteDeep,
+  checkIfKeyIsComponent,
+  addAdditionalExtend,
+  hasVariantProp,
+  isVariant
+} from "@domql/utils";
+import { applyExtend } from "../extend.js";
+import { REGISTRY } from "../mixins/index.js";
+const createValidDomqlObjectFromSugar = (el, parent, key, options) => {
+  const newElem = {
+    props: {},
+    define: {}
+  };
+  for (const k in el) {
+    const value = el[k];
+    const isComponent = checkIfKeyIsComponent(k);
+    const isRegistry = REGISTRY[k];
+    const allowedKeys = ["data", "state", "attr", "if"];
+    if (isComponent || isRegistry || allowedKeys.includes(k)) {
+      newElem[k] = value;
+    } else {
+      newElem.props[k] = value;
+    }
+  }
+  return newElem;
+};
+const overwriteVariant = (element, variant, variantProps) => {
+  let variantElement = element[variant];
+  if (!variantElement)
+    return;
+  const props = isObject(variantProps) ? variantProps : {};
+  if (isString(variantElement)) {
+    variantElement = {
+      extend: [{ props }, variantElement]
+    };
+  } else if (variantElement.extend) {
+    variantElement = addAdditionalExtend({ props }, variantElement);
+  }
+  const extendedVariant = applyExtend(variantElement, element.parent);
+  const { parent, ...rest } = extendedVariant;
+  return overwriteDeep(element, rest);
+};
+const applyVariant = (element) => {
+  const { props } = element;
+  if (!hasVariantProp(element))
+    return element;
+  const { variant } = props;
+  overwriteVariant(element, `.${variant}`);
+  const elKeys = Object.keys(element).filter((key) => isVariant(key));
+  elKeys.forEach((variant2) => {
+    const slicedVariantElementKey = variant2.slice(1);
+    const variantElementProps = props[slicedVariantElementKey];
+    if (variantElementProps)
+      overwriteVariant(element, variant2, variantElementProps);
+  });
+  return element;
+};
+export {
+  applyVariant,
+  createValidDomqlObjectFromSugar,
+  overwriteVariant
+};

package/dist/esm/utils/extendUtils.js

@@ -0,0 +1,122 @@
+import { isArray, isFunction, isObject, isString, deepClone } from "@domql/utils";
+const ENV = "development";
+const generateHash = () => Math.random().toString(36).substring(2);
+const extendStackRegistry = {};
+const extendCachedRegistry = {};
+const getHashedExtend = (extend) => {
+  return extendStackRegistry[extend.__hash];
+};
+const setHashedExtend = (extend, stack) => {
+  const hash = generateHash();
+  if (!isString(extend)) {
+    extend.__hash = hash;
+  }
+  extendStackRegistry[hash] = stack;
+  return stack;
+};
+const getExtendStackRegistry = (extend, stack) => {
+  if (extend.__hash) {
+    return stack.concat(getHashedExtend(extend));
+  }
+  return setHashedExtend(extend, stack);
+};
+const extractArrayExtend = (extend, stack, context) => {
+  extend.forEach((each) => flattenExtend(each, stack, context));
+  return stack;
+};
+const deepExtend = (extend, stack, context) => {
+  const extendOflattenExtend = extend.extend;
+  if (extendOflattenExtend) {
+    flattenExtend(extendOflattenExtend, stack, context);
+  }
+  return stack;
+};
+const flattenExtend = (extend, stack, context) => {
+  if (!extend)
+    return stack;
+  if (isArray(extend))
+    return extractArrayExtend(extend, stack, context);
+  if (isString(extend))
+    extend = fallbackStringExtend(extend, context);
+  stack.push(extend);
+  if (extend.extend)
+    deepExtend(extend, stack, context);
+  return stack;
+};
+const deepMergeExtend = (element, extend) => {
+  for (const e in extend) {
+    if (["parent", "node", "__element"].indexOf(e) > -1)
+      continue;
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (elementProp === void 0) {
+      element[e] = extendProp;
+    } else if (isObject(elementProp) && isObject(extendProp)) {
+      deepMergeExtend(elementProp, extendProp);
+    } else if (isArray(elementProp) && isArray(extendProp)) {
+      element[e] = elementProp.concat(extendProp);
+    } else if (isArray(elementProp) && isObject(extendProp)) {
+      const obj = deepMergeExtend({}, elementProp);
+      element[e] = deepMergeExtend(obj, extendProp);
+    } else if (elementProp === void 0 && isFunction(extendProp)) {
+      element[e] = extendProp;
+    }
+  }
+  return element;
+};
+const cloneAndMergeArrayExtend = (stack) => {
+  return stack.reduce((a, c) => {
+    return deepMergeExtend(a, deepClone(c));
+  }, {});
+};
+const fallbackStringExtend = (extend, context, options = {}, variant) => {
+  const COMPONENTS = context && context.components || options.components;
+  const PAGES = context && context.pages || options.pages;
+  if (isString(extend)) {
+    const componentExists = COMPONENTS && (COMPONENTS[extend + "." + variant] || COMPONENTS[extend] || COMPONENTS["smbls." + extend]);
+    const pageExists = PAGES && extend.startsWith("/") && PAGES[extend];
+    if (componentExists)
+      return componentExists;
+    else if (pageExists)
+      return pageExists;
+    else {
+      if (options.verbose && (ENV === "test" || ENV === "development")) {
+        console.warn("Extend is string but component was not found:", extend);
+      }
+      return {};
+    }
+  }
+  return extend;
+};
+const jointStacks = (extendStack, childExtendStack) => {
+  return [].concat(extendStack.slice(0, 1)).concat(childExtendStack.slice(0, 1)).concat(extendStack.slice(1)).concat(childExtendStack.slice(1));
+};
+const getExtendStack = (extend, context) => {
+  if (!extend)
+    return [];
+  if (extend.__hash)
+    return getHashedExtend(extend) || [];
+  const stack = flattenExtend(extend, [], context);
+  return getExtendStackRegistry(extend, stack);
+};
+const getExtendMerged = (extend) => {
+  const stack = getExtendStack(extend);
+  return cloneAndMergeArrayExtend(stack);
+};
+export {
+  cloneAndMergeArrayExtend,
+  deepExtend,
+  deepMergeExtend,
+  extendCachedRegistry,
+  extendStackRegistry,
+  extractArrayExtend,
+  fallbackStringExtend,
+  flattenExtend,
+  generateHash,
+  getExtendMerged,
+  getExtendStack,
+  getExtendStackRegistry,
+  getHashedExtend,
+  jointStacks,
+  setHashedExtend
+};

package/dist/esm/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./object.js";
+export * from "./extendUtils.js";
+export * from "./component.js";

package/dist/esm/utils/object.js

@@ -0,0 +1,159 @@
+import { isArray, isObject, isObjectLike, joinArrays, deepClone } from "@domql/utils";
+import { IGNORE_PROPS_PARAMS } from "../props/index.js";
+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",
+  "setByPath",
+  "setPathCollection",
+  "removeByPath",
+  "removePathCollection",
+  "getByPath"
+];
+const METHODS = [
+  "set",
+  "reset",
+  "update",
+  "remove",
+  "updateContent",
+  "removeContent",
+  "lookup",
+  "lookdown",
+  "lookdownAll",
+  "getRef",
+  "getPath",
+  "setNodeStyles",
+  "spotByPath",
+  "keys",
+  "parse",
+  "setProps",
+  "parseDeep",
+  "variables",
+  "if",
+  "log",
+  "nextElement",
+  "previousElement"
+];
+const METHODS_EXL = joinArrays(
+  ["node", "state", "context", "extend", "__element"],
+  METHODS,
+  IGNORE_STATE_PARAMS,
+  IGNORE_PROPS_PARAMS
+);
+const deepMerge = (element, extend, exclude = METHODS_EXL) => {
+  for (const e in extend) {
+    if (exclude.includes(e))
+      continue;
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (elementProp === void 0) {
+      element[e] = extendProp;
+    } else if (isObjectLike(elementProp) && isObject(extendProp)) {
+      deepMerge(elementProp, extendProp);
+    }
+  }
+  return element;
+};
+const clone = (obj, exclude = METHODS_EXL) => {
+  const o = {};
+  for (const e in obj) {
+    if (exclude.includes(e))
+      continue;
+    o[e] = obj[e];
+  }
+  return o;
+};
+const overwrite = (element, params, options) => {
+  const changes = {};
+  const { __ref } = element;
+  const { __exec, __cached } = __ref;
+  for (const e in params) {
+    if (e === "props" || e === "state" || e === "__ref")
+      continue;
+    const elementProp = element[e];
+    const paramsProp = params[e];
+    if (paramsProp !== void 0) {
+      __cached[e] = changes[e] = elementProp;
+      element[e] = paramsProp;
+    }
+    if (options.cleanExec)
+      delete __exec[e];
+  }
+  return changes;
+};
+const overwriteShallow = (obj, params, exclude = METHODS_EXL) => {
+  for (const e in params) {
+    if (exclude.includes(e))
+      continue;
+    obj[e] = params[e];
+  }
+  return obj;
+};
+const overwriteDeep = (obj, params, exclude = METHODS_EXL) => {
+  for (const e in params) {
+    if (exclude.includes(e))
+      continue;
+    const objProp = obj[e];
+    const paramsProp = params[e];
+    if (isObjectLike(objProp) && isObjectLike(paramsProp)) {
+      overwriteDeep(objProp, paramsProp);
+    } else if (paramsProp !== void 0) {
+      obj[e] = paramsProp;
+    }
+  }
+  return obj;
+};
+const mergeIfExisted = (a, b) => {
+  if (isObjectLike(a) && isObjectLike(b))
+    return deepMerge(a, b);
+  return a || b;
+};
+const mergeArray = (arr, exclude = ["parent", "node", "__element", "state", "context", "__ref"]) => {
+  return arr.reduce((a, c) => deepMerge(a, deepClone(c, { exclude })), {});
+};
+const mergeAndCloneIfArray = (obj) => {
+  return isArray(obj) ? mergeArray(obj) : deepClone(obj);
+};
+const flattenRecursive = (param, prop, stack = []) => {
+  const objectized = mergeAndCloneIfArray(param);
+  stack.push(objectized);
+  const extendOfExtend = objectized[prop];
+  if (extendOfExtend)
+    flattenRecursive(extendOfExtend, prop, stack);
+  delete objectized[prop];
+  return stack;
+};
+export {
+  METHODS,
+  METHODS_EXL,
+  clone,
+  deepMerge,
+  flattenRecursive,
+  mergeAndCloneIfArray,
+  mergeArray,
+  mergeIfExisted,
+  overwrite,
+  overwriteDeep,
+  overwriteShallow
+};