@domql/element 2.3.154 → 2.4.1

package/dist/cjs/iterate.js

@@ -0,0 +1,108 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var iterate_exports = {};
+__export(iterate_exports, {
+  throughInitialDefine: () => throughInitialDefine,
+  throughInitialExec: () => throughInitialExec,
+  throughUpdatedDefine: () => throughUpdatedDefine,
+  throughUpdatedExec: () => throughUpdatedExec
+});
+module.exports = __toCommonJS(iterate_exports);
+var import_utils = require("@domql/utils");
+var import_utils2 = require("./utils");
+var import_methods = require("./methods");
+const throughInitialExec = (element, exclude = {}) => {
+  const { __ref: ref } = element;
+  for (const param in element) {
+    if (exclude[param])
+      continue;
+    const prop = element[param];
+    if ((0, import_utils.isFunction)(prop) && !(0, import_methods.isMethod)(param) && !(0, import_utils2.isVariant)(param)) {
+      ref.__exec[param] = prop;
+      element[param] = prop(element, element.state);
+    }
+  }
+};
+const throughUpdatedExec = (element, options = { excludes: import_utils2.METHODS_EXL }) => {
+  const { __ref: ref } = element;
+  const changes = {};
+  for (const param in ref.__exec) {
+    const prop = element[param];
+    const isDefinedParam = ref.__defineCache[param];
+    if (isDefinedParam)
+      continue;
+    const newExec = ref.__exec[param](element, element.state, element.context);
+    const execReturnsString = (0, import_utils.isString)(newExec) || (0, import_utils.isNumber)(newExec);
+    if (prop && prop.node && execReturnsString) {
+      (0, import_utils2.overwrite)(prop, { text: newExec }, options);
+    } else if (newExec !== prop) {
+      if ((0, import_utils2.checkIfKeyIsComponent)(param)) {
+        const { extend, ...newElem } = (0, import_utils2.extendizeByKey)(newExec, element, param);
+        (0, import_utils2.overwrite)(prop, newElem, options);
+      } else {
+        ref.__cached[param] = changes[param] = prop;
+        element[param] = newExec;
+      }
+    }
+  }
+  return changes;
+};
+const throughInitialDefine = (element) => {
+  const { define, context, __ref: ref } = element;
+  let defineObj = {};
+  const hasGlobalDefine = context && (0, import_utils.isObject)(context.define);
+  if ((0, import_utils.isObject)(define))
+    defineObj = { ...define };
+  if (hasGlobalDefine)
+    defineObj = { ...defineObj, ...context.define };
+  for (const param in defineObj) {
+    let elementProp = element[param];
+    if ((0, import_utils.isFunction)(elementProp) && !(0, import_methods.isMethod)(param) && !(0, import_utils2.isVariant)(param)) {
+      ref.__exec[param] = elementProp;
+      const execParam2 = elementProp = (0, import_utils.exec)(elementProp, element);
+      if (execParam2) {
+        elementProp = element[param] = execParam2.parse ? execParam2.parse() : execParam2;
+        ref.__defineCache[param] = elementProp;
+      }
+    }
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
+    if (execParam)
+      element[param] = execParam;
+  }
+  return element;
+};
+const throughUpdatedDefine = (element) => {
+  const { context, define, __ref: ref } = element;
+  const changes = {};
+  let obj = {};
+  if ((0, import_utils.isObject)(define))
+    obj = { ...define };
+  if ((0, import_utils.isObject)(context && context.define))
+    obj = { ...obj, ...context.define };
+  for (const param in obj) {
+    const execParam = ref.__exec[param];
+    if (execParam)
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
+    const cached = (0, import_utils.exec)(ref.__defineCache[param], element);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
+    if (newExecParam)
+      element[param] = newExecParam;
+  }
+  return changes;
+};

package/dist/cjs/node.js

