domql 1.6.39 → 1.6.41

package/packages/transform-react/node_modules/@domql/extends/extendUtils.js

@@ -0,0 +1,118 @@
+'use strict'
+
+import { isArray, isFunction, isObject } from '@domql/utils'
+
+export const generateHash = () => Math.random().toString(36).substring(2)
+
+// hashing
+export const extendStackRegistry = {}
+export const extendCachedRegistry = {}
+
+window.extendStackRegistry = extendStackRegistry
+window.extendCachedRegistry = extendCachedRegistry
+
+export const getHashedExtend = extend => {
+  return extendStackRegistry[extend.__hash]
+}
+
+export const setHashedExtend = (extend, stack) => {
+  const hash = generateHash()
+  extend.__hash = hash
+  extendStackRegistry[hash] = stack
+  return extendStackRegistry[hash]
+}
+
+export const getExtendStackRegistry = (extend, stack) => {
+  if (extend.__hash) {
+    return stack.concat(getHashedExtend(extend))
+  } else {
+    setHashedExtend(extend, stack)
+  }
+  return stack // .concat(hashedExtend)
+}
+
+// stacking
+export const extractArrayExtend = (extend, stack) => {
+  extend.forEach(each => flattenExtend(each, stack))
+  return stack
+}
+
+export const deepExtend = (extend, stack) => {
+  const extendOflattenExtend = extend.extends
+  if (extendOflattenExtend) {
+    flattenExtend(extendOflattenExtend, stack)
+  }
+  return stack
+}
+
+export const flattenExtend = (extend, stack) => {
+  if (!extend) return stack
+  if (isArray(extend)) return extractArrayExtend(extend, stack)
+  stack.push(extend)
+  if (extend.extends) deepExtend(extend, stack)
+  return stack
+}
+
+// merging
+export const deepCloneExtend = obj => {
+  const o = {}
+  for (const prop in obj) {
+    if (['ref'].indexOf(prop) > -1) continue
+    const objProp = obj[prop]
+    if (isObject(objProp)) {
+      o[prop] = deepCloneExtend(objProp)
+    } else if (isArray(objProp)) {
+      o[prop] = objProp.map(x => x)
+    } else o[prop] = objProp
+  }
+  return o
+}
+
+export const deepMergeExtend = (element, extend) => {
+  for (const e in extend) {
+    if (e === 'ref') continue
+    const elementProp = element[e]
+    const extendProp = extend[e]
+    if (elementProp === undefined) {
+      element[e] = extendProp
+    } else if (isObject(elementProp) && isObject(extendProp)) {
+      deepMergeExtend(elementProp, extendProp)
+    } else if (isArray(elementProp) && isArray(extendProp)) {
+      element[e] = elementProp.concat(extendProp)
+    } else if (isArray(elementProp) && isObject(extendProp)) {
+      const obj = deepMergeExtend({}, elementProp)
+      element[e] = deepMergeExtend(obj, extendProp)
+    } else if (elementProp === undefined && isFunction(extendProp)) {
+      element[e] = extendProp
+    }
+  }
+  return element
+}
+
+export const cloneAndMergeArrayExtend = stack => {
+  return stack.reduce((a, c) => {
+    return deepMergeExtend(a, deepCloneExtend(c))
+  }, {})
+}
+
+// joint stacks
+export const jointStacks = (extendStack, childExtendStack) => {
+  return []
+    .concat(extendStack.slice(0, 1))
+    .concat(childExtendStack.slice(0, 1))
+    .concat(extendStack.slice(1))
+    .concat(childExtendStack.slice(1))
+}
+
+// init
+export const getExtendStack = extend => {
+  if (!extend) return []
+  if (extend.__hash) return getHashedExtend(extend)
+  const stack = flattenExtend(extend, [])
+  return getExtendStackRegistry(extend, stack)
+}
+
+export const getExtendMerged = extend => {
+  const stack = getExtendStack(extend)
+  return cloneAndMergeArrayExtend(stack)
+}

package/packages/transform-react/node_modules/@domql/extends/index.js

