@domql/element 3.1.1 → 3.2.3

package/dist/esm/__tests__/set.test.js

@@ -1,256 +0,0 @@
-import { jest } from "@jest/globals";
-import { removeContent, set, setContentKey } from "../set";
-describe("set", () => {
-  let element, ref;
-  beforeEach(() => {
-    ref = {
-      contentElementKey: "content",
-      __noChildrenDifference: false
-    };
-    element = {
-      __ref: ref,
-      props: {},
-      children: [],
-      context: { components: {} },
-      state: {},
-      node: document.createElement("div"),
-      childExtends: {},
-      parent: { node: document.createElement("div") }
-    };
-  });
-  it("updates element.props when params.props are provided", async () => {
-    await set.call(element, { props: { title: "New Title" } });
-    expect(element.content.props.title).toBe("New Title");
-  });
-  it("skips update when deepContains matches existing content", async () => {
-    ref.__noChildrenDifference = true;
-    const originalProps = { ...element.props };
-    await set.call(element, { props: { id: "same" } });
-    expect(element.props).toEqual(originalProps);
-  });
-  it("merges element.childExtends into params when missing", async () => {
-    element.childExtends = { button: "PrimaryButton" };
-    const params = { tag: "fragment", props: {} };
-    await set.call(element, params);
-    expect(params.childExtends).toEqual({ button: "PrimaryButton" });
-    expect(params.props.ignoreChildExtends).toBe(true);
-  });
-  it("preserves content when preventContentUpdate=true and no children", async () => {
-    const originalContent = element[ref.contentElementKey];
-    await set.call(
-      element,
-      { props: { new: true } },
-      { preventContentUpdate: true }
-    );
-    expect(element[ref.contentElementKey]).toBeDefined();
-    expect(originalContent).toBeUndefined();
-  });
-  it("copies element.props.childProps into params when missing", async () => {
-    element.props.childProps = { size: "large" };
-    const params = { tag: "fragment", props: {} };
-    await set.call(element, params);
-    expect(params.props.childProps).toEqual({ size: "large" });
-    expect(params.props.ignoreChildProps).toBe(true);
-  });
-  it("preserves state when beforeUpdate returns false", async () => {
-    ref.__noChildrenDifference = true;
-    const originalState = { ...element.state };
-    await set.call(element, { state: { shouldChange: true } });
-    expect(element.state).toEqual(originalState);
-  });
-  it("updates node reference when provided in params", async () => {
-    const newNode = document.createElement("section");
-    await set.call(element, { node: newNode });
-    expect(element.node.tagName).toBe("DIV");
-  });
-  it("resolves context components in params", async () => {
-    element.context.components = { Header: {} };
-    await set.call(element, { Header: {} });
-    expect(element.Header).toBeUndefined();
-  });
-  it("updates nested props without mutating original", async () => {
-    const originalProps = { nested: { value: 1 } };
-    element.props = originalProps;
-    await set.call(element, { props: { nested: { value: 2 } } });
-    expect(element.props.nested.value).toBe(1);
-    expect(originalProps.nested.value).toBe(1);
-  });
-  it("preserves existing props when params=null", async () => {
-    element.props = { preserveMe: true };
-    await set.call(element, null);
-    expect(element.props.preserveMe).toBe(true);
-  });
-  it("removes content correctly when calling removeContent", async () => {
-    const content = document.createElement("div");
-    element.content = {
-      node: content,
-      tag: "div",
-      remove: jest.fn()
-    };
-    element.node.appendChild(content);
-    await set.call(element, { props: { new: true } });
-    expect(element.content.__ref).toBeDefined();
-    expect(element.node.contains(content)).toBeFalsy();
-  });
-  it("handles lazy loading with requestAnimationFrame", async () => {
-    jest.useFakeTimers();
-    element.props = { lazyLoad: true };
-    const params = { props: { test: true } };
-    await set.call(element, params);
-    jest.runAllTimers();
-    setTimeout(() => {
-      expect(element.content).toBeDefined();
-    }, 35);
-    jest.useRealTimers();
-  });
-  it("handles fragment content removal correctly", async () => {
-    const remove1 = jest.fn(() => Promise.resolve());
-    const remove2 = jest.fn(() => Promise.resolve());
-    const node1 = document.createElement("div");
-    const node2 = document.createElement("div");
-    element.tag = "fragment";
-    element.content = {
-      tag: "fragment",
-      node: element.node,
-      __ref: {
-        __children: ["child1", "child2"]
-      },
-      child1: { node: node1, remove: remove1 },
-      child2: { node: node2, remove: remove2 }
-    };
-    element.node.appendChild(node1);
-    element.node.appendChild(node2);
-    await set.call(element, { props: { new: true } });
-    expect(remove1).toHaveBeenCalled();
-    expect(remove2).toHaveBeenCalled();
-  });
-  it("handles fragment content removal with children", async () => {
-    const remove1 = jest.fn();
-    const remove2 = jest.fn();
-    const node1 = document.createElement("div");
-    const node2 = document.createElement("div");
-    element.content = {
-      tag: "fragment",
-      node: element.node,
-      __ref: {
-        __children: ["child1", "child2"]
-      },
-      child1: { node: node1, remove: remove1 },
-      child2: { node: node2, remove: remove2 }
-    };
-    element.node.appendChild(node1);
-    element.node.appendChild(node2);
-    await set.call(element, { props: { new: true } });
-    expect(remove1).toHaveBeenCalled();
-    expect(remove2).toHaveBeenCalled();
-  });
-  it("merges element.childExtends into params when tag is fragment", async () => {
-    element.tag = "fragment";
-    element.childExtends = { button: "PrimaryButton" };
-    const params = { tag: "fragment", props: {} };
-    await set.call(element, params);
-    expect(params.childExtends).toEqual(element.childExtends);
-  });
-  it("copies element.props.childProps into params for fragments", async () => {
-    element.tag = "fragment";
-    element.props.childProps = { size: "large" };
-    const params = { tag: "fragment", props: {} };
-    await set.call(element, params);
-    expect(params.props.childProps).toEqual(element.props.childProps);
-  });
-});
-describe("setContentKey", () => {
-  test("should set default content key", () => {
-    const element = {
-      __ref: {}
-    };
-    const result = setContentKey(element);
-    expect(result).toBe("content");
-    expect(element.__ref.contentElementKey).toBe("content");
-  });
-  test("should set custom content key", () => {
-    const element = {
-      __ref: {}
-    };
-    const opts = { contentElementKey: "customContent" };
-    const result = setContentKey(element, opts);
-    expect(result).toBe("customContent");
-    expect(element.__ref.contentElementKey).toBe("customContent");
-  });
-  test("should not override existing content key if same value", () => {
-    const element = {
-      __ref: {
-        contentElementKey: "content"
-      }
-    };
-    const result = setContentKey(element);
-    expect(result).toBe("content");
-    expect(element.__ref.contentElementKey).toBe("content");
-  });
-  test("should override existing content key if different value", () => {
-    const element = {
-      __ref: {
-        contentElementKey: "oldContent"
-      }
-    };
-    const opts = { contentElementKey: "newContent" };
-    const result = setContentKey(element, opts);
-    expect(result).toBe("newContent");
-    expect(element.__ref.contentElementKey).toBe("newContent");
-  });
-});
-describe("removeContent", () => {
-  let element;
-  beforeEach(() => {
-    element = {
-      node: document.createElement("div"),
-      __ref: {}
-    };
-  });
-  test("removes basic content", () => {
-    const contentNode = document.createElement("span");
-    element.content = {
-      node: contentNode,
-      tag: "span"
-    };
-    element.node.appendChild(contentNode);
-    removeContent(element);
-    expect(element.content).toBeUndefined();
-    expect(element.node.children.length).toBe(0);
-  });
-  test("removes fragment content", () => {
-    const remove1 = jest.fn();
-    const remove2 = jest.fn();
-    const node1 = document.createElement("div");
-    const node2 = document.createElement("div");
-    const fragmentNode = document.createElement("div");
-    fragmentNode.setAttribute("fragment", "");
-    element.node.appendChild(node1);
-    element.node.appendChild(node2);
-    element.content = {
-      tag: "fragment",
-      node: fragmentNode,
-      __ref: {
-        __children: ["child1", "child2"]
-      },
-      child1: { node: node1, remove: remove1 },
-      child2: { node: node2, remove: remove2 }
-    };
-    removeContent(element);
-    expect(remove1).toHaveBeenCalled();
-    expect(remove2).toHaveBeenCalled();
-    expect(element.content).toBeUndefined();
-    expect(element.node.children.length).toBe(0);
-  });
-  test("handles custom content element key", () => {
-    const contentNode = document.createElement("span");
-    element.customContent = {
-      node: contentNode,
-      tag: "span"
-    };
-    element.node.appendChild(contentNode);
-    removeContent(element, { contentElementKey: "customContent" });
-    expect(element.customContent).toBeUndefined();
-    expect(element.node.children.length).toBe(0);
-  });
-});

