@domql/element 2.5.200 → 2.5.203

package/create.js

@@ -128,13 +128,13 @@ export const create = async (element, parent, key, options = OPTIONS.create || {
 const createBasedOnType = (element, parent, key, options) => {
   // if ELEMENT is not given
   if (element === undefined) {
-    if (ENV === 'test' || ENV === 'development') {
+    if (ENV === 'testing' || ENV === 'development') {
       console.warn(key, 'element is undefined in', parent && parent.__ref && parent.__ref.path)
     }
     return {}
   }
   if (isString(key) && key.slice(0, 2 === '__')) {
-    if (ENV === 'test' || ENV === 'development') {
+    if (ENV === 'testing' || ENV === 'development') {
       console.warn(key, 'seems like to be in __ref')
     }
   }
@@ -215,7 +215,7 @@ const addElementIntoParentChildren = (element, parent) => {
 const visitedElements = new WeakMap()
 const renderElement = async (element, parent, options, attachOptions) => {
   if (visitedElements.has(element)) {
-    if (ENV === 'test' || ENV === 'development') console.warn('Cyclic rendering detected:', element.__ref.path)
+    if (ENV === 'testing' || ENV === 'development') console.warn('Cyclic rendering detected:', element.__ref.path)
   }
 
   visitedElements.set(element, true)
@@ -230,7 +230,7 @@ const renderElement = async (element, parent, options, attachOptions) => {
   }
 
   // CREATE a real NODE
-  if (ENV === 'test' || ENV === 'development') {
+  if (ENV === 'testing' || ENV === 'development') {
     await createNestedChild()
   } else {
     try {
@@ -344,7 +344,7 @@ const addCaching = (element, parent) => {
   if (!ref.root) ref.root = hasRoot ? element : parentRef.root
 
   // set the PATH array
-  // if (ENV === 'test' || ENV === 'development') {
+  // if (ENV === 'testing' || ENV === 'development') {
   if (!parentRef) parentRef = parent.ref = {}
   if (!parentRef.path) parentRef.path = []
   ref.path = parentRef.path.concat(element.key)

package/dist/cjs/create.js

@@ -63,17 +63,20 @@ const create = async (element, parent, key, options = import_options.OPTIONS.cre
   (0, import_set.addMethods)(element, parent, options);
   createScope(element, parent);
   await (0, import_state.createState)(element, parent);
-  if (element.scope === "state") element.scope = element.state;
+  if (element.scope === "state")
+    element.scope = element.state;
   createIfConditionFlag(element, parent);
   (0, import_props.createProps)(element, parent, options);
-  if (element.scope === "props" || element.scope === true) element.scope = element.props;
+  if (element.scope === "props" || element.scope === true)
+    element.scope = element.props;
   createIfConditionFlag(element, parent);
   if (element.node && ref.__if) {
     return (0, import_render.assignNode)(element, parent, key, attachOptions);
   }
   (0, import_component.applyVariant)(element, parent);
   const onInit = await (0, import_event.triggerEventOn)("init", element, options);
-  if (onInit === false) return element;
+  if (onInit === false)
+    return element;
   (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
   (0, import_classList.assignKeyAsClassname)(element);
   (0, import_utils.addChildrenIfNotInOriginal)(element, parent, key);
@@ -84,18 +87,20 @@ const create = async (element, parent, key, options = import_options.OPTIONS.cre
 };
 const createBasedOnType = (element, parent, key, options) => {
   if (element === void 0) {
-    if (ENV === "test" || ENV === "development") {
+    if (ENV === "testing" || ENV === "development") {
       console.warn(key, "element is undefined in", parent && parent.__ref && parent.__ref.path);
     }
     return {};
   }
-  if ((0, import_utils.isString)(key) && key.slice(0, false)) {
-    if (ENV === "test" || ENV === "development") {
+  if ((0, import_utils.isString)(key) && key.slice(0, 2 === "__")) {
+    if (ENV === "testing" || ENV === "development") {
       console.warn(key, "seems like to be in __ref");
     }
   }
-  if (element === null) return;
-  if (element === true) return { text: true };
+  if (element === null)
+    return;
+  if (element === true)
+    return { text: true };
   if (element.__hash) {
     return { extend: element };
   }
@@ -104,8 +109,10 @@ const createBasedOnType = (element, parent, key, options) => {
 const redefineElement = (element, parent, key, options) => {
   const elementWrapper = createBasedOnType(element, parent, key, options);
   if (options.syntaxv3 || element.props && element.props.syntaxv3 || parent && parent.props && parent.props.syntaxv3) {
-    if (element.props) element.props.syntaxv3 = true;
-    else element.syntaxv3 = true;
+    if (element.props)
+      element.props.syntaxv3 = true;
+    else
+      element.syntaxv3 = true;
     return (0, import_component.createValidDomqlObjectFromSugar)(element, parent, key, options);
   } else if ((0, import_utils.checkIfKeyIsComponent)(key)) {
     return (0, import_utils.applyKeyComponentAsExtend)(elementWrapper, parent, key);
@@ -116,7 +123,8 @@ const redefineElement = (element, parent, key, options) => {
   return elementWrapper;
 };
 const redefineParent = (element, parent, key, options) => {
-  if (!parent) return import_tree.ROOT;
+  if (!parent)
+    return import_tree.ROOT;
   if ((0, import_utils.isNode)(parent)) {
     const parentNodeWrapper = { key: ":root", node: parent };
     import_tree.ROOT[`${key}_parent`] = parentNodeWrapper;
@@ -134,48 +142,58 @@ const createKey = (element, parent, key) => {
   return ((0, import_utils.exec)(key, element) || key || element.key || (0, import_utils.generateKey)()).toString();
 };
 const addRef = (element, parent) => {
-  if (element.__ref) element.__ref.origin = element;
-  else element.__ref = { origin: element };
+  if (element.__ref)
+    element.__ref.origin = element;
+  else
+    element.__ref = { origin: element };
   return element.__ref;
 };
 const switchDefaultOptions = (element, parent, options) => {
   if (Object.keys(options).length) {
     import_mixins.registry.defaultOptions = options;
-    if (options.ignoreChildExtend) delete options.ignoreChildExtend;
+    if (options.ignoreChildExtend)
+      delete options.ignoreChildExtend;
   }
 };
 const addElementIntoParentChildren = (element, parent) => {
-  if (parent.__ref && parent.__ref.__children) parent.__ref.__children.push(element.key);
+  if (parent.__ref && parent.__ref.__children)
+    parent.__ref.__children.push(element.key);
 };
 const visitedElements = /* @__PURE__ */ new WeakMap();
 const renderElement = async (element, parent, options, attachOptions) => {
   var _a, _b, _c, _d;
   if (visitedElements.has(element)) {
-    if (ENV === "test" || ENV === "development") console.warn("Cyclic rendering detected:", element.__ref.path);
+    if (ENV === "testing" || ENV === "development")
+      console.warn("Cyclic rendering detected:", element.__ref.path);
   }
   visitedElements.set(element, true);
   const { __ref: ref, key } = element;
   const createNestedChild = async () => {
     const isInfiniteLoopDetected = (0, import_utils.detectInfiniteLoop)(ref.path);
-    if (ref.__uniqId || isInfiniteLoopDetected) return;
+    if (ref.__uniqId || isInfiniteLoopDetected)
+      return;
     await (0, import_node.createNode)(element, options);
     ref.__uniqId = Math.random();
   };
-  if (ENV === "test" || ENV === "development") {
+  if (ENV === "testing" || ENV === "development") {
     await createNestedChild();
   } else {
     try {
       await createNestedChild();
     } catch (e) {
       const path = ref.path;
-      if (path.includes("ComponentsGrid")) path.splice(0, path.indexOf("ComponentsGrid") + 2);
-      if (path.includes("demoComponent")) path.splice(0, path.indexOf("demoComponent") + 1);
+      if (path.includes("ComponentsGrid"))
+        path.splice(0, path.indexOf("ComponentsGrid") + 2);
+      if (path.includes("demoComponent"))
+        path.splice(0, path.indexOf("demoComponent") + 1);
       const isDemoComponent = (_b = (_a = element.lookup((el) => el.state.key)) == null ? void 0 : _a.state) == null ? void 0 : _b.key;
       element.warn("Error happened in:", isDemoComponent ? isDemoComponent + " " : "" + path.join("."));
       element.verbose();
       element.error(e, options);
-      if ((_c = element.on) == null ? void 0 : _c.error) element.on.error(e, element, element.state, element.context, options);
-      if ((_d = element.props) == null ? void 0 : _d.onError) element.props.onError(e, element, element.state, element.context, options);
+      if ((_c = element.on) == null ? void 0 : _c.error)
+        element.on.error(e, element, element.state, element.context, options);
+      if ((_d = element.props) == null ? void 0 : _d.onError)
+        element.props.onError(e, element, element.state, element.context, options);
     }
   }
   if (!ref.__if) {
@@ -202,37 +220,55 @@ const applyValueAsText = (element, parent, key) => {
 };
 const applyContext = (element, parent, options) => {
   const forcedOptionsContext = options.context && !import_tree.ROOT.context && !element.context;
-  if (forcedOptionsContext) import_tree.ROOT.context = options.context;
-  if (!element.context) element.context = parent.context || options.context || import_tree.ROOT.context;
+  if (forcedOptionsContext)
+    import_tree.ROOT.context = options.context;
+  if (!element.context)
+    element.context = parent.context || options.context || import_tree.ROOT.context;
 };
 const createScope = (element, parent) => {
   const { __ref: ref } = element;
-  if (!element.scope) element.scope = parent.scope || ref.root.scope || {};
+  if (!element.scope)
+    element.scope = parent.scope || ref.root.scope || {};
 };
 const createIfConditionFlag = (element, parent) => {
   const { __ref: ref } = element;
   if ((0, import_utils.isFunction)(element.if) && !element.if(element, element.state, element.context)) {
     delete ref.__if;
-  } else ref.__if = true;
+  } else
+    ref.__if = true;
 };
 const addCaching = (element, parent) => {
   const { __ref: ref, key } = element;
   let { __ref: parentRef } = parent;
-  if (!element.transform) element.transform = {};
-  if (!ref.__cached) ref.__cached = {};
-  if (!ref.__defineCache) ref.__defineCache = {};
-  if (!ref.__exec) ref.__exec = {};
-  if (!ref.__execProps) ref.__execProps = {};
-  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 ((0, import_utils.checkIfKeyIsComponent)(key)) ref.__componentKey = key.split("_")[0].split(".")[0].split("+")[0];
+  if (!element.transform)
+    element.transform = {};
+  if (!ref.__cached)
+    ref.__cached = {};
+  if (!ref.__defineCache)
+    ref.__defineCache = {};
+  if (!ref.__exec)
+    ref.__exec = {};
+  if (!ref.__execProps)
+    ref.__execProps = {};
+  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 ((0, import_utils.checkIfKeyIsComponent)(key))
+    ref.__componentKey = key.split("_")[0].split(".")[0].split("+")[0];
   const hasRoot = parent && parent.key === ":root";
-  if (!ref.root) ref.root = hasRoot ? element : parentRef.root;
-  if (!parentRef) parentRef = parent.ref = {};
-  if (!parentRef.path) parentRef.path = [];
+  if (!ref.root)
+    ref.root = hasRoot ? element : parentRef.root;
+  if (!parentRef)
+    parentRef = parent.ref = {};
+  if (!parentRef.path)
+    parentRef.path = [];
   ref.path = parentRef.path.concat(element.key);
 };
 const onlyResolveExtends = (element, parent, key, options) => {
@@ -242,14 +278,17 @@ const onlyResolveExtends = (element, parent, key, options) => {
     (0, import_set.addMethods)(element, parent, options);
     createScope(element, parent);
     (0, import_state.createState)(element, parent);
-    if (element.scope === "state") element.scope = element.state;
+    if (element.scope === "state")
+      element.scope = element.state;
     createIfConditionFlag(element, parent);
     (0, import_props.createProps)(element, parent, options);
-    if (element.scope === "props" || element.scope === true) element.scope = element.props;
+    if (element.scope === "props" || element.scope === true)
+      element.scope = element.props;
     if (element.node && ref.__if) {
       parent[key || element.key] = element;
     }
-    if (!element.props) element.props = {};
+    if (!element.props)
+      element.props = {};
     (0, import_component.applyVariant)(element, parent);
     addElementIntoParentChildren(element, parent);
   }
@@ -257,7 +296,8 @@ const onlyResolveExtends = (element, parent, key, options) => {
     (0, import_iterate.throughInitialDefine)(element);
     (0, import_iterate.throughInitialExec)(element);
     for (const k in element) {
-      if ((0, import_utils.isUndefined)(element[k]) || (0, import_methods.isMethod)(k, element) || (0, import_utils.isObject)((import_mixins.registry.default || import_mixins.registry)[k]) || (0, import_utils.isVariant)(k)) continue;
+      if ((0, import_utils.isUndefined)(element[k]) || (0, import_methods.isMethod)(k, element) || (0, import_utils.isObject)((import_mixins.registry.default || import_mixins.registry)[k]) || (0, import_utils.isVariant)(k))
+        continue;
       const hasDefine = element.define && element.define[k];
       const contextHasDefine = element.context && element.context.define && element.context.define[k];
       const optionsHasDefine = options.define && options.define[k];
@@ -282,8 +322,10 @@ const applyMediaProps = (element, parent, key) => {
   const { props } = element;
   if (props) {
     props.display = "none";
-    if (props[key]) props[key].display = props.display;
-    else props[key] = { display: props.display || "block" };
+    if (props[key])
+      props[key].display = props.display;
+    else
+      props[key] = { display: props.display || "block" };
     return element;
   } else {
     return {

package/dist/cjs/define.js

@@ -28,6 +28,7 @@ var define_default = (params, options = {}) => {
   for (const param in params) {
     if (import_mixins.REGISTRY[param] && !overwrite) {
       (0, import_report.report)("OverwriteToBuiltin", param);
-    } else import_mixins.REGISTRY[param] = params[param];
+    } else
+      import_mixins.REGISTRY[param] = params[param];
   }
 };

package/dist/cjs/extend.js

@@ -26,14 +26,16 @@ var import_utils2 = require("./utils/index.js");
 const ENV = "development";
 let mainExtend;
 const applyExtend = (element, parent, options = {}) => {
-  if ((0, import_utils.isFunction)(element)) element = (0, import_utils.exec)(element, parent);
+  if ((0, import_utils.isFunction)(element))
+    element = (0, import_utils.exec)(element, parent);
   const { props, __ref } = element;
   let extend = (props == null ? void 0 : props.extends) || element.extends || element.extend;
   const variant = props == null ? void 0 : props.variant;
   const context = element.context || parent.context;
   extend = (0, import_utils2.fallbackStringExtend)(extend, context, options, variant);
   const extendStack = (0, import_utils2.getExtendStack)(extend, context);
-  if (ENV !== "test" || ENV !== "development") delete element.extend;
+  if (ENV !== "test" || ENV !== "development")
+    delete element.extend;
   let childExtendStack = [];
   if (parent) {
     element.parent = parent;
@@ -59,7 +61,8 @@ const applyExtend = (element, parent, options = {}) => {
     stack = extendStack;
   } else if (childExtendLength) {
     stack = childExtendStack;
-  } else if (!context.defaultExtends) return element;
+  } else if (!context.defaultExtends)
+    return element;
   if (context.defaultExtends) {
     if (!mainExtend) {
       const defaultOptionsExtend = (0, import_utils2.getExtendStack)(context.defaultExtends, context);
@@ -68,7 +71,8 @@ const applyExtend = (element, parent, options = {}) => {
     }
     stack = [].concat(stack, mainExtend);
   }
-  if (__ref) __ref.__extend = stack;
+  if (__ref)
+    __ref.__extend = stack;
   let mergedExtend = (0, import_utils2.cloneAndMergeArrayExtend)(stack);
   const COMPONENTS = context && context.components || options.components;
   const component = (0, import_utils.exec)(element.component || mergedExtend.component, element);

package/dist/cjs/index.js

@@ -26,8 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var index_exports = {};
-__export(index_exports, {
+var element_exports = {};
+__export(element_exports, {
   TREE: () => import_tree.TREE,
   create: () => import_create.default,
   createNode: () => import_node.default,
@@ -35,7 +35,7 @@ __export(index_exports, {
   set: () => import_set.default,
   update: () => import_update.default
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(element_exports);
 var import_tree = require("./tree");
 var import_create = __toESM(require("./create"), 1);
 var import_node = __toESM(require("./node"), 1);

package/dist/cjs/iterate.js

@@ -31,7 +31,8 @@ var import_methods = require("./methods/index.js");
 const throughInitialExec = (element, exclude = {}) => {
   const { __ref: ref } = element;
   for (const param in element) {
-    if (exclude[param]) continue;
+    if (exclude[param])
+      continue;
     const prop = element[param];
     if ((0, import_utils.isFunction)(prop) && !(0, import_methods.isMethod)(param, element) && !(0, import_utils.isVariant)(param)) {
       ref.__exec[param] = prop;
@@ -45,7 +46,8 @@ const throughUpdatedExec = (element, options = { excludes: import_utils2.METHODS
   for (const param in ref.__exec) {
     const prop = element[param];
     const isDefinedParam = ref.__defineCache[param];
-    if (isDefinedParam) continue;
+    if (isDefinedParam)
+      continue;
     const newExec = ref.__exec[param](element, element.state, element.context);
     const execReturnsString = (0, import_utils.isString)(newExec) || (0, import_utils.isNumber)(newExec);
     if (prop && prop.node && execReturnsString) {
@@ -80,8 +82,10 @@ const throughInitialDefine = (element) => {
   const { define, context, __ref: ref } = element;
   let defineObj = {};
   const hasGlobalDefine = context && (0, import_utils.isObject)(context.define);
-  if ((0, import_utils.isObject)(define)) defineObj = { ...define };
-  if (hasGlobalDefine) defineObj = { ...defineObj, ...context.define };
+  if ((0, import_utils.isObject)(define))
+    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, element) && !(0, import_utils.isVariant)(param)) {
@@ -93,7 +97,8 @@ const throughInitialDefine = (element) => {
       }
     }
     const execParam = defineObj[param](elementProp, element, element.state, element.context);
-    if (execParam) element[param] = execParam;
+    if (execParam)
+      element[param] = execParam;
   }
   return element;
 };
@@ -101,14 +106,18 @@ const throughUpdatedDefine = (element) => {
   const { context, define, __ref: ref } = element;
   const changes = {};
   let obj = {};
-  if ((0, import_utils.isObject)(define)) obj = { ...define };
-  if ((0, import_utils.isObject)(context && context.define)) obj = { ...obj, ...context.define };
+  if ((0, import_utils.isObject)(define))
+    obj = { ...define };
+  if ((0, import_utils.isObject)(context && context.define))
+    obj = { ...obj, ...context.define };
   for (const param in obj) {
     const execParam = ref.__exec[param];
-    if (execParam) ref.__defineCache[param] = execParam(element, element.state, element.context);
+    if (execParam)
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = (0, import_utils.exec)(ref.__defineCache[param], element);
     const newExecParam = obj[param](cached, element, element.state, element.context);
-    if (newExecParam) element[param] = newExecParam;
+    if (newExecParam)
+      element[param] = newExecParam;
   }
   return changes;
 };