domql 1.6.4 → 1.6.6

package/dist/cjs/element/node.js

@@ -0,0 +1,80 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var node_exports = {};
+__export(node_exports, {
+  createNode: () => createNode,
+  default: () => node_default
+});
+module.exports = __toCommonJS(node_exports);
+var import_utils = require("@domql/utils");
+var import_event = require("@domql/event");
+var import_methods = require("@domql/methods");
+var import_node = require("@domql/node");
+var import_create = __toESM(require("./create"));
+var import_iterate = require("./iterate");
+var import_mixins = require("./mixins");
+var import_applyParam = require("./applyParam");
+const ENV = "development";
+const createNode = (element, options) => {
+  let { node, tag, __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 = (0, import_node.cacheNode)(element);
+    (0, import_event.triggerEventOn)("attachNode", element);
+  }
+  if (ENV === "test" || ENV === "development" || options.alowRefReference) {
+    node.ref = element;
+    if ((0, import_utils.isFunction)(node.setAttribute))
+      node.setAttribute("key", element.key);
+  }
+  if (!__ref.__if)
+    return element;
+  if (element.tag !== "string" || element.tag !== "fragment") {
+    (0, import_iterate.throughInitialDefine)(element);
+    (0, import_iterate.throughInitialExec)(element);
+    if (isNewNode && (0, import_utils.isObject)(element.on))
+      (0, import_event.applyEventsOnNode)(element);
+    for (const param in element) {
+      const prop = element[param];
+      if ((0, import_methods.isMethod)(param) || (0, import_utils.isObject)(import_mixins.registry[param]) || prop === void 0)
+        continue;
+      const isElement = (0, import_applyParam.applyParam)(param, element, options);
+      if (isElement) {
+        const { hasDefine, hasContextDefine } = isElement;
+        if (element[param] && !hasDefine && !hasContextDefine) {
+          (0, import_create.default)((0, import_utils.exec)(prop, element), element, param, options);
+        }
+      }
+    }
+  }
+  return element;
+};
+var node_default = createNode;

package/dist/cjs/element/options.js

@@ -0,0 +1,24 @@
+"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, {
+  default: () => options_default
+});
+module.exports = __toCommonJS(options_exports);
+var options_default = {};

package/dist/cjs/element/parse.js

@@ -0,0 +1,42 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parse_exports = {};
+__export(parse_exports, {
+  default: () => parse_default
+});
+module.exports = __toCommonJS(parse_exports);
+var import_render = require("@domql/render");
+var import_create = __toESM(require("./create"));
+const parse = (element) => {
+  const virtualTree = {
+    node: document.createElement("div")
+  };
+  if (element && element.node)
+    (0, import_render.assignNode)(element, virtualTree);
+  else
+    (0, import_create.default)(element, virtualTree);
+  return virtualTree.node.innerHTML;
+};
+var parse_default = parse;

package/dist/cjs/element/props.js