package/dist/esm/__tests__/throughExecProps.test.js

@@ -1,62 +0,0 @@
-import { throughExecProps } from "../iterate";
-describe("throughExecProps", () => {
-  let element, ref;
-  beforeEach(() => {
-    ref = {
-      __execProps: {}
-    };
-    element = {
-      __ref: ref,
-      props: {},
-      state: { test: "state" },
-      context: { test: "context" }
-    };
-  });
-  it("should cache and execute define-prefixed function props", async () => {
-    element.props.isActive = () => true;
-    element.props.hasFeature = (el, state) => state.test === "state";
-    await throughExecProps(element);
-    expect(element.props.isActive).toBe(true);
-    expect(element.props.hasFeature).toBe(true);
-    expect(ref.__execProps).toEqual({
-      isActive: expect.any(Function),
-      hasFeature: expect.any(Function)
-    });
-  });
-  it("should execute cached functions from previous runs", async () => {
-    ref.__execProps.value = () => "cached";
-    element.props.value = "current";
-    await throughExecProps(element);
-    expect(element.props.value).toBe("cached");
-  });
-  it("should leave non-function props unchanged", async () => {
-    element.props.title = "static text";
-    element.props.disabled = false;
-    await throughExecProps(element);
-    expect(element.props.title).toBe("static text");
-    expect(element.props.disabled).toBe(false);
-    expect(ref.__execProps).toEqual({});
-  });
-  it("should handle mixed define-prefixed and regular props", async () => {
-    element.props.useHelper = () => "helper";
-    element.props.color = "blue";
-    await throughExecProps(element);
-    expect(element.props.useHelper).toBe("helper");
-    expect(element.props.color).toBe("blue");
-    expect(ref.__execProps).toHaveProperty("useHelper");
-  });
-  it("should preserve existing cache entries", async () => {
-    ref.__execProps.existing = () => "prior";
-    element.props.existing = "new";
-    await throughExecProps(element);
-    expect(element.props.existing).toBe("prior");
-    expect(ref.__execProps.existing).toBeInstanceOf(Function);
-  });
-  it("should pass correct execution context", async () => {
-    element.props.checkContext = function(el, state, context) {
-      return this === element && state === element.state && context === element.context;
-    };
-    await throughExecProps(element);
-    expect(typeof element.props.checkContext).toBe("function");
-  });
-});

