domql 1.6.39 → 1.6.41

package/dist/cjs/element/create.js

@@ -225,7 +225,7 @@ const resolveExtends = (element, parent, options) => {
   if (!element.state)
     element.state = {};
   element = (0, import_props.createProps)(element, parent);
-  (0, import_state.createState)(element, parent, { skip: true });
+  (0, import_state.createState)(element, parent, { skipApplyMethods: true });
   (0, import_component.applyVariant)(element, parent);
   (0, import_iterate.throughInitialExec)(element, options.propsExcludedFromExec);
   for (const param in element) {

package/dist/cjs/element/iterate.js

@@ -76,7 +76,7 @@ const throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state);
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
     if (execParam)
       element[param] = execParam;
   }
@@ -93,9 +93,9 @@ const throughUpdatedDefine = (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam)
-      ref.__defineCache[param] = execParam(element, element.state);
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = (0, import_utils.exec)(ref.__defineCache[param], element);
-    const newExecParam = obj[param](cached, element, element.state);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
     if (newExecParam)
       element[param] = newExecParam;
   }

package/dist/cjs/element/mixins/attr.js

@@ -0,0 +1,42 @@
+"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 attr_exports = {};
+__export(attr_exports, {
+  default: () => attr_default
+});
+module.exports = __toCommonJS(attr_exports);
+var import_utils = require("@domql/utils");
+var import_report = require("@domql/report");
+var attr_default = (params, element, node) => {
+  const { __ref } = element;
+  const { __attr } = __ref;
+  if ((0, import_utils.isNot)("object"))
+    (0, import_report.report)("HTMLInvalidAttr", params);
+  if (params) {
+    for (const attr in params) {
+      const val = (0, import_utils.exec)(params[attr], element);
+      if (val && node.setAttribute)
+        node.setAttribute(attr, val);
+      else if (node.removeAttribute)
+        node.removeAttribute(attr);
+      __attr[attr] = val;
+    }
+  }
+  console.groupEnd(params, __attr);
+};

package/dist/cjs/element/mixins/classList.js

@@ -0,0 +1,29 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var classList_exports = {};
+__export(classList_exports, {
+  default: () => classList_default
+});
+module.exports = __toCommonJS(classList_exports);
+var import_classlist = require("@domql/classlist");
+__reExport(classList_exports, require("@domql/classlist"), module.exports);
+var classList_default = (params, element, node) => {
+  (0, import_classlist.applyClassListOnNode)(params, element, node);
+};

package/dist/cjs/element/mixins/content.js

@@ -0,0 +1,39 @@
+"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 content_exports = {};
+__export(content_exports, {
+  default: () => content_default
+});
+module.exports = __toCommonJS(content_exports);
+var import_set = __toESM(require("../set"), 1);
+var content_default = (param, element, node, options) => {
+  if (param && element) {
+    if (element.content.update) {
+      element.content.update({}, options);
+    } else {
+      import_set.default.call(element, param, options);
+    }
+  }
+};

package/dist/cjs/element/mixins/data.js

@@ -0,0 +1,36 @@
+"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 data_exports = {};
+__export(data_exports, {
+  default: () => data_default
+});
+module.exports = __toCommonJS(data_exports);
+var import_utils = require("@domql/utils");
+var import_report = require("@domql/report");
+var data_default = (params, element, node) => {
+  if (params && params.showOnNode) {
+    if (!(0, import_utils.isObject)(params))
+      (0, import_report.report)("HTMLInvalidData", params);
+    for (const dataset in params) {
+      if (dataset !== "showOnNode") {
+        node.dataset[dataset] = (0, import_utils.exec)(params[dataset], element);
+      }
+    }
+  }
+};

package/dist/cjs/element/mixins/html.js

@@ -0,0 +1,35 @@
+"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 html_exports = {};
+__export(html_exports, {
+  default: () => html_default
+});
+module.exports = __toCommonJS(html_exports);
+var import_utils = require("@domql/utils");
+var html_default = (param, element, node) => {
+  const prop = (0, import_utils.exec)(param, element);
+  const { __ref } = element;
+  if (prop !== __ref.__html) {
+    if (node.nodeName === "SVG")
+      node.textContent = prop;
+    else
+      node.innerHTML = prop;
+    __ref.__html = prop;
+  }
+};

package/dist/cjs/element/mixins/index.js

@@ -0,0 +1,48 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 mixins_exports = {};
+__export(mixins_exports, {
+  attr: () => import_attr.default,
+  classList: () => import_classList.default,
+  content: () => import_content.default,
+  data: () => import_data.default,
+  html: () => import_html.default,
+  registry: () => import_registry.default,
+  state: () => import_state.default,
+  style: () => import_style.default,
+  text: () => import_text.default
+});
+module.exports = __toCommonJS(mixins_exports);
+var import_attr = __toESM(require("./attr"), 1);
+var import_classList = __toESM(require("./classList"), 1);
+var import_content = __toESM(require("./content"), 1);
+var import_data = __toESM(require("./data"), 1);
+var import_html = __toESM(require("./html"), 1);
+var import_style = __toESM(require("./style"), 1);
+var import_text = __toESM(require("./text"), 1);
+var import_state = __toESM(require("./state"), 1);
+var import_registry = __toESM(require("./registry"), 1);
+__reExport(mixins_exports, require("./registry"), module.exports);

package/dist/cjs/element/mixins/registry.js

@@ -0,0 +1,89 @@
+"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 registry_exports = {};
+__export(registry_exports, {
+  default: () => registry_default,
+  parseFilters: () => parseFilters
+});
+module.exports = __toCommonJS(registry_exports);
+var import__ = require(".");
+var registry_default = {
+  attr: import__.attr,
+  style: import__.style,
+  text: import__.text,
+  html: import__.html,
+  content: import__.content,
+  data: import__.data,
+  class: import__.classList,
+  state: import__.state,
+  extend: {},
+  childExtend: {},
+  childExtendRecursive: {},
+  props: {},
+  path: {},
+  if: {},
+  define: {},
+  transform: {},
+  __ref: {},
+  __hash: {},
+  __text: {},
+  nextElement: {},
+  previousElement: {},
+  key: {},
+  tag: {},
+  query: {},
+  parent: {},
+  node: {},
+  set: {},
+  update: {},
+  setProps: {},
+  remove: {},
+  updateContent: {},
+  removeContent: {},
+  lookup: {},
+  spotByPath: {},
+  keys: {},
+  log: {},
+  parse: {},
+  parseDeep: {},
+  on: {},
+  component: {},
+  context: {},
+  $setStateCollection: {},
+  $setCollection: {},
+  $setPropsCollection: {}
+};
+const parseFilters = {
+  elementKeys: [
+    "tag",
+    "text",
+    "style",
+    "attr",
+    "class",
+    "state",
+    "props",
+    "data",
+    "content",
+    "html",
+    "on",
+    "key"
+  ],
+  propsKeys: ["__element", "update"],
+  stateKeys: []
+};

package/dist/cjs/element/mixins/state.js

@@ -0,0 +1,25 @@
+"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, {
+  default: () => state_default
+});
+module.exports = __toCommonJS(state_exports);
+var import_mixins = require("@domql/mixins");
+var state_default = import_mixins.state;

package/dist/cjs/element/mixins/style.js

@@ -0,0 +1,33 @@
+"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 style_exports = {};
+__export(style_exports, {
+  default: () => style_default
+});
+module.exports = __toCommonJS(style_exports);
+var import_utils = require("@domql/utils");
+var import_report = require("@domql/report");
+var style_default = (params, element, node) => {
+  if (params) {
+    if ((0, import_utils.isObject)(params))
+      (0, import_utils.map)(node.style, params, element);
+    else
+      (0, import_report.report)("HTMLInvalidStyles", params);
+  }
+};

package/dist/cjs/element/mixins/text.js

@@ -0,0 +1,57 @@
+"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 text_exports = {};
+__export(text_exports, {
+  asd: () => asd,
+  default: () => text_default
+});
+module.exports = __toCommonJS(text_exports);
+var import__ = require("..");
+var import_utils = require("@domql/utils");
+const asd = (param, element, node) => {
+  const prop = (0, import_utils.exec)(param, element);
+  if (element.tag === "string") {
+    node.nodeValue = prop;
+  } else if (param !== void 0 || param !== null) {
+    if (element.__text && element.__text.text !== prop)
+      return;
+    element.__text.text = prop;
+    if (element.__text.node)
+      element.__text.node.nodeValue = prop;
+    else
+      (0, import__.create)({ tag: "string", text: prop }, element, "__text");
+  }
+};
+var text_default = (param, element, node) => {
+  const prop = (0, import_utils.exec)(param, element);
+  if (element.tag === "string") {
+    if (element.text === prop)
+      return;
+    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
+      (0, import__.create)({ tag: "string", text: prop }, element, "__text");
+  }
+};

package/dist/cjs/element/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 { extend, props, state, childExtend, childProps, on } = element;
+  const hasComponentAttrs = extend || childExtend || props || state || on;
+  const componentKey = key.split("_")[0];
+  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;
+};