@xenknight/framework7 0.0.2

package/modules/component/snabbdom/modules/dataset.js

@@ -0,0 +1,37 @@
+var CAPS_REGEX = /[A-Z]/g;
+function updateDataset(oldVnode, vnode) {
+  var elm = vnode.elm,
+    oldDataset = oldVnode.data.dataset,
+    dataset = vnode.data.dataset,
+    key;
+  if (!oldDataset && !dataset) return;
+  if (oldDataset === dataset) return;
+  oldDataset = oldDataset || {};
+  dataset = dataset || {};
+  var d = elm.dataset;
+  for (key in oldDataset) {
+    if (!dataset[key]) {
+      if (d) {
+        if (key in d) {
+          delete d[key];
+        }
+      } else {
+        elm.removeAttribute('data-' + key.replace(CAPS_REGEX, '-$&').toLowerCase());
+      }
+    }
+  }
+  for (key in dataset) {
+    if (oldDataset[key] !== dataset[key]) {
+      if (d) {
+        d[key] = dataset[key];
+      } else {
+        elm.setAttribute('data-' + key.replace(CAPS_REGEX, '-$&').toLowerCase(), dataset[key]);
+      }
+    }
+  }
+}
+export var datasetModule = {
+  create: updateDataset,
+  update: updateDataset
+};
+export default datasetModule;

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

@@ -0,0 +1,8 @@
+import { Module } from './module.js';
+export declare type On = {
+  [N in keyof HTMLElementEventMap]?: (ev: HTMLElementEventMap[N]) => void;
+} & {
+  [event: string]: EventListener;
+};
+export declare const eventListenersModule: Module;
+export default eventListenersModule;

package/modules/component/snabbdom/modules/eventlisteners.js

@@ -0,0 +1,93 @@
+function invokeHandler(handler, vnode, event) {
+  if (typeof handler === "function") {
+    // call function handler
+    handler.call(vnode, event, vnode);
+  } else if (typeof handler === "object") {
+    // call handler with arguments
+    if (typeof handler[0] === "function") {
+      // special case for single argument for performance
+      if (handler.length === 2) {
+        handler[0].call(vnode, handler[1], event, vnode);
+      } else {
+        var args = handler.slice(1);
+        args.push(event);
+        args.push(vnode);
+        handler[0].apply(vnode, args);
+      }
+    } else {
+      // call multiple handlers
+      for (var i = 0; i < handler.length; i++) {
+        invokeHandler(handler[i]);
+      }
+    }
+  }
+}
+function handleEvent(event, vnode) {
+  var name = event.type,
+    on = vnode.data.on;
+  // call event handler(s) if exists
+  if (on && on[name]) {
+    invokeHandler(on[name], vnode, event);
+  }
+}
+function createListener() {
+  return function handler(event) {
+    handleEvent(event, handler.vnode);
+  };
+}
+function updateEventListeners(oldVnode, vnode) {
+  var oldOn = oldVnode.data.on,
+    oldListener = oldVnode.listener,
+    oldElm = oldVnode.elm,
+    on = vnode && vnode.data.on,
+    elm = vnode && vnode.elm,
+    name;
+  // optimization for reused immutable handlers
+  if (oldOn === on) {
+    return;
+  }
+  // remove existing listeners which no longer used
+  if (oldOn && oldListener) {
+    // if element changed or deleted we remove all existing listeners unconditionally
+    if (!on) {
+      for (name in oldOn) {
+        // remove listener if element was changed or existing listeners removed
+        oldElm.removeEventListener(name, oldListener, false);
+      }
+    } else {
+      for (name in oldOn) {
+        // remove listener if existing listener removed
+        if (!on[name]) {
+          oldElm.removeEventListener(name, oldListener, false);
+        }
+      }
+    }
+  }
+  // add new listeners which has not already attached
+  if (on) {
+    // reuse existing listener or create new
+    var listener = vnode.listener = oldVnode.listener || createListener();
+    // update vnode for listener
+    listener.vnode = vnode;
+    // if element changed or added we add all needed listeners unconditionally
+    if (!oldOn) {
+      for (name in on) {
+        // add listener if element was changed or new listeners added
+        elm.addEventListener(name, listener, false);
+      }
+    } else {
+      for (name in on) {
+        // add listener if new listener added
+        if (!oldOn[name]) {
+          elm.addEventListener(name, listener, false);
+        }
+      }
+    }
+  }
+}
+export var eventListenersModule = {
+  create: updateEventListeners,
+  update: updateEventListeners,
+  destroy: updateEventListeners
+};
+export default eventListenersModule;

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