package/dist/esm/__tests__/throughInitialDefine.test.js

@@ -1,79 +0,0 @@
-import { throughInitialDefine } from "../iterate";
-describe("throughInitialDefine", () => {
-  let element, ref;
-  beforeEach(() => {
-    ref = {
-      __exec: {},
-      __defineCache: {}
-    };
-    element = {
-      __ref: ref,
-      define: {},
-      state: { testState: true },
-      context: { testContext: true }
-    };
-  });
-  it("should merge local and global define objects", async () => {
-    element.define = { localProp: () => "local" };
-    element.context.define = { globalProp: () => "global" };
-    await throughInitialDefine(element);
-    expect(element.localProp).toBe("local");
-    expect(element.globalProp).toBe("global");
-  });
-  it("should cache and execute define functions", async () => {
-    element.define.testProp = (value) => "defined value";
-    element.testProp = () => "initial value";
-    await throughInitialDefine(element);
-    expect(element.testProp).toBe("defined value");
-    expect(ref.__exec.testProp).toBeInstanceOf(Function);
-    expect(ref.__defineCache.testProp).toBe("initial value");
-  });
-  it("should skip execution for method properties", async () => {
-    element.define.update = (value) => "should not execute";
-    element.update = () => "built-in method";
-    await throughInitialDefine(element);
-    expect(ref.__exec).not.toHaveProperty("update");
-    expect(ref.__defineCache).not.toHaveProperty("update");
-  });
-  it("should handle parse method in execution result", async () => {
-    element.define.testProp = () => ({ parse: () => "parsed value" });
-    element.testProp = () => "initial value";
-    await throughInitialDefine(element);
-    expect(ref.__defineCache.testProp).toBe("initial value");
-  });
-  it("should pass correct arguments to define functions", async () => {
-    element.define.testProp = (value, el, state, context) => ({
-      valueMatch: value === "initial value",
-      elMatch: el === element,
-      stateMatch: state === element.state,
-      contextMatch: context === element.context
-    });
-    element.testProp = "initial value";
-    await throughInitialDefine(element);
-    expect(element.testProp).toEqual({
-      valueMatch: true,
-      elMatch: true,
-      stateMatch: true,
-      contextMatch: true
-    });
-  });
-  it("should handle non-function element properties", async () => {
-    element.define.testProp = (value) => "defined value";
-    element.testProp = "non-function value";
-    await throughInitialDefine(element);
-    expect(element.testProp).toBe("defined value");
-  });
-  it("should handle empty define objects", async () => {
-    await throughInitialDefine(element);
-    expect(element).toEqual({
-      ...element,
-      __ref: ref
-    });
-  });
-  it("should handle null or undefined define properties", async () => {
-    element.define.testProp = () => null;
-    element.testProp = "initial value";
-    await throughInitialDefine(element);
-    expect(element.testProp).toBe("initial value");
-  });
-});

