@domql/element 2.5.184 → 2.5.186

package/dist/esm/mixins/registry.js

@@ -0,0 +1,105 @@
+import attr from "./attr.js";
+import { classList } from "./classList.js";
+import setContent from "./content.js";
+import data from "./data.js";
+import html from "./html.js";
+import scope from "./scope.js";
+import state from "./state.js";
+import style from "./style.js";
+import text from "./text.js";
+const REGISTRY = {
+  attr,
+  style,
+  text,
+  html,
+  setContent,
+  data,
+  class: classList,
+  state,
+  scope,
+  deps: (param, el) => param || el.parent.deps,
+  extend: {},
+  childExtend: {},
+  childExtendRecursive: {},
+  props: {},
+  path: {},
+  if: {},
+  define: {},
+  transform: {},
+  __name: {},
+  __ref: {},
+  __hash: {},
+  __text: {},
+  nextElement: {},
+  previousElement: {},
+  key: {},
+  tag: {},
+  query: {},
+  parent: {},
+  node: {},
+  set: {},
+  reset: {},
+  update: {},
+  error: {},
+  warn: {},
+  call: {},
+  setProps: {},
+  remove: {},
+  updateContent: {},
+  removeContent: {},
+  variables: {},
+  lookup: {},
+  lookdown: {},
+  getRef: {},
+  getPath: {},
+  lookdownAll: {},
+  setNodeStyles: {},
+  spotByPath: {},
+  keys: {},
+  log: {},
+  parse: {},
+  parseDeep: {},
+  on: {},
+  component: {},
+  context: {},
+  $collection: {},
+  $stateCollection: {},
+  $propsCollection: {},
+  $setCollection: {},
+  $setStateCollection: {},
+  $setPropsCollection: {}
+};
+var registry_default = REGISTRY;
+const parseFilters = {
+  elementKeys: [
+    "tag",
+    "text",
+    "style",
+    "attr",
+    "class",
+    "state",
+    "props",
+    "data",
+    "content",
+    "html",
+    "on",
+    "key",
+    "extend",
+    "childExtend",
+    "childExtendRecursive",
+    "scope",
+    "query",
+    "$collection",
+    "$stateCollection",
+    "$propsCollection"
+  ],
+  propsKeys: ["__element", "update"],
+  stateKeys: []
+};
+const collectionFilters = ["$collection", "$stateCollection", "$propsCollection"];
+export {
+  REGISTRY,
+  collectionFilters,
+  registry_default as default,
+  parseFilters
+};

package/dist/esm/mixins/scope.js

@@ -0,0 +1,18 @@
+import { isFunction, isObject } from "@domql/utils";
+function scope(params, element, node) {
+  if (!isObject(params))
+    return;
+  for (const scopeItem in params) {
+    const value = params[scopeItem];
+    if (isFunction(value)) {
+      element.scope[scopeItem] = value.bind(element);
+    } else {
+      element.scope[scopeItem] = value;
+    }
+  }
+}
+var scope_default = scope;
+export {
+  scope_default as default,
+  scope
+};

package/dist/esm/mixins/state.js

@@ -0,0 +1,19 @@
+import { IGNORE_STATE_PARAMS } from "@domql/state";
+import { exec, isObject } from "@domql/utils";
+function state(params, element, node) {
+  const state2 = exec(params, element);
+  if (isObject(state2)) {
+    for (const param in state2) {
+      if (IGNORE_STATE_PARAMS.includes(param))
+        continue;
+      if (!Object.hasOwnProperty.call(state2, param))
+        continue;
+    }
+  }
+  return element;
+}
+var state_default = state;
+export {
+  state_default as default,
+  state
+};

package/dist/esm/mixins/style.js

@@ -0,0 +1,15 @@
+import { isObject, map } from "@domql/utils";
+import { report } from "@domql/report";
+function style(params, element, node) {
+  if (params) {
+    if (isObject(params))
+      map(node.style, params, element);
+    else
+      report("HTMLInvalidStyles", params);
+  }
+}
+var style_default = style;
+export {
+  style_default as default,
+  style
+};

package/dist/esm/mixins/text.js

@@ -0,0 +1,28 @@
+import { create } from "../create.js";
+import {
+  exec,
+  isString
+} from "@domql/utils";
+function text(param, element, node) {
+  let prop = exec(param, element);
+  if (isString(prop) && prop.includes("{{")) {
+    prop = element.call("replaceLiteralsWithObjectFields", prop);
+  }
+  if (element.tag === "string") {
+    node.nodeValue = prop;
+  } else if (param !== void 0 || param !== null) {
+    if (element.__text) {
+      if (element.__text.text === prop)
+        return;
+      element.__text.text = prop;
+      if (element.__text.node)
+        element.__text.node.nodeValue = prop;
+    } else
+      create({ tag: "string", text: prop }, element, "__text");
+  }
+}
+var text_default = text;
+export {
+  text_default as default,
+  text
+};

package/dist/esm/node.js

