@domql/element 2.4.0 → 2.4.2

package/dist/cjs/utils/component.js

@@ -0,0 +1,133 @@
+"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 component_exports = {};
+__export(component_exports, {
+  addAdditionalExtend: () => addAdditionalExtend,
+  applyComponentFromContext: () => applyComponentFromContext,
+  applyKeyComponentAsExtend: () => applyKeyComponentAsExtend,
+  applyVariant: () => applyVariant,
+  checkIfKeyIsComponent: () => checkIfKeyIsComponent,
+  extendizeByKey: () => extendizeByKey,
+  hasVariantProp: () => hasVariantProp,
+  isVariant: () => isVariant,
+  overwriteVariant: () => overwriteVariant
+});
+module.exports = __toCommonJS(component_exports);
+var import_utils = require("@domql/utils");
+var import_extend = require("../extend");
+const ENV = "development";
+const checkIfKeyIsComponent = (key) => {
+  const isFirstKeyString = (0, import_utils.isString)(key);
+  if (!isFirstKeyString)
+    return;
+  const firstCharKey = key.slice(0, 1);
+  return /^[A-Z]*$/.test(firstCharKey);
+};
+const addAdditionalExtend = (newExtend, element) => {
+  const { extend } = element;
+  const preserveExtend = (0, import_utils.isArray)(extend) ? extend : [extend];
+  return {
+    ...element,
+    extend: [newExtend].concat(preserveExtend)
+  };
+};
+const extendizeByKey = (element, parent, key) => {
+  const { tag, extend, props, state, childExtend, childProps, on } = element;
+  const hasComponentAttrs = tag || extend || childExtend || props || state || on;
+  const componentKey = key.includes("_") ? key.split("_")[0] : key.includes(".") ? key.split(".")[0] : key;
+  const extendKey = componentKey || key;
+  if (!hasComponentAttrs || childProps) {
+    return {
+      extend: extendKey,
+      props: { ...element }
+    };
+  } else if (!extend || extend === true) {
+    return {
+      ...element,
+      extend: extendKey
+    };
+  } else if (extend) {
+    addAdditionalExtend(extendKey, element);
+  } else if ((0, import_utils.isFunction)(element)) {
+    return {
+      extend: extendKey,
+      props: { ...(0, import_utils.exec)(element, parent) }
+    };
+  }
+};
+const applyKeyComponentAsExtend = (element, parent, key) => {
+  return extendizeByKey(element, parent, key) || element;
+};
+const applyComponentFromContext = (element, parent, options) => {
+  const { context } = element;
+  const { components } = context;
+  const { extend } = element;
+  const execExtend = (0, import_utils.exec)(extend, element);
+  if ((0, import_utils.isString)(execExtend)) {
+    if (components[execExtend])
+      element.extend = components[execExtend];
+    else {
+      if ((ENV === "test" || ENV === "development") && options.verbose) {
+        console.warn(execExtend, "is not in library", components, element);
+        console.warn("replacing with ", {});
+      }
+      element.extend = {};
+    }
+  }
+};
+const isVariant = (param) => {
+  if (!(0, import_utils.isString)(param))
+    return;
+  const firstCharKey = param.slice(0, 1);
+  return firstCharKey === ".";
+};
+const hasVariantProp = (element) => {
+  const { props } = element;
+  if ((0, import_utils.isObject)(props) && (0, import_utils.isString)(props.variant))
+    return true;
+};
+const overwriteVariant = (element, variant, variantProps) => {
+  let variantElement = element[variant];
+  if (!variantElement)
+    return;
+  const props = (0, import_utils.isObject)(variantProps) ? variantProps : {};
+  if ((0, import_utils.isString)(variantElement)) {
+    variantElement = {
+      extend: [{ props }, variantElement]
+    };
+  } else if (variantElement.extend) {
+    variantElement = addAdditionalExtend({ props }, variantElement);
+  }
+  return (0, import_utils.overwriteDeep)(element, (0, import_extend.applyExtend)(variantElement));
+};
+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;
+};

package/dist/cjs/utils/extendUtils.js

