domql 1.6.39 → 1.6.41

package/packages/transform-react/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/transform-react/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/transform-react/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/transform-react/node_modules/@domql/element/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/element/README.md

@@ -0,0 +1,21 @@
+# DOMQL Element
+Takes object and creates DOMQL element.
+
+[![npm version](https://badge.fury.io/js/%40domql%2Felement.svg)](https://badge.fury.io/js/%40domql%2Felement)
+
+### Example:
+```javascript
+import DOM from 'domql'
+
+const Poster = {
+  extend: [Link, Img],
+  props: {
+    boxSize: [100, 200],
+    borderRadius: 12,
+    padding: 16,
+    background: '#fff'
+  }
+}
+
+DOM.create(Poster, document.body)
+```

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

@@ -0,0 +1,7 @@
+'use strict'
+
+export * from '@domql/methods'
+export * from '@domql/iterate'
+export * from '@domql/update'
+export * from '@domql/create'
+export * from '@domql/set'

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

@@ -0,0 +1,15 @@
+{
+  "name": "@domql/element",
+  "version": "2.3.0",
+  "main": "index.js",
+  "license": "MIT",
+  "dependencies": {
+    "@domql/create": "latest",
+    "@domql/iterate": "latest",
+    "@domql/methods": "latest",
+    "@domql/set": "latest",
+    "@domql/update": "latest"
+  },
+  "gitHead": "02944ad228d2cf5f5727b08e9378d221b2f7205b",
+  "source": "index.js"
+}

package/packages/transform-react/node_modules/@domql/element/test/create.test.js

@@ -0,0 +1,136 @@
+'use strict'
+
+import { tree } from '@domql/tree'
+import { create } from '../create'
+
+describe('Should create DOMQL element', () => {
+  const dom = create({})
+
+  test('should create EMPTY element', () => {
+    expect(dom.key).toBe(1)
+    expect(dom.tag).toBe('div')
+  })
+
+  test('should create REF', () => {
+    const { ref } = dom
+    expect(ref.tag).toBe('div')
+    expect(ref.parent).toEqual(tree)
+    expect(ref.state).toEqual({})
+    expect(ref.props).toEqual({})
+  })
+})
+
+describe('Should create DOMQL element from PRIMITIVES', () => {
+  const ref = {
+    tag: 'div',
+    parent: tree,
+    state: {},
+    props: {}
+  }
+  test('should create element from Int', () => {
+    const number = create(123)
+    expect(number).toEqual({
+      key: 6,
+      tag: 'div',
+      text: 123,
+      ref
+    })
+  })
+  test('should create element from String', () => {
+    const string = create('test')
+    expect(string).toEqual({
+      key: 7,
+      tag: 'div',
+      text: 'test',
+      ref
+    })
+  })
+})
+
+describe('Should create NESTED DOMQL element', () => {
+  const dom = create({
+    test: 123,
+    test2: 'test2',
+    test3: { text: 'test3' }
+  })
+  const ref = {
+    tag: 'div',
+    parent: tree,
+    state: {},
+    props: {}
+  }
+  test('element must have children', () => {
+    const { children, childrenKeys } = dom.ref
+    expect(children).toEqual(expect.any(Array))
+    expect(childrenKeys).toEqual(expect.any(Array))
+    expect(childrenKeys).toHaveLength(3)
+    expect(childrenKeys).toEqual(['test', 'test2', 'test3'])
+  })
+  test('should structure proper children', () => {
+    const { children } = dom.ref
+    expect(children[0]).toEqual({
+      key: 3,
+      tag: 'div',
+      text: 123,
+      ref
+    })
+    expect(children[1]).toEqual({
+      key: 4,
+      tag: 'div',
+      text: 'test2',
+      ref
+    })
+    expect(children[2]).toEqual({
+      key: 5,
+      tag: 'div',
+      text: 'test3',
+      ref
+    })
+  })
+})
+
+// test('should create valid DOM node', () => {
+//   expect(dom.node).toBeInstanceOf(window.HTMLDivElement)
+// })
+
+// test('must be able to create valid PATH', () => {
+//   expect(dom.path).toStrictEqual([dom.key])
+// })
+
+// test('if it HAS a NODE, don\'t recreate', () => {
+//   const node = document.createElement('div')
+//   const dom2 = create({ node })
+//   expect(dom2.node.parentElement).toBe(document.body)
+// })
+
+// test('create with number', () => {
+//   const numb = create(0)
+//   expect(numb.text).toBe(0)
+//   expect(numb.tag).toBe('string')
+//   expect(numb.node.nodeType).toBe(3) // #text
+// })
+
+// test('create with string', () => {
+//   const str = create('hello')
+//   expect(str.text).toBe('hello')
+//   expect(str.tag).toBe('string')
+//   expect(str.node.nodeType).toBe(3) // #text
+// })
+
+// test('creating conditions', () => {
+//   const element = create({
+//     data: { visible: true },
+//     if: element => element.data.visible
+//   })
+//   expect(element.tag).toBe('div')
+// })
+
+// test('creating nesting', () => {
+//   const element = create({
+//     header: {
+//       h1: {}
+//     }
+//   })
+//   expect(element.header.tag).toBe('header')
+//   expect(element.header.h1.tag).toBe('h1')
+// })

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

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

package/packages/transform-react/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/transform-react/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.