package/dist/esm/__tests__/throughInitialExec.test.js

@@ -1,73 +0,0 @@
-import { throughInitialExec } from "../iterate";
-describe("throughInitialExec", () => {
-  let element, ref;
-  beforeEach(() => {
-    ref = { __exec: {} };
-    element = {
-      __ref: ref,
-      state: { testState: true },
-      context: { testContext: true },
-      // Default non-method function
-      customFn: () => "executed"
-    };
-  });
-  it("should process non-method functions and update element properties", async () => {
-    await throughInitialExec(element);
-    expect(element.customFn).toBe("executed");
-    expect(ref.__exec.customFn).toBeInstanceOf(Function);
-  });
-  it("should skip excluded parameters", async () => {
-    element.excludedFn = () => "should not execute";
-    await throughInitialExec(element, { excludedFn: true });
-    expect(element.excludedFn).toBeInstanceOf(Function);
-    expect(ref.__exec).not.toHaveProperty("excludedFn");
-  });
-  it("should skip methods from METHODS array", async () => {
-    element.update = () => "built-in method";
-    await throughInitialExec(element);
-    expect(element.update).toBeInstanceOf(Function);
-    expect(ref.__exec).not.toHaveProperty("update");
-  });
-  it("should skip methods from context.methods", async () => {
-    element.context.methods = { contextMethod: true };
-    element.contextMethod = () => "context method";
-    await throughInitialExec(element);
-    expect(element.contextMethod).toBeInstanceOf(Function);
-    expect(ref.__exec).not.toHaveProperty("contextMethod");
-  });
-  it("should leave non-function properties unchanged", async () => {
-    element.stringProp = "text";
-    await throughInitialExec(element);
-    expect(element.stringProp).toBe("text");
-    expect(ref.__exec).not.toHaveProperty("stringProp");
-  });
-  it("should store original functions in __exec", async () => {
-    const originalFn = () => "original";
-    element.testFn = originalFn;
-    await throughInitialExec(element);
-    expect(ref.__exec.testFn).toBe(originalFn);
-    expect(element.testFn).toBe("original");
-  });
-  it("should execute functions with correct arguments", async () => {
-    element.argChecker = (el, state, context) => ({
-      elIsElement: el === element,
-      stateMatch: state === element.state,
-      contextMatch: context === element.context
-    });
-    await throughInitialExec(element);
-    expect(element.argChecker).toEqual({
-      elIsElement: true,
-      stateMatch: true,
-      contextMatch: true
-    });
-  });
-  it("should handle empty exclude object", async () => {
-    element.fn1 = () => "one";
-    element.fn2 = () => "two";
-    await throughInitialExec(element, {});
-    expect(element.fn1).toBe("one");
-    expect(element.fn2).toBe("two");
-    expect(ref.__exec).toHaveProperty("fn1");
-    expect(ref.__exec).toHaveProperty("fn2");
-  });
-});