@@ -0,0 +1,6 @@
+import { Module } from './module.js';
+export declare type Hero = {
+  id: string;
+};
+export declare const heroModule: Module;
+export default heroModule;

package/modules/component/snabbdom/modules/hero.js

@@ -0,0 +1,147 @@
+var raf = typeof window !== 'undefined' && window.requestAnimationFrame || setTimeout;
+var nextFrame = function (fn) {
+  raf(function () {
+    raf(fn);
+  });
+};
+function setNextFrame(obj, prop, val) {
+  nextFrame(function () {
+    obj[prop] = val;
+  });
+}
+function getTextNodeRect(textNode) {
+  var rect;
+  if (document.createRange) {
+    var range = document.createRange();
+    range.selectNodeContents(textNode);
+    if (range.getBoundingClientRect) {
+      rect = range.getBoundingClientRect();
+    }
+  }
+  return rect;
+}
+function calcTransformOrigin(isTextNode, textRect, boundingRect) {
+  if (isTextNode) {
+    if (textRect) {
+      //calculate pixels to center of text from left edge of bounding box
+      var relativeCenterX = textRect.left + textRect.width / 2 - boundingRect.left;
+      var relativeCenterY = textRect.top + textRect.height / 2 - boundingRect.top;
+      return relativeCenterX + 'px ' + relativeCenterY + 'px';
+    }
+  }
+  return '0 0'; //top left
+}
+
+function getTextDx(oldTextRect, newTextRect) {
+  if (oldTextRect && newTextRect) {
+    return oldTextRect.left + oldTextRect.width / 2 - (newTextRect.left + newTextRect.width / 2);
+  }
+  return 0;
+}
+function getTextDy(oldTextRect, newTextRect) {
+  if (oldTextRect && newTextRect) {
+    return oldTextRect.top + oldTextRect.height / 2 - (newTextRect.top + newTextRect.height / 2);
+  }
+  return 0;
+}
+function isTextElement(elm) {
+  return elm.childNodes.length === 1 && elm.childNodes[0].nodeType === 3;
+}
+var removed, created;
+function pre() {
+  removed = {};
+  created = [];
+}
+function create(oldVnode, vnode) {
+  var hero = vnode.data.hero;
+  if (hero && hero.id) {
+    created.push(hero.id);
+    created.push(vnode);
+  }
+}
+function destroy(vnode) {
+  var hero = vnode.data.hero;
+  if (hero && hero.id) {
+    var elm = vnode.elm;
+    vnode.isTextNode = isTextElement(elm); //is this a text node?
+    vnode.boundingRect = elm.getBoundingClientRect(); //save the bounding rectangle to a new property on the vnode
+    vnode.textRect = vnode.isTextNode ? getTextNodeRect(elm.childNodes[0]) : null; //save bounding rect of inner text node
+    var computedStyle = window.getComputedStyle(elm, void 0); //get current styles (includes inherited properties)
+    vnode.savedStyle = JSON.parse(JSON.stringify(computedStyle)); //save a copy of computed style values
+    removed[hero.id] = vnode;
+  }
+}
+function post() {
+  var i, id, newElm, oldVnode, oldElm, hRatio, wRatio, oldRect, newRect, dx, dy, origTransform, origTransition, newStyle, oldStyle, newComputedStyle, isTextNode, newTextRect, oldTextRect;
+  for (i = 0; i < created.length; i += 2) {
+    id = created[i];
+    newElm = created[i + 1].elm;
+    oldVnode = removed[id];
+    if (oldVnode) {
+      isTextNode = oldVnode.isTextNode && isTextElement(newElm); //Are old & new both text?
+      newStyle = newElm.style;
+      newComputedStyle = window.getComputedStyle(newElm, void 0); //get full computed style for new element
+      oldElm = oldVnode.elm;
+      oldStyle = oldElm.style;
+      //Overall element bounding boxes
+      newRect = newElm.getBoundingClientRect();
+      oldRect = oldVnode.boundingRect; //previously saved bounding rect
+      //Text node bounding boxes & distances
+      if (isTextNode) {
+        newTextRect = getTextNodeRect(newElm.childNodes[0]);
+        oldTextRect = oldVnode.textRect;
+        dx = getTextDx(oldTextRect, newTextRect);
+        dy = getTextDy(oldTextRect, newTextRect);
+      } else {
+        //Calculate distances between old & new positions
+        dx = oldRect.left - newRect.left;
+        dy = oldRect.top - newRect.top;
+      }
+      hRatio = newRect.height / Math.max(oldRect.height, 1);
+      wRatio = isTextNode ? hRatio : newRect.width / Math.max(oldRect.width, 1); //text scales based on hRatio
+      // Animate new element
+      origTransform = newStyle.transform;
+      origTransition = newStyle.transition;
+      if (newComputedStyle.display === 'inline') newStyle.display = 'inline-block'; //this does not appear to have any negative side effects
+      newStyle.transition = origTransition + 'transform 0s';
+      newStyle.transformOrigin = calcTransformOrigin(isTextNode, newTextRect, newRect);
+      newStyle.opacity = '0';
+      newStyle.transform = origTransform + 'translate(' + dx + 'px, ' + dy + 'px) ' + 'scale(' + 1 / wRatio + ', ' + 1 / hRatio + ')';
+      setNextFrame(newStyle, 'transition', origTransition);
+      setNextFrame(newStyle, 'transform', origTransform);
+      setNextFrame(newStyle, 'opacity', '1');
+      // Animate old element
+      for (var key in oldVnode.savedStyle) {
+        if (parseInt(key) != key) {
+          var ms = key.substring(0, 2) === 'ms';
+          var moz = key.substring(0, 3) === 'moz';
+          var webkit = key.substring(0, 6) === 'webkit';
+          if (!ms && !moz && !webkit) oldStyle[key] = oldVnode.savedStyle[key];
+        }
+      }
+      oldStyle.position = 'absolute';
+      oldStyle.top = oldRect.top + 'px'; //start at existing position
+      oldStyle.left = oldRect.left + 'px';
+      oldStyle.width = oldRect.width + 'px'; //Needed for elements who were sized relative to their parents
+      oldStyle.height = oldRect.height + 'px'; //Needed for elements who were sized relative to their parents
+      oldStyle.margin = '0'; //Margin on hero element leads to incorrect positioning
+      oldStyle.transformOrigin = calcTransformOrigin(isTextNode, oldTextRect, oldRect);
+      oldStyle.transform = '';
+      oldStyle.opacity = '1';
+      document.body.appendChild(oldElm);
+      setNextFrame(oldStyle, 'transform', 'translate(' + -dx + 'px, ' + -dy + 'px) scale(' + wRatio + ', ' + hRatio + ')'); //scale must be on far right for translate to be correct
+      setNextFrame(oldStyle, 'opacity', '0');
+      oldElm.addEventListener('transitionend', function (ev) {
+        if (ev.propertyName === 'transform') document.body.removeChild(ev.target);
+      });
+    }
+  }
+  removed = created = undefined;
+}
+export var heroModule = {
+  pre: pre,
+  create: create,
+  destroy: destroy,
+  post: post
+};
+export default heroModule;

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