@@ -0,0 +1,116 @@
+"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 props_exports = {};
+__export(props_exports, {
+  IGNORE_PROPS_PARAMS: () => IGNORE_PROPS_PARAMS,
+  default: () => props_default,
+  syncProps: () => syncProps,
+  updateProps: () => updateProps
+});
+module.exports = __toCommonJS(props_exports);
+var import_utils = require("@domql/utils");
+var import_utils2 = require("../utils");
+const IGNORE_PROPS_PARAMS = ["update", "__element"];
+const objectizeStringProperty = (propValue) => {
+  if ((0, import_utils.is)(propValue)("string", "number"))
+    return { inheritedString: propValue };
+  return propValue;
+};
+const inheritParentProps = (element, parent) => {
+  let propsStack = [];
+  const parentProps = (0, import_utils.exec)(parent, parent.state).props;
+  const matchParent = parent.props && parentProps[element.key];
+  const matchParentIsString = (0, import_utils.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)
+    propsStack.push(matchParentChildProps);
+  return propsStack;
+};
+const createPropsStack = (element, parent) => {
+  const { props, __ref } = element;
+  const propsStack = __ref.__props = inheritParentProps(element, parent);
+  if ((0, import_utils.isObject)(props))
+    propsStack.push(props);
+  else if (props === "inherit" && parent.props)
+    propsStack.push(parent.props);
+  else if (props)
+    propsStack.push(props);
+  if ((0, import_utils.isArray)(__ref.__extend)) {
+    __ref.__extend.map((extend) => {
+      if (extend.props)
+        propsStack.push(extend.props);
+      return extend.props;
+    });
+  }
+  __ref.__props = propsStack;
+  return propsStack;
+};
+const syncProps = (props, element) => {
+  element.props = {};
+  const mergedProps = { update, __element: element };
+  props.forEach((v) => {
+    if (IGNORE_PROPS_PARAMS.includes(v))
+      return;
+    const execProps = (0, import_utils.exec)(v, element);
+    if ((0, import_utils.isObject)(execProps) && execProps.__element)
+      return;
+    element.props = (0, import_utils2.deepMerge)(mergedProps, (0, import_utils2.deepClone)(execProps));
+  });
+  element.props = mergedProps;
+  return element.props;
+};
+const createProps = function(element, parent, cached) {
+  const propsStack = cached || createPropsStack(element, parent);
+  const { __ref } = element;
+  if (propsStack.length) {
+    __ref.__props = propsStack;
+    syncProps(propsStack, element);
+    element.props.update = update;
+  }
+  return element;
+};
+const updateProps = (newProps, element, parent) => {
+  const { __ref } = element;
+  let propsStack = __ref.__props;
+  const parentProps = inheritParentProps(element, parent);
+  if (parentProps)
+    propsStack = __ref.__props = [].concat(parentProps, propsStack);
+  if (newProps)
+    propsStack = __ref.__props = [].concat(newProps, propsStack);
+  if (propsStack)
+    syncProps(propsStack, element);
+  return element;
+};
+function update(props, options) {
+  const element = this.__element;
+  element.update({ props }, options);
+}
+var props_default = createProps;

package/dist/cjs/element/remove.js

@@ -0,0 +1,44 @@
+"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 remove_exports = {};
+__export(remove_exports, {
+  removeContentElement: () => removeContentElement
+});
+module.exports = __toCommonJS(remove_exports);
+var import_utils = require("@domql/utils");
+const removeContentElement = function(el) {
+  const element = el || this;
+  const { __ref } = element;
+  if (element.content) {
+    if (element.content.node) {
+      if (element.content.tag === "fragment")
+        element.node.innerHTML = "";
+      else
+        element.node.removeChild(element.content.node);
+    }
+    const { __cached } = __ref;
+    if (__cached && __cached.content) {
+      if (__cached.content.tag === "fragment")
+        __cached.content.parent.node.innerHTML = "";
+      else if (__cached.content && (0, import_utils.isFunction)(__cached.content.remove))
+        __cached.content.remove();
+    }
+    delete element.content;
+  }
+};

package/dist/cjs/element/set.js

@@ -0,0 +1,55 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var set_exports = {};
+__export(set_exports, {
+  default: () => set_default
+});
+module.exports = __toCommonJS(set_exports);
+var import_utils = require("@domql/utils");
+var import_remove = require("./remove");
+var import_create = __toESM(require("./create"));
+var import_mixins = require("./mixins");
+var import_options = __toESM(require("./options"));
+const set = function(params, options = {}, el) {
+  const element = el || this;
+  const __contentRef = element.content && element.content.__ref;
+  const isEqual = (0, import_utils.isEqualDeep)(params, element.content);
+  if (isEqual && __contentRef && __contentRef.__cached)
+    return element;
+  (0, import_remove.removeContentElement)(element);
+  if (params) {
+    const { childExtend } = params;
+    if (!childExtend && element.childExtend)
+      params.childExtend = element.childExtend;
+    (0, import_create.default)(params, element, "content", {
+      ignoreChildExtend: true,
+      ...import_mixins.registry.defaultOptions,
+      ...import_options.default.create,
+      ...options
+    });
+  }
+  return element;
+};
+var set_default = set;

package/dist/cjs/element/state.js

