@domql/element 2.5.185 → 2.5.187

package/dist/esm/create.js

@@ -0,0 +1,334 @@
+import createNode from "./node.js";
+import { ROOT } from "./tree.js";
+import {
+  HTML_TAGS,
+  isObject,
+  isFunction,
+  isString,
+  exec,
+  is,
+  isNode,
+  isUndefined,
+  generateKey,
+  checkIfKeyIsComponent,
+  deepClone,
+  applyComponentFromContext,
+  applyKeyComponentAsExtend,
+  isVariant,
+  detectInfiniteLoop,
+  addChildrenIfNotInOriginal
+} from "@domql/utils";
+import { triggerEventOn } from "@domql/event";
+import { assignNode } from "@domql/render";
+import { createState } from "@domql/state";
+import { isMethod } from "./methods/index.js";
+import { createProps } from "./props/index.js";
+import { applyExtend } from "./extend.js";
+import { REGISTRY, registry } from "./mixins/index.js";
+import { addMethods } from "./methods/set.js";
+import { assignKeyAsClassname } from "./mixins/classList.js";
+import { throughInitialExec, throughInitialDefine } from "./iterate.js";
+import { OPTIONS } from "./cache/options.js";
+import {
+  applyVariant,
+  createValidDomqlObjectFromSugar
+} from "./utils/component.js";
+const ENV = "development";
+const create = async (element, parent, key, options = OPTIONS.create || {}, attachOptions) => {
+  cacheOptions(element, options);
+  if (checkIfPrimitive(element)) {
+    element = applyValueAsText(element, parent, key);
+  }
+  element = redefineElement(element, parent, key, options);
+  parent = redefineParent(element, parent, key);
+  key = createKey(element, parent, key);
+  const ref = addRef(element, parent, key);
+  ref.__initialProps = deepClone(element.props);
+  applyContext(element, parent, options);
+  applyComponentFromContext(element, parent, options);
+  if (!ref.__skipCreate) {
+    applyExtend(element, parent, options);
+  }
+  element.key = key;
+  if (options.onlyResolveExtends) {
+    return onlyResolveExtends(element, parent, key, options);
+  }
+  await triggerEventOn("start", element, options);
+  switchDefaultOptions(element, parent, options);
+  addCaching(element, parent);
+  addMethods(element, parent, options);
+  createScope(element, parent);
+  await createState(element, parent);
+  if (element.scope === "state")
+    element.scope = element.state;
+  createIfConditionFlag(element, parent);
+  createProps(element, parent, options);
+  if (element.scope === "props" || element.scope === true)
+    element.scope = element.props;
+  createIfConditionFlag(element, parent);
+  if (element.node && ref.__if) {
+    return assignNode(element, parent, key, attachOptions);
+  }
+  applyVariant(element, parent);
+  const onInit = await triggerEventOn("init", element, options);
+  if (onInit === false)
+    return element;
+  triggerEventOn("beforeClassAssign", element, options);
+  assignKeyAsClassname(element);
+  addChildrenIfNotInOriginal(element, parent, key);
+  await renderElement(element, parent, options, attachOptions);
+  addElementIntoParentChildren(element, parent);
+  await triggerEventOn("complete", element, options);
+  return element;
+};
+const createBasedOnType = (element, parent, key, options) => {
+  if (element === void 0) {
+    if (ENV === "test" || 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") {
+      console.warn(key, "seems like to be in __ref");
+    }
+  }
+  if (element === null)
+    return;
+  if (element === true)
+    return { text: true };
+  if (element.__hash) {
+    return { extend: element };
+  }
+  return element;
+};
+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;
+    return createValidDomqlObjectFromSugar(element, parent, key, options);
+  } else if (checkIfKeyIsComponent(key)) {
+    return applyKeyComponentAsExtend(elementWrapper, parent, key);
+  }
+  if (checkIfMedia(key)) {
+    return applyMediaProps(elementWrapper, parent, key);
+  }
+  return elementWrapper;
+};
+const redefineParent = (element, parent, key, options) => {
+  if (!parent)
+    return ROOT;
+  if (isNode(parent)) {
+    const parentNodeWrapper = { key: ":root", node: parent };
+    ROOT[`${key}_parent`] = parentNodeWrapper;
+    return parentNodeWrapper;
+  }
+  return parent;
+};
+const cacheOptions = (element, options) => {
+  if (options && !OPTIONS.create) {
+    OPTIONS.create = options;
+    OPTIONS.create.context = element.context || options.context;
+  }
+};
+const createKey = (element, parent, key) => {
+  return (exec(key, element) || key || element.key || generateKey()).toString();
+};
+const addRef = (element, parent) => {
+  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) {
+    registry.defaultOptions = options;
+    if (options.ignoreChildExtend)
+      delete options.ignoreChildExtend;
+  }
+};
+const addElementIntoParentChildren = (element, parent) => {
+  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);
+  }
+  visitedElements.set(element, true);
+  const { __ref: ref, key } = element;
+  try {
+    const isInfiniteLoopDetected = detectInfiniteLoop(ref.path);
+    if (ref.__uniqId || isInfiniteLoopDetected)
+      return;
+    await createNode(element, options);
+    ref.__uniqId = Math.random();
+  } catch (e) {
+    if (ENV === "test" || ENV === "development") {
+      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);
+      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 (!ref.__if) {
+    parent[key || element.key] = element;
+    return element;
+  }
+  assignNode(element, parent, key, attachOptions);
+  await triggerEventOn("renderRouter", element, options);
+  await triggerEventOn("render", element, options);
+  await triggerEventOn("done", element, options);
+  await triggerEventOn("create", element, options);
+};
+const checkIfPrimitive = (element) => is(element)("string", "number");
+const applyValueAsText = (element, parent, key) => {
+  const extendTag = element.extend && element.extend.tag;
+  const childExtendTag = parent.childExtend && parent.childExtend.tag;
+  const childPropsTag = parent.props.childProps && parent.props.childProps.tag;
+  const isKeyValidHTMLTag = HTML_TAGS.body.indexOf(key) > -1 && key;
+  return {
+    text: element,
+    tag: extendTag || childExtendTag || childPropsTag || isKeyValidHTMLTag || "string"
+  };
+};
+const applyContext = (element, parent, options) => {
+  const forcedOptionsContext = options.context && !ROOT.context && !element.context;
+  if (forcedOptionsContext)
+    ROOT.context = options.context;
+  if (!element.context)
+    element.context = parent.context || options.context || ROOT.context;
+};
+const createScope = (element, parent) => {
+  const { __ref: ref } = element;
+  if (!element.scope)
+    element.scope = parent.scope || ref.root.scope || {};
+};
+const createIfConditionFlag = (element, parent) => {
+  const { __ref: ref } = element;
+  if (isFunction(element.if) && !element.if(element, element.state, element.context)) {
+    delete ref.__if;
+  } 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 (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 = [];
+  ref.path = parentRef.path.concat(element.key);
+};
+const onlyResolveExtends = (element, parent, key, options) => {
+  const { __ref: ref } = element;
+  if (!ref.__skipCreate) {
+    addCaching(element, parent);
+    addMethods(element, parent, options);
+    createScope(element, parent);
+    createState(element, parent);
+    if (element.scope === "state")
+      element.scope = element.state;
+    createIfConditionFlag(element, parent);
+    createProps(element, parent, options);
+    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 = {};
+    applyVariant(element, parent);
+    addElementIntoParentChildren(element, parent);
+  }
+  if (element.tag !== "string" && element.tag !== "fragment") {
+    throughInitialDefine(element);
+    throughInitialExec(element);
+    for (const k in element) {
+      if (isUndefined(element[k]) || isMethod(k, element) || isObject((registry.default || registry)[k]) || 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];
+      if (!ref.__skipCreate && REGISTRY[k] && !optionsHasDefine) {
+        continue;
+      } else if (element[k] && !hasDefine && !optionsHasDefine && !contextHasDefine) {
+        create(exec(element[k], element), element, k, options);
+      }
+    }
+  }
+  parent[key || element.key] = element;
+  delete element.update;
+  delete element.__element;
+  if (element.props) {
+    delete element.props.update;
+    delete element.props.__element;
+  }
+  return element;
+};
+const checkIfMedia = (key) => key.slice(0, 1) === "@";
+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" };
+    return element;
+  } else {
+    return {
+      ...element,
+      props: {
+        display: "none",
+        [key]: { display: "block" }
+      }
+    };
+  }
+};
+var create_default = create;
+export {
+  create,
+  create_default as default
+};

