@xenknight/framework7 0.0.2

package/modules/component/snabbdom/snabbdom.js

@@ -0,0 +1,282 @@
+import vnode from './vnode.js';
+import * as is from './is.js';
+import htmlDomApi from './htmldomapi.js';
+function isUndef(s) {
+  return s === undefined;
+}
+function isDef(s) {
+  return s !== undefined;
+}
+var emptyNode = vnode('', {}, [], undefined, undefined);
+function sameVnode(vnode1, vnode2) {
+  return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;
+}
+function isVnode(vnode) {
+  return vnode.sel !== undefined;
+}
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+  var i,
+    map = {},
+    key,
+    ch;
+  for (i = beginIdx; i <= endIdx; ++i) {
+    ch = children[i];
+    if (ch != null) {
+      key = ch.key;
+      if (key !== undefined) map[key] = i;
+    }
+  }
+  return map;
+}
+var hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];
+export { h } from './h.js';
+export { thunk } from './thunk.js';
+export function init(modules, domApi) {
+  var i,
+    j,
+    cbs = {};
+  var api = domApi !== undefined ? domApi : htmlDomApi;
+  for (i = 0; i < hooks.length; ++i) {
+    cbs[hooks[i]] = [];
+    for (j = 0; j < modules.length; ++j) {
+      var hook = modules[j][hooks[i]];
+      if (hook !== undefined) {
+        cbs[hooks[i]].push(hook);
+      }
+    }
+  }
+  function emptyNodeAt(elm) {
+    var id = elm.id ? '#' + elm.id : '';
+    var c = elm.className ? '.' + elm.className.split(' ').join('.') : '';
+    return vnode(api.tagName(elm).toLowerCase() + id + c, {}, [], undefined, elm);
+  }
+  function createRmCb(childElm, listeners) {
+    return function rmCb() {
+      if (--listeners === 0) {
+        var parent_1 = api.parentNode(childElm);
+        api.removeChild(parent_1, childElm);
+      }
+    };
+  }
+  function createElm(vnode, insertedVnodeQueue) {
+    var i,
+      data = vnode.data;
+    if (data !== undefined) {
+      if (isDef(i = data.hook) && isDef(i = i.init)) {
+        i(vnode);
+        data = vnode.data;
+      }
+    }
+    var children = vnode.children,
+      sel = vnode.sel;
+    if (sel === '!') {
+      if (isUndef(vnode.text)) {
+        vnode.text = '';
+      }
+      vnode.elm = api.createComment(vnode.text);
+    } else if (sel !== undefined) {
+      // Parse selector
+      var hashIdx = sel.indexOf('#');
+      var dotIdx = sel.indexOf('.', hashIdx);
+      var hash = hashIdx > 0 ? hashIdx : sel.length;
+      var dot = dotIdx > 0 ? dotIdx : sel.length;
+      var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;
+      var elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? api.createElementNS(i, tag) : api.createElement(tag);
+      if (hash < dot) elm.setAttribute('id', sel.slice(hash + 1, dot));
+      if (dotIdx > 0) elm.setAttribute('class', sel.slice(dot + 1).replace(/\./g, ' '));
+      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);
+      if (is.array(children)) {
+        for (i = 0; i < children.length; ++i) {
+          var ch = children[i];
+          if (ch != null) {
+            api.appendChild(elm, createElm(ch, insertedVnodeQueue));
+          }
+        }
+      } else if (is.primitive(vnode.text)) {
+        api.appendChild(elm, api.createTextNode(vnode.text));
+      }
+      i = vnode.data.hook; // Reuse variable
+      if (isDef(i)) {
+        if (i.create) i.create(emptyNode, vnode);
+        if (i.insert) insertedVnodeQueue.push(vnode);
+      }
+    } else {
+      vnode.elm = api.createTextNode(vnode.text);
+    }
+    return vnode.elm;
+  }
+  function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+    for (; startIdx <= endIdx; ++startIdx) {
+      var ch = vnodes[startIdx];
+      if (ch != null) {
+        api.insertBefore(parentElm, createElm(ch, insertedVnodeQueue), before);
+      }
+    }
+  }
+  function invokeDestroyHook(vnode) {
+    var i,
+      j,
+      data = vnode.data;
+    if (data !== undefined) {
+      if (isDef(i = data.hook) && isDef(i = i.destroy)) i(vnode);
+      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);
+      if (vnode.children !== undefined) {
+        for (j = 0; j < vnode.children.length; ++j) {
+          i = vnode.children[j];
+          if (i != null && typeof i !== "string") {
+            invokeDestroyHook(i);
+          }
+        }
+      }
+    }
+  }
+  function removeVnodes(parentElm, vnodes, startIdx, endIdx) {
+    for (; startIdx <= endIdx; ++startIdx) {
+      var i_1 = void 0,
+        listeners = void 0,
+        rm = void 0,
+        ch = vnodes[startIdx];
+      if (ch != null) {
+        if (isDef(ch.sel)) {
+          invokeDestroyHook(ch);
+          listeners = cbs.remove.length + 1;
+          rm = createRmCb(ch.elm, listeners);
+          for (i_1 = 0; i_1 < cbs.remove.length; ++i_1) cbs.remove[i_1](ch, rm);
+          if (isDef(i_1 = ch.data) && isDef(i_1 = i_1.hook) && isDef(i_1 = i_1.remove)) {
+            i_1(ch, rm);
+          } else {
+            rm();
+          }
+        } else {
+          api.removeChild(parentElm, ch.elm);
+        }
+      }
+    }
+  }
+  function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue) {
+    var oldStartIdx = 0,
+      newStartIdx = 0;
+    var oldEndIdx = oldCh.length - 1;
+    var oldStartVnode = oldCh[0];
+    var oldEndVnode = oldCh[oldEndIdx];
+    var newEndIdx = newCh.length - 1;
+    var newStartVnode = newCh[0];
+    var newEndVnode = newCh[newEndIdx];
+    var oldKeyToIdx;
+    var idxInOld;
+    var elmToMove;
+    var before;
+    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+      if (oldStartVnode == null) {
+        oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left
+      } else if (oldEndVnode == null) {
+        oldEndVnode = oldCh[--oldEndIdx];
+      } else if (newStartVnode == null) {
+        newStartVnode = newCh[++newStartIdx];
+      } else if (newEndVnode == null) {
+        newEndVnode = newCh[--newEndIdx];
+      } else if (sameVnode(oldStartVnode, newStartVnode)) {
+        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);
+        oldStartVnode = oldCh[++oldStartIdx];
+        newStartVnode = newCh[++newStartIdx];
+      } else if (sameVnode(oldEndVnode, newEndVnode)) {
+        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);
+        oldEndVnode = oldCh[--oldEndIdx];
+        newEndVnode = newCh[--newEndIdx];
+      } else if (sameVnode(oldStartVnode, newEndVnode)) {
+        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);
+        api.insertBefore(parentElm, oldStartVnode.elm, api.nextSibling(oldEndVnode.elm));
+        oldStartVnode = oldCh[++oldStartIdx];
+        newEndVnode = newCh[--newEndIdx];
+      } else if (sameVnode(oldEndVnode, newStartVnode)) {
+        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);
+        api.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+        oldEndVnode = oldCh[--oldEndIdx];
+        newStartVnode = newCh[++newStartIdx];
+      } else {
+        if (oldKeyToIdx === undefined) {
+          oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
+        }
+        idxInOld = oldKeyToIdx[newStartVnode.key];
+        if (isUndef(idxInOld)) {
+          api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);
+          newStartVnode = newCh[++newStartIdx];
+        } else {
+          elmToMove = oldCh[idxInOld];
+          if (elmToMove.sel !== newStartVnode.sel) {
+            api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);
+          } else {
+            patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);
+            oldCh[idxInOld] = undefined;
+            api.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);
+          }
+          newStartVnode = newCh[++newStartIdx];
+        }
+      }
+    }
+    if (oldStartIdx <= oldEndIdx || newStartIdx <= newEndIdx) {
+      if (oldStartIdx > oldEndIdx) {
+        before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm;
+        addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+      } else {
+        removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
+      }
+    }
+  }
+  function patchVnode(oldVnode, vnode, insertedVnodeQueue) {
+    var i, hook;
+    if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {
+      i(oldVnode, vnode);
+    }
+    var elm = vnode.elm = oldVnode.elm;
+    var oldCh = oldVnode.children;
+    var ch = vnode.children;
+    if (oldVnode === vnode) return;
+    if (vnode.data !== undefined) {
+      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);
+      i = vnode.data.hook;
+      if (isDef(i) && isDef(i = i.update)) i(oldVnode, vnode);
+    }
+    if (isUndef(vnode.text)) {
+      if (isDef(oldCh) && isDef(ch)) {
+        if (oldCh !== ch) updateChildren(elm, oldCh, ch, insertedVnodeQueue);
+      } else if (isDef(ch)) {
+        if (isDef(oldVnode.text)) api.setTextContent(elm, '');
+        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+      } else if (isDef(oldCh)) {
+        removeVnodes(elm, oldCh, 0, oldCh.length - 1);
+      } else if (isDef(oldVnode.text)) {
+        api.setTextContent(elm, '');
+      }
+    } else if (oldVnode.text !== vnode.text) {
+      api.setTextContent(elm, vnode.text);
+    }
+    if (isDef(hook) && isDef(i = hook.postpatch)) {
+      i(oldVnode, vnode);
+    }
+  }
+  return function patch(oldVnode, vnode) {
+    var i, elm, parent;
+    var insertedVnodeQueue = [];
+    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();
+    if (!isVnode(oldVnode)) {
+      oldVnode = emptyNodeAt(oldVnode);
+    }
+    if (sameVnode(oldVnode, vnode)) {
+      patchVnode(oldVnode, vnode, insertedVnodeQueue);
+    } else {
+      elm = oldVnode.elm;
+      parent = api.parentNode(elm);
+      createElm(vnode, insertedVnodeQueue);
+      if (parent !== null) {
+        api.insertBefore(parent, vnode.elm, api.nextSibling(elm));
+        removeVnodes(parent, [oldVnode], 0, 0);
+      }
+    }
+    for (i = 0; i < insertedVnodeQueue.length; ++i) {
+      insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);
+    }
+    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();
+    return vnode;
+  };
+}

