@domql/element 2.5.200 → 2.5.205

package/dist/esm/utils/extendUtils.js

@@ -32,16 +32,21 @@ const deepExtend = (extend, 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);
+  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);
+  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;
+    if (["parent", "node", "__element"].indexOf(e) > -1)
+      continue;
     const elementProp = element[e];
     const extendProp = extend[e];
     if (elementProp === void 0) {
@@ -70,10 +75,12 @@ const fallbackStringExtend = (extend, context, options = {}, variant) => {
   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;
+    if (componentExists)
+      return componentExists;
+    else if (pageExists)
+      return pageExists;
     else {
-      if (options.verbose && (ENV === "test" || ENV === "development")) {
+      if (options.verbose && (ENV === "testing" || ENV === "development")) {
         console.warn("Extend is string but component was not found:", extend);
       }
       return {};
@@ -85,8 +92,10 @@ 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) || [];
+  if (!extend)
+    return [];
+  if (extend.__hash)
+    return getHashedExtend(extend) || [];
   const stack = flattenExtend(extend, [], context);
   return getExtendStackRegistry(extend, stack);
 };

package/dist/esm/utils/object.js

@@ -63,7 +63,8 @@ const METHODS_EXL = joinArrays(
 );
 const deepMerge = (element, extend, exclude = METHODS_EXL) => {
   for (const e in extend) {
-    if (exclude.includes(e)) continue;
+    if (exclude.includes(e))
+      continue;
     const elementProp = element[e];
     const extendProp = extend[e];
     if (elementProp === void 0) {
@@ -77,7 +78,8 @@ const deepMerge = (element, extend, exclude = METHODS_EXL) => {
 const clone = (obj, exclude = METHODS_EXL) => {
   const o = {};
   for (const e in obj) {
-    if (exclude.includes(e)) continue;
+    if (exclude.includes(e))
+      continue;
     o[e] = obj[e];
   }
   return o;
@@ -87,27 +89,31 @@ const overwrite = (element, params, options) => {
   const { __ref } = element;
   const { __exec, __cached } = __ref;
   for (const e in params) {
-    if (e === "props" || e === "state" || e === "__ref") continue;
+    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];
+    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;
+    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;
+    if (exclude.includes(e))
+      continue;
     const objProp = obj[e];
     const paramsProp = params[e];
     if (isObjectLike(objProp) && isObjectLike(paramsProp)) {
@@ -119,7 +125,8 @@ const overwriteDeep = (obj, params, exclude = METHODS_EXL) => {
   return obj;
 };
 const mergeIfExisted = (a, b) => {
-  if (isObjectLike(a) && isObjectLike(b)) return deepMerge(a, b);
+  if (isObjectLike(a) && isObjectLike(b))
+    return deepMerge(a, b);
   return a || b;
 };
 const mergeArray = (arr, exclude = ["parent", "node", "__element", "state", "context", "__ref"]) => {
@@ -132,7 +139,8 @@ const flattenRecursive = (param, prop, stack = []) => {
   const objectized = mergeAndCloneIfArray(param);
   stack.push(objectized);
   const extendOfExtend = objectized[prop];
-  if (extendOfExtend) flattenRecursive(extendOfExtend, prop, stack);
+  if (extendOfExtend)
+    flattenRecursive(extendOfExtend, prop, stack);
   delete objectized[prop];
   return stack;
 };

package/dist/esm/utils/onlyResolveExtends.js

@@ -13,15 +13,24 @@ const onlyResolveExtends = (element, parent, key, options) => {
   element.tag = 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 = {};
-    if (!ref2.__class) ref2.__class = {};
-    if (!ref2.__classNames) ref2.__classNames = {};
-    if (!ref2.__attr) ref2.__attr = {};
-    if (!ref2.__changes) ref2.__changes = [];
-    if (!ref2.__children) ref2.__children = [];
+    if (!ref2.__cached)
+      ref2.__cached = {};
+    if (!ref2.__defineCache)
+      ref2.__defineCache = {};
+    if (!ref2.__exec)
+      ref2.__exec = {};
+    if (!ref2.__execProps)
+      ref2.__execProps = {};
+    if (!ref2.__class)
+      ref2.__class = {};
+    if (!ref2.__classNames)
+      ref2.__classNames = {};
+    if (!ref2.__attr)
+      ref2.__attr = {};
+    if (!ref2.__changes)
+      ref2.__changes = [];
+    if (!ref2.__children)
+      ref2.__children = [];
   }
   addMethods(element, parent, options);
   createState(element, parent);
@@ -30,8 +39,10 @@ const onlyResolveExtends = (element, parent, key, options) => {
     const ifPassed = element.if(element, element.state, element.context);
     if (!ifPassed) {
       delete ref.__if;
-    } else ref.__if = true;
-  } else ref.__if = true;
+    } else
+      ref.__if = true;
+  } else
+    ref.__if = true;
   if (element.node && ref.__if) {
     parent[key || element.key] = element;
   }
@@ -42,7 +53,8 @@ const onlyResolveExtends = (element, parent, key, options) => {
     throughInitialExec(element);
     for (const param in element) {
       const prop = element[param];
-      if (isUndefined(prop) || isMethod(param, element) || isObject(REGISTRY[param]) || isVariant(param)) continue;
+      if (isUndefined(prop) || isMethod(param, element) || isObject(REGISTRY[param]) || isVariant(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];
@@ -60,7 +72,8 @@ const onlyResolveExtends = (element, parent, key, options) => {
     delete element.props.update;
     delete element.props.__element;
   }
-  if (!options.keepRef) delete element.__ref;
+  if (!options.keepRef)
+    delete element.__ref;
   return element;
 };
 export {

package/dist/esm/utils/propEvents.js

@@ -9,9 +9,11 @@ const propagateEventsFromProps = (element) => {
     if (isFunction(origEvent)) {
       on[eventName] = (...args) => {
         const originalEventRetunrs = origEvent(...args);
-        if (originalEventRetunrs !== false) funcFromProps(...args);
+        if (originalEventRetunrs !== false)
+          funcFromProps(...args);
       };
-    } else on[eventName] = funcFromProps;
+    } else
+      on[eventName] = funcFromProps;
   });
 };
 export {

package/methods/index.js

@@ -205,19 +205,19 @@ export function verbose (...args) {
 }
 
 export function log (...params) {
-  if (ENV === 'test' || ENV === 'development') {
+  if (ENV === 'testing' || ENV === 'development') {
     console.log(...params)
   }
 }
 
 export function warn (...params) {
-  if (ENV === 'test' || ENV === 'development') {
+  if (ENV === 'testing' || ENV === 'development') {
     console.warn(...params)
   }
 }
 
 export function error (...params) {
-  if (ENV === 'test' || ENV === 'development') {
+  if (ENV === 'testing' || ENV === 'development') {
     if (params[params.length - 1]?.debugger) debugger // eslint-disable-line
     if (params[params.length - 1]?.verbose) verbose.call(this)
     throw new Error(...params)

package/mixins/content.js

@@ -41,13 +41,13 @@ export const removeContent = function (el, opts = {}) {
  * Appends anything as content
  * an original one as a child
  */
-export function setContent (param, element, node, opts) {
+export async function setContent (param, element, node, opts) {
   const contentElementKey = setContentKey(element, opts)
   if (param && element) {
     if (element[contentElementKey].update) {
       element[contentElementKey].update({}, opts)
     } else {
-      set.call(element, param, opts)
+      await set.call(element, param, opts)
     }
   }
 }

package/node.js

@@ -38,7 +38,7 @@ export const createNode = async (element, options) => {
   }
   // node.dataset // .key = element.key
 
-  if (ENV === 'test' || ENV === 'development' || options.alowRefReference) {
+  if (ENV === 'testing' || ENV === 'development' || options.alowRefReference) {
     node.ref = element
     if (isFunction(node.setAttribute)) node.setAttribute('key', element.key)
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/element",
-  "version": "2.5.200",
+  "version": "2.5.205",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
@@ -23,16 +23,16 @@
     "copy:package:cjs": "cp ../../build/package-cjs.json dist/cjs/package.json",
     "build:esm": "npx esbuild *.js **/*.js --target=es2019 --format=esm --outdir=dist/esm",
     "build:cjs": "npx esbuild *.js **/*.js --target=node16 --format=cjs --outdir=dist/cjs",
-    "build": "rimraf -I dist; npm run build:cjs; npm run build:esm",
-    "prepublish": "rimraf -I dist && npm run build && npm run copy:package:cjs"
+    "build": "npx rimraf -I dist; npm run build:cjs; npm run build:esm",
+    "prepublish": "npx rimraf -I dist && npm run build && npm run copy:package:cjs"
   },
   "dependencies": {
-    "@domql/event": "^2.5.200",
-    "@domql/render": "^2.5.200",
-    "@domql/state": "^2.5.200",
-    "@domql/utils": "^2.5.200"
+    "@domql/event": "^2.5.203",
+    "@domql/render": "^2.5.203",
+    "@domql/state": "^2.5.203",
+    "@domql/utils": "^2.5.203"
   },
-  "gitHead": "0afb63ec375f0526f47ff300885de393138b01e8",
+  "gitHead": "0e199902ea51b67aa7c0ca0446aae8e492d49789",
   "devDependencies": {
     "@babel/core": "^7.12.0"
   }

package/set.js

@@ -19,9 +19,9 @@ export const resetElement = async (params, element, options) => {
   })
 }
 
-export const reset = (options) => {
+export const reset = async (options) => {
   const element = this
-  create(element, element.parent, undefined, {
+  await create(element, element.parent, undefined, {
     ignoreChildExtend: true,
     ...registry.defaultOptions,
     ...OPTIONS.create,
@@ -45,7 +45,7 @@ export const set = async function (params, options = {}, el) {
       const beforeUpdateReturns = await triggerEventOnUpdate('beforeUpdate', params, element, options)
       if (beforeUpdateReturns === false) return element
     }
-    if (content?.update) content.update()
+    if (content?.update) await content.update()
     if (!options.preventUpdateListener) await triggerEventOn('update', element, options)
     return
   }

package/update.js

@@ -133,7 +133,7 @@ export const update = async function (params = {}, opts) {
 
     if (preventStateUpdate === 'once') options.preventStateUpdate = false
 
-    const isElement = applyParam(param, element, options)
+    const isElement = await applyParam(param, element, options)
     if (isElement) {
       const { hasDefine, hasContextDefine } = isElement
       const canUpdate = isObject(prop) && !hasDefine && !hasContextDefine && !preventRecursive
@@ -145,23 +145,23 @@ export const update = async function (params = {}, opts) {
         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 ? window.requestAnimationFrame(() => { // eslint-disable-line
-        childUpdateCall()
+      lazyLoad ? window.requestAnimationFrame(async () => { // eslint-disable-line
+        await childUpdateCall()
         // handle lazy load
         if (!options.preventUpdateListener) {
           triggerEventOn('lazyLoad', element, options)
         }
-      }) : childUpdateCall()
+      }) : await childUpdateCall()
     }
   }
 
-  if (!preventUpdateListener) triggerEventOn('update', element, options)
+  if (!preventUpdateListener) await triggerEventOn('update', element, options)
 }
 
 const captureSnapshot = (element, options) => {

package/utils/applyParam.js

@@ -3,7 +3,7 @@
 import { isFunction } from '@domql/utils'
 import { REGISTRY } from '../mixins/index.js'
 
-export const applyParam = (param, element, options) => {
+export const applyParam = async (param, element, options) => {
   const { node, context, __ref: ref } = element
   const prop = element[param]
 
@@ -22,7 +22,7 @@ export const applyParam = (param, element, options) => {
 
   if (isGlobalTransformer && !hasContextDefine && hasOnlyUpdate) {
     if (isFunction(isGlobalTransformer)) {
-      isGlobalTransformer(prop, element, node, options)
+      await isGlobalTransformer(prop, element, node, options)
       return
     }
   }

package/utils/extendUtils.js

@@ -88,7 +88,7 @@ export const fallbackStringExtend = (extend, context, options = {}, variant) =>
     if (componentExists) return componentExists
     else if (pageExists) return pageExists
     else {
-      if (options.verbose && (ENV === 'test' || ENV === 'development')) {
+      if (options.verbose && (ENV === 'testing' || ENV === 'development')) {
         console.warn('Extend is string but component was not found:', extend)
       }
       return {}