@domql/utils 2.5.200 → 3.0.0

package/dist/esm/element.js

@@ -0,0 +1,135 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { createExtends } from "./extends.js";
+import { createKey } from "./key.js";
+import { isNode } from "./node.js";
+import { createProps } from "./props.js";
+import { HTML_TAGS } from "./tags.js";
+import { is, isFunction } from "./types.js";
+const ENV = "development";
+const returnValueAsText = (element, parent, key) => {
+  const childExtendsTag = parent.childExtends && parent.childExtends.tag;
+  const childPropsTag = parent.props.childProps && parent.props.childProps.tag;
+  const isKeyValidHTMLTag = HTML_TAGS.body.indexOf(key) > -1 && key;
+  return {
+    text: element,
+    tag: childExtendsTag || childPropsTag || isKeyValidHTMLTag || "string"
+  };
+};
+const createBasedOnType = (element, parent, key) => {
+  if (element === void 0) {
+    if (ENV === "test" || ENV === "development") {
+      console.warn(
+        key,
+        "element is undefined in",
+        parent && parent.__ref && parent.__ref.path
+      );
+    }
+    return {};
+  }
+  if (element === null) return;
+  if (element === true) return {};
+  if (is(element)("string", "number")) {
+    return returnValueAsText(element, parent, key);
+  }
+  if (isFunction(element)) {
+    return { props: element };
+  }
+  return element;
+};
+const addRef = (element, parent) => {
+  const ref = {};
+  ref.origin = element;
+  ref.parent = parent;
+  return ref;
+};
+const createParent = (element, parent, key, options, root) => {
+  if (!parent) return root;
+  if (isNode(parent)) {
+    const parentNodeWrapper = { key: ":root", node: parent };
+    root[`${key}_parent`] = parentNodeWrapper;
+    return parentNodeWrapper;
+  }
+  return parent;
+};
+const createRoot = (element, parent) => {
+  const { __ref: ref } = element;
+  const { __ref: parentRef } = parent;
+  const hasRoot = parent && parent.key === ":root";
+  if (!(ref == null ? void 0 : ref.root)) {
+    return hasRoot ? element : parentRef == null ? void 0 : parentRef.root;
+  }
+};
+const createPath = (element, parent, key) => {
+  let { __ref: parentRef } = parent;
+  if (!parentRef) parentRef = parent.ref = {};
+  if (!parentRef.path) parentRef.path = [];
+  return parentRef.path.concat(key);
+};
+const addContext = (element, parent, key, options, root) => {
+  const forcedOptionsContext = options.context && !root.context && !element.context;
+  if (forcedOptionsContext) root.context = options.context;
+  return options.context || parent.context || root.context || element.context;
+};
+const addCaching = (element, parent, key) => {
+  const ref = addRef(element, parent);
+  element.__ref = ref;
+  if (!ref.__defineCache) ref.__defineCache = {};
+  if (!ref.__exec) ref.__exec = {};
+  if (!ref.__execProps) ref.__execProps = {};
+  if (!ref.__class) ref.__class = {};
+  if (!ref.__classNames) ref.__classNames = {};
+  if (!ref.__attr) ref.__attr = {};
+  if (!ref.__changes) ref.__changes = [];
+  if (!ref.__children) ref.__children = [];
+  ref.__extends = createExtends(element, parent, key);
+  ref.path = createPath(element, parent, key);
+  ref.root = createRoot(element, parent);
+  return ref;
+};
+const createElement = (passedProps, parentEl, passedKey, opts, root) => {
+  const hashed = passedProps == null ? void 0 : passedProps.__hash;
+  const element = hashed ? { extends: [passedProps] } : createBasedOnType(passedProps, parentEl, passedKey);
+  if (!element) return;
+  const parent = createParent(element, parentEl, passedKey, opts, root);
+  const key = createKey(element, parent, passedKey);
+  addCaching(element, parent, key);
+  const props = createProps(element, parent, key);
+  const context = addContext(element, parent, key, opts, root);
+  const on = element.on || {};
+  return __spreadProps(__spreadValues({}, element), {
+    key,
+    props,
+    parent,
+    context,
+    on
+  });
+};
+export {
+  addCaching,
+  addContext,
+  addRef,
+  createBasedOnType,
+  createElement,
+  createParent,
+  createPath,
+  createRoot,
+  returnValueAsText
+};

package/dist/esm/events.js

