domql 1.6.39 → 1.6.41

package/packages/extends/node_modules/@domql/utils/object.js

@@ -0,0 +1,195 @@
+'use strict'
+
+import { isFunction, isObjectLike, isObject, isArray } 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) => {
+  // console.groupCollapsed('deepMerge:')
+  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)
+    }
+  }
+  // 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 === 'extend' && 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 { 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/packages/extends/node_modules/@domql/utils/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@domql/utils",
+  "version": "2.3.11",
+  "main": "index.js",
+  "license": "MIT",
+  "dependencies": {
+    "@domql/tags": "latest"
+  },
+  "gitHead": "b68b909999a34649b9bc1679663442c3580ada3f",
+  "source": "index.js"
+}

package/packages/extends/node_modules/@domql/utils/types.js

@@ -0,0 +1,74 @@
+'use strict'
+
+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 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 TYPES = {
+  array: isArray,
+  object: isObject,
+  string: isString,
+  number: isNumber,
+  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
+  }
+}

package/packages/iterate/node_modules/@domql/methods/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 rackai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/packages/iterate/node_modules/@domql/methods/index.js

@@ -0,0 +1,96 @@
+'use strict'
+
+import { isObject, isObjectLike } from '@domql/utils'
+import { DEFAULT_METHODS } from '@domql/registry'
+
+// TODO: update these files
+export const lookup = function (key) {
+  const element = this
+  let { parent } = element
+
+  while (parent.key !== key) {
+    parent = parent.parent
+    if (!parent) return
+  }
+
+  return parent
+}
+
+export const remove = function (params) {
+  const element = this
+  element.node.remove()
+  delete element.parent[element.key]
+}
+
+export const get = function (param) {
+  const element = this
+  return element[param]
+}
+
+// export const set = function () {
+// }
+
+// export const update = function () {
+// }
+
+export const defineSetter = (element, key, get, set) =>
+  Object.defineProperty(element, key, { get, set })
+
+export const keys = function () {
+  const element = this
+  const keys = []
+  for (const param in element) {
+    if (!isObject(DEFAULT_METHODS[param])) {
+      keys.push(param)
+    }
+  }
+  return keys
+}
+
+export const parse = function () {
+  const element = this
+  const obj = {}
+  const keys = element.keys()
+  keys.forEach(v => (obj[v] = element[v]))
+  return obj
+}
+
+export const parseDeep = function (param) {
+  const element = this
+  const orig = param || element
+  const obj = {}
+  const keys = orig.keys && orig.keys()
+  if (!keys) return
+  keys.forEach(v => {
+    const prop = orig[v]
+    if (isObjectLike(prop)) parseDeep(prop)
+    else obj[v] = prop
+  })
+  return obj
+}
+
+export const log = function (...args) {
+  const element = this
+  console.group(element.key)
+  if (args.length) {
+    args.forEach(v => console.log(`%c${v}:\n`, 'font-weight: bold', element[v]))
+  } else {
+    console.log(element.path)
+    const keys = element.keys()
+    keys.forEach(v => console.log(`%c${v}:\n`, 'font-weight: bold', element[v]))
+  }
+  console.groupEnd(element.key)
+  return element
+}
+
+export const isMethod = function (param) {
+  return param === 'set' ||
+    param === 'update' ||
+    param === 'remove' ||
+    param === 'lookup' ||
+    param === 'keys' ||
+    param === 'parse' ||
+    param === 'parseDeep' ||
+    param === 'if' ||
+    param === 'log'
+}

package/packages/iterate/node_modules/@domql/methods/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@domql/methods",
+  "version": "2.1.0",
+  "main": "index.js",
+  "license": "MIT",
+  "dependencies": {
+    "@domql/registry": "latest",
+    "@domql/utils": "latest"
+  },
+  "gitHead": "1e384e4a15f44201165f6bd54efb4a0e9c105745",
+  "source": "src/index.js"
+}

package/packages/iterate/node_modules/@domql/registry/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 rackai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/packages/iterate/node_modules/@domql/registry/index.js

@@ -0,0 +1,4 @@
+'use strict'
+
+export * from './methods'
+export * from './tags'

