@domql/element 3.1.2 → 3.2.7

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

@@ -1,69 +0,0 @@
-var import_iterate = require("../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 (0, import_iterate.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 (0, import_iterate.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 (0, import_iterate.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 (0, import_iterate.throughUpdatedDefine)(element);
-    expect(element.testProp).toBe("original value");
-  });
-  it("should handle empty define objects", async () => {
-    const originalElement = { ...element };
-    await (0, import_iterate.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 (0, import_iterate.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 (0, import_iterate.throughUpdatedDefine)(element);
-    expect(changes).toEqual({});
-  });
-});

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

@@ -1,84 +0,0 @@
-var import_iterate = require("../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 = (0, import_iterate.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 = (0, import_iterate.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 = (0, import_iterate.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 = (0, import_iterate.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 = (0, import_iterate.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 = (0, import_iterate.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 = (0, import_iterate.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 = (0, import_iterate.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/cjs/__tests__/tree.test.js

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

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

@@ -1,222 +0,0 @@
-var import_update = require("../update");
-describe("update()", () => {
-  let element, params, opts;
-  beforeEach(() => {
-    element = {
-      __ref: {
-        __if: true,
-        __execProps: {},
-        __exec: {},
-        __defineCache: {},
-        __propsStack: [],
-        __props: [],
-        __state: "state"
-      },
-      state: "string",
-      props: {},
-      parent: {
-        props: {}
-      },
-      context: {},
-      define: {},
-      node: document.createElement("div"),
-      key: "testElement",
-      on: {},
-      update: import_update.update
-    };
-    opts = {
-      preventUpdate: [],
-      preventDefineUpdate: [],
-      preventBeforeStateUpdateListener: false,
-      preventListeners: false,
-      preventStateUpdateListener: false
-    };
-    params = {};
-  });
-  it("does not modify opts when params and opts are empty", async () => {
-    await element.update({}, opts);
-    expect(opts).toEqual({
-      calleeElement: false,
-      cleanExec: true,
-      currentSnapshot: false,
-      exclude: [],
-      preventRecursive: false,
-      stackChanges: false,
-      preventUpdate: [],
-      preventDefineUpdate: [],
-      preventBeforeStateUpdateListener: false,
-      preventListeners: false,
-      preventStateUpdateListener: false
-    });
-  });
-  it("initializes options with UPDATE_DEFAULT_OPTIONS when opts is empty", async () => {
-    await element.update({}, opts);
-    expect(opts.calleeElement).toBe(false);
-    expect(element.__ref).toBeDefined();
-  });
-  it("merges opts with UPDATE_DEFAULT_OPTIONS using deepMerge", async () => {
-    opts.customOption = true;
-    await element.update({}, opts);
-    expect(opts.customOption).toBe(true);
-  });
-  it("converts string params to { text: params }", async () => {
-    await element.update("testString", opts);
-    expect(element.text).toBe("testString");
-  });
-  it("converts number params to { text: params }", async () => {
-    await element.update(123, opts);
-    expect(element.text).toBe(123);
-  });
-  it("returns early if preventInheritAtCurrentState matches element", async () => {
-    opts.preventInheritAtCurrentState = { __element: element };
-    await element.update({}, opts);
-    expect(element.__ref.__currentSnapshot).toBe(6);
-  });
-  it("initializes __ref if not present", async () => {
-    delete element.__ref;
-    await element.update({}, opts);
-    expect(element.__ref).toBeDefined();
-  });
-  it("merges options with UPDATE_DEFAULT_OPTIONS when exclude is missing", async () => {
-    await element.update({}, opts);
-    expect(opts.exclude).toBeDefined();
-  });
-  it("does not throw or modify opts when params is undefined", async () => {
-    await element.update(void 0, opts);
-    expect(opts).toEqual({
-      calleeElement: false,
-      cleanExec: true,
-      currentSnapshot: false,
-      exclude: [],
-      preventRecursive: false,
-      preventUpdate: [],
-      preventDefineUpdate: [],
-      stackChanges: false,
-      preventBeforeStateUpdateListener: false,
-      preventListeners: false,
-      preventStateUpdateListener: false
-    });
-  });
-  it("does not throw when opts is undefined", async () => {
-    await element.update({}, void 0);
-    expect(element.__ref).toBeDefined();
-  });
-  it("does not throw when opts is null", async () => {
-    await element.update({}, null);
-    expect(element.__ref).toBeDefined();
-  });
-  it("does not modify the params object", async () => {
-    params = { key: "value" };
-    await element.update(params, opts);
-    expect(params).toEqual({ key: "value" });
-  });
-  it("does modify opts when params is an empty object", async () => {
-    await element.update({}, opts);
-    expect(opts).toEqual({
-      calleeElement: false,
-      cleanExec: true,
-      currentSnapshot: false,
-      exclude: [],
-      preventRecursive: false,
-      stackChanges: false,
-      preventUpdate: [],
-      preventDefineUpdate: [],
-      preventBeforeStateUpdateListener: false,
-      preventListeners: false,
-      preventStateUpdateListener: false
-    });
-  });
-  it("moves regular properties to element.props", async () => {
-    params = { props: { title: "Test", description: "Content" } };
-    await element.update(params, opts);
-    expect(element.props).toEqual({
-      title: "Test",
-      description: "Content"
-    });
-    expect(element.title).toBeUndefined();
-  });
-  it("keeps element-rooted properties", async () => {
-    params = { Header: {}, Footer: {}, 0: "index" };
-    await element.update(params, opts);
-    expect(element.Header).toBeDefined();
-    expect(element.Footer).toBeDefined();
-    expect(element["0"]).toBe("index");
-    expect(element.props).toEqual({});
-  });
-  it("preserves built-in properties on element", async () => {
-    params = { props: { className: "container", hidden: true } };
-    await element.update(params, opts);
-    expect(element.props.className).toBe("container");
-    expect(element.props.hidden).toBe(true);
-    expect(element.props).toEqual({ className: "container", hidden: true });
-  });
-  it("moves element-like properties from props to root", async () => {
-    params = { props: { Header: {} } };
-    await element.update(params, opts);
-    expect(element.Header).toBeDefined();
-    expect(element.props.Header).toBeUndefined();
-  });
-  it("exits early when inheritStateUpdates returns false", async () => {
-    element.__ref.__stateBlocked = true;
-    await element.update({ props: { shouldChange: true } }, opts);
-    expect(element.props.shouldChange).toBe(true);
-    expect(element.__ref.__stateBlocked).toBe(true);
-  });
-  it("exits early when checkIfOnUpdate fails", async () => {
-    element.parent.props.ifCondition = false;
-    await element.update({ state: { newState: true } }, opts);
-    expect(element.state.newState).toBe(true);
-  });
-  it("updates props from parent key match", async () => {
-    element.parent.props.testKey = { inherited: true };
-    await element.update({}, opts);
-    expect(element.props.inherited).toBeUndefined();
-  });
-  it("updates props when functions exist in __props", async () => {
-    element.__ref.__props.push(() => "dynamic");
-    await element.update({}, opts);
-    expect(element.props).toEqual(expect.any(Object));
-  });
-  it("skips props update when preventPropsUpdate=true", async () => {
-    opts.preventPropsUpdate = true;
-    opts.preventUpdateAfter = true;
-    element.parent.props.testKey = { shouldExist: true };
-    await element.update({}, opts);
-    expect(element.props.shouldExist).toBeUndefined();
-  });
-  it("should not skips props update when preventPropsUpdate=false", async () => {
-    opts.preventPropsUpdate = false;
-    opts.lazyLoad = true;
-    opts.onEachUpdate = () => {
-      return true;
-    };
-    element.parent.props.testKey = { shouldExist: true };
-    element.__ref.__propsStack = [];
-    element.__ref.__if = true;
-    element.off = { text: "off" };
-    await element.update({}, opts);
-    expect(element.props.shouldExist).toBeUndefined();
-  });
-  it("should set preventUpdateAfterCount to 1 when is not a number", async () => {
-    opts.preventPropsUpdate = true;
-    opts.preventUpdateAfter = 2;
-    opts.preventUpdateAfterCount = void 0;
-    element.parent.props.testKey = { shouldExist: true };
-    await element.update({}, opts);
-    expect(element.props.shouldExist).toBeUndefined();
-  });
-  it("processes parent.childProps", async () => {
-    element.parent.props.childProps = { global: true };
-    await element.update({}, opts);
-    expect(element.props.global).toBe(true);
-  });
-  it("processes function props", async () => {
-    await element.update({ props: { calc: () => 42 } }, opts);
-    expect(element.props.calc()).toBe(42);
-  });
-  it("returns element when beforeUpdate rejects", async () => {
-    element.on.beforeUpdate = () => false;
-    const result = await element.update({}, opts);
-    expect(result).toBe(element);
-  });
-});

package/dist/cjs/package.json

@@ -1,4 +0,0 @@
-{
-  "type": "commonjs",
-  "main": "index.js"
-}

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

@@ -1,73 +0,0 @@
-import { update } from "../update";
-describe("checkIfOnUpdate via update()", () => {
-  let element, parent, options;
-  beforeEach(() => {
-    parent = {
-      node: document.createElement("div"),
-      props: {},
-      state: {}
-    };
-    element = {
-      __ref: {
-        __if: void 0,
-        __state: null,
-        __hasRootState: false,
-        __execProps: {},
-        contentElementKey: "content"
-      },
-      parent,
-      props: {},
-      state: {
-        update: (el, st) => {
-          return st;
-        }
-      },
-      context: {
-        defaultExtends: {}
-      },
-      node: document.createElement("div"),
-      if: () => true,
-      previousElement: () => {
-        return {};
-      },
-      nextElement: () => {
-        return {};
-      },
-      removeContent: () => {
-        return true;
-      }
-    };
-    options = {};
-  });
-  it("uses props.if when element.if missing", async () => {
-    delete element.if;
-    element.props.if = () => false;
-    await update.call(element, {}, options);
-    expect(element.node).toEqual(document.createElement("div"));
-  });
-  it("retains state when __hasRootState=true", async () => {
-    element.__ref.__hasRootState = true;
-    element.state.critical = true;
-    element.__ref.__if = false;
-    await update.call(element, {}, options);
-    expect(element.state.critical).toBe(true);
-    expect(element.state.preserved).toBeUndefined();
-  });
-  it("processes nested content with parseDeep", async () => {
-    element.content = {
-      parseDeep: () => ({ parsed: true }),
-      existing: "data"
-    };
-    await update.call(element, {}, options);
-    expect(element.content.parsed).toBe(true);
-    expect(element.content.existing).toBeUndefined();
-  });
-  it("reattaches after previous sibling", async () => {
-    const prevNode = document.createElement("span");
-    parent.node.appendChild(prevNode);
-    await update.call(element, {}, options);
-    const newElement = parent.node.children[0];
-    expect(newElement).toEqual(document.createElement("span"));
-    expect(newElement.previousSibling).toBe(null);
-  });
-});

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

@@ -1,177 +0,0 @@
-import { jest } from "@jest/globals";
-import { setChildren } from "../children";
-describe("children", () => {
-  let element, node;
-  beforeEach(() => {
-    element = {
-      __ref: {},
-      state: {},
-      props: {},
-      call: jest.fn(),
-      removeContent: jest.fn(),
-      content: null
-    };
-    node = {};
-  });
-  it("handles null/undefined params", async () => {
-    const result = await setChildren(null, element, node);
-    expect(result).toBeUndefined();
-  });
-  it("handles direct string children", async () => {
-    const result = await setChildren("Hello World", element, node);
-    expect(result).toEqual({ tag: "fragment", 0: { text: "Hello World" } });
-  });
-  it("handles numeric children", async () => {
-    const result = await 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 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 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 setChildren(children1, element, node);
-    expect(element.__ref.__childrenCache).toEqual(children1);
-    expect(element.__ref.__noChildrenDifference).toBeUndefined();
-    await setChildren(children2, element, node);
-    expect(element.__ref.__noChildrenDifference).toBe(true);
-    await 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 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 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 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 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 setChildren([], element, node);
-    expect(result).toEqual({
-      tag: "fragment"
-    });
-    result = await setChildren({}, element, node);
-    expect(result).toEqual({
-      tag: "fragment"
-    });
-  });
-  it("handles falsy values in arrays", async () => {
-    const result = await 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 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 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 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/esm/__tests__/define.test.js

@@ -1,53 +0,0 @@
-import define from "../define";
-import { REGISTRY } from "../mixins";
-describe("default function (registry updater)", () => {
-  let originalRegistry;
-  beforeEach(() => {
-    originalRegistry = { ...REGISTRY };
-  });
-  afterEach(() => {
-    Object.keys(REGISTRY).forEach((key) => {
-      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 };
-    define(params, options);
-    expect(REGISTRY.newKey).toBe("newValue");
-    expect(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 {
-      define(params);
-    } catch (e) {
-    }
-    expect(REGISTRY.attr).toBe(originalRegistry.attr);
-    expect(REGISTRY.text).toBe(originalRegistry.text);
-  });
-  it("should overwrite existing keys when overwrite is true", () => {
-    const params = { attr: "newValue", text: "newText" };
-    const options = { overwrite: true };
-    define(params, options);
-    expect(REGISTRY.attr).toBe("newValue");
-    expect(REGISTRY.text).toBe("newText");
-  });
-  it("should handle empty params object without errors", () => {
-    const params = {};
-    const options = { overwrite: true };
-    expect(() => define(params, options)).not.toThrow();
-    expect(REGISTRY).toEqual(originalRegistry);
-  });
-  it("should handle empty options object without errors", () => {
-    const params = { newKey: "newValue" };
-    expect(() => define(params, {})).not.toThrow();
-    expect(REGISTRY.newKey).toBe("newValue");
-  });
-  it("should not add new keys when params is empty", () => {
-    const params = {};
-    const options = { overwrite: true };
-    define(params, options);
-    expect(REGISTRY).toEqual(originalRegistry);
-  });
-});