@@ -0,0 +1,9 @@
+import { PreHook, CreateHook, UpdateHook, DestroyHook, RemoveHook, PostHook } from '../hooks.js';
+export interface Module {
+  pre: PreHook;
+  create: CreateHook;
+  update: UpdateHook;
+  destroy: DestroyHook;
+  remove: RemoveHook;
+  post: PostHook;
+}

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

@@ -0,0 +1,4 @@
+import { Module } from './module.js';
+export declare type Props = Record<string, any>;
+export declare const propsModule: Module;
+export default propsModule;

package/modules/component/snabbdom/modules/props.js

@@ -0,0 +1,29 @@
+function updateProps(oldVnode, vnode) {
+  var key,
+    cur,
+    old,
+    elm = vnode.elm,
+    oldProps = oldVnode.data.props,
+    props = vnode.data.props;
+  if (!oldProps && !props) return;
+  if (oldProps === props) return;
+  oldProps = oldProps || {};
+  props = props || {};
+  for (key in oldProps) {
+    if (!props[key]) {
+      delete elm[key];
+    }
+  }
+  for (key in props) {
+    cur = props[key];
+    old = oldProps[key];
+    if (old !== cur && (key !== 'value' || elm[key] !== cur)) {
+      elm[key] = cur;
+    }
+  }
+}
+export var propsModule = {
+  create: updateProps,
+  update: updateProps
+};
+export default propsModule;

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

@@ -0,0 +1,7 @@
+import { Module } from './module.js';
+export declare type VNodeStyle = Record<string, string> & {
+  delayed?: Record<string, string>;
+  remove?: Record<string, string>;
+};
+export declare const styleModule: Module;
+export default styleModule;