package/dist/esm/__tests__/throughUpdatedDefine.test.js

@@ -1,69 +0,0 @@
-import { throughUpdatedDefine } from "../iterate";
-describe("throughUpdatedDefine", () => {
-  let element, ref;
-  beforeEach(() => {
-    ref = {
-      __exec: {},
-      __defineCache: {}
-    };
-    element = {
-      __ref: ref,
-      define: {},
-      state: { testState: true },
-      context: { testContext: true }
-    };
-  });
-  it("should merge local and global define objects", async () => {
-    element.define = { localProp: () => "local" };
-    element.context.define = { globalProp: () => "global" };
-    await throughUpdatedDefine(element);
-    expect(element.localProp).toBe("local");
-    expect(element.globalProp).toBe("global");
-  });
-  it("should update element properties using cached exec functions", async () => {
-    ref.__exec.testProp = () => "cached value";
-    element.define.testProp = (cached) => `updated ${cached}`;
-    await throughUpdatedDefine(element);
-    expect(element.testProp).toBe("updated cached value");
-    expect(ref.__defineCache.testProp).toBe("cached value");
-  });
-  it("should handle non-function cached values", async () => {
-    ref.__defineCache.testProp = "static value";
-    element.define.testProp = (cached) => `updated ${cached}`;
-    await throughUpdatedDefine(element);
-    expect(element.testProp).toBe("updated static value");
-  });
-  it("should skip updates for undefined or null results", async () => {
-    ref.__exec.testProp = () => "cached value";
-    element.define.testProp = () => null;
-    element.testProp = "original value";
-    await throughUpdatedDefine(element);
-    expect(element.testProp).toBe("original value");
-  });
-  it("should handle empty define objects", async () => {
-    const originalElement = { ...element };
-    await throughUpdatedDefine(element);
-    expect(element).toEqual(originalElement);
-  });
-  it("should pass correct arguments to define functions", async () => {
-    element.define.testProp = (cached, el, state, context) => ({
-      cachedMatch: cached === "cached value",
-      elMatch: el === element,
-      stateMatch: state === element.state,
-      contextMatch: context === element.context
-    });
-    ref.__defineCache.testProp = "cached value";
-    await throughUpdatedDefine(element);
-    expect(element.testProp).toEqual({
-      cachedMatch: true,
-      elMatch: true,
-      stateMatch: true,
-      contextMatch: true
-    });
-  });
-  it("should return an empty changes object", async () => {
-    element.define.testProp = () => "updated value";
-    const changes = await throughUpdatedDefine(element);
-    expect(changes).toEqual({});
-  });
-});