package/modules/component/snabbdom/thunk.d.ts

@@ -0,0 +1,14 @@
+import { VNode, VNodeData } from './vnode.js';
+export interface ThunkData extends VNodeData {
+  fn: () => VNode;
+  args: Array<any>;
+}
+export interface Thunk extends VNode {
+  data: ThunkData;
+}
+export interface ThunkFn {
+  (sel: string, fn: Function, args: Array<any>): Thunk;
+  (sel: string, key: any, fn: Function, args: Array<any>): Thunk;
+}
+export declare const thunk: ThunkFn;
+export default thunk;

package/modules/component/snabbdom/thunk.js

@@ -0,0 +1,50 @@
+import { h } from './h.js';
+function copyToThunk(vnode, thunk) {
+  thunk.elm = vnode.elm;
+  vnode.data.fn = thunk.data.fn;
+  vnode.data.args = thunk.data.args;
+  thunk.data = vnode.data;
+  thunk.children = vnode.children;
+  thunk.text = vnode.text;
+  thunk.elm = vnode.elm;
+}
+function init(thunk) {
+  var cur = thunk.data;
+  var vnode = cur.fn.apply(undefined, cur.args);
+  copyToThunk(vnode, thunk);
+}
+function prepatch(oldVnode, thunk) {
+  var i,
+    old = oldVnode.data,
+    cur = thunk.data;
+  var oldArgs = old.args,
+    args = cur.args;
+  if (old.fn !== cur.fn || oldArgs.length !== args.length) {
+    copyToThunk(cur.fn.apply(undefined, args), thunk);
+    return;
+  }
+  for (i = 0; i < args.length; ++i) {
+    if (oldArgs[i] !== args[i]) {
+      copyToThunk(cur.fn.apply(undefined, args), thunk);
+      return;
+    }
+  }
+  copyToThunk(oldVnode, thunk);
+}
+export var thunk = function thunk(sel, key, fn, args) {
+  if (args === undefined) {
+    args = fn;
+    fn = key;
+    key = undefined;
+  }
+  return h(sel, {
+    key: key,
+    hook: {
+      init: init,
+      prepatch: prepatch
+    },
+    fn: fn,
+    args: args
+  });
+};
+export default thunk;