@@ -0,0 +1,17 @@
+import { lowercaseFirstLetter } from "./string.js";
+import { isFunction } from "./types.js";
+const addEventFromProps = (key, element) => {
+  const { props, on } = element;
+  const eventName = lowercaseFirstLetter(key.split("on")[1]);
+  const origEvent = on[eventName];
+  const funcFromProps = props[key];
+  if (isFunction(origEvent)) {
+    on[eventName] = (...args) => {
+      const originalEventRetunrs = origEvent(...args);
+      if (originalEventRetunrs !== false) funcFromProps(...args);
+    };
+  } else on[eventName] = funcFromProps;
+};
+export {
+  addEventFromProps
+};

package/dist/esm/extends.js

@@ -0,0 +1,349 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { joinArrays, removeDuplicatesInArray } from "./array.js";
+import { matchesComponentNaming } from "./component.js";
+import { deepClone, exec } from "./object.js";
+import { isArray, isFunction, isObject, isString } from "./types.js";
+const ENV = "development";
+const createExtendsFromKeys = (key) => {
+  if (key.includes("+")) {
+    return key.split("+").filter(matchesComponentNaming);
+  }
+  if (key.includes("_")) {
+    const [first] = key.split("_");
+    return [first];
+  }
+  if (key.includes(".") && !matchesComponentNaming(key.split(".")[1])) {
+    const [first] = key.split(".");
+    return [first];
+  }
+  return [key];
+};
+const createExtends = (element, parent, key) => {
+  let __extends = [];
+  const keyExtends = createExtendsFromKeys(key);
+  if (keyExtends) __extends = [...keyExtends];
+  const elementExtends = element.extends;
+  if (elementExtends) {
+    __extends = isArray(elementExtends) ? [...__extends, ...elementExtends] : [...__extends, elementExtends];
+  }
+  return __extends;
+};
+const addExtends = (newExtends, element) => {
+  var _a;
+  const { __ref: ref } = element;
+  let { __extends } = ref;
+  if (!newExtends) return __extends;
+  const variant = (_a = element.props) == null ? void 0 : _a.variant;
+  const context = element.context;
+  if (variant && (context == null ? void 0 : context.components) && !Array.isArray(newExtends) && typeof newExtends === "string") {
+    const variantKey = `${newExtends}.${variant}`;
+    if (context.components[variantKey]) {
+      newExtends = variantKey;
+    }
+  }
+  if (!__extends.includes(newExtends)) {
+    __extends = Array.isArray(newExtends) ? [...__extends, ...newExtends] : [...__extends, newExtends];
+    ref.__extends = __extends;
+  }
+  return __extends;
+};
+const concatAddExtends = (newExtend, element) => {
+  if (!newExtend) return element;
+  const { extend: elementExtend } = element;
+  const originalArray = isArray(elementExtend) ? elementExtend : [elementExtend];
+  const receivedArray = isArray(newExtend) ? newExtend : [newExtend];
+  return __spreadProps(__spreadValues({}, element), {
+    extends: joinArrays(receivedArray, originalArray)
+  });
+};
+const generateHash = () => Math.random().toString(36).substring(2);
+const extendStackRegistry = {};
+const extendCachedRegistry = {};
+const getHashedExtend = (extend) => {
+  return extendStackRegistry[extend.__hash];
+};
+const setHashedExtend = (extend, stack) => {
+  const hash = generateHash();
+  if (!isString(extend)) {
+    extend.__hash = hash;
+  }
+  if (!["__proto__", "constructor", "prototype"].includes(hash)) {
+    extendStackRegistry[hash] = stack;
+  }
+  return stack;
+};
+const getExtendsStackRegistry = (extend, stack) => {
+  if (extend.__hash) {
+    return stack.concat(getHashedExtend(extend));
+  }
+  return setHashedExtend(extend, stack);
+};
+const extractArrayExtend = (extend, stack, context, processed = /* @__PURE__ */ new Set()) => {
+  for (const each of extend) {
+    if (isArray(each)) {
+      extractArrayExtend(each, stack, context, processed);
+    } else {
+      flattenExtend(each, stack, context, processed);
+    }
+  }
+  return stack;
+};
+const deepExtend = (extend, stack, context, processed = /* @__PURE__ */ new Set()) => {
+  const extendOflattenExtend = extend.extends;
+  const cleanExtend = __spreadValues({}, extend);
+  delete cleanExtend.extends;
+  if (Object.keys(cleanExtend).length > 0) {
+    stack.push(cleanExtend);
+  }
+  if (extendOflattenExtend) {
+    flattenExtend(extendOflattenExtend, stack, context, processed);
+  }
+  return stack;
+};
+const flattenExtend = (extend, stack, context, processed = /* @__PURE__ */ new Set()) => {
+  if (!extend) return stack;
+  if (processed.has(extend)) return stack;
+  if (isArray(extend)) {
+    return extractArrayExtend(extend, stack, context, processed);
+  }
+  if (isString(extend)) {
+    extend = mapStringsWithContextComponents(extend, context);
+  }
+  processed.add(extend);
+  if (extend == null ? void 0 : extend.extends) {
+    deepExtend(extend, stack, context, processed);
+  } else {
+    stack.push(extend);
+  }
+  return stack;
+};
+const deepMergeExtends = (element, extend) => {
+  extend = deepClone(extend);
+  for (const e in extend) {
+    if (["parent", "node", "__ref"].indexOf(e) > -1) continue;
+    if (e === "__proto__") continue;
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (extendProp === void 0) continue;
+    if (Object.prototype.hasOwnProperty.call(extend, e) && !["__proto__", "constructor", "prototype"].includes(e)) {
+      if (elementProp === void 0) {
+        element[e] = isObject(extendProp) ? deepClone(extendProp) : extendProp;
+      } else if (isObject(elementProp) && isObject(extendProp)) {
+        if (matchesComponentNaming(e)) {
+          element[e] = deepMergeExtends(elementProp, deepClone(extendProp));
+        } else {
+          deepMergeExtends(elementProp, extendProp);
+        }
+      }
+    }
+  }
+  return element;
+};
+const cloneAndMergeArrayExtend = (stack) => {
+  return stack.reduce((acc, current) => {
+    const cloned = deepClone(current);
+    return deepMergeExtends(acc, cloned);
+  }, {});
+};
+const mapStringsWithContextComponents = (extend, context, options = {}, variant) => {
+  const COMPONENTS = context && context.components || options.components;
+  const PAGES = context && context.pages || options.pages;
+  if (isString(extend)) {
+    const componentExists = COMPONENTS && (COMPONENTS[extend + "." + variant] || COMPONENTS[extend] || COMPONENTS["smbls." + extend]);
+    const pageExists = PAGES && extend.startsWith("/") && PAGES[extend];
+    if (componentExists) return componentExists;
+    else if (pageExists) return pageExists;
+    else {
+      if (options.verbose && (ENV === "test" || ENV === "development")) {
+        console.warn("Extend is string but component was not found:", extend);
+      }
+      return;
+    }
+  }
+  return extend;
+};
+const jointStacks = (extendStack, childExtendsStack) => {
+  return [].concat(extendStack.slice(0, 1)).concat(childExtendsStack.slice(0, 1)).concat(extendStack.slice(1)).concat(childExtendsStack.slice(1));
+};
+const getExtendsStack = (extend, context) => {
+  if (!extend) return [];
+  if (extend.__hash) return getHashedExtend(extend) || [];
+  const processed = /* @__PURE__ */ new Set();
+  const stack = flattenExtend(extend, [], context, processed);
+  return getExtendsStackRegistry(extend, stack);
+};
+const addExtend = (newExtends, elementExtends) => {
+  if (!newExtends) return elementExtends;
+  const receivedArray = isArray(newExtends) ? newExtends : [newExtends];
+  return joinArrays(receivedArray, elementExtends);
+};
+const getExtendsInElement = (obj) => {
+  let result = [];
+  function traverse(o) {
+    for (const key in o) {
+      if (Object.hasOwnProperty.call(o, key)) {
+        if (matchesComponentNaming(key)) {
+          result.push(key);
+        }
+        if (key === "extends") {
+          if (typeof o[key] === "string") {
+            result.push(o[key]);
+          } else if (Array.isArray(o[key])) {
+            result = result.concat(o[key]);
+          }
+        }
+        if (typeof o[key] === "object" && o[key] !== null) {
+          traverse(o[key]);
+        }
+      }
+    }
+  }
+  traverse(obj);
+  return result;
+};
+const createElementExtends = (element, parent, options = {}) => {
+  var _a;
+  const { __ref: ref } = element;
+  const context = element.context || parent.context;
+  const variant = (_a = element.props) == null ? void 0 : _a.variant;
+  if (element.extends) {
+    if (Array.isArray(element.extends) && element.extends.length > 0) {
+      const [firstExtend, ...restExtends] = element.extends;
+      if (typeof firstExtend === "string" && variant && (context == null ? void 0 : context.components)) {
+        const variantKey = `${firstExtend}.${variant}`;
+        if (context.components[variantKey]) {
+          addExtends([variantKey, ...restExtends], element);
+        } else {
+          addExtends(element.extends, element);
+        }
+      } else {
+        addExtends(element.extends, element);
+      }
+    } else if (typeof element.extends === "string" && variant && (context == null ? void 0 : context.components)) {
+      const variantKey = `${element.extends}.${variant}`;
+      if (context.components[variantKey]) {
+        addExtends(variantKey, element);
+      } else {
+        addExtends(element.extends, element);
+      }
+    } else {
+      addExtends(element.extends, element);
+    }
+  }
+  inheritChildPropsExtends(element, parent, options);
+  inheritChildExtends(element, parent, options);
+  inheritRecursiveChildExtends(element, parent, options);
+  if (element.component) {
+    addExtends(exec(element.component, element), element);
+  }
+  if (context.defaultExtends) {
+    addExtends(context.defaultExtends, element);
+  }
+  return removeDuplicatesInArray(ref.__extends);
+};
+const inheritChildPropsExtends = (element, parent, options = {}) => {
+  var _a, _b, _c;
+  const { props, __ref: ref } = element;
+  const ignoreChildExtends = options.ignoreChildExtends || (props == null ? void 0 : props.ignoreChildExtends);
+  if (!ignoreChildExtends) {
+    if ((_b = (_a = parent.props) == null ? void 0 : _a.childProps) == null ? void 0 : _b.extends) {
+      addExtends((_c = parent.props) == null ? void 0 : _c.childProps.extends, element);
+    }
+  }
+  return ref.__extends;
+};
+const inheritChildExtends = (element, parent, options = {}) => {
+  const { props, __ref: ref } = element;
+  const ignoreChildExtends = options.ignoreChildExtends || (props == null ? void 0 : props.ignoreChildExtends);
+  if (!ignoreChildExtends && parent.childExtends) {
+    addExtends(parent.childExtends, element);
+  }
+  return ref.__extends;
+};
+const inheritRecursiveChildExtends = (element, parent, options = {}) => {
+  const { props, __ref: ref } = element;
+  const childExtendsRecursive = parent.childExtendsRecursive;
+  const ignoreChildExtendsRecursive = options.ignoreChildExtendsRecursive || (props == null ? void 0 : props.ignoreChildExtendsRecursive);
+  const isText = element.key === "__text";
+  if (childExtendsRecursive && !isText && !ignoreChildExtendsRecursive) {
+    addExtends(childExtendsRecursive, element);
+  }
+  return ref.__extends;
+};
+const createExtendsStack = (element, parent, options = {}) => {
+  const { props, __ref: ref } = element;
+  const context = element.context || parent.context;
+  const variant = element.variant || (props == null ? void 0 : props.variant);
+  const __extends = removeDuplicatesInArray(
+    ref.__extends.map((val, i) => {
+      return mapStringsWithContextComponents(
+        val,
+        context,
+        options,
+        i === 0 && variant
+      );
+    })
+  );
+  const stack = getExtendsStack(__extends, context);
+  ref.__extendsStack = stack;
+  return ref.__extendsStack;
+};
+const finalizeExtends = (element, parent, options = {}) => {
+  const { __ref: ref } = element;
+  const { __extendsStack } = ref;
+  const flattenExtends = cloneAndMergeArrayExtend(__extendsStack);
+  return deepMergeExtends(element, flattenExtends);
+};
+const applyExtends = (element, parent, options = {}) => {
+  createElementExtends(element, parent, options);
+  createExtendsStack(element, parent, options);
+  finalizeExtends(element, parent, options);
+  return element;
+};
+export {
+  addExtend,
+  addExtends,
+  applyExtends,
+  cloneAndMergeArrayExtend,
+  concatAddExtends,
+  createElementExtends,
+  createExtends,
+  createExtendsFromKeys,
+  createExtendsStack,
+  deepExtend,
+  deepMergeExtends,
+  extendCachedRegistry,
+  extendStackRegistry,
+  extractArrayExtend,
+  finalizeExtends,
+  flattenExtend,
+  generateHash,
+  getExtendsInElement,
+  getExtendsStack,
+  getExtendsStackRegistry,
+  getHashedExtend,
+  inheritChildExtends,
+  inheritChildPropsExtends,
+  inheritRecursiveChildExtends,
+  jointStacks,
+  mapStringsWithContextComponents,
+  setHashedExtend
+};