@@ -0,0 +1,279 @@
+"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 state_exports = {};
+__export(state_exports, {
+  IGNORE_STATE_PARAMS: () => IGNORE_STATE_PARAMS,
+  apply: () => apply,
+  clean: () => clean,
+  createState: () => createState,
+  default: () => state_default,
+  destroy: () => destroy,
+  isState: () => isState,
+  parse: () => parse,
+  remove: () => remove,
+  rootUpdate: () => rootUpdate,
+  updateState: () => updateState
+});
+module.exports = __toCommonJS(state_exports);
+var import_event = require("@domql/event");
+var import_utils = require("@domql/utils");
+var import_utils2 = require("../utils");
+var import__ = require(".");
+const IGNORE_STATE_PARAMS = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "destroy",
+  "remove",
+  "apply",
+  "rootUpdate",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "__root"
+];
+const parse = function() {
+  const state = this;
+  if ((0, import_utils.isObject)(state)) {
+    const obj = {};
+    for (const param in state) {
+      if (!IGNORE_STATE_PARAMS.includes(param)) {
+        obj[param] = state[param];
+      }
+    }
+    return obj;
+  } else if ((0, import_utils.isArray)(state)) {
+    return state.filter((item) => !IGNORE_STATE_PARAMS.includes(item));
+  }
+};
+const clean = function(options = {}) {
+  const state = this;
+  for (const param in state) {
+    if (!IGNORE_STATE_PARAMS.includes(param)) {
+      delete state[param];
+    }
+  }
+  state.update(state, { skipOverwrite: true, options });
+  return state;
+};
+const destroy = function() {
+  const state = this;
+  const element = state.__element;
+  delete element.state;
+  element.state = state.parent;
+  if (state.parent) {
+    delete state.parent.__children[element.key];
+  }
+  if (state.__children) {
+    for (const key in state.__children) {
+      const child = state.__children[key];
+      if (child.state) {
+        child.parent = state.parent;
+      }
+    }
+  }
+  element.state.update();
+  return element.state;
+};
+const rootUpdate = function(obj, options = {}) {
+  const state = this;
+  if (!state)
+    return;
+  const rootState = state.__element.__ref.__root.state;
+  return rootState.update(obj, options);
+};
+const updateState = function(obj, options = {}) {
+  const state = this;
+  const element = state.__element;
+  const __elementRef = element.__ref;
+  const parentState = element.parent.state;
+  state.parent = parentState;
+  for (const param in state) {
+    if ((0, import_utils.isUndefined)(state[param])) {
+      delete state[param];
+    }
+  }
+  if (!state.__element) {
+    (0, import__.create)(element, element.parent);
+  }
+  const initStateUpdateReturns = (0, import_event.triggerEventOn)("initStateUpdated", element, obj);
+  if (initStateUpdateReturns === false)
+    return element;
+  if (!options.skipOverwrite) {
+    if (options.shallow) {
+      (0, import_utils2.overwriteShallow)(state, obj, IGNORE_STATE_PARAMS);
+    } else {
+      (0, import_utils2.overwriteDeep)(state, obj, IGNORE_STATE_PARAMS);
+    }
+  }
+  const stateKey = __elementRef.__state;
+  const shouldPropagateState = stateKey && parentState && parentState[stateKey] && !options.stopStatePropagation;
+  if (shouldPropagateState) {
+    const isStringState = __elementRef.__stateType === "string";
+    const value = isStringState ? state.value : state.parse();
+    parentState[stateKey] = value;
+    parentState.update(value, { skipOverwrite: true, ...options });
+    return state;
+  }
+  if (!options.preventUpdate) {
+    element.update({}, options);
+  } else if (options.preventUpdate === "recursive") {
+    element.update({}, { ...options, preventUpdate: true });
+  }
+  if (state.__depends) {
+    for (const el in state.__depends) {
+      const findElement = state.__depends[el];
+      findElement.clean().update(state.parse(), options);
+    }
+  }
+  if (!options.preventUpdateListener) {
+    (0, import_event.triggerEventOn)("stateUpdated", element, obj);
+  }
+  return state;
+};
+const remove = function(key, options) {
+  const state = this;
+  if ((0, import_utils.isArray)(state))
+    (0, import_utils.removeFromArray)(state, key);
+  if ((0, import_utils.isObject)(state))
+    (0, import_utils.removeFromObject)(state, key);
+  return state.update(state, { skipOverwrite: true, options });
+};
+const apply = function(func, options) {
+  const state = this;
+  if ((0, import_utils.isFunction)(func)) {
+    func(state);
+    return state.update(state, { skipOverwrite: true, options });
+  }
+};
+const getParentStateInKey = (stateKey, parentState) => {
+  const arr = stateKey.split("../");
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    if (!parentState.parent)
+      return null;
+    parentState = parentState.parent;
+  }
+  return parentState;
+};
+const getChildStateInKey = (stateKey, parentState) => {
+  const arr = stateKey.split("/");
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    const childKey = arr[i];
+    const grandChildKey = arr[i + 1];
+    const childInParent = parentState[childKey];
+    if (childInParent && childInParent[grandChildKey]) {
+      stateKey = grandChildKey;
+      parentState = childInParent;
+    } else
+      return;
+  }
+  return parentState[stateKey];
+};
+const createInheritedState = function(element, parent) {
+  const __elementRef = element.__ref;
+  let stateKey = __elementRef.__state;
+  if (!stateKey)
+    return element.state;
+  let parentState = parent.state;
+  if (stateKey.includes("../")) {
+    parentState = getParentStateInKey(stateKey, parent.state);
+    stateKey = stateKey.replaceAll("../", "");
+  }
+  if (!parentState)
+    return {};
+  const keyInParentState = getChildStateInKey(stateKey, parentState);
+  if (!keyInParentState)
+    return {};
+  if ((0, import_utils.is)(keyInParentState)("object", "array")) {
+    return (0, import_utils2.deepClone)(keyInParentState);
+  } else if ((0, import_utils.is)(keyInParentState)("string", "number")) {
+    __elementRef.__stateType = "string";
+    return { value: keyInParentState };
+  }
+  console.warn(stateKey, "is not present. Replacing with", {});
+  return {};
+};
+const createState = function(element, parent, opts) {
+  const skip = opts && opts.skip ? opts.skip : false;
+  let { state, __ref: __elementRef } = element;
+  if ((0, import_utils.isFunction)(state))
+    element.state = (0, import_utils.exec)(state, element);
+  if ((0, import_utils.is)(state)("string", "number")) {
+    __elementRef.__state = state;
+    element.state = {};
+  }
+  if (state === true) {
+    __elementRef.__state = element.key;
+    element.state = {};
+  }
+  (0, import_event.triggerEventOn)("stateInit", element);
+  state = element.state = createInheritedState(element, parent);
+  if (!state) {
+    if (parent && parent.state)
+      return parent.state;
+    return {};
+  } else {
+    __elementRef.__hasRootState = true;
+  }
+  const { __ref } = state;
+  if (__ref) {
+    state = (0, import_utils2.deepClone)(__ref, IGNORE_STATE_PARAMS);
+    if ((0, import_utils.isObject)(__ref.__depends)) {
+      __ref.__depends[element.key] = state;
+    } else
+      __ref.__depends = { [element.key]: state };
+  } else {
+    state = (0, import_utils2.deepClone)(state, IGNORE_STATE_PARAMS);
+  }
+  element.state = state;
+  if (skip)
+    return state;
+  applyMethods(element, state);
+  (0, import_event.triggerEventOn)("stateCreated", element);
+  return state;
+};
+const isState = function(state) {
+  if (!(0, import_utils.isObjectLike)(state))
+    return false;
+  const keys = Object.keys(state);
+  return (0, import_utils.arrayContainsOtherArray)(keys, ["update", "parse", "clean", "create", "parent", "rootUpdate"]);
+};
+const applyMethods = (element, state) => {
+  const __elementRef = element.__ref;
+  state.clean = clean;
+  state.parse = parse;
+  state.destroy = destroy;
+  state.update = updateState;
+  state.rootUpdate = rootUpdate;
+  state.create = createState;
+  state.remove = remove;
+  state.apply = apply;
+  state.parent = element.parent.state;
+  state.__element = element;
+  state.__children = {};
+  state.__root = __elementRef.__root ? __elementRef.__root.state : state;
+  if (state.parent)
+    state.parent.__children[element.key] = state;
+};
+var state_default = createState;