@@ -0,0 +1,56 @@
+'use strict'
+
+import { isFunction, exec } from '@domql/utils'
+import { getExtendStack, jointStacks, cloneAndMergeArrayExtend, deepMergeExtend } from './extendUtils'
+
+const ENV = process.env.NODE_ENV
+
+/**
+ * Checks whether element has `extend` or is a part
+ * of parent's `childExtend` extendtype
+ */
+export const extendElement = (element, parent, options = {}) => {
+  if (isFunction(element)) element = exec(element, parent)
+
+  const { extend: ext } = element
+
+  // merge if extend is array
+  // const extend = mergeAndCloneIfArray(element.extend, v => {
+  //   if (v.props) cache.props.push(v.props)
+  // })
+
+  const extendStack = getExtendStack(ext)
+
+  if (ENV !== 'development') delete element.extends
+
+  let childExtendStack = []
+  if (!options.ignoreChildExtend) {
+    childExtendStack = getExtendStack(parent.childExtends)
+  }
+
+  const extendLength = extendStack.length
+  const childExtendLength = childExtendStack.length
+
+  let stack = []
+  if (extendLength && childExtendLength) {
+    stack = jointStacks(extendStack, childExtendStack)
+  } else if (extendLength) {
+    stack = extendStack
+  } else if (childExtendLength) {
+    stack = childExtendStack
+  } else return element
+
+  if (options.extends) {
+    const defaultOptionsExtend = getExtendStack(options.extends)
+    stack = [].concat(defaultOptionsExtend, stack)
+  }
+
+  element.ref.extends = stack
+  const mergedExtend = cloneAndMergeArrayExtend(stack)
+
+  delete mergedExtend.__hash
+
+  return deepMergeExtend(element, mergedExtend)
+
+  // final merging with extendtype
+}

package/packages/transform-react/node_modules/@domql/extends/package.json

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

package/packages/transform-react/node_modules/@domql/extends/test/index.test.js

@@ -0,0 +1,53 @@
+'use strict'
+
+import { tree } from '@domql/tree'
+import { extendElement } from '..'
+
+describe('Should extend other element', () => {
+  const extended = extendElement({
+    ref: {},
+    extend: {
+      test2: 'test2'
+    },
+    test: 123
+  }, tree)
+
+  test('should extent an object element', () => {
+    expect(extended).toEqual({
+      ref: {
+        extend: [{
+          __hash: extended.ref.extends[0].__hash,
+          test2: 'test2'
+        }]
+      },
+      test: 123,
+      test2: 'test2'
+    })
+  })
+
+  test('should extent a nested object', () => {
+    const extended2 = extendElement({
+      ref: {},
+      extend: extended,
+      test3: { text: 'test3' }
+    }, tree)
+    expect(extended2).toEqual({
+      ref: {
+        extend: [{
+          __hash: extended2.ref.extends[0].__hash,
+          test: 123,
+          test2: 'test2',
+          ref: {
+            extend: [{
+              __hash: extended.ref.extends[0].__hash,
+              test2: 'test2'
+            }]
+          }
+        }]
+      },
+      test: 123,
+      test2: 'test2',
+      test3: { text: 'test3' }
+    })
+  })
+})

package/packages/transform-react/node_modules/@domql/iterate/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/transform-react/node_modules/@domql/iterate/index.js

@@ -0,0 +1,80 @@
+'use strict'
+
+import { exec, isFunction } from '@domql/utils'
+import { isMethod } from '@domql/methods'
+
+export const applyEvents = element => {
+  const { node, on } = element
+  for (const param in on) {
+    if (
+      param === 'init' ||
+      param === 'render' ||
+      param === 'update'
+    ) continue
+
+    const appliedFunction = element.on[param]
+    if (isFunction(appliedFunction)) {
+      node.addEventListener(param, event =>
+        appliedFunction(event, element, element.state),
+      true)
+    }
+  }
+}
+
+// export const throughInitialExec = element => {
+//   for (const param in element) {
+//     const prop = element[param]
+//     if (isFunction(prop) && !isMethod(param)) {
+//       element.__exec[param] = prop
+//       element[param] = prop(element, element.state)
+//     }
+//   }
+// }
+
+// export const execUpdatedParams = (options, element) => {
+//   const { __exec } = element
+//   const changes = {}
+
+//   for (const param in __exec) {
+//     const prop = element[param]
+//     const newExec = __exec[param](element, element.state)
+
+//     // if element is string
+//     if (prop && prop.node && (isString(newExec) || isNumber(newExec))) {
+//       overwrite(prop, { text: newExec }, options)
+//     } else if (newExec !== prop) {
+//       element.__cache[param] = changes[param] = prop
+//       element[param] = newExec
+//     }
+//   }
+
+//   return changes
+// }
+
+export const throughInitialDefine = element => {
+  const { define } = element
+  for (const param in define) {
+    let prop = element[param]
+
+    if (isFunction(prop) && !isMethod(param)) {
+      element.__exec[param] = prop
+      element[param] = prop = exec(prop, element)
+    }
+
+    element.__cache[param] = prop
+    element[param] = define[param](prop, element, element.state)
+  }
+  return element
+}
+
+export const throughUpdatedDefine = element => {
+  const { define, __exec } = element
+  const changes = {}
+  for (const param in define) {
+    const execParam = __exec[param]
+    if (execParam) element.__cache[param] = execParam(element, element.state)
+    const cached = exec(element.__cache[param], element)
+    element[param] = define[param](cached, element, element.state)
+  }
+  return changes
+}

