@domql/element 2.5.198 → 3.0.0

package/utils/onlyResolveExtends.js

@@ -1,14 +1,18 @@
 'use strict'
 
-import { exec, isFunction, isObject, isUndefined } from '@domql/utils'
+import {
+  exec,
+  initProps,
+  isFunction,
+  isMethod,
+  isObject,
+  isUndefined
+} from '@domql/utils'
 import { create } from '..'
 import { REGISTRY } from '../mixins/index.js'
-import { applyVariant, isVariant } from '.'
-import { isMethod } from '../methods'
 import { addMethods } from '../methods/set'
 import { createState } from '@domql/state'
 import { detectTag } from '@domql/render'
-import { createProps } from '../props'
 import { throughInitialDefine, throughInitialExec } from '../iterate'
 
 export const onlyResolveExtends = (element, parent, key, options) => {
@@ -24,10 +28,8 @@ export const onlyResolveExtends = (element, parent, key, options) => {
 
     // enable TRANSFORM in data
     // TODO: do we need this at all?
-    // if (!element.transform) element.transform = {}
 
     // enable CACHING
-    if (!ref.__cached) ref.__cached = {}
     if (!ref.__defineCache) ref.__defineCache = {}
 
     // enable EXEC
@@ -68,10 +70,11 @@ export const onlyResolveExtends = (element, parent, key, options) => {
   } else ref.__if = true
   /// ///
 
-  if (element.node && ref.__if) { parent[key || element.key] = element } // Borrowed from assignNode()
+  if (element.node && ref.__if) {
+    parent[key || element.key] = element
+  } // Borrowed from assignNode()
 
-  createProps(element, parent, options)
-  applyVariant(element, parent)
+  initProps(element, parent, options)
 
   if (element.tag !== 'string' && element.tag !== 'fragment') {
     throughInitialDefine(element)
@@ -82,18 +85,26 @@ export const onlyResolveExtends = (element, parent, key, options) => {
       if (
         isUndefined(prop) ||
         isMethod(param, element) ||
-        isObject(REGISTRY[param]) ||
-        isVariant(param)
-      ) continue
+        isObject(REGISTRY[param])
+      ) {
+        continue
+      }
 
       const hasDefine = element.define && element.define[param]
-      const contextHasDefine = element.context && element.context.define &&
-            element.context.define[param]
+      const contextHasDefine =
+        element.context &&
+        element.context.define &&
+        element.context.define[param]
       const optionsHasDefine = options.define && options.define[param]
 
       if (REGISTRY[param] && !optionsHasDefine) {
         continue
-      } else if (element[param] && !hasDefine && !optionsHasDefine && !contextHasDefine) {
+      } else if (
+        element[param] &&
+        !hasDefine &&
+        !optionsHasDefine &&
+        !contextHasDefine
+      ) {
         create(exec(prop, element), element, param, options)
       }
     }
@@ -104,7 +115,7 @@ export const onlyResolveExtends = (element, parent, key, options) => {
   delete element.update
   delete element.__element
 
-  // added by createProps
+  // added by initProps
   if (element.props) {
     delete element.props.update
     delete element.props.__element

package/cache/index.js

@@ -1,3 +0,0 @@
-'use strict'
-
-export const cache = {}

package/cache/options.js

@@ -1,4 +0,0 @@
-'use strict'
-
-export const OPTIONS = {}
-export default OPTIONS

package/dist/cjs/cache/index.js

@@ -1,24 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var cache_exports = {};
-__export(cache_exports, {
-  cache: () => cache
-});
-module.exports = __toCommonJS(cache_exports);
-const cache = {};

package/dist/cjs/cache/options.js

@@ -1,26 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var options_exports = {};
-__export(options_exports, {
-  OPTIONS: () => OPTIONS,
-  default: () => options_default
-});
-module.exports = __toCommonJS(options_exports);
-const OPTIONS = {};
-var options_default = OPTIONS;

package/dist/cjs/extend.js

@@ -1,85 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var extend_exports = {};
-__export(extend_exports, {
-  applyExtend: () => applyExtend
-});
-module.exports = __toCommonJS(extend_exports);
-var import_utils = require("@domql/utils");
-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);
-  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;
-  let childExtendStack = [];
-  if (parent) {
-    element.parent = parent;
-    if (!options.ignoreChildExtend && !(props && props.ignoreChildExtend)) {
-      childExtendStack = (0, import_utils2.getExtendStack)(parent.childExtend, context);
-      const ignoreChildExtendRecursive = props && props.ignoreChildExtendRecursive;
-      if (parent.childExtendRecursive && !ignoreChildExtendRecursive) {
-        const canExtendRecursive = element.key !== "__text";
-        if (canExtendRecursive) {
-          const childExtendRecursiveStack = (0, import_utils2.getExtendStack)(parent.childExtendRecursive, context);
-          childExtendStack = childExtendStack.concat(childExtendRecursiveStack);
-          element.childExtendRecursive = parent.childExtendRecursive;
-        }
-      }
-    }
-  }
-  const extendLength = extendStack.length;
-  const childExtendLength = childExtendStack.length;
-  let stack = [];
-  if (extendLength && childExtendLength) {
-    stack = (0, import_utils2.jointStacks)(extendStack, childExtendStack);
-  } else if (extendLength) {
-    stack = extendStack;
-  } else if (childExtendLength) {
-    stack = childExtendStack;
-  } else if (!context.defaultExtends)
-    return element;
-  if (context.defaultExtends) {
-    if (!mainExtend) {
-      const defaultOptionsExtend = (0, import_utils2.getExtendStack)(context.defaultExtends, context);
-      mainExtend = (0, import_utils2.cloneAndMergeArrayExtend)(defaultOptionsExtend);
-      delete mainExtend.extend;
-    }
-    stack = [].concat(stack, mainExtend);
-  }
-  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);
-  if (component && COMPONENTS && COMPONENTS[component]) {
-    const componentExtend = (0, import_utils2.cloneAndMergeArrayExtend)((0, import_utils2.getExtendStack)(COMPONENTS[component]));
-    mergedExtend = (0, import_utils2.deepMergeExtend)(componentExtend, mergedExtend);
-  }
-  const merged = (0, import_utils2.deepMergeExtend)(element, mergedExtend);
-  return merged;
-};

package/dist/cjs/methods/index.js

@@ -1,353 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var methods_exports = {};
-__export(methods_exports, {
-  METHODS: () => METHODS,
-  call: () => call,
-  defineSetter: () => defineSetter,
-  error: () => error,
-  get: () => get,
-  getPath: () => getPath,
-  getRef: () => getRef,
-  isMethod: () => isMethod,
-  keys: () => keys,
-  log: () => log,
-  lookdown: () => lookdown,
-  lookdownAll: () => lookdownAll,
-  lookup: () => lookup,
-  nextElement: () => nextElement,
-  parse: () => parse,
-  parseDeep: () => parseDeep,
-  previousElement: () => previousElement,
-  remove: () => remove,
-  setNodeStyles: () => setNodeStyles,
-  setProps: () => setProps,
-  spotByPath: () => spotByPath,
-  variables: () => variables,
-  verbose: () => verbose,
-  warn: () => warn
-});
-module.exports = __toCommonJS(methods_exports);
-var import_event = require("@domql/event");
-var import_utils = require("@domql/utils");
-var import_tree = require("../tree.js");
-var import_mixins = require("../mixins/index.js");
-const ENV = "development";
-function spotByPath(path) {
-  const element = this;
-  const arr = [].concat(path);
-  let active = import_tree.TREE[arr[0]];
-  if (!arr || !arr.length)
-    return console.log(arr, "on", element.key, "is undefined");
-  while (active.key === arr[0]) {
-    arr.shift();
-    if (!arr.length)
-      break;
-    active = active[arr[0]];
-    if (!active)
-      return;
-  }
-  return active;
-}
-function lookup(param) {
-  const el = this;
-  let { parent } = el;
-  if ((0, import_utils.isFunction)(param)) {
-    if (parent.state && param(parent, parent.state, parent.context))
-      return parent;
-    else if (parent.parent)
-      return parent.lookup(param);
-    else
-      return;
-  }
-  if (el[param])
-    return el[param];
-  while (parent.param !== param) {
-    if (parent[param])
-      return parent[param];
-    parent = parent.parent;
-    if (!parent)
-      return;
-  }
-  return parent;
-}
-function lookdown(param) {
-  var _a;
-  const el = this;
-  const { __ref: ref } = el;
-  const children = ref.__children;
-  for (let i = 0; i < children.length; i++) {
-    const v = children[i];
-    const childElem = el[v];
-    if (v === param)
-      return childElem;
-    else if ((0, import_utils.isFunction)(param)) {
-      const exec = param(childElem, childElem.state, childElem.context);
-      if (childElem.state && exec) {
-        return childElem;
-      }
-    }
-    const lookdown2 = (_a = childElem == null ? void 0 : childElem.lookdown) == null ? void 0 : _a.call(childElem, param);
-    if (lookdown2)
-      return lookdown2;
-  }
-}
-function lookdownAll(param, results = []) {
-  var _a;
-  const el = this;
-  const { __ref: ref } = el;
-  const children = ref.__children;
-  for (let i = 0; i < children.length; i++) {
-    const v = children[i];
-    const childElem = el[v];
-    if (v === param)
-      results.push(childElem);
-    else if ((0, import_utils.isFunction)(param)) {
-      const exec = param(childElem, childElem.state, childElem.context);
-      if (childElem.state && exec)
-        results.push(childElem);
-    }
-    (_a = childElem == null ? void 0 : childElem.lookdownAll) == null ? void 0 : _a.call(childElem, param, results);
-  }
-  return results.length ? results : void 0;
-}
-function setNodeStyles(params = {}) {
-  var _a;
-  const el = this;
-  if (!((_a = el.node) == null ? void 0 : _a.style))
-    return;
-  for (const param in params) {
-    const value = params[param];
-    const childElem = el[param];
-    if ((0, import_utils.isObject)(value) && childElem)
-      setNodeStyles.call(childElem, value);
-    else
-      el.node.style[param] = value;
-  }
-  return el;
-}
-function remove(opts) {
-  const element = this;
-  const beforeRemoveReturns = (0, import_event.triggerEventOn)("beforeRemove", element, opts);
-  if (beforeRemoveReturns === false)
-    return element;
-  if ((0, import_utils.isFunction)(element.node.remove))
-    element.node.remove();
-  else if (!(0, import_utils.isProduction)()) {
-    console.warn("This item cant be removed");
-    element.log();
-  }
-  delete element.parent[element.key];
-  if (element.parent.__ref)
-    element.parent.__ref.__children = (0, import_utils.removeValueFromArray)(element.parent.__ref.__children, element.key);
-  (0, import_event.triggerEventOn)("remove", element, opts);
-}
-function get(param) {
-  const element = this;
-  return element[param];
-}
-function setProps(param, options) {
-  const element = this;
-  if (!param || !element.props)
-    return;
-  element.update({ props: param }, options);
-  return element;
-}
-function getRef() {
-  return this.__ref;
-}
-function getPath() {
-  return this.getRef().path;
-}
-const defineSetter = (element, key, get2, set) => Object.defineProperty(element, key, { get: get2, set });
-function keys() {
-  const element = this;
-  const keys2 = [];
-  for (const param in element) {
-    if (import_mixins.REGISTRY[param] && !import_mixins.parseFilters.elementKeys.includes(param) || !Object.hasOwnProperty.call(element, param)) {
-      continue;
-    }
-    keys2.push(param);
-  }
-  return keys2;
-}
-function parse(excl = []) {
-  const element = this;
-  const obj = {};
-  const keyList = keys.call(element);
-  keyList.forEach((v) => {
-    if (excl.includes(v))
-      return;
-    const val = element[v];
-    if (v === "state") {
-      if (element.__ref && !element.__ref.__hasRootState)
-        return;
-      const parsedVal = (0, import_utils.isFunction)(val && val.parse) ? val.parse() : val;
-      obj[v] = (0, import_utils.isFunction)(parsedVal) ? parsedVal : JSON.parse(JSON.stringify(parsedVal || {}));
-    } else if (v === "scope") {
-      if (element.__ref && !element.__ref.__hasRootScope)
-        return;
-      obj[v] = JSON.parse(JSON.stringify(val || {}));
-    } else if (v === "props") {
-      const { __element, update, ...props } = element[v];
-      obj[v] = props;
-    } else if ((0, import_utils.isDefined)(val) && Object.hasOwnProperty.call(element, v))
-      obj[v] = val;
-  });
-  return obj;
-}
-function parseDeep(excl = []) {
-  const element = this;
-  const obj = parse.call(element, excl);
-  for (const v in obj) {
-    if (excl.includes(v))
-      return;
-    if ((0, import_utils.isObjectLike)(obj[v])) {
-      obj[v] = parseDeep.call(obj[v], excl);
-    }
-  }
-  return obj;
-}
-function verbose(...args) {
-  if (ENV !== "test" && ENV !== "development")
-    return;
-  const element = this;
-  const { __ref: ref } = element;
-  console.groupCollapsed(element.key);
-  if (args.length) {
-    args.forEach((v) => console.log(`%c${v}:
-`, "font-weight: bold", element[v]));
-  } else {
-    console.log(ref.path);
-    const keys2 = element.keys();
-    keys2.forEach((v) => console.log(`%c${v}:`, "font-weight: bold", element[v]));
-  }
-  console.log(element);
-  console.groupEnd(element.key);
-  return element;
-}
-function log(...params) {
-  if (ENV === "test" || ENV === "development") {
-    console.log(...params);
-  }
-}
-function warn(...params) {
-  if (ENV === "test" || ENV === "development") {
-    console.warn(...params);
-  }
-}
-function error(...params) {
-  var _a, _b;
-  if (ENV === "test" || ENV === "development") {
-    if ((_a = params[params.length - 1]) == null ? void 0 : _a.debugger)
-      debugger;
-    if ((_b = params[params.length - 1]) == null ? void 0 : _b.verbose)
-      verbose.call(this);
-    throw new Error(...params);
-  }
-}
-function nextElement() {
-  const element = this;
-  const { key, parent } = element;
-  const { __children } = parent.__ref;
-  const currentIndex = __children.indexOf(key);
-  const nextChild = __children[currentIndex + 1];
-  return parent[nextChild];
-}
-function previousElement(el) {
-  const element = el || this;
-  const { key, parent } = element;
-  const { __children } = parent.__ref;
-  if (!__children)
-    return;
-  const currentIndex = __children.indexOf(key);
-  return parent[__children[currentIndex - 1]];
-}
-function variables(obj = {}) {
-  const element = this;
-  if (!element.data)
-    element.data = {};
-  if (!element.data.varCaches)
-    element.data.varCaches = {};
-  const varCaches = element.data.varCaches;
-  const changes = {};
-  let changed;
-  for (const key in obj) {
-    if (obj[key] !== varCaches[key]) {
-      changed = true;
-      changes[key] = obj[key];
-    }
-  }
-  return {
-    changed: (cb) => {
-      if (!changed)
-        return;
-      const returns = cb(changes, (0, import_utils.deepClone)(varCaches));
-      for (const key in changes) {
-        varCaches[key] = changes[key];
-      }
-      return returns;
-    },
-    timeout: (cb, timeout) => {
-      if (!changed)
-        return;
-      const t = setTimeout(() => {
-        cb(changes);
-        clearTimeout(t);
-      }, timeout);
-    }
-  };
-}
-function call(fnKey, ...args) {
-  var _a;
-  const context = this.context;
-  return (_a = context.utils[fnKey] || context.functions[fnKey] || context.methods[fnKey] || context.snippets[fnKey]) == null ? void 0 : _a.call(this, ...args);
-}
-const METHODS = [
-  "set",
-  "reset",
-  "update",
-  "remove",
-  "updateContent",
-  "removeContent",
-  "lookup",
-  "lookdown",
-  "lookdownAll",
-  "getRef",
-  "getPath",
-  "setNodeStyles",
-  "spotByPath",
-  "keys",
-  "parse",
-  "setProps",
-  "parseDeep",
-  "variables",
-  "if",
-  "log",
-  "verbose",
-  "warn",
-  "error",
-  "call",
-  "nextElement",
-  "previousElement"
-];
-function isMethod(param, element) {
-  var _a, _b;
-  return METHODS.includes(param) || ((_b = (_a = element == null ? void 0 : element.context) == null ? void 0 : _a.methods) == null ? void 0 : _b[param]);
-}

package/dist/cjs/mixins/content.js

@@ -1,74 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var content_exports = {};
-__export(content_exports, {
-  default: () => content_default,
-  removeContent: () => removeContent,
-  setContent: () => setContent,
-  updateContent: () => updateContent
-});
-module.exports = __toCommonJS(content_exports);
-var import_utils = require("@domql/utils");
-var import_set = require("../set.js");
-const updateContent = function(params, options) {
-  const element = this;
-  const ref = element.__ref;
-  const contentKey = ref.contentElementKey;
-  if (!element[contentKey])
-    return;
-  if (element[contentKey].update)
-    element[contentKey].update(params, options);
-};
-const removeContent = function(el, opts = {}) {
-  const element = el || this;
-  const { __ref: ref } = element;
-  const contentElementKey = (0, import_utils.setContentKey)(element, opts);
-  if (opts.contentElementKey !== "content")
-    opts.contentElementKey = "content";
-  if (element[contentElementKey]) {
-    if (element[contentElementKey].node && element.node) {
-      if (element[contentElementKey].tag === "fragment")
-        element.node.innerHTML = "";
-      else {
-        const contentNode = element[contentElementKey].node;
-        if (contentNode.parentNode === element.node)
-          element.node.removeChild(element[contentElementKey].node);
-      }
-    }
-    const { __cached } = ref;
-    if (__cached && __cached[contentElementKey]) {
-      if (__cached[contentElementKey].tag === "fragment")
-        __cached[contentElementKey].parent.node.innerHTML = "";
-      else if (__cached[contentElementKey] && (0, import_utils.isFunction)(__cached[contentElementKey].remove))
-        __cached[contentElementKey].remove();
-    }
-    delete element[contentElementKey];
-  }
-};
-function setContent(param, element, node, opts) {
-  const contentElementKey = (0, import_utils.setContentKey)(element, opts);
-  if (param && element) {
-    if (element[contentElementKey].update) {
-      element[contentElementKey].update({}, opts);
-    } else {
-      import_set.set.call(element, param, opts);
-    }
-  }
-}
-var content_default = setContent;