@domql/element 3.0.1 → 3.0.6

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

@@ -1,62 +0,0 @@
-var import_update = require("../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 import_update.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 import_update.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 import_update.update.call(element, {}, options);
-    expect(element.state.calculated).toEqual(42);
-  });
-  it("preserves state when beforeStateUpdate rejects", async () => {
-    element.props.onBeforeStateUpdate = () => false;
-    await import_update.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 import_update.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 import_update.update.call(element, {}, options);
-    expect(element.state.local).toBe("data");
-  });
-});

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

@@ -1,138 +0,0 @@
-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 __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(
-  // 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 import_globals = require("@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"
-    };
-    import_globals.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/cjs/__tests__/resetElement.test.js

@@ -1,35 +0,0 @@
-var import_set = require("../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 (0, import_set.resetContent)({}, element, { contentElementKey: "mainContent" });
-    expect(ref.contentElementKey).toBe("mainContent");
-    expect(element.mainContent).toBeDefined();
-  });
-  it("should merge options correctly", async () => {
-    await (0, import_set.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 (0, import_set.resetContent)({}, element, {});
-    expect(element.context).toBe(originalContext);
-    expect(element.content.context).toBe(originalContext);
-  });
-});

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

@@ -1,256 +0,0 @@
-var import_globals = require("@jest/globals");
-var import_set = require("../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 import_set.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 import_set.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 import_set.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 import_set.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 import_set.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 import_set.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 import_set.set.call(element, { node: newNode });
-    expect(element.node.tagName).toBe("DIV");
-  });
-  it("resolves context components in params", async () => {
-    element.context.components = { Header: {} };
-    await import_set.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 import_set.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 import_set.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: import_globals.jest.fn()
-    };
-    element.node.appendChild(content);
-    await import_set.set.call(element, { props: { new: true } });
-    expect(element.content.__ref).toBeDefined();
-    expect(element.node.contains(content)).toBeFalsy();
-  });
-  it("handles lazy loading with requestAnimationFrame", async () => {
-    import_globals.jest.useFakeTimers();
-    element.props = { lazyLoad: true };
-    const params = { props: { test: true } };
-    await import_set.set.call(element, params);
-    import_globals.jest.runAllTimers();
-    setTimeout(() => {
-      expect(element.content).toBeDefined();
-    }, 35);
-    import_globals.jest.useRealTimers();
-  });
-  it("handles fragment content removal correctly", async () => {
-    const remove1 = import_globals.jest.fn(() => Promise.resolve());
-    const remove2 = import_globals.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 import_set.set.call(element, { props: { new: true } });
-    expect(remove1).toHaveBeenCalled();
-    expect(remove2).toHaveBeenCalled();
-  });
-  it("handles fragment content removal with children", async () => {
-    const remove1 = import_globals.jest.fn();
-    const remove2 = import_globals.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 import_set.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 import_set.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 import_set.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 = (0, import_set.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 = (0, import_set.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 = (0, import_set.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 = (0, import_set.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);
-    (0, import_set.removeContent)(element);
-    expect(element.content).toBeUndefined();
-    expect(element.node.children.length).toBe(0);
-  });
-  test("removes fragment content", () => {
-    const remove1 = import_globals.jest.fn();
-    const remove2 = import_globals.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 }
-    };
-    (0, import_set.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);
-    (0, import_set.removeContent)(element, { contentElementKey: "customContent" });
-    expect(element.customContent).toBeUndefined();
-    expect(element.node.children.length).toBe(0);
-  });
-});

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

@@ -1,62 +0,0 @@
-var import_iterate = require("../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", () => {
-    element.props.isActive = () => true;
-    element.props.hasFeature = (el, state) => state.test === "state";
-    (0, import_iterate.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", () => {
-    ref.__execProps.value = () => "cached";
-    element.props.value = "current";
-    (0, import_iterate.throughExecProps)(element);
-    expect(element.props.value).toBe("cached");
-  });
-  it("should leave non-function props unchanged", () => {
-    element.props.title = "static text";
-    element.props.disabled = false;
-    (0, import_iterate.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", () => {
-    element.props.useHelper = () => "helper";
-    element.props.color = "blue";
-    (0, import_iterate.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", () => {
-    ref.__execProps.existing = () => "prior";
-    element.props.existing = "new";
-    (0, import_iterate.throughExecProps)(element);
-    expect(element.props.existing).toBe("prior");
-    expect(ref.__execProps.existing).toBeInstanceOf(Function);
-  });
-  it("should pass correct execution context", () => {
-    element.props.checkContext = function(el, state, context) {
-      return this === element && state === element.state && context === element.context;
-    };
-    (0, import_iterate.throughExecProps)(element);
-    expect(typeof element.props.checkContext).toBe("function");
-  });
-});

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

@@ -1,79 +0,0 @@
-var import_iterate = require("../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", () => {
-    element.define = { localProp: () => "local" };
-    element.context.define = { globalProp: () => "global" };
-    (0, import_iterate.throughInitialDefine)(element);
-    expect(element.localProp).toBe("local");
-    expect(element.globalProp).toBe("global");
-  });
-  it("should cache and execute define functions", () => {
-    element.define.testProp = (value) => "defined value";
-    element.testProp = () => "initial value";
-    (0, import_iterate.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", () => {
-    element.define.update = (value) => "should not execute";
-    element.update = () => "built-in method";
-    (0, import_iterate.throughInitialDefine)(element);
-    expect(ref.__exec).not.toHaveProperty("update");
-    expect(ref.__defineCache).not.toHaveProperty("update");
-  });
-  it("should handle parse method in execution result", () => {
-    element.define.testProp = () => ({ parse: () => "parsed value" });
-    element.testProp = () => "initial value";
-    (0, import_iterate.throughInitialDefine)(element);
-    expect(ref.__defineCache.testProp).toBe("initial value");
-  });
-  it("should pass correct arguments to define functions", () => {
-    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";
-    (0, import_iterate.throughInitialDefine)(element);
-    expect(element.testProp).toEqual({
-      valueMatch: true,
-      elMatch: true,
-      stateMatch: true,
-      contextMatch: true
-    });
-  });
-  it("should handle non-function element properties", () => {
-    element.define.testProp = (value) => "defined value";
-    element.testProp = "non-function value";
-    (0, import_iterate.throughInitialDefine)(element);
-    expect(element.testProp).toBe("defined value");
-  });
-  it("should handle empty define objects", () => {
-    (0, import_iterate.throughInitialDefine)(element);
-    expect(element).toEqual({
-      ...element,
-      __ref: ref
-    });
-  });
-  it("should handle null or undefined define properties", () => {
-    element.define.testProp = () => null;
-    element.testProp = "initial value";
-    (0, import_iterate.throughInitialDefine)(element);
-    expect(element.testProp).toBe("initial value");
-  });
-});