package/dist/esm/__tests__/throughUpdatedExec.test.js

@@ -1,84 +0,0 @@
-import { throughUpdatedExec } from "../iterate";
-describe("throughUpdatedExec", () => {
-  let element, ref;
-  beforeEach(() => {
-    ref = {
-      __exec: {},
-      __defineCache: {}
-    };
-    element = {
-      __ref: ref,
-      state: { testState: true },
-      context: { testContext: true }
-    };
-  });
-  it("should skip execution for params in __defineCache", () => {
-    ref.__defineCache.cachedParam = true;
-    ref.__exec.cachedParam = () => "should not execute";
-    element.cachedParam = "original";
-    const changes = throughUpdatedExec(element);
-    expect(element.cachedParam).toBe("original");
-    expect(changes).toEqual({});
-  });
-  it("should update element properties when newExec differs from current value", () => {
-    ref.__exec.testParam = () => "new value";
-    element.testParam = "old value";
-    const changes = throughUpdatedExec(element);
-    expect(element.testParam).toBe("new value");
-    expect(changes).toEqual({ testParam: "old value" });
-  });
-  it("should overwrite text property for nodes when exec returns string or number", () => {
-    const node = { node: true, text: "old text" };
-    ref.__exec.testParam = () => "new text";
-    element.testParam = node;
-    const changes = throughUpdatedExec(element);
-    expect(element.testParam.text).toBe("new text");
-    expect(changes).toEqual({});
-  });
-  it("should handle component naming matches and overwrite with context component", () => {
-    const contextComponent = { extends: "Component", prop: "value" };
-    element.context.components = { TestComponent: contextComponent };
-    ref.__exec.TestComponent = () => contextComponent;
-    element.TestComponent = { oldProp: "oldValue" };
-    const changes = throughUpdatedExec(element);
-    expect(element.TestComponent).toEqual({
-      oldProp: "oldValue",
-      prop: "value"
-    });
-    expect(changes).toEqual({});
-  });
-  it("should not update element properties when newExec matches current value", () => {
-    ref.__exec.testParam = () => "same value";
-    element.testParam = "same value";
-    const changes = throughUpdatedExec(element);
-    expect(element.testParam).toBe("same value");
-    expect(changes).toEqual({});
-  });
-  it("should handle non-string/non-number exec returns for non-node properties", () => {
-    const newValue = { complex: "object" };
-    ref.__exec.testParam = () => newValue;
-    element.testParam = "old value";
-    const changes = throughUpdatedExec(element);
-    expect(element.testParam).toBe(newValue);
-    expect(changes).toEqual({ testParam: "old value" });
-  });
-  it("should return an empty changes object when no updates occur", () => {
-    ref.__exec.testParam = () => "same value";
-    element.testParam = "same value";
-    const changes = throughUpdatedExec(element);
-    expect(changes).toEqual({});
-  });
-  it("should handle multiple properties and return correct changes", () => {
-    ref.__exec.param1 = () => "new value 1";
-    ref.__exec.param2 = () => "new value 2";
-    element.param1 = "old value 1";
-    element.param2 = "old value 2";
-    const changes = throughUpdatedExec(element);
-    expect(element.param1).toBe("new value 1");
-    expect(element.param2).toBe("new value 2");
-    expect(changes).toEqual({
-      param1: "old value 1",
-      param2: "old value 2"
-    });
-  });
-});

package/dist/esm/__tests__/tree.test.js

@@ -1,11 +0,0 @@
-import { ROOT, TREE } from "../tree";
-describe("ROOT/TREE initialization and report()", () => {
-  it("initializes ROOT with :root key and document.body node", () => {
-    expect(ROOT.key).toBe(":root");
-    expect(ROOT.node).toBe(document.body);
-  });
-  it("assigns TREE to reference ROOT", () => {
-    expect(TREE).toBe(ROOT);
-    expect(TREE.node).toBe(document.body);
-  });
-});