@@ -0,0 +1,144 @@
+"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 extendUtils_exports = {};
+__export(extendUtils_exports, {
+  cloneAndMergeArrayExtend: () => cloneAndMergeArrayExtend,
+  deepCloneExtend: () => deepCloneExtend,
+  deepExtend: () => deepExtend,
+  deepMergeExtend: () => deepMergeExtend,
+  extendCachedRegistry: () => extendCachedRegistry,
+  extendStackRegistry: () => extendStackRegistry,
+  extractArrayExtend: () => extractArrayExtend,
+  flattenExtend: () => flattenExtend,
+  generateHash: () => generateHash,
+  getExtendMerged: () => getExtendMerged,
+  getExtendStack: () => getExtendStack,
+  getExtendStackRegistry: () => getExtendStackRegistry,
+  getHashedExtend: () => getHashedExtend,
+  jointStacks: () => jointStacks,
+  replaceStringsWithComponents: () => replaceStringsWithComponents,
+  setHashedExtend: () => setHashedExtend
+});
+module.exports = __toCommonJS(extendUtils_exports);
+var import_utils = require("@domql/utils");
+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 (!(0, import_utils.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) => {
+  extend.forEach((each) => flattenExtend(each, stack));
+  return stack;
+};
+const deepExtend = (extend, stack) => {
+  const extendOflattenExtend = extend.extend;
+  if (extendOflattenExtend) {
+    flattenExtend(extendOflattenExtend, stack);
+  }
+  return stack;
+};
+const flattenExtend = (extend, stack) => {
+  if (!extend)
+    return stack;
+  if ((0, import_utils.isArray)(extend))
+    return extractArrayExtend(extend, stack);
+  stack.push(extend);
+  if (extend.extend)
+    deepExtend(extend, stack);
+  return stack;
+};
+const deepCloneExtend = (obj) => {
+  const o = {};
+  for (const prop in obj) {
+    if (["parent", "node", "__element"].indexOf(prop) > -1)
+      continue;
+    const objProp = obj[prop];
+    if ((0, import_utils.isObject)(objProp)) {
+      o[prop] = deepCloneExtend(objProp);
+    } else if ((0, import_utils.isArray)(objProp)) {
+      o[prop] = objProp.map((x) => x);
+    } else
+      o[prop] = objProp;
+  }
+  return o;
+};
+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 ((0, import_utils.isObject)(elementProp) && (0, import_utils.isObject)(extendProp)) {
+      deepMergeExtend(elementProp, extendProp);
+    } else if ((0, import_utils.isArray)(elementProp) && (0, import_utils.isArray)(extendProp)) {
+      element[e] = elementProp.concat(extendProp);
+    } else if ((0, import_utils.isArray)(elementProp) && (0, import_utils.isObject)(extendProp)) {
+      const obj = deepMergeExtend({}, elementProp);
+      element[e] = deepMergeExtend(obj, extendProp);
+    } else if (elementProp === void 0 && (0, import_utils.isFunction)(extendProp)) {
+      element[e] = extendProp;
+    }
+  }
+  return element;
+};
+const cloneAndMergeArrayExtend = (stack) => {
+  return stack.reduce((a, c) => {
+    return deepMergeExtend(a, deepCloneExtend(c));
+  }, {});
+};
+const replaceStringsWithComponents = (stack, components) => {
+  return stack.map((v) => {
+    if ((0, import_utils.isString)(v))
+      return components[v];
+    else
+      return v;
+  });
+};
+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) => {
+  if (!extend)
+    return [];
+  if (extend.__hash)
+    return getHashedExtend(extend) || [];
+  const stack = flattenExtend(extend, []);
+  return getExtendStackRegistry(extend, stack);
+};
+const getExtendMerged = (extend) => {
+  const stack = getExtendStack(extend);
+  return cloneAndMergeArrayExtend(stack);
+};

package/dist/cjs/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./object"), module.exports);
+__reExport(utils_exports, require("./extendUtils"), module.exports);
+__reExport(utils_exports, require("./component"), module.exports);

package/dist/cjs/utils/object.js

