@domql/utils 2.5.200 → 3.0.1

package/dist/esm/state.js

@@ -0,0 +1,185 @@
+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 { addProtoToArray } from "./array.js";
+import { STATE_METHODS } from "./keys.js";
+import {
+  deepClone,
+  deepMerge,
+  execPromise,
+  overwriteDeep,
+  overwriteShallow
+} from "./object.js";
+import {
+  is,
+  isFunction,
+  isObject,
+  isObjectLike,
+  isString,
+  isUndefined
+} from "./types.js";
+const checkForStateTypes = async (element) => {
+  const { state: orig, props, __ref: ref } = element;
+  const state = (props == null ? void 0 : props.state) || orig;
+  if (isFunction(state)) {
+    ref.__state = state;
+    return await execPromise(state, element);
+  } else if (is(state)("string", "number")) {
+    ref.__state = state;
+    return { value: state };
+  } else if (state === true) {
+    ref.__state = element.key;
+    return {};
+  } else if (state) {
+    ref.__hasRootState = true;
+    return state;
+  } else {
+    return false;
+  }
+};
+const getRootStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("~/")) return;
+  const arr = stateKey.split("~/");
+  if (arr.length > 1) return parentState.root;
+};
+const getParentStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("../")) return;
+  const arr = stateKey.split("../");
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    if (!parentState.parent) return null;
+    parentState = parentState.parent;
+  }
+  return parentState;
+};
+const getChildStateInKey = (stateKey, parentState, options = {}) => {
+  const arr = isString(stateKey) ? stateKey.split("/") : [stateKey];
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    const childKey = arr[i];
+    const grandChildKey = arr[i + 1];
+    if (childKey === "__proto__" || grandChildKey === "__proto__") return;
+    let childInParent = parentState[childKey];
+    if (!childInParent) childInParent = parentState[childKey] = {};
+    if (!childInParent[grandChildKey]) childInParent[grandChildKey] = {};
+    stateKey = grandChildKey;
+    parentState = childInParent;
+  }
+  if (options.returnParent) return parentState;
+  return parentState[stateKey];
+};
+const findInheritedState = (element, parent, options = {}) => {
+  const ref = element.__ref;
+  let stateKey = ref.__state;
+  if (!checkIfInherits(element)) return;
+  const rootState = getRootStateInKey(stateKey, parent.state);
+  let parentState = parent.state;
+  if (rootState) {
+    parentState = rootState;
+    stateKey = stateKey.replaceAll("~/", "");
+  } else {
+    const findGrandParentState = getParentStateInKey(stateKey, parent.state);
+    if (findGrandParentState) {
+      parentState = findGrandParentState;
+      stateKey = stateKey.replaceAll("../", "");
+    }
+  }
+  if (!parentState) return;
+  return getChildStateInKey(stateKey, parentState, options);
+};
+const createInheritedState = (element, parent) => {
+  const ref = element.__ref;
+  const inheritedState = findInheritedState(element, parent);
+  if (isUndefined(inheritedState)) return element.state;
+  if (is(inheritedState)("object", "array")) {
+    return deepClone(inheritedState);
+  } else if (is(inheritedState)("string", "number", "boolean")) {
+    ref.__stateType = typeof inheritedState;
+    return { value: inheritedState };
+  }
+  console.warn(ref.__state, "is not present. Replacing with", {});
+};
+const checkIfInherits = (element) => {
+  const { __ref: ref } = element;
+  const stateKey = ref == null ? void 0 : ref.__state;
+  if (stateKey && is(stateKey)("number", "string", "boolean")) return true;
+  return false;
+};
+const isState = function(state) {
+  if (!isObjectLike(state)) return false;
+  return Boolean(
+    state.update && state.parse && state.clean && state.create && state.parent && state.destroy && state.rootUpdate && state.parentUpdate && state.keys && state.values && state.toggle && state.replace && state.quietUpdate && state.quietReplace && state.add && state.apply && state.applyReplace && state.setByPath && state.setPathCollection && state.removeByPath && state.removePathCollection && state.getByPath && state.applyFunction && state.__element && state.__children
+  );
+};
+const createNestedObjectByKeyPath = (path, value) => {
+  if (!path) {
+    return value || {};
+  }
+  const keys = path.split("/");
+  const obj = {};
+  let ref = obj;
+  keys.forEach((key, index) => {
+    ref[key] = index === keys.length - 1 ? value || {} : {};
+    ref = ref[key];
+  });
+  return obj;
+};
+const applyDependentState = async (element, state) => {
+  const { __element } = state;
+  const origState = await execPromise(__element == null ? void 0 : __element.state, element);
+  if (!origState) return;
+  const dependentState = deepClone(origState, STATE_METHODS);
+  const newDepends = { [element.key]: dependentState };
+  const __depends = isObject(origState.__depends) ? __spreadValues(__spreadValues({}, origState.__depends), newDepends) : newDepends;
+  if (Array.isArray(origState)) {
+    addProtoToArray(origState, __spreadProps(__spreadValues({}, Object.getPrototypeOf(origState)), {
+      __depends
+    }));
+  } else {
+    Object.setPrototypeOf(origState, __spreadProps(__spreadValues({}, Object.getPrototypeOf(origState)), {
+      __depends
+    }));
+  }
+  return dependentState;
+};
+const overwriteState = (state, obj, options = {}) => {
+  const { overwrite } = options;
+  if (!overwrite) return;
+  const shallow = overwrite === "shallow";
+  const merge = overwrite === "merge";
+  if (merge) {
+    deepMerge(state, obj, STATE_METHODS);
+    return;
+  }
+  const overwriteFunc = shallow ? overwriteShallow : overwriteDeep;
+  overwriteFunc(state, obj, STATE_METHODS);
+};
+export {
+  applyDependentState,
+  checkForStateTypes,
+  checkIfInherits,
+  createInheritedState,
+  createNestedObjectByKeyPath,
+  findInheritedState,
+  getChildStateInKey,
+  getParentStateInKey,
+  getRootStateInKey,
+  isState,
+  overwriteState
+};