@@ -0,0 +1,85 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var node_exports = {};
+__export(node_exports, {
+  createNode: () => createNode,
+  default: () => node_default
+});
+module.exports = __toCommonJS(node_exports);
+var import_utils = require("@domql/utils");
+var import_event = require("@domql/event");
+var import_methods = require("./methods");
+var import_node = require("@domql/node");
+var import_create = __toESM(require("./create"), 1);
+var import_iterate = require("./iterate");
+var import_mixins = require("./mixins");
+var import_applyParam = require("./applyParam");
+var import_utils2 = require("./utils");
+const ENV = "development";
+const createNode = (element, options) => {
+  let { node, tag, __ref: ref } = element;
+  let isNewNode;
+  if (!node) {
+    isNewNode = true;
+    if (!ref.__if)
+      return element;
+    if (tag === "shadow") {
+      node = element.node = element.parent.node.attachShadow({ mode: "open" });
+    } else
+      node = element.node = (0, import_node.cacheNode)(element);
+    (0, import_event.triggerEventOn)("attachNode", element, options);
+  }
+  if (ENV === "test" || ENV === "development" || options.alowRefReference) {
+    node.ref = element;
+    if ((0, import_utils.isFunction)(node.setAttribute))
+      node.setAttribute("key", element.key);
+  }
+  if (!ref.__if)
+    return element;
+  if (element.tag !== "string" || element.tag !== "fragment") {
+    (0, import_iterate.throughInitialDefine)(element);
+    (0, import_iterate.throughInitialExec)(element);
+    if (isNewNode && (0, import_utils.isObject)(element.on))
+      (0, import_event.applyEventsOnNode)(element);
+    for (const param in element) {
+      const prop = element[param];
+      if ((0, import_utils.isUndefined)(prop) || (0, import_methods.isMethod)(param) || (0, import_utils2.isVariant)(param) || (0, import_utils.isObject)(import_mixins.registry[param]))
+        continue;
+      const isElement = (0, import_applyParam.applyParam)(param, element, options);
+      if (isElement) {
+        const { hasDefine, hasContextDefine } = isElement;
+        if (element[param] && !hasDefine && !hasContextDefine) {
+          (0, import_create.default)((0, import_utils.exec)(prop, element), element, param, options);
+        }
+      }
+    }
+  }
+  return element;
+};
+var node_default = createNode;

package/dist/cjs/package.json

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

package/dist/cjs/set.js

@@ -0,0 +1,58 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var set_exports = {};
+__export(set_exports, {
+  default: () => set_default
+});
+module.exports = __toCommonJS(set_exports);
+var import_utils = require("@domql/utils");
+var import_create = __toESM(require("./create"), 1);
+var import_options = __toESM(require("./cache/options"), 1);
+var import_mixins = require("./mixins");
+var import_content = require("./mixins/content");
+const set = function(params, options = {}, el) {
+  const element = el || this;
+  const __contentRef = element.content && element.content.__ref;
+  if (__contentRef && __contentRef.__cached && (0, import_utils.isEqualDeep)(params, element.content))
+    return element;
+  (0, import_content.removeContent)(element);
+  if (params) {
+    const { childExtend } = params;
+    if (!childExtend && element.childExtend)
+      params.childExtend = element.childExtend;
+    (0, import_create.default)(params, element, "content", {
+      ignoreChildExtend: true,
+      ...import_mixins.registry.defaultOptions,
+      ...import_options.default.create,
+      ...options
+    });
+  }
+  return element;
+};
+var set_default = set;

package/dist/cjs/tree.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tree_exports = {};
+__export(tree_exports, {
+  ROOT: () => ROOT,
+  TREE: () => TREE
+});
+module.exports = __toCommonJS(tree_exports);
+var import_utils = require("@domql/utils");
+var import_report = require("@domql/report");
+const ROOT = {
+  key: ":root",
+  node: import_utils.document ? import_utils.document.body : (0, import_report.report)("DocumentNotDefined", import_utils.document)
+};
+const TREE = ROOT;

package/dist/cjs/update.js

