domql 1.6.39 → 1.6.41

package/packages/define/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/element/node_modules/@domql/create/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/element/node_modules/@domql/create/index.js

@@ -0,0 +1,181 @@
+'use strict'
+
+import { DEFAULT_METHODS, TAGS } from '@domql/registry'
+
+import { root } from '@domql/tree'
+import { createKey } from '@domql/key'
+import { isNumber, isString, isObject, isNode, isFunction, isArray, exec } from '@domql/utils'
+import { createState } from '@domql/state'
+import { createProps } from '@domql/props'
+import { extendElement } from '@domql/extends'
+
+const OPTIONS = {}
+
+const init = (element, key, options, parent) => {
+  const ref = {}
+  if (!element) return { ref }
+  // if null remove
+
+  if (isString(element) || isNumber(element)) {
+    return {
+      key,
+      ref,
+      tag: 'string',
+      text: element
+    }
+  } else if (isArray(element)) return Object.assign({}, element)
+  else if (isObject(element)) {
+    const { extendLibrary } = options
+    const extendFromLibrary = isString(element.extends) && extendLibrary[element.extends]
+    if (extendFromLibrary && extendLibrary) {
+      element = {
+        props: element,
+        ref,
+        extend: extendFromLibrary
+      }
+    }
+    if (!element.ref) element.ref = ref
+    if (element.on && element.on.init) element.on.init(element, element.state)
+    return element
+  } else if (isFunction(element)) return ({ ref, ...exec(parent, parent.ref.state) })
+  return element
+}
+
+const assignKey = (element, key) => {
+  if (element.key) return element
+  element.key = key || createKey.next().value
+  return element
+}
+
+const applyParent = (element, key) => {
+  const { ref } = element
+  const { parent } = ref
+  if (isNode(parent)) {
+    ref.parent = root.ref.parent = { node: parent }
+  }
+  if (!parent) ref.parent = root
+  return element
+}
+
+const applyState = (element, key) => {
+  const { ref } = element
+  ref.state = createState(element, element.ref.parent)
+  return element
+}
+
+const applyExtends = (element, key, options) => {
+  extendElement(element, element.ref.parent, options)
+  return element
+}
+
+const applyTag = (element, key) => {
+  if (element.tag) {
+    element.ref.tag = element.tag
+    return element
+  }
+
+  const keyIsTag = TAGS.body.indexOf(key) > -1
+  element.tag = element.ref.tag = keyIsTag ? key : 'div'
+  return element
+}
+
+const applyProps = (element, key) => {
+  const { ref } = element
+  ref.props = createProps(element, ref.parent)
+  return element
+}
+
+const applyAttr = (element, key) => {
+  if (!isObject(element.attr)) return element
+  const { ref } = element
+  if (!ref.attr) ref.attr = {}
+  for (const attrKey in element.attr) {
+    ref.attr[attrKey] = exec(element.attr[attrKey], element, element.state)
+  }
+  return element
+}
+
+const onEachAvailable = (element, key, options) => {
+  const { ref } = element
+  const value = element[key]
+  let { children, childrenKeys } = ref
+  if (!children) children = ref.children = []
+  if (!childrenKeys) childrenKeys = ref.childrenKeys = []
+
+  // move value to ref.children
+  children.push(value)
+  childrenKeys.push(key)
+
+  // apply global options
+  const useOption = options[onEachAvailable]
+  if (useOption) useOption(element, key)
+}
+
+export const onEach = (element, key, options) => {
+  for (const key in element) {
+    const isMethod = DEFAULT_METHODS[key]
+    if (isMethod && isFunction(isMethod)) isMethod(element, element.ref.state)
+    const hasDefine = element.define && element.define[key]
+    if (hasDefine && isFunction(hasDefine)) element.ref[key] = hasDefine(element, element.ref.state)
+    if (!isMethod && !hasDefine) onEachAvailable(element, key, options)
+  }
+  return element
+}
+
+export const applyTransform = (element, key, options) => {
+  const { ref, transform } = element
+  if (!transform) return element
+  if (!ref.transform) ref.transform = {}
+  const keys = Object.keys(transform || {})
+  keys.map(key => {
+    const transformer = transform[key]
+    ref.transform[key] = transformer(element, key)
+    return key
+  })
+  return element
+}
+
+const addChildren = (element, key, options) => {
+  const { ref } = element
+  const { children, childrenKeys } = ref
+
+  if (children && children.length) {
+    ref.children = children.map((child, key) => {
+      return create(child, element, childrenKeys[key], options)
+    })
+  }
+
+  return element
+}
+
+const applyGlobalTransform = (element, key, options) => {
+  const { ref } = element
+  const { transform } = options
+  if (!transform) return element
+  if (!ref.transform) ref.transform = {}
+  const keys = Object.keys(transform || {})
+  keys.map(key => {
+    const transformer = transform[key]
+    ref.transform[key] = transformer(element, key)
+    return key
+  })
+  return element
+}
+
+/**
+ * Creating a DOMQL element
+ */
+export const create = (element, parent, key, options = OPTIONS) => [
+  init,
+  assignKey,
+  applyParent,
+  applyState,
+  applyExtends,
+  applyTag,
+  applyProps,
+  applyAttr,
+  onEach,
+  applyTransform,
+  addChildren,
+  applyGlobalTransform
+].reduce((prev, current) => current(prev, key, options, parent), element)