package/dist/esm/string.js

@@ -11,28 +11,37 @@ const trimStringFromSymbols = (str, characters) => {
   return str.replace(pattern, "");
 };
 const brackRegex = {
-  2: /\{\{\s*((?:\.\.\/)+)?([^}\s]+)\s*\}\}/g,
-  3: /\{\{\{\s*((?:\.\.\/)+)?([^}\s]+)\s*\}\}\}/g
+  2: /{{\s*((?:\.\.\/)*)([\w\d.]+)\s*}}/g,
+  3: /{{{(\s*(?:\.\.\/)*)([\w\d.]+)\s*}}}/g
 };
-function replaceLiteralsWithObjectFields(str, options = {}, forcedState) {
-  if (!str.includes(options.bracketsLength === 3 ? "{{{" : "{{")) return str;
-  const reg = brackRegex[options.bracketsLength || 2];
-  const obj = forcedState || (this == null ? void 0 : this.state) || {};
+const getNestedValue = (obj, path) => {
+  return path.split(".").reduce((acc, part) => {
+    return acc && acc[part] !== void 0 ? acc[part] : void 0;
+  }, obj);
+};
+function replaceLiteralsWithObjectFields(str, state = {}, options = {}) {
+  const { bracketsLength = 2 } = options;
+  const bracketPattern = bracketsLength === 3 ? "{{{" : "{{";
+  if (!str.includes(bracketPattern)) return str;
+  const reg = brackRegex[bracketsLength];
+  const obj = state || {};
   return str.replace(reg, (_, parentPath, variable) => {
     if (parentPath) {
-      const parentLevels = parentPath.match(options.bracketsLength === 3 ? /\.\.\.\//g : /\.\.\//g).length;
+      const parentLevels = (parentPath.match(/\.\.\//g) || []).length;
       let parentState = obj;
       for (let i = 0; i < parentLevels; i++) {
+        if (!parentState || !parentState.parent) return "";
         parentState = parentState.parent;
-        if (!parentState) {
-          return "";
-        }
       }
-      const value = parentState[variable.trim()];
-      return value !== void 0 ? `${value}` : "";
+      const key = variable.trim();
+      if (key === "parent") {
+        return parentState.value !== void 0 ? String(parentState.value) : "";
+      }
+      const value = getNestedValue(parentState, key);
+      return value !== void 0 ? String(value) : "";
     } else {
-      const value = obj[variable.trim()];
-      return value !== void 0 ? `${value}` : "";
+      const value = getNestedValue(obj, variable.trim());
+      return value !== void 0 ? String(value) : "";
     }
   });
 }
@@ -108,7 +117,10 @@ const customEncodeURIComponent = (str) => {
   }).join("");
 };
 const customDecodeURIComponent = (encodedStr) => {
-  return encodedStr.replace(/%[0-9A-Fa-f]{2}/g, (match) => String.fromCharCode(parseInt(match.slice(1), 16)));
+  return encodedStr.replace(
+    /%[0-9A-Fa-f]{2}/g,
+    (match) => String.fromCharCode(parseInt(match.slice(1), 16))
+  );
 };
 export {
   customDecodeURIComponent,

package/dist/esm/update.js

@@ -0,0 +1,22 @@
+import { createSnapshotId } from "./key.js";
+const snapshot = {
+  snapshotId: createSnapshotId
+};
+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 = calleeElement.__ref.__currentSnapshot;
+  if (currentSnapshot < snapshotOnCallee) {
+    return [snapshotOnCallee, calleeElement, true];
+  }
+  return [snapshotOnCallee, calleeElement];
+};
+export {
+  captureSnapshot
+};

package/element.js

@@ -0,0 +1,148 @@
+'use strict'
+
+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 = process.env.NODE_ENV
+
+export 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'
+  }
+}
+
+export const createBasedOnType = (element, parent, key) => {
+  // if ELEMENT is not given
+  if (element === undefined) {
+    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
+}
+
+export const addRef = (element, parent) => {
+  const ref = {}
+  ref.origin = element
+  ref.parent = parent
+  return ref
+}
+
+export 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
+}
+
+export const createRoot = (element, parent) => {
+  const { __ref: ref } = element
+  const { __ref: parentRef } = parent
+
+  const hasRoot = parent && parent.key === ':root'
+  if (!ref?.root) {
+    ref.root = hasRoot ? element : parentRef?.root
+  }
+}
+
+export const createPath = (element, parent, key) => {
+  let { __ref: parentRef } = parent
+  // set the PATH array
+  if (!parentRef) parentRef = parent.ref = {}
+  if (!parentRef.path) parentRef.path = []
+  return parentRef.path.concat(key)
+}
+
+export const addContext = (element, parent, key, options, root) => {
+  const forcedOptionsContext =
+    options.context && !root.context && !element.context
+  if (forcedOptionsContext) root.context = options.context
+
+  // inherit from parent or root
+  return options.context || parent.context || root.context || element.context
+}
+
+export const addCaching = (element, parent, key) => {
+  const ref = addRef(element, parent)
+
+  element.__ref = ref
+
+  // enable CACHING
+  if (!ref.__defineCache) ref.__defineCache = {}
+
+  // enable EXEC
+  if (!ref.__exec) ref.__exec = {}
+  if (!ref.__execProps) ref.__execProps = {}
+
+  // enable CLASS CACHING
+  if (!ref.__class) ref.__class = {}
+  if (!ref.__classNames) ref.__classNames = {}
+
+  // enable CLASS CACHING
+  if (!ref.__attr) ref.__attr = {}
+
+  // enable CHANGES storing
+  if (!ref.__changes) ref.__changes = []
+
+  // enable CHANGES storing
+  if (!ref.__children) ref.__children = []
+
+  ref.__extends = createExtends(element, parent, key)
+  ref.path = createPath(element, parent, key)
+
+  return ref
+}
+
+export const createElement = (passedProps, parentEl, passedKey, opts, root) => {
+  const hashed = 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 {
+    ...element,
+    key,
+    props,
+    parent,
+    context,
+    on
+  }
+}

package/env.js

@@ -2,9 +2,12 @@
 
 export const NODE_ENV = process.env.NODE_ENV
 
-export const isProduction = (env = NODE_ENV) => (env === 'production' || env === 'prod') ||
+export const isProduction = (env = NODE_ENV) =>
+  env === 'production' ||
+  env === 'prod' ||
   (env !== 'development' && env !== 'dev' && env !== 'test')
 export const isTest = (env = NODE_ENV) => env === 'test'
-export const isDevelopment = (env = NODE_ENV) => env === 'development' || env === 'dev'
+export const isDevelopment = (env = NODE_ENV) =>
+  env === 'development' || env === 'dev'
 
 export const getNev = (key, env = NODE_ENV) => env[key]

package/events.js

@@ -0,0 +1,17 @@
+'use strict'
+
+import { lowercaseFirstLetter } from './string.js'
+import { isFunction } from './types.js'
+
+export 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
+}