@domql/utils 2.3.28 → 2.3.32

package/dist/index.cjs.js

@@ -0,0 +1,23 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./types"), module.exports);
+__reExport(utils_exports, require("./object"), module.exports);
+__reExport(utils_exports, require("./function"), module.exports);
+__reExport(utils_exports, require("./array"), module.exports);
+__reExport(utils_exports, require("./node"), module.exports);
+__reExport(utils_exports, require("./log"), module.exports);

package/dist/index.cjs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../index.js"],
+  "sourcesContent": ["'use strict'\n\nexport * from './types'\nexport * from './object'\nexport * from './function'\nexport * from './array'\nexport * from './node'\nexport * from './log'\n"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAEA,0BAAc,oBAFd;AAGA,0BAAc,qBAHd;AAIA,0BAAc,uBAJd;AAKA,0BAAc,oBALd;AAMA,0BAAc,mBANd;AAOA,0BAAc,kBAPd;",
+  "names": []
+}

package/package.json

@@ -1,12 +1,19 @@
 {
   "name": "@domql/utils",
-  "version": "2.3.28",
-  "main": "index.js",
+  "version": "2.3.32",
   "module": "index.js",
+  "main": "index.js",
+  "browser": "dist/index.cjs.js",
+  "files": [
+    "dist"
+  ],
   "license": "MIT",
+  "scripts": {
+    "prepublish": "rm -rf dist && npx esbuild index.js --target=es2020 --format=cjs --sourcemap=external --outfile=dist/index.cjs.js"
+  },
   "dependencies": {
     "@domql/globals": "latest",
     "@domql/tags": "latest"
   },
-  "gitHead": "ce6edd557f212de49c3fd8419bb8421d28bb1d92"
+  "gitHead": "3908b29bdaa12549b3ff14ec144331a2a0d125b3"
 }

package/array.js

@@ -1 +0,0 @@
-'use strict'

package/function.js

@@ -1,23 +0,0 @@
-'use strict'
-
-export const debounce = (element, func, timeout = 300) => {
-  let timer
-  return (...args) => {
-    clearTimeout(timer)
-    timer = setTimeout(() => { func.apply(element, args) }, timeout)
-  }
-}
-
-export const memoize = (fn) => {
-  const cache = {}
-  return (...args) => {
-    const n = args[0]
-    if (n in cache) {
-      return cache[n]
-    } else {
-      const result = fn(n)
-      cache[n] = result
-      return result
-    }
-  }
-}

package/log.js

@@ -1,10 +0,0 @@
-'use strict'
-
-export const logIf = (bool, ...arg) => { if (bool) arg.map(v => console.log(v)) }
-export const logGroupIf = (bool, key, ...arg) => {
-  if (bool) {
-    console.group(key)
-    arg.map(v => console.log(v))
-    console.groupEnd(key)
-  }
-}

package/node.js

@@ -1,10 +0,0 @@
-'use strict'
-
-export const cleanWithNode = extend => delete extend.node && extend
-
-export const createID = (function * () {
-  let index = 1
-  while (index < index + 1) {
-    yield index++
-  }
-}())

package/object.js