package/modules/component/snabbdom/tovnode.d.ts

@@ -0,0 +1,4 @@
+import { VNode } from './vnode.js';
+import { DOMAPI } from './htmldomapi.js';
+export declare function toVNode (node: Node, domApi?: DOMAPI): VNode;
+export default toVNode;

package/modules/component/snabbdom/tovnode.js

@@ -0,0 +1,40 @@
+import vnode from './vnode.js';
+import htmlDomApi from './htmldomapi.js';
+export function toVNode(node, domApi) {
+  var api = domApi !== undefined ? domApi : htmlDomApi;
+  var text;
+  if (api.isElement(node)) {
+    var id = node.id ? '#' + node.id : '';
+    var cn = node.getAttribute('class');
+    var c = cn ? '.' + cn.split(' ').join('.') : '';
+    var sel = api.tagName(node).toLowerCase() + id + c;
+    var attrs = {};
+    var children = [];
+    var name_1;
+    var i = void 0,
+      n = void 0;
+    var elmAttrs = node.attributes;
+    var elmChildren = node.childNodes;
+    for (i = 0, n = elmAttrs.length; i < n; i++) {
+      name_1 = elmAttrs[i].nodeName;
+      if (name_1 !== 'id' && name_1 !== 'class') {
+        attrs[name_1] = elmAttrs[i].nodeValue;
+      }
+    }
+    for (i = 0, n = elmChildren.length; i < n; i++) {
+      children.push(toVNode(elmChildren[i]));
+    }
+    return vnode(sel, {
+      attrs: attrs
+    }, children, undefined, node);
+  } else if (api.isText(node)) {
+    text = api.getTextContent(node);
+    return vnode(undefined, undefined, undefined, text, node);
+  } else if (api.isComment(node)) {
+    text = api.getTextContent(node);
+    return vnode('!', {}, [], text, node);
+  } else {
+    return vnode('', {}, [], undefined, node);
+  }
+}
+export default toVNode;