@@ -0,0 +1,223 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var update_exports = {};
+__export(update_exports, {
+  default: () => update_default
+});
+module.exports = __toCommonJS(update_exports);
+var import_utils = require("@domql/utils");
+var import_event = require("@domql/event");
+var import_methods = require("./methods");
+var import_props = require("./props");
+var import_state = require("@domql/state");
+var import_utils2 = require("./utils");
+var import_create = __toESM(require("./create"), 1);
+var import_iterate = require("./iterate");
+var import_mixins = require("./mixins");
+var import_applyParam = require("./applyParam");
+var import_options = __toESM(require("./cache/options"), 1);
+const snapshot = {
+  snapshotId: import_utils.createSnapshotId
+};
+const UPDATE_DEFAULT_OPTIONS = {
+  stackChanges: false,
+  cleanExec: true,
+  preventRecursive: false,
+  currentSnapshot: false,
+  calleeElement: false,
+  excludes: import_utils2.METHODS_EXL
+};
+const update = function(params = {}, options = UPDATE_DEFAULT_OPTIONS) {
+  const element = this;
+  const { parent, node, key } = element;
+  const { excludes, preventInheritAtCurrentState } = options;
+  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element)
+    return;
+  if (!excludes)
+    (0, import_utils.merge)(options, UPDATE_DEFAULT_OPTIONS);
+  let ref = element.__ref;
+  if (!ref)
+    ref = element.__ref = {};
+  const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(element, options);
+  if (snapshotHasUpdated)
+    return;
+  if ((0, import_utils.isString)(params) || (0, import_utils.isNumber)(params)) {
+    params = { text: params };
+  }
+  const ifFails = checkIfOnUpdate(element, parent, options);
+  if (ifFails)
+    return;
+  const inheritState = inheritStateUpdates(element, options);
+  if (inheritState === false)
+    return;
+  if (ref.__if && !options.preventPropsUpdate) {
+    const hasParentProps = parent.props && (parent.props[key] || parent.props.childProps);
+    const hasFunctionInProps = ref.__props.filter((v) => (0, import_utils.isFunction)(v));
+    const props = params.props || hasParentProps || hasFunctionInProps.length;
+    if (props)
+      (0, import_props.updateProps)(props, element, parent);
+  }
+  if (!options.isForced) {
+    (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
+  }
+  if (!options.preventInitUpdateListener) {
+    const initUpdateReturns = (0, import_event.triggerEventOnUpdate)("initUpdate", params, element, options);
+    if (initUpdateReturns === false)
+      return element;
+  }
+  const overwriteChanges = (0, import_utils.overwriteDeep)(element, params, import_utils2.METHODS_EXL);
+  const execChanges = (0, import_iterate.throughUpdatedExec)(element, { ignore: UPDATE_DEFAULT_OPTIONS });
+  const definedChanges = (0, import_iterate.throughUpdatedDefine)(element);
+  if (options.stackChanges && element.__stackChanges) {
+    const stackChanges = (0, import_utils.merge)(definedChanges, (0, import_utils.merge)(execChanges, overwriteChanges));
+    element.__stackChanges.push(stackChanges);
+  }
+  if (!ref.__if)
+    return false;
+  if (!node) {
+    return;
+  }
+  for (const param in element) {
+    const prop = element[param];
+    const hasOnlyUpdateFalsy = options.onlyUpdate && (options.onlyUpdate !== param || !element.lookup(options.onlyUpdate));
+    const isInPreventUpdate = (0, import_utils.isArray)(options.preventUpdate) && options.preventUpdate.includes(param);
+    const isInPreventDefineUpdate = (0, import_utils.isArray)(options.preventDefineUpdate) && options.preventDefineUpdate.includes(param);
+    if ((0, import_utils.isUndefined)(prop) || hasOnlyUpdateFalsy || isInPreventUpdate || isInPreventDefineUpdate || options.preventDefineUpdate === true || options.preventDefineUpdate === param || options.preventContentUpdate && param === "content" || (options.preventStateUpdate && param) === "state" || (0, import_methods.isMethod)(param) || (0, import_utils.isObject)(import_mixins.registry[param]) || (0, import_utils2.isVariant)(param))
+      continue;
+    if (options.preventStateUpdate === "once")
+      options.preventStateUpdate = false;
+    const isElement = (0, import_applyParam.applyParam)(param, element, options);
+    if (isElement) {
+      const { hasDefine, hasContextDefine } = isElement;
+      const canUpdate = (0, import_utils.isObject)(prop) && !hasDefine && !hasContextDefine && !options.preventRecursive;
+      if (!canUpdate)
+        continue;
+      const childUpdateCall = () => update.call(prop, params[prop], {
+        ...options,
+        currentSnapshot: snapshotOnCallee,
+        calleeElement
+      });
+      if (element.props && element.props.lazyLoad || options.lazyLoad) {
+        import_utils.window.requestAnimationFrame(() => childUpdateCall());
+      } else
+        childUpdateCall();
+    }
+  }
+  if (!options.preventUpdateListener)
+    (0, import_event.triggerEventOn)("update", element, options);
+};
+const captureSnapshot = (element, options) => {
+  const ref = element.__ref;
+  const { currentSnapshot, calleeElement } = options;
+  const isCallee = calleeElement === element;
+  if (!calleeElement || isCallee) {
+    const createdStanpshot = snapshot.snapshotId();
+    ref.__currentSnapshot = createdStanpshot;
+    return [createdStanpshot, element];
+  }
+  const snapshotOnCallee = ref.__currentSnapshot;
+  if (currentSnapshot < snapshotOnCallee) {
+    return [snapshotOnCallee, calleeElement, true];
+  }
+  return [snapshotOnCallee, calleeElement];
+};
+const checkIfOnUpdate = (element, parent, options) => {
+  if (!(0, import_utils.isFunction)(element.if) || !element.state || !parent)
+    return;
+  const ref = element.__ref;
+  const ifPassed = element.if(element, element.state, element.context, options);
+  const itWasFalse = ref.__if !== true;
+  if (ifPassed) {
+    ref.__if = true;
+    if (itWasFalse) {
+      delete element.__hash;
+      delete element.extend;
+      if (!ref.__hasRootState) {
+        delete element.state;
+      }
+      if (ref.__state) {
+        element.state = ref.__state;
+      }
+      const created = (0, import_create.default)(element, parent, element.key, import_options.default.create);
+      if (options.preventUpdate !== true && element.on && (0, import_utils.isFunction)(element.on.update)) {
+        (0, import_event.applyEvent)(element.on.update, created, created.state);
+      }
+      return created;
+    }
+  } else if (element.node && !ifPassed) {
+    element.node.remove();
+    delete ref.__if;
+  }
+};
+const inheritStateUpdates = (element, options) => {
+  const { __ref: ref } = element;
+  const stateKey = ref.__state;
+  const { parent, state } = element;
+  if (options.preventpdateTriggerStateUpdate)
+    return;
+  if (!stateKey && !ref.__hasRootState) {
+    element.state = parent && parent.state || {};
+    return;
+  }
+  const { isHoisted, execStateFunction, stateFunctionOverwrite } = options;
+  const shouldForceStateUpdate = (0, import_utils.isFunction)(stateKey) && (!isHoisted && execStateFunction && stateFunctionOverwrite);
+  if (shouldForceStateUpdate) {
+    const execState = (0, import_utils.exec)(stateKey, element);
+    state.set(execState, {
+      ...options,
+      preventUpdate: true
+    });
+    return;
+  }
+  const parentState = parent && parent.state || {};
+  const keyInParentState = parentState[stateKey];
+  if (!keyInParentState || options.preventInheritedStateUpdate)
+    return;
+  if (!options.preventInitStateUpdateListener) {
+    const initStateReturns = (0, import_event.triggerEventOnUpdate)("initStateUpdated", keyInParentState, element, options);
+    if (initStateReturns === false)
+      return element;
+  }
+  const newState = createStateUpdate(element, parent, options);
+  if (!options.preventStateUpdateListener) {
+    (0, import_event.triggerEventOnUpdate)("stateUpdated", newState.parse(), element, options);
+  }
+};
+const createStateUpdate = (element, parent, options) => {
+  const __stateChildren = element.state.__children;
+  const newState = (0, import_state.createState)(element, parent);
+  element.state = newState;
+  for (const child in __stateChildren) {
+    if (newState[child])
+      newState.__children[child] = __stateChildren[child];
+    __stateChildren[child].parent = newState;
+  }
+  return newState;
+};
+var update_default = update;

package/index.js

@@ -1,27 +1,17 @@
 'use strict'
 
-import { TREE } from '@domql/tree'
+import { TREE } from './tree'
 import create from './create'
 import createNode from './node'
 import define from './define'
 import update from './update'
-import parse from './parse'
 import set from './set'
 
-import { log, keys } from './methods'
-import { get, remove, lookup } from '@domql/methods'
-
 export {
   TREE,
   create,
   createNode,
   define,
-  remove,
   update,
-  parse,
-  lookup,
-  set,
-  get,
-  log,
-  keys
+  set
 }

package/iterate.js

@@ -2,7 +2,7 @@
 
 import { isObject, exec, isFunction, isNumber, isString } from '@domql/utils'
 import { METHODS_EXL, checkIfKeyIsComponent, extendizeByKey, isVariant, overwrite } from './utils'
-import { isMethod } from '@domql/methods'
+import { isMethod } from './methods'
 
 export const throughInitialExec = (element, exclude = {}) => {
   const { __ref: ref } = element