@@ -1,266 +0,0 @@
-'use strict'
-
-import { isFunction, isObjectLike, isObject, isArray, isString } from './types'
-
-export const exec = (param, element, state) => {
-  if (isFunction(param)) return param(element, state || element.state)
-  return param
-}
-
-export const map = (obj, extention, element) => {
-  for (const e in extention) {
-    obj[e] = exec(extention[e], element)
-  }
-}
-
-export const merge = (element, obj) => {
-  for (const e in obj) {
-    const elementProp = element[e]
-    const objProp = obj[e]
-    if (elementProp === undefined) {
-      element[e] = objProp
-    }
-  }
-  return element
-}
-
-export const deepMerge = (element, extend) => {
-  for (const e in extend) {
-    const elementProp = element[e]
-    const extendProp = extend[e]
-    // const cachedProps = cache.props
-    if (e === 'parent' || e === 'props') continue
-    if (elementProp === undefined) {
-      element[e] = extendProp
-    } else if (isObjectLike(elementProp) && isObject(extendProp)) {
-      deepMerge(elementProp, extendProp)
-    }
-  }
-  return element
-}
-
-export const clone = obj => {
-  const o = {}
-  for (const prop in obj) {
-    if (prop === 'node') continue
-    o[prop] = obj[prop]
-  }
-  return o
-}
-
-// Clone anything deeply but exclude keys given in 'exclude'
-export const deepCloneExclude = (obj, exclude = []) => {
-  if (isArray(obj)) {
-    return obj.map(x => deepCloneExclude(x, exclude))
-  }
-
-  const o = {}
-  for (const k in obj) {
-    if (exclude.indexOf(k) > -1) continue
-
-    let v = obj[k]
-
-    if (k === 'extend' && isArray(v)) {
-      v = mergeArrayExclude(v, exclude)
-    }
-
-    if (isArray(v)) {
-      o[k] = v.map(x => deepCloneExclude(x, exclude))
-    } else if (isObject(v)) {
-      o[k] = deepCloneExclude(v, exclude)
-    } else o[k] = v
-  }
-
-  return o
-}
-
-// Merge array, but exclude keys listed in 'excl'
-export const mergeArrayExclude = (arr, excl = []) => {
-  return arr.reduce((acc, curr) => deepMerge(acc, deepCloneExclude(curr, excl)), {})
-}
-
-/**
- * Deep cloning of object
- */
-export const deepClone = (obj) => {
-  if (isArray(obj)) {
-    return obj.map(deepClone)
-  }
-  const o = {}
-  for (const prop in obj) {
-    let objProp = obj[prop]
-    if (prop === 'extend' && isArray(objProp)) {
-      objProp = mergeArray(objProp)
-    }
-    if (isArray(objProp)) {
-      o[prop] = objProp.map(v => isObject(v) ? deepClone(v) : v)
-    } else if (isObject(objProp)) {
-      o[prop] = deepClone(objProp)
-    } else o[prop] = objProp
-  }
-  return o
-}
-
-/**
- * Stringify object
- */
-export const deepStringify = (obj, stringified = {}) => {
-  for (const prop in obj) {
-    const objProp = obj[prop]
-    if (isFunction(objProp)) {
-      stringified[prop] = objProp.toString()
-    } else if (isObject(objProp)) {
-      stringified[prop] = {}
-      deepStringify(objProp[prop], stringified[prop])
-    } else if (isArray(objProp)) {
-      stringified[prop] = []
-      objProp.map((v, i) => deepStringify(v, stringified[prop][i]))
-    } else stringified[prop] = objProp
-  }
-  return stringified
-}
-
-/**
- * Detringify object
- */
-export const deepDestringify = (obj, stringified = {}) => {
-  for (const prop in obj) {
-    const objProp = obj[prop]
-    if (isString(objProp)) {
-      if (objProp.includes('=>') || objProp.includes('function') || objProp[0] === '(') {
-        try {
-          const evalProp = eval(objProp) // eslint-disable-line
-          stringified[prop] = evalProp
-        } catch (e) { if (e) stringified[prop] = objProp }
-      }
-    } else stringified[prop] = objProp
-    if (isObject(objProp)) deepDestringify(stringified[prop], stringified[prop])
-  }
-  return stringified
-}
-
-/**
- * Overwrites object properties with another
- */
-export const overwrite = (element, params, options) => {
-  const { ref } = element
-  const changes = {}
-
-  for (const e in params) {
-    if (e === 'props') continue
-
-    const elementProp = element[e]
-    const paramsProp = params[e]
-
-    if (paramsProp) {
-      ref.__cache[e] = changes[e] = elementProp
-      ref[e] = paramsProp
-    }
-  }
-
-  return changes
-}
-
-export const diff = (obj, original, cache) => {
-  const changes = cache || {}
-  for (const e in obj) {
-    if (e === 'ref') continue
-    const originalProp = original[e]
-    const objProp = obj[e]
-    if (isObjectLike(originalProp) && isObjectLike(objProp)) {
-      changes[e] = {}
-      diff(originalProp, objProp, changes[e])
-    } else if (objProp !== undefined) {
-      changes[e] = objProp
-    }
-  }
-  return changes
-}
-
-/**
- * Overwrites object properties with another
- */
-export const overwriteObj = (params, obj) => {
-  const changes = {}
-
-  for (const e in params) {
-    const objProp = obj[e]
-    const paramsProp = params[e]
-
-    if (paramsProp) {
-      obj[e] = changes[e] = objProp
-    }
-  }
-
-  return changes
-}
-
-/**
- * Overwrites DEEPly object properties with another
- */
-export const overwriteDeep = (params, obj) => {
-  for (const e in params) {
-    const objProp = obj[e]
-    const paramsProp = params[e]
-    if (isObjectLike(objProp) && isObjectLike(paramsProp)) {
-      overwriteDeep(objProp, paramsProp)
-    } else if (paramsProp !== undefined) {
-      obj[e] = paramsProp
-    }
-  }
-  return obj
-}
-
-/**
- * Overwrites object properties with another
- */
-export const mergeIfExisted = (a, b) => {
-  if (isObjectLike(a) && isObjectLike(b)) return deepMerge(a, b)
-  return a || b
-}
-
-/**
- * Merges array extendtypes
- */
-export const mergeArray = (arr) => {
-  return arr.reduce((a, c) => deepMerge(a, deepClone(c)), {})
-}
-
-/**
- * Merges array extendtypes
- */
-export const mergeAndCloneIfArray = obj => {
-  return isArray(obj) ? mergeArray(obj) : deepClone(obj)
-}
-
-/**
- * Overwrites object properties with another
- */
-export const flattenRecursive = (param, prop, stack = []) => {
-  const objectized = mergeAndCloneIfArray(param)
-  stack.push(objectized)
-
-  const extendOfExtend = objectized[prop]
-  if (extendOfExtend) flattenRecursive(extendOfExtend, prop, stack)
-
-  delete objectized[prop]
-
-  return stack
-}
-
-export const isEqualDeep = (param, element) => {
-  if (param === element) return true
-  if (!param || !element) return false
-  for (const prop in param) {
-    const paramProp = param[prop]
-    const elementProp = element[prop]
-    if (isObjectLike(paramProp)) {
-      const isEqual = isEqualDeep(paramProp, elementProp)
-      if (!isEqual) return false
-    } else {
-      const isEqual = paramProp === elementProp
-      if (!isEqual) return false
-    }
-  }
-  return true
-}