package/packages/transform-react/node_modules/@domql/iterate/package.json

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

package/packages/transform-react/node_modules/@domql/key/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/transform-react/node_modules/@domql/key/index.js

@@ -0,0 +1,12 @@
+'use strict'
+
+import 'regenerator-runtime/runtime'
+
+const id = function * () {
+  let index = 1
+  while (index < index + 1) {
+    yield index++
+  }
+}
+
+export const createKey = id()

package/packages/transform-react/node_modules/@domql/key/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@domql/key",
+  "version": "2.0.8",
+  "main": "index.js",
+  "license": "MIT",
+  "dependencies": {
+    "regenerator-runtime": "^0.13.9"
+  },
+  "gitHead": "b60c46e45c462d00976902d6cdbea6fd5504542b",
+  "source": "index.js"
+}

package/packages/transform-react/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/transform-react/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/transform-react/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/transform-react/node_modules/@domql/mixins/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/transform-react/node_modules/@domql/mixins/attr.js

@@ -0,0 +1,19 @@
+'use strict'
+
+import { exec } from '@domql/utils'
+import { report } from '@domql/report'
+
+/**
+ * Recursively add attributes to a DOM node
+ */
+export const attr = (params, element, node) => {
+  if (params) {
+    if (!(typeof params === 'object')) report('HTMLInvalidAttr', params)
+    for (const attr in params) {
+      // if (!node) node = element.node
+      const val = exec(params[attr], element)
+      if (val && node.setAttribute) node.setAttribute(attr, val)
+      else if (node.removeAttribute) node.removeAttribute(attr)
+    }
+  }
+}

package/packages/transform-react/node_modules/@domql/mixins/classList.js

@@ -0,0 +1,37 @@
+'use strict'
+
+import { exec, isObject, isString } from '@domql/utils'
+
+export const assignClass = (element) => {
+  const { key } = element
+  if (element.class === true) element.class = key
+  else if (!element.class && typeof key === 'string' && key.charAt(0) === '_' && key.charAt(1) !== '_') {
+    element.class = key.slice(1)
+  }
+}
+
+// stringifies class object
+export const classify = (obj, element) => {
+  let className = ''
+  for (const item in obj) {
+    const param = obj[item]
+    if (typeof param === 'boolean' && param) className += ` ${item}`
+    else if (typeof param === 'string') className += ` ${param}`
+    else if (typeof param === 'function') {
+      className += ` ${exec(param, element)}`
+    }
+  }
+  return className
+}
+
+export const classList = (params, element) => {
+  if (!params) return
+  const { key } = element
+  if (params === true) params = element.class = { key }
+  if (isString(params)) params = element.class = { default: params }
+  if (isObject(params)) params = classify(params, element)
+  // TODO: fails on string
+  const className = params.replace(/\s+/g, ' ').trim()
+  element.ref.class = className
+  return className
+}

package/packages/transform-react/node_modules/@domql/mixins/content.js

@@ -0,0 +1,17 @@
+'use strict'
+
+import { set } from '@domql/set'
+
+/**
+ * Appends anything as content
+ * an original one as a child
+ */
+export const content = (param, element, node) => {
+  if (param && element) {
+    if (param.__hash === element.content.__hash && element.content.update) {
+      element.content.update(param)
+    } else {
+      set.call(element, param)
+    }
+  }
+}

package/packages/transform-react/node_modules/@domql/mixins/data.js

@@ -0,0 +1,21 @@
+'use strict'
+
+import { exec, isObject } from '@domql/utils'
+import { report } from '@domql/report'
+
+/**
+ * Apply data parameters on the DOM nodes
+ * this should only work if `showOnNode: true` is passed
+ */
+export const data = (params, element, node) => {
+  if (params && params.showOnNode) {
+    if (!isObject(params)) report('HTMLInvalidData', params)
+
+    // Apply data params on node
+    for (const dataset in params) {
+      if (dataset !== 'showOnNode') {
+        node.dataset[dataset] = exec(params[dataset], element)
+      }
+    }
+  }
+}

package/packages/transform-react/node_modules/@domql/mixins/html.js

@@ -0,0 +1,17 @@
+'use strict'
+
+import { exec } from '@domql/utils'
+
+/**
+ * Appends raw HTML as content
+ * an original one as a child
+ */
+export const html = (param, element, node) => {
+  const prop = exec(param, element)
+  if (prop) {
+    // const parser = new window.DOMParser()
+    // param = parser.parseFromString(param, 'text/html')
+    if (node.nodeName === 'SVG') node.textContent = prop
+    else node.innerHTML = prop
+  }
+}