@domql/element 3.1.2 → 3.2.7

package/__tests__/update.test.js

@@ -1,256 +0,0 @@
-import { update } from '../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
-    }
-    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) // Ensure opts is not mutated
-    expect(element.__ref).toBeDefined() // Ensure __ref is initialized
-  })
-
-  it('merges opts with UPDATE_DEFAULT_OPTIONS using deepMerge', async () => {
-    opts.customOption = true
-    await element.update({}, opts)
-    expect(opts.customOption).toBe(true) // Ensure custom options are preserved
-  })
-
-  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) // No snapshot update
-  })
-
-  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() // Ensure exclude is added
-  })
-
-  it('does not throw or modify opts when params is undefined', async () => {
-    await element.update(undefined, 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({}, undefined)
-    expect(element.__ref).toBeDefined() // Ensure __ref is initialized
-  })
-
-  it('does not throw when opts is null', async () => {
-    await element.update({}, null)
-    expect(element.__ref).toBeDefined() // Ensure __ref is initialized
-  })
-
-  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 () => {
-    // Simulate inheritStateUpdates failure
-    element.__ref.__stateBlocked = true
-    await element.update({ props: { shouldChange: true } }, opts)
-
-    expect(element.props.shouldChange).toBe(true)
-    expect(element.__ref.__stateBlocked).toBe(true) // State remains blocked
-  })
-
-  it('exits early when checkIfOnUpdate fails', async () => {
-    // Force checkIfOnUpdate failure
-    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)) // Props were processed
-  })
-
-  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 = undefined
-    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 () => {
-    // Simulate beforeUpdate rejection
-    element.on.beforeUpdate = () => false
-    const result = await element.update({}, opts)
-    expect(result).toBe(element)
-  })
-})

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

@@ -1,73 +0,0 @@
-var import_update = require("../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 import_update.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 import_update.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 import_update.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 import_update.update.call(element, {}, options);
-    const newElement = parent.node.children[0];
-    expect(newElement).toEqual(document.createElement("span"));
-    expect(newElement.previousSibling).toBe(null);
-  });
-});

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

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

@@ -1,75 +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_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

@@ -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.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");
-  });
-});