@domql/element 2.5.200 → 3.0.0

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

@@ -0,0 +1,177 @@
+var import_globals = require("@jest/globals");
+var import_children = require("../children");
+describe("children", () => {
+  let element, node;
+  beforeEach(() => {
+    element = {
+      __ref: {},
+      state: {},
+      props: {},
+      call: import_globals.jest.fn(),
+      removeContent: import_globals.jest.fn(),
+      content: null
+    };
+    node = {};
+  });
+  it("handles null/undefined params", async () => {
+    const result = await (0, import_children.setChildren)(null, element, node);
+    expect(result).toBeUndefined();
+  });
+  it("handles direct string children", async () => {
+    const result = await (0, import_children.setChildren)("Hello World", element, node);
+    expect(result).toEqual({ tag: "fragment", 0: { text: "Hello World" } });
+  });
+  it("handles numeric children", async () => {
+    const result = await (0, import_children.setChildren)(42, element, node);
+    expect(result).toEqual({ tag: "fragment", 0: { text: 42 } });
+  });
+  it("handles array of primitive values with childrenAs prop", async () => {
+    const result = await (0, import_children.setChildren)(["one", "two"], element, node);
+    expect(result).toEqual({
+      tag: "fragment",
+      0: { text: "one" },
+      1: { text: "two" }
+    });
+  });
+  it("handles array of primitive values with childrenAs state", async () => {
+    element.props.childrenAs = "state";
+    const result = await (0, import_children.setChildren)(["one", "two"], element, node);
+    expect(result).toEqual({
+      tag: "fragment",
+      0: { state: { value: "one" } },
+      1: { state: { value: "two" } }
+    });
+  });
+  it("caches children and detects changes", async () => {
+    const children1 = [{ id: 1 }, { id: 2 }];
+    const children2 = [{ id: 1 }, { id: 2 }];
+    const children3 = [{ id: 1 }, { id: 3 }];
+    await (0, import_children.setChildren)(children1, element, node);
+    expect(element.__ref.__childrenCache).toEqual(children1);
+    expect(element.__ref.__noChildrenDifference).toBeUndefined();
+    await (0, import_children.setChildren)(children2, element, node);
+    expect(element.__ref.__noChildrenDifference).toBe(true);
+    await (0, import_children.setChildren)(children3, element, node);
+    expect(element.__ref.__noChildrenDifference).toBeUndefined();
+    expect(element.__ref.__childrenCache).toEqual(children3);
+  });
+  it("handles mixed React and normal components", async () => {
+    const mixedChildren = [
+      { type: "div", text: "Normal" },
+      { $$typeof: Symbol("react") },
+      { type: "span", text: "Another" }
+    ];
+    await (0, import_children.setChildren)(mixedChildren, element, node);
+    expect(element.call).toHaveBeenCalledWith(
+      "renderReact",
+      [mixedChildren[1]],
+      element
+    );
+  });
+  it("handles state-based children", async () => {
+    element.state = {
+      items: ["a", "b"],
+      parse: () => ["parsed a", "parsed b"]
+    };
+    const result = await (0, import_children.setChildren)("state", element, node);
+    expect(result).toEqual({
+      tag: "fragment",
+      0: { text: "parsed a" },
+      1: { text: "parsed b" }
+    });
+  });
+  it("handles async function parameters", async () => {
+    const asyncParam = async () => ["async1", "async2"];
+    const result = await (0, import_children.setChildren)(asyncParam, element, node);
+    expect(result).toEqual({
+      tag: "fragment",
+      0: { text: "async1" },
+      1: { text: "async2" }
+    });
+  });
+  it("handles nested object structures", async () => {
+    const nestedChildren = {
+      header: { text: "Title" },
+      content: {
+        nested: { text: "Content" }
+      }
+    };
+    const result = await (0, import_children.setChildren)(nestedChildren, element, node);
+    expect(result).toEqual({
+      tag: "fragment",
+      0: { text: "Title" },
+      1: { nested: { text: "Content" } }
+    });
+  });
+  it("handles empty arrays and objects", async () => {
+    let result = await (0, import_children.setChildren)([], element, node);
+    expect(result).toEqual({
+      tag: "fragment"
+    });
+    result = await (0, import_children.setChildren)({}, element, node);
+    expect(result).toEqual({
+      tag: "fragment"
+    });
+  });
+  it("handles falsy values in arrays", async () => {
+    const result = await (0, import_children.setChildren)(
+      [null, void 0, false, 0, ""],
+      element,
+      node
+    );
+    expect(result).toEqual({
+      tag: "fragment",
+      3: { text: 0 },
+      4: { text: "" }
+    });
+  });
+  it("handles React components with falsy values in array", async () => {
+    const mixedChildren = [
+      null,
+      { $$typeof: Symbol("react") },
+      void 0,
+      { $$typeof: Symbol("react") },
+      false
+    ];
+    await (0, import_children.setChildren)(mixedChildren, element, node);
+    expect(element.call).toHaveBeenCalledWith(
+      "renderReact",
+      [mixedChildren[1], mixedChildren[3]],
+      element
+    );
+  });
+  it("handles nested state parsing", async () => {
+    element.state = {
+      nested: {
+        items: ["c", "d"]
+      }
+    };
+    element.state.nested.__proto__.parse = () => ["parsed c", "parsed d"];
+    const result = await (0, import_children.setChildren)("nested", element, node);
+    expect(result).toEqual({
+      tag: "fragment",
+      0: { state: ["c", "d"] }
+    });
+  });
+  it("handles mixed state and regular objects", async () => {
+    element.state = {
+      header: { parse: () => "Header" },
+      footer: { parse: () => "Footer" }
+    };
+    const result = await (0, import_children.setChildren)(
+      {
+        header: "header",
+        content: { text: "Content" },
+        footer: "footer"
+      },
+      element,
+      node
+    );
+    expect(result).toEqual({
+      tag: "fragment",
+      0: { text: "header" },
+      1: { text: "Content" },
+      2: { text: "footer" }
+    });
+  });
+});

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