package/dist/esm/if.js

@@ -0,0 +1,10 @@
+import { isFunction } from "./types.js";
+const createIfConditionFlag = (element, parent) => {
+  const { __ref: ref } = element;
+  if (isFunction(element.if) && !element.if(element, element.state, element.context)) {
+    delete ref.__if;
+  } else ref.__if = true;
+};
+export {
+  createIfConditionFlag
+};

package/dist/esm/index.js

@@ -5,9 +5,19 @@ export * from "./object.js";
 export * from "./function.js";
 export * from "./array.js";
 export * from "./node.js";
+export * from "./if.js";
 export * from "./log.js";
 export * from "./string.js";
 export * from "./globals.js";
 export * from "./cookie.js";
 export * from "./tags.js";
 export * from "./component.js";
+export * from "./props.js";
+export * from "./extends.js";
+export * from "./element.js";
+export * from "./state.js";
+export * from "./keys.js";
+export * from "./scope.js";
+export * from "./methods.js";
+export * from "./cache.js";
+export * from "./update.js";

package/dist/esm/key.js

@@ -1,3 +1,4 @@
+import { exec } from "./object.js";
 const generateKey = /* @__PURE__ */ function() {
   let index = 0;
   function newId() {
@@ -7,7 +8,11 @@ const generateKey = /* @__PURE__ */ function() {
   return newId;
 }();
 const createSnapshotId = generateKey;
+const createKey = (element, parent, key) => {
+  return (exec(key, element) || key || element.key || generateKey()).toString();
+};
 export {
+  createKey,
   createSnapshotId,
   generateKey
 };

package/dist/esm/keys.js

@@ -0,0 +1,158 @@
+const DOMQ_PROPERTIES = [
+  "attr",
+  "style",
+  "text",
+  "html",
+  "content",
+  "data",
+  "class",
+  "state",
+  "scope",
+  "deps",
+  "extends",
+  "$router",
+  "routes",
+  "children",
+  "childExtends",
+  "childExtendsRecursive",
+  "props",
+  "if",
+  "define",
+  "__name",
+  "__ref",
+  "__hash",
+  "__text",
+  "key",
+  "tag",
+  "query",
+  "parent",
+  "node",
+  "variables",
+  "on",
+  "component",
+  "context"
+];
+const PARSED_DOMQ_PROPERTIES = [
+  "attr",
+  "style",
+  "text",
+  "html",
+  "content",
+  "data",
+  "class",
+  "state",
+  "scope",
+  "children",
+  "props",
+  "if",
+  "key",
+  "tag",
+  "query",
+  "on",
+  "context"
+];
+const STATE_PROPERTIES = [
+  "ref",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "root"
+];
+const STATE_METHODS = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "destroy",
+  "add",
+  "toggle",
+  "remove",
+  "apply",
+  "set",
+  "reset",
+  "replace",
+  "quietReplace",
+  "quietUpdate",
+  "applyReplace",
+  "applyFunction",
+  "keys",
+  "values",
+  "ref",
+  "rootUpdate",
+  "parentUpdate",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "root",
+  "setByPath",
+  "setPathCollection",
+  "removeByPath",
+  "removePathCollection",
+  "getByPath"
+];
+const PROPS_METHODS = ["update", "__element"];
+const METHODS = [
+  "set",
+  "reset",
+  "update",
+  "remove",
+  "updateContent",
+  "removeContent",
+  "lookup",
+  "lookdown",
+  "lookdownAll",
+  "getRef",
+  "getPath",
+  "setNodeStyles",
+  "spotByPath",
+  "keys",
+  "parse",
+  "setProps",
+  "parseDeep",
+  "variables",
+  "if",
+  "log",
+  "verbose",
+  "warn",
+  "error",
+  "call",
+  "nextElement",
+  "previousElement"
+];
+const METHODS_EXL = [
+  ...["node", "context", "extends", "__element", "__ref"],
+  ...METHODS,
+  ...STATE_METHODS,
+  ...PROPS_METHODS
+];
+const DOMQL_EVENTS = [
+  "init",
+  "beforeClassAssign",
+  "render",
+  "renderRouter",
+  "attachNode",
+  "stateInit",
+  "stateCreated",
+  "beforeStateUpdate",
+  "stateUpdate",
+  "beforeUpdate",
+  "done",
+  "create",
+  "complete",
+  "frame",
+  "update"
+];
+export {
+  DOMQL_EVENTS,
+  DOMQ_PROPERTIES,
+  METHODS,
+  METHODS_EXL,
+  PARSED_DOMQ_PROPERTIES,
+  PROPS_METHODS,
+  STATE_METHODS,
+  STATE_PROPERTIES
+};