package/packages/iterate/node_modules/@domql/registry/methods.js

@@ -0,0 +1,67 @@
+'use strict'
+
+import { exec } from '@domql/utils'
+
+export const DEFAULT_METHODS = {
+  key: {},
+  tag: {},
+
+  if: {},
+  define: {},
+
+  attr: {},
+  style: {},
+
+  content: {},
+  class: {},
+
+  props: {},
+  state: {},
+
+  method: {},
+  transform: {},
+
+  on: {},
+
+  ref: {},
+
+  extend: {},
+  childExtends: {},
+  text: (element, state) => {
+    element.ref.text = {
+      tag: 'text',
+      text: exec(element.text, element, state)
+    }
+  },
+
+  innerHTML: {},
+
+  set: {},
+  update: {},
+  remove: {}
+}
+
+// log: {}
+// value: {},
+// text: {},
+// html: {},
+// path: {},
+// data: {},
+// if: {},
+// __hash: {},
+// __cache: {},
+// __defined: {},
+// __exec: {},
+// __changes: {},
+// __trash: {},
+// __root: {},
+// __props: {},
+// __extend: {},
+// __ifFragment: {},
+// __ifFalsy: {},
+// parent: {},
+// node: {},
+// lookup: {},
+// keys: {},
+// parse: {},
+// parseDeep: {},

package/packages/iterate/node_modules/@domql/registry/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@domql/registry",
+  "version": "2.3.0",
+  "main": "index.js",
+  "license": "MIT",
+  "source": "index.js",
+  "dependencies": {
+    "@domql/utils": "latest"
+  },
+  "gitHead": "02944ad228d2cf5f5727b08e9378d221b2f7205b"
+}

package/packages/iterate/node_modules/@domql/registry/tags.js

@@ -0,0 +1,139 @@
+'use strict'
+
+export const TAGS = {
+  root: [
+    'body',
+    'html'
+  ],
+
+  head: [
+    'title',
+    'base',
+    'meta',
+    'style'
+  ],
+
+  body: [
+    'string',
+    'fragment',
+    'a',
+    'abbr',
+    'acronym',
+    'address',
+    'applet',
+    'area',
+    'article',
+    'aside',
+    'audio',
+    'b',
+    'basefont',
+    'bdi',
+    'bdo',
+    'big',
+    'blockquote',
+    'br',
+    'button',
+    'canvas',
+    'caption',
+    'center',
+    'cite',
+    'code',
+    'col',
+    'colgroup',
+    'data',
+    'datalist',
+    'dd',
+    'del',
+    'details',
+    'dfn',
+    'dialog',
+    'dir',
+    'div',
+    'dl',
+    'dt',
+    'em',
+    'embed',
+    'fieldset',
+    'figcaption',
+    'figure',
+    'font',
+    'footer',
+    'form',
+    'frame',
+    'frameset',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'head',
+    'header',
+    'hr',
+    'i',
+    'iframe',
+    'img',
+    'input',
+    'ins',
+    'kbd',
+    'label',
+    'legend',
+    'li',
+    'link',
+    'main',
+    'map',
+    'mark',
+    'meter',
+    'nav',
+    'noframes',
+    'noscript',
+    'object',
+    'ol',
+    'optgroup',
+    'option',
+    'output',
+    'p',
+    'param',
+    'picture',
+    'pre',
+    'progress',
+    'q',
+    'rp',
+    'rt',
+    'ruby',
+    's',
+    'samp',
+    'script',
+    'section',
+    'select',
+    'small',
+    'source',
+    'span',
+    'strike',
+    'strong',
+    'sub',
+    'summary',
+    'sup',
+    'table',
+    'tbody',
+    'td',
+    'template',
+    'textarea',
+    'tfoot',
+    'th',
+    'thead',
+    'time',
+    'tr',
+    'track',
+    'tt',
+    'u',
+    'ul',
+    'var',
+    'video',
+    'wbr',
+
+    // SVG
+    'svg',
+    'path'
+  ]
+}

package/packages/iterate/node_modules/@domql/tags/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 rackai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.