@@ -0,0 +1,142 @@
+"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 object_exports = {};
+__export(object_exports, {
+  METHODS_EXL: () => METHODS_EXL,
+  clone: () => clone,
+  deepClone: () => deepClone,
+  deepMerge: () => deepMerge,
+  flattenRecursive: () => flattenRecursive,
+  mergeAndCloneIfArray: () => mergeAndCloneIfArray,
+  mergeArray: () => mergeArray,
+  mergeIfExisted: () => mergeIfExisted,
+  overwrite: () => overwrite,
+  overwriteDeep: () => overwriteDeep,
+  overwriteShallow: () => overwriteShallow
+});
+module.exports = __toCommonJS(object_exports);
+var import_utils = require("@domql/utils");
+var import_state = require("@domql/state");
+var import_props = require("../props");
+var import_methods = require("../methods");
+const METHODS_EXL = (0, import_utils.joinArrays)(
+  ["node", "state", "context", "extend"],
+  import_methods.METHODS,
+  import_state.IGNORE_STATE_PARAMS,
+  import_props.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 ((0, import_utils.isObjectLike)(elementProp) && (0, import_utils.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 deepClone = (obj, exclude = METHODS_EXL) => {
+  const o = (0, import_utils.isArray)(obj) ? [] : {};
+  for (const e in obj) {
+    if (exclude.includes(e))
+      continue;
+    let objProp = obj[e];
+    if (e === "extend" && (0, import_utils.isArray)(objProp)) {
+      objProp = mergeArray(objProp, exclude);
+    }
+    if ((0, import_utils.isObjectLike)(objProp)) {
+      o[e] = deepClone(objProp, exclude);
+    } else
+      o[e] = objProp;
+  }
+  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 ((0, import_utils.isObjectLike)(objProp) && (0, import_utils.isObjectLike)(paramsProp)) {
+      overwriteDeep(objProp, paramsProp);
+    } else if (paramsProp !== void 0) {
+      obj[e] = paramsProp;
+    }
+  }
+  return obj;
+};
+const mergeIfExisted = (a, b) => {
+  if ((0, import_utils.isObjectLike)(a) && (0, import_utils.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 (0, import_utils.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;
+};

package/methods/index.js

@@ -0,0 +1,165 @@
+'use strict'
+
+import { isDefined, isFunction, isObjectLike, isProduction } from '@domql/utils'
+import { TREE } from '../tree'
+import { parseFilters, registry } from '../mixins'
+
+// TODO: update these files
+export const spotByPath = function (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
+}
+
+// TODO: update these files
+export const lookup = function (key) {
+  const element = this
+  let { parent } = element
+
+  while (parent.key !== key) {
+    if (parent[key]) return parent[key]
+    parent = parent.parent
+    if (!parent) return
+  }
+
+  return parent
+}
+
+export const remove = function (params) {
+  const element = this
+  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]
+}
+
+export const get = function (param) {
+  const element = this
+  return element[param]
+}
+
+export const setProps = function (param, options) {
+  const element = this
+  if (!param || !element.props) return
+  element.update({ props: param }, options)
+  return element
+}
+
+// export const set = function () {
+// }
+
+// export const update = function () {
+// }
+
+export const defineSetter = (element, key, get, set) =>
+  Object.defineProperty(element, key, { get, set })
+
+export const keys = function () {
+  const element = this
+  const keys = []
+  for (const param in element) {
+    if (registry[param] && !parseFilters.elementKeys.includes(param)) { continue }
+    keys.push(param)
+  }
+  return keys
+}
+
+export const parse = function (excl = []) {
+  const element = this
+  const obj = {}
+  const keyList = keys.call(element)
+  keyList.forEach(v => {
+    if (excl.includes(v)) return
+    let val = element[v]
+    if (v === 'state') {
+      if (element.__ref && element.__ref.__hasRootState) return
+      if (isFunction(val && val.parse)) val = val.parse()
+    } else if (v === 'props') {
+      const { __element, update, ...props } = element[v]
+      obj[v] = props
+    } else if (isDefined(val)) obj[v] = val
+  })
+  return obj
+}
+
+export const parseDeep = function (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
+}
+
+export const log = function (...args) {
+  const element = this
+  const { __ref } = element
+  console.group(element.key)
+  if (args.length) {
+    args.forEach(v => console.log(`%c${v}:\n`, 'font-weight: bold', element[v]))
+  } else {
+    console.log(__ref.path)
+    const keys = element.keys()
+    keys.forEach(v => console.log(`%c${v}:\n`, 'font-weight: bold', element[v]))
+  }
+  console.groupEnd(element.key)
+  return element
+}
+
+export const nextElement = function () {
+  const element = this
+  const { key, parent } = element
+  const { __children } = parent.__ref
+
+  const currentIndex = __children.indexOf(key)
+  const nextChild = __children[currentIndex + 1]
+
+  return parent[nextChild]
+}
+
+export const previousElement = function (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]]
+}
+
+export const METHODS = [
+  'set',
+  'update',
+  'remove',
+  'updateContent',
+  'removeContent',
+  'lookup',
+  'spotByPath',
+  'keys',
+  'parse',
+  'setProps',
+  'parseDeep',
+  'if',
+  'log',
+  'nextElement',
+  'previousElement'
+]
+
+export const isMethod = function (param) {
+  return METHODS.includes(param)
+}

package/methods/set.js

@@ -0,0 +1,41 @@
+'use strict'
+
+import { isDevelopment } from '@domql/utils'
+
+import set from '../set'
+import update from '../update'
+
+import {
+  lookup,
+  setProps,
+  remove,
+  spotByPath,
+  log,
+  keys,
+  parse,
+  parseDeep,
+  nextElement,
+  previousElement
+} from './'
+
+import { removeContent, updateContent } from '../mixins/content'
+
+export const addMethods = (element, parent) => {
+  const proto = {
+    set: set.bind(element),
+    update: update.bind(element),
+    remove: remove.bind(element),
+    updateContent: updateContent.bind(element),
+    removeContent: removeContent.bind(element),
+    setProps: setProps.bind(element),
+    lookup: lookup.bind(element),
+    spotByPath: spotByPath.bind(element),
+    parse: parse.bind(element),
+    parseDeep: parseDeep.bind(element),
+    keys: keys.bind(element),
+    nextElement: nextElement.bind(element),
+    previousElement: previousElement.bind(element)
+  }
+  if (isDevelopment()) proto.log = log.bind(element)
+  Object.setPrototypeOf(element, proto)
+}