package/modules/component/snabbdom/modules/style.js

@@ -0,0 +1,93 @@
+var raf = typeof window !== 'undefined' && window.requestAnimationFrame || setTimeout;
+var nextFrame = function (fn) {
+  raf(function () {
+    raf(fn);
+  });
+};
+function setNextFrame(obj, prop, val) {
+  nextFrame(function () {
+    obj[prop] = val;
+  });
+}
+function updateStyle(oldVnode, vnode) {
+  var cur,
+    name,
+    elm = vnode.elm,
+    oldStyle = oldVnode.data.style,
+    style = vnode.data.style;
+  if (!oldStyle && !style) return;
+  if (oldStyle === style) return;
+  oldStyle = oldStyle || {};
+  style = style || {};
+  var oldHasDel = ('delayed' in oldStyle);
+  for (name in oldStyle) {
+    if (!style[name]) {
+      if (name[0] === '-' && name[1] === '-') {
+        elm.style.removeProperty(name);
+      } else {
+        elm.style[name] = '';
+      }
+    }
+  }
+  for (name in style) {
+    cur = style[name];
+    if (name === 'delayed' && style.delayed) {
+      for (var name2 in style.delayed) {
+        cur = style.delayed[name2];
+        if (!oldHasDel || cur !== oldStyle.delayed[name2]) {
+          setNextFrame(elm.style, name2, cur);
+        }
+      }
+    } else if (name !== 'remove' && cur !== oldStyle[name]) {
+      if (name[0] === '-' && name[1] === '-') {
+        elm.style.setProperty(name, cur);
+      } else {
+        elm.style[name] = cur;
+      }
+    }
+  }
+}
+function applyDestroyStyle(vnode) {
+  var style,
+    name,
+    elm = vnode.elm,
+    s = vnode.data.style;
+  if (!s || !(style = s.destroy)) return;
+  for (name in style) {
+    elm.style[name] = style[name];
+  }
+}
+function applyRemoveStyle(vnode, rm) {
+  var s = vnode.data.style;
+  if (!s || !s.remove) {
+    rm();
+    return;
+  }
+  var name,
+    elm = vnode.elm,
+    i = 0,
+    compStyle,
+    style = s.remove,
+    amount = 0,
+    applied = [];
+  for (name in style) {
+    applied.push(name);
+    elm.style[name] = style[name];
+  }
+  compStyle = getComputedStyle(elm);
+  var props = compStyle['transition-property'].split(', ');
+  for (; i < props.length; ++i) {
+    if (applied.indexOf(props[i]) !== -1) amount++;
+  }
+  elm.addEventListener('transitionend', function (ev) {
+    if (ev.target === elm) --amount;
+    if (amount === 0) rm();
+  });
+}
+export var styleModule = {
+  create: updateStyle,
+  update: updateStyle,
+  destroy: applyDestroyStyle,
+  remove: applyRemoveStyle
+};
+export default styleModule;

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

@@ -0,0 +1,5 @@
+export declare const snabbdomBundle: {
+    patch: (oldVNode: any, vnode: any) => any;
+    h: any;
+};
+export default snabbdomBundle;

package/modules/component/snabbdom/snabbdom.bundle.js

@@ -0,0 +1,13 @@
+import { init } from './snabbdom.js';
+import { attributesModule } from './modules/attributes.js'; // for setting attributes on DOM elements
+import { classModule } from './modules/class.js'; // makes it easy to toggle classes
+import { propsModule } from './modules/props.js'; // for setting properties on DOM elements
+import { styleModule } from './modules/style.js'; // handles styling on elements with support for animations
+import { eventListenersModule } from './modules/eventlisteners.js'; // attaches event listeners
+import { h } from './h.js'; // helper function for creating vnodes
+var patch = init([attributesModule, classModule, propsModule, styleModule, eventListenersModule]);
+export var snabbdomBundle = {
+  patch: patch,
+  h: h
+};
+export default snabbdomBundle;

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

@@ -0,0 +1,6 @@
+import { Module } from './modules/module.js';
+import { VNode } from './vnode.js';
+import { DOMAPI } from './htmldomapi.js';
+export { h } from './h.js';
+export { thunk } from './thunk.js';
+export declare function init (modules: Array<Partial<Module>>, domApi?: DOMAPI): (oldVnode: Element | VNode, vnode: VNode) => VNode;