@domql/element 3.0.7 → 3.1.1

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

@@ -0,0 +1,62 @@
+import { update } from "../update";
+describe("update() with inheritStateUpdates", () => {
+  let element, options;
+  beforeEach(() => {
+    element = {
+      __ref: {
+        __state: null,
+        __hasRootState: false,
+        __execProps: {},
+        __props: []
+      },
+      state: {
+        calculated: 42,
+        set: () => {
+          return true;
+        }
+      },
+      parent: {
+        state: { baseState: true },
+        props: {}
+      },
+      props: {},
+      key: "testKey"
+    };
+    options = {};
+  });
+  it("processes full update flow when state is inherited", async () => {
+    await update.call(element, { props: { newProp: true } }, options);
+    expect(element.props.newProp).toBe(true);
+    expect(element.state.baseState).toBe(true);
+  });
+  it("maintains state when preventInheritedStateUpdate=true", async () => {
+    options.preventInheritedStateUpdate = true;
+    element.state = { existing: "state" };
+    await update.call(element, {}, options);
+    expect(element.state).toEqual({ baseState: true });
+  });
+  it("overwrites state with function result", async () => {
+    element.__ref.__state = () => ({ calculated: 42 });
+    options.execStateFunction = true;
+    options.stateFunctionOverwrite = true;
+    await update.call(element, {}, options);
+    expect(element.state.calculated).toEqual(42);
+  });
+  it("preserves state when beforeStateUpdate rejects", async () => {
+    element.onBeforeStateUpdate = () => false;
+    await update.call(element, { props: { shouldChange: true } }, options);
+    expect(element.state).toEqual({ baseState: true });
+    expect(element.props.shouldChange).toBe(true);
+  });
+  it("reflects parent state updates", async () => {
+    element.parent.state = { updatedParentState: true };
+    await update.call(element, {}, options);
+    expect(element.state.updatedParentState).toBe(true);
+  });
+  it("preserves local state when __hasRootState=true", async () => {
+    element.__ref.__hasRootState = true;
+    element.state = { local: "data" };
+    await update.call(element, {}, options);
+    expect(element.state.local).toBe("data");
+  });
+});

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

