@domql/element 2.5.200 → 3.0.0

package/dist/esm/methods/index.js

@@ -1,300 +0,0 @@
-import { triggerEventOn } from "@domql/event";
-import { isDefined, isObject, isFunction, isObjectLike, isProduction, removeValueFromArray, deepClone } from "@domql/utils";
-import { TREE } from "../tree.js";
-import { parseFilters, REGISTRY } from "../mixins/index.js";
-const ENV = "development";
-function spotByPath(path) {
-  const element = this;
-  const arr = [].concat(path);
-  let active = 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 (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 (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 (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 (isObject(value) && childElem) setNodeStyles.call(childElem, value);
-    else el.node.style[param] = value;
-  }
-  return el;
-}
-function remove(opts) {
-  const element = this;
-  const beforeRemoveReturns = triggerEventOn("beforeRemove", element, opts);
-  if (beforeRemoveReturns === false) return element;
-  if (isFunction(element.node.remove)) element.node.remove();
-  else if (!isProduction()) {
-    console.warn("This item cant be removed");
-    element.log();
-  }
-  delete element.parent[element.key];
-  if (element.parent.__ref) element.parent.__ref.__children = removeValueFromArray(element.parent.__ref.__children, element.key);
-  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 (REGISTRY[param] && !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 = isFunction(val && val.parse) ? val.parse() : val;
-      obj[v] = 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 (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 (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, 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]);
-}
-export {
-  METHODS,
-  call,
-  defineSetter,
-  error,
-  get,
-  getPath,
-  getRef,
-  isMethod,
-  keys,
-  log,
-  lookdown,
-  lookdownAll,
-  lookup,
-  nextElement,
-  parse,
-  parseDeep,
-  previousElement,
-  remove,
-  setNodeStyles,
-  setProps,
-  spotByPath,
-  variables,
-  verbose,
-  warn
-};

package/dist/esm/mixins/content.js

@@ -1,47 +0,0 @@
-import { isFunction, setContentKey } from "@domql/utils";
-import { set } from "../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 = 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] && isFunction(__cached[contentElementKey].remove)) __cached[contentElementKey].remove();
-    }
-    delete element[contentElementKey];
-  }
-};
-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);
-    }
-  }
-}
-var content_default = setContent;
-export {
-  content_default as default,
-  removeContent,
-  setContent,
-  updateContent
-};

package/dist/esm/props/create.js

@@ -1,72 +0,0 @@
-import { exec, isArray, isObject, deepClone, deepMerge } from "@domql/utils";
-import { IGNORE_PROPS_PARAMS } from "./ignore.js";
-import { inheritParentProps } from "./inherit.js";
-const createPropsStack = (element, parent) => {
-  const { props, __ref: ref } = element;
-  const propsStack = ref.__props = inheritParentProps(element, parent);
-  if (isObject(props)) propsStack.push(props);
-  else if (props === "inherit" && parent.props) propsStack.push(parent.props);
-  else if (props) propsStack.push(props);
-  if (isArray(ref.__extend)) {
-    ref.__extend.forEach((extend) => {
-      if (extend.props && extend.props !== props) propsStack.push(extend.props);
-    });
-  }
-  ref.__props = propsStack;
-  return propsStack;
-};
-const syncProps = (props, element, opts) => {
-  element.props = {};
-  const mergedProps = {};
-  props.forEach((v) => {
-    if (IGNORE_PROPS_PARAMS.includes(v)) return;
-    let execProps;
-    try {
-      execProps = exec(v, element);
-    } catch (e) {
-      element.error(e, opts);
-    }
-    element.props = deepMerge(
-      mergedProps,
-      deepClone(execProps, { ignore: IGNORE_PROPS_PARAMS }),
-      IGNORE_PROPS_PARAMS
-    );
-  });
-  element.props = mergedProps;
-  const methods = { update: update.bind(element.props), __element: element };
-  Object.setPrototypeOf(element.props, methods);
-  return element.props;
-};
-const createProps = function(element, parent, options) {
-  const { __ref: ref } = element;
-  const applyProps = () => {
-    const propsStack = options.cachedProps || createPropsStack(element, parent);
-    if (propsStack.length) {
-      ref.__props = propsStack;
-      syncProps(propsStack, element);
-    } else {
-      ref.__props = options.cachedProps || [];
-      element.props = {};
-    }
-  };
-  if (ref.__if) applyProps();
-  else {
-    try {
-      applyProps();
-    } catch {
-      element.props = {};
-      ref.__props = options.cachedProps || [];
-    }
-  }
-  const methods = { update: update.bind(element.props), __element: element };
-  Object.setPrototypeOf(element.props, methods);
-  return element;
-};
-function update(props, options) {
-  const element = this.__element;
-  element.update({ props }, options);
-}
-export {
-  createProps,
-  syncProps
-};

package/dist/esm/props/ignore.js

@@ -1,4 +0,0 @@
-const IGNORE_PROPS_PARAMS = ["update", "__element"];
-export {
-  IGNORE_PROPS_PARAMS
-};

package/dist/esm/props/index.js

@@ -1,4 +0,0 @@
-export * from "./ignore.js";
-export * from "./create.js";
-export * from "./inherit.js";
-export * from "./update.js";

package/dist/esm/props/inherit.js

@@ -1,31 +0,0 @@
-import { exec, is, isString } from "@domql/utils";
-const objectizeStringProperty = (propValue) => {
-  if (is(propValue)("string", "number")) {
-    return { inheritedString: propValue };
-  }
-  return propValue;
-};
-const inheritParentProps = (element, parent) => {
-  var _a;
-  let propsStack = [];
-  const parentProps = exec(parent, parent.state).props;
-  const matchParent = parent.props && parentProps[element.key];
-  const matchParentIsString = isString(matchParent);
-  const matchParentChildProps = parentProps && parentProps.childProps;
-  if (matchParent) {
-    if (matchParentIsString) {
-      const inheritedStringExists = propsStack.filter((v) => v.inheritedString)[0];
-      if (inheritedStringExists) inheritedStringExists.inheritedString = matchParent;
-      else {
-        propsStack = [].concat(objectizeStringProperty(matchParent), propsStack);
-      }
-    } else {
-      propsStack.push(objectizeStringProperty(matchParent));
-    }
-  }
-  if (matchParentChildProps && !((_a = element == null ? void 0 : element.props) == null ? void 0 : _a.ignoreChildProps)) propsStack.push(matchParentChildProps);
-  return propsStack;
-};
-export {
-  inheritParentProps
-};

package/dist/esm/props/update.js

@@ -1,14 +0,0 @@
-import { syncProps } from "./create.js";
-import { inheritParentProps } from "./inherit.js";
-const updateProps = (newProps, element, parent) => {
-  const { __ref } = element;
-  let propsStack = __ref.__props;
-  const parentProps = inheritParentProps(element, parent);
-  if (parentProps.length) propsStack = __ref.__props = [].concat(parentProps, propsStack);
-  if (newProps) propsStack = __ref.__props = [].concat(newProps, propsStack);
-  if (propsStack) syncProps(propsStack, element);
-  return element;
-};
-export {
-  updateProps
-};

package/dist/esm/utils/component.js

@@ -1,62 +0,0 @@
-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: {}
-  };
-  const allowedKeys = ["data", "state", "attr", "if"];
-  for (const k in el) {
-    const value = el[k];
-    const isComponent = checkIfKeyIsComponent(k);
-    const isRegistry = REGISTRY[k];
-    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

@@ -1,113 +0,0 @@
-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
-};