@domql/element 3.1.1 → 3.2.3

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

@@ -1,73 +0,0 @@
-var import_iterate = require("../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 (0, import_iterate.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 (0, import_iterate.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 (0, import_iterate.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 (0, import_iterate.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 (0, import_iterate.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 (0, import_iterate.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 (0, import_iterate.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 (0, import_iterate.throughInitialExec)(element, {});
-    expect(element.fn1).toBe("one");
-    expect(element.fn2).toBe("two");
-    expect(ref.__exec).toHaveProperty("fn1");
-    expect(ref.__exec).toHaveProperty("fn2");
-  });
-});

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/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);
-  });
-});