package/modules/component/snabbdom/vnode.d.ts

@@ -0,0 +1,36 @@
+import { Hooks } from './hooks.js';
+import { AttachData } from './helpers/attachto.js';
+import { VNodeStyle } from './modules/style.js';
+import { On } from './modules/eventlisteners.js';
+import { Attrs } from './modules/attributes.js';
+import { Classes } from './modules/class.js';
+import { Props } from './modules/props.js';
+import { Dataset } from './modules/dataset.js';
+import { Hero } from './modules/hero.js';
+export declare type Key = string | number;
+export interface VNode {
+  sel: string | undefined;
+  data: VNodeData | undefined;
+  children: Array<VNode | string> | undefined;
+  elm: Node | undefined;
+  text: string | undefined;
+  key: Key | undefined;
+}
+export interface VNodeData {
+  props?: Props;
+  attrs?: Attrs;
+  class?: Classes;
+  style?: VNodeStyle;
+  dataset?: Dataset;
+  on?: On;
+  hero?: Hero;
+  attachData?: AttachData;
+  hook?: Hooks;
+  key?: Key;
+  ns?: string;
+  fn?: () => VNode;
+  args?: Array<any>;
+  [key: string]: any;
+}
+export declare function vnode (sel: string | undefined, data: any | undefined, children: Array<VNode | string> | undefined, text: string | undefined, elm: Element | Text | undefined): VNode;
+export default vnode;

package/modules/component/snabbdom/vnode.js

@@ -0,0 +1,12 @@
+export function vnode(sel, data, children, text, elm) {
+  var key = data === undefined ? undefined : data.key;
+  return {
+    sel: sel,
+    data: data,
+    children: children,
+    text: text,
+    elm: elm,
+    key: key
+  };
+}
+export default vnode;