@domql/utils 0.0.1

package/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@domql/utils",
+  "version": "0.0.1",
+  "main": "src/index.js",
+  "license": "MIT"
+}

package/src/index.js

@@ -0,0 +1,6 @@
+'use strict'
+
+export * from './report'
+export * from './object'
+export * from './node'
+export * from './protoUtils'

package/src/node.js

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

package/src/object.js

@@ -0,0 +1,193 @@
+'use strict'
+
+import nodes from '../element/nodes'
+
+export const isTagRegistered = arg => nodes.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 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)
+}
+
+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, proto) => {
+  // console.groupCollapsed('deepMerge:')
+  for (const e in proto) {
+    const elementProp = element[e]
+    const protoProp = proto[e]
+    // const cachedProps = cache.props
+    if (e === 'parent' || e === 'props') continue
+    if (elementProp === undefined) {
+      element[e] = protoProp
+    } else if (isObjectLike(elementProp) && isObject(protoProp)) {
+      deepMerge(elementProp, protoProp)
+    }
+  }
+  // console.groupEnd('deepMerge:')
+  return element
+}
+
+export const clone = obj => {
+  const o = {}
+  for (const prop in obj) {
+    if (prop === 'node') continue
+    o[prop] = obj[prop]
+  }
+  return o
+}
+
+/**
+ * Deep cloning of object
+ */
+export const deepClone = (obj, excluding = ['parent', 'node', '__element', '__root']) => {
+  const o = {}
+  for (const prop in obj) {
+    if (excluding.indexOf(prop) > -1) continue
+    let objProp = obj[prop]
+    if (prop === 'proto' && isArray(objProp)) {
+      objProp = mergeArray(objProp)
+    }
+    if (isObjectLike(objProp)) {
+      o[prop] = deepClone(objProp)
+    } else o[prop] = objProp
+  }
+  return o
+}
+
+/**
+ * Overwrites object properties with another
+ */
+export const overwrite = (element, params, options) => {
+  const changes = {}
+
+  for (const e in params) {
+    if (e === 'props') continue
+
+    const elementProp = element[e]
+    const paramsProp = params[e]
+
+    if (paramsProp) {
+      element.__cached[e] = changes[e] = elementProp
+      element[e] = paramsProp
+    }
+
+    if (options.cleanExec) delete element.__exec[e]
+  }
+
+  return changes
+}
+
+/**
+ * Overwrites DEEPly object properties with another
+ */
+export const overwriteDeep = (obj, params, excluding = ['node', '__root']) => {
+  for (const e in params) {
+    if (excluding.indexOf(e) > -1) continue
+    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 prototypes
+ */
+export const mergeArray = (arr) => {
+  return arr.reduce((a, c) => deepMerge(a, deepClone(c)), {})
+}
+
+/**
+ * Merges array prototypes
+ */
+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 protoOfProto = objectized[prop]
+  if (protoOfProto) flattenRecursive(protoOfProto, prop, stack)
+
+  delete objectized[prop]
+
+  return stack
+}

package/src/protoUtils.js

@@ -0,0 +1,119 @@
+'use strict'
+
+import { isArray, isFunction, isObject } from './object'
+
+export const generateHash = () => Math.random().toString(36).substring(2)
+
+// hashing
+export const protoStackRegistry = {}
+export const protoCachedRegistry = {}
+
+window.protoStackRegistry = protoStackRegistry
+window.protoCachedRegistry = protoCachedRegistry
+
+export const getHashedProto = proto => {
+  return protoStackRegistry[proto.__hash]
+}
+
+export const setHashedProto = (proto, stack) => {
+  const hash = generateHash()
+  proto.__hash = hash
+  protoStackRegistry[hash] = stack
+  return protoStackRegistry[hash]
+}
+
+export const getProtoStackRegistry = (proto, stack) => {
+  if (proto.__hash) {
+    return stack.concat(getHashedProto(proto))
+  } else {
+    setHashedProto(proto, stack)
+  }
+  return stack // .concat(hashedProto)
+}
+
+// stacking
+export const extractArrayProto = (proto, stack) => {
+  proto.forEach(each => flattenProto(each, stack))
+  return stack
+}
+
+export const deepProto = (proto, stack) => {
+  const protoOflattenProto = proto.proto
+  if (protoOflattenProto) {
+    flattenProto(protoOflattenProto, stack)
+  }
+  return stack
+}
+
+export const flattenProto = (proto, stack) => {
+  if (!proto) return stack
+  if (isArray(proto)) return extractArrayProto(proto, stack)
+  stack.push(proto)
+  if (proto.proto) deepProto(proto, stack)
+  return stack
+}
+
+// merging
+export const deepCloneProto = obj => {
+  const o = {}
+  for (const prop in obj) {
+    if (['parent', 'node', '__element', '__root', '__key'].indexOf(prop) > -1) continue
+    const objProp = obj[prop]
+    if (isObject(objProp)) {
+      o[prop] = deepCloneProto(objProp)
+    } else if (isArray(objProp)) {
+      o[prop] = objProp.map(x => x)
+    } else o[prop] = objProp
+  }
+  return o
+}
+
+export const deepMergeProto = (element, proto) => {
+  for (const e in proto) {
+    if (['parent', 'node', '__element', '__root'].indexOf(e) > -1) continue
+    const elementProp = element[e]
+    const protoProp = proto[e]
+    if (elementProp === undefined) {
+      element[e] = protoProp
+    } else if (isObject(elementProp) && isObject(protoProp)) {
+      deepMergeProto(elementProp, protoProp)
+    } else if (isArray(elementProp) && isArray(protoProp)) {
+      element[e] = elementProp.concat(protoProp)
+    } else if (isArray(elementProp) && isObject(protoProp)) {
+      const obj = deepMergeProto({}, elementProp)
+      element[e] = deepMergeProto(obj, protoProp)
+    } else if (elementProp === undefined && isFunction(protoProp)) {
+      element[e] = protoProp
+    }
+  }
+  return element
+}
+
+export const cloneAndMergeArrayProto = stack => {
+  return stack.reduce((a, c) => {
+    return deepMergeProto(a, deepCloneProto(c))
+  }, {})
+}
+
+// joint stacks
+export const jointStacks = (protoStack, childProtoStack) => {
+  return []
+    .concat(protoStack.slice(0, 1))
+    .concat(childProtoStack.slice(0, 1))
+    .concat(protoStack.slice(1))
+    .concat(childProtoStack.slice(1))
+}
+
+// init
+export const getProtoStack = proto => {
+  if (!proto) return []
+  if (proto.__hash) return getHashedProto(proto)
+  const stack = flattenProto(proto, [])
+  // console.log(stack)
+  return getProtoStackRegistry(proto, stack)
+}
+
+export const getProtoMerged = proto => {
+  const stack = getProtoStack(proto)
+  return cloneAndMergeArrayProto(stack)
+}

package/src/report.js

@@ -0,0 +1,62 @@
+'use strict'
+
+export const errors = {
+  en: {
+    DocumentNotDefined: {
+      title: 'Document is undefined',
+      description: 'To tweak with DOM, you should use browser.'
+    },
+    OverwriteToBuiltin: {
+      title: 'Overwriting to builtin method',
+      description: 'Overwriting a builtin method in the global define is not possible, please choose different name'
+    },
+    BrowserNotDefined: {
+      title: 'Can\'t recognize environment',
+      description: 'Environment should be browser application, that can run Javascript'
+    },
+    SetQuickPreferancesIsNotObject: {
+      title: 'Quick preferances object is required',
+      description: 'Please pass a plain object with "lang", "culture" and "area" properties'
+    },
+    InvalidParams: {
+      title: 'Params are invalid',
+      description: 'Please pass a plain object with "lang", "culture" and "area" properties'
+    },
+    CantCreateWithoutNode: {
+      title: 'You must provide node',
+      description: 'Can\'t create DOM element without setting node or text'
+    },
+    HTMLInvalidTag: {
+      title: 'Element tag name (or DOM nodeName) is invalid',
+      description: 'To create element, you must provide valid DOM node. See full list of them at here: http://www.w3schools.com/tags/'
+    },
+    HTMLInvalidAttr: {
+      title: 'Attibutes object is invalid',
+      description: 'Please pass a valid plain object to apply as an attributes for a DOM node'
+    },
+    HTMLInvalidData: {
+      title: 'Data object is invalid',
+      description: 'Please pass a valid plain object to apply as an dataset for a DOM node'
+    },
+    HTMLInvalidStyles: {
+      title: 'Styles object is invalid',
+      description: 'Please pass a valid plain object to apply as an style for a DOM node'
+    },
+    HTMLInvalidText: {
+      title: 'Text string is invalid',
+      description: 'Please pass a valid string to apply text to DOM node'
+    }
+  }
+}
+
+export const report = (err, arg, element) => {
+  const currentLang = 'en'
+  let errObj
+  if (err && typeof err === 'string') errObj = errors[currentLang][err]
+
+  return new Error(
+    `"${err}", "${arg}"\n\n`,
+    `${errObj.description}`,
+    element ? `\n\n${element}` : ''
+  )
+}