@@ -0,0 +1,75 @@
+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_define = __toESM(require("../define"), 1);
+var import_mixins = require("../mixins");
+describe("default function (registry updater)", () => {
+  let originalRegistry;
+  beforeEach(() => {
+    originalRegistry = { ...import_mixins.REGISTRY };
+  });
+  afterEach(() => {
+    Object.keys(import_mixins.REGISTRY).forEach((key) => {
+      import_mixins.REGISTRY[key] = originalRegistry[key];
+    });
+  });
+  it("should add new params to REGISTRY when overwrite is true", () => {
+    const params = { newKey: "newValue", anotherKey: "anotherValue" };
+    const options = { overwrite: true };
+    (0, import_define.default)(params, options);
+    expect(import_mixins.REGISTRY.newKey).toBe("newValue");
+    expect(import_mixins.REGISTRY.anotherKey).toBe("anotherValue");
+  });
+  it("should not modify REGISTRY when trying to overwrite existing keys without overwrite option", () => {
+    const params = { attr: "newValue", text: "newText" };
+    try {
+      (0, import_define.default)(params);
+    } catch (e) {
+    }
+    expect(import_mixins.REGISTRY.attr).toBe(originalRegistry.attr);
+    expect(import_mixins.REGISTRY.text).toBe(originalRegistry.text);
+  });
+  it("should overwrite existing keys when overwrite is true", () => {
+    const params = { attr: "newValue", text: "newText" };
+    const options = { overwrite: true };
+    (0, import_define.default)(params, options);
+    expect(import_mixins.REGISTRY.attr).toBe("newValue");
+    expect(import_mixins.REGISTRY.text).toBe("newText");
+  });
+  it("should handle empty params object without errors", () => {
+    const params = {};
+    const options = { overwrite: true };
+    expect(() => (0, import_define.default)(params, options)).not.toThrow();
+    expect(import_mixins.REGISTRY).toEqual(originalRegistry);
+  });
+  it("should handle empty options object without errors", () => {
+    const params = { newKey: "newValue" };
+    expect(() => (0, import_define.default)(params, {})).not.toThrow();
+    expect(import_mixins.REGISTRY.newKey).toBe("newValue");
+  });
+  it("should not add new keys when params is empty", () => {
+    const params = {};
+    const options = { overwrite: true };
+    (0, import_define.default)(params, options);
+    expect(import_mixins.REGISTRY).toEqual(originalRegistry);
+  });
+});

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

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

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

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