package/dist/esm/define.js

@@ -0,0 +1,14 @@
+import { report } from "@domql/report";
+import { REGISTRY } from "./mixins";
+var define_default = (params, options = {}) => {
+  const { overwrite } = options;
+  for (const param in params) {
+    if (REGISTRY[param] && !overwrite) {
+      report("OverwriteToBuiltin", param);
+    } else
+      REGISTRY[param] = params[param];
+  }
+};
+export {
+  define_default as default
+};

package/dist/esm/extend.js

@@ -0,0 +1,71 @@
+import { isFunction, exec } from "@domql/utils";
+import {
+  getExtendStack,
+  jointStacks,
+  cloneAndMergeArrayExtend,
+  deepMergeExtend,
+  fallbackStringExtend
+} from "./utils/index.js";
+const ENV = "development";
+let mainExtend;
+const applyExtend = (element, parent, options = {}) => {
+  if (isFunction(element))
+    element = 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 = fallbackStringExtend(extend, context, options, variant);
+  const extendStack = 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 = getExtendStack(parent.childExtend, context);
+      const ignoreChildExtendRecursive = props && props.ignoreChildExtendRecursive;
+      if (parent.childExtendRecursive && !ignoreChildExtendRecursive) {
+        const canExtendRecursive = element.key !== "__text";
+        if (canExtendRecursive) {
+          const childExtendRecursiveStack = 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 = 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 = getExtendStack(context.defaultExtends, context);
+      mainExtend = cloneAndMergeArrayExtend(defaultOptionsExtend);
+      delete mainExtend.extend;
+    }
+    stack = [].concat(stack, mainExtend);
+  }
+  if (__ref)
+    __ref.__extend = stack;
+  let mergedExtend = cloneAndMergeArrayExtend(stack);
+  const COMPONENTS = context && context.components || options.components;
+  const component = exec(element.component || mergedExtend.component, element);
+  if (component && COMPONENTS && COMPONENTS[component]) {
+    const componentExtend = cloneAndMergeArrayExtend(getExtendStack(COMPONENTS[component]));
+    mergedExtend = deepMergeExtend(componentExtend, mergedExtend);
+  }
+  const merged = deepMergeExtend(element, mergedExtend);
+  return merged;
+};
+export {
+  applyExtend
+};

