@domql/element 2.4.4 → 2.4.6

package/create.js

@@ -1,22 +1,23 @@
 'use strict'
 
+import createNode from './node'
+
 import { isObject, isFunction, isString, exec, is, isNode, isUndefined, createKey } from '@domql/utils'
 import { ROOT } from './tree'
 import { TAGS } from '@domql/registry'
 import { triggerEventOn } from '@domql/event'
 import { appendNode, assignNode } from '@domql/render'
-import { assignClass } from '@domql/classlist'
 import { cacheNode, detectTag } from '@domql/node'
 import { createState } from '@domql/state'
 
 import { isMethod } from './methods'
-
 import { createProps } from './props'
-
-import createNode from './node'
 import { applyExtend } from './extend'
 import { registry } from './mixins'
+import { addMethods } from './methods/set'
+import { assignClass } from './mixins/classList'
 import { throughInitialExec } from './iterate'
+
 import OPTIONS from './cache/options'
 
 import {
@@ -26,7 +27,6 @@ import {
   checkIfKeyIsComponent,
   isVariant
 } from './utils/component'
-import { addMethods } from './methods/set'
 
 const ENV = process.env.NODE_ENV
 
@@ -71,7 +71,7 @@ const create = (element, parent, key, options = OPTIONS.create || {}) => {
   }
 
   // define KEY
-  const assignedKey = (element.key || key || createKey()).toString()
+  const assignedKey = (key || element.key || createKey()).toString()
 
   if (checkIfKeyIsComponent(assignedKey)) {
     element = applyKeyComponentAsExtend(element, parent, assignedKey)

package/dist/cjs/create.js

@@ -31,23 +31,23 @@ __export(create_exports, {
   default: () => create_default
 });
 module.exports = __toCommonJS(create_exports);
+var import_node = __toESM(require("./node"), 1);
 var import_utils = require("@domql/utils");
 var import_tree = require("./tree");
 var import_registry = require("@domql/registry");
 var import_event = require("@domql/event");
 var import_render = require("@domql/render");
-var import_classlist = require("@domql/classlist");
-var import_node = require("@domql/node");
+var import_node2 = require("@domql/node");
 var import_state = require("@domql/state");
 var import_methods = require("./methods");
 var import_props = require("./props");
-var import_node2 = __toESM(require("./node"), 1);
 var import_extend = require("./extend");
 var import_mixins = require("./mixins");
+var import_set = require("./methods/set");
+var import_classList = require("./mixins/classList");
 var import_iterate = require("./iterate");
 var import_options = __toESM(require("./cache/options"), 1);
 var import_component = require("./utils/component");
-var import_set = require("./methods/set");
 const ENV = "development";
 const create = (element, parent, key, options = import_options.default.create || {}) => {
   if (options && !import_options.default.create) {
@@ -80,7 +80,7 @@ const create = (element, parent, key, options = import_options.default.create ||
   if (checkIfPrimitive(element)) {
     element = applyValueAsText(element, parent, key);
   }
-  const assignedKey = (element.key || key || (0, import_utils.createKey)()).toString();
+  const assignedKey = (key || element.key || (0, import_utils.createKey)()).toString();
   if ((0, import_component.checkIfKeyIsComponent)(assignedKey)) {
     element = (0, import_component.applyKeyComponentAsExtend)(element, parent, assignedKey);
   }
@@ -121,7 +121,7 @@ const create = (element, parent, key, options = import_options.default.create ||
   if (initReturns === false)
     return element;
   (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
-  (0, import_classlist.assignClass)(element);
+  (0, import_classList.assignClass)(element);
   renderElement(element, parent, options);
   if (parent.__ref && parent.__ref.__children)
     parent.__ref.__children.push(element.key);
@@ -130,7 +130,7 @@ const create = (element, parent, key, options = import_options.default.create ||
 };
 const renderElement = (element, parent, options) => {
   const { __ref: ref, key } = element;
-  (0, import_node2.default)(element, options);
+  (0, import_node.default)(element, options);
   if (!ref.__if)
     return element;
   (0, import_render.assignNode)(element, parent, key);
@@ -160,7 +160,7 @@ const checkIf = (element, parent) => {
   if ((0, import_utils.isFunction)(element.if)) {
     const ifPassed = element.if(element, element.state);
     if (!ifPassed) {
-      const ifFragment = (0, import_node.cacheNode)({ tag: "fragment" });
+      const ifFragment = (0, import_node2.cacheNode)({ tag: "fragment" });
       ref.__ifFragment = (0, import_render.appendNode)(ifFragment, parent.node);
       delete ref.__if;
     } else
@@ -202,7 +202,7 @@ const addCaching = (element, parent) => {
 };
 const resolveExtends = (element, parent, options) => {
   const { __ref } = element;
-  element.tag = (0, import_node.detectTag)(element);
+  element.tag = (0, import_node2.detectTag)(element);
   if (!__ref.__exec)
     __ref.__exec = {};
   if (!__ref.__attr)

package/dist/cjs/extend.js

@@ -50,7 +50,7 @@ const applyExtend = (element, parent, options = {}) => {
         return;
       childExtendStack = (0, import_utils2.getExtendStack)(parent.childExtend);
       if (parent.childExtendRecursive) {
-        const canExtendRecursive = !(props == null ? void 0 : props.ignoreChildExtendRecursive) && element.key !== "__text";
+        const canExtendRecursive = !props.ignoreChildExtendRecursive && element.key !== "__text";
         if (canExtendRecursive) {
           const childExtendRecursiveStack = (0, import_utils2.getExtendStack)(parent.childExtendRecursive);
           childExtendStack = childExtendStack.concat(childExtendRecursiveStack);

package/dist/cjs/set.js

@@ -39,8 +39,9 @@ var import_content = require("./mixins/content");
 const set = function(params, options = {}, el) {
   const element = el || this;
   const __contentRef = element.content && element.content.__ref;
-  if (__contentRef && __contentRef.__cached && (0, import_utils.isEqualDeep)(params, element.content))
+  if (__contentRef && __contentRef.__cached && (0, import_utils.isEqualDeep)(params, element.content)) {
     return element;
+  }
   (0, import_content.removeContent)(element);
   if (params) {
     const { childExtend } = params;

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

@@ -1,6 +1,6 @@
 "use strict";
-var import_element = require("../../src/element");
-const dom = (0, import_element.create)({});
+var import__ = require("../");
+const dom = (0, import__.create)({});
 test("should create EMPTY element", () => {
   expect(dom).toHaveProperty("key");
   expect(dom).toHaveProperty("state");
@@ -18,30 +18,30 @@ test("must be able to create valid PATH", () => {
 });
 test("if it HAS a NODE, don't recreate", () => {
   const node = document.createElement("div");
-  const dom2 = (0, import_element.create)({ node });
+  const dom2 = (0, import__.create)({ node });
   expect(dom2.node.parentElement).toBe(document.body);
 });
 test("create with number", () => {
-  const numb = (0, import_element.create)(0);
+  const numb = (0, import__.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");
+  const str = (0, import__.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)({
+  const element = (0, import__.create)({
     data: { visible: true },
     if: (element2) => element2.data.visible
   });
   expect(element.tag).toBe("div");
 });
 test("creating nesting", () => {
-  const element = (0, import_element.create)({
+  const element = (0, import__.create)({
     header: {
       h1: {}
     }

package/dist/cjs/test/isMethod.test.js

@@ -0,0 +1,28 @@
+const { isMethod, METHODS } = require("../dist/cjs");
+describe("isMethod", () => {
+  test("returns true if parameter is a method", () => {
+    const validMethod = "set";
+    const result = isMethod(validMethod);
+    expect(result).toBe(true);
+  });
+  test("returns false if parameter is not a method", () => {
+    const invalidMethod = "invalidMethod";
+    const result = isMethod(invalidMethod);
+    expect(result).toBe(false);
+  });
+  test("returns false if parameter is not a string", () => {
+    const invalidParam = 123;
+    const result = isMethod(invalidParam);
+    expect(result).toBe(false);
+  });
+  test("returns true if parameter is a valid method in the METHODS array", () => {
+    const validMethod = METHODS[0];
+    const result = isMethod(validMethod);
+    expect(result).toBe(true);
+  });
+  test("returns false if parameter is not a valid method in the METHODS array", () => {
+    const invalidMethod = "invalidMethod";
+    const result = isMethod(invalidMethod);
+    expect(result).toBe(false);
+  });
+});

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

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

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

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

package/extend.js

@@ -45,7 +45,7 @@ export const applyExtend = (element, parent, options = {}) => {
 
       // if (parent.childExtendRecursive && (props && !props.ignoreChildExtendRecursive)) {
       if (parent.childExtendRecursive) {
-        const canExtendRecursive = !props?.ignoreChildExtendRecursive && element.key !== '__text'
+        const canExtendRecursive = !props.ignoreChildExtendRecursive && element.key !== '__text'
         if (canExtendRecursive) {
           const childExtendRecursiveStack = getExtendStack(parent.childExtendRecursive)
           // add error if childExtendRecursive contains element which goes to infinite loop

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/element",
-  "version": "2.4.4",
+  "version": "2.4.6",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
@@ -31,7 +31,7 @@
     "@domql/state": "latest",
     "@domql/utils": "latest"
   },
-  "gitHead": "7cd7195bfa99a253070a8db387483bb28720bf39",
+  "gitHead": "7d5af56fe712bac2369db9e07e8ec70df585764e",
   "devDependencies": {
     "@babel/core": "^7.12.0"
   }

package/set.js

@@ -11,7 +11,9 @@ const set = function (params, options = {}, el) {
   const element = el || this
   const __contentRef = element.content && element.content.__ref
 
-  if (__contentRef && __contentRef.__cached && isEqualDeep(params, element.content)) return element
+  if (__contentRef && __contentRef.__cached && isEqualDeep(params, element.content)) {
+    return element
+  }
   removeContent(element)
 
   if (params) {

package/test/create.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-import { create } from '../../src/element'
+import { create } from '../'
 
 const dom = create({})
 

package/test/isMethod.test.js

@@ -0,0 +1,38 @@
+const { isMethod, METHODS } = require('../dist/cjs')
+
+describe('isMethod', () => {
+  test('returns true if parameter is a method', () => {
+    const validMethod = 'set'
+    const result = isMethod(validMethod)
+
+    expect(result).toBe(true)
+  })
+
+  test('returns false if parameter is not a method', () => {
+    const invalidMethod = 'invalidMethod'
+    const result = isMethod(invalidMethod)
+
+    expect(result).toBe(false)
+  })
+
+  test('returns false if parameter is not a string', () => {
+    const invalidParam = 123
+    const result = isMethod(invalidParam)
+
+    expect(result).toBe(false)
+  })
+
+  test('returns true if parameter is a valid method in the METHODS array', () => {
+    const validMethod = METHODS[0]
+    const result = isMethod(validMethod)
+
+    expect(result).toBe(true)
+  })
+
+  test('returns false if parameter is not a valid method in the METHODS array', () => {
+    const invalidMethod = 'invalidMethod'
+    const result = isMethod(invalidMethod)
+
+    expect(result).toBe(false)
+  })
+})

package/test/set.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-import { create } from '../../src/element'
+import { create } from '../'
 
 const element = create({})
 

package/test/update.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-import { create } from '../../src/element'
+import { create } from '../'
 
 const element = create({})