@@ -0,0 +1,69 @@
+import { exec, isFunction, isObject, isUndefined, isVariant } from "@domql/utils";
+import { applyEventsOnNode, triggerEventOn, applyAnimationFrame } from "@domql/event";
+import { cacheNode } from "@domql/render";
+import { isMethod } from "./methods/index.js";
+import create from "./create.js";
+import {
+  throughExecProps,
+  throughInitialDefine,
+  throughInitialExec
+} from "./iterate.js";
+import { REGISTRY } from "./mixins/index.js";
+import { applyParam } from "./utils/applyParam.js";
+import { propagateEventsFromProps } from "./utils/propEvents.js";
+const ENV = "development";
+const createNode = async (element, options) => {
+  let { node, tag, __ref: ref } = element;
+  let isNewNode;
+  if (!node) {
+    isNewNode = true;
+    if (!ref.__if)
+      return element;
+    if (tag === "shadow") {
+      node = element.node = element.parent.node.attachShadow({ mode: "open" });
+    } else
+      node = element.node = cacheNode(element);
+    triggerEventOn("attachNode", element, options);
+  }
+  if (ENV === "test" || ENV === "development" || options.alowRefReference) {
+    node.ref = element;
+    if (isFunction(node.setAttribute))
+      node.setAttribute("key", element.key);
+  }
+  throughExecProps(element);
+  throughInitialDefine(element);
+  throughInitialExec(element);
+  if (element.tag !== "string" && element.tag !== "fragment") {
+    propagateEventsFromProps(element);
+    applyAnimationFrame(element, options);
+    if (isNewNode && isObject(element.on)) {
+      applyEventsOnNode(element, options);
+    }
+  }
+  for (const param in element) {
+    const value = element[param];
+    if (!Object.hasOwnProperty.call(element, param))
+      continue;
+    if (isUndefined(value) || isMethod(param, element) || isVariant(param) || isObject(REGISTRY[param]))
+      continue;
+    const isElement = applyParam(param, element, options);
+    if (isElement) {
+      const { hasDefine, hasContextDefine } = isElement;
+      if (element[param] && !hasDefine && !hasContextDefine) {
+        const createAsync = async () => {
+          await create(exec(value, element), element, param, options);
+        };
+        if (element.props && element.props.lazyLoad || options.lazyLoad) {
+          window.requestAnimationFrame(async () => await createAsync());
+        } else
+          await createAsync();
+      }
+    }
+  }
+  return element;
+};
+var node_default = createNode;
+export {
+  createNode,
+  node_default as default
+};

package/dist/esm/props/create.js

@@ -0,0 +1,78 @@
+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

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

package/dist/esm/props/index.js

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

package/dist/esm/props/inherit.js

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,17 @@
+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/set.js

@@ -0,0 +1,73 @@
+import { deepContains, setContentKey } from "@domql/utils";
+import { OPTIONS } from "./cache/options.js";
+import { create } from "./create.js";
+import { registry } from "./mixins/index.js";
+import { removeContent } from "./mixins/content.js";
+import { triggerEventOn, triggerEventOnUpdate } from "@domql/event";
+const resetElement = (params, element, options) => {
+  if (!options.preventRemove)
+    removeContent(element, options);
+  const { __ref: ref } = element;
+  create(params, element, ref.contentElementKey || "content", {
+    ignoreChildExtend: true,
+    ...registry.defaultOptions,
+    ...OPTIONS.create,
+    ...options
+  });
+};
+const reset = (options) => {
+  const element = void 0;
+  create(element, element.parent, void 0, {
+    ignoreChildExtend: true,
+    ...registry.defaultOptions,
+    ...OPTIONS.create,
+    ...options
+  });
+};
+const set = function(params, options = {}, el) {
+  var _a;
+  const element = el || this;
+  const { __ref: ref } = element;
+  const content = setContentKey(element, options);
+  const __contentRef = content && content.__ref;
+  const lazyLoad = element.props && element.props.lazyLoad;
+  const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection;
+  if (options.preventContentUpdate === true && !hasCollection)
+    return;
+  if (ref.__noCollectionDifference || __contentRef && __contentRef.__cached && deepContains(params, content)) {
+    if (!options.preventBeforeUpdateListener && !options.preventListeners) {
+      const beforeUpdateReturns = triggerEventOnUpdate("beforeUpdate", params, element, options);
+      if (beforeUpdateReturns === false)
+        return element;
+    }
+    if (content == null ? void 0 : content.update)
+      content.update();
+    if (!options.preventUpdateListener)
+      triggerEventOn("update", element, options);
+    return;
+  }
+  if (params) {
+    let { childExtend, childProps, props } = params;
+    if (!childExtend && element.childExtend)
+      params.childExtend = element.childExtend;
+    if (!childProps && element.childProps)
+      params.childProps = element.childProps;
+    if (!(props == null ? void 0 : props.childProps) && ((_a = element.props) == null ? void 0 : _a.childProps)) {
+      if (!props)
+        props = params.props = {};
+      props.childProps = element.props.childProps;
+    }
+    if (lazyLoad) {
+      window.requestAnimationFrame(() => resetElement(params, element, options));
+    } else
+      resetElement(params, element, options);
+  }
+  return element;
+};
+var set_default = set;
+export {
+  set_default as default,
+  reset,
+  resetElement,
+  set
+};

package/dist/esm/tree.js

@@ -0,0 +1,11 @@
+import { document } from "@domql/utils";
+import { report } from "@domql/report";
+const ROOT = {
+  key: ":root",
+  node: document ? document.body : report("DocumentNotDefined", document)
+};
+const TREE = ROOT;
+export {
+  ROOT,
+  TREE
+};