package/types.js

@@ -1,87 +0,0 @@
-'use strict'
-
-import { window } from '@domql/globals'
-import { HTML_TAGS } from '@domql/tags'
-
-export const isValidHtmlTag = arg => HTML_TAGS.body.indexOf(arg)
-
-export const isObject = arg => {
-  if (arg === null) return false
-  return (typeof arg === 'object') && (arg.constructor === Object)
-}
-
-export const isString = arg => typeof arg === 'string'
-
-export const isNumber = arg => typeof arg === 'number'
-
-export const isFunction = arg => typeof arg === 'function'
-
-export const isBoolean = arg => arg === true || arg === false
-
-export const isNull = arg => arg === null
-
-export const isArray = arg => Array.isArray(arg)
-
-export const isObjectLike = arg => {
-  if (arg === null) return false
-  // if (isArray(arg)) return false
-  return (typeof arg === 'object')
-}
-
-export const isNode = obj => {
-  return (
-    typeof window.Node === 'object'
-      ? obj instanceof window.Node
-      : obj && typeof obj === 'object' && typeof obj.nodeType === 'number' && typeof obj.nodeName === 'string'
-  )
-}
-
-export const isHtmlElement = obj => {
-  return (
-    typeof window.HTMLElement === 'object'
-      ? obj instanceof window.HTMLElement // DOM2
-      : obj && typeof obj === 'object' && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === 'string'
-  )
-}
-
-export const isDefined = arg => {
-  return isObject(arg) ||
-    isObjectLike(arg) ||
-    isString(arg) ||
-    isNumber(arg) ||
-    isFunction(arg) ||
-    isArray(arg) ||
-    isObjectLike(arg) ||
-    isBoolean(arg) ||
-    isNull(arg)
-}
-
-export const isUndefined = arg => {
-  return arg === undefined
-}
-
-export const TYPES = {
-  boolean: isBoolean,
-  array: isArray,
-  object: isObject,
-  string: isString,
-  number: isNumber,
-  null: isNull,
-  function: isFunction,
-  objectLike: isObjectLike,
-  node: isNode,
-  htmlElement: isHtmlElement,
-  defined: isDefined
-}
-
-export const is = (arg) => {
-  return (...args) => {
-    return args.map(val => TYPES[val](arg)).filter(v => v).length > 0
-  }
-}
-
-export const isNot = (arg) => {
-  return (...args) => {
-    return args.map(val => TYPES[val](arg)).filter(v => v).length === 0
-  }
-}