package/dist/esm/index.js

@@ -0,0 +1,14 @@
+import { TREE } from "./tree";
+import create from "./create";
+import createNode from "./node";
+import define from "./define";
+import update from "./update";
+import set from "./set";
+export {
+  TREE,
+  create,
+  createNode,
+  define,
+  set,
+  update
+};

package/dist/esm/iterate.js

@@ -0,0 +1,112 @@
+import {
+  isObject,
+  exec,
+  isFunction,
+  isNumber,
+  isString,
+  checkIfKeyIsComponent,
+  extendizeByKey,
+  isVariant
+} from "@domql/utils";
+import { METHODS_EXL, overwrite } from "./utils/index.js";
+import { isMethod } from "./methods/index.js";
+const throughInitialExec = (element, exclude = {}) => {
+  const { __ref: ref } = element;
+  for (const param in element) {
+    if (exclude[param])
+      continue;
+    const prop = element[param];
+    if (isFunction(prop) && !isMethod(param, element) && !isVariant(param)) {
+      ref.__exec[param] = prop;
+      element[param] = prop(element, element.state, element.context);
+    }
+  }
+};
+const throughUpdatedExec = (element, options = { excludes: METHODS_EXL }) => {
+  const { __ref: ref } = element;
+  const changes = {};
+  for (const param in ref.__exec) {
+    const prop = element[param];
+    const isDefinedParam = ref.__defineCache[param];
+    if (isDefinedParam)
+      continue;
+    const newExec = ref.__exec[param](element, element.state, element.context);
+    const execReturnsString = isString(newExec) || isNumber(newExec);
+    if (prop && prop.node && execReturnsString) {
+      overwrite(prop, { text: newExec }, options);
+    } else if (newExec !== prop) {
+      if (checkIfKeyIsComponent(param)) {
+        const { extend, ...newElem } = extendizeByKey(newExec, element, param);
+        overwrite(prop, newElem, options);
+      } else {
+        ref.__cached[param] = changes[param] = prop;
+        element[param] = newExec;
+      }
+    }
+  }
+  return changes;
+};
+const throughExecProps = (element) => {
+  const { __ref: ref } = element;
+  const { props } = element;
+  for (const k in props) {
+    const isDefine = k.startsWith("is") || k.startsWith("has") || k.startsWith("use");
+    const cachedExecProp = ref.__execProps[k];
+    if (isFunction(cachedExecProp)) {
+      props[k] = exec(cachedExecProp, element);
+    } else if (isDefine && isFunction(props[k])) {
+      ref.__execProps[k] = props[k];
+      props[k] = exec(props[k], element);
+    }
+  }
+};
+const throughInitialDefine = (element) => {
+  const { define, context, __ref: ref } = element;
+  let defineObj = {};
+  const hasGlobalDefine = context && isObject(context.define);
+  if (isObject(define))
+    defineObj = { ...define };
+  if (hasGlobalDefine)
+    defineObj = { ...defineObj, ...context.define };
+  for (const param in defineObj) {
+    let elementProp = element[param];
+    if (isFunction(elementProp) && !isMethod(param, element) && !isVariant(param)) {
+      ref.__exec[param] = elementProp;
+      const execParam2 = elementProp = exec(elementProp, element);
+      if (execParam2) {
+        elementProp = element[param] = execParam2.parse ? execParam2.parse() : execParam2;
+        ref.__defineCache[param] = elementProp;
+      }
+    }
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
+    if (execParam)
+      element[param] = execParam;
+  }
+  return element;
+};
+const throughUpdatedDefine = (element) => {
+  const { context, define, __ref: ref } = element;
+  const changes = {};
+  let obj = {};
+  if (isObject(define))
+    obj = { ...define };
+  if (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);
+    const cached = exec(ref.__defineCache[param], element);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
+    if (newExecParam)
+      element[param] = newExecParam;
+  }
+  return changes;
+};
+export {
+  throughExecProps,
+  throughInitialDefine,
+  throughInitialExec,
+  throughUpdatedDefine,
+  throughUpdatedExec
+};