@@ -0,0 +1,116 @@
+import { jest } from "@jest/globals";
+describe("create()", () => {
+  let props;
+  let parent;
+  const OLD_ENV = process.env;
+  beforeEach(() => {
+    props = {
+      __ref: { __if: false, path: [], __skipCreate: true },
+      key: "testKey",
+      context: {
+        defaultExtends: {},
+        define: ["test"]
+      },
+      scope: "props",
+      define: ["test"]
+    };
+    parent = {
+      testKey: "parentTestKey",
+      key: "parentKey"
+    };
+    jest.resetModules();
+    process.env = { ...OLD_ENV };
+  });
+  afterAll(() => {
+    process.env = OLD_ENV;
+  });
+  test("should execute onlyResolveExtends when __skipCreate is true", async () => {
+    props.__ref.__skipCreate = true;
+    props.scope = void 0;
+    const { create } = await import("../create");
+    await create(props, parent, "passedKey", {
+      onlyResolveExtends: true,
+      define: ["test"]
+    });
+    expect(parent.__ref).toBeUndefined();
+    expect(parent.passedKey).toBe(props.__ref.parent.passedKey);
+  });
+  test("should execute onlyResolveExtends when __ref.__if is true", async () => {
+    props.__ref.__if = true;
+    props.scope = "state";
+    const { create } = await import("../create");
+    await create(props, parent, "passedKey", {
+      onlyResolveExtends: true,
+      define: ["test"]
+    });
+    expect(parent.__ref).toBeUndefined();
+    expect(parent.passedKey).toBe(props.__ref.parent.passedKey);
+  });
+  test("should execute onlyResolveExtends when scope is not state", async () => {
+    process.env.NODE_ENV = "prod";
+    props.__ref = void 0;
+    const { create } = await import("../create");
+    await create(props, parent, "passedKey", { onlyResolveExtends: true });
+    expect(parent.__ref).toBeUndefined();
+    expect(parent.passedKey).toBe(props.__ref.parent.passedKey);
+  });
+  test("should execute catch statement when __ref is undefined", async () => {
+    process.env.NODE_ENV = "prod";
+    props.__ref = void 0;
+    const { create } = await import("../create");
+    await create(props, parent, "passedKey");
+    expect(parent.__ref).toBeUndefined();
+    expect(parent.passedKey).toBe(props.__ref.parent.passedKey);
+  });
+  test("should attaches element to parent when ref.__if is false", async () => {
+    process.env.NODE_ENV = "prod";
+    const { create } = await import("../create");
+    await create(props, parent, "passedKey");
+    expect(parent.__ref).toBeUndefined();
+    expect(parent.passedKey).toBe(props.__ref.parent.passedKey);
+  });
+  test("should attach element to parent when ref.__if is true", async () => {
+    process.env.NODE_ENV = "prod";
+    props.__if = true;
+    const { create } = await import("../create");
+    await create(props, parent, "passedKey");
+    expect(parent.testKey).toBe("parentTestKey");
+    expect(parent.passedKey).toBe(props.__ref.parent.passedKey);
+  });
+  test("skips createNestedChild when __uniqId exists", async () => {
+    process.env.NODE_ENV = "prod";
+    props.__ref = { __uniqId: "existing-id", path: [] };
+    const { create } = await import("../create");
+    await create(props, {}, "passedKey");
+    expect(props.__ref.__uniqId).toBeDefined();
+  });
+  test("skips createNestedChild when infinite loop detected", async () => {
+    process.env.NODE_ENV = "prod";
+    props.__ref = { path: ["loop-path"], __uniqId: void 0 };
+    const { create } = await import("../create");
+    await create(props, {}, "passedKey");
+    expect(props.__ref.__uniqId).toBeDefined();
+  });
+  test("should modifies path containing ComponentsGrid", async () => {
+    process.env.NODE_ENV = "prod";
+    props.__ref = { path: ["ComponentsGrid", "x", "y", "z"] };
+    const { create } = await import("../create");
+    await create(props, {}, ["ComponentsGrid", "x", "y", "z"]);
+    expect(props.__ref.path).toEqual(["ComponentsGrid,x,y,z"]);
+  });
+  test("should modifies path containing demoComponent", async () => {
+    process.env.NODE_ENV = "prod";
+    props.__ref = { path: ["demoComponent", "a", "b", "c"] };
+    const { create } = await import("../create");
+    await create(props, {}, ["demoComponent", "a", "b", "c"]);
+    expect(props.__ref.path).toEqual(["demoComponent,a,b,c"]);
+  });
+  test("uses element.key when key property is missing", async () => {
+    process.env.NODE_ENV = "prod";
+    props.__ref = { __if: false, path: [] };
+    props.key = "fallbackKey";
+    const { create } = await import("../create");
+    await create(props, parent, null);
+    expect(props.__ref.parent.fallbackKey).toBeDefined();
+  });
+});

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

@@ -0,0 +1,35 @@
+import { resetContent } from "../set";
+describe("resetContent", () => {
+  let element, ref;
+  beforeEach(() => {
+    ref = {
+      contentElementKey: "content"
+    };
+    element = {
+      __ref: ref,
+      content: { node: document.createElement("div") },
+      node: document.createElement("div"),
+      context: {}
+    };
+  });
+  it("should update contentElementKey from options", async () => {
+    await resetContent({}, element, { contentElementKey: "mainContent" });
+    expect(ref.contentElementKey).toBe("mainContent");
+    expect(element.mainContent).toBeDefined();
+  });
+  it("should merge options correctly", async () => {
+    await resetContent({}, element, { customOption: true });
+    expect(element.content).toEqual(
+      expect.objectContaining({
+        // Verify options merging through observable behavior
+        // (this assertion pattern would need actual create() implementation details)
+      })
+    );
+  });
+  it("should maintain context through reset", async () => {
+    const originalContext = element.context;
+    await resetContent({}, element, {});
+    expect(element.context).toBe(originalContext);
+    expect(element.content.context).toBe(originalContext);
+  });
+});

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

@@ -0,0 +1,256 @@
+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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,73 @@
+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");
+  });
+});