package/packages/element/node_modules/@domql/create/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@domql/create",
+  "version": "2.3.0",
+  "main": "index.js",
+  "license": "MIT",
+  "dependencies": {
+    "@domql/extends": "latest",
+    "@domql/key": "latest",
+    "@domql/props": "latest",
+    "@domql/registry": "latest",
+    "@domql/state": "latest",
+    "@domql/tree": "latest",
+    "@domql/utils": "latest"
+  },
+  "gitHead": "02944ad228d2cf5f5727b08e9378d221b2f7205b",
+  "source": "src/index.js"
+}

package/packages/element/node_modules/@domql/event/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/element/node_modules/@domql/event/can.js

@@ -0,0 +1,10 @@
+'use strict'
+
+// import { TAGS } from '@domql/registry'
+// import { report } from '@domql/report'
+
+// export const render = (element) => {
+//   const tag = element.tag || 'div'
+//   const isValid = TAGS.body.indexOf(tag) > -1
+//   return isValid || report('HTMLInvalidTag')
+// }

package/packages/element/node_modules/@domql/event/index.js

@@ -0,0 +1,11 @@
+'use strict'
+
+import * as on from './on'
+import * as can from './can'
+import * as is from './is'
+
+export {
+  on,
+  can,
+  is
+}

package/packages/element/node_modules/@domql/event/is.js

@@ -0,0 +1,13 @@
+'use strict'
+
+export const node = (node) => {
+  const { Node } = window
+  return (
+    typeof Node === 'function'
+      ? node instanceof Node
+      : node &&
+        typeof node === 'object' &&
+        typeof node.nodeType === 'number' &&
+        typeof node.tag === 'string'
+  )
+}

package/packages/element/node_modules/@domql/event/on.js

@@ -0,0 +1,58 @@
+'use strict'
+
+import { isFunction } from '@domql/utils'
+
+export const init = (param, element, state) => {
+  param(element, state)
+}
+
+export const render = (param, element, state) => {
+  param(element, state)
+}
+
+export const initUpdate = (element) => {
+  const { ref, state, on } = element
+  const { props } = ref
+  if (on && isFunction(on.initUpdate)) {
+    on.initUpdate(props, state, ref)
+  }
+}
+
+// export const attachNode = (param, element, state) => {
+//   param(element, state)
+// }
+
+export const createState = (state, element) => {
+  const { on, ...el } = element
+  if (on && isFunction(on.createState)) {
+    on.createState(state, el)
+  }
+}
+
+export const updateStateInit = (changes, element) => {
+  const { state, on, ...el } = element
+  if (on && isFunction(on.updateStateInit)) {
+    on.updateStateInit(changes, state, el)
+  }
+}
+
+export const updateState = (changes, element) => {
+  const { state, on } = element
+  if (on && isFunction(on.updateState)) {
+    on.updateState(changes, state, element)
+  }
+}
+
+export const propsUpdated = (element) => {
+  const { props, state, on } = element
+  if (on && isFunction(on.propsUpdated)) {
+    on.propsUpdated(props, state, element)
+  }
+}
+
+export const update = (params, element, state) => {
+  if (element.on && isFunction(element.on.update)) {
+    element.on.update(element, state)
+  }
+  return params
+}

package/packages/element/node_modules/@domql/event/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@domql/event",
+  "version": "2.2.1",
+  "main": "index.js",
+  "license": "MIT",
+  "scripts": {
+    "vpatch": "npm version patch && npm publish --access public"
+  },
+  "dependencies": {
+    "@domql/utils": "latest"
+  },
+  "gitHead": "87a27f601df3c39a91dd199fb2068bb761f6ed4e",
+  "source": "index.js"
+}

package/packages/element/node_modules/@domql/event/store.js

@@ -0,0 +1,6 @@
+'use strict'
+
+export default {
+  click: [],
+  render: []
+}

package/packages/element/node_modules/@domql/event/wrappers.js

@@ -0,0 +1,14 @@
+'use strict'
+
+// export const getScrollPositions = () => {
+//   if (window.pageYOffset !== undefined) {
+//     return [window.pageXOffset, window.pageYOffset]
+//   } else {
+//     const d = document
+//     const r = d.documentElement
+//     const b = d.body
+//     const sx = r.scrollLeft || b.scrollLeft || 0
+//     const sy = r.scrollTop || b.scrollTop || 0
+//     return [sx, sy]
+//   }
+// }

package/packages/element/node_modules/@domql/extends/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/element/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/element/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/element/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"
+}