@domql/element 2.4.1 → 2.4.3

package/dist/cjs/mixins/index.js

@@ -0,0 +1,52 @@
+"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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  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/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/mixins/state.js

@@ -0,0 +1,40 @@
+"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,
+  state: () => state
+});
+module.exports = __toCommonJS(state_exports);
+var import_state = require("@domql/state");
+var import_utils = require("@domql/utils");
+const state = (params, element, node) => {
+  const state2 = (0, import_utils.exec)(params, element);
+  if ((0, import_utils.isObject)(state2)) {
+    for (const param in state2) {
+      if (import_state.IGNORE_STATE_PARAMS.includes(param))
+        continue;
+      if (!state2.hasOwnProperty(param))
+        continue;
+      element.state[param] = (0, import_utils.exec)(state2[param], element);
+    }
+  }
+  return element;
+};
+var state_default = state;

package/dist/cjs/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/mixins/text.js

@@ -0,0 +1,60 @@
+"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) => {
+  let prop = (0, import_utils.exec)(param, element);
+  if ((0, import_utils.isString)(prop) && prop.includes("{{")) {
+    prop = (0, import_utils.replaceLiteralsWithObjectFields)(prop, element.state);
+  }
+  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/props/create.js

@@ -0,0 +1,77 @@
+"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 create_exports = {};
+__export(create_exports, {
+  createProps: () => createProps,
+  syncProps: () => syncProps
+});
+module.exports = __toCommonJS(create_exports);
+var import_utils = require("@domql/utils");
+var import_ignore = require("./ignore");
+var import_inherit = require("./inherit");
+const createPropsStack = (element, parent) => {
+  const { props, __ref } = element;
+  const propsStack = __ref.__props = (0, import_inherit.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.forEach((extend) => {
+      if (extend.props)
+        propsStack.push(extend.props);
+    });
+  }
+  __ref.__props = propsStack;
+  return propsStack;
+};
+const syncProps = (props, element) => {
+  element.props = {};
+  const mergedProps = { update, __element: element };
+  props.forEach((v) => {
+    if (import_ignore.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_utils.deepMerge)(
+      mergedProps,
+      (0, import_utils.deepClone)(execProps, import_ignore.IGNORE_PROPS_PARAMS),
+      import_ignore.IGNORE_PROPS_PARAMS
+    );
+  });
+  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;
+};
+function update(props, options) {
+  const element = this.__element;
+  element.update({ props }, options);
+}

package/dist/cjs/props/ignore.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 ignore_exports = {};
+__export(ignore_exports, {
+  IGNORE_PROPS_PARAMS: () => IGNORE_PROPS_PARAMS
+});
+module.exports = __toCommonJS(ignore_exports);
+const IGNORE_PROPS_PARAMS = ["update", "__element"];

package/dist/cjs/props/index.js

@@ -0,0 +1,21 @@
+"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 props_exports = {};
+module.exports = __toCommonJS(props_exports);
+__reExport(props_exports, require("./ignore"), module.exports);
+__reExport(props_exports, require("./create"), module.exports);
+__reExport(props_exports, require("./inherit"), module.exports);
+__reExport(props_exports, require("./update"), module.exports);

package/dist/cjs/props/inherit.js

@@ -0,0 +1,52 @@
+"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 inherit_exports = {};
+__export(inherit_exports, {
+  inheritParentProps: () => inheritParentProps
+});
+module.exports = __toCommonJS(inherit_exports);
+var import_utils = require("@domql/utils");
+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;
+};

package/dist/cjs/props/update.js

@@ -0,0 +1,37 @@
+"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 update_exports = {};
+__export(update_exports, {
+  updateProps: () => updateProps
+});
+module.exports = __toCommonJS(update_exports);
+var import_create = require("./create");
+var import_inherit = require("./inherit");
+const updateProps = (newProps, element, parent) => {
+  const { __ref } = element;
+  let propsStack = __ref.__props;
+  const parentProps = (0, import_inherit.inheritParentProps)(element, parent);
+  if (parentProps)
+    propsStack = __ref.__props = [].concat(parentProps, propsStack);
+  if (newProps)
+    propsStack = __ref.__props = [].concat(newProps, propsStack);
+  if (propsStack)
+    (0, import_create.syncProps)(propsStack, element);
+  return element;
+};

package/dist/cjs/test/create.test.js

@@ -0,0 +1,51 @@
+"use strict";
+var import_element = require("../../src/element");
+const dom = (0, import_element.create)({});
+test("should create EMPTY element", () => {
+  expect(dom).toHaveProperty("key");
+  expect(dom).toHaveProperty("state");
+  expect(dom).toHaveProperty("parent");
+  expect(dom).toHaveProperty("node");
+  expect(dom).toHaveProperty("set");
+  expect(dom).toHaveProperty("update");
+  expect(dom).toHaveProperty("__ref");
+});
+test("should create valid DOM node", () => {
+  expect(dom.node).toBeInstanceOf(window.HTMLDivElement);
+});
+test("must be able to create valid PATH", () => {
+  expect(dom.__ref.__path).toStrictEqual([dom.key]);
+});
+test("if it HAS a NODE, don't recreate", () => {
+  const node = document.createElement("div");
+  const dom2 = (0, import_element.create)({ node });
+  expect(dom2.node.parentElement).toBe(document.body);
+});
+test("create with number", () => {
+  const numb = (0, import_element.create)(0);
+  expect(numb.text).toBe(0);
+  expect(numb.tag).toBe("string");
+  expect(numb.node.nodeType).toBe(3);
+});
+test("create with string", () => {
+  const str = (0, import_element.create)("hello");
+  expect(str.text).toBe("hello");
+  expect(str.tag).toBe("string");
+  expect(str.node.nodeType).toBe(3);
+});
+test("creating conditions", () => {
+  const element = (0, import_element.create)({
+    data: { visible: true },
+    if: (element2) => element2.data.visible
+  });
+  expect(element.tag).toBe("div");
+});
+test("creating nesting", () => {
+  const element = (0, import_element.create)({
+    header: {
+      h1: {}
+    }
+  });
+  expect(element.header.tag).toBe("header");
+  expect(element.header.h1.tag).toBe("h1");
+});

package/dist/cjs/test/set.test.js

@@ -0,0 +1,9 @@
+"use strict";
+var import_element = require("../../src/element");
+const element = (0, import_element.create)({});
+test("should SET element", () => {
+  element.set({ text: "test" });
+  expect(element.content.text).toBe("test");
+  element.set({ text: "test2" });
+  expect(element.content.text).toBe("test2");
+});

package/dist/cjs/test/update.test.js

@@ -0,0 +1,8 @@
+"use strict";
+var import_element = require("../../src/element");
+const element = (0, import_element.create)({});
+test("should UPDATE element", () => {
+  expect(element.text).toBeUndefined();
+  element.update("test");
+  expect(element.text).toBe("test");
+});