diff --git a/package.json b/package.json index a4eab998..faf33f8a 100644 --- a/package.json +++ b/package.json @@ -33,5 +33,8 @@ "ts-jest": "^23.10.5", "live-server": "^1.2.1", "typescript": "^3.2.2" + }, + "dependencies": { + "snabbdom": "^0.7.3" } } diff --git a/src/core/qweb.ts b/src/core/qweb.ts index 31018779..e29e3b6b 100644 --- a/src/core/qweb.ts +++ b/src/core/qweb.ts @@ -1,7 +1,6 @@ import { escape } from "./utils"; import directives from "./qweb_directives"; import { Directive } from "./qweb_directives"; - type RawTemplate = string; type Template = (context: any) => DocumentFragment; diff --git a/src/libs/snabbdom/.gitignore b/src/libs/snabbdom/.gitignore new file mode 100755 index 00000000..91de20a0 --- /dev/null +++ b/src/libs/snabbdom/.gitignore @@ -0,0 +1,64 @@ +# Logs +logs +*.log + +# Runtime data +pids +*.pid +*.seed + +# Directory for instrumented libs generated by jscoverage/JSCover +lib-cov + +# Coverage directory used by tools like istanbul +coverage + +# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) +.grunt + +# node-waf configuration +.lock-wscript + +# Compiled binary addons (http://nodejs.org/api/addons.html) +build/Release + +# Dependency directory +# https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git +node_modules + +# Vim +*.swp + +# Generated JavaScript +/test/browserified.js +/browserified.js +/h.d.ts +/h.js +/h.js.map +/hooks.d.ts +/hooks.js +/hooks.js.map +/htmldomapi.d.ts +/htmldomapi.js +/htmldomapi.js.map +/is.d.ts +/is.js +/is.js.map +/snabbdom.bundle.d.ts +/snabbdom.bundle.js +/snabbdom.bundle.js.map +/snabbdom.d.ts +/snabbdom.js +/snabbdom.js.map +/thunk.d.ts +/thunk.js +/thunk.js.map +/tovnode.d.ts +/tovnode.js +/tovnode.js.map +/vnode.d.ts +/vnode.js +/vnode.js.map +/modules +/helpers +/es diff --git a/src/libs/snabbdom/.npmignore b/src/libs/snabbdom/.npmignore new file mode 100755 index 00000000..0da76a69 --- /dev/null +++ b/src/libs/snabbdom/.npmignore @@ -0,0 +1,33 @@ +/test +/perf + +# Logs +logs +*.log + +# Runtime data +pids +*.pid +*.seed + +# Directory for instrumented libs generated by jscoverage/JSCover +lib-cov + +# Coverage directory used by tools like istanbul +coverage + +# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) +.grunt + +# node-waf configuration +.lock-wscript + +# Compiled binary addons (http://nodejs.org/api/addons.html) +build/Release + +# Dependency directory +# https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git +node_modules + +# Vim +*.swp \ No newline at end of file diff --git a/src/libs/snabbdom/.travis.yml b/src/libs/snabbdom/.travis.yml new file mode 100755 index 00000000..af144511 --- /dev/null +++ b/src/libs/snabbdom/.travis.yml @@ -0,0 +1,17 @@ +sudo: false +language: node_js +node_js: + - '6.10.1' +script: + - export IP_ADDR=$(ip addr | grep eth -A 4 | grep 'inet ' | awk '{ print $2 }' | sed 's/\/..//') + - npm test +addons: + browserstack: + username: + secure: + access_key: + secure: +env: + global: + - secure: + - secure: diff --git a/src/libs/snabbdom/LICENSE b/src/libs/snabbdom/LICENSE new file mode 100755 index 00000000..2f1fedbd --- /dev/null +++ b/src/libs/snabbdom/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2015 Simon Friis Vindum + +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. + diff --git a/src/libs/snabbdom/README.md b/src/libs/snabbdom/README.md new file mode 100755 index 00000000..03255412 --- /dev/null +++ b/src/libs/snabbdom/README.md @@ -0,0 +1,758 @@ +# Snabbdom + +A virtual DOM library with focus on simplicity, modularity, powerful features +and performance. + +[![License: MIT](https://img.shields.io/badge/License-MIT-brightgreen.svg)](https://opensource.org/licenses/MIT) [![npm version](https://badge.fury.io/js/snabbdom.svg)](https://badge.fury.io/js/snabbdom) [![npm downloads](https://img.shields.io/npm/dm/snabbdom.svg)](https://www.npmjs.com/package/snabbdom) + +[![Join the chat at https://gitter.im/paldepind/snabbdom](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/paldepind/snabbdom?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) + +## Table of contents + +* [Introduction](#introduction) +* [Features](#features) +* [Inline example](#inline-example) +* [Examples](#examples) +* [Core documentation](#core-documentation) +* [Modules documentation](#modules-documentation) +* [Helpers](#helpers) +* [Virtual Node documentation](#virtual-node) +* [Structuring applications](#structuring-applications) + +## Why + +Virtual DOM is awesome. It allows us to express our application's view +as a function of its state. But existing solutions were way way too +bloated, too slow, lacked features, had an API biased towards OOP +and/or lacked features I needed. + +## Introduction + +Snabbdom consists of an extremely simple, performant and extensible +core that is only ≈ 200 SLOC. It offers a modular architecture with +rich functionality for extensions through custom modules. To keep the +core simple, all non-essential functionality is delegated to modules. + +You can mold Snabbdom into whatever you desire! Pick, choose and +customize the functionality you want. Alternatively you can just use +the default extensions and get a virtual DOM library with high +performance, small size and all the features listed below. + +## Features + +* Core features + * About 200 SLOC – you could easily read through the entire core and fully + understand how it works. + * Extendable through modules. + * A rich set of hooks available, both per vnode and globally for modules, + to hook into any part of the diff and patch process. + * Splendid performance. Snabbdom is among the fastest virtual DOM libraries + in the [Virtual DOM Benchmark](http://vdom-benchmark.github.io/vdom-benchmark/). + * Patch function with a function signature equivalent to a reduce/scan + function. Allows for easier integration with a FRP library. +* Features in modules + * `h` function for easily creating virtual DOM nodes. + * [SVG _just works_ with the `h` helper](#svg). + * Features for doing complex CSS animations. + * Powerful event listener functionality. + * [Thunks](#thunks) to optimize the diff and patch process even further. +* Third party features + * JSX support thanks to [snabbdom-pragma](https://github.com/Swizz/snabbdom-pragma). + * Server-side HTML output provided by [snabbdom-to-html](https://github.com/acstll/snabbdom-to-html). + * Compact virtual DOM creation with [snabbdom-helpers](https://github.com/krainboltgreene/snabbdom-helpers). + * Template string support using [snabby](https://github.com/jamen/snabby). + * Virtual DOM assertion with [snabbdom-looks-like](https://github.com/jvanbruegge/snabbdom-looks-like) + +## Inline example + +```javascript +var snabbdom = require('snabbdom'); +var patch = snabbdom.init([ // Init patch function with chosen modules + require('snabbdom/modules/class').default, // makes it easy to toggle classes + require('snabbdom/modules/props').default, // for setting properties on DOM elements + require('snabbdom/modules/style').default, // handles styling on elements with support for animations + require('snabbdom/modules/eventlisteners').default, // attaches event listeners +]); +var h = require('snabbdom/h').default; // helper function for creating vnodes + +var container = document.getElementById('container'); + +var vnode = h('div#container.two.classes', {on: {click: someFn}}, [ + h('span', {style: {fontWeight: 'bold'}}, 'This is bold'), + ' and this is just normal text', + h('a', {props: {href: '/foo'}}, 'I\'ll take you places!') +]); +// Patch into empty DOM element – this modifies the DOM as a side effect +patch(container, vnode); + +var newVnode = h('div#container.two.classes', {on: {click: anotherEventHandler}}, [ + h('span', {style: {fontWeight: 'normal', fontStyle: 'italic'}}, 'This is now italic type'), + ' and this is still just normal text', + h('a', {props: {href: '/bar'}}, 'I\'ll take you places!') +]); +// Second `patch` invocation +patch(vnode, newVnode); // Snabbdom efficiently updates the old view to the new state +``` + +## Examples + +* [Animated reordering of elements](http://snabbdom.github.io/snabbdom/examples/reorder-animation/) +* [Hero transitions](http://snabbdom.github.io/snabbdom/examples/hero/) +* [SVG Carousel](http://snabbdom.github.io/snabbdom/examples/carousel-svg/) + +## Core documentation + +The core of Snabbdom provides only the most essential functionality. +It is designed to be as simple as possible while still being fast and +extendable. + +### `snabbdom.init` + +The core exposes only one single function `snabbdom.init`. This `init` +takes a list of modules and returns a `patch` function that uses the +specified set of modules. + +```javascript +var patch = snabbdom.init([ + require('snabbdom/modules/class').default, + require('snabbdom/modules/style').default, +]); +``` + +### `patch` + +The `patch` function returned by `init` takes two arguments. The first +is a DOM element or a vnode representing the current view. The second +is a vnode representing the new, updated view. + +If a DOM element with a parent is passed, `newVnode` will be turned +into a DOM node, and the passed element will be replaced by the +created DOM node. If an old vnode is passed, Snabbdom will efficiently +modify it to match the description in the new vnode. + +Any old vnode passed must be the resulting vnode from a previous call +to `patch`. This is necessary since Snabbdom stores information in the +vnode. This makes it possible to implement a simpler and more +performant architecture. This also avoids the creation of a new old +vnode tree. + +```javascript +patch(oldVnode, newVnode); +``` + +### `snabbdom/h` + +It is recommended that you use `snabbdom/h` to create vnodes. `h` accepts a +tag/selector as a string, an optional data object and an optional string or +array of children. + +```javascript +var h = require('snabbdom/h').default; +var vnode = h('div', {style: {color: '#000'}}, [ + h('h1', 'Headline'), + h('p', 'A paragraph'), +]); +``` + +### `snabbdom/tovnode` + +Converts a DOM node into a virtual node. Especially good for patching over an pre-existing, +server-side generated content. + +```javascript +var snabbdom = require('snabbdom') +var patch = snabbdom.init([ // Init patch function with chosen modules + require('snabbdom/modules/class').default, // makes it easy to toggle classes + require('snabbdom/modules/props').default, // for setting properties on DOM elements + require('snabbdom/modules/style').default, // handles styling on elements with support for animations + require('snabbdom/modules/eventlisteners').default, // attaches event listeners +]); +var h = require('snabbdom/h').default; // helper function for creating vnodes +var toVNode = require('snabbdom/tovnode').default; + +var newVNode = h('div', {style: {color: '#000'}}, [ + h('h1', 'Headline'), + h('p', 'A paragraph'), +]); + +patch(toVNode(document.querySelector('.container')), newVNode) + +``` + +### Hooks + +Hooks are a way to hook into the lifecycle of DOM nodes. Snabbdom +offers a rich selection of hooks. Hooks are used both by modules to +extend Snabbdom, and in normal code for executing arbitrary code at +desired points in the life of a virtual node. + +#### Overview + +| Name | Triggered when | Arguments to callback | +| ----------- | -------------- | ----------------------- | +| `pre` | the patch process begins | none | +| `init` | a vnode has been added | `vnode` | +| `create` | a DOM element has been created based on a vnode | `emptyVnode, vnode` | +| `insert` | an element has been inserted into the DOM | `vnode` | +| `prepatch` | an element is about to be patched | `oldVnode, vnode` | +| `update` | an element is being updated | `oldVnode, vnode` | +| `postpatch` | an element has been patched | `oldVnode, vnode` | +| `destroy` | an element is directly or indirectly being removed | `vnode` | +| `remove` | an element is directly being removed from the DOM | `vnode, removeCallback` | +| `post` | the patch process is done | none | + +The following hooks are available for modules: `pre`, `create`, +`update`, `destroy`, `remove`, `post`. + +The following hooks are available in the `hook` property of individual +elements: `init`, `create`, `insert`, `prepatch`, `update`, +`postpatch`, `destroy`, `remove`. + +#### Usage + +To use hooks, pass them as an object to `hook` field of the data +object argument. + +```javascript +h('div.row', { + key: movie.rank, + hook: { + insert: (vnode) => { movie.elmHeight = vnode.elm.offsetHeight; } + } +}); +``` + +#### The `init` hook + +This hook is invoked during the patch process when a new virtual node +has been found. The hook is called before Snabbdom has processed the +node in any way. I.e., before it has created a DOM node based on the +vnode. + +#### The `insert` hook + +This hook is invoked once the DOM element for a vnode has been +inserted into the document _and_ the rest of the patch cycle is done. +This means that you can do DOM measurements (like using +[getBoundingClientRect](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect) +in this hook safely, knowing that no elements will be changed +afterwards that could affect the position of the inserted elements. + +#### The `remove` hook + +Allows you to hook into the removal of an element. The hook is called +once a vnode is to be removed from the DOM. The handling function +receives both the vnode and a callback. You can control and delay the +removal with the callback. The callback should be invoked once the +hook is done doing its business, and the element will only be removed +once all `remove` hooks have invoked their callback. + +The hook is only triggered when an element is to be removed from its +parent – not if it is the child of an element that is removed. For +that, see the `destroy` hook. + +#### The `destroy` hook + +This hook is invoked on a virtual node when its DOM element is removed +from the DOM or if its parent is being removed from the DOM. + +To see the difference between this hook and the `remove` hook, +consider an example. + +```js +var vnode1 = h('div', [h('div', [h('span', 'Hello')])]); +var vnode2 = h('div', []); +patch(container, vnode1); +patch(vnode1, vnode2); +``` + +Here `destroy` is triggered for both the inner `div` element _and_ the +`span` element it contains. `remove`, on the other hand, is only +triggered on the `div` element because it is the only element being +detached from its parent. + +You can, for instance, use `remove` to trigger an animation when an +element is being removed and use the `destroy` hook to additionally +animate the disappearance of the removed element's children. + +### Creating modules + +Modules works by registering global listeners for [hooks](#hooks). A module is simply a dictionary mapping hook names to functions. + +```javascript +var myModule = { + create: function(oldVnode, vnode) { + // invoked whenever a new virtual node is created + }, + update: function(oldVnode, vnode) { + // invoked whenever a virtual node is updated + } +}; +``` + +With this mechanism you can easily augment the behaviour of Snabbdom. +For demonstration, take a look at the implementations of the default +modules. + +## Modules documentation + +This describes the core modules. All modules are optional. + +### The class module + +The class module provides an easy way to dynamically toggle classes on +elements. It expects an object in the `class` data property. The +object should map class names to booleans that indicates whether or +not the class should stay or go on the vnode. + +```javascript +h('a', {class: {active: true, selected: false}}, 'Toggle'); +``` + +### The props module + +Allows you to set properties on DOM elements. + +```javascript +h('a', {props: {href: '/foo'}}, 'Go to Foo'); +``` + +### The attributes module + +Same as props, but set attributes instead of properties on DOM elements. + +```javascript +h('a', {attrs: {href: '/foo'}}, 'Go to Foo'); +``` + +Attributes are added and updated using `setAttribute`. In case of an +attribute that had been previously added/set and is no longer present +in the `attrs` object, it is removed from the DOM element's attribute +list using `removeAttribute`. + +In the case of boolean attributes (e.g. `disabled`, `hidden`, +`selected` ...), the meaning doesn't depend on the attribute value +(`true` or `false`) but depends instead on the presence/absence of the +attribute itself in the DOM element. Those attributes are handled +differently by the module: if a boolean attribute is set to a +[falsy value](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean) +(`0`, `-0`, `null`, `false`,`NaN`, `undefined`, or the empty string +(`""`)), then the attribute will be removed from the attribute list of +the DOM element. + +### The dataset module + +Allows you to set custom data attributes (`data-*`) on DOM elements. These can then be accessed with the [HTMLElement.dataset](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/dataset) property. + +```javascript +h('button', {dataset: {action: 'reset'}}, 'Reset'); +``` + +### The style module + +The style module is for making your HTML look slick and animate smoothly. At +its core it allows you to set CSS properties on elements. + +```javascript +h('span', { + style: {border: '1px solid #bada55', color: '#c0ffee', fontWeight: 'bold'} +}, 'Say my name, and every colour illuminates'); +``` + +Note that the style module does not remove style attributes if they +are removed as properties from the style object. To remove a style, +you should instead set it to the empty string. + +```javascript +h('div', { + style: {position: shouldFollow ? 'fixed' : ''} +}, 'I, I follow, I follow you'); +``` + +#### Custom properties (CSS variables) + +CSS custom properties (aka CSS variables) are supported, they must be prefixed +with `--` + +```javascript +h('div', { + style: {'--warnColor': 'yellow'} +}, 'Warning'); +``` + +#### Delayed properties + +You can specify properties as being delayed. Whenever these properties +change, the change is not applied until after the next frame. + +```javascript +h('span', { + style: {opacity: '0', transition: 'opacity 1s', delayed: {opacity: '1'}} +}, 'Imma fade right in!'); +``` + +This makes it easy to declaratively animate the entry of elements. + +#### Set properties on `remove` + +Styles set in the `remove` property will take effect once the element +is about to be removed from the DOM. The applied styles should be +animated with CSS transitions. Only once all the styles are done +animating will the element be removed from the DOM. + +```javascript +h('span', { + style: {opacity: '1', transition: 'opacity 1s', + remove: {opacity: '0'}} +}, 'It\'s better to fade out than to burn away'); +``` + +This makes it easy to declaratively animate the removal of elements. + +#### Set properties on `destroy` + +```javascript +h('span', { + style: {opacity: '1', transition: 'opacity 1s', + destroy: {opacity: '0'}} +}, 'It\'s better to fade out than to burn away'); +``` + +### Eventlisteners module + +The event listeners module gives powerful capabilities for attaching +event listeners. + +You can attach a function to an event on a vnode by supplying an +object at `on` with a property corresponding to the name of the event +you want to listen to. The function will be called when the event +happens and will be passed the event object that belongs to it. + +```javascript +function clickHandler(ev) { console.log('got clicked'); } +h('div', {on: {click: clickHandler}}); +``` + +Very often, however, you're not really interested in the event object +itself. Often you have some data associated with the element that +triggers an event and you want that data passed along instead. + +Consider a counter application with three buttons, one to increment +the counter by 1, one to increment the counter by 2 and one to +increment the counter by 3. You don't really care exactly which button +was pressed. Instead you're interested in what number was associated +with the clicked button. The event listeners module allows one to +express that by supplying an array at the named event property. The +first element in the array should be a function that will be invoked +with the value in the second element once the event occurs. + +```javascript +function clickHandler(number) { console.log('button ' + number + ' was clicked!'); } +h('div', [ + h('a', {on: {click: [clickHandler, 1]}}), + h('a', {on: {click: [clickHandler, 2]}}), + h('a', {on: {click: [clickHandler, 3]}}), +]); +``` + +Each handler is called not only with the given arguments but also with the current event and vnode appended to the argument list. It also supports using multiple listeners per event by specifying an array of handlers: +```javascript +stopPropagation = function(ev) { ev.stopPropagation() } +sendValue = function(func, ev, vnode) { func(vnode.elm.value) } + +h('a', { on:{ click:[[sendValue, console.log], stopPropagation] } }); +``` + +Snabbdom allows swapping event handlers between renders. This happens without +actually touching the event handlers attached to the DOM. + +Note, however, that **you should be careful when sharing event +handlers between vnodes**, because of the technique this module uses +to avoid re-binding event handlers to the DOM. (And in general, +sharing data between vnodes is not guaranteed to work, because modules +are allowed to mutate the given data). + +In particular, you should **not** do something like this: + +```javascript +// Does not work +var sharedHandler = { + change: function(e){ console.log('you chose: ' + e.target.value); } +}; +h('div', [ + h('input', {props: {type: 'radio', name: 'test', value: '0'}, + on: sharedHandler}), + h('input', {props: {type: 'radio', name: 'test', value: '1'}, + on: sharedHandler}), + h('input', {props: {type: 'radio', name: 'test', value: '2'}, + on: sharedHandler}) +]); +``` + +For many such cases, you can use array-based handlers instead (described above). +Alternatively, simply make sure each node is passed unique `on` values: + +```javascript +// Works +var sharedHandler = function(e){ console.log('you chose: ' + e.target.value); }; +h('div', [ + h('input', {props: {type: 'radio', name: 'test', value: '0'}, + on: {change: sharedHandler}}), + h('input', {props: {type: 'radio', name: 'test', value: '1'}, + on: {change: sharedHandler}}), + h('input', {props: {type: 'radio', name: 'test', value: '2'}, + on: {change: sharedHandler}}) +]); +``` + +## Helpers + +### SVG + +SVG just works when using the `h` function for creating virtual +nodes. SVG elements are automatically created with the appropriate +namespaces. + +```javascript +var vnode = h('div', [ + h('svg', {attrs: {width: 100, height: 100}}, [ + h('circle', {attrs: {cx: 50, cy: 50, r: 40, stroke: 'green', 'stroke-width': 4, fill: 'yellow'}}) + ]) +]); +``` + +See also the [SVG example](./examples/svg) and the [SVG Carousel example](./examples/carousel-svg/). + +#### Using Classes in SVG Elements + +Certain browsers (like IE <=11) [do not support `classList` property in SVG elements](http://caniuse.com/#feat=classlist). +Hence, the _class_ module (which uses `classList` property internally) will not work for these browsers. + +The classes in selectors for SVG elements work fine from version 0.6.7. + +You can add dynamic classes to SVG elements for these cases by using the _attributes_ module and an Array as shown below: + +```js +h('svg', [ + h('text.underline', { // 'underline' is a selector class, remain unchanged between renders. + attrs: { + // 'active' and 'red' are dynamic classes, they can change between renders + // so we need to put them in the class attribute. + // (Normally we'd use the classModule, but it doesn't work inside SVG) + class: [isActive && "active", isColored && "red"].filter(Boolean).join(" ") + } + }, + 'Hello World' + ) +]) +``` + +### Thunks + +The `thunk` function takes a selector, a key for identifying a thunk, +a function that returns a vnode and a variable amount of state +parameters. If invoked, the render function will receive the state +arguments. + +`thunk(selector, key, renderFn, [stateArguments])` + +The `key` is optional. It should be supplied when the `selector` is +not unique among the thunks siblings. This ensures that the thunk is +always matched correctly when diffing. + +Thunks are an optimization strategy that can be used when one is +dealing with immutable data. + +Consider a simple function for creating a virtual node based on a number. + +```js +function numberView(n) { + return h('div', 'Number is: ' + n); +} +``` + +The view depends only on `n`. This means that if `n` is unchanged, +then creating the virtual DOM node and patching it against the old +vnode is wasteful. To avoid the overhead we can use the `thunk` helper +function. + +```js +function render(state) { + return thunk('num', numberView, [state.number]); +} +``` + +Instead of actually invoking the `numberView` function this will only +place a dummy vnode in the virtual tree. When Snabbdom patches this +dummy vnode against a previous vnode, it will compare the value of +`n`. If `n` is unchanged it will simply reuse the old vnode. This +avoids recreating the number view and the diff process altogether. + +The view function here is only an example. In practice thunks are only +relevant if you are rendering a complicated view that takes +significant computational time to generate. + +## Virtual Node +**Properties** + - [sel](#sel--string) + - [data](#data--object) + - [children](#children--array) + - [text](#text--string) + - [elm](#elm--element) + - [key](#key--string--number) + +#### sel : String + +The `.sel` property of a virtual node is the CSS selector passed to +[`h()`](#snabbdomh) during creation. For example: `h('div#container', +{}, [...])` will create a a virtual node which has `div#container` as +its `.sel` property. + +#### data : Object + +The `.data` property of a virtual node is the place to add information +for [modules](#modules-documentation) to access and manipulate the +real DOM element when it is created; Add styles, CSS classes, +attributes, etc. + +The data object is the (optional) second parameter to [`h()`](#snabbdomh) + +For example `h('div', {props: {className: 'container'}}, [...])` will produce a virtual node with +```js +{ + "props": { + className: "container" + } +} +``` +as its `.data` object. + +#### children : Array + +The `.children` property of a virtual node is the third (optional) +parameter to [`h()`](#snabbdomh) during creation. `.children` is +simply an Array of virtual nodes that should be added as children of +the parent DOM node upon creation. + +For example `h('div', {}, [ h('h1', {}, 'Hello, World') ])` will +create a virtual node with + +```js +[ + { + sel: 'h1', + data: {}, + children: undefined, + text: 'Hello, World', + elm: Element, + key: undefined, + } +] +``` + +as its `.children` property. + +#### text : string + +The `.text` property is created when a virtual node is created with +only a single child that possesses text and only requires +`document.createTextNode()` to be used. + +For example: `h('h1', {}, 'Hello')` will create a virtual node with +`Hello` as its `.text` property. + +#### elm : Element + +The `.elm` property of a virtual node is a pointer to the real DOM +node created by snabbdom. This property is very useful to do +calculations in [hooks](#hooks) as well as +[modules](#modules-documentation). + +#### key : string | number + +The `.key` property is created when a key is provided inside of your +[`.data`](#data--object) object. The `.key` property is used to keep +pointers to DOM nodes that existed previously to avoid recreating them +if it is unnecessary. This is very useful for things like list +reordering. A key must be either a string or a number to allow for +proper lookup as it is stored internally as a key/value pair inside of +an object, where `.key` is the key and the value is the +[`.elm`](#elm--element) property created. + +For example: `h('div', {key: 1}, [])` will create a virtual node +object with a `.key` property with the value of `1`. + + +## Structuring applications + +Snabbdom is a low-level virtual DOM library. It is unopinionated with +regards to how you should structure your application. + +Here are some approaches to building applications with Snabbdom. + +* [functional-frontend-architecture](https://github.com/paldepind/functional-frontend-architecture) – + a repository containing several example applications that + demonstrates an architecture that uses Snabbdom. +* [Cycle.js](https://cycle.js.org/) – + "A functional and reactive JavaScript framework for cleaner code" + uses Snabbdom +* [Vue.js](http://vuejs.org/) use a fork of snabbdom. +* [scheme-todomvc](https://github.com/amirouche/scheme-todomvc/) build + redux-like architecture on top of snabbdom bindings. +* [kaiju](https://github.com/AlexGalays/kaiju) - + Stateful components and observables on top of snabbdom +* [Tweed](https://tweedjs.github.io) – + An Object Oriented approach to reactive interfaces. +* [Cyclow](http://cyclow.js.org) - + "A reactive frontend framework for JavaScript" + uses Snabbdom +* [Tung](https://github.com/Reon90/tung) – + A JavaScript library for rendering html. Tung helps to divide html and JavaScript development. +* [sprotty](https://github.com/theia-ide/sprotty) - "A web-based diagramming framework" uses Snabbdom. +* [Mark Text](https://github.com/marktext/marktext) - "Realtime preview Markdown Editor" build on Snabbdom. +* [puddles](https://github.com/flintinatux/puddles) - + "Tiny vdom app framework. Pure Redux. No boilerplate." - Built with :heart: on Snabbdom. +* [Backbone.VDOMView](https://github.com/jcbrand/backbone.vdomview) - A [Backbone](http://backbonejs.org/) View with VirtualDOM capability via Snabbdom. + +Be sure to share it if you're building an application in another way +using Snabbdom. + +## Common errors + +``` +Uncaught NotFoundError: Failed to execute 'insertBefore' on 'Node': + The node before which the new node is to be inserted is not a child of this node. +``` +The reason for this error is reusing of vnodes between patches (see code example), snabbdom stores actual dom nodes inside the virtual dom nodes passed to it as performance improvement, so reusing nodes between patches is not supported. +```js +var sharedNode = h('div', {}, 'Selected'); +var vnode1 = h('div', [ + h('div', {}, ['One']), + h('div', {}, ['Two']), + h('div', {}, [sharedNode]), +]); +var vnode2 = h('div', [ + h('div', {}, ['One']), + h('div', {}, [sharedNode]), + h('div', {}, ['Three']), +]); +patch(container, vnode1); +patch(vnode1, vnode2); +``` +You can fix this issue by creating a shallow copy of the object (here with object spread syntax): +```js +var vnode2 = h('div', [ + h('div', {}, ['One']), + h('div', {}, [{ ...sharedNode }]), + h('div', {}, ['Three']), +]); +``` +Another solution would be to wrap shared vnodes in a factory function: +```js +var sharedNode = () => h('div', {}, 'Selected'); +var vnode1 = h('div', [ + h('div', {}, ['One']), + h('div', {}, ['Two']), + h('div', {}, [sharedNode()]), +]); +``` diff --git a/src/libs/snabbdom/browserstack-karma.js b/src/libs/snabbdom/browserstack-karma.js new file mode 100755 index 00000000..81aa4d8c --- /dev/null +++ b/src/libs/snabbdom/browserstack-karma.js @@ -0,0 +1,95 @@ +module.exports = { + // Latest mainstream + BS_Chrome_Current: { + base: 'BrowserStack', + browser: 'chrome', + browser_version: 'latest', + os: 'Windows', + os_version: '10', + }, + BS_Firefox_Current: { + base: 'BrowserStack', + browser: 'firefox', + browser_version: 'latest', + os: 'Windows', + os_version: '10', + }, + BS_Safari_Current: { + base: 'BrowserStack', + browser: 'safari', + browser_version: 'latest', + os: 'OS X', + os_version: 'High Sierra', + }, + BS_Android_8: { + base: 'BrowserStack', + browser: 'Android', + device: 'Google Pixel 2', + os: 'Android', + os_version: '8.0', + real_mobile: true, + }, + + // Older mainstream + BS_Chrome_49: { + base: 'BrowserStack', + browser: 'chrome', + browser_version: '49', + os: 'Windows', + os_version: '10', + }, + BS_Firefox_52: { + base: 'BrowserStack', + browser: 'firefox', + browser_version: '52', + os: 'Windows', + os_version: '10', + }, + BS_Safari_9: { + base: 'BrowserStack', + browser: 'safari', + browser_version: '9.1', + os: 'OS X', + os_version: 'El Capitan', + }, + + // Misc + BS_Android_4_4: { + base: 'BrowserStack', + device_browser: 'ucbrowser', + device: 'Google Nexus 5', + os: 'Android', + os_version: '4.4', + real_mobile: true, + }, + BS_iphone_10: { + base: 'BrowserStack', + browser: 'Mobile Safari', + browser_version: null, + device: 'iPhone 7', + real_mobile: true, + os: 'ios', + os_version: '10.3', + }, + BS_MS_Edge: { + base: 'BrowserStack', + browser: 'edge', + browser_version: 'latest', + os: 'Windows', + os_version: '10', + }, + BS_IE_11: { + base: 'BrowserStack', + browser: 'ie', + browser_version: '11.0', + os: 'Windows', + os_version: '7', + }, + BS_IE_10: { + base: 'BrowserStack', + browser: 'ie', + browser_version: '10.0', + os: 'Windows', + os_version: '7', + }, +}; diff --git a/src/libs/snabbdom/dist/h.js b/src/libs/snabbdom/dist/h.js new file mode 100755 index 00000000..52219d4a --- /dev/null +++ b/src/libs/snabbdom/dist/h.js @@ -0,0 +1,83 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.h = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o1&&o.hasOwnProperty(u[0])?d.setAttributeNS(o[u[0]],r,n):d.setAttribute(r,n)));for(r in l)r in f||d.removeAttribute(r)}}for(var o={xlink:"http://www.w3.org/1999/xlink"},i=["allowfullscreen","async","autofocus","autoplay","checked","compact","controls","declare","default","defaultchecked","defaultmuted","defaultselected","defer","disabled","draggable","enabled","formnovalidate","hidden","indeterminate","inert","ismap","itemscope","loop","multiple","muted","nohref","noresize","noshade","novalidate","nowrap","open","pauseonexit","readonly","required","reversed","scoped","seamless","selected","sortable","spellcheck","translate","truespeed","typemustmatch","visible"],a=Object.create(null),u=0,d=i.length;u 1 && NamespaceURIs.hasOwnProperty(namespaceSplit[0]))\n elm.setAttributeNS(NamespaceURIs[namespaceSplit[0]], key, cur);\n else\n elm.setAttribute(key, cur);\n }\n }\n }\n //remove removed attributes\n // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n // the other option is to remove all attributes with value == undefined\n for (key in oldAttrs) {\n if (!(key in attrs)) {\n elm.removeAttribute(key);\n }\n }\n}\nexports.attributesModule = { create: updateAttrs, update: updateAttrs };\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.attributesModule;\n\n},{}]},{},[1])(1)\n});\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n"]} \ No newline at end of file diff --git a/src/libs/snabbdom/dist/snabbdom-class.js b/src/libs/snabbdom/dist/snabbdom-class.js new file mode 100755 index 00000000..4a8f4ee3 --- /dev/null +++ b/src/libs/snabbdom/dist/snabbdom-class.js @@ -0,0 +1,29 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.snabbdom_class = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 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) { + before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm; + addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue); + } + else if (newStartIdx > newEndIdx) { + 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; + }; +} +exports.init = init; + +},{"./h":1,"./htmldomapi":2,"./is":3,"./thunk":11,"./vnode":12}],11:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var h_1 = require("./h"); +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); +} +exports.thunk = function thunk(sel, key, fn, args) { + if (args === undefined) { + args = fn; + fn = key; + key = undefined; + } + return h_1.h(sel, { + key: key, + hook: { init: init, prepatch: prepatch }, + fn: fn, + args: args + }); +}; +exports.default = exports.thunk; + +},{"./h":1}],12:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +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 }; +} +exports.vnode = vnode; +exports.default = vnode; + +},{}]},{},[9])(9) +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/.registry.npmjs.org/browser-pack/6.0.2/node_modules/browser-pack/_prelude.js","h.js","htmldomapi.js","is.js","modules/attributes.js","modules/class.js","modules/eventlisteners.js","modules/props.js","modules/style.js","snabbdom.bundle.js","snabbdom.js","thunk.js","vnode.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar vnode_1 = require(\"./vnode\");\nvar is = require(\"./is\");\nfunction addNS(data, children, sel) {\n    data.ns = 'http://www.w3.org/2000/svg';\n    if (sel !== 'foreignObject' && children !== undefined) {\n        for (var i = 0; i < children.length; ++i) {\n            var childData = children[i].data;\n            if (childData !== undefined) {\n                addNS(childData, children[i].children, children[i].sel);\n            }\n        }\n    }\n}\nfunction h(sel, b, c) {\n    var data = {}, children, text, i;\n    if (c !== undefined) {\n        data = b;\n        if (is.array(c)) {\n            children = c;\n        }\n        else if (is.primitive(c)) {\n            text = c;\n        }\n        else if (c && c.sel) {\n            children = [c];\n        }\n    }\n    else if (b !== undefined) {\n        if (is.array(b)) {\n            children = b;\n        }\n        else if (is.primitive(b)) {\n            text = b;\n        }\n        else if (b && b.sel) {\n            children = [b];\n        }\n        else {\n            data = b;\n        }\n    }\n    if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n            if (is.primitive(children[i]))\n                children[i] = vnode_1.vnode(undefined, undefined, undefined, children[i]);\n        }\n    }\n    if (sel[0] === 's' && sel[1] === 'v' && sel[2] === 'g' &&\n        (sel.length === 3 || sel[3] === '.' || sel[3] === '#')) {\n        addNS(data, children, sel);\n    }\n    return vnode_1.vnode(sel, data, children, text, undefined);\n}\nexports.h = h;\n;\nexports.default = h;\n//# sourceMappingURL=h.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction createElement(tagName) {\n    return document.createElement(tagName);\n}\nfunction createElementNS(namespaceURI, qualifiedName) {\n    return document.createElementNS(namespaceURI, qualifiedName);\n}\nfunction createTextNode(text) {\n    return document.createTextNode(text);\n}\nfunction createComment(text) {\n    return document.createComment(text);\n}\nfunction insertBefore(parentNode, newNode, referenceNode) {\n    parentNode.insertBefore(newNode, referenceNode);\n}\nfunction removeChild(node, child) {\n    node.removeChild(child);\n}\nfunction appendChild(node, child) {\n    node.appendChild(child);\n}\nfunction parentNode(node) {\n    return node.parentNode;\n}\nfunction nextSibling(node) {\n    return node.nextSibling;\n}\nfunction tagName(elm) {\n    return elm.tagName;\n}\nfunction setTextContent(node, text) {\n    node.textContent = text;\n}\nfunction getTextContent(node) {\n    return node.textContent;\n}\nfunction isElement(node) {\n    return node.nodeType === 1;\n}\nfunction isText(node) {\n    return node.nodeType === 3;\n}\nfunction isComment(node) {\n    return node.nodeType === 8;\n}\nexports.htmlDomApi = {\n    createElement: createElement,\n    createElementNS: createElementNS,\n    createTextNode: createTextNode,\n    createComment: createComment,\n    insertBefore: insertBefore,\n    removeChild: removeChild,\n    appendChild: appendChild,\n    parentNode: parentNode,\n    nextSibling: nextSibling,\n    tagName: tagName,\n    setTextContent: setTextContent,\n    getTextContent: getTextContent,\n    isElement: isElement,\n    isText: isText,\n    isComment: isComment,\n};\nexports.default = exports.htmlDomApi;\n//# sourceMappingURL=htmldomapi.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.array = Array.isArray;\nfunction primitive(s) {\n    return typeof s === 'string' || typeof s === 'number';\n}\nexports.primitive = primitive;\n//# sourceMappingURL=is.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\",\n    \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\",\n    \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\",\n    \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\",\n    \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\",\n    \"truespeed\", \"typemustmatch\", \"visible\"];\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\nvar xmlNS = 'http://www.w3.org/XML/1998/namespace';\nvar colonChar = 58;\nvar xChar = 120;\nvar booleanAttrsDict = Object.create(null);\nfor (var i = 0, len = booleanAttrs.length; i < len; i++) {\n    booleanAttrsDict[booleanAttrs[i]] = true;\n}\nfunction updateAttrs(oldVnode, vnode) {\n    var key, elm = vnode.elm, oldAttrs = oldVnode.data.attrs, attrs = vnode.data.attrs;\n    if (!oldAttrs && !attrs)\n        return;\n    if (oldAttrs === attrs)\n        return;\n    oldAttrs = oldAttrs || {};\n    attrs = attrs || {};\n    // update modified attributes, add new attributes\n    for (key in attrs) {\n        var cur = attrs[key];\n        var old = oldAttrs[key];\n        if (old !== cur) {\n            if (booleanAttrsDict[key]) {\n                if (cur) {\n                    elm.setAttribute(key, \"\");\n                }\n                else {\n                    elm.removeAttribute(key);\n                }\n            }\n            else {\n                if (key.charCodeAt(0) !== xChar) {\n                    elm.setAttribute(key, cur);\n                }\n                else if (key.charCodeAt(3) === colonChar) {\n                    // Assume xml namespace\n                    elm.setAttributeNS(xmlNS, key, cur);\n                }\n                else if (key.charCodeAt(5) === colonChar) {\n                    // Assume xlink namespace\n                    elm.setAttributeNS(xlinkNS, key, cur);\n                }\n                else {\n                    elm.setAttribute(key, cur);\n                }\n            }\n        }\n    }\n    // remove removed attributes\n    // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n    // the other option is to remove all attributes with value == undefined\n    for (key in oldAttrs) {\n        if (!(key in attrs)) {\n            elm.removeAttribute(key);\n        }\n    }\n}\nexports.attributesModule = { create: updateAttrs, update: updateAttrs };\nexports.default = exports.attributesModule;\n//# sourceMappingURL=attributes.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction updateClass(oldVnode, vnode) {\n    var cur, name, elm = vnode.elm, oldClass = oldVnode.data.class, klass = vnode.data.class;\n    if (!oldClass && !klass)\n        return;\n    if (oldClass === klass)\n        return;\n    oldClass = oldClass || {};\n    klass = klass || {};\n    for (name in oldClass) {\n        if (!klass[name]) {\n            elm.classList.remove(name);\n        }\n    }\n    for (name in klass) {\n        cur = klass[name];\n        if (cur !== oldClass[name]) {\n            elm.classList[cur ? 'add' : 'remove'](name);\n        }\n    }\n}\nexports.classModule = { create: updateClass, update: updateClass };\nexports.default = exports.classModule;\n//# sourceMappingURL=class.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction invokeHandler(handler, vnode, event) {\n    if (typeof handler === \"function\") {\n        // call function handler\n        handler.call(vnode, event, vnode);\n    }\n    else if (typeof handler === \"object\") {\n        // call handler with arguments\n        if (typeof handler[0] === \"function\") {\n            // special case for single argument for performance\n            if (handler.length === 2) {\n                handler[0].call(vnode, handler[1], event, vnode);\n            }\n            else {\n                var args = handler.slice(1);\n                args.push(event);\n                args.push(vnode);\n                handler[0].apply(vnode, args);\n            }\n        }\n        else {\n            // call multiple handlers\n            for (var i = 0; i < handler.length; i++) {\n                invokeHandler(handler[i]);\n            }\n        }\n    }\n}\nfunction handleEvent(event, vnode) {\n    var name = event.type, on = vnode.data.on;\n    // call event handler(s) if exists\n    if (on && on[name]) {\n        invokeHandler(on[name], vnode, event);\n    }\n}\nfunction createListener() {\n    return function handler(event) {\n        handleEvent(event, handler.vnode);\n    };\n}\nfunction updateEventListeners(oldVnode, vnode) {\n    var oldOn = oldVnode.data.on, oldListener = oldVnode.listener, oldElm = oldVnode.elm, on = vnode && vnode.data.on, elm = (vnode && vnode.elm), name;\n    // optimization for reused immutable handlers\n    if (oldOn === on) {\n        return;\n    }\n    // remove existing listeners which no longer used\n    if (oldOn && oldListener) {\n        // if element changed or deleted we remove all existing listeners unconditionally\n        if (!on) {\n            for (name in oldOn) {\n                // remove listener if element was changed or existing listeners removed\n                oldElm.removeEventListener(name, oldListener, false);\n            }\n        }\n        else {\n            for (name in oldOn) {\n                // remove listener if existing listener removed\n                if (!on[name]) {\n                    oldElm.removeEventListener(name, oldListener, false);\n                }\n            }\n        }\n    }\n    // add new listeners which has not already attached\n    if (on) {\n        // reuse existing listener or create new\n        var listener = vnode.listener = oldVnode.listener || createListener();\n        // update vnode for listener\n        listener.vnode = vnode;\n        // if element changed or added we add all needed listeners unconditionally\n        if (!oldOn) {\n            for (name in on) {\n                // add listener if element was changed or new listeners added\n                elm.addEventListener(name, listener, false);\n            }\n        }\n        else {\n            for (name in on) {\n                // add listener if new listener added\n                if (!oldOn[name]) {\n                    elm.addEventListener(name, listener, false);\n                }\n            }\n        }\n    }\n}\nexports.eventListenersModule = {\n    create: updateEventListeners,\n    update: updateEventListeners,\n    destroy: updateEventListeners\n};\nexports.default = exports.eventListenersModule;\n//# sourceMappingURL=eventlisteners.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction updateProps(oldVnode, vnode) {\n    var key, cur, old, elm = vnode.elm, oldProps = oldVnode.data.props, props = vnode.data.props;\n    if (!oldProps && !props)\n        return;\n    if (oldProps === props)\n        return;\n    oldProps = oldProps || {};\n    props = props || {};\n    for (key in oldProps) {\n        if (!props[key]) {\n            delete elm[key];\n        }\n    }\n    for (key in props) {\n        cur = props[key];\n        old = oldProps[key];\n        if (old !== cur && (key !== 'value' || elm[key] !== cur)) {\n            elm[key] = cur;\n        }\n    }\n}\nexports.propsModule = { create: updateProps, update: updateProps };\nexports.default = exports.propsModule;\n//# sourceMappingURL=props.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar raf = (typeof window !== 'undefined' && window.requestAnimationFrame) || setTimeout;\nvar nextFrame = function (fn) { raf(function () { raf(fn); }); };\nfunction setNextFrame(obj, prop, val) {\n    nextFrame(function () { obj[prop] = val; });\n}\nfunction updateStyle(oldVnode, vnode) {\n    var cur, name, elm = vnode.elm, oldStyle = oldVnode.data.style, style = vnode.data.style;\n    if (!oldStyle && !style)\n        return;\n    if (oldStyle === style)\n        return;\n    oldStyle = oldStyle || {};\n    style = style || {};\n    var oldHasDel = 'delayed' in oldStyle;\n    for (name in oldStyle) {\n        if (!style[name]) {\n            if (name[0] === '-' && name[1] === '-') {\n                elm.style.removeProperty(name);\n            }\n            else {\n                elm.style[name] = '';\n            }\n        }\n    }\n    for (name in style) {\n        cur = style[name];\n        if (name === 'delayed' && style.delayed) {\n            for (var name2 in style.delayed) {\n                cur = style.delayed[name2];\n                if (!oldHasDel || cur !== oldStyle.delayed[name2]) {\n                    setNextFrame(elm.style, name2, cur);\n                }\n            }\n        }\n        else if (name !== 'remove' && cur !== oldStyle[name]) {\n            if (name[0] === '-' && name[1] === '-') {\n                elm.style.setProperty(name, cur);\n            }\n            else {\n                elm.style[name] = cur;\n            }\n        }\n    }\n}\nfunction applyDestroyStyle(vnode) {\n    var style, name, elm = vnode.elm, s = vnode.data.style;\n    if (!s || !(style = s.destroy))\n        return;\n    for (name in style) {\n        elm.style[name] = style[name];\n    }\n}\nfunction applyRemoveStyle(vnode, rm) {\n    var s = vnode.data.style;\n    if (!s || !s.remove) {\n        rm();\n        return;\n    }\n    var name, elm = vnode.elm, i = 0, compStyle, style = s.remove, amount = 0, applied = [];\n    for (name in style) {\n        applied.push(name);\n        elm.style[name] = style[name];\n    }\n    compStyle = getComputedStyle(elm);\n    var props = compStyle['transition-property'].split(', ');\n    for (; i < props.length; ++i) {\n        if (applied.indexOf(props[i]) !== -1)\n            amount++;\n    }\n    elm.addEventListener('transitionend', function (ev) {\n        if (ev.target === elm)\n            --amount;\n        if (amount === 0)\n            rm();\n    });\n}\nexports.styleModule = {\n    create: updateStyle,\n    update: updateStyle,\n    destroy: applyDestroyStyle,\n    remove: applyRemoveStyle\n};\nexports.default = exports.styleModule;\n//# sourceMappingURL=style.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar snabbdom_1 = require(\"./snabbdom\");\nvar attributes_1 = require(\"./modules/attributes\"); // for setting attributes on DOM elements\nvar class_1 = require(\"./modules/class\"); // makes it easy to toggle classes\nvar props_1 = require(\"./modules/props\"); // for setting properties on DOM elements\nvar style_1 = require(\"./modules/style\"); // handles styling on elements with support for animations\nvar eventlisteners_1 = require(\"./modules/eventlisteners\"); // attaches event listeners\nvar h_1 = require(\"./h\"); // helper function for creating vnodes\nvar patch = snabbdom_1.init([\n    attributes_1.attributesModule,\n    class_1.classModule,\n    props_1.propsModule,\n    style_1.styleModule,\n    eventlisteners_1.eventListenersModule\n]);\nexports.snabbdomBundle = { patch: patch, h: h_1.h };\nexports.default = exports.snabbdomBundle;\n//# sourceMappingURL=snabbdom.bundle.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar vnode_1 = require(\"./vnode\");\nvar is = require(\"./is\");\nvar htmldomapi_1 = require(\"./htmldomapi\");\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\nvar emptyNode = vnode_1.default('', {}, [], undefined, undefined);\nfunction sameVnode(vnode1, vnode2) {\n    return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\nfunction isVnode(vnode) {\n    return vnode.sel !== undefined;\n}\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n    var i, map = {}, key, ch;\n    for (i = beginIdx; i <= endIdx; ++i) {\n        ch = children[i];\n        if (ch != null) {\n            key = ch.key;\n            if (key !== undefined)\n                map[key] = i;\n        }\n    }\n    return map;\n}\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\nvar h_1 = require(\"./h\");\nexports.h = h_1.h;\nvar thunk_1 = require(\"./thunk\");\nexports.thunk = thunk_1.thunk;\nfunction init(modules, domApi) {\n    var i, j, cbs = {};\n    var api = domApi !== undefined ? domApi : htmldomapi_1.default;\n    for (i = 0; i < hooks.length; ++i) {\n        cbs[hooks[i]] = [];\n        for (j = 0; j < modules.length; ++j) {\n            var hook = modules[j][hooks[i]];\n            if (hook !== undefined) {\n                cbs[hooks[i]].push(hook);\n            }\n        }\n    }\n    function emptyNodeAt(elm) {\n        var id = elm.id ? '#' + elm.id : '';\n        var c = elm.className ? '.' + elm.className.split(' ').join('.') : '';\n        return vnode_1.default(api.tagName(elm).toLowerCase() + id + c, {}, [], undefined, elm);\n    }\n    function createRmCb(childElm, listeners) {\n        return function rmCb() {\n            if (--listeners === 0) {\n                var parent_1 = api.parentNode(childElm);\n                api.removeChild(parent_1, childElm);\n            }\n        };\n    }\n    function createElm(vnode, insertedVnodeQueue) {\n        var i, data = vnode.data;\n        if (data !== undefined) {\n            if (isDef(i = data.hook) && isDef(i = i.init)) {\n                i(vnode);\n                data = vnode.data;\n            }\n        }\n        var children = vnode.children, sel = vnode.sel;\n        if (sel === '!') {\n            if (isUndef(vnode.text)) {\n                vnode.text = '';\n            }\n            vnode.elm = api.createComment(vnode.text);\n        }\n        else if (sel !== undefined) {\n            // Parse selector\n            var hashIdx = sel.indexOf('#');\n            var dotIdx = sel.indexOf('.', hashIdx);\n            var hash = hashIdx > 0 ? hashIdx : sel.length;\n            var dot = dotIdx > 0 ? dotIdx : sel.length;\n            var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n            var elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? api.createElementNS(i, tag)\n                : api.createElement(tag);\n            if (hash < dot)\n                elm.setAttribute('id', sel.slice(hash + 1, dot));\n            if (dotIdx > 0)\n                elm.setAttribute('class', sel.slice(dot + 1).replace(/\\./g, ' '));\n            for (i = 0; i < cbs.create.length; ++i)\n                cbs.create[i](emptyNode, vnode);\n            if (is.array(children)) {\n                for (i = 0; i < children.length; ++i) {\n                    var ch = children[i];\n                    if (ch != null) {\n                        api.appendChild(elm, createElm(ch, insertedVnodeQueue));\n                    }\n                }\n            }\n            else if (is.primitive(vnode.text)) {\n                api.appendChild(elm, api.createTextNode(vnode.text));\n            }\n            i = vnode.data.hook; // Reuse variable\n            if (isDef(i)) {\n                if (i.create)\n                    i.create(emptyNode, vnode);\n                if (i.insert)\n                    insertedVnodeQueue.push(vnode);\n            }\n        }\n        else {\n            vnode.elm = api.createTextNode(vnode.text);\n        }\n        return vnode.elm;\n    }\n    function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n        for (; startIdx <= endIdx; ++startIdx) {\n            var ch = vnodes[startIdx];\n            if (ch != null) {\n                api.insertBefore(parentElm, createElm(ch, insertedVnodeQueue), before);\n            }\n        }\n    }\n    function invokeDestroyHook(vnode) {\n        var i, j, data = vnode.data;\n        if (data !== undefined) {\n            if (isDef(i = data.hook) && isDef(i = i.destroy))\n                i(vnode);\n            for (i = 0; i < cbs.destroy.length; ++i)\n                cbs.destroy[i](vnode);\n            if (vnode.children !== undefined) {\n                for (j = 0; j < vnode.children.length; ++j) {\n                    i = vnode.children[j];\n                    if (i != null && typeof i !== \"string\") {\n                        invokeDestroyHook(i);\n                    }\n                }\n            }\n        }\n    }\n    function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n        for (; startIdx <= endIdx; ++startIdx) {\n            var i_1 = void 0, listeners = void 0, rm = void 0, ch = vnodes[startIdx];\n            if (ch != null) {\n                if (isDef(ch.sel)) {\n                    invokeDestroyHook(ch);\n                    listeners = cbs.remove.length + 1;\n                    rm = createRmCb(ch.elm, listeners);\n                    for (i_1 = 0; i_1 < cbs.remove.length; ++i_1)\n                        cbs.remove[i_1](ch, rm);\n                    if (isDef(i_1 = ch.data) && isDef(i_1 = i_1.hook) && isDef(i_1 = i_1.remove)) {\n                        i_1(ch, rm);\n                    }\n                    else {\n                        rm();\n                    }\n                }\n                else {\n                    api.removeChild(parentElm, ch.elm);\n                }\n            }\n        }\n    }\n    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue) {\n        var oldStartIdx = 0, newStartIdx = 0;\n        var oldEndIdx = oldCh.length - 1;\n        var oldStartVnode = oldCh[0];\n        var oldEndVnode = oldCh[oldEndIdx];\n        var newEndIdx = newCh.length - 1;\n        var newStartVnode = newCh[0];\n        var newEndVnode = newCh[newEndIdx];\n        var oldKeyToIdx;\n        var idxInOld;\n        var elmToMove;\n        var before;\n        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n            if (oldStartVnode == null) {\n                oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left\n            }\n            else if (oldEndVnode == null) {\n                oldEndVnode = oldCh[--oldEndIdx];\n            }\n            else if (newStartVnode == null) {\n                newStartVnode = newCh[++newStartIdx];\n            }\n            else if (newEndVnode == null) {\n                newEndVnode = newCh[--newEndIdx];\n            }\n            else if (sameVnode(oldStartVnode, newStartVnode)) {\n                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n                oldStartVnode = oldCh[++oldStartIdx];\n                newStartVnode = newCh[++newStartIdx];\n            }\n            else if (sameVnode(oldEndVnode, newEndVnode)) {\n                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n                oldEndVnode = oldCh[--oldEndIdx];\n                newEndVnode = newCh[--newEndIdx];\n            }\n            else if (sameVnode(oldStartVnode, newEndVnode)) {\n                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n                api.insertBefore(parentElm, oldStartVnode.elm, api.nextSibling(oldEndVnode.elm));\n                oldStartVnode = oldCh[++oldStartIdx];\n                newEndVnode = newCh[--newEndIdx];\n            }\n            else if (sameVnode(oldEndVnode, newStartVnode)) {\n                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n                api.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n                oldEndVnode = oldCh[--oldEndIdx];\n                newStartVnode = newCh[++newStartIdx];\n            }\n            else {\n                if (oldKeyToIdx === undefined) {\n                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n                }\n                idxInOld = oldKeyToIdx[newStartVnode.key];\n                if (isUndef(idxInOld)) {\n                    api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);\n                    newStartVnode = newCh[++newStartIdx];\n                }\n                else {\n                    elmToMove = oldCh[idxInOld];\n                    if (elmToMove.sel !== newStartVnode.sel) {\n                        api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);\n                    }\n                    else {\n                        patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n                        oldCh[idxInOld] = undefined;\n                        api.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);\n                    }\n                    newStartVnode = newCh[++newStartIdx];\n                }\n            }\n        }\n        if (oldStartIdx > oldEndIdx) {\n            before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm;\n            addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n        }\n        else if (newStartIdx > newEndIdx) {\n            removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n        }\n    }\n    function patchVnode(oldVnode, vnode, insertedVnodeQueue) {\n        var i, hook;\n        if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n            i(oldVnode, vnode);\n        }\n        var elm = vnode.elm = oldVnode.elm;\n        var oldCh = oldVnode.children;\n        var ch = vnode.children;\n        if (oldVnode === vnode)\n            return;\n        if (vnode.data !== undefined) {\n            for (i = 0; i < cbs.update.length; ++i)\n                cbs.update[i](oldVnode, vnode);\n            i = vnode.data.hook;\n            if (isDef(i) && isDef(i = i.update))\n                i(oldVnode, vnode);\n        }\n        if (isUndef(vnode.text)) {\n            if (isDef(oldCh) && isDef(ch)) {\n                if (oldCh !== ch)\n                    updateChildren(elm, oldCh, ch, insertedVnodeQueue);\n            }\n            else if (isDef(ch)) {\n                if (isDef(oldVnode.text))\n                    api.setTextContent(elm, '');\n                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n            }\n            else if (isDef(oldCh)) {\n                removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n            }\n            else if (isDef(oldVnode.text)) {\n                api.setTextContent(elm, '');\n            }\n        }\n        else if (oldVnode.text !== vnode.text) {\n            api.setTextContent(elm, vnode.text);\n        }\n        if (isDef(hook) && isDef(i = hook.postpatch)) {\n            i(oldVnode, vnode);\n        }\n    }\n    return function patch(oldVnode, vnode) {\n        var i, elm, parent;\n        var insertedVnodeQueue = [];\n        for (i = 0; i < cbs.pre.length; ++i)\n            cbs.pre[i]();\n        if (!isVnode(oldVnode)) {\n            oldVnode = emptyNodeAt(oldVnode);\n        }\n        if (sameVnode(oldVnode, vnode)) {\n            patchVnode(oldVnode, vnode, insertedVnodeQueue);\n        }\n        else {\n            elm = oldVnode.elm;\n            parent = api.parentNode(elm);\n            createElm(vnode, insertedVnodeQueue);\n            if (parent !== null) {\n                api.insertBefore(parent, vnode.elm, api.nextSibling(elm));\n                removeVnodes(parent, [oldVnode], 0, 0);\n            }\n        }\n        for (i = 0; i < insertedVnodeQueue.length; ++i) {\n            insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n        }\n        for (i = 0; i < cbs.post.length; ++i)\n            cbs.post[i]();\n        return vnode;\n    };\n}\nexports.init = init;\n//# sourceMappingURL=snabbdom.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar h_1 = require(\"./h\");\nfunction copyToThunk(vnode, thunk) {\n    thunk.elm = vnode.elm;\n    vnode.data.fn = thunk.data.fn;\n    vnode.data.args = thunk.data.args;\n    thunk.data = vnode.data;\n    thunk.children = vnode.children;\n    thunk.text = vnode.text;\n    thunk.elm = vnode.elm;\n}\nfunction init(thunk) {\n    var cur = thunk.data;\n    var vnode = cur.fn.apply(undefined, cur.args);\n    copyToThunk(vnode, thunk);\n}\nfunction prepatch(oldVnode, thunk) {\n    var i, old = oldVnode.data, cur = thunk.data;\n    var oldArgs = old.args, args = cur.args;\n    if (old.fn !== cur.fn || oldArgs.length !== args.length) {\n        copyToThunk(cur.fn.apply(undefined, args), thunk);\n        return;\n    }\n    for (i = 0; i < args.length; ++i) {\n        if (oldArgs[i] !== args[i]) {\n            copyToThunk(cur.fn.apply(undefined, args), thunk);\n            return;\n        }\n    }\n    copyToThunk(oldVnode, thunk);\n}\nexports.thunk = function thunk(sel, key, fn, args) {\n    if (args === undefined) {\n        args = fn;\n        fn = key;\n        key = undefined;\n    }\n    return h_1.h(sel, {\n        key: key,\n        hook: { init: init, prepatch: prepatch },\n        fn: fn,\n        args: args\n    });\n};\nexports.default = exports.thunk;\n//# sourceMappingURL=thunk.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction vnode(sel, data, children, text, elm) {\n    var key = data === undefined ? undefined : data.key;\n    return { sel: sel, data: data, children: children,\n        text: text, elm: elm, key: key };\n}\nexports.vnode = vnode;\nexports.default = vnode;\n//# sourceMappingURL=vnode.js.map"]} diff --git a/src/libs/snabbdom/dist/snabbdom-patch.min.js b/src/libs/snabbdom/dist/snabbdom-patch.min.js new file mode 100755 index 00000000..960c0d86 --- /dev/null +++ b/src/libs/snabbdom/dist/snabbdom-patch.min.js @@ -0,0 +1,2 @@ +!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var t;t="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,t.snabbdom=e()}}(function(){return function e(t,n,r){function o(l,a){if(!n[l]){if(!t[l]){var d="function"==typeof require&&require;if(!a&&d)return d(l,!0);if(i)return i(l,!0);var u=new Error("Cannot find module '"+l+"'");throw u.code="MODULE_NOT_FOUND",u}var s=n[l]={exports:{}};t[l][0].call(s.exports,function(e){var n=t[l][1][e];return o(n?n:e)},s,s.exports,e,t,n,r)}return n[l].exports}for(var i="function"==typeof require&&require,l=0;l1&&o.hasOwnProperty(a[0])?d.setAttributeNS(o[a[0]],n,r):d.setAttribute(n,r)));for(n in u)n in s||d.removeAttribute(n)}}for(var o={xlink:"http://www.w3.org/1999/xlink"},i=["allowfullscreen","async","autofocus","autoplay","checked","compact","controls","declare","default","defaultchecked","defaultmuted","defaultselected","defer","disabled","draggable","enabled","formnovalidate","hidden","indeterminate","inert","ismap","itemscope","loop","multiple","muted","nohref","noresize","noshade","novalidate","nowrap","open","pauseonexit","readonly","required","reversed","scoped","seamless","selected","sortable","spellcheck","translate","truespeed","typemustmatch","visible"],l=Object.create(null),a=0,d=i.length;a0?d:a.length,v=u>0?u:a.length,m=d!==-1||u!==-1?a.slice(0,Math.min(f,v)):a,h=e.elm=o(i)&&o(n=i.ns)?w.createElementNS(n,m):w.createElement(m);for(f0&&(h.className=a.slice(v+1).replace(/\./g," ")),n=0;nv?(s=null==n[x+1]?null:n[x+1].elm,m(e,s,n,c,x,o)):c>x&&y(e,t,f,v)}function b(e,t,n){var i,l;o(i=t.data)&&o(l=i.hook)&&o(i=l.prepatch)&&i(e,t);var a=t.elm=e.elm,d=e.children,u=t.children;if(e!==t){if(void 0!==t.data){for(i=0;i 1 && NamespaceURIs.hasOwnProperty(namespaceSplit[0]))\n elm.setAttributeNS(NamespaceURIs[namespaceSplit[0]], key, cur);\n else\n elm.setAttribute(key, cur);\n }\n }\n }\n //remove removed attributes\n // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n // the other option is to remove all attributes with value == undefined\n for (key in oldAttrs) {\n if (!(key in attrs)) {\n elm.removeAttribute(key);\n }\n }\n}\nexports.attributesModule = { create: updateAttrs, update: updateAttrs };\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.attributesModule;\n\n},{}],5:[function(require,module,exports){\n\"use strict\";\nfunction updateClass(oldVnode, vnode) {\n var cur, name, elm = vnode.elm, oldClass = oldVnode.data.class, klass = vnode.data.class;\n if (!oldClass && !klass)\n return;\n if (oldClass === klass)\n return;\n oldClass = oldClass || {};\n klass = klass || {};\n for (name in oldClass) {\n if (!klass[name]) {\n elm.classList.remove(name);\n }\n }\n for (name in klass) {\n cur = klass[name];\n if (cur !== oldClass[name]) {\n elm.classList[cur ? 'add' : 'remove'](name);\n }\n }\n}\nexports.classModule = { create: updateClass, update: updateClass };\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.classModule;\n\n},{}],6:[function(require,module,exports){\n\"use strict\";\nfunction invokeHandler(handler, vnode, event) {\n if (typeof handler === \"function\") {\n // call function handler\n handler.call(vnode, event, vnode);\n }\n else if (typeof handler === \"object\") {\n // call handler with arguments\n if (typeof handler[0] === \"function\") {\n // special case for single argument for performance\n if (handler.length === 2) {\n handler[0].call(vnode, handler[1], event, vnode);\n }\n else {\n var args = handler.slice(1);\n args.push(event);\n args.push(vnode);\n handler[0].apply(vnode, args);\n }\n }\n else {\n // call multiple handlers\n for (var i = 0; i < handler.length; i++) {\n invokeHandler(handler[i]);\n }\n }\n }\n}\nfunction handleEvent(event, vnode) {\n var name = event.type, on = vnode.data.on;\n // call event handler(s) if exists\n if (on && on[name]) {\n invokeHandler(on[name], vnode, event);\n }\n}\nfunction createListener() {\n return function handler(event) {\n handleEvent(event, handler.vnode);\n };\n}\nfunction updateEventListeners(oldVnode, vnode) {\n var oldOn = oldVnode.data.on, oldListener = oldVnode.listener, oldElm = oldVnode.elm, on = vnode && vnode.data.on, elm = (vnode && vnode.elm), name;\n // optimization for reused immutable handlers\n if (oldOn === on) {\n return;\n }\n // remove existing listeners which no longer used\n if (oldOn && oldListener) {\n // if element changed or deleted we remove all existing listeners unconditionally\n if (!on) {\n for (name in oldOn) {\n // remove listener if element was changed or existing listeners removed\n oldElm.removeEventListener(name, oldListener, false);\n }\n }\n else {\n for (name in oldOn) {\n // remove listener if existing listener removed\n if (!on[name]) {\n oldElm.removeEventListener(name, oldListener, false);\n }\n }\n }\n }\n // add new listeners which has not already attached\n if (on) {\n // reuse existing listener or create new\n var listener = vnode.listener = oldVnode.listener || createListener();\n // update vnode for listener\n listener.vnode = vnode;\n // if element changed or added we add all needed listeners unconditionally\n if (!oldOn) {\n for (name in on) {\n // add listener if element was changed or new listeners added\n elm.addEventListener(name, listener, false);\n }\n }\n else {\n for (name in on) {\n // add listener if new listener added\n if (!oldOn[name]) {\n elm.addEventListener(name, listener, false);\n }\n }\n }\n }\n}\nexports.eventListenersModule = {\n create: updateEventListeners,\n update: updateEventListeners,\n destroy: updateEventListeners\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.eventListenersModule;\n\n},{}],7:[function(require,module,exports){\n\"use strict\";\nfunction updateProps(oldVnode, vnode) {\n var key, cur, old, elm = vnode.elm, oldProps = oldVnode.data.props, props = vnode.data.props;\n if (!oldProps && !props)\n return;\n if (oldProps === props)\n return;\n oldProps = oldProps || {};\n props = props || {};\n for (key in oldProps) {\n if (!props[key]) {\n delete elm[key];\n }\n }\n for (key in props) {\n cur = props[key];\n old = oldProps[key];\n if (old !== cur && (key !== 'value' || elm[key] !== cur)) {\n elm[key] = cur;\n }\n }\n}\nexports.propsModule = { create: updateProps, update: updateProps };\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.propsModule;\n\n},{}],8:[function(require,module,exports){\n\"use strict\";\nvar raf = (typeof window !== 'undefined' && window.requestAnimationFrame) || setTimeout;\nvar nextFrame = function (fn) { raf(function () { raf(fn); }); };\nfunction setNextFrame(obj, prop, val) {\n nextFrame(function () { obj[prop] = val; });\n}\nfunction updateStyle(oldVnode, vnode) {\n var cur, name, elm = vnode.elm, oldStyle = oldVnode.data.style, style = vnode.data.style;\n if (!oldStyle && !style)\n return;\n if (oldStyle === style)\n return;\n oldStyle = oldStyle || {};\n style = style || {};\n var oldHasDel = 'delayed' in oldStyle;\n for (name in oldStyle) {\n if (!style[name]) {\n if (name[0] === '-' && name[1] === '-') {\n elm.style.removeProperty(name);\n }\n else {\n elm.style[name] = '';\n }\n }\n }\n for (name in style) {\n cur = style[name];\n if (name === 'delayed') {\n for (name in style.delayed) {\n cur = style.delayed[name];\n if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n setNextFrame(elm.style, name, cur);\n }\n }\n }\n else if (name !== 'remove' && cur !== oldStyle[name]) {\n if (name[0] === '-' && name[1] === '-') {\n elm.style.setProperty(name, cur);\n }\n else {\n elm.style[name] = cur;\n }\n }\n }\n}\nfunction applyDestroyStyle(vnode) {\n var style, name, elm = vnode.elm, s = vnode.data.style;\n if (!s || !(style = s.destroy))\n return;\n for (name in style) {\n elm.style[name] = style[name];\n }\n}\nfunction applyRemoveStyle(vnode, rm) {\n var s = vnode.data.style;\n if (!s || !s.remove) {\n rm();\n return;\n }\n var name, elm = vnode.elm, i = 0, compStyle, style = s.remove, amount = 0, applied = [];\n for (name in style) {\n applied.push(name);\n elm.style[name] = style[name];\n }\n compStyle = getComputedStyle(elm);\n var props = compStyle['transition-property'].split(', ');\n for (; i < props.length; ++i) {\n if (applied.indexOf(props[i]) !== -1)\n amount++;\n }\n elm.addEventListener('transitionend', function (ev) {\n if (ev.target === elm)\n --amount;\n if (amount === 0)\n rm();\n });\n}\nexports.styleModule = {\n create: updateStyle,\n update: updateStyle,\n destroy: applyDestroyStyle,\n remove: applyRemoveStyle\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.styleModule;\n\n},{}],9:[function(require,module,exports){\n\"use strict\";\nvar snabbdom_1 = require(\"./snabbdom\");\nvar attributes_1 = require(\"./modules/attributes\"); // for setting attributes on DOM elements\nvar class_1 = require(\"./modules/class\"); // makes it easy to toggle classes\nvar props_1 = require(\"./modules/props\"); // for setting properties on DOM elements\nvar style_1 = require(\"./modules/style\"); // handles styling on elements with support for animations\nvar eventlisteners_1 = require(\"./modules/eventlisteners\"); // attaches event listeners\nvar h_1 = require(\"./h\"); // helper function for creating vnodes\nvar patch = snabbdom_1.init([\n attributes_1.attributesModule,\n class_1.classModule,\n props_1.propsModule,\n style_1.styleModule,\n eventlisteners_1.eventListenersModule\n]);\nexports.snabbdomBundle = { patch: patch, h: h_1.h };\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.snabbdomBundle;\n\n},{\"./h\":1,\"./modules/attributes\":4,\"./modules/class\":5,\"./modules/eventlisteners\":6,\"./modules/props\":7,\"./modules/style\":8,\"./snabbdom\":10}],10:[function(require,module,exports){\n\"use strict\";\nvar vnode_1 = require(\"./vnode\");\nvar is = require(\"./is\");\nvar htmldomapi_1 = require(\"./htmldomapi\");\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\nvar emptyNode = vnode_1.default('', {}, [], undefined, undefined);\nfunction sameVnode(vnode1, vnode2) {\n return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\nfunction isVnode(vnode) {\n return vnode.sel !== undefined;\n}\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n var i, map = {}, key, ch;\n for (i = beginIdx; i <= endIdx; ++i) {\n ch = children[i];\n if (ch != null) {\n key = ch.key;\n if (key !== undefined)\n map[key] = i;\n }\n }\n return map;\n}\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\nvar h_1 = require(\"./h\");\nexports.h = h_1.h;\nvar thunk_1 = require(\"./thunk\");\nexports.thunk = thunk_1.thunk;\nfunction init(modules, domApi) {\n var i, j, cbs = {};\n var api = domApi !== undefined ? domApi : htmldomapi_1.default;\n for (i = 0; i < hooks.length; ++i) {\n cbs[hooks[i]] = [];\n for (j = 0; j < modules.length; ++j) {\n var hook = modules[j][hooks[i]];\n if (hook !== undefined) {\n cbs[hooks[i]].push(hook);\n }\n }\n }\n function emptyNodeAt(elm) {\n var id = elm.id ? '#' + elm.id : '';\n var c = elm.className ? '.' + elm.className.split(' ').join('.') : '';\n return vnode_1.default(api.tagName(elm).toLowerCase() + id + c, {}, [], undefined, elm);\n }\n function createRmCb(childElm, listeners) {\n return function rmCb() {\n if (--listeners === 0) {\n var parent_1 = api.parentNode(childElm);\n api.removeChild(parent_1, childElm);\n }\n };\n }\n function createElm(vnode, insertedVnodeQueue) {\n var i, data = vnode.data;\n if (data !== undefined) {\n if (isDef(i = data.hook) && isDef(i = i.init)) {\n i(vnode);\n data = vnode.data;\n }\n }\n var children = vnode.children, sel = vnode.sel;\n if (sel === '!') {\n if (isUndef(vnode.text)) {\n vnode.text = '';\n }\n vnode.elm = api.createComment(vnode.text);\n }\n else if (sel !== undefined) {\n // Parse selector\n var hashIdx = sel.indexOf('#');\n var dotIdx = sel.indexOf('.', hashIdx);\n var hash = hashIdx > 0 ? hashIdx : sel.length;\n var dot = dotIdx > 0 ? dotIdx : sel.length;\n var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n var elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? api.createElementNS(i, tag)\n : api.createElement(tag);\n if (hash < dot)\n elm.id = sel.slice(hash + 1, dot);\n if (dotIdx > 0)\n elm.className = sel.slice(dot + 1).replace(/\\./g, ' ');\n for (i = 0; i < cbs.create.length; ++i)\n cbs.create[i](emptyNode, vnode);\n if (is.array(children)) {\n for (i = 0; i < children.length; ++i) {\n var ch = children[i];\n if (ch != null) {\n api.appendChild(elm, createElm(ch, insertedVnodeQueue));\n }\n }\n }\n else if (is.primitive(vnode.text)) {\n api.appendChild(elm, api.createTextNode(vnode.text));\n }\n i = vnode.data.hook; // Reuse variable\n if (isDef(i)) {\n if (i.create)\n i.create(emptyNode, vnode);\n if (i.insert)\n insertedVnodeQueue.push(vnode);\n }\n }\n else {\n vnode.elm = api.createTextNode(vnode.text);\n }\n return vnode.elm;\n }\n function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n for (; startIdx <= endIdx; ++startIdx) {\n var ch = vnodes[startIdx];\n if (ch != null) {\n api.insertBefore(parentElm, createElm(ch, insertedVnodeQueue), before);\n }\n }\n }\n function invokeDestroyHook(vnode) {\n var i, j, data = vnode.data;\n if (data !== undefined) {\n if (isDef(i = data.hook) && isDef(i = i.destroy))\n i(vnode);\n for (i = 0; i < cbs.destroy.length; ++i)\n cbs.destroy[i](vnode);\n if (vnode.children !== undefined) {\n for (j = 0; j < vnode.children.length; ++j) {\n i = vnode.children[j];\n if (i != null && typeof i !== \"string\") {\n invokeDestroyHook(i);\n }\n }\n }\n }\n }\n function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n for (; startIdx <= endIdx; ++startIdx) {\n var i_1 = void 0, listeners = void 0, rm = void 0, ch = vnodes[startIdx];\n if (ch != null) {\n if (isDef(ch.sel)) {\n invokeDestroyHook(ch);\n listeners = cbs.remove.length + 1;\n rm = createRmCb(ch.elm, listeners);\n for (i_1 = 0; i_1 < cbs.remove.length; ++i_1)\n cbs.remove[i_1](ch, rm);\n if (isDef(i_1 = ch.data) && isDef(i_1 = i_1.hook) && isDef(i_1 = i_1.remove)) {\n i_1(ch, rm);\n }\n else {\n rm();\n }\n }\n else {\n api.removeChild(parentElm, ch.elm);\n }\n }\n }\n }\n function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue) {\n var oldStartIdx = 0, newStartIdx = 0;\n var oldEndIdx = oldCh.length - 1;\n var oldStartVnode = oldCh[0];\n var oldEndVnode = oldCh[oldEndIdx];\n var newEndIdx = newCh.length - 1;\n var newStartVnode = newCh[0];\n var newEndVnode = newCh[newEndIdx];\n var oldKeyToIdx;\n var idxInOld;\n var elmToMove;\n var before;\n while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n if (oldStartVnode == null) {\n oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left\n }\n else if (oldEndVnode == null) {\n oldEndVnode = oldCh[--oldEndIdx];\n }\n else if (newStartVnode == null) {\n newStartVnode = newCh[++newStartIdx];\n }\n else if (newEndVnode == null) {\n newEndVnode = newCh[--newEndIdx];\n }\n else if (sameVnode(oldStartVnode, newStartVnode)) {\n patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n oldStartVnode = oldCh[++oldStartIdx];\n newStartVnode = newCh[++newStartIdx];\n }\n else if (sameVnode(oldEndVnode, newEndVnode)) {\n patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n oldEndVnode = oldCh[--oldEndIdx];\n newEndVnode = newCh[--newEndIdx];\n }\n else if (sameVnode(oldStartVnode, newEndVnode)) {\n patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n api.insertBefore(parentElm, oldStartVnode.elm, api.nextSibling(oldEndVnode.elm));\n oldStartVnode = oldCh[++oldStartIdx];\n newEndVnode = newCh[--newEndIdx];\n }\n else if (sameVnode(oldEndVnode, newStartVnode)) {\n patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n api.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n oldEndVnode = oldCh[--oldEndIdx];\n newStartVnode = newCh[++newStartIdx];\n }\n else {\n if (oldKeyToIdx === undefined) {\n oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n }\n idxInOld = oldKeyToIdx[newStartVnode.key];\n if (isUndef(idxInOld)) {\n api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n }\n else {\n elmToMove = oldCh[idxInOld];\n if (elmToMove.sel !== newStartVnode.sel) {\n api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);\n }\n else {\n patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n oldCh[idxInOld] = undefined;\n api.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);\n }\n newStartVnode = newCh[++newStartIdx];\n }\n }\n }\n if (oldStartIdx > oldEndIdx) {\n before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm;\n addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n }\n else if (newStartIdx > newEndIdx) {\n removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n }\n }\n function patchVnode(oldVnode, vnode, insertedVnodeQueue) {\n var i, hook;\n if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n i(oldVnode, vnode);\n }\n var elm = vnode.elm = oldVnode.elm;\n var oldCh = oldVnode.children;\n var ch = vnode.children;\n if (oldVnode === vnode)\n return;\n if (vnode.data !== undefined) {\n for (i = 0; i < cbs.update.length; ++i)\n cbs.update[i](oldVnode, vnode);\n i = vnode.data.hook;\n if (isDef(i) && isDef(i = i.update))\n i(oldVnode, vnode);\n }\n if (isUndef(vnode.text)) {\n if (isDef(oldCh) && isDef(ch)) {\n if (oldCh !== ch)\n updateChildren(elm, oldCh, ch, insertedVnodeQueue);\n }\n else if (isDef(ch)) {\n if (isDef(oldVnode.text))\n api.setTextContent(elm, '');\n addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n }\n else if (isDef(oldCh)) {\n removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n }\n else if (isDef(oldVnode.text)) {\n api.setTextContent(elm, '');\n }\n }\n else if (oldVnode.text !== vnode.text) {\n api.setTextContent(elm, vnode.text);\n }\n if (isDef(hook) && isDef(i = hook.postpatch)) {\n i(oldVnode, vnode);\n }\n }\n return function patch(oldVnode, vnode) {\n var i, elm, parent;\n var insertedVnodeQueue = [];\n for (i = 0; i < cbs.pre.length; ++i)\n cbs.pre[i]();\n if (!isVnode(oldVnode)) {\n oldVnode = emptyNodeAt(oldVnode);\n }\n if (sameVnode(oldVnode, vnode)) {\n patchVnode(oldVnode, vnode, insertedVnodeQueue);\n }\n else {\n elm = oldVnode.elm;\n parent = api.parentNode(elm);\n createElm(vnode, insertedVnodeQueue);\n if (parent !== null) {\n api.insertBefore(parent, vnode.elm, api.nextSibling(elm));\n removeVnodes(parent, [oldVnode], 0, 0);\n }\n }\n for (i = 0; i < insertedVnodeQueue.length; ++i) {\n insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n }\n for (i = 0; i < cbs.post.length; ++i)\n cbs.post[i]();\n return vnode;\n };\n}\nexports.init = init;\n\n},{\"./h\":1,\"./htmldomapi\":2,\"./is\":3,\"./thunk\":11,\"./vnode\":12}],11:[function(require,module,exports){\n\"use strict\";\nvar h_1 = require(\"./h\");\nfunction copyToThunk(vnode, thunk) {\n thunk.elm = vnode.elm;\n vnode.data.fn = thunk.data.fn;\n vnode.data.args = thunk.data.args;\n thunk.data = vnode.data;\n thunk.children = vnode.children;\n thunk.text = vnode.text;\n thunk.elm = vnode.elm;\n}\nfunction init(thunk) {\n var cur = thunk.data;\n var vnode = cur.fn.apply(undefined, cur.args);\n copyToThunk(vnode, thunk);\n}\nfunction prepatch(oldVnode, thunk) {\n var i, old = oldVnode.data, cur = thunk.data;\n var oldArgs = old.args, args = cur.args;\n if (old.fn !== cur.fn || oldArgs.length !== args.length) {\n copyToThunk(cur.fn.apply(undefined, args), thunk);\n }\n for (i = 0; i < args.length; ++i) {\n if (oldArgs[i] !== args[i]) {\n copyToThunk(cur.fn.apply(undefined, args), thunk);\n return;\n }\n }\n copyToThunk(oldVnode, thunk);\n}\nexports.thunk = function thunk(sel, key, fn, args) {\n if (args === undefined) {\n args = fn;\n fn = key;\n key = undefined;\n }\n return h_1.h(sel, {\n key: key,\n hook: { init: init, prepatch: prepatch },\n fn: fn,\n args: args\n });\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.thunk;\n\n},{\"./h\":1}],12:[function(require,module,exports){\n\"use strict\";\nfunction vnode(sel, data, children, text, elm) {\n var key = data === undefined ? undefined : data.key;\n return { sel: sel, data: data, children: children,\n text: text, elm: elm, key: key };\n}\nexports.vnode = vnode;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = vnode;\n\n},{}]},{},[9])(9)\n});\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","h.js","htmldomapi.js","is.js","modules/attributes.js","modules/class.js","modules/eventlisteners.js","modules/props.js","modules/style.js","snabbdom.bundle.js","snabbdom.js","thunk.js","vnode.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\"use strict\";\nvar vnode_1 = require(\"./vnode\");\nvar is = require(\"./is\");\nfunction addNS(data, children, sel) {\n    data.ns = 'http://www.w3.org/2000/svg';\n    if (sel !== 'foreignObject' && children !== undefined) {\n        for (var i = 0; i < children.length; ++i) {\n            var childData = children[i].data;\n            if (childData !== undefined) {\n                addNS(childData, children[i].children, children[i].sel);\n            }\n        }\n    }\n}\nfunction h(sel, b, c) {\n    var data = {}, children, text, i;\n    if (c !== undefined) {\n        data = b;\n        if (is.array(c)) {\n            children = c;\n        }\n        else if (is.primitive(c)) {\n            text = c;\n        }\n        else if (c && c.sel) {\n            children = [c];\n        }\n    }\n    else if (b !== undefined) {\n        if (is.array(b)) {\n            children = b;\n        }\n        else if (is.primitive(b)) {\n            text = b;\n        }\n        else if (b && b.sel) {\n            children = [b];\n        }\n        else {\n            data = b;\n        }\n    }\n    if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n            if (is.primitive(children[i]))\n                children[i] = vnode_1.vnode(undefined, undefined, undefined, children[i]);\n        }\n    }\n    if (sel[0] === 's' && sel[1] === 'v' && sel[2] === 'g' &&\n        (sel.length === 3 || sel[3] === '.' || sel[3] === '#')) {\n        addNS(data, children, sel);\n    }\n    return vnode_1.vnode(sel, data, children, text, undefined);\n}\nexports.h = h;\n;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = h;\n//# sourceMappingURL=h.js.map","\"use strict\";\nfunction createElement(tagName) {\n    return document.createElement(tagName);\n}\nfunction createElementNS(namespaceURI, qualifiedName) {\n    return document.createElementNS(namespaceURI, qualifiedName);\n}\nfunction createTextNode(text) {\n    return document.createTextNode(text);\n}\nfunction createComment(text) {\n    return document.createComment(text);\n}\nfunction insertBefore(parentNode, newNode, referenceNode) {\n    parentNode.insertBefore(newNode, referenceNode);\n}\nfunction removeChild(node, child) {\n    node.removeChild(child);\n}\nfunction appendChild(node, child) {\n    node.appendChild(child);\n}\nfunction parentNode(node) {\n    return node.parentNode;\n}\nfunction nextSibling(node) {\n    return node.nextSibling;\n}\nfunction tagName(elm) {\n    return elm.tagName;\n}\nfunction setTextContent(node, text) {\n    node.textContent = text;\n}\nfunction getTextContent(node) {\n    return node.textContent;\n}\nfunction isElement(node) {\n    return node.nodeType === 1;\n}\nfunction isText(node) {\n    return node.nodeType === 3;\n}\nfunction isComment(node) {\n    return node.nodeType === 8;\n}\nexports.htmlDomApi = {\n    createElement: createElement,\n    createElementNS: createElementNS,\n    createTextNode: createTextNode,\n    createComment: createComment,\n    insertBefore: insertBefore,\n    removeChild: removeChild,\n    appendChild: appendChild,\n    parentNode: parentNode,\n    nextSibling: nextSibling,\n    tagName: tagName,\n    setTextContent: setTextContent,\n    getTextContent: getTextContent,\n    isElement: isElement,\n    isText: isText,\n    isComment: isComment,\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.htmlDomApi;\n//# sourceMappingURL=htmldomapi.js.map","\"use strict\";\nexports.array = Array.isArray;\nfunction primitive(s) {\n    return typeof s === 'string' || typeof s === 'number';\n}\nexports.primitive = primitive;\n//# sourceMappingURL=is.js.map","\"use strict\";\nvar NamespaceURIs = {\n    \"xlink\": \"http://www.w3.org/1999/xlink\"\n};\nvar booleanAttrs = [\"allowfullscreen\", \"async\", \"autofocus\", \"autoplay\", \"checked\", \"compact\", \"controls\", \"declare\",\n    \"default\", \"defaultchecked\", \"defaultmuted\", \"defaultselected\", \"defer\", \"disabled\", \"draggable\",\n    \"enabled\", \"formnovalidate\", \"hidden\", \"indeterminate\", \"inert\", \"ismap\", \"itemscope\", \"loop\", \"multiple\",\n    \"muted\", \"nohref\", \"noresize\", \"noshade\", \"novalidate\", \"nowrap\", \"open\", \"pauseonexit\", \"readonly\",\n    \"required\", \"reversed\", \"scoped\", \"seamless\", \"selected\", \"sortable\", \"spellcheck\", \"translate\",\n    \"truespeed\", \"typemustmatch\", \"visible\"];\nvar booleanAttrsDict = Object.create(null);\nfor (var i = 0, len = booleanAttrs.length; i < len; i++) {\n    booleanAttrsDict[booleanAttrs[i]] = true;\n}\nfunction updateAttrs(oldVnode, vnode) {\n    var key, cur, old, elm = vnode.elm, oldAttrs = oldVnode.data.attrs, attrs = vnode.data.attrs, namespaceSplit;\n    if (!oldAttrs && !attrs)\n        return;\n    if (oldAttrs === attrs)\n        return;\n    oldAttrs = oldAttrs || {};\n    attrs = attrs || {};\n    // update modified attributes, add new attributes\n    for (key in attrs) {\n        cur = attrs[key];\n        old = oldAttrs[key];\n        if (old !== cur) {\n            if (!cur && booleanAttrsDict[key])\n                elm.removeAttribute(key);\n            else {\n                namespaceSplit = key.split(\":\");\n                if (namespaceSplit.length > 1 && NamespaceURIs.hasOwnProperty(namespaceSplit[0]))\n                    elm.setAttributeNS(NamespaceURIs[namespaceSplit[0]], key, cur);\n                else\n                    elm.setAttribute(key, cur);\n            }\n        }\n    }\n    //remove removed attributes\n    // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)\n    // the other option is to remove all attributes with value == undefined\n    for (key in oldAttrs) {\n        if (!(key in attrs)) {\n            elm.removeAttribute(key);\n        }\n    }\n}\nexports.attributesModule = { create: updateAttrs, update: updateAttrs };\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.attributesModule;\n//# sourceMappingURL=attributes.js.map","\"use strict\";\nfunction updateClass(oldVnode, vnode) {\n    var cur, name, elm = vnode.elm, oldClass = oldVnode.data.class, klass = vnode.data.class;\n    if (!oldClass && !klass)\n        return;\n    if (oldClass === klass)\n        return;\n    oldClass = oldClass || {};\n    klass = klass || {};\n    for (name in oldClass) {\n        if (!klass[name]) {\n            elm.classList.remove(name);\n        }\n    }\n    for (name in klass) {\n        cur = klass[name];\n        if (cur !== oldClass[name]) {\n            elm.classList[cur ? 'add' : 'remove'](name);\n        }\n    }\n}\nexports.classModule = { create: updateClass, update: updateClass };\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.classModule;\n//# sourceMappingURL=class.js.map","\"use strict\";\nfunction invokeHandler(handler, vnode, event) {\n    if (typeof handler === \"function\") {\n        // call function handler\n        handler.call(vnode, event, vnode);\n    }\n    else if (typeof handler === \"object\") {\n        // call handler with arguments\n        if (typeof handler[0] === \"function\") {\n            // special case for single argument for performance\n            if (handler.length === 2) {\n                handler[0].call(vnode, handler[1], event, vnode);\n            }\n            else {\n                var args = handler.slice(1);\n                args.push(event);\n                args.push(vnode);\n                handler[0].apply(vnode, args);\n            }\n        }\n        else {\n            // call multiple handlers\n            for (var i = 0; i < handler.length; i++) {\n                invokeHandler(handler[i]);\n            }\n        }\n    }\n}\nfunction handleEvent(event, vnode) {\n    var name = event.type, on = vnode.data.on;\n    // call event handler(s) if exists\n    if (on && on[name]) {\n        invokeHandler(on[name], vnode, event);\n    }\n}\nfunction createListener() {\n    return function handler(event) {\n        handleEvent(event, handler.vnode);\n    };\n}\nfunction updateEventListeners(oldVnode, vnode) {\n    var oldOn = oldVnode.data.on, oldListener = oldVnode.listener, oldElm = oldVnode.elm, on = vnode && vnode.data.on, elm = (vnode && vnode.elm), name;\n    // optimization for reused immutable handlers\n    if (oldOn === on) {\n        return;\n    }\n    // remove existing listeners which no longer used\n    if (oldOn && oldListener) {\n        // if element changed or deleted we remove all existing listeners unconditionally\n        if (!on) {\n            for (name in oldOn) {\n                // remove listener if element was changed or existing listeners removed\n                oldElm.removeEventListener(name, oldListener, false);\n            }\n        }\n        else {\n            for (name in oldOn) {\n                // remove listener if existing listener removed\n                if (!on[name]) {\n                    oldElm.removeEventListener(name, oldListener, false);\n                }\n            }\n        }\n    }\n    // add new listeners which has not already attached\n    if (on) {\n        // reuse existing listener or create new\n        var listener = vnode.listener = oldVnode.listener || createListener();\n        // update vnode for listener\n        listener.vnode = vnode;\n        // if element changed or added we add all needed listeners unconditionally\n        if (!oldOn) {\n            for (name in on) {\n                // add listener if element was changed or new listeners added\n                elm.addEventListener(name, listener, false);\n            }\n        }\n        else {\n            for (name in on) {\n                // add listener if new listener added\n                if (!oldOn[name]) {\n                    elm.addEventListener(name, listener, false);\n                }\n            }\n        }\n    }\n}\nexports.eventListenersModule = {\n    create: updateEventListeners,\n    update: updateEventListeners,\n    destroy: updateEventListeners\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.eventListenersModule;\n//# sourceMappingURL=eventlisteners.js.map","\"use strict\";\nfunction updateProps(oldVnode, vnode) {\n    var key, cur, old, elm = vnode.elm, oldProps = oldVnode.data.props, props = vnode.data.props;\n    if (!oldProps && !props)\n        return;\n    if (oldProps === props)\n        return;\n    oldProps = oldProps || {};\n    props = props || {};\n    for (key in oldProps) {\n        if (!props[key]) {\n            delete elm[key];\n        }\n    }\n    for (key in props) {\n        cur = props[key];\n        old = oldProps[key];\n        if (old !== cur && (key !== 'value' || elm[key] !== cur)) {\n            elm[key] = cur;\n        }\n    }\n}\nexports.propsModule = { create: updateProps, update: updateProps };\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.propsModule;\n//# sourceMappingURL=props.js.map","\"use strict\";\nvar raf = (typeof window !== 'undefined' && window.requestAnimationFrame) || setTimeout;\nvar nextFrame = function (fn) { raf(function () { raf(fn); }); };\nfunction setNextFrame(obj, prop, val) {\n    nextFrame(function () { obj[prop] = val; });\n}\nfunction updateStyle(oldVnode, vnode) {\n    var cur, name, elm = vnode.elm, oldStyle = oldVnode.data.style, style = vnode.data.style;\n    if (!oldStyle && !style)\n        return;\n    if (oldStyle === style)\n        return;\n    oldStyle = oldStyle || {};\n    style = style || {};\n    var oldHasDel = 'delayed' in oldStyle;\n    for (name in oldStyle) {\n        if (!style[name]) {\n            if (name[0] === '-' && name[1] === '-') {\n                elm.style.removeProperty(name);\n            }\n            else {\n                elm.style[name] = '';\n            }\n        }\n    }\n    for (name in style) {\n        cur = style[name];\n        if (name === 'delayed') {\n            for (name in style.delayed) {\n                cur = style.delayed[name];\n                if (!oldHasDel || cur !== oldStyle.delayed[name]) {\n                    setNextFrame(elm.style, name, cur);\n                }\n            }\n        }\n        else if (name !== 'remove' && cur !== oldStyle[name]) {\n            if (name[0] === '-' && name[1] === '-') {\n                elm.style.setProperty(name, cur);\n            }\n            else {\n                elm.style[name] = cur;\n            }\n        }\n    }\n}\nfunction applyDestroyStyle(vnode) {\n    var style, name, elm = vnode.elm, s = vnode.data.style;\n    if (!s || !(style = s.destroy))\n        return;\n    for (name in style) {\n        elm.style[name] = style[name];\n    }\n}\nfunction applyRemoveStyle(vnode, rm) {\n    var s = vnode.data.style;\n    if (!s || !s.remove) {\n        rm();\n        return;\n    }\n    var name, elm = vnode.elm, i = 0, compStyle, style = s.remove, amount = 0, applied = [];\n    for (name in style) {\n        applied.push(name);\n        elm.style[name] = style[name];\n    }\n    compStyle = getComputedStyle(elm);\n    var props = compStyle['transition-property'].split(', ');\n    for (; i < props.length; ++i) {\n        if (applied.indexOf(props[i]) !== -1)\n            amount++;\n    }\n    elm.addEventListener('transitionend', function (ev) {\n        if (ev.target === elm)\n            --amount;\n        if (amount === 0)\n            rm();\n    });\n}\nexports.styleModule = {\n    create: updateStyle,\n    update: updateStyle,\n    destroy: applyDestroyStyle,\n    remove: applyRemoveStyle\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.styleModule;\n//# sourceMappingURL=style.js.map","\"use strict\";\nvar snabbdom_1 = require(\"./snabbdom\");\nvar attributes_1 = require(\"./modules/attributes\"); // for setting attributes on DOM elements\nvar class_1 = require(\"./modules/class\"); // makes it easy to toggle classes\nvar props_1 = require(\"./modules/props\"); // for setting properties on DOM elements\nvar style_1 = require(\"./modules/style\"); // handles styling on elements with support for animations\nvar eventlisteners_1 = require(\"./modules/eventlisteners\"); // attaches event listeners\nvar h_1 = require(\"./h\"); // helper function for creating vnodes\nvar patch = snabbdom_1.init([\n    attributes_1.attributesModule,\n    class_1.classModule,\n    props_1.propsModule,\n    style_1.styleModule,\n    eventlisteners_1.eventListenersModule\n]);\nexports.snabbdomBundle = { patch: patch, h: h_1.h };\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.snabbdomBundle;\n//# sourceMappingURL=snabbdom.bundle.js.map","\"use strict\";\nvar vnode_1 = require(\"./vnode\");\nvar is = require(\"./is\");\nvar htmldomapi_1 = require(\"./htmldomapi\");\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\nvar emptyNode = vnode_1.default('', {}, [], undefined, undefined);\nfunction sameVnode(vnode1, vnode2) {\n    return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\nfunction isVnode(vnode) {\n    return vnode.sel !== undefined;\n}\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n    var i, map = {}, key, ch;\n    for (i = beginIdx; i <= endIdx; ++i) {\n        ch = children[i];\n        if (ch != null) {\n            key = ch.key;\n            if (key !== undefined)\n                map[key] = i;\n        }\n    }\n    return map;\n}\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\nvar h_1 = require(\"./h\");\nexports.h = h_1.h;\nvar thunk_1 = require(\"./thunk\");\nexports.thunk = thunk_1.thunk;\nfunction init(modules, domApi) {\n    var i, j, cbs = {};\n    var api = domApi !== undefined ? domApi : htmldomapi_1.default;\n    for (i = 0; i < hooks.length; ++i) {\n        cbs[hooks[i]] = [];\n        for (j = 0; j < modules.length; ++j) {\n            var hook = modules[j][hooks[i]];\n            if (hook !== undefined) {\n                cbs[hooks[i]].push(hook);\n            }\n        }\n    }\n    function emptyNodeAt(elm) {\n        var id = elm.id ? '#' + elm.id : '';\n        var c = elm.className ? '.' + elm.className.split(' ').join('.') : '';\n        return vnode_1.default(api.tagName(elm).toLowerCase() + id + c, {}, [], undefined, elm);\n    }\n    function createRmCb(childElm, listeners) {\n        return function rmCb() {\n            if (--listeners === 0) {\n                var parent_1 = api.parentNode(childElm);\n                api.removeChild(parent_1, childElm);\n            }\n        };\n    }\n    function createElm(vnode, insertedVnodeQueue) {\n        var i, data = vnode.data;\n        if (data !== undefined) {\n            if (isDef(i = data.hook) && isDef(i = i.init)) {\n                i(vnode);\n                data = vnode.data;\n            }\n        }\n        var children = vnode.children, sel = vnode.sel;\n        if (sel === '!') {\n            if (isUndef(vnode.text)) {\n                vnode.text = '';\n            }\n            vnode.elm = api.createComment(vnode.text);\n        }\n        else if (sel !== undefined) {\n            // Parse selector\n            var hashIdx = sel.indexOf('#');\n            var dotIdx = sel.indexOf('.', hashIdx);\n            var hash = hashIdx > 0 ? hashIdx : sel.length;\n            var dot = dotIdx > 0 ? dotIdx : sel.length;\n            var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n            var elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? api.createElementNS(i, tag)\n                : api.createElement(tag);\n            if (hash < dot)\n                elm.id = sel.slice(hash + 1, dot);\n            if (dotIdx > 0)\n                elm.className = sel.slice(dot + 1).replace(/\\./g, ' ');\n            for (i = 0; i < cbs.create.length; ++i)\n                cbs.create[i](emptyNode, vnode);\n            if (is.array(children)) {\n                for (i = 0; i < children.length; ++i) {\n                    var ch = children[i];\n                    if (ch != null) {\n                        api.appendChild(elm, createElm(ch, insertedVnodeQueue));\n                    }\n                }\n            }\n            else if (is.primitive(vnode.text)) {\n                api.appendChild(elm, api.createTextNode(vnode.text));\n            }\n            i = vnode.data.hook; // Reuse variable\n            if (isDef(i)) {\n                if (i.create)\n                    i.create(emptyNode, vnode);\n                if (i.insert)\n                    insertedVnodeQueue.push(vnode);\n            }\n        }\n        else {\n            vnode.elm = api.createTextNode(vnode.text);\n        }\n        return vnode.elm;\n    }\n    function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n        for (; startIdx <= endIdx; ++startIdx) {\n            var ch = vnodes[startIdx];\n            if (ch != null) {\n                api.insertBefore(parentElm, createElm(ch, insertedVnodeQueue), before);\n            }\n        }\n    }\n    function invokeDestroyHook(vnode) {\n        var i, j, data = vnode.data;\n        if (data !== undefined) {\n            if (isDef(i = data.hook) && isDef(i = i.destroy))\n                i(vnode);\n            for (i = 0; i < cbs.destroy.length; ++i)\n                cbs.destroy[i](vnode);\n            if (vnode.children !== undefined) {\n                for (j = 0; j < vnode.children.length; ++j) {\n                    i = vnode.children[j];\n                    if (i != null && typeof i !== \"string\") {\n                        invokeDestroyHook(i);\n                    }\n                }\n            }\n        }\n    }\n    function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n        for (; startIdx <= endIdx; ++startIdx) {\n            var i_1 = void 0, listeners = void 0, rm = void 0, ch = vnodes[startIdx];\n            if (ch != null) {\n                if (isDef(ch.sel)) {\n                    invokeDestroyHook(ch);\n                    listeners = cbs.remove.length + 1;\n                    rm = createRmCb(ch.elm, listeners);\n                    for (i_1 = 0; i_1 < cbs.remove.length; ++i_1)\n                        cbs.remove[i_1](ch, rm);\n                    if (isDef(i_1 = ch.data) && isDef(i_1 = i_1.hook) && isDef(i_1 = i_1.remove)) {\n                        i_1(ch, rm);\n                    }\n                    else {\n                        rm();\n                    }\n                }\n                else {\n                    api.removeChild(parentElm, ch.elm);\n                }\n            }\n        }\n    }\n    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue) {\n        var oldStartIdx = 0, newStartIdx = 0;\n        var oldEndIdx = oldCh.length - 1;\n        var oldStartVnode = oldCh[0];\n        var oldEndVnode = oldCh[oldEndIdx];\n        var newEndIdx = newCh.length - 1;\n        var newStartVnode = newCh[0];\n        var newEndVnode = newCh[newEndIdx];\n        var oldKeyToIdx;\n        var idxInOld;\n        var elmToMove;\n        var before;\n        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n            if (oldStartVnode == null) {\n                oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left\n            }\n            else if (oldEndVnode == null) {\n                oldEndVnode = oldCh[--oldEndIdx];\n            }\n            else if (newStartVnode == null) {\n                newStartVnode = newCh[++newStartIdx];\n            }\n            else if (newEndVnode == null) {\n                newEndVnode = newCh[--newEndIdx];\n            }\n            else if (sameVnode(oldStartVnode, newStartVnode)) {\n                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n                oldStartVnode = oldCh[++oldStartIdx];\n                newStartVnode = newCh[++newStartIdx];\n            }\n            else if (sameVnode(oldEndVnode, newEndVnode)) {\n                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n                oldEndVnode = oldCh[--oldEndIdx];\n                newEndVnode = newCh[--newEndIdx];\n            }\n            else if (sameVnode(oldStartVnode, newEndVnode)) {\n                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n                api.insertBefore(parentElm, oldStartVnode.elm, api.nextSibling(oldEndVnode.elm));\n                oldStartVnode = oldCh[++oldStartIdx];\n                newEndVnode = newCh[--newEndIdx];\n            }\n            else if (sameVnode(oldEndVnode, newStartVnode)) {\n                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n                api.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n                oldEndVnode = oldCh[--oldEndIdx];\n                newStartVnode = newCh[++newStartIdx];\n            }\n            else {\n                if (oldKeyToIdx === undefined) {\n                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n                }\n                idxInOld = oldKeyToIdx[newStartVnode.key];\n                if (isUndef(idxInOld)) {\n                    api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);\n                    newStartVnode = newCh[++newStartIdx];\n                }\n                else {\n                    elmToMove = oldCh[idxInOld];\n                    if (elmToMove.sel !== newStartVnode.sel) {\n                        api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);\n                    }\n                    else {\n                        patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n                        oldCh[idxInOld] = undefined;\n                        api.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);\n                    }\n                    newStartVnode = newCh[++newStartIdx];\n                }\n            }\n        }\n        if (oldStartIdx > oldEndIdx) {\n            before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm;\n            addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n        }\n        else if (newStartIdx > newEndIdx) {\n            removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n        }\n    }\n    function patchVnode(oldVnode, vnode, insertedVnodeQueue) {\n        var i, hook;\n        if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n            i(oldVnode, vnode);\n        }\n        var elm = vnode.elm = oldVnode.elm;\n        var oldCh = oldVnode.children;\n        var ch = vnode.children;\n        if (oldVnode === vnode)\n            return;\n        if (vnode.data !== undefined) {\n            for (i = 0; i < cbs.update.length; ++i)\n                cbs.update[i](oldVnode, vnode);\n            i = vnode.data.hook;\n            if (isDef(i) && isDef(i = i.update))\n                i(oldVnode, vnode);\n        }\n        if (isUndef(vnode.text)) {\n            if (isDef(oldCh) && isDef(ch)) {\n                if (oldCh !== ch)\n                    updateChildren(elm, oldCh, ch, insertedVnodeQueue);\n            }\n            else if (isDef(ch)) {\n                if (isDef(oldVnode.text))\n                    api.setTextContent(elm, '');\n                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n            }\n            else if (isDef(oldCh)) {\n                removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n            }\n            else if (isDef(oldVnode.text)) {\n                api.setTextContent(elm, '');\n            }\n        }\n        else if (oldVnode.text !== vnode.text) {\n            api.setTextContent(elm, vnode.text);\n        }\n        if (isDef(hook) && isDef(i = hook.postpatch)) {\n            i(oldVnode, vnode);\n        }\n    }\n    return function patch(oldVnode, vnode) {\n        var i, elm, parent;\n        var insertedVnodeQueue = [];\n        for (i = 0; i < cbs.pre.length; ++i)\n            cbs.pre[i]();\n        if (!isVnode(oldVnode)) {\n            oldVnode = emptyNodeAt(oldVnode);\n        }\n        if (sameVnode(oldVnode, vnode)) {\n            patchVnode(oldVnode, vnode, insertedVnodeQueue);\n        }\n        else {\n            elm = oldVnode.elm;\n            parent = api.parentNode(elm);\n            createElm(vnode, insertedVnodeQueue);\n            if (parent !== null) {\n                api.insertBefore(parent, vnode.elm, api.nextSibling(elm));\n                removeVnodes(parent, [oldVnode], 0, 0);\n            }\n        }\n        for (i = 0; i < insertedVnodeQueue.length; ++i) {\n            insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n        }\n        for (i = 0; i < cbs.post.length; ++i)\n            cbs.post[i]();\n        return vnode;\n    };\n}\nexports.init = init;\n//# sourceMappingURL=snabbdom.js.map","\"use strict\";\nvar h_1 = require(\"./h\");\nfunction copyToThunk(vnode, thunk) {\n    thunk.elm = vnode.elm;\n    vnode.data.fn = thunk.data.fn;\n    vnode.data.args = thunk.data.args;\n    thunk.data = vnode.data;\n    thunk.children = vnode.children;\n    thunk.text = vnode.text;\n    thunk.elm = vnode.elm;\n}\nfunction init(thunk) {\n    var cur = thunk.data;\n    var vnode = cur.fn.apply(undefined, cur.args);\n    copyToThunk(vnode, thunk);\n}\nfunction prepatch(oldVnode, thunk) {\n    var i, old = oldVnode.data, cur = thunk.data;\n    var oldArgs = old.args, args = cur.args;\n    if (old.fn !== cur.fn || oldArgs.length !== args.length) {\n        copyToThunk(cur.fn.apply(undefined, args), thunk);\n    }\n    for (i = 0; i < args.length; ++i) {\n        if (oldArgs[i] !== args[i]) {\n            copyToThunk(cur.fn.apply(undefined, args), thunk);\n            return;\n        }\n    }\n    copyToThunk(oldVnode, thunk);\n}\nexports.thunk = function thunk(sel, key, fn, args) {\n    if (args === undefined) {\n        args = fn;\n        fn = key;\n        key = undefined;\n    }\n    return h_1.h(sel, {\n        key: key,\n        hook: { init: init, prepatch: prepatch },\n        fn: fn,\n        args: args\n    });\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.thunk;\n//# sourceMappingURL=thunk.js.map","\"use strict\";\nfunction vnode(sel, data, children, text, elm) {\n    var key = data === undefined ? undefined : data.key;\n    return { sel: sel, data: data, children: children,\n        text: text, elm: elm, key: key };\n}\nexports.vnode = vnode;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = vnode;\n//# sourceMappingURL=vnode.js.map"]}\n"]} \ No newline at end of file diff --git a/src/libs/snabbdom/dist/snabbdom-props.js b/src/libs/snabbdom/dist/snabbdom-props.js new file mode 100755 index 00000000..2da19808 --- /dev/null +++ b/src/libs/snabbdom/dist/snabbdom-props.js @@ -0,0 +1,30 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.snabbdom_props = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 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) { + before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm; + addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue); + } + else if (newStartIdx > newEndIdx) { + 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; + }; +} +exports.init = init; + +},{"./h":1,"./htmldomapi":2,"./is":3,"./thunk":5,"./vnode":6}],5:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var h_1 = require("./h"); +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); +} +exports.thunk = function thunk(sel, key, fn, args) { + if (args === undefined) { + args = fn; + fn = key; + key = undefined; + } + return h_1.h(sel, { + key: key, + hook: { init: init, prepatch: prepatch }, + fn: fn, + args: args + }); +}; +exports.default = exports.thunk; + +},{"./h":1}],6:[function(require,module,exports){ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +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 }; +} +exports.vnode = vnode; +exports.default = vnode; + +},{}]},{},[4])(4) +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/.registry.npmjs.org/browser-pack/6.0.2/node_modules/browser-pack/_prelude.js","h.js","htmldomapi.js","is.js","snabbdom.js","thunk.js","vnode.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar vnode_1 = require(\"./vnode\");\nvar is = require(\"./is\");\nfunction addNS(data, children, sel) {\n    data.ns = 'http://www.w3.org/2000/svg';\n    if (sel !== 'foreignObject' && children !== undefined) {\n        for (var i = 0; i < children.length; ++i) {\n            var childData = children[i].data;\n            if (childData !== undefined) {\n                addNS(childData, children[i].children, children[i].sel);\n            }\n        }\n    }\n}\nfunction h(sel, b, c) {\n    var data = {}, children, text, i;\n    if (c !== undefined) {\n        data = b;\n        if (is.array(c)) {\n            children = c;\n        }\n        else if (is.primitive(c)) {\n            text = c;\n        }\n        else if (c && c.sel) {\n            children = [c];\n        }\n    }\n    else if (b !== undefined) {\n        if (is.array(b)) {\n            children = b;\n        }\n        else if (is.primitive(b)) {\n            text = b;\n        }\n        else if (b && b.sel) {\n            children = [b];\n        }\n        else {\n            data = b;\n        }\n    }\n    if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n            if (is.primitive(children[i]))\n                children[i] = vnode_1.vnode(undefined, undefined, undefined, children[i]);\n        }\n    }\n    if (sel[0] === 's' && sel[1] === 'v' && sel[2] === 'g' &&\n        (sel.length === 3 || sel[3] === '.' || sel[3] === '#')) {\n        addNS(data, children, sel);\n    }\n    return vnode_1.vnode(sel, data, children, text, undefined);\n}\nexports.h = h;\n;\nexports.default = h;\n//# sourceMappingURL=h.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction createElement(tagName) {\n    return document.createElement(tagName);\n}\nfunction createElementNS(namespaceURI, qualifiedName) {\n    return document.createElementNS(namespaceURI, qualifiedName);\n}\nfunction createTextNode(text) {\n    return document.createTextNode(text);\n}\nfunction createComment(text) {\n    return document.createComment(text);\n}\nfunction insertBefore(parentNode, newNode, referenceNode) {\n    parentNode.insertBefore(newNode, referenceNode);\n}\nfunction removeChild(node, child) {\n    node.removeChild(child);\n}\nfunction appendChild(node, child) {\n    node.appendChild(child);\n}\nfunction parentNode(node) {\n    return node.parentNode;\n}\nfunction nextSibling(node) {\n    return node.nextSibling;\n}\nfunction tagName(elm) {\n    return elm.tagName;\n}\nfunction setTextContent(node, text) {\n    node.textContent = text;\n}\nfunction getTextContent(node) {\n    return node.textContent;\n}\nfunction isElement(node) {\n    return node.nodeType === 1;\n}\nfunction isText(node) {\n    return node.nodeType === 3;\n}\nfunction isComment(node) {\n    return node.nodeType === 8;\n}\nexports.htmlDomApi = {\n    createElement: createElement,\n    createElementNS: createElementNS,\n    createTextNode: createTextNode,\n    createComment: createComment,\n    insertBefore: insertBefore,\n    removeChild: removeChild,\n    appendChild: appendChild,\n    parentNode: parentNode,\n    nextSibling: nextSibling,\n    tagName: tagName,\n    setTextContent: setTextContent,\n    getTextContent: getTextContent,\n    isElement: isElement,\n    isText: isText,\n    isComment: isComment,\n};\nexports.default = exports.htmlDomApi;\n//# sourceMappingURL=htmldomapi.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.array = Array.isArray;\nfunction primitive(s) {\n    return typeof s === 'string' || typeof s === 'number';\n}\nexports.primitive = primitive;\n//# sourceMappingURL=is.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar vnode_1 = require(\"./vnode\");\nvar is = require(\"./is\");\nvar htmldomapi_1 = require(\"./htmldomapi\");\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\nvar emptyNode = vnode_1.default('', {}, [], undefined, undefined);\nfunction sameVnode(vnode1, vnode2) {\n    return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\nfunction isVnode(vnode) {\n    return vnode.sel !== undefined;\n}\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n    var i, map = {}, key, ch;\n    for (i = beginIdx; i <= endIdx; ++i) {\n        ch = children[i];\n        if (ch != null) {\n            key = ch.key;\n            if (key !== undefined)\n                map[key] = i;\n        }\n    }\n    return map;\n}\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\nvar h_1 = require(\"./h\");\nexports.h = h_1.h;\nvar thunk_1 = require(\"./thunk\");\nexports.thunk = thunk_1.thunk;\nfunction init(modules, domApi) {\n    var i, j, cbs = {};\n    var api = domApi !== undefined ? domApi : htmldomapi_1.default;\n    for (i = 0; i < hooks.length; ++i) {\n        cbs[hooks[i]] = [];\n        for (j = 0; j < modules.length; ++j) {\n            var hook = modules[j][hooks[i]];\n            if (hook !== undefined) {\n                cbs[hooks[i]].push(hook);\n            }\n        }\n    }\n    function emptyNodeAt(elm) {\n        var id = elm.id ? '#' + elm.id : '';\n        var c = elm.className ? '.' + elm.className.split(' ').join('.') : '';\n        return vnode_1.default(api.tagName(elm).toLowerCase() + id + c, {}, [], undefined, elm);\n    }\n    function createRmCb(childElm, listeners) {\n        return function rmCb() {\n            if (--listeners === 0) {\n                var parent_1 = api.parentNode(childElm);\n                api.removeChild(parent_1, childElm);\n            }\n        };\n    }\n    function createElm(vnode, insertedVnodeQueue) {\n        var i, data = vnode.data;\n        if (data !== undefined) {\n            if (isDef(i = data.hook) && isDef(i = i.init)) {\n                i(vnode);\n                data = vnode.data;\n            }\n        }\n        var children = vnode.children, sel = vnode.sel;\n        if (sel === '!') {\n            if (isUndef(vnode.text)) {\n                vnode.text = '';\n            }\n            vnode.elm = api.createComment(vnode.text);\n        }\n        else if (sel !== undefined) {\n            // Parse selector\n            var hashIdx = sel.indexOf('#');\n            var dotIdx = sel.indexOf('.', hashIdx);\n            var hash = hashIdx > 0 ? hashIdx : sel.length;\n            var dot = dotIdx > 0 ? dotIdx : sel.length;\n            var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n            var elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? api.createElementNS(i, tag)\n                : api.createElement(tag);\n            if (hash < dot)\n                elm.setAttribute('id', sel.slice(hash + 1, dot));\n            if (dotIdx > 0)\n                elm.setAttribute('class', sel.slice(dot + 1).replace(/\\./g, ' '));\n            for (i = 0; i < cbs.create.length; ++i)\n                cbs.create[i](emptyNode, vnode);\n            if (is.array(children)) {\n                for (i = 0; i < children.length; ++i) {\n                    var ch = children[i];\n                    if (ch != null) {\n                        api.appendChild(elm, createElm(ch, insertedVnodeQueue));\n                    }\n                }\n            }\n            else if (is.primitive(vnode.text)) {\n                api.appendChild(elm, api.createTextNode(vnode.text));\n            }\n            i = vnode.data.hook; // Reuse variable\n            if (isDef(i)) {\n                if (i.create)\n                    i.create(emptyNode, vnode);\n                if (i.insert)\n                    insertedVnodeQueue.push(vnode);\n            }\n        }\n        else {\n            vnode.elm = api.createTextNode(vnode.text);\n        }\n        return vnode.elm;\n    }\n    function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n        for (; startIdx <= endIdx; ++startIdx) {\n            var ch = vnodes[startIdx];\n            if (ch != null) {\n                api.insertBefore(parentElm, createElm(ch, insertedVnodeQueue), before);\n            }\n        }\n    }\n    function invokeDestroyHook(vnode) {\n        var i, j, data = vnode.data;\n        if (data !== undefined) {\n            if (isDef(i = data.hook) && isDef(i = i.destroy))\n                i(vnode);\n            for (i = 0; i < cbs.destroy.length; ++i)\n                cbs.destroy[i](vnode);\n            if (vnode.children !== undefined) {\n                for (j = 0; j < vnode.children.length; ++j) {\n                    i = vnode.children[j];\n                    if (i != null && typeof i !== \"string\") {\n                        invokeDestroyHook(i);\n                    }\n                }\n            }\n        }\n    }\n    function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n        for (; startIdx <= endIdx; ++startIdx) {\n            var i_1 = void 0, listeners = void 0, rm = void 0, ch = vnodes[startIdx];\n            if (ch != null) {\n                if (isDef(ch.sel)) {\n                    invokeDestroyHook(ch);\n                    listeners = cbs.remove.length + 1;\n                    rm = createRmCb(ch.elm, listeners);\n                    for (i_1 = 0; i_1 < cbs.remove.length; ++i_1)\n                        cbs.remove[i_1](ch, rm);\n                    if (isDef(i_1 = ch.data) && isDef(i_1 = i_1.hook) && isDef(i_1 = i_1.remove)) {\n                        i_1(ch, rm);\n                    }\n                    else {\n                        rm();\n                    }\n                }\n                else {\n                    api.removeChild(parentElm, ch.elm);\n                }\n            }\n        }\n    }\n    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue) {\n        var oldStartIdx = 0, newStartIdx = 0;\n        var oldEndIdx = oldCh.length - 1;\n        var oldStartVnode = oldCh[0];\n        var oldEndVnode = oldCh[oldEndIdx];\n        var newEndIdx = newCh.length - 1;\n        var newStartVnode = newCh[0];\n        var newEndVnode = newCh[newEndIdx];\n        var oldKeyToIdx;\n        var idxInOld;\n        var elmToMove;\n        var before;\n        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n            if (oldStartVnode == null) {\n                oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left\n            }\n            else if (oldEndVnode == null) {\n                oldEndVnode = oldCh[--oldEndIdx];\n            }\n            else if (newStartVnode == null) {\n                newStartVnode = newCh[++newStartIdx];\n            }\n            else if (newEndVnode == null) {\n                newEndVnode = newCh[--newEndIdx];\n            }\n            else if (sameVnode(oldStartVnode, newStartVnode)) {\n                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n                oldStartVnode = oldCh[++oldStartIdx];\n                newStartVnode = newCh[++newStartIdx];\n            }\n            else if (sameVnode(oldEndVnode, newEndVnode)) {\n                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n                oldEndVnode = oldCh[--oldEndIdx];\n                newEndVnode = newCh[--newEndIdx];\n            }\n            else if (sameVnode(oldStartVnode, newEndVnode)) {\n                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n                api.insertBefore(parentElm, oldStartVnode.elm, api.nextSibling(oldEndVnode.elm));\n                oldStartVnode = oldCh[++oldStartIdx];\n                newEndVnode = newCh[--newEndIdx];\n            }\n            else if (sameVnode(oldEndVnode, newStartVnode)) {\n                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n                api.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n                oldEndVnode = oldCh[--oldEndIdx];\n                newStartVnode = newCh[++newStartIdx];\n            }\n            else {\n                if (oldKeyToIdx === undefined) {\n                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n                }\n                idxInOld = oldKeyToIdx[newStartVnode.key];\n                if (isUndef(idxInOld)) {\n                    api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);\n                    newStartVnode = newCh[++newStartIdx];\n                }\n                else {\n                    elmToMove = oldCh[idxInOld];\n                    if (elmToMove.sel !== newStartVnode.sel) {\n                        api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);\n                    }\n                    else {\n                        patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n                        oldCh[idxInOld] = undefined;\n                        api.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);\n                    }\n                    newStartVnode = newCh[++newStartIdx];\n                }\n            }\n        }\n        if (oldStartIdx > oldEndIdx) {\n            before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm;\n            addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n        }\n        else if (newStartIdx > newEndIdx) {\n            removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n        }\n    }\n    function patchVnode(oldVnode, vnode, insertedVnodeQueue) {\n        var i, hook;\n        if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n            i(oldVnode, vnode);\n        }\n        var elm = vnode.elm = oldVnode.elm;\n        var oldCh = oldVnode.children;\n        var ch = vnode.children;\n        if (oldVnode === vnode)\n            return;\n        if (vnode.data !== undefined) {\n            for (i = 0; i < cbs.update.length; ++i)\n                cbs.update[i](oldVnode, vnode);\n            i = vnode.data.hook;\n            if (isDef(i) && isDef(i = i.update))\n                i(oldVnode, vnode);\n        }\n        if (isUndef(vnode.text)) {\n            if (isDef(oldCh) && isDef(ch)) {\n                if (oldCh !== ch)\n                    updateChildren(elm, oldCh, ch, insertedVnodeQueue);\n            }\n            else if (isDef(ch)) {\n                if (isDef(oldVnode.text))\n                    api.setTextContent(elm, '');\n                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n            }\n            else if (isDef(oldCh)) {\n                removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n            }\n            else if (isDef(oldVnode.text)) {\n                api.setTextContent(elm, '');\n            }\n        }\n        else if (oldVnode.text !== vnode.text) {\n            api.setTextContent(elm, vnode.text);\n        }\n        if (isDef(hook) && isDef(i = hook.postpatch)) {\n            i(oldVnode, vnode);\n        }\n    }\n    return function patch(oldVnode, vnode) {\n        var i, elm, parent;\n        var insertedVnodeQueue = [];\n        for (i = 0; i < cbs.pre.length; ++i)\n            cbs.pre[i]();\n        if (!isVnode(oldVnode)) {\n            oldVnode = emptyNodeAt(oldVnode);\n        }\n        if (sameVnode(oldVnode, vnode)) {\n            patchVnode(oldVnode, vnode, insertedVnodeQueue);\n        }\n        else {\n            elm = oldVnode.elm;\n            parent = api.parentNode(elm);\n            createElm(vnode, insertedVnodeQueue);\n            if (parent !== null) {\n                api.insertBefore(parent, vnode.elm, api.nextSibling(elm));\n                removeVnodes(parent, [oldVnode], 0, 0);\n            }\n        }\n        for (i = 0; i < insertedVnodeQueue.length; ++i) {\n            insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n        }\n        for (i = 0; i < cbs.post.length; ++i)\n            cbs.post[i]();\n        return vnode;\n    };\n}\nexports.init = init;\n//# sourceMappingURL=snabbdom.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar h_1 = require(\"./h\");\nfunction copyToThunk(vnode, thunk) {\n    thunk.elm = vnode.elm;\n    vnode.data.fn = thunk.data.fn;\n    vnode.data.args = thunk.data.args;\n    thunk.data = vnode.data;\n    thunk.children = vnode.children;\n    thunk.text = vnode.text;\n    thunk.elm = vnode.elm;\n}\nfunction init(thunk) {\n    var cur = thunk.data;\n    var vnode = cur.fn.apply(undefined, cur.args);\n    copyToThunk(vnode, thunk);\n}\nfunction prepatch(oldVnode, thunk) {\n    var i, old = oldVnode.data, cur = thunk.data;\n    var oldArgs = old.args, args = cur.args;\n    if (old.fn !== cur.fn || oldArgs.length !== args.length) {\n        copyToThunk(cur.fn.apply(undefined, args), thunk);\n        return;\n    }\n    for (i = 0; i < args.length; ++i) {\n        if (oldArgs[i] !== args[i]) {\n            copyToThunk(cur.fn.apply(undefined, args), thunk);\n            return;\n        }\n    }\n    copyToThunk(oldVnode, thunk);\n}\nexports.thunk = function thunk(sel, key, fn, args) {\n    if (args === undefined) {\n        args = fn;\n        fn = key;\n        key = undefined;\n    }\n    return h_1.h(sel, {\n        key: key,\n        hook: { init: init, prepatch: prepatch },\n        fn: fn,\n        args: args\n    });\n};\nexports.default = exports.thunk;\n//# sourceMappingURL=thunk.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction vnode(sel, data, children, text, elm) {\n    var key = data === undefined ? undefined : data.key;\n    return { sel: sel, data: data, children: children,\n        text: text, elm: elm, key: key };\n}\nexports.vnode = vnode;\nexports.default = vnode;\n//# sourceMappingURL=vnode.js.map"]} diff --git a/src/libs/snabbdom/dist/snabbdom.min.js b/src/libs/snabbdom/dist/snabbdom.min.js new file mode 100755 index 00000000..95ab9cb1 --- /dev/null +++ b/src/libs/snabbdom/dist/snabbdom.min.js @@ -0,0 +1,2 @@ +!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var t;t="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,t.snabbdom=e()}}(function(){return function e(t,n,r){function o(l,a){if(!n[l]){if(!t[l]){var d="function"==typeof require&&require;if(!a&&d)return d(l,!0);if(i)return i(l,!0);var u=new Error("Cannot find module '"+l+"'");throw u.code="MODULE_NOT_FOUND",u}var f=n[l]={exports:{}};t[l][0].call(f.exports,function(e){var n=t[l][1][e];return o(n?n:e)},f,f.exports,e,t,n,r)}return n[l].exports}for(var i="function"==typeof require&&require,l=0;l0?d:a.length,v=u>0?u:a.length,m=d!==-1||u!==-1?a.slice(0,Math.min(c,v)):a,p=e.elm=o(i)&&o(n=i.ns)?b.createElementNS(n,m):b.createElement(m);for(c0&&(p.className=a.slice(v+1).replace(/\./g," ")),n=0;nv?(f=null==n[k+1]?null:n[k+1].elm,m(e,f,n,s,k,o)):s>k&&g(e,t,c,v)}function y(e,t,n){var i,l;o(i=t.data)&&o(l=i.hook)&&o(i=l.prepatch)&&i(e,t);var a=t.elm=e.elm,d=e.children,u=t.children;if(e!==t){if(void 0!==t.data){for(i=0;i 0 ? hashIdx : sel.length;\n var dot = dotIdx > 0 ? dotIdx : sel.length;\n var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n var elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? api.createElementNS(i, tag)\n : api.createElement(tag);\n if (hash < dot)\n elm.id = sel.slice(hash + 1, dot);\n if (dotIdx > 0)\n elm.className = sel.slice(dot + 1).replace(/\\./g, ' ');\n for (i = 0; i < cbs.create.length; ++i)\n cbs.create[i](emptyNode, vnode);\n if (is.array(children)) {\n for (i = 0; i < children.length; ++i) {\n var ch = children[i];\n if (ch != null) {\n api.appendChild(elm, createElm(ch, insertedVnodeQueue));\n }\n }\n }\n else if (is.primitive(vnode.text)) {\n api.appendChild(elm, api.createTextNode(vnode.text));\n }\n i = vnode.data.hook; // Reuse variable\n if (isDef(i)) {\n if (i.create)\n i.create(emptyNode, vnode);\n if (i.insert)\n insertedVnodeQueue.push(vnode);\n }\n }\n else {\n vnode.elm = api.createTextNode(vnode.text);\n }\n return vnode.elm;\n }\n function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n for (; startIdx <= endIdx; ++startIdx) {\n var ch = vnodes[startIdx];\n if (ch != null) {\n api.insertBefore(parentElm, createElm(ch, insertedVnodeQueue), before);\n }\n }\n }\n function invokeDestroyHook(vnode) {\n var i, j, data = vnode.data;\n if (data !== undefined) {\n if (isDef(i = data.hook) && isDef(i = i.destroy))\n i(vnode);\n for (i = 0; i < cbs.destroy.length; ++i)\n cbs.destroy[i](vnode);\n if (vnode.children !== undefined) {\n for (j = 0; j < vnode.children.length; ++j) {\n i = vnode.children[j];\n if (i != null && typeof i !== \"string\") {\n invokeDestroyHook(i);\n }\n }\n }\n }\n }\n function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n for (; startIdx <= endIdx; ++startIdx) {\n var i_1 = void 0, listeners = void 0, rm = void 0, ch = vnodes[startIdx];\n if (ch != null) {\n if (isDef(ch.sel)) {\n invokeDestroyHook(ch);\n listeners = cbs.remove.length + 1;\n rm = createRmCb(ch.elm, listeners);\n for (i_1 = 0; i_1 < cbs.remove.length; ++i_1)\n cbs.remove[i_1](ch, rm);\n if (isDef(i_1 = ch.data) && isDef(i_1 = i_1.hook) && isDef(i_1 = i_1.remove)) {\n i_1(ch, rm);\n }\n else {\n rm();\n }\n }\n else {\n api.removeChild(parentElm, ch.elm);\n }\n }\n }\n }\n function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue) {\n var oldStartIdx = 0, newStartIdx = 0;\n var oldEndIdx = oldCh.length - 1;\n var oldStartVnode = oldCh[0];\n var oldEndVnode = oldCh[oldEndIdx];\n var newEndIdx = newCh.length - 1;\n var newStartVnode = newCh[0];\n var newEndVnode = newCh[newEndIdx];\n var oldKeyToIdx;\n var idxInOld;\n var elmToMove;\n var before;\n while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n if (oldStartVnode == null) {\n oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left\n }\n else if (oldEndVnode == null) {\n oldEndVnode = oldCh[--oldEndIdx];\n }\n else if (newStartVnode == null) {\n newStartVnode = newCh[++newStartIdx];\n }\n else if (newEndVnode == null) {\n newEndVnode = newCh[--newEndIdx];\n }\n else if (sameVnode(oldStartVnode, newStartVnode)) {\n patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n oldStartVnode = oldCh[++oldStartIdx];\n newStartVnode = newCh[++newStartIdx];\n }\n else if (sameVnode(oldEndVnode, newEndVnode)) {\n patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n oldEndVnode = oldCh[--oldEndIdx];\n newEndVnode = newCh[--newEndIdx];\n }\n else if (sameVnode(oldStartVnode, newEndVnode)) {\n patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n api.insertBefore(parentElm, oldStartVnode.elm, api.nextSibling(oldEndVnode.elm));\n oldStartVnode = oldCh[++oldStartIdx];\n newEndVnode = newCh[--newEndIdx];\n }\n else if (sameVnode(oldEndVnode, newStartVnode)) {\n patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n api.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n oldEndVnode = oldCh[--oldEndIdx];\n newStartVnode = newCh[++newStartIdx];\n }\n else {\n if (oldKeyToIdx === undefined) {\n oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n }\n idxInOld = oldKeyToIdx[newStartVnode.key];\n if (isUndef(idxInOld)) {\n api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);\n newStartVnode = newCh[++newStartIdx];\n }\n else {\n elmToMove = oldCh[idxInOld];\n if (elmToMove.sel !== newStartVnode.sel) {\n api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);\n }\n else {\n patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n oldCh[idxInOld] = undefined;\n api.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);\n }\n newStartVnode = newCh[++newStartIdx];\n }\n }\n }\n if (oldStartIdx > oldEndIdx) {\n before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm;\n addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n }\n else if (newStartIdx > newEndIdx) {\n removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n }\n }\n function patchVnode(oldVnode, vnode, insertedVnodeQueue) {\n var i, hook;\n if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n i(oldVnode, vnode);\n }\n var elm = vnode.elm = oldVnode.elm;\n var oldCh = oldVnode.children;\n var ch = vnode.children;\n if (oldVnode === vnode)\n return;\n if (vnode.data !== undefined) {\n for (i = 0; i < cbs.update.length; ++i)\n cbs.update[i](oldVnode, vnode);\n i = vnode.data.hook;\n if (isDef(i) && isDef(i = i.update))\n i(oldVnode, vnode);\n }\n if (isUndef(vnode.text)) {\n if (isDef(oldCh) && isDef(ch)) {\n if (oldCh !== ch)\n updateChildren(elm, oldCh, ch, insertedVnodeQueue);\n }\n else if (isDef(ch)) {\n if (isDef(oldVnode.text))\n api.setTextContent(elm, '');\n addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n }\n else if (isDef(oldCh)) {\n removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n }\n else if (isDef(oldVnode.text)) {\n api.setTextContent(elm, '');\n }\n }\n else if (oldVnode.text !== vnode.text) {\n api.setTextContent(elm, vnode.text);\n }\n if (isDef(hook) && isDef(i = hook.postpatch)) {\n i(oldVnode, vnode);\n }\n }\n return function patch(oldVnode, vnode) {\n var i, elm, parent;\n var insertedVnodeQueue = [];\n for (i = 0; i < cbs.pre.length; ++i)\n cbs.pre[i]();\n if (!isVnode(oldVnode)) {\n oldVnode = emptyNodeAt(oldVnode);\n }\n if (sameVnode(oldVnode, vnode)) {\n patchVnode(oldVnode, vnode, insertedVnodeQueue);\n }\n else {\n elm = oldVnode.elm;\n parent = api.parentNode(elm);\n createElm(vnode, insertedVnodeQueue);\n if (parent !== null) {\n api.insertBefore(parent, vnode.elm, api.nextSibling(elm));\n removeVnodes(parent, [oldVnode], 0, 0);\n }\n }\n for (i = 0; i < insertedVnodeQueue.length; ++i) {\n insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n }\n for (i = 0; i < cbs.post.length; ++i)\n cbs.post[i]();\n return vnode;\n };\n}\nexports.init = init;\n\n},{\"./h\":1,\"./htmldomapi\":2,\"./is\":3,\"./thunk\":5,\"./vnode\":6}],5:[function(require,module,exports){\n\"use strict\";\nvar h_1 = require(\"./h\");\nfunction copyToThunk(vnode, thunk) {\n thunk.elm = vnode.elm;\n vnode.data.fn = thunk.data.fn;\n vnode.data.args = thunk.data.args;\n thunk.data = vnode.data;\n thunk.children = vnode.children;\n thunk.text = vnode.text;\n thunk.elm = vnode.elm;\n}\nfunction init(thunk) {\n var cur = thunk.data;\n var vnode = cur.fn.apply(undefined, cur.args);\n copyToThunk(vnode, thunk);\n}\nfunction prepatch(oldVnode, thunk) {\n var i, old = oldVnode.data, cur = thunk.data;\n var oldArgs = old.args, args = cur.args;\n if (old.fn !== cur.fn || oldArgs.length !== args.length) {\n copyToThunk(cur.fn.apply(undefined, args), thunk);\n }\n for (i = 0; i < args.length; ++i) {\n if (oldArgs[i] !== args[i]) {\n copyToThunk(cur.fn.apply(undefined, args), thunk);\n return;\n }\n }\n copyToThunk(oldVnode, thunk);\n}\nexports.thunk = function thunk(sel, key, fn, args) {\n if (args === undefined) {\n args = fn;\n fn = key;\n key = undefined;\n }\n return h_1.h(sel, {\n key: key,\n hook: { init: init, prepatch: prepatch },\n fn: fn,\n args: args\n });\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.thunk;\n\n},{\"./h\":1}],6:[function(require,module,exports){\n\"use strict\";\nfunction vnode(sel, data, children, text, elm) {\n var key = data === undefined ? undefined : data.key;\n return { sel: sel, data: data, children: children,\n text: text, elm: elm, key: key };\n}\nexports.vnode = vnode;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = vnode;\n\n},{}]},{},[4])(4)\n});\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","h.js","htmldomapi.js","is.js","snabbdom.js","thunk.js","vnode.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjEA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\"use strict\";\nvar vnode_1 = require(\"./vnode\");\nvar is = require(\"./is\");\nfunction addNS(data, children, sel) {\n    data.ns = 'http://www.w3.org/2000/svg';\n    if (sel !== 'foreignObject' && children !== undefined) {\n        for (var i = 0; i < children.length; ++i) {\n            var childData = children[i].data;\n            if (childData !== undefined) {\n                addNS(childData, children[i].children, children[i].sel);\n            }\n        }\n    }\n}\nfunction h(sel, b, c) {\n    var data = {}, children, text, i;\n    if (c !== undefined) {\n        data = b;\n        if (is.array(c)) {\n            children = c;\n        }\n        else if (is.primitive(c)) {\n            text = c;\n        }\n        else if (c && c.sel) {\n            children = [c];\n        }\n    }\n    else if (b !== undefined) {\n        if (is.array(b)) {\n            children = b;\n        }\n        else if (is.primitive(b)) {\n            text = b;\n        }\n        else if (b && b.sel) {\n            children = [b];\n        }\n        else {\n            data = b;\n        }\n    }\n    if (is.array(children)) {\n        for (i = 0; i < children.length; ++i) {\n            if (is.primitive(children[i]))\n                children[i] = vnode_1.vnode(undefined, undefined, undefined, children[i]);\n        }\n    }\n    if (sel[0] === 's' && sel[1] === 'v' && sel[2] === 'g' &&\n        (sel.length === 3 || sel[3] === '.' || sel[3] === '#')) {\n        addNS(data, children, sel);\n    }\n    return vnode_1.vnode(sel, data, children, text, undefined);\n}\nexports.h = h;\n;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = h;\n//# sourceMappingURL=h.js.map","\"use strict\";\nfunction createElement(tagName) {\n    return document.createElement(tagName);\n}\nfunction createElementNS(namespaceURI, qualifiedName) {\n    return document.createElementNS(namespaceURI, qualifiedName);\n}\nfunction createTextNode(text) {\n    return document.createTextNode(text);\n}\nfunction createComment(text) {\n    return document.createComment(text);\n}\nfunction insertBefore(parentNode, newNode, referenceNode) {\n    parentNode.insertBefore(newNode, referenceNode);\n}\nfunction removeChild(node, child) {\n    node.removeChild(child);\n}\nfunction appendChild(node, child) {\n    node.appendChild(child);\n}\nfunction parentNode(node) {\n    return node.parentNode;\n}\nfunction nextSibling(node) {\n    return node.nextSibling;\n}\nfunction tagName(elm) {\n    return elm.tagName;\n}\nfunction setTextContent(node, text) {\n    node.textContent = text;\n}\nfunction getTextContent(node) {\n    return node.textContent;\n}\nfunction isElement(node) {\n    return node.nodeType === 1;\n}\nfunction isText(node) {\n    return node.nodeType === 3;\n}\nfunction isComment(node) {\n    return node.nodeType === 8;\n}\nexports.htmlDomApi = {\n    createElement: createElement,\n    createElementNS: createElementNS,\n    createTextNode: createTextNode,\n    createComment: createComment,\n    insertBefore: insertBefore,\n    removeChild: removeChild,\n    appendChild: appendChild,\n    parentNode: parentNode,\n    nextSibling: nextSibling,\n    tagName: tagName,\n    setTextContent: setTextContent,\n    getTextContent: getTextContent,\n    isElement: isElement,\n    isText: isText,\n    isComment: isComment,\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.htmlDomApi;\n//# sourceMappingURL=htmldomapi.js.map","\"use strict\";\nexports.array = Array.isArray;\nfunction primitive(s) {\n    return typeof s === 'string' || typeof s === 'number';\n}\nexports.primitive = primitive;\n//# sourceMappingURL=is.js.map","\"use strict\";\nvar vnode_1 = require(\"./vnode\");\nvar is = require(\"./is\");\nvar htmldomapi_1 = require(\"./htmldomapi\");\nfunction isUndef(s) { return s === undefined; }\nfunction isDef(s) { return s !== undefined; }\nvar emptyNode = vnode_1.default('', {}, [], undefined, undefined);\nfunction sameVnode(vnode1, vnode2) {\n    return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel;\n}\nfunction isVnode(vnode) {\n    return vnode.sel !== undefined;\n}\nfunction createKeyToOldIdx(children, beginIdx, endIdx) {\n    var i, map = {}, key, ch;\n    for (i = beginIdx; i <= endIdx; ++i) {\n        ch = children[i];\n        if (ch != null) {\n            key = ch.key;\n            if (key !== undefined)\n                map[key] = i;\n        }\n    }\n    return map;\n}\nvar hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post'];\nvar h_1 = require(\"./h\");\nexports.h = h_1.h;\nvar thunk_1 = require(\"./thunk\");\nexports.thunk = thunk_1.thunk;\nfunction init(modules, domApi) {\n    var i, j, cbs = {};\n    var api = domApi !== undefined ? domApi : htmldomapi_1.default;\n    for (i = 0; i < hooks.length; ++i) {\n        cbs[hooks[i]] = [];\n        for (j = 0; j < modules.length; ++j) {\n            var hook = modules[j][hooks[i]];\n            if (hook !== undefined) {\n                cbs[hooks[i]].push(hook);\n            }\n        }\n    }\n    function emptyNodeAt(elm) {\n        var id = elm.id ? '#' + elm.id : '';\n        var c = elm.className ? '.' + elm.className.split(' ').join('.') : '';\n        return vnode_1.default(api.tagName(elm).toLowerCase() + id + c, {}, [], undefined, elm);\n    }\n    function createRmCb(childElm, listeners) {\n        return function rmCb() {\n            if (--listeners === 0) {\n                var parent_1 = api.parentNode(childElm);\n                api.removeChild(parent_1, childElm);\n            }\n        };\n    }\n    function createElm(vnode, insertedVnodeQueue) {\n        var i, data = vnode.data;\n        if (data !== undefined) {\n            if (isDef(i = data.hook) && isDef(i = i.init)) {\n                i(vnode);\n                data = vnode.data;\n            }\n        }\n        var children = vnode.children, sel = vnode.sel;\n        if (sel === '!') {\n            if (isUndef(vnode.text)) {\n                vnode.text = '';\n            }\n            vnode.elm = api.createComment(vnode.text);\n        }\n        else if (sel !== undefined) {\n            // Parse selector\n            var hashIdx = sel.indexOf('#');\n            var dotIdx = sel.indexOf('.', hashIdx);\n            var hash = hashIdx > 0 ? hashIdx : sel.length;\n            var dot = dotIdx > 0 ? dotIdx : sel.length;\n            var tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;\n            var elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? api.createElementNS(i, tag)\n                : api.createElement(tag);\n            if (hash < dot)\n                elm.id = sel.slice(hash + 1, dot);\n            if (dotIdx > 0)\n                elm.className = sel.slice(dot + 1).replace(/\\./g, ' ');\n            for (i = 0; i < cbs.create.length; ++i)\n                cbs.create[i](emptyNode, vnode);\n            if (is.array(children)) {\n                for (i = 0; i < children.length; ++i) {\n                    var ch = children[i];\n                    if (ch != null) {\n                        api.appendChild(elm, createElm(ch, insertedVnodeQueue));\n                    }\n                }\n            }\n            else if (is.primitive(vnode.text)) {\n                api.appendChild(elm, api.createTextNode(vnode.text));\n            }\n            i = vnode.data.hook; // Reuse variable\n            if (isDef(i)) {\n                if (i.create)\n                    i.create(emptyNode, vnode);\n                if (i.insert)\n                    insertedVnodeQueue.push(vnode);\n            }\n        }\n        else {\n            vnode.elm = api.createTextNode(vnode.text);\n        }\n        return vnode.elm;\n    }\n    function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n        for (; startIdx <= endIdx; ++startIdx) {\n            var ch = vnodes[startIdx];\n            if (ch != null) {\n                api.insertBefore(parentElm, createElm(ch, insertedVnodeQueue), before);\n            }\n        }\n    }\n    function invokeDestroyHook(vnode) {\n        var i, j, data = vnode.data;\n        if (data !== undefined) {\n            if (isDef(i = data.hook) && isDef(i = i.destroy))\n                i(vnode);\n            for (i = 0; i < cbs.destroy.length; ++i)\n                cbs.destroy[i](vnode);\n            if (vnode.children !== undefined) {\n                for (j = 0; j < vnode.children.length; ++j) {\n                    i = vnode.children[j];\n                    if (i != null && typeof i !== \"string\") {\n                        invokeDestroyHook(i);\n                    }\n                }\n            }\n        }\n    }\n    function removeVnodes(parentElm, vnodes, startIdx, endIdx) {\n        for (; startIdx <= endIdx; ++startIdx) {\n            var i_1 = void 0, listeners = void 0, rm = void 0, ch = vnodes[startIdx];\n            if (ch != null) {\n                if (isDef(ch.sel)) {\n                    invokeDestroyHook(ch);\n                    listeners = cbs.remove.length + 1;\n                    rm = createRmCb(ch.elm, listeners);\n                    for (i_1 = 0; i_1 < cbs.remove.length; ++i_1)\n                        cbs.remove[i_1](ch, rm);\n                    if (isDef(i_1 = ch.data) && isDef(i_1 = i_1.hook) && isDef(i_1 = i_1.remove)) {\n                        i_1(ch, rm);\n                    }\n                    else {\n                        rm();\n                    }\n                }\n                else {\n                    api.removeChild(parentElm, ch.elm);\n                }\n            }\n        }\n    }\n    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue) {\n        var oldStartIdx = 0, newStartIdx = 0;\n        var oldEndIdx = oldCh.length - 1;\n        var oldStartVnode = oldCh[0];\n        var oldEndVnode = oldCh[oldEndIdx];\n        var newEndIdx = newCh.length - 1;\n        var newStartVnode = newCh[0];\n        var newEndVnode = newCh[newEndIdx];\n        var oldKeyToIdx;\n        var idxInOld;\n        var elmToMove;\n        var before;\n        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n            if (oldStartVnode == null) {\n                oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left\n            }\n            else if (oldEndVnode == null) {\n                oldEndVnode = oldCh[--oldEndIdx];\n            }\n            else if (newStartVnode == null) {\n                newStartVnode = newCh[++newStartIdx];\n            }\n            else if (newEndVnode == null) {\n                newEndVnode = newCh[--newEndIdx];\n            }\n            else if (sameVnode(oldStartVnode, newStartVnode)) {\n                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);\n                oldStartVnode = oldCh[++oldStartIdx];\n                newStartVnode = newCh[++newStartIdx];\n            }\n            else if (sameVnode(oldEndVnode, newEndVnode)) {\n                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);\n                oldEndVnode = oldCh[--oldEndIdx];\n                newEndVnode = newCh[--newEndIdx];\n            }\n            else if (sameVnode(oldStartVnode, newEndVnode)) {\n                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);\n                api.insertBefore(parentElm, oldStartVnode.elm, api.nextSibling(oldEndVnode.elm));\n                oldStartVnode = oldCh[++oldStartIdx];\n                newEndVnode = newCh[--newEndIdx];\n            }\n            else if (sameVnode(oldEndVnode, newStartVnode)) {\n                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);\n                api.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n                oldEndVnode = oldCh[--oldEndIdx];\n                newStartVnode = newCh[++newStartIdx];\n            }\n            else {\n                if (oldKeyToIdx === undefined) {\n                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);\n                }\n                idxInOld = oldKeyToIdx[newStartVnode.key];\n                if (isUndef(idxInOld)) {\n                    api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);\n                    newStartVnode = newCh[++newStartIdx];\n                }\n                else {\n                    elmToMove = oldCh[idxInOld];\n                    if (elmToMove.sel !== newStartVnode.sel) {\n                        api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);\n                    }\n                    else {\n                        patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);\n                        oldCh[idxInOld] = undefined;\n                        api.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);\n                    }\n                    newStartVnode = newCh[++newStartIdx];\n                }\n            }\n        }\n        if (oldStartIdx > oldEndIdx) {\n            before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm;\n            addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n        }\n        else if (newStartIdx > newEndIdx) {\n            removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);\n        }\n    }\n    function patchVnode(oldVnode, vnode, insertedVnodeQueue) {\n        var i, hook;\n        if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) {\n            i(oldVnode, vnode);\n        }\n        var elm = vnode.elm = oldVnode.elm;\n        var oldCh = oldVnode.children;\n        var ch = vnode.children;\n        if (oldVnode === vnode)\n            return;\n        if (vnode.data !== undefined) {\n            for (i = 0; i < cbs.update.length; ++i)\n                cbs.update[i](oldVnode, vnode);\n            i = vnode.data.hook;\n            if (isDef(i) && isDef(i = i.update))\n                i(oldVnode, vnode);\n        }\n        if (isUndef(vnode.text)) {\n            if (isDef(oldCh) && isDef(ch)) {\n                if (oldCh !== ch)\n                    updateChildren(elm, oldCh, ch, insertedVnodeQueue);\n            }\n            else if (isDef(ch)) {\n                if (isDef(oldVnode.text))\n                    api.setTextContent(elm, '');\n                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n            }\n            else if (isDef(oldCh)) {\n                removeVnodes(elm, oldCh, 0, oldCh.length - 1);\n            }\n            else if (isDef(oldVnode.text)) {\n                api.setTextContent(elm, '');\n            }\n        }\n        else if (oldVnode.text !== vnode.text) {\n            api.setTextContent(elm, vnode.text);\n        }\n        if (isDef(hook) && isDef(i = hook.postpatch)) {\n            i(oldVnode, vnode);\n        }\n    }\n    return function patch(oldVnode, vnode) {\n        var i, elm, parent;\n        var insertedVnodeQueue = [];\n        for (i = 0; i < cbs.pre.length; ++i)\n            cbs.pre[i]();\n        if (!isVnode(oldVnode)) {\n            oldVnode = emptyNodeAt(oldVnode);\n        }\n        if (sameVnode(oldVnode, vnode)) {\n            patchVnode(oldVnode, vnode, insertedVnodeQueue);\n        }\n        else {\n            elm = oldVnode.elm;\n            parent = api.parentNode(elm);\n            createElm(vnode, insertedVnodeQueue);\n            if (parent !== null) {\n                api.insertBefore(parent, vnode.elm, api.nextSibling(elm));\n                removeVnodes(parent, [oldVnode], 0, 0);\n            }\n        }\n        for (i = 0; i < insertedVnodeQueue.length; ++i) {\n            insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);\n        }\n        for (i = 0; i < cbs.post.length; ++i)\n            cbs.post[i]();\n        return vnode;\n    };\n}\nexports.init = init;\n//# sourceMappingURL=snabbdom.js.map","\"use strict\";\nvar h_1 = require(\"./h\");\nfunction copyToThunk(vnode, thunk) {\n    thunk.elm = vnode.elm;\n    vnode.data.fn = thunk.data.fn;\n    vnode.data.args = thunk.data.args;\n    thunk.data = vnode.data;\n    thunk.children = vnode.children;\n    thunk.text = vnode.text;\n    thunk.elm = vnode.elm;\n}\nfunction init(thunk) {\n    var cur = thunk.data;\n    var vnode = cur.fn.apply(undefined, cur.args);\n    copyToThunk(vnode, thunk);\n}\nfunction prepatch(oldVnode, thunk) {\n    var i, old = oldVnode.data, cur = thunk.data;\n    var oldArgs = old.args, args = cur.args;\n    if (old.fn !== cur.fn || oldArgs.length !== args.length) {\n        copyToThunk(cur.fn.apply(undefined, args), thunk);\n    }\n    for (i = 0; i < args.length; ++i) {\n        if (oldArgs[i] !== args[i]) {\n            copyToThunk(cur.fn.apply(undefined, args), thunk);\n            return;\n        }\n    }\n    copyToThunk(oldVnode, thunk);\n}\nexports.thunk = function thunk(sel, key, fn, args) {\n    if (args === undefined) {\n        args = fn;\n        fn = key;\n        key = undefined;\n    }\n    return h_1.h(sel, {\n        key: key,\n        hook: { init: init, prepatch: prepatch },\n        fn: fn,\n        args: args\n    });\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = exports.thunk;\n//# sourceMappingURL=thunk.js.map","\"use strict\";\nfunction vnode(sel, data, children, text, elm) {\n    var key = data === undefined ? undefined : data.key;\n    return { sel: sel, data: data, children: children,\n        text: text, elm: elm, key: key };\n}\nexports.vnode = vnode;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = vnode;\n//# sourceMappingURL=vnode.js.map"]}\n"]} \ No newline at end of file diff --git a/src/libs/snabbdom/dist/tovnode.js b/src/libs/snabbdom/dist/tovnode.js new file mode 100755 index 00000000..bc9283a4 --- /dev/null +++ b/src/libs/snabbdom/dist/tovnode.js @@ -0,0 +1,126 @@ +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.tovnode = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o .babelrc +``` + +I then built like this: +``` +browserify examples/carousel-svg/script.js -t babelify -o examples/carousel-svg/build.js +``` + +-- *jk* diff --git a/src/libs/snabbdom/examples/carousel-svg/build.js b/src/libs/snabbdom/examples/carousel-svg/build.js new file mode 100755 index 00000000..3b1d598c --- /dev/null +++ b/src/libs/snabbdom/examples/carousel-svg/build.js @@ -0,0 +1,566 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 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; + elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag) : document.createElement(tag); + if (hash < dot) elm.id = sel.slice(hash + 1, dot); + if (dotIdx > 0) elm.className = sel.slice(dot + 1).replace(/\./g, ' '); + if (is.array(children)) { + for (i = 0; i < children.length; ++i) { + elm.appendChild(createElm(children[i], insertedVnodeQueue)); + } + } else if (is.primitive(vnode.text)) { + elm.appendChild(document.createTextNode(vnode.text)); + } + for (i = 0; i < cbs.create.length; ++i) { + cbs.create[i](emptyNode, vnode); + }i = vnode.data.hook; // Reuse variable + if (isDef(i)) { + if (i.create) i.create(emptyNode, vnode); + if (i.insert) insertedVnodeQueue.push(vnode); + } + } else { + elm = vnode.elm = document.createTextNode(vnode.text); + } + return vnode.elm; + } + + function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) { + for (; startIdx <= endIdx; ++startIdx) { + parentElm.insertBefore(createElm(vnodes[startIdx], insertedVnodeQueue), before); + } + } + + function invokeDestroyHook(vnode) { + var i = vnode.data, + j; + if (isDef(i)) { + if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode); + for (i = 0; i < cbs.destroy.length; ++i) { + cbs.destroy[i](vnode); + }if (isDef(i = vnode.children)) { + for (j = 0; j < vnode.children.length; ++j) { + invokeDestroyHook(vnode.children[j]); + } + } + } + } + + function removeVnodes(parentElm, vnodes, startIdx, endIdx) { + for (; startIdx <= endIdx; ++startIdx) { + var i, + listeners, + rm, + ch = vnodes[startIdx]; + if (isDef(ch)) { + if (isDef(ch.sel)) { + invokeDestroyHook(ch); + listeners = cbs.remove.length + 1; + rm = createRmCb(ch.elm, listeners); + for (i = 0; i < cbs.remove.length; ++i) { + cbs.remove[i](ch, rm); + }if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) { + i(ch, rm); + } else { + rm(); + } + } else { + // Text node + parentElm.removeChild(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, idxInOld, elmToMove, before; + + while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { + if (isUndef(oldStartVnode)) { + oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left + } else if (isUndef(oldEndVnode)) { + oldEndVnode = oldCh[--oldEndIdx]; + } 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)) { + // Vnode moved right + patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue); + parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling); + oldStartVnode = oldCh[++oldStartIdx]; + newEndVnode = newCh[--newEndIdx]; + } else if (sameVnode(oldEndVnode, newStartVnode)) { + // Vnode moved left + patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue); + parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm); + oldEndVnode = oldCh[--oldEndIdx]; + newStartVnode = newCh[++newStartIdx]; + } else { + if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); + idxInOld = oldKeyToIdx[newStartVnode.key]; + if (isUndef(idxInOld)) { + // New element + parentElm.insertBefore(createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm); + newStartVnode = newCh[++newStartIdx]; + } else { + elmToMove = oldCh[idxInOld]; + patchVnode(elmToMove, newStartVnode, insertedVnodeQueue); + oldCh[idxInOld] = undefined; + parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm); + newStartVnode = newCh[++newStartIdx]; + } + } + } + if (oldStartIdx > oldEndIdx) { + before = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm; + addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue); + } else if (newStartIdx > newEndIdx) { + 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); + } + if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i; + if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i; + var elm = vnode.elm = oldVnode.elm, + oldCh = oldVnode.children, + ch = vnode.children; + if (oldVnode === vnode) return; + if (isDef(vnode.data)) { + 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)) { + addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue); + } else if (isDef(oldCh)) { + removeVnodes(elm, oldCh, 0, oldCh.length - 1); + } + } else if (oldVnode.text !== vnode.text) { + elm.textContent = vnode.text; + } + if (isDef(hook) && isDef(i = hook.postpatch)) { + i(oldVnode, vnode); + } + } + + return function (oldVnode, vnode) { + var i; + var insertedVnodeQueue = []; + for (i = 0; i < cbs.pre.length; ++i) { + cbs.pre[i](); + }if (oldVnode instanceof Element) { + if (oldVnode.parentElement !== null) { + createElm(vnode, insertedVnodeQueue); + oldVnode.parentElement.replaceChild(vnode.elm, oldVnode); + } else { + oldVnode = emptyNodeAt(oldVnode); + patchVnode(oldVnode, vnode, insertedVnodeQueue); + } + } else { + patchVnode(oldVnode, vnode, insertedVnodeQueue); + } + 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; + }; +} + +module.exports = { init: init }; + +},{"./is":2,"./vnode":7}],7:[function(require,module,exports){ +"use strict"; + +module.exports = function (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 }; +}; + +},{}],8:[function(require,module,exports){ +'use strict'; + +var snabbdom = require('../../snabbdom.js'); +var patch = snabbdom.init([require('../../modules/attributes'), require('../../modules/style'), require('../../modules/eventlisteners')]); +var h = require('../../h.js'); + +var vnode; + +var data = { + degRotation: 0 +}; + +function gRotation() { + //console.log("gRotation: %s", data.degRotation); + return "rotate(" + data.degRotation + "deg)"; +} + +function triangleClick(id) { + console.log("triangleClick: %s", id); + render(); +} + +function handleRotate(degs) { + data.degRotation += degs; + console.log("handleRotate: %s, %s", degs, data.degRotation); + render(); +} + +function handleReset(degs) { + data.degRotation = degs; + console.log("handleReset: %s", degs); + render(); +} + +function render() { + vnode = patch(vnode, view(data)); +} + +var hTriangle = function hTriangle(id, degRotation) { + return h("polygon#" + id, { + attrs: { + points: "-50,-88 0,-175 50,-88", + transform: "rotate(" + degRotation + ")", + "stroke-width": 3 + }, + on: { click: [triangleClick, id] } + }); +}; + +var view = function view(data) { + return h("div.view", [h("h1", "Snabbdom SVG Carousel"), h("svg", { attrs: { width: 380, height: 380, viewBox: [-190, -190, 380, 380] } }, [h("g#carousel", { style: { "-webkit-transform": gRotation(), transform: gRotation() } }, [hTriangle("yellow", 0), hTriangle("green", 60), hTriangle("magenta", 120), hTriangle("red", 180), hTriangle("cyan", 240), hTriangle("blue", 300)])]), h("button", { on: { click: [handleRotate, 60] } }, "Rotate Clockwise"), h("button", { on: { click: [handleRotate, -60] } }, "Rotate Anticlockwise"), h("button", { on: { click: [handleReset, 0] } }, "Reset")]); +}; + +window.addEventListener("DOMContentLoaded", function () { + var container = document.getElementById("container"); + vnode = patch(container, view(data)); + render(); +}); + +},{"../../h.js":1,"../../modules/attributes":3,"../../modules/eventlisteners":4,"../../modules/style":5,"../../snabbdom.js":6}]},{},[8]); diff --git a/src/libs/snabbdom/examples/carousel-svg/index.html b/src/libs/snabbdom/examples/carousel-svg/index.html new file mode 100755 index 00000000..3b81d87d --- /dev/null +++ b/src/libs/snabbdom/examples/carousel-svg/index.html @@ -0,0 +1,74 @@ + + + + + + Carousel + + + + +
+ + diff --git a/src/libs/snabbdom/examples/carousel-svg/script.js b/src/libs/snabbdom/examples/carousel-svg/script.js new file mode 100755 index 00000000..3e06f160 --- /dev/null +++ b/src/libs/snabbdom/examples/carousel-svg/script.js @@ -0,0 +1,74 @@ +var snabbdom = require('../../snabbdom.js'); +var patch = snabbdom.init([ + require('../../modules/attributes').default, + require('../../modules/style').default, + require('../../modules/eventlisteners').default +]); +var h = require('../../h.js').default; + +var vnode; + +var data = { + degRotation: 0 +}; + +function gRotation() { + //console.log("gRotation: %s", data.degRotation); + return "rotate(" + data.degRotation + "deg)"; +} + +function triangleClick(id) { + console.log("triangleClick: %s", id); + render(); +} + +function handleRotate(degs) { + data.degRotation += degs; + console.log("handleRotate: %s, %s", degs, data.degRotation); + render(); +} + +function handleReset(degs) { + data.degRotation = degs; + console.log("handleReset: %s", degs); + render(); +} + +function render() { + vnode = patch(vnode, view(data)); +} + +const hTriangle = (id, degRotation) => + h("polygon#" + id, { + attrs: { + points: "-50,-88 0,-175 50,-88", + transform: "rotate(" + degRotation + ")", + "stroke-width": 3 + }, + on: {click: [triangleClick, id]} + }); + +const view = (data) => + h("div.view", [ + h("h1", "Snabbdom SVG Carousel"), + h("svg", {attrs: {width: 380, height: 380, viewBox: [-190, -190, 380, 380]}}, [ + h("g#carousel", + {style: {"-webkit-transform": gRotation(), transform: gRotation()}}, [ + hTriangle("yellow", 0), + hTriangle("green", 60), + hTriangle("magenta", 120), + hTriangle("red", 180), + hTriangle("cyan", 240), + hTriangle("blue", 300) + ]) + ]), + h("button", {on: {click: [handleRotate, 60]}}, "Rotate Clockwise"), + h("button", {on: {click: [handleRotate, -60]}}, "Rotate Anticlockwise"), + h("button", {on: {click: [handleReset, 0]}}, "Reset") + ]); + +window.addEventListener("DOMContentLoaded", () => { + var container = document.getElementById("container"); + vnode = patch(container, view(data)); + render(); +}); diff --git a/src/libs/snabbdom/examples/hero/build.js b/src/libs/snabbdom/examples/hero/build.js new file mode 100755 index 00000000..8e7ab12e --- /dev/null +++ b/src/libs/snabbdom/examples/hero/build.js @@ -0,0 +1,708 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 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; + elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag) : document.createElement(tag); + if (hash < dot) elm.id = sel.slice(hash + 1, dot); + if (dotIdx > 0) elm.className = sel.slice(dot + 1).replace(/\./g, ' '); + if (is.array(children)) { + for (i = 0; i < children.length; ++i) { + elm.appendChild(createElm(children[i], insertedVnodeQueue)); + } + } else if (is.primitive(vnode.text)) { + elm.appendChild(document.createTextNode(vnode.text)); + } + for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode); + i = vnode.data.hook; // Reuse variable + if (isDef(i)) { + if (i.create) i.create(emptyNode, vnode); + if (i.insert) insertedVnodeQueue.push(vnode); + } + } else { + elm = vnode.elm = document.createTextNode(vnode.text); + } + return vnode.elm; + } + + function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) { + for (; startIdx <= endIdx; ++startIdx) { + parentElm.insertBefore(createElm(vnodes[startIdx], insertedVnodeQueue), before); + } + } + + function invokeDestroyHook(vnode) { + var i = vnode.data, + j; + if (isDef(i)) { + if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode); + for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode); + if (isDef(i = vnode.children)) { + for (j = 0; j < vnode.children.length; ++j) { + invokeDestroyHook(vnode.children[j]); + } + } + } + } + + function removeVnodes(parentElm, vnodes, startIdx, endIdx) { + for (; startIdx <= endIdx; ++startIdx) { + var i, + listeners, + rm, + ch = vnodes[startIdx]; + if (isDef(ch)) { + if (isDef(ch.sel)) { + invokeDestroyHook(ch); + listeners = cbs.remove.length + 1; + rm = createRmCb(ch.elm, listeners); + for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm); + if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) { + i(ch, rm); + } else { + rm(); + } + } else { + // Text node + parentElm.removeChild(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, idxInOld, elmToMove, before; + + while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { + if (isUndef(oldStartVnode)) { + oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left + } else if (isUndef(oldEndVnode)) { + oldEndVnode = oldCh[--oldEndIdx]; + } 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)) { + // Vnode moved right + patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue); + parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling); + oldStartVnode = oldCh[++oldStartIdx]; + newEndVnode = newCh[--newEndIdx]; + } else if (sameVnode(oldEndVnode, newStartVnode)) { + // Vnode moved left + patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue); + parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm); + oldEndVnode = oldCh[--oldEndIdx]; + newStartVnode = newCh[++newStartIdx]; + } else { + if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); + idxInOld = oldKeyToIdx[newStartVnode.key]; + if (isUndef(idxInOld)) { + // New element + parentElm.insertBefore(createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm); + newStartVnode = newCh[++newStartIdx]; + } else { + elmToMove = oldCh[idxInOld]; + patchVnode(elmToMove, newStartVnode, insertedVnodeQueue); + oldCh[idxInOld] = undefined; + parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm); + newStartVnode = newCh[++newStartIdx]; + } + } + } + if (oldStartIdx > oldEndIdx) { + before = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm; + addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue); + } else if (newStartIdx > newEndIdx) { + 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); + } + if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i; + if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i; + var elm = vnode.elm = oldVnode.elm, + oldCh = oldVnode.children, + ch = vnode.children; + if (oldVnode === vnode) return; + if (isDef(vnode.data)) { + 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)) { + addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue); + } else if (isDef(oldCh)) { + removeVnodes(elm, oldCh, 0, oldCh.length - 1); + } + } else if (oldVnode.text !== vnode.text) { + elm.textContent = vnode.text; + } + if (isDef(hook) && isDef(i = hook.postpatch)) { + i(oldVnode, vnode); + } + } + + return function (oldVnode, vnode) { + var i; + var insertedVnodeQueue = []; + for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i](); + if (oldVnode instanceof Element) { + if (oldVnode.parentElement !== null) { + createElm(vnode, insertedVnodeQueue); + oldVnode.parentElement.replaceChild(vnode.elm, oldVnode); + } else { + oldVnode = emptyNodeAt(oldVnode); + patchVnode(oldVnode, vnode, insertedVnodeQueue); + } + } else { + patchVnode(oldVnode, vnode, insertedVnodeQueue); + } + 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; + }; +} + +module.exports = { init: init }; + +},{"./is":3,"./vnode":9}],9:[function(require,module,exports){ +"use strict"; + +module.exports = function (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 }; +}; + +},{}]},{},[1]); diff --git a/src/libs/snabbdom/examples/hero/index.html b/src/libs/snabbdom/examples/hero/index.html new file mode 100755 index 00000000..6b0e9757 --- /dev/null +++ b/src/libs/snabbdom/examples/hero/index.html @@ -0,0 +1,166 @@ + + + + + + Hero animation + + + + +
+ + diff --git a/src/libs/snabbdom/examples/hero/script.js b/src/libs/snabbdom/examples/hero/script.js new file mode 100755 index 00000000..db9ceb01 --- /dev/null +++ b/src/libs/snabbdom/examples/hero/script.js @@ -0,0 +1,120 @@ +/* jshint esnext: true */ +var snabbdom = require('../../snabbdom.js'); +var patch = snabbdom.init([ + require('../../modules/class').default, + require('../../modules/hero').default, + require('../../modules/style').default, + require('../../modules/eventlisteners').default, +]); +var h = require('../../h.js').default; + +var vnode; + +var data = { + selected: undefined, + movies: [ + {rank: 1, title: 'This is an', desc: 'Lorem ipsum dolor sit amet, sed pede integer vitae bibendum, accumsan sit, vulputate aenean tempora ipsum. Lorem sed id et metus, eros posuere suspendisse nec nunc justo, fusce augue placerat nibh purus suspendisse. Aliquam aliquam, ut eget. Mollis a eget sed nibh tincidunt nec, mi integer, proin magna lacus iaculis tortor. Aliquam vel arcu arcu, vivamus a urna fames felis vel wisi, cursus tortor nec erat dignissim cras sem, mauris ac venenatis tellus elit.'}, + {rank: 2, title: 'example of', desc: 'Consequuntur ipsum nulla, consequat curabitur in magnis risus. Taciti mattis bibendum tellus nibh, at dui neque eget, odio pede ut, sapien pede, ipsum ut. Sagittis dui, sodales sem, praesent ipsum conubia eget lorem lobortis wisi.'}, + {rank: 3, title: 'Snabbdom', desc: 'Quam lorem aliquam fusce wisi, urna purus ipsum pharetra sed, at cras sodales enim vestibulum odio cras, luctus integer phasellus.'}, + {rank: 4, title: 'doing hero transitions', desc: 'Et orci hac ultrices id in. Diam ultrices luctus egestas, sem aliquam auctor molestie odio laoreet. Pede nam cubilia, diam vestibulum ornare natoque, aenean etiam fusce id, eget dictum blandit et mauris mauris. Metus amet ad, elit porttitor a aliquet commodo lacus, integer neque imperdiet augue laoreet, nonummy turpis lacus sed pulvinar condimentum platea. Wisi eleifend quis, tristique dictum, ac dictumst. Sem nec tristique vel vehicula fringilla, nibh eu et posuere mi rhoncus.'}, + {rank: 5, title: 'using the', desc: 'Pede nam cubilia, diam vestibulum ornare natoque, aenean etiam fusce id, eget dictum blandit et mauris mauris. Metus amet ad, elit porttitor a aliquet commodo lacus, integer neque imperdiet augue laoreet, nonummy turpis lacus sed pulvinar condimentum platea. Wisi eleifend quis, tristique dictum, ac dictumst. Sem nec tristique vel vehicula fringilla, nibh eu et posuere mi rhoncus.'}, + {rank: 6, title: 'module for hero transitions', desc: 'Sapien laoreet, ligula elit tortor nulla pellentesque, maecenas enim turpis, quae duis venenatis vivamus ultricies, nunc imperdiet sollicitudin ipsum malesuada. Ut sem. Wisi fusce nullam nibh enim. Nisl hymenaeos id sed sed in. Proin leo et, pulvinar nunc pede laoreet.'}, + {rank: 7, title: 'click on ar element in', desc: 'Accumsan quia, id nascetur dui et congue erat, id excepteur, primis ratione nec. At nulla et. Suspendisse lobortis, lobortis in tortor fringilla, duis adipiscing vestibulum voluptates sociosqu auctor.'}, + {rank: 8, title: 'the list', desc: 'Ante tellus egestas vel hymenaeos, ut viverra nibh ut, ipsum nibh donec donec dolor. Eros ridiculus vel egestas convallis ipsum, commodo ut venenatis nullam porta iaculis, suspendisse ante proin leo, felis risus etiam.'}, + {rank: 9, title: 'to witness', desc: 'Metus amet ad, elit porttitor a aliquet commodo lacus, integer neque imperdiet augue laoreet, nonummy turpis lacus sed pulvinar condimentum platea. Wisi eleifend quis, tristique dictum, ac dictumst.'}, + {rank: 10, title: 'the effect', desc: 'Et orci hac ultrices id in. Diam ultrices luctus egestas, sem aliquam auctor molestie odio laoreet. Pede nam cubilia, diam vestibulum ornare natoque, aenean etiam fusce id, eget dictum blandit et mauris mauris'}, + ] +}; + +function select(m) { + data.selected = m; + render(); +} + +function render() { + vnode = patch(vnode, view(data)); +} + +const fadeInOutStyle = { + opacity: '0', delayed: {opacity: '1'}, remove: {opacity: '0'} +}; + +const detailView = (movie) => + h('div.page', {style: fadeInOutStyle}, [ + h('div.header', [ + h('div.header-content.detail', { + style: {opacity: '1', remove: {opacity: '0'}}, + }, [ + h('div.rank', [ + h('span.header-rank.hero', {hero: {id: 'rank'+movie.rank}}, movie.rank), + h('div.rank-circle', { + style: {transform: 'scale(0)', + delayed: {transform: 'scale(1)'}, + destroy: {transform: 'scale(0)'}}, + }), + ]), + h('div.hero.header-title', {hero: {id: movie.title}}, movie.title), + h('div.spacer'), + h('div.close', { + on: {click: [select, undefined]}, + style: {transform: 'scale(0)', + delayed: {transform: 'scale(1)'}, + destroy: {transform: 'scale(0)'}}, + }, 'x'), + ]), + ]), + h('div.page-content', [ + h('div.desc', { + style: {opacity: '0', transform: 'translateX(3em)', + delayed: {opacity: '1', transform: 'translate(0)'}, + remove: {opacity: '0', position: 'absolute', top: '0', left: '0', + transform: 'translateX(3em)'} + } + }, [ + h('h2', 'Description:'), + h('span', movie.desc), + ]), + ]), + ]); + +const overviewView = (movies) => + h('div.page', {style: fadeInOutStyle}, [ + h('div.header', [ + h('div.header-content.overview', { + style: fadeInOutStyle, + }, [ + h('div.header-title', { + style: {transform: 'translateY(-2em)', + delayed: {transform: 'translate(0)'}, + destroy: {transform: 'translateY(-2em)'}} + }, 'Top 10 movies'), + h('div.spacer'), + ]), + ]), + h('div.page-content', [ + h('div.list', { + style: {opacity: '0', delayed: {opacity: '1'}, + remove: {opacity: '0', position: 'absolute', top: '0', left: '0'}} + }, movies.map((movie) => + h('div.row', { + on: {click: [select, movie]}, + }, [ + h('div.hero.rank', [ + h('span.hero', {hero: {id: 'rank'+movie.rank}}, movie.rank) + ]), + h('div.hero', {hero: {id: movie.title}}, movie.title) + ]) + )), + ]), + ]); + +const view = (data) => + h('div.page-container', [ + data.selected ? detailView(data.selected) : overviewView(data.movies), + ]); + +window.addEventListener('DOMContentLoaded', () => { + var container = document.getElementById('container'); + vnode = patch(container, view(data)); + render(); +}); diff --git a/src/libs/snabbdom/examples/reorder-animation/build.js b/src/libs/snabbdom/examples/reorder-animation/build.js new file mode 100755 index 00000000..8cb2f312 --- /dev/null +++ b/src/libs/snabbdom/examples/reorder-animation/build.js @@ -0,0 +1,523 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o b[prop]) { + return 1; + } + if (a[prop] < b[prop]) { + return -1; + } + return 0; + }); + render(); +} + +function add() { + var n = originalData[Math.floor(Math.random() * 10)]; + data = [{ rank: nextKey++, title: n.title, desc: n.desc, elmHeight: 0 }].concat(data); + render(); + render(); +} + +function remove(movie) { + data = data.filter(function (m) { + return m !== movie; + }); + render(); +} + +function movieView(movie) { + return h('div.row', { + key: movie.rank, + style: { opacity: '0', transform: 'translate(-200px)', + delayed: { transform: 'translateY(' + movie.offset + 'px)', opacity: '1' }, + remove: { opacity: '0', transform: 'translateY(' + movie.offset + 'px) translateX(200px)' } }, + hook: { insert: function insert(vnode) { + movie.elmHeight = vnode.elm.offsetHeight; + } } }, [h('div', { style: { fontWeight: 'bold' } }, movie.rank), h('div', movie.title), h('div', movie.desc), h('div.btn.rm-btn', { on: { click: [remove, movie] } }, 'x')]); +} + +function render() { + data = data.reduce(function (acc, m) { + var last = acc[acc.length - 1]; + m.offset = last ? last.offset + last.elmHeight + margin : margin; + return acc.concat(m); + }, []); + totalHeight = data[data.length - 1].offset + data[data.length - 1].elmHeight; + vnode = patch(vnode, view(data)); +} + +function view(data) { + return h('div', [h('h1', 'Top 10 movies'), h('div', [h('a.btn.add', { on: { click: add } }, 'Add'), 'Sort by: ', h('span.btn-group', [h('a.btn.rank', { 'class': { active: sortBy === 'rank' }, on: { click: [changeSort, 'rank'] } }, 'Rank'), h('a.btn.title', { 'class': { active: sortBy === 'title' }, on: { click: [changeSort, 'title'] } }, 'Title'), h('a.btn.desc', { 'class': { active: sortBy === 'desc' }, on: { click: [changeSort, 'desc'] } }, 'Description')])]), h('div.list', { style: { height: totalHeight + 'px' } }, data.map(movieView))]); +} + +window.addEventListener('DOMContentLoaded', function () { + var container = document.getElementById('container'); + vnode = patch(container, view(data)); + render(); +}); + +},{"../../h.js":2,"../../modules/class":4,"../../modules/eventlisteners":5,"../../modules/props":6,"../../modules/style":7,"../../snabbdom.js":8}],2:[function(require,module,exports){ +'use strict'; + +var VNode = require('./vnode'); +var is = require('./is'); + +module.exports = function h(sel, b, c) { + var data = {}, + children, + text, + i; + if (arguments.length === 3) { + data = b; + if (is.array(c)) { + children = c; + } else if (is.primitive(c)) { + text = c; + } + } else if (arguments.length === 2) { + if (is.array(b)) { + children = b; + } else if (is.primitive(b)) { + text = b; + } else { + data = b; + } + } + if (is.array(children)) { + for (i = 0; i < children.length; ++i) { + if (is.primitive(children[i])) children[i] = VNode(undefined, undefined, undefined, children[i]); + } + } + return VNode(sel, data, children, text, undefined); +}; + +},{"./is":3,"./vnode":9}],3:[function(require,module,exports){ +'use strict'; + +module.exports = { + array: Array.isArray, + primitive: function primitive(s) { + return typeof s === 'string' || typeof s === 'number'; + } }; + +},{}],4:[function(require,module,exports){ +'use strict'; + +function updateClass(oldVnode, vnode) { + var cur, + name, + elm = vnode.elm, + oldClass = oldVnode.data['class'] || {}, + klass = vnode.data['class'] || {}; + for (name in klass) { + cur = klass[name]; + if (cur !== oldClass[name]) { + elm.classList[cur ? 'add' : 'remove'](name); + } + } +} + +module.exports = { create: updateClass, update: updateClass }; + +},{}],5:[function(require,module,exports){ +'use strict'; + +var is = require('../is'); + +function arrInvoker(arr) { + return function () { + arr[0](arr[1]); + }; +} + +function updateEventListeners(oldVnode, vnode) { + var name, + cur, + old, + elm = vnode.elm, + oldOn = oldVnode.data.on || {}, + on = vnode.data.on; + if (!on) return; + for (name in on) { + cur = on[name]; + old = oldOn[name]; + if (old === undefined) { + elm.addEventListener(name, is.array(cur) ? arrInvoker(cur) : cur); + } else if (is.array(old)) { + old[0] = cur[0]; // Deliberately modify old array since it's + old[1] = cur[1]; // captured in closure created with `arrInvoker` + } + } +} + +module.exports = { create: updateEventListeners, update: updateEventListeners }; + +},{"../is":3}],6:[function(require,module,exports){ +"use strict"; + +function updateProps(oldVnode, vnode) { + var key, + cur, + old, + elm = vnode.elm, + oldProps = oldVnode.data.props || {}, + props = vnode.data.props || {}; + for (key in props) { + cur = props[key]; + old = oldProps[key]; + if (old !== cur) { + elm[key] = cur; + } + } +} + +module.exports = { create: updateProps, update: updateProps }; + +},{}],7:[function(require,module,exports){ +'use strict'; + +var raf = requestAnimationFrame || setTimeout; +var nextFrame = function nextFrame(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 || {}, + oldHasDel = ('delayed' in oldStyle); + for (name in style) { + cur = style[name]; + if (name === 'delayed') { + for (name in style.delayed) { + cur = style.delayed[name]; + if (!oldHasDel || cur !== oldStyle.delayed[name]) { + setNextFrame(elm.style, name, cur); + } + } + } else if (name !== 'remove' && cur !== oldStyle[name]) { + 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, + idx, + i = 0, + maxDur = 0, + compStyle, + style = s.remove, + amount = 0; + var 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(); + }); +} + +module.exports = { create: updateStyle, update: updateStyle, destroy: applyDestroyStyle, remove: applyRemoveStyle }; + +},{}],8:[function(require,module,exports){ +// jshint newcap: false +'use strict'; + +var VNode = require('./vnode'); +var is = require('./is'); + +function isUndef(s) { + return s === undefined; +} + +function emptyNodeAt(elm) { + return VNode(elm.tagName, {}, [], undefined, elm); +} + +var emptyNode = VNode('', {}, [], undefined, undefined); + +var insertedVnodeQueue; + +function sameVnode(vnode1, vnode2) { + return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel; +} + +function createKeyToOldIdx(children, beginIdx, endIdx) { + var i, + map = {}, + key; + for (i = beginIdx; i <= endIdx; ++i) { + key = children[i].key; + if (!isUndef(key)) map[key] = i; + } + return map; +} + +function createRmCb(parentElm, childElm, listeners) { + return function () { + if (--listeners === 0) parentElm.removeChild(childElm); + }; +} + +var hooks = ['create', 'update', 'remove', 'destroy', 'pre', 'post']; + +function init(modules) { + var i, + j, + cbs = {}; + for (i = 0; i < hooks.length; ++i) { + cbs[hooks[i]] = []; + for (j = 0; j < modules.length; ++j) { + if (modules[j][hooks[i]] !== undefined) cbs[hooks[i]].push(modules[j][hooks[i]]); + } + } + + function createElm(vnode) { + var i; + if (!isUndef(i = vnode.data) && !isUndef(i = i.hook) && !isUndef(i = i.init)) { + i(vnode); + } + if (!isUndef(i = vnode.data) && !isUndef(i = i.vnode)) vnode = i; + var elm, + children = vnode.children, + sel = vnode.sel; + if (!isUndef(sel)) { + // 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; + elm = vnode.elm = document.createElement(tag); + if (hash < dot) elm.id = sel.slice(hash + 1, dot); + if (dotIdx > 0) elm.className = sel.slice(dot + 1).replace(/\./g, ' '); + if (is.array(children)) { + for (i = 0; i < children.length; ++i) { + elm.appendChild(createElm(children[i])); + } + } else if (is.primitive(vnode.text)) { + elm.appendChild(document.createTextNode(vnode.text)); + } + for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode); + i = vnode.data.hook; // Reuse variable + if (!isUndef(i)) { + if (i.create) i.create(vnode); + if (i.insert) insertedVnodeQueue.push(vnode); + } + } else { + elm = vnode.elm = document.createTextNode(vnode.text); + } + return elm; + } + + function addVnodes(parentElm, before, vnodes, startIdx, endIdx) { + if (isUndef(before)) { + for (; startIdx <= endIdx; ++startIdx) { + parentElm.appendChild(createElm(vnodes[startIdx])); + } + } else { + var elm = before.elm; + for (; startIdx <= endIdx; ++startIdx) { + parentElm.insertBefore(createElm(vnodes[startIdx]), elm); + } + } + } + + function invokeDestroyHook(vnode) { + var i = vnode.data.hook, + j; + if (!isUndef(i) && !isUndef(j = i.destroy)) j(vnode); + for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode); + if (!isUndef(vnode.children)) { + for (j = 0; j < vnode.children.length; ++j) { + invokeDestroyHook(vnode.children[j]); + } + } + } + + function removeVnodes(parentElm, vnodes, startIdx, endIdx) { + for (; startIdx <= endIdx; ++startIdx) { + var i, + listeners, + rm, + ch = vnodes[startIdx]; + if (!isUndef(ch)) { + listeners = cbs.remove.length + 1; + rm = createRmCb(parentElm, ch.elm, listeners); + for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm); + invokeDestroyHook(ch); + if (ch.data.hook && ch.data.hook.remove) { + ch.data.hook.remove(ch, rm); + } else { + rm(); + } + } + } + } + + function updateChildren(parentElm, oldCh, newCh) { + 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, idxInOld, elmToMove; + + while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { + if (isUndef(oldStartVnode)) { + oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left + } else if (isUndef(oldEndVnode)) { + oldEndVnode = oldCh[--oldEndIdx]; + } else if (sameVnode(oldStartVnode, newStartVnode)) { + patchVnode(oldStartVnode, newStartVnode); + oldStartVnode = oldCh[++oldStartIdx]; + newStartVnode = newCh[++newStartIdx]; + } else if (sameVnode(oldEndVnode, newEndVnode)) { + patchVnode(oldEndVnode, newEndVnode); + oldEndVnode = oldCh[--oldEndIdx]; + newEndVnode = newCh[--newEndIdx]; + } else if (sameVnode(oldStartVnode, newEndVnode)) { + // Vnode moved right + patchVnode(oldStartVnode, newEndVnode); + parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling); + oldStartVnode = oldCh[++oldStartIdx]; + newEndVnode = newCh[--newEndIdx]; + } else if (sameVnode(oldEndVnode, newStartVnode)) { + // Vnode moved left + patchVnode(oldEndVnode, newStartVnode); + parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm); + oldEndVnode = oldCh[--oldEndIdx]; + newStartVnode = newCh[++newStartIdx]; + } else { + if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); + idxInOld = oldKeyToIdx[newStartVnode.key]; + if (isUndef(idxInOld)) { + // New element + parentElm.insertBefore(createElm(newStartVnode), oldStartVnode.elm); + newStartVnode = newCh[++newStartIdx]; + } else { + elmToMove = oldCh[idxInOld]; + patchVnode(elmToMove, newStartVnode); + oldCh[idxInOld] = undefined; + parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm); + newStartVnode = newCh[++newStartIdx]; + } + } + } + if (oldStartIdx > oldEndIdx) addVnodes(parentElm, oldStartVnode, newCh, newStartIdx, newEndIdx);else if (newStartIdx > newEndIdx) removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx); + } + + function patchVnode(oldVnode, vnode) { + var i; + if (!isUndef(i = vnode.data) && !isUndef(i = i.hook) && !isUndef(i = i.patch)) { + i = i(oldVnode, vnode); + } + if (!isUndef(i = oldVnode.data) && !isUndef(i = i.vnode)) oldVnode = i; + if (!isUndef(i = vnode.data) && !isUndef(i = i.vnode)) vnode = i; + var elm = vnode.elm = oldVnode.elm, + oldCh = oldVnode.children, + ch = vnode.children; + if (oldVnode === vnode) return; + if (!isUndef(vnode.data)) { + for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode); + i = vnode.data.hook; + if (!isUndef(i) && !isUndef(i = i.update)) i(vnode); + } + if (isUndef(vnode.text)) { + if (!isUndef(oldCh) && !isUndef(ch)) { + if (oldCh !== ch) updateChildren(elm, oldCh, ch); + } else if (!isUndef(ch)) { + addVnodes(elm, undefined, ch, 0, ch.length - 1); + } else if (!isUndef(oldCh)) { + removeVnodes(elm, oldCh, 0, oldCh.length - 1); + } + } else if (oldVnode.text !== vnode.text) { + elm.childNodes[0].nodeValue = vnode.text; + } + return vnode; + } + + return function (oldVnode, vnode) { + var i; + insertedVnodeQueue = []; + if (oldVnode instanceof Element) { + oldVnode = emptyNodeAt(oldVnode); + } + for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i](); + patchVnode(oldVnode, vnode); + for (i = 0; i < insertedVnodeQueue.length; ++i) { + insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]); + } + insertedVnodeQueue = undefined; + for (i = 0; i < cbs.post.length; ++i) cbs.post[i](); + return vnode; + }; +} + +module.exports = { init: init }; + +},{"./is":3,"./vnode":9}],9:[function(require,module,exports){ +"use strict"; + +module.exports = function (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 }; +}; + +},{}]},{},[1]); diff --git a/src/libs/snabbdom/examples/reorder-animation/index.html b/src/libs/snabbdom/examples/reorder-animation/index.html new file mode 100755 index 00000000..0ecc3c48 --- /dev/null +++ b/src/libs/snabbdom/examples/reorder-animation/index.html @@ -0,0 +1,84 @@ + + + + + Reorder animation + + + + +
+ + diff --git a/src/libs/snabbdom/examples/reorder-animation/script.js b/src/libs/snabbdom/examples/reorder-animation/script.js new file mode 100755 index 00000000..214cd176 --- /dev/null +++ b/src/libs/snabbdom/examples/reorder-animation/script.js @@ -0,0 +1,112 @@ +var snabbdom = require('../../snabbdom.js'); +var patch = snabbdom.init([ + require('../../modules/class').default, + require('../../modules/props').default, + require('../../modules/style').default, + require('../../modules/eventlisteners').default, +]); +var h = require('../../h.js').default; + +var vnode; + +var nextKey = 11; +var margin = 8; +var sortBy = 'rank'; +var totalHeight = 0; +var originalData = [ + {rank: 1, title: 'The Shawshank Redemption', desc: 'Two imprisoned men bond over a number of years, finding solace and eventual redemption through acts of common decency.', elmHeight: 0}, + {rank: 2, title: 'The Godfather', desc: 'The aging patriarch of an organized crime dynasty transfers control of his clandestine empire to his reluctant son.', elmHeight: 0}, + {rank: 3, title: 'The Godfather: Part II', desc: 'The early life and career of Vito Corleone in 1920s New York is portrayed while his son, Michael, expands and tightens his grip on his crime syndicate stretching from Lake Tahoe, Nevada to pre-revolution 1958 Cuba.', elmHeight: 0}, + {rank: 4, title: 'The Dark Knight', desc: 'When the menace known as the Joker wreaks havoc and chaos on the people of Gotham, the caped crusader must come to terms with one of the greatest psychological tests of his ability to fight injustice.', elmHeight: 0}, + {rank: 5, title: 'Pulp Fiction', desc: 'The lives of two mob hit men, a boxer, a gangster\'s wife, and a pair of diner bandits intertwine in four tales of violence and redemption.', elmHeight: 0}, + {rank: 6, title: 'Schindler\'s List', desc: 'In Poland during World War II, Oskar Schindler gradually becomes concerned for his Jewish workforce after witnessing their persecution by the Nazis.', elmHeight: 0}, + {rank: 7, title: '12 Angry Men', desc: 'A dissenting juror in a murder trial slowly manages to convince the others that the case is not as obviously clear as it seemed in court.', elmHeight: 0}, + {rank: 8, title: 'The Good, the Bad and the Ugly', desc: 'A bounty hunting scam joins two men in an uneasy alliance against a third in a race to find a fortune in gold buried in a remote cemetery.', elmHeight: 0}, + {rank: 9, title: 'The Lord of the Rings: The Return of the King', desc: 'Gandalf and Aragorn lead the World of Men against Sauron\'s army to draw his gaze from Frodo and Sam as they approach Mount Doom with the One Ring.', elmHeight: 0}, + {rank: 10, title: 'Fight Club', desc: 'An insomniac office worker looking for a way to change his life crosses paths with a devil-may-care soap maker and they form an underground fight club that evolves into something much, much more...', elmHeight: 0}, +]; +var data = [ + originalData[0], + originalData[1], + originalData[2], + originalData[3], + originalData[4], + originalData[5], + originalData[6], + originalData[7], + originalData[8], + originalData[9], +]; + +function changeSort(prop) { + sortBy = prop; + data.sort((a, b) => { + if (a[prop] > b[prop]) { + return 1; + } + if (a[prop] < b[prop]) { + return -1; + } + return 0; + }); + render(); +} + +function add() { + var n = originalData[Math.floor(Math.random() * 10)]; + data = [{rank: nextKey++, title: n.title, desc: n.desc, elmHeight: 0}].concat(data); + render(); + render(); +} + +function remove(movie) { + data = data.filter((m) => { return m !== movie; }); + render(); +} + +function movieView(movie) { + return h('div.row', { + key: movie.rank, + style: {opacity: '0', transform: 'translate(-200px)', + delayed: {transform: `translateY(${movie.offset}px)`, opacity: '1'}, + remove: {opacity: '0', transform: `translateY(${movie.offset}px) translateX(200px)`}}, + hook: {insert: (vnode) => { movie.elmHeight = vnode.elm.offsetHeight; }}, + }, [ + h('div', {style: {fontWeight: 'bold'}}, movie.rank), + h('div', movie.title), + h('div', movie.desc), + h('div.btn.rm-btn', {on: {click: [remove, movie]}}, 'x'), + ]); +} + +function render() { + data = data.reduce((acc, m) => { + var last = acc[acc.length - 1]; + m.offset = last ? last.offset + last.elmHeight + margin : margin; + return acc.concat(m); + }, []); + totalHeight = data[data.length - 1].offset + data[data.length - 1].elmHeight; + vnode = patch(vnode, view(data)); +} + +function view(data) { + return h('div', [ + h('h1', 'Top 10 movies'), + h('div', [ + h('a.btn.add', {on: {click: add}}, 'Add'), + 'Sort by: ', + h('span.btn-group', [ + h('a.btn.rank', {class: {active: sortBy === 'rank'}, on: {click: [changeSort, 'rank']}}, 'Rank'), + h('a.btn.title', {class: {active: sortBy === 'title'}, on: {click: [changeSort, 'title']}}, 'Title'), + h('a.btn.desc', {class: {active: sortBy === 'desc'}, on: {click: [changeSort, 'desc']}}, 'Description'), + ]), + ]), + h('div.list', {style: {height: totalHeight+'px'}}, data.map(movieView)), + ]); +} + +window.addEventListener('DOMContentLoaded', () => { + var container = document.getElementById('container'); + vnode = patch(container, view(data)); + render(); +}); diff --git a/src/libs/snabbdom/examples/svg/build.js b/src/libs/snabbdom/examples/svg/build.js new file mode 100755 index 00000000..4a9a5875 --- /dev/null +++ b/src/libs/snabbdom/examples/svg/build.js @@ -0,0 +1,376 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 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; + elm = vnode.elm = isDef(data) && isDef(i = data.ns) ? document.createElementNS(i, tag) : document.createElement(tag); + if (hash < dot) elm.id = sel.slice(hash + 1, dot); + if (dotIdx > 0) elm.className = sel.slice(dot + 1).replace(/\./g, ' '); + if (is.array(children)) { + for (i = 0; i < children.length; ++i) { + elm.appendChild(createElm(children[i], insertedVnodeQueue)); + } + } else if (is.primitive(vnode.text)) { + elm.appendChild(document.createTextNode(vnode.text)); + } + for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode); + i = vnode.data.hook; // Reuse variable + if (isDef(i)) { + if (i.create) i.create(emptyNode, vnode); + if (i.insert) insertedVnodeQueue.push(vnode); + } + } else { + elm = vnode.elm = document.createTextNode(vnode.text); + } + return vnode.elm; + } + + function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) { + for (; startIdx <= endIdx; ++startIdx) { + parentElm.insertBefore(createElm(vnodes[startIdx], insertedVnodeQueue), before); + } + } + + function invokeDestroyHook(vnode) { + var i = vnode.data, + j; + if (isDef(i)) { + if (isDef(i = i.hook) && isDef(i = i.destroy)) i(vnode); + for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode); + if (isDef(i = vnode.children)) { + for (j = 0; j < vnode.children.length; ++j) { + invokeDestroyHook(vnode.children[j]); + } + } + } + } + + function removeVnodes(parentElm, vnodes, startIdx, endIdx) { + for (; startIdx <= endIdx; ++startIdx) { + var i, + listeners, + rm, + ch = vnodes[startIdx]; + if (isDef(ch)) { + if (isDef(ch.sel)) { + invokeDestroyHook(ch); + listeners = cbs.remove.length + 1; + rm = createRmCb(ch.elm, listeners); + for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm); + if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) { + i(ch, rm); + } else { + rm(); + } + } else { + // Text node + parentElm.removeChild(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, idxInOld, elmToMove, before; + + while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { + if (isUndef(oldStartVnode)) { + oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left + } else if (isUndef(oldEndVnode)) { + oldEndVnode = oldCh[--oldEndIdx]; + } 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)) { + // Vnode moved right + patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue); + parentElm.insertBefore(oldStartVnode.elm, oldEndVnode.elm.nextSibling); + oldStartVnode = oldCh[++oldStartIdx]; + newEndVnode = newCh[--newEndIdx]; + } else if (sameVnode(oldEndVnode, newStartVnode)) { + // Vnode moved left + patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue); + parentElm.insertBefore(oldEndVnode.elm, oldStartVnode.elm); + oldEndVnode = oldCh[--oldEndIdx]; + newStartVnode = newCh[++newStartIdx]; + } else { + if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); + idxInOld = oldKeyToIdx[newStartVnode.key]; + if (isUndef(idxInOld)) { + // New element + parentElm.insertBefore(createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm); + newStartVnode = newCh[++newStartIdx]; + } else { + elmToMove = oldCh[idxInOld]; + patchVnode(elmToMove, newStartVnode, insertedVnodeQueue); + oldCh[idxInOld] = undefined; + parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm); + newStartVnode = newCh[++newStartIdx]; + } + } + } + if (oldStartIdx > oldEndIdx) { + before = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm; + addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue); + } else if (newStartIdx > newEndIdx) { + 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); + } + if (isDef(i = oldVnode.data) && isDef(i = i.vnode)) oldVnode = i; + if (isDef(i = vnode.data) && isDef(i = i.vnode)) vnode = i; + var elm = vnode.elm = oldVnode.elm, + oldCh = oldVnode.children, + ch = vnode.children; + if (oldVnode === vnode) return; + if (isDef(vnode.data)) { + 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)) { + addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue); + } else if (isDef(oldCh)) { + removeVnodes(elm, oldCh, 0, oldCh.length - 1); + } + } else if (oldVnode.text !== vnode.text) { + elm.textContent = vnode.text; + } + if (isDef(hook) && isDef(i = hook.postpatch)) { + i(oldVnode, vnode); + } + } + + return function (oldVnode, vnode) { + var i; + var insertedVnodeQueue = []; + for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i](); + if (oldVnode instanceof Element) { + if (oldVnode.parentElement !== null) { + createElm(vnode, insertedVnodeQueue); + oldVnode.parentElement.replaceChild(vnode.elm, oldVnode); + } else { + oldVnode = emptyNodeAt(oldVnode); + patchVnode(oldVnode, vnode, insertedVnodeQueue); + } + } else { + patchVnode(oldVnode, vnode, insertedVnodeQueue); + } + 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; + }; +} + +module.exports = { init: init }; + +},{"./is":3,"./vnode":6}],6:[function(require,module,exports){ +"use strict"; + +module.exports = function (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 }; +}; + +},{}]},{},[1]); diff --git a/src/libs/snabbdom/examples/svg/index.html b/src/libs/snabbdom/examples/svg/index.html new file mode 100755 index 00000000..2f9d1a04 --- /dev/null +++ b/src/libs/snabbdom/examples/svg/index.html @@ -0,0 +1,84 @@ + + + + + SVG + + + + +
+ + diff --git a/src/libs/snabbdom/examples/svg/script.js b/src/libs/snabbdom/examples/svg/script.js new file mode 100755 index 00000000..6c478259 --- /dev/null +++ b/src/libs/snabbdom/examples/svg/script.js @@ -0,0 +1,17 @@ +var snabbdom = require('../../snabbdom.js'); +var patch = snabbdom.init([ + require('../../modules/attributes').default, +]); +var h = require('../../h.js').default; + +var vnode; + +window.addEventListener('DOMContentLoaded', () => { + var container = document.getElementById('container'); + var vnode = h('div', [ + h('svg', {attrs: {width: 100, height: 100}}, [ + h('circle', {attrs: {cx: 50, cy: 50, r: 40, stroke: 'green', 'stroke-width': 4, fill: 'yellow'}}) + ]) + ]); + vnode = patch(container, vnode); +}); diff --git a/src/libs/snabbdom/gulpfile.js b/src/libs/snabbdom/gulpfile.js new file mode 100755 index 00000000..ee6b8554 --- /dev/null +++ b/src/libs/snabbdom/gulpfile.js @@ -0,0 +1,82 @@ +var gulp = require('gulp') +var clean = require('gulp-clean') +var uglify = require('gulp-uglify') +var rename = require('gulp-rename') +var sourcemaps = require('gulp-sourcemaps') +var browserify = require('browserify') +var fs = require('fs') + +function standalone(name, entry, exportName) { + return browserify(entry, { debug: true, standalone: exportName || name }) + .bundle() + .pipe(fs.createWriteStream('./dist/'+ name.replace(/_/g, '-') +'.js')) +} + +gulp.task('bundle:snabbdom', function() { + return standalone('snabbdom_patch', './snabbdom.bundle.js', 'snabbdom') +}) + +gulp.task('bundle:snabbdom:init', function() { + return standalone('snabbdom', './snabbdom.js') +}) + +gulp.task('bundle:snabbdom:h', function() { + return standalone('h', './h.js') +}) + +gulp.task('bundle:snabbdom:tovnode', function() { + return standalone('tovnode', './tovnode.js') +}) + +gulp.task('bundle:module:class', function() { + return standalone('snabbdom_class', './modules/class.js') +}) + +gulp.task('bundle:module:dataset', function() { + return standalone('snabbdom_dataset', './modules/dataset.js') +}) + +gulp.task('bundle:module:props', function() { + return standalone('snabbdom_props', './modules/props.js') +}) + +gulp.task('bundle:module:attributes', function() { + return standalone('snabbdom_attributes', './modules/attributes.js') +}) + +gulp.task('bundle:module:style', function() { + return standalone('snabbdom_style', './modules/style.js') +}) + +gulp.task('bundle:module:eventlisteners', function() { + return standalone('snabbdom_eventlisteners', './modules/eventlisteners.js') +}) + +gulp.task('bundle', [ + 'bundle:snabbdom', + 'bundle:snabbdom:init', + 'bundle:snabbdom:h', + 'bundle:snabbdom:tovnode', + 'bundle:module:attributes', + 'bundle:module:class', + 'bundle:module:dataset', + 'bundle:module:props', + 'bundle:module:style', + 'bundle:module:eventlisteners' +]) + +gulp.task('compress', ['bundle'], function() { + return gulp.src(['dist/*.js', '!dist/*.min.js']) + .pipe(sourcemaps.init()) + .pipe(uglify()) + .pipe(rename({ suffix: '.min' })) + .pipe(sourcemaps.write('.')) + .pipe(gulp.dest('dist')) +}) + +gulp.task('clean', function() { + return gulp.src('dist/*.*', {read: false}) + .pipe(clean()) +}) + +gulp.task('default', ['bundle']) diff --git a/src/libs/snabbdom/karma.conf.js b/src/libs/snabbdom/karma.conf.js new file mode 100755 index 00000000..00160eea --- /dev/null +++ b/src/libs/snabbdom/karma.conf.js @@ -0,0 +1,66 @@ +const ci = !!process.env.CI; +const watch = !!process.env.WATCH; +const live = !!process.env.LIVE; + +const identifier = process.env.BROWSERSTACK_LOCAL_IDENTIFIER; +const ip = process.env.IP_ADDR; + +const browserstack = require('./browserstack-karma.js'); + +const browsers = ci + ? Object.keys(browserstack) + : live + ? undefined + : watch + ? ['Chrome'] + : ['Chrome', 'Firefox']; + +module.exports = function(config) { + config.set({ + basePath: '.', + frameworks: ['mocha', 'karma-typescript'], + // list of files / patterns to load in the browser + files: [{pattern: 'src/**/*.ts'}, {pattern: 'test/**/*'}], + plugins: [ + 'karma-mocha', + 'karma-chrome-launcher', + 'karma-firefox-launcher', + 'karma-browserstack-launcher', + 'karma-typescript', + ], + hostname: ci ? ip : 'localhost', + preprocessors: { + 'src/**/*.ts': ['karma-typescript'], + 'test/**/*.js': ['karma-typescript'], + }, + browserStack: { + name: 'Snabbdom', + startTunnel: false, + retryLimit: 3, + tunnelIdentifier: identifier, + }, + browserNoActivityTimeout: 1000000, + customLaunchers: browserstack, + karmaTypescriptConfig: { + coverageOptions: { + exclude: /test\//, + }, + compilerOptions: { + allowJs: true, + declaration: false + }, + tsconfig: './tsconfig.json', + include: { + mode: 'merge', + values: ['test/**/*'], + }, + }, + reporters: ['dots', 'karma-typescript', 'BrowserStack'], + port: 9876, + colors: true, + autoWatch: true, + browsers: browsers, + singleRun: !watch && !live, + concurrency: ci ? 1 : Infinity, + }); +} diff --git a/src/libs/snabbdom/package.json b/src/libs/snabbdom/package.json new file mode 100755 index 00000000..cc426a81 --- /dev/null +++ b/src/libs/snabbdom/package.json @@ -0,0 +1,60 @@ +{ + "name": "snabbdom", + "version": "0.7.3", + "description": "A virtual DOM library with focus on simplicity, modularity, powerful features and performance.", + "main": "snabbdom.js", + "module": "es/snabbdom.js", + "typings": "snabbdom.d.ts", + "directories": { + "example": "examples", + "test": "test" + }, + "devDependencies": { + "benchmark": "^2.1.4", + "browserify": "^14.4.0", + "fake-raf": "1.0.1", + "gulp": "^3.9.1", + "gulp-clean": "^0.3.2", + "gulp-rename": "^1.2.2", + "gulp-sourcemaps": "^2.6.0", + "gulp-uglify": "^3.0.0", + "karma": "^3.0.0", + "karma-browserstack-launcher": "^1.3.0", + "karma-chrome-launcher": "^2.2.0", + "karma-firefox-launcher": "^1.1.0", + "karma-mocha": "^1.3.0", + "karma-typescript": "^3.0.13", + "knuth-shuffle": "^1.0.1", + "mocha": "^5.2.0", + "typescript": "^3.0.3", + "xyz": "2.1.0" + }, + "scripts": { + "pretest": "npm run compile", + "test": "testem", + "compile": "npm run compile-es && npm run compile-commonjs", + "compile-es": "tsc --outDir es --module es6 --moduleResolution node", + "compile-commonjs": "tsc --outDir ./", + "prepublish": "npm run compile", + "release-major": "xyz --repo git@github.com:paldepind/snabbdom.git --increment major", + "release-minor": "xyz --repo git@github.com:paldepind/snabbdom.git --increment minor", + "release-patch": "xyz --repo git@github.com:paldepind/snabbdom.git --increment patch" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/paldepind/snabbdom.git" + }, + "keywords": [ + "virtual", + "dom", + "light", + "kiss", + "performance" + ], + "author": "Simon Friis Vindum", + "license": "MIT", + "bugs": { + "url": "https://github.com/paldepind/snabbdom/issues" + }, + "homepage": "https://github.com/paldepind/snabbdom#readme" +} diff --git a/src/libs/snabbdom/perf/benchmarks.js b/src/libs/snabbdom/perf/benchmarks.js new file mode 100755 index 00000000..ac3fc90b --- /dev/null +++ b/src/libs/snabbdom/perf/benchmarks.js @@ -0,0 +1,58 @@ +var Benchmark = require('benchmark'); +var a = require('../snabbdom.js'); +var b = require('../oldsnabbdom.js'); + +global.a = a; +global.b = b; + +var suite = new Benchmark.Suite(); + +a.spanNum = function spanNum(n) { + return a.h('span', {key: n}, n.toString()); +}; + +b.spanNum = function spanNum(n) { + return b.h('span', {key: n}, n.toString()); +}; + +var elms = global.elms = 10; +var arr = global.arr = []; +for (var n = 0; n < elms; ++n) { arr[n] = n; } + +document.addEventListener('DOMContentLoaded', function() { + var elm = global.elm = document.getElementById('container'); + // add tests + suite.add('a/ insert first', { + setup: function() { + var vnode1 = a.h('div', arr.map(a.spanNum)); + var vnode2 = a.h('div', ['new'].concat(arr).map(a.spanNum)); + }, + fn: function() { + var emptyNode = a.emptyNodeAt(elm); + a.patch(emptyNode, vnode1); + a.patch(vnode1, vnode2); + a.patch(vnode2, a.emptyNode); + }, + }) + .add('b/ insert first', { + setup: function() { + var vnode1 = b.h('div', arr.map(b.spanNum)); + var vnode2 = b.h('div', ['new'].concat(arr).map(b.spanNum)); + }, + fn: function() { + var emptyNode = b.emptyNodeAt(elm); + b.patch(emptyNode, vnode1); + b.patch(vnode1, vnode2); + b.patch(vnode2, b.emptyNode); + }, + }) + // add listeners + .on('cycle', function(event) { + console.log(String(event.target)); + }) + .on('complete', function() { + console.log('Fastest is ' + this.filter('fastest').pluck('name')); + }) + // run async + .run({async: true}); +}); diff --git a/src/libs/snabbdom/perf/index.html b/src/libs/snabbdom/perf/index.html new file mode 100755 index 00000000..07217446 --- /dev/null +++ b/src/libs/snabbdom/perf/index.html @@ -0,0 +1,12 @@ + + + + + Snabbdom benchmarks + + + +

See console

+
+ + diff --git a/src/libs/snabbdom/src/h.ts b/src/libs/snabbdom/src/h.ts new file mode 100755 index 00000000..9b9886c2 --- /dev/null +++ b/src/libs/snabbdom/src/h.ts @@ -0,0 +1,50 @@ +import {vnode, VNode, VNodeData} from './vnode'; +export type VNodes = Array; +export type VNodeChildElement = VNode | string | number | undefined | null; +export type ArrayOrElement = T | T[]; +export type VNodeChildren = ArrayOrElement +import * as is from './is'; + +function addNS(data: any, children: VNodes | undefined, sel: string | undefined): void { + data.ns = 'http://www.w3.org/2000/svg'; + if (sel !== 'foreignObject' && children !== undefined) { + for (let i = 0; i < children.length; ++i) { + let childData = children[i].data; + if (childData !== undefined) { + addNS(childData, (children[i] as VNode).children as VNodes, children[i].sel); + } + } + } +} + +export function h(sel: string): VNode; +export function h(sel: string, data: VNodeData): VNode; +export function h(sel: string, children: VNodeChildren): VNode; +export function h(sel: string, data: VNodeData, children: VNodeChildren): VNode; +export function h(sel: any, b?: any, c?: any): VNode { + var data: VNodeData = {}, children: any, text: any, i: number; + if (c !== undefined) { + data = b; + if (is.array(c)) { children = c; } + else if (is.primitive(c)) { text = c; } + else if (c && c.sel) { children = [c]; } + } else if (b !== undefined) { + if (is.array(b)) { children = b; } + else if (is.primitive(b)) { text = b; } + else if (b && b.sel) { children = [b]; } + else { data = b; } + } + if (children !== undefined) { + for (i = 0; i < children.length; ++i) { + if (is.primitive(children[i])) children[i] = vnode(undefined, undefined, undefined, children[i], undefined); + } + } + if ( + sel[0] === 's' && sel[1] === 'v' && sel[2] === 'g' && + (sel.length === 3 || sel[3] === '.' || sel[3] === '#') + ) { + addNS(data, children, sel); + } + return vnode(sel, data, children, text, undefined); +}; +export default h; diff --git a/src/libs/snabbdom/src/helpers/attachto.ts b/src/libs/snabbdom/src/helpers/attachto.ts new file mode 100755 index 00000000..77f81c58 --- /dev/null +++ b/src/libs/snabbdom/src/helpers/attachto.ts @@ -0,0 +1,64 @@ +import {VNode, VNodeData} from '../vnode'; + +export interface AttachData { + [key: string]: any + [i: number]: any + placeholder?: any + real?: Node +} + +interface VNodeDataWithAttach extends VNodeData { + attachData: AttachData +} + +interface VNodeWithAttachData extends VNode { + data: VNodeDataWithAttach +} + +function pre(vnode: VNodeWithAttachData, newVnode: VNodeWithAttachData): void { + const attachData = vnode.data.attachData; + // Copy created placeholder and real element from old vnode + newVnode.data.attachData.placeholder = attachData.placeholder; + newVnode.data.attachData.real = attachData.real; + // Mount real element in vnode so the patch process operates on it + vnode.elm = vnode.data.attachData.real; +} + +function post(_: any, vnode: VNodeWithAttachData): void { + // Mount dummy placeholder in vnode so potential reorders use it + vnode.elm = vnode.data.attachData.placeholder; +} + +function destroy(vnode: VNodeWithAttachData): void { + // Remove placeholder + if (vnode.elm !== undefined) { + (vnode.elm.parentNode as HTMLElement).removeChild(vnode.elm); + } + // Remove real element from where it was inserted + vnode.elm = vnode.data.attachData.real; +} + +function create(_: any, vnode: VNodeWithAttachData): void { + const real = vnode.elm, attachData = vnode.data.attachData; + const placeholder = document.createElement('span'); + // Replace actual element with dummy placeholder + // Snabbdom will then insert placeholder instead + vnode.elm = placeholder; + attachData.target.appendChild(real); + attachData.real = real; + attachData.placeholder = placeholder; +} + +export function attachTo(target: Element, vnode: VNode): VNode { + if (vnode.data === undefined) vnode.data = {}; + if (vnode.data.hook === undefined) vnode.data.hook = {}; + const data = vnode.data; + const hook = vnode.data.hook; + data.attachData = {target: target, placeholder: undefined, real: undefined}; + hook.create = create; + hook.prepatch = pre; + hook.postpatch = post; + hook.destroy = destroy; + return vnode; +}; +export default attachTo; diff --git a/src/libs/snabbdom/src/hooks.ts b/src/libs/snabbdom/src/hooks.ts new file mode 100755 index 00000000..4b3965d8 --- /dev/null +++ b/src/libs/snabbdom/src/hooks.ts @@ -0,0 +1,25 @@ +import {VNode} from './vnode'; + +export type PreHook = () => any; +export type InitHook = (vNode: VNode) => any; +export type CreateHook = (emptyVNode: VNode, vNode: VNode) => any; +export type InsertHook = (vNode: VNode) => any; +export type PrePatchHook = (oldVNode: VNode, vNode: VNode) => any; +export type UpdateHook = (oldVNode: VNode, vNode: VNode) => any; +export type PostPatchHook = (oldVNode: VNode, vNode: VNode) => any; +export type DestroyHook = (vNode: VNode) => any; +export type RemoveHook = (vNode: VNode, removeCallback: () => void) => any; +export type PostHook = () => any; + +export interface Hooks { + pre?: PreHook; + init?: InitHook; + create?: CreateHook; + insert?: InsertHook; + prepatch?: PrePatchHook; + update?: UpdateHook; + postpatch?: PostPatchHook; + destroy?: DestroyHook; + remove?: RemoveHook; + post?: PostHook; +} diff --git a/src/libs/snabbdom/src/htmldomapi.ts b/src/libs/snabbdom/src/htmldomapi.ts new file mode 100755 index 00000000..f17fc4af --- /dev/null +++ b/src/libs/snabbdom/src/htmldomapi.ts @@ -0,0 +1,97 @@ +export interface DOMAPI { + createElement: (tagName: any) => HTMLElement; + createElementNS: (namespaceURI: string, qualifiedName: string) => Element; + createTextNode: (text: string) => Text; + createComment: (text: string) => Comment; + insertBefore: (parentNode: Node, newNode: Node, referenceNode: Node | null) => void; + removeChild: (node: Node, child: Node) => void; + appendChild: (node: Node, child: Node) => void; + parentNode: (node: Node) => Node; + nextSibling: (node: Node) => Node; + tagName: (elm: Element) => string; + setTextContent: (node: Node, text: string | null) => void; + getTextContent: (node: Node) => string | null; + isElement: (node: Node) => node is Element; + isText: (node: Node) => node is Text; + isComment: (node: Node) => node is Comment; +} + +function createElement(tagName: any): HTMLElement { + return document.createElement(tagName); +} + +function createElementNS(namespaceURI: string, qualifiedName: string): Element { + return document.createElementNS(namespaceURI, qualifiedName); +} + +function createTextNode(text: string): Text { + return document.createTextNode(text); +} + +function createComment(text: string): Comment { + return document.createComment(text); +} + +function insertBefore(parentNode: Node, newNode: Node, referenceNode: Node | null): void { + parentNode.insertBefore(newNode, referenceNode); +} + +function removeChild(node: Node, child: Node): void { + node.removeChild(child); +} + +function appendChild(node: Node, child: Node): void { + node.appendChild(child); +} + +function parentNode(node: Node): Node | null { + return node.parentNode; +} + +function nextSibling(node: Node): Node | null { + return node.nextSibling; +} + +function tagName(elm: Element): string { + return elm.tagName; +} + +function setTextContent(node: Node, text: string | null): void { + node.textContent = text; +} + +function getTextContent(node: Node): string | null { + return node.textContent; +} + +function isElement(node: Node): node is Element { + return node.nodeType === 1; +} + +function isText(node: Node): node is Text { + return node.nodeType === 3; +} + +function isComment(node: Node): node is Comment { + return node.nodeType === 8; +} + +export const htmlDomApi = { + createElement, + createElementNS, + createTextNode, + createComment, + insertBefore, + removeChild, + appendChild, + parentNode, + nextSibling, + tagName, + setTextContent, + getTextContent, + isElement, + isText, + isComment, +} as DOMAPI; + +export default htmlDomApi; diff --git a/src/libs/snabbdom/src/is.ts b/src/libs/snabbdom/src/is.ts new file mode 100755 index 00000000..9f7ef1ff --- /dev/null +++ b/src/libs/snabbdom/src/is.ts @@ -0,0 +1,4 @@ +export const array = Array.isArray; +export function primitive(s: any): s is (string | number) { + return typeof s === 'string' || typeof s === 'number'; +} diff --git a/src/libs/snabbdom/src/modules/attributes.ts b/src/libs/snabbdom/src/modules/attributes.ts new file mode 100755 index 00000000..47612e8c --- /dev/null +++ b/src/libs/snabbdom/src/modules/attributes.ts @@ -0,0 +1,64 @@ +import {VNode, VNodeData} from '../vnode'; +import {Module} from './module'; + +// because those in TypeScript are too restrictive: https://github.com/Microsoft/TSJS-lib-generator/pull/237 +declare global { + interface Element { + setAttribute(name: string, value: string | number | boolean): void; + setAttributeNS(namespaceURI: string, qualifiedName: string, value: string | number | boolean): void; + } +} + +export type Attrs = Record + +const xlinkNS = 'http://www.w3.org/1999/xlink'; +const xmlNS = 'http://www.w3.org/XML/1998/namespace'; +const colonChar = 58; +const xChar = 120; + +function updateAttrs(oldVnode: VNode, vnode: VNode): void { + var key: string, elm: Element = vnode.elm as Element, + oldAttrs = (oldVnode.data as VNodeData).attrs, + attrs = (vnode.data as VNodeData).attrs; + + if (!oldAttrs && !attrs) return; + if (oldAttrs === attrs) return; + oldAttrs = oldAttrs || {}; + attrs = attrs || {}; + + // update modified attributes, add new attributes + for (key in attrs) { + const cur = attrs[key]; + const old = oldAttrs[key]; + if (old !== cur) { + if (cur === true) { + elm.setAttribute(key, ""); + } else if (cur === false) { + elm.removeAttribute(key); + } else { + if (key.charCodeAt(0) !== xChar) { + elm.setAttribute(key, cur); + } else if (key.charCodeAt(3) === colonChar) { + // Assume xml namespace + elm.setAttributeNS(xmlNS, key, cur); + } else if (key.charCodeAt(5) === colonChar) { + // Assume xlink namespace + elm.setAttributeNS(xlinkNS, key, cur); + } else { + elm.setAttribute(key, cur); + } + } + } + } + // remove removed attributes + // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value) + // the other option is to remove all attributes with value == undefined + for (key in oldAttrs) { + if (!(key in attrs)) { + elm.removeAttribute(key); + } + } +} + +export const attributesModule = {create: updateAttrs, update: updateAttrs} as Module; +export default attributesModule; diff --git a/src/libs/snabbdom/src/modules/class.ts b/src/libs/snabbdom/src/modules/class.ts new file mode 100755 index 00000000..dcdfa590 --- /dev/null +++ b/src/libs/snabbdom/src/modules/class.ts @@ -0,0 +1,30 @@ +import {VNode, VNodeData} from '../vnode'; +import {Module} from './module'; + +export type Classes = Record + +function updateClass(oldVnode: VNode, vnode: VNode): void { + var cur: any, name: string, elm: Element = vnode.elm as Element, + oldClass = (oldVnode.data as VNodeData).class, + klass = (vnode.data as VNodeData).class; + + if (!oldClass && !klass) return; + if (oldClass === klass) return; + oldClass = oldClass || {}; + klass = klass || {}; + + for (name in oldClass) { + if (!klass[name]) { + elm.classList.remove(name); + } + } + for (name in klass) { + cur = klass[name]; + if (cur !== oldClass[name]) { + (elm.classList as any)[cur ? 'add' : 'remove'](name); + } + } +} + +export const classModule = {create: updateClass, update: updateClass} as Module; +export default classModule; diff --git a/src/libs/snabbdom/src/modules/dataset.ts b/src/libs/snabbdom/src/modules/dataset.ts new file mode 100755 index 00000000..a49204b6 --- /dev/null +++ b/src/libs/snabbdom/src/modules/dataset.ts @@ -0,0 +1,43 @@ +import {VNode, VNodeData} from '../vnode'; +import {Module} from './module'; + +export type Dataset = Record; + +const CAPS_REGEX = /[A-Z]/g; + +function updateDataset(oldVnode: VNode, vnode: VNode): void { + let elm: HTMLElement = vnode.elm as HTMLElement, + oldDataset = (oldVnode.data as VNodeData).dataset, + dataset = (vnode.data as VNodeData).dataset, + key: string; + + if (!oldDataset && !dataset) return; + if (oldDataset === dataset) return; + oldDataset = oldDataset || {}; + dataset = dataset || {}; + const 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 const datasetModule = {create: updateDataset, update: updateDataset} as Module; +export default datasetModule; diff --git a/src/libs/snabbdom/src/modules/eventlisteners.ts b/src/libs/snabbdom/src/modules/eventlisteners.ts new file mode 100755 index 00000000..d32cc466 --- /dev/null +++ b/src/libs/snabbdom/src/modules/eventlisteners.ts @@ -0,0 +1,111 @@ +import {VNode, VNodeData} from '../vnode'; +import {Module} from './module'; + +export type On = { + [N in keyof HTMLElementEventMap]?: (ev: HTMLElementEventMap[N]) => void +} & { + [event: string]: EventListener +}; + +function invokeHandler(handler: any, vnode?: VNode, event?: Event): void { + 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], vnode, event); + } + } + } +} + +function handleEvent(event: Event, vnode: VNode) { + var name = event.type, + on = (vnode.data as VNodeData).on; + + // call event handler(s) if exists + if (on && on[name]) { + invokeHandler(on[name], vnode, event); + } +} + +function createListener() { + return function handler(event: Event) { + handleEvent(event, (handler as any).vnode); + } +} + +function updateEventListeners(oldVnode: VNode, vnode?: VNode): void { + var oldOn = (oldVnode.data as VNodeData).on, + oldListener = (oldVnode as any).listener, + oldElm: Element = oldVnode.elm as Element, + on = vnode && (vnode.data as VNodeData).on, + elm: Element = (vnode && vnode.elm) as Element, + name: string; + + // 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 as any).listener = (oldVnode as any).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 const eventListenersModule = { + create: updateEventListeners, + update: updateEventListeners, + destroy: updateEventListeners +} as Module; +export default eventListenersModule; diff --git a/src/libs/snabbdom/src/modules/hero.ts b/src/libs/snabbdom/src/modules/hero.ts new file mode 100755 index 00000000..3a8274d7 --- /dev/null +++ b/src/libs/snabbdom/src/modules/hero.ts @@ -0,0 +1,165 @@ +import {VNode, VNodeData} from '../vnode'; +import {Module} from './module'; + +export type Hero = { id: string } + +var raf = (typeof window !== 'undefined' && window.requestAnimationFrame) || setTimeout; +var nextFrame = function(fn: any) { raf(function() { raf(fn); }); }; + +function setNextFrame(obj: any, prop: string, val: any): void { + nextFrame(function() { obj[prop] = val; }); +} + +function getTextNodeRect(textNode: Text): ClientRect | undefined { + var rect: ClientRect | undefined; + if (document.createRange) { + var range = document.createRange(); + range.selectNodeContents(textNode); + if (range.getBoundingClientRect) { + rect = range.getBoundingClientRect(); + } + } + return rect; +} + +function calcTransformOrigin(isTextNode: boolean, + textRect: ClientRect | undefined, + boundingRect: ClientRect): string { + 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: ClientRect | undefined, + newTextRect: ClientRect | undefined): number { + if (oldTextRect && newTextRect) { + return ((oldTextRect.left + oldTextRect.width/2) - (newTextRect.left + newTextRect.width/2)); + } + return 0; +} +function getTextDy(oldTextRect: ClientRect | undefined, + newTextRect: ClientRect | undefined): number { + if (oldTextRect && newTextRect) { + return ((oldTextRect.top + oldTextRect.height/2) - (newTextRect.top + newTextRect.height/2)); + } + return 0; +} + +function isTextElement(elm: Element | Text): elm is Text { + return elm.childNodes.length === 1 && elm.childNodes[0].nodeType === 3; +} + +var removed: any, created: any; + +function pre() { + removed = {}; + created = []; +} + +function create(oldVnode: VNode, vnode: VNode): void { + var hero = (vnode.data as VNodeData).hero; + if (hero && hero.id) { + created.push(hero.id); + created.push(vnode); + } +} + +function destroy(vnode: VNode): void { + var hero = (vnode.data as VNodeData).hero; + if (hero && hero.id) { + var elm = vnode.elm; + (vnode as any).isTextNode = isTextElement(elm as Element | Text); //is this a text node? + (vnode as any).boundingRect = (elm as Element).getBoundingClientRect(); //save the bounding rectangle to a new property on the vnode + (vnode as any).textRect = (vnode as any).isTextNode ? getTextNodeRect((elm as Element).childNodes[0] as Text) : null; //save bounding rect of inner text node + var computedStyle = window.getComputedStyle(elm as Element, void 0); //get current styles (includes inherited properties) + (vnode as any).savedStyle = JSON.parse(JSON.stringify(computedStyle)); //save a copy of computed style values + removed[hero.id] = vnode; + } +} + +function post() { + var i: number, id: any, newElm: Element, oldVnode: VNode, oldElm: Element, + hRatio: number, wRatio: number, + oldRect: ClientRect, newRect: ClientRect, dx: number, dy: number, + origTransform: string | null, origTransition: string | null, + newStyle: CSSStyleDeclaration, oldStyle: CSSStyleDeclaration, + newComputedStyle: CSSStyleDeclaration, isTextNode: boolean, + newTextRect: ClientRect | undefined, oldTextRect: ClientRect | undefined; + for (i = 0; i < created.length; i += 2) { + id = created[i]; + newElm = created[i+1].elm; + oldVnode = removed[id]; + if (oldVnode) { + isTextNode = (oldVnode as any).isTextNode && isTextElement(newElm); //Are old & new both text? + newStyle = (newElm as HTMLElement).style; + newComputedStyle = window.getComputedStyle(newElm, void 0); //get full computed style for new element + oldElm = oldVnode.elm as Element; + oldStyle = (oldElm as HTMLElement).style; + //Overall element bounding boxes + newRect = newElm.getBoundingClientRect(); + oldRect = (oldVnode as any).boundingRect; //previously saved bounding rect + //Text node bounding boxes & distances + if (isTextNode) { + newTextRect = getTextNodeRect(newElm.childNodes[0] as Text); + oldTextRect = (oldVnode as any).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') //inline elements cannot be transformed + 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 as any).savedStyle) { //re-apply saved inherited properties + if (parseInt(key) != key as any as number) { + 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) //ignore prefixed style properties + (oldStyle as any)[key] = (oldVnode as any).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: TransitionEvent) { + if (ev.propertyName === 'transform') + document.body.removeChild(ev.target as Node); + }); + } + } + removed = created = undefined; +} + +export const heroModule = {pre, create, destroy, post} as Module; +export default heroModule; \ No newline at end of file diff --git a/src/libs/snabbdom/src/modules/module.ts b/src/libs/snabbdom/src/modules/module.ts new file mode 100755 index 00000000..256d8ba6 --- /dev/null +++ b/src/libs/snabbdom/src/modules/module.ts @@ -0,0 +1,10 @@ +import {PreHook, CreateHook, UpdateHook, DestroyHook, RemoveHook, PostHook} from '../hooks'; + +export interface Module { + pre: PreHook; + create: CreateHook; + update: UpdateHook; + destroy: DestroyHook; + remove: RemoveHook; + post: PostHook; +} \ No newline at end of file diff --git a/src/libs/snabbdom/src/modules/props.ts b/src/libs/snabbdom/src/modules/props.ts new file mode 100755 index 00000000..ef572e05 --- /dev/null +++ b/src/libs/snabbdom/src/modules/props.ts @@ -0,0 +1,31 @@ +import {VNode, VNodeData} from '../vnode'; +import {Module} from './module'; + +export type Props = Record; + +function updateProps(oldVnode: VNode, vnode: VNode): void { + var key: string, cur: any, old: any, elm = vnode.elm, + oldProps = (oldVnode.data as VNodeData).props, + props = (vnode.data as VNodeData).props; + + if (!oldProps && !props) return; + if (oldProps === props) return; + oldProps = oldProps || {}; + props = props || {}; + + for (key in oldProps) { + if (!props[key]) { + delete (elm as any)[key]; + } + } + for (key in props) { + cur = props[key]; + old = oldProps[key]; + if (old !== cur && (key !== 'value' || (elm as any)[key] !== cur)) { + (elm as any)[key] = cur; + } + } +} + +export const propsModule = {create: updateProps, update: updateProps} as Module; +export default propsModule; \ No newline at end of file diff --git a/src/libs/snabbdom/src/modules/style.ts b/src/libs/snabbdom/src/modules/style.ts new file mode 100755 index 00000000..763d4bea --- /dev/null +++ b/src/libs/snabbdom/src/modules/style.ts @@ -0,0 +1,103 @@ +import {VNode, VNodeData} from '../vnode'; +import {Module} from './module'; + +export type VNodeStyle = Record & { + delayed?: Record + remove?: Record +} + +// Bindig `requestAnimationFrame` like this fixes a bug in IE/Edge. See #360 and #409. +var raf = (typeof window !== 'undefined' && (window.requestAnimationFrame).bind(window)) || setTimeout; +var nextFrame = function(fn: any) { raf(function() { raf(fn); }); }; +var reflowForced = false; + +function setNextFrame(obj: any, prop: string, val: any): void { + nextFrame(function() { obj[prop] = val; }); +} + +function updateStyle(oldVnode: VNode, vnode: VNode): void { + var cur: any, name: string, elm = vnode.elm, + oldStyle = (oldVnode.data as VNodeData).style, + style = (vnode.data as VNodeData).style; + + if (!oldStyle && !style) return; + if (oldStyle === style) return; + oldStyle = oldStyle || {} as VNodeStyle; + style = style || {} as VNodeStyle; + var oldHasDel = 'delayed' in oldStyle; + + for (name in oldStyle) { + if (!style[name]) { + if (name[0] === '-' && name[1] === '-') { + (elm as any).style.removeProperty(name); + } else { + (elm as any).style[name] = ''; + } + } + } + for (name in style) { + cur = style[name]; + if (name === 'delayed' && style.delayed) { + for (let name2 in style.delayed) { + cur = style.delayed[name2]; + if (!oldHasDel || cur !== (oldStyle.delayed as any)[name2]) { + setNextFrame((elm as any).style, name2, cur); + } + } + } else if (name !== 'remove' && cur !== oldStyle[name]) { + if (name[0] === '-' && name[1] === '-') { + (elm as any).style.setProperty(name, cur); + } else { + (elm as any).style[name] = cur; + } + } + } +} + +function applyDestroyStyle(vnode: VNode): void { + var style: any, name: string, elm = vnode.elm, s = (vnode.data as VNodeData).style; + if (!s || !(style = s.destroy)) return; + for (name in style) { + (elm as any).style[name] = style[name]; + } +} + +function applyRemoveStyle(vnode: VNode, rm: () => void): void { + var s = (vnode.data as VNodeData).style; + if (!s || !s.remove) { + rm(); + return; + } + if(!reflowForced) { + getComputedStyle(document.body).transform; + reflowForced = true; + } + var name: string, elm = vnode.elm, i = 0, compStyle: CSSStyleDeclaration, + style = s.remove, amount = 0, applied: Array = []; + for (name in style) { + applied.push(name); + (elm as any).style[name] = style[name]; + } + compStyle = getComputedStyle(elm as Element); + var props = (compStyle as any)['transition-property'].split(', '); + for (; i < props.length; ++i) { + if(applied.indexOf(props[i]) !== -1) amount++; + } + (elm as Element).addEventListener('transitionend', function (ev: TransitionEvent) { + if (ev.target === elm) --amount; + if (amount === 0) rm(); + }); +} + +function forceReflow() { + reflowForced = false; +} + +export const styleModule = { + pre: forceReflow, + create: updateStyle, + update: updateStyle, + destroy: applyDestroyStyle, + remove: applyRemoveStyle +} as Module; +export default styleModule; diff --git a/src/libs/snabbdom/src/snabbdom.bundle.ts b/src/libs/snabbdom/src/snabbdom.bundle.ts new file mode 100755 index 00000000..aae41177 --- /dev/null +++ b/src/libs/snabbdom/src/snabbdom.bundle.ts @@ -0,0 +1,16 @@ +import {init} from './snabbdom'; +import {attributesModule} from './modules/attributes'; // for setting attributes on DOM elements +import {classModule} from './modules/class'; // makes it easy to toggle classes +import {propsModule} from './modules/props'; // for setting properties on DOM elements +import {styleModule} from './modules/style'; // handles styling on elements with support for animations +import {eventListenersModule} from './modules/eventlisteners'; // attaches event listeners +import {h} from './h'; // helper function for creating vnodes +var patch = init([ // Init patch function with choosen modules + attributesModule, + classModule, + propsModule, + styleModule, + eventListenersModule +]) as (oldVNode: any, vnode: any) => any; +export const snabbdomBundle = { patch, h: h as any }; +export default snabbdomBundle; \ No newline at end of file diff --git a/src/libs/snabbdom/src/snabbdom.ts b/src/libs/snabbdom/src/snabbdom.ts new file mode 100755 index 00000000..9194fd88 --- /dev/null +++ b/src/libs/snabbdom/src/snabbdom.ts @@ -0,0 +1,318 @@ +/* global module, document, Node */ +import {Module} from './modules/module'; +import {Hooks} from './hooks'; +import vnode, {VNode, VNodeData, Key} from './vnode'; +import * as is from './is'; +import htmlDomApi, {DOMAPI} from './htmldomapi'; + +function isUndef(s: any): boolean { return s === undefined; } +function isDef(s: any): boolean { return s !== undefined; } + +type VNodeQueue = Array; + +const emptyNode = vnode('', {}, [], undefined, undefined); + +function sameVnode(vnode1: VNode, vnode2: VNode): boolean { + return vnode1.key === vnode2.key && vnode1.sel === vnode2.sel; +} + +function isVnode(vnode: any): vnode is VNode { + return vnode.sel !== undefined; +} + +type KeyToIndexMap = {[key: string]: number}; + +type ArraysOf = { + [K in keyof T]: (T[K])[]; +} + +type ModuleHooks = ArraysOf; + +function createKeyToOldIdx(children: Array, beginIdx: number, endIdx: number): KeyToIndexMap { + let i: number, map: KeyToIndexMap = {}, key: Key | undefined, ch; + for (i = beginIdx; i <= endIdx; ++i) { + ch = children[i]; + if (ch != null) { + key = ch.key; + if (key !== undefined) map[key] = i; + } + } + return map; +} + +const hooks: (keyof Module)[] = ['create', 'update', 'remove', 'destroy', 'pre', 'post']; + +export {h} from './h'; +export {thunk} from './thunk'; + +export function init(modules: Array>, domApi?: DOMAPI) { + let i: number, j: number, cbs = ({} as ModuleHooks); + + const api: DOMAPI = domApi !== undefined ? domApi : htmlDomApi; + + for (i = 0; i < hooks.length; ++i) { + cbs[hooks[i]] = []; + for (j = 0; j < modules.length; ++j) { + const hook = modules[j][hooks[i]]; + if (hook !== undefined) { + (cbs[hooks[i]] as Array).push(hook); + } + } + } + + function emptyNodeAt(elm: Element) { + const id = elm.id ? '#' + elm.id : ''; + const c = elm.className ? '.' + elm.className.split(' ').join('.') : ''; + return vnode(api.tagName(elm).toLowerCase() + id + c, {}, [], undefined, elm); + } + + function createRmCb(childElm: Node, listeners: number) { + return function rmCb() { + if (--listeners === 0) { + const parent = api.parentNode(childElm); + api.removeChild(parent, childElm); + } + }; + } + + function createElm(vnode: VNode, insertedVnodeQueue: VNodeQueue): Node { + let i: any, data = vnode.data; + if (data !== undefined) { + if (isDef(i = data.hook) && isDef(i = i.init)) { + i(vnode); + data = vnode.data; + } + } + let children = vnode.children, sel = vnode.sel; + if (sel === '!') { + if (isUndef(vnode.text)) { + vnode.text = ''; + } + vnode.elm = api.createComment(vnode.text as string); + } else if (sel !== undefined) { + // Parse selector + const hashIdx = sel.indexOf('#'); + const dotIdx = sel.indexOf('.', hashIdx); + const hash = hashIdx > 0 ? hashIdx : sel.length; + const dot = dotIdx > 0 ? dotIdx : sel.length; + const tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel; + const elm = vnode.elm = isDef(data) && isDef(i = (data as VNodeData).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) { + const ch = children[i]; + if (ch != null) { + api.appendChild(elm, createElm(ch as VNode, insertedVnodeQueue)); + } + } + } else if (is.primitive(vnode.text)) { + api.appendChild(elm, api.createTextNode(vnode.text)); + } + i = (vnode.data as VNodeData).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 as string); + } + return vnode.elm; + } + + function addVnodes(parentElm: Node, + before: Node | null, + vnodes: Array, + startIdx: number, + endIdx: number, + insertedVnodeQueue: VNodeQueue) { + for (; startIdx <= endIdx; ++startIdx) { + const ch = vnodes[startIdx]; + if (ch != null) { + api.insertBefore(parentElm, createElm(ch, insertedVnodeQueue), before); + } + } + } + + function invokeDestroyHook(vnode: VNode) { + let i: any, j: number, 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: Node, + vnodes: Array, + startIdx: number, + endIdx: number): void { + for (; startIdx <= endIdx; ++startIdx) { + let i: any, listeners: number, rm: () => void, ch = vnodes[startIdx]; + if (ch != null) { + if (isDef(ch.sel)) { + invokeDestroyHook(ch); + listeners = cbs.remove.length + 1; + rm = createRmCb(ch.elm as Node, listeners); + for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm); + if (isDef(i = ch.data) && isDef(i = i.hook) && isDef(i = i.remove)) { + i(ch, rm); + } else { + rm(); + } + } else { // Text node + api.removeChild(parentElm, ch.elm as Node); + } + } + } + } + + function updateChildren(parentElm: Node, + oldCh: Array, + newCh: Array, + insertedVnodeQueue: VNodeQueue) { + let oldStartIdx = 0, newStartIdx = 0; + let oldEndIdx = oldCh.length - 1; + let oldStartVnode = oldCh[0]; + let oldEndVnode = oldCh[oldEndIdx]; + let newEndIdx = newCh.length - 1; + let newStartVnode = newCh[0]; + let newEndVnode = newCh[newEndIdx]; + let oldKeyToIdx: any; + let idxInOld: number; + let elmToMove: VNode; + let before: any; + + 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)) { // Vnode moved right + patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue); + api.insertBefore(parentElm, oldStartVnode.elm as Node, api.nextSibling(oldEndVnode.elm as Node)); + oldStartVnode = oldCh[++oldStartIdx]; + newEndVnode = newCh[--newEndIdx]; + } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left + patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue); + api.insertBefore(parentElm, oldEndVnode.elm as Node, oldStartVnode.elm as Node); + oldEndVnode = oldCh[--oldEndIdx]; + newStartVnode = newCh[++newStartIdx]; + } else { + if (oldKeyToIdx === undefined) { + oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); + } + idxInOld = oldKeyToIdx[newStartVnode.key as string]; + if (isUndef(idxInOld)) { // New element + api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm as Node); + newStartVnode = newCh[++newStartIdx]; + } else { + elmToMove = oldCh[idxInOld]; + if (elmToMove.sel !== newStartVnode.sel) { + api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm as Node); + } else { + patchVnode(elmToMove, newStartVnode, insertedVnodeQueue); + oldCh[idxInOld] = undefined as any; + api.insertBefore(parentElm, (elmToMove.elm as Node), oldStartVnode.elm as Node); + } + 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, vnode: VNode, insertedVnodeQueue: VNodeQueue) { + let i: any, hook: any; + if (isDef(i = vnode.data) && isDef(hook = i.hook) && isDef(i = hook.prepatch)) { + i(oldVnode, vnode); + } + const elm = vnode.elm = (oldVnode.elm as Node); + let oldCh = oldVnode.children; + let 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 as Array, ch as Array, insertedVnodeQueue); + } else if (isDef(ch)) { + if (isDef(oldVnode.text)) api.setTextContent(elm, ''); + addVnodes(elm, null, ch as Array, 0, (ch as Array).length - 1, insertedVnodeQueue); + } else if (isDef(oldCh)) { + removeVnodes(elm, oldCh as Array, 0, (oldCh as Array).length - 1); + } else if (isDef(oldVnode.text)) { + api.setTextContent(elm, ''); + } + } else if (oldVnode.text !== vnode.text) { + if (isDef(oldCh)) { + removeVnodes(elm, oldCh as Array, 0, (oldCh as Array).length - 1); + } + api.setTextContent(elm, vnode.text as string); + } + if (isDef(hook) && isDef(i = hook.postpatch)) { + i(oldVnode, vnode); + } + } + + return function patch(oldVnode: VNode | Element, vnode: VNode): VNode { + let i: number, elm: Node, parent: Node; + const insertedVnodeQueue: VNodeQueue = []; + 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 as Node; + parent = api.parentNode(elm); + + createElm(vnode, insertedVnodeQueue); + + if (parent !== null) { + api.insertBefore(parent, vnode.elm as Node, api.nextSibling(elm)); + removeVnodes(parent, [oldVnode], 0, 0); + } + } + + for (i = 0; i < insertedVnodeQueue.length; ++i) { + (((insertedVnodeQueue[i].data as VNodeData).hook as Hooks).insert as any)(insertedVnodeQueue[i]); + } + for (i = 0; i < cbs.post.length; ++i) cbs.post[i](); + return vnode; + }; +} diff --git a/src/libs/snabbdom/src/thunk.ts b/src/libs/snabbdom/src/thunk.ts new file mode 100755 index 00000000..96504120 --- /dev/null +++ b/src/libs/snabbdom/src/thunk.ts @@ -0,0 +1,64 @@ +import {VNode, VNodeData} from './vnode'; +import {h} from './h'; + +export interface ThunkData extends VNodeData { + fn: () => VNode; + args: Array; +} + +export interface Thunk extends VNode { + data: ThunkData; +} + +export interface ThunkFn { + (sel: string, fn: Function, args: Array): Thunk; + (sel: string, key: any, fn: Function, args: Array): Thunk; +} + +function copyToThunk(vnode: VNode, thunk: VNode): void { + thunk.elm = vnode.elm; + (vnode.data as VNodeData).fn = (thunk.data as VNodeData).fn; + (vnode.data as VNodeData).args = (thunk.data as VNodeData).args; + thunk.data = vnode.data; + thunk.children = vnode.children; + thunk.text = vnode.text; + thunk.elm = vnode.elm; +} + +function init(thunk: VNode): void { + const cur = thunk.data as VNodeData; + const vnode = (cur.fn as any).apply(undefined, cur.args); + copyToThunk(vnode, thunk); +} + +function prepatch(oldVnode: VNode, thunk: VNode): void { + let i: number, old = oldVnode.data as VNodeData, cur = thunk.data as VNodeData; + const oldArgs = old.args, args = cur.args; + if (old.fn !== cur.fn || (oldArgs as any).length !== (args as any).length) { + copyToThunk((cur.fn as any).apply(undefined, args), thunk); + return; + } + for (i = 0; i < (args as any).length; ++i) { + if ((oldArgs as any)[i] !== (args as any)[i]) { + copyToThunk((cur.fn as any).apply(undefined, args), thunk); + return; + } + } + copyToThunk(oldVnode, thunk); +} + +export const thunk = function thunk(sel: string, key?: any, fn?: any, args?: any): VNode { + if (args === undefined) { + args = fn; + fn = key; + key = undefined; + } + return h(sel, { + key: key, + hook: {init: init, prepatch: prepatch}, + fn: fn, + args: args + }); +} as ThunkFn; + +export default thunk; \ No newline at end of file diff --git a/src/libs/snabbdom/src/tovnode.ts b/src/libs/snabbdom/src/tovnode.ts new file mode 100755 index 00000000..313c8eb4 --- /dev/null +++ b/src/libs/snabbdom/src/tovnode.ts @@ -0,0 +1,39 @@ +import vnode, {VNode} from './vnode'; +import htmlDomApi, {DOMAPI} from './htmldomapi'; + +export function toVNode(node: Node, domApi?: DOMAPI): VNode { + const api: DOMAPI = domApi !== undefined ? domApi : htmlDomApi; + let text: string; + if (api.isElement(node)) { + const id = node.id ? '#' + node.id : ''; + const cn = node.getAttribute('class'); + const c = cn ? '.' + cn.split(' ').join('.') : ''; + const sel = api.tagName(node).toLowerCase() + id + c; + const attrs: any = {}; + const children: Array = []; + let name: string; + let i: number, n: number; + const elmAttrs = node.attributes; + const elmChildren = node.childNodes; + for (i = 0, n = elmAttrs.length; i < n; i++) { + name = elmAttrs[i].nodeName; + if (name !== 'id' && name !== 'class') { + attrs[name] = elmAttrs[i].nodeValue; + } + } + for (i = 0, n = elmChildren.length; i < n; i++) { + children.push(toVNode(elmChildren[i], domApi)); + } + return vnode(sel, {attrs}, children, undefined, node); + } else if (api.isText(node)) { + text = api.getTextContent(node) as string; + return vnode(undefined, undefined, undefined, text, node); + } else if (api.isComment(node)) { + text = api.getTextContent(node) as string; + return vnode('!', {}, [], text, node as any); + } else { + return vnode('', {}, [], undefined, node as any); + } +} + +export default toVNode; \ No newline at end of file diff --git a/src/libs/snabbdom/src/vnode.ts b/src/libs/snabbdom/src/vnode.ts new file mode 100755 index 00000000..1a6d4a7c --- /dev/null +++ b/src/libs/snabbdom/src/vnode.ts @@ -0,0 +1,49 @@ +import {Hooks} from './hooks'; +import {AttachData} from './helpers/attachto' +import {VNodeStyle} from './modules/style' +import {On} from './modules/eventlisteners' +import {Attrs} from './modules/attributes' +import {Classes} from './modules/class' +import {Props} from './modules/props' +import {Dataset} from './modules/dataset' +import {Hero} from './modules/hero' + +export type Key = string | number; + +export interface VNode { + sel: string | undefined; + data: VNodeData | undefined; + children: Array | 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; // for SVGs + fn?: () => VNode; // for thunks + args?: Array; // for thunks + [key: string]: any; // for any other 3rd party module +} + +export function vnode(sel: string | undefined, + data: any | undefined, + children: Array | undefined, + text: string | undefined, + elm: Element | Text | undefined): VNode { + let key = data === undefined ? undefined : data.key; + return {sel: sel, data: data, children: children, + text: text, elm: elm, key: key}; +} + +export default vnode; diff --git a/src/libs/snabbdom/test/attachto.js b/src/libs/snabbdom/test/attachto.js new file mode 100755 index 00000000..607c9918 --- /dev/null +++ b/src/libs/snabbdom/test/attachto.js @@ -0,0 +1,98 @@ +var assert = require('assert'); +var snabbdom = require('../snabbdom'); + +var patch = snabbdom.init([]); +var attachTo = require('../helpers/attachto').default; +var h = require('../h').default; + +describe('attachTo', function() { + var elm, vnode0; + beforeEach(function() { + elm = document.createElement('div'); + vnode0 = elm; + }); + it('adds element to target', function() { + var vnode1 = h('div', [ + h('div#wrapper', [ + h('div', 'Some element'), + attachTo(elm, h('div#attached', 'Test')), + ]), + ]); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 2); + }); + it('updates element at target', function() { + var vnode1 = h('div', [ + h('div#wrapper', [ + h('div', 'Some element'), + attachTo(elm, h('div#attached', 'First text')), + ]), + ]); + var vnode2 = h('div', [ + h('div#wrapper', [ + h('div', 'Some element'), + attachTo(elm, h('div#attached', 'New text')), + ]), + ]); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children[0].innerHTML, 'First text'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children[0].innerHTML, 'New text'); + }); + it('element can be inserted before modal', function() { + var vnode1 = h('div', [ + h('div#wrapper', [ + h('div', 'Some element'), + attachTo(elm, h('div#attached', 'Text')), + ]), + ]); + var vnode2 = h('div', [ + h('div#wrapper', [ + h('div', 'Some element'), + h('div', 'A new element'), + attachTo(elm, h('div#attached', 'Text')), + ]), + ]); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children[0].innerHTML, 'Text'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children[0].innerHTML, 'Text'); + }); + it('removes element at target', function() { + var vnode1 = h('div', [ + h('div#wrapper', [ + h('div', 'Some element'), + attachTo(elm, h('div#attached', 'First text')), + ]), + ]); + var vnode2 = h('div', [ + h('div#wrapper', [ + h('div', 'Some element'), + ]), + ]); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children[0].innerHTML, 'First text'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 1); + }); + it('remove hook receives real element', function() { + function rm(vnode, cb) { + assert.equal(vnode.elm.tagName, 'DIV'); + assert.equal(vnode.elm.innerHTML, 'First text'); + cb(); + } + var vnode1 = h('div', [ + h('div#wrapper', [ + h('div', 'Some element'), + attachTo(elm, h('div#attached', {hook: {remove: rm}}, 'First text')), + ]), + ]); + var vnode2 = h('div', [ + h('div#wrapper', [ + h('div', 'Some element'), + ]), + ]); + elm = patch(vnode0, vnode1).elm; + elm = patch(vnode1, vnode2).elm; + }); +}); diff --git a/src/libs/snabbdom/test/attributes.js b/src/libs/snabbdom/test/attributes.js new file mode 100755 index 00000000..bef6e4d2 --- /dev/null +++ b/src/libs/snabbdom/test/attributes.js @@ -0,0 +1,97 @@ +var assert = require('assert'); + +var snabbdom = require('../snabbdom'); +var patch = snabbdom.init([ + require('../modules/attributes').default, +]); +var h = require('../h').default; + +describe('attributes', function() { + var elm, vnode0; + beforeEach(function() { + elm = document.createElement('div'); + vnode0 = elm; + }); + it('have their provided values', function() { + var vnode1 = h('div', {attrs: {href: '/foo', minlength: 1, selected: true, disabled: false}}); + elm = patch(vnode0, vnode1).elm; + assert.strictEqual(elm.getAttribute('href'), '/foo'); + assert.strictEqual(elm.getAttribute('minlength'), '1'); + assert.strictEqual(elm.hasAttribute('selected'), true); + assert.strictEqual(elm.getAttribute('selected'), ''); + assert.strictEqual(elm.hasAttribute('disabled'), false); + }); + it('can be memoized', function() { + var cachedAttrs = {href: '/foo', minlength: 1, selected: true}; + var vnode1 = h('div', {attrs: cachedAttrs}); + var vnode2 = h('div', {attrs: cachedAttrs}); + elm = patch(vnode0, vnode1).elm; + assert.strictEqual(elm.getAttribute('href'), '/foo'); + assert.strictEqual(elm.getAttribute('minlength'), '1'); + assert.strictEqual(elm.getAttribute('selected'), ''); + elm = patch(vnode1, vnode2).elm; + assert.strictEqual(elm.getAttribute('href'), '/foo'); + assert.strictEqual(elm.getAttribute('minlength'), '1'); + assert.strictEqual(elm.getAttribute('selected'), ''); + }); + it('are not omitted when falsy values are provided', function() { + var vnode1 = h('div', {attrs: {href: null, minlength: 0, value: '', title:'undefined'}}); + elm = patch(vnode0, vnode1).elm; + assert.strictEqual(elm.getAttribute('href'), 'null'); + assert.strictEqual(elm.getAttribute('minlength'), '0'); + assert.strictEqual(elm.getAttribute('value'), ''); + assert.strictEqual(elm.getAttribute('title'), 'undefined'); + }); + it('are set correctly when namespaced', function() { + var vnode1 = h('div', {attrs: {'xlink:href': '#foo'}}); + elm = patch(vnode0, vnode1).elm; + assert.strictEqual(elm.getAttributeNS('http://www.w3.org/1999/xlink', 'href'), '#foo'); + }); + it('should not touch class nor id fields', function() { + elm = document.createElement('div'); + elm.id = 'myId'; + elm.className = 'myClass'; + vnode0 = elm; + var vnode1 = h('div#myId.myClass', {attrs: {}}, ['Hello']); + elm = patch(vnode0, vnode1).elm; + assert.strictEqual(elm.tagName, 'DIV'); + assert.strictEqual(elm.id, 'myId'); + assert.strictEqual(elm.className, 'myClass'); + assert.strictEqual(elm.textContent, 'Hello'); + }); + describe('boolean attribute', function() { + it('is present and empty string if the value is truthy', function() { + var vnode1 = h('div', {attrs: {required: true, readonly: 1, noresize: 'truthy'}}); + elm = patch(vnode0, vnode1).elm; + assert.strictEqual(elm.hasAttribute('required'), true); + assert.strictEqual(elm.getAttribute('required'), ''); + assert.strictEqual(elm.hasAttribute('readonly'), true); + assert.strictEqual(elm.getAttribute('readonly'), '1'); + assert.strictEqual(elm.hasAttribute('noresize'), true); + assert.strictEqual(elm.getAttribute('noresize'), 'truthy'); + }); + it('is omitted if the value is false', function() { + var vnode1 = h('div', {attrs: {required: false}}); + elm = patch(vnode0, vnode1).elm; + assert.strictEqual(elm.hasAttribute('required'), false); + assert.strictEqual(elm.getAttribute('required'), null); + }); + it('is not omitted if the value is falsy but casted to string', function() { + var vnode1 = h('div', {attrs: {readonly: 0, noresize: null}}); + elm = patch(vnode0, vnode1).elm; + assert.strictEqual(elm.getAttribute('readonly'), '0'); + assert.strictEqual(elm.getAttribute('noresize'), 'null'); + }); + }); + describe('Object.prototype property', function() { + it('is not considered as a boolean attribute and shouldn\'t be omitted', function() { + var vnode1 = h('div', {attrs: {constructor: true}}); + elm = patch(vnode0, vnode1).elm; + assert.strictEqual(elm.hasAttribute('constructor'), true); + assert.strictEqual(elm.getAttribute('constructor'), ''); + var vnode2 = h('div', {attrs: {constructor: false}}); + elm = patch(vnode0, vnode2).elm; + assert.strictEqual(elm.hasAttribute('constructor'), false); + }); + }); +}); diff --git a/src/libs/snabbdom/test/core.js b/src/libs/snabbdom/test/core.js new file mode 100755 index 00000000..f4c90510 --- /dev/null +++ b/src/libs/snabbdom/test/core.js @@ -0,0 +1,1114 @@ +var assert = require('assert'); +var shuffle = require('knuth-shuffle').knuthShuffle; + +var snabbdom = require('../snabbdom'); +var patch = snabbdom.init([ + require('../modules/class').default, + require('../modules/props').default, + require('../modules/eventlisteners').default, +]); +var h = require('../h').default; +var toVNode = require('../tovnode').default; +var vnode = require('../vnode').default; +var htmlDomApi = require('../htmldomapi').htmlDomApi; + +function prop(name) { + return function(obj) { + return obj[name]; + }; +} + +function map(fn, list) { + var ret = []; + for (var i = 0; i < list.length; ++i) { + ret[i] = fn(list[i]); + } + return ret; +} + +var inner = prop('innerHTML'); + +describe('snabbdom', function() { + var elm, vnode0; + beforeEach(function() { + elm = document.createElement('div'); + vnode0 = elm; + }); + describe('hyperscript', function() { + it('can create vnode with proper tag', function() { + assert.equal(h('div').sel, 'div'); + assert.equal(h('a').sel, 'a'); + }); + it('can create vnode with children', function() { + var vnode = h('div', [h('span#hello'), h('b.world')]); + assert.equal(vnode.sel, 'div'); + assert.equal(vnode.children[0].sel, 'span#hello'); + assert.equal(vnode.children[1].sel, 'b.world'); + }); + it('can create vnode with one child vnode', function() { + var vnode = h('div', h('span#hello')); + assert.equal(vnode.sel, 'div'); + assert.equal(vnode.children[0].sel, 'span#hello'); + }); + it('can create vnode with props and one child vnode', function() { + var vnode = h('div', {}, h('span#hello')); + assert.equal(vnode.sel, 'div'); + assert.equal(vnode.children[0].sel, 'span#hello'); + }); + it('can create vnode with text content', function() { + var vnode = h('a', ['I am a string']); + assert.equal(vnode.children[0].text, 'I am a string'); + }); + it('can create vnode with text content in string', function() { + var vnode = h('a', 'I am a string'); + assert.equal(vnode.text, 'I am a string'); + }); + it('can create vnode with props and text content in string', function() { + var vnode = h('a', {}, 'I am a string'); + assert.equal(vnode.text, 'I am a string'); + }); + it('can create vnode for comment', function() { + var vnode = h('!', 'test'); + assert.equal(vnode.sel, '!'); + assert.equal(vnode.text, 'test'); + }); + }); + describe('created element', function() { + it('has tag', function() { + elm = patch(vnode0, h('div')).elm; + assert.equal(elm.tagName, 'DIV'); + }); + it('has different tag and id', function() { + var elm = document.createElement('div'); + vnode0.appendChild(elm); + var vnode1 = h('span#id'); + elm = patch(elm, vnode1).elm; + assert.equal(elm.tagName, 'SPAN'); + assert.equal(elm.id, 'id'); + }); + it('has id', function() { + elm = patch(vnode0, h('div', [h('div#unique')])).elm; + assert.equal(elm.firstChild.id, 'unique'); + }); + it('has correct namespace', function() { + var SVGNamespace = 'http://www.w3.org/2000/svg'; + var XHTMLNamespace = 'http://www.w3.org/1999/xhtml'; + + elm = patch(vnode0, h('div', [h('div', {ns: SVGNamespace})])).elm; + assert.equal(elm.firstChild.namespaceURI, SVGNamespace); + + // verify that svg tag automatically gets svg namespace + elm = patch(vnode0, h('svg', [ + h('foreignObject', [ + h('div', ['I am HTML embedded in SVG']) + ]) + ])).elm; + assert.equal(elm.namespaceURI, SVGNamespace); + assert.equal(elm.firstChild.namespaceURI, SVGNamespace); + assert.equal(elm.firstChild.firstChild.namespaceURI, XHTMLNamespace); + + // verify that svg tag with extra selectors gets svg namespace + elm = patch(vnode0, h('svg#some-id')).elm; + assert.equal(elm.namespaceURI, SVGNamespace); + + // verify that non-svg tag beginning with 'svg' does NOT get namespace + elm = patch(vnode0, h('svg-custom-el')).elm; + assert.notEqual(elm.namespaceURI, SVGNamespace); + }); + it('receives classes in selector', function() { + elm = patch(vnode0, h('div', [h('i.am.a.class')])).elm; + assert(elm.firstChild.classList.contains('am')); + assert(elm.firstChild.classList.contains('a')); + assert(elm.firstChild.classList.contains('class')); + }); + it('receives classes in class property', function() { + elm = patch(vnode0, h('i', {class: {am: true, a: true, class: true, not: false}})).elm; + assert(elm.classList.contains('am')); + assert(elm.classList.contains('a')); + assert(elm.classList.contains('class')); + assert(!elm.classList.contains('not')); + }); + it('receives classes in selector when namespaced', function() { + elm = patch(vnode0, + h('svg', [ + h('g.am.a.class.too') + ]) + ).elm; + assert(elm.firstChild.classList.contains('am')); + assert(elm.firstChild.classList.contains('a')); + assert(elm.firstChild.classList.contains('class')); + }); + it('receives classes in class property when namespaced', function() { + elm = patch(vnode0, + h('svg', [ + h('g', {class: {am: true, a: true, class: true, not: false, too: true}}) + ]) + ).elm; + assert(elm.firstChild.classList.contains('am')); + assert(elm.firstChild.classList.contains('a')); + assert(elm.firstChild.classList.contains('class')); + assert(!elm.firstChild.classList.contains('not')); + }); + it('handles classes from both selector and property', function() { + elm = patch(vnode0, h('div', [h('i.has', {class: {classes: true}})])).elm; + assert(elm.firstChild.classList.contains('has')); + assert(elm.firstChild.classList.contains('classes')); + }); + it('can create elements with text content', function() { + elm = patch(vnode0, h('div', ['I am a string'])).elm; + assert.equal(elm.innerHTML, 'I am a string'); + }); + it('can create elements with span and text content', function() { + elm = patch(vnode0, h('a', [h('span'), 'I am a string'])).elm; + assert.equal(elm.childNodes[0].tagName, 'SPAN'); + assert.equal(elm.childNodes[1].textContent, 'I am a string'); + }); + it('can create elements with props', function() { + elm = patch(vnode0, h('a', {props: {src: 'http://localhost/'}})).elm; + assert.equal(elm.src, 'http://localhost/'); + }); + it('can create an element created inside an iframe', function(done) { + // Only run if srcdoc is supported. + var frame = document.createElement('iframe'); + if (typeof frame.srcdoc !== 'undefined') { + frame.srcdoc = "
Thing 1
"; + frame.onload = function() { + patch(frame.contentDocument.body.querySelector('div'), h('div', 'Thing 2')); + assert.equal(frame.contentDocument.body.querySelector('div').textContent, 'Thing 2'); + frame.remove(); + done(); + }; + document.body.appendChild(frame); + } else { + done(); + } + }); + it('is a patch of the root element', function () { + var elmWithIdAndClass = document.createElement('div'); + elmWithIdAndClass.id = 'id'; + elmWithIdAndClass.className = 'class'; + var vnode1 = h('div#id.class', [h('span', 'Hi')]); + elm = patch(elmWithIdAndClass, vnode1).elm; + assert.strictEqual(elm, elmWithIdAndClass); + assert.equal(elm.tagName, 'DIV'); + assert.equal(elm.id, 'id'); + assert.equal(elm.className, 'class'); + }); + it('can create comments', function() { + elm = patch(vnode0, h('!', 'test')).elm; + assert.equal(elm.nodeType, document.COMMENT_NODE); + assert.equal(elm.textContent, 'test'); + }); + }); + describe('patching an element', function() { + it('changes the elements classes', function() { + var vnode1 = h('i', {class: {i: true, am: true, horse: true}}); + var vnode2 = h('i', {class: {i: true, am: true, horse: false}}); + patch(vnode0, vnode1); + elm = patch(vnode1, vnode2).elm; + assert(elm.classList.contains('i')); + assert(elm.classList.contains('am')); + assert(!elm.classList.contains('horse')); + }); + it('changes classes in selector', function() { + var vnode1 = h('i', {class: {i: true, am: true, horse: true}}); + var vnode2 = h('i', {class: {i: true, am: true, horse: false}}); + patch(vnode0, vnode1); + elm = patch(vnode1, vnode2).elm; + assert(elm.classList.contains('i')); + assert(elm.classList.contains('am')); + assert(!elm.classList.contains('horse')); + }); + it('preserves memoized classes', function() { + var cachedClass = {i: true, am: true, horse: false}; + var vnode1 = h('i', {class: cachedClass}); + var vnode2 = h('i', {class: cachedClass}); + elm = patch(vnode0, vnode1).elm; + assert(elm.classList.contains('i')); + assert(elm.classList.contains('am')); + assert(!elm.classList.contains('horse')); + elm = patch(vnode1, vnode2).elm; + assert(elm.classList.contains('i')); + assert(elm.classList.contains('am')); + assert(!elm.classList.contains('horse')); + }); + it('removes missing classes', function() { + var vnode1 = h('i', {class: {i: true, am: true, horse: true}}); + var vnode2 = h('i', {class: {i: true, am: true}}); + patch(vnode0, vnode1); + elm = patch(vnode1, vnode2).elm; + assert(elm.classList.contains('i')); + assert(elm.classList.contains('am')); + assert(!elm.classList.contains('horse')); + }); + it('changes an elements props', function() { + var vnode1 = h('a', {props: {src: 'http://other/'}}); + var vnode2 = h('a', {props: {src: 'http://localhost/'}}); + patch(vnode0, vnode1); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.src, 'http://localhost/'); + }); + it('preserves memoized props', function() { + var cachedProps = {src: 'http://other/'}; + var vnode1 = h('a', {props: cachedProps}); + var vnode2 = h('a', {props: cachedProps}); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.src, 'http://other/'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.src, 'http://other/'); + }); + it('removes an elements props', function() { + var vnode1 = h('a', {props: {src: 'http://other/'}}); + var vnode2 = h('a'); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(elm.src, undefined); + }); + describe('using toVNode()', function () { + it('can remove previous children of the root element', function () { + var h2 = document.createElement('h2'); + h2.textContent = 'Hello' + var prevElm = document.createElement('div'); + prevElm.id = 'id'; + prevElm.className = 'class'; + prevElm.appendChild(h2); + var nextVNode = h('div#id.class', [h('span', 'Hi')]); + elm = patch(toVNode(prevElm), nextVNode).elm; + assert.strictEqual(elm, prevElm); + assert.equal(elm.tagName, 'DIV'); + assert.equal(elm.id, 'id'); + assert.equal(elm.className, 'class'); + assert.strictEqual(elm.childNodes.length, 1); + assert.strictEqual(elm.childNodes[0].tagName, 'SPAN'); + assert.strictEqual(elm.childNodes[0].textContent, 'Hi'); + }); + it('can support patching in a DocumentFragment', function () { + var prevElm = document.createDocumentFragment(); + var nextVNode = vnode('', {}, [ + h('div#id.class', [h('span', 'Hi')]) + ], undefined, prevElm); + elm = patch(toVNode(prevElm), nextVNode).elm; + assert.strictEqual(elm, prevElm); + assert.equal(elm.nodeType, 11); + assert.equal(elm.childNodes.length, 1); + assert.equal(elm.childNodes[0].tagName, 'DIV'); + assert.equal(elm.childNodes[0].id, 'id'); + assert.equal(elm.childNodes[0].className, 'class'); + assert.strictEqual(elm.childNodes[0].childNodes.length, 1); + assert.strictEqual(elm.childNodes[0].childNodes[0].tagName, 'SPAN'); + assert.strictEqual(elm.childNodes[0].childNodes[0].textContent, 'Hi'); + }); + it('can remove some children of the root element', function () { + var h2 = document.createElement('h2'); + h2.textContent = 'Hello' + var prevElm = document.createElement('div'); + prevElm.id = 'id'; + prevElm.className = 'class'; + var text = new Text('Foobar'); + text.testProperty = function () {}; // ensures we dont recreate the Text Node + prevElm.appendChild(text); + prevElm.appendChild(h2); + var nextVNode = h('div#id.class', ['Foobar']); + elm = patch(toVNode(prevElm), nextVNode).elm; + assert.strictEqual(elm, prevElm); + assert.equal(elm.tagName, 'DIV'); + assert.equal(elm.id, 'id'); + assert.equal(elm.className, 'class'); + assert.strictEqual(elm.childNodes.length, 1); + assert.strictEqual(elm.childNodes[0].nodeType, 3); + assert.strictEqual(elm.childNodes[0].wholeText, 'Foobar'); + assert.strictEqual(typeof elm.childNodes[0].testProperty, 'function'); + }); + it('can remove text elements', function () { + var h2 = document.createElement('h2'); + h2.textContent = 'Hello' + var prevElm = document.createElement('div'); + prevElm.id = 'id'; + prevElm.className = 'class'; + var text = new Text('Foobar'); + prevElm.appendChild(text); + prevElm.appendChild(h2); + var nextVNode = h('div#id.class', [h('h2', 'Hello')]); + elm = patch(toVNode(prevElm), nextVNode).elm; + assert.strictEqual(elm, prevElm); + assert.equal(elm.tagName, 'DIV'); + assert.equal(elm.id, 'id'); + assert.equal(elm.className, 'class'); + assert.strictEqual(elm.childNodes.length, 1); + assert.strictEqual(elm.childNodes[0].nodeType, 1); + assert.strictEqual(elm.childNodes[0].textContent, 'Hello'); + }); + it('can work with domApi', function () { + var domApi = Object.assign({}, htmlDomApi, { + tagName: function(elm) { return 'x-' + elm.tagName.toUpperCase(); } + }); + var h2 = document.createElement('h2'); + h2.id = 'hx'; + h2.setAttribute('data-env', "xyz"); + var text = document.createTextNode("Foobar"); + var elm = document.createElement('div'); + elm.id = 'id'; + elm.className = 'class other'; + elm.setAttribute('data', 'value'); + elm.appendChild(h2); + elm.appendChild(text); + var vnode = toVNode(elm, domApi); + assert.equal(vnode.sel, 'x-div#id.class.other'); + assert.deepEqual(vnode.data, {attrs: {'data': 'value'}}); + assert.equal(vnode.children[0].sel, 'x-h2#hx'); + assert.deepEqual(vnode.children[0].data, {attrs: {'data-env': 'xyz'}}); + assert.equal(vnode.children[1].text, 'Foobar'); + }); + }); + describe('updating children with keys', function() { + function spanNum(n) { + if (n == null) { + return n; + } else if (typeof n === 'string') { + return h('span', {}, n); + } else { + return h('span', {key: n}, n.toString()); + } + } + describe('addition of elements', function() { + it('appends elements', function() { + var vnode1 = h('span', [1].map(spanNum)); + var vnode2 = h('span', [1, 2, 3].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 1); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 3); + assert.equal(elm.children[1].innerHTML, '2'); + assert.equal(elm.children[2].innerHTML, '3'); + }); + it('prepends elements', function() { + var vnode1 = h('span', [4, 5].map(spanNum)); + var vnode2 = h('span', [1, 2, 3, 4, 5].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 2); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['1', '2', '3', '4', '5']); + }); + it('add elements in the middle', function() { + var vnode1 = h('span', [1, 2, 4, 5].map(spanNum)); + var vnode2 = h('span', [1, 2, 3, 4, 5].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 4); + assert.equal(elm.children.length, 4); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['1', '2', '3', '4', '5']); + }); + it('add elements at begin and end', function() { + var vnode1 = h('span', [2, 3, 4].map(spanNum)); + var vnode2 = h('span', [1, 2, 3, 4, 5].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 3); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['1', '2', '3', '4', '5']); + }); + it('adds children to parent with no children', function() { + var vnode1 = h('span', {key: 'span'}); + var vnode2 = h('span', {key: 'span'}, [1, 2, 3].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 0); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['1', '2', '3']); + }); + it('removes all children from parent', function() { + var vnode1 = h('span', {key: 'span'}, [1, 2, 3].map(spanNum)); + var vnode2 = h('span', {key: 'span'}); + elm = patch(vnode0, vnode1).elm; + assert.deepEqual(map(inner, elm.children), ['1', '2', '3']); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 0); + }); + it('update one child with same key but different sel', function() { + var vnode1 = h('span', {key: 'span'}, [1, 2, 3].map(spanNum)); + var vnode2 = h('span', {key: 'span'}, [spanNum(1), h('i', {key: 2}, '2'), spanNum(3)]); + elm = patch(vnode0, vnode1).elm; + assert.deepEqual(map(inner, elm.children), ['1', '2', '3']); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['1', '2', '3']); + assert.equal(elm.children.length, 3); + assert.equal(elm.children[1].tagName, 'I'); + }); + }); + describe('removal of elements', function() { + it('removes elements from the beginning', function() { + var vnode1 = h('span', [1, 2, 3, 4, 5].map(spanNum)); + var vnode2 = h('span', [3, 4, 5].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 5); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['3', '4', '5']); + }); + it('removes elements from the end', function() { + var vnode1 = h('span', [1, 2, 3, 4, 5].map(spanNum)); + var vnode2 = h('span', [1, 2, 3].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 5); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 3); + assert.equal(elm.children[0].innerHTML, '1'); + assert.equal(elm.children[1].innerHTML, '2'); + assert.equal(elm.children[2].innerHTML, '3'); + }); + it('removes elements from the middle', function() { + var vnode1 = h('span', [1, 2, 3, 4, 5].map(spanNum)); + var vnode2 = h('span', [1, 2, 4, 5].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 5); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 4); + assert.deepEqual(elm.children[0].innerHTML, '1'); + assert.equal(elm.children[0].innerHTML, '1'); + assert.equal(elm.children[1].innerHTML, '2'); + assert.equal(elm.children[2].innerHTML, '4'); + assert.equal(elm.children[3].innerHTML, '5'); + }); + }); + describe('element reordering', function() { + it('moves element forward', function() { + var vnode1 = h('span', [1, 2, 3, 4].map(spanNum)); + var vnode2 = h('span', [2, 3, 1, 4].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 4); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 4); + assert.equal(elm.children[0].innerHTML, '2'); + assert.equal(elm.children[1].innerHTML, '3'); + assert.equal(elm.children[2].innerHTML, '1'); + assert.equal(elm.children[3].innerHTML, '4'); + }); + it('moves element to end', function() { + var vnode1 = h('span', [1, 2, 3].map(spanNum)); + var vnode2 = h('span', [2, 3, 1].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 3); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 3); + assert.equal(elm.children[0].innerHTML, '2'); + assert.equal(elm.children[1].innerHTML, '3'); + assert.equal(elm.children[2].innerHTML, '1'); + }); + it('moves element backwards', function() { + var vnode1 = h('span', [1, 2, 3, 4].map(spanNum)); + var vnode2 = h('span', [1, 4, 2, 3].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 4); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 4); + assert.equal(elm.children[0].innerHTML, '1'); + assert.equal(elm.children[1].innerHTML, '4'); + assert.equal(elm.children[2].innerHTML, '2'); + assert.equal(elm.children[3].innerHTML, '3'); + }); + it('swaps first and last', function() { + var vnode1 = h('span', [1, 2, 3, 4].map(spanNum)); + var vnode2 = h('span', [4, 2, 3, 1].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 4); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 4); + assert.equal(elm.children[0].innerHTML, '4'); + assert.equal(elm.children[1].innerHTML, '2'); + assert.equal(elm.children[2].innerHTML, '3'); + assert.equal(elm.children[3].innerHTML, '1'); + }); + }); + describe('combinations of additions, removals and reorderings', function() { + it('move to left and replace', function() { + var vnode1 = h('span', [1, 2, 3, 4, 5].map(spanNum)); + var vnode2 = h('span', [4, 1, 2, 3, 6].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 5); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 5); + assert.equal(elm.children[0].innerHTML, '4'); + assert.equal(elm.children[1].innerHTML, '1'); + assert.equal(elm.children[2].innerHTML, '2'); + assert.equal(elm.children[3].innerHTML, '3'); + assert.equal(elm.children[4].innerHTML, '6'); + }); + it('moves to left and leaves hole', function() { + var vnode1 = h('span', [1, 4, 5].map(spanNum)); + var vnode2 = h('span', [4, 6].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 3); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['4', '6']); + }); + it('handles moved and set to undefined element ending at the end', function() { + var vnode1 = h('span', [2, 4, 5].map(spanNum)); + var vnode2 = h('span', [4, 5, 3].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 3); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 3); + assert.equal(elm.children[0].innerHTML, '4'); + assert.equal(elm.children[1].innerHTML, '5'); + assert.equal(elm.children[2].innerHTML, '3'); + }); + it('moves a key in non-keyed nodes with a size up', function() { + var vnode1 = h('span', [1, 'a', 'b', 'c'].map(spanNum)); + var vnode2 = h('span', ['d', 'a', 'b', 'c', 1, 'e'].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.childNodes.length, 4); + assert.equal(elm.textContent, '1abc'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.childNodes.length, 6); + assert.equal(elm.textContent, 'dabc1e'); + }); + }); + it('reverses elements', function() { + var vnode1 = h('span', [1, 2, 3, 4, 5, 6, 7, 8].map(spanNum)); + var vnode2 = h('span', [8, 7, 6, 5, 4, 3, 2, 1].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 8); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['8', '7', '6', '5', '4', '3', '2', '1']); + }); + it('something', function() { + var vnode1 = h('span', [0, 1, 2, 3, 4, 5].map(spanNum)); + var vnode2 = h('span', [4, 3, 2, 1, 5, 0].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 6); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['4', '3', '2', '1', '5', '0']); + }); + it('handles random shuffles', function() { + var n, i, arr = [], opacities = [], elms = 14, samples = 5; + function spanNumWithOpacity(n, o) { + return h('span', {key: n, style: {opacity: o}}, n.toString()); + } + for (n = 0; n < elms; ++n) { arr[n] = n; } + for (n = 0; n < samples; ++n) { + var vnode1 = h('span', arr.map(function(n) { + return spanNumWithOpacity(n, '1'); + })); + var shufArr = shuffle(arr.slice(0)); + var elm = document.createElement('div'); + elm = patch(elm, vnode1).elm; + for (i = 0; i < elms; ++i) { + assert.equal(elm.children[i].innerHTML, i.toString()); + opacities[i] = Math.random().toFixed(5).toString(); + } + var vnode2 = h('span', arr.map(function(n) { + return spanNumWithOpacity(shufArr[n], opacities[n]); + })); + elm = patch(vnode1, vnode2).elm; + for (i = 0; i < elms; ++i) { + assert.equal(elm.children[i].innerHTML, shufArr[i].toString()); + assert.equal(opacities[i].indexOf(elm.children[i].style.opacity), 0); + } + } + }); + it('supports null/undefined children', function() { + var vnode1 = h('i', [0, 1, 2, 3, 4, 5].map(spanNum)); + var vnode2 = h('i', [null, 2, undefined, null, 1, 0, null, 5, 4, null, 3, undefined].map(spanNum)); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 6); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['2', '1', '0', '5', '4', '3']); + }); + it('supports all null/undefined children', function() { + var vnode1 = h('i', [0, 1, 2, 3, 4, 5].map(spanNum)); + var vnode2 = h('i', [null, null, undefined, null, null, undefined]); + var vnode3 = h('i', [5, 4, 3, 2, 1, 0].map(spanNum)); + patch(vnode0, vnode1); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 0); + elm = patch(vnode2, vnode3).elm; + assert.deepEqual(map(inner, elm.children), ['5', '4', '3', '2', '1', '0']); + }); + it('handles random shuffles with null/undefined children', function() { + var i, j, r, len, arr, maxArrLen = 15, samples = 5, vnode1 = vnode0, vnode2; + for (i = 0; i < samples; ++i, vnode1 = vnode2) { + len = Math.floor(Math.random() * maxArrLen); + arr = []; + for (j = 0; j < len; ++j) { + if ((r = Math.random()) < 0.5) arr[j] = String(j); + else if (r < 0.75) arr[j] = null; + else arr[j] = undefined; + } + shuffle(arr); + vnode2 = h('div', arr.map(spanNum)); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), arr.filter(function(x) {return x != null;})); + } + }); + }); + describe('updating children without keys', function() { + it('appends elements', function() { + var vnode1 = h('div', [h('span', 'Hello')]); + var vnode2 = h('div', [h('span', 'Hello'), h('span', 'World')]); + elm = patch(vnode0, vnode1).elm; + assert.deepEqual(map(inner, elm.children), ['Hello']); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['Hello', 'World']); + }); + it('handles unmoved text nodes', function() { + var vnode1 = h('div', ['Text', h('span', 'Span')]); + var vnode2 = h('div', ['Text', h('span', 'Span')]); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.childNodes[0].textContent, 'Text'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.childNodes[0].textContent, 'Text'); + }); + it('handles changing text children', function() { + var vnode1 = h('div', ['Text', h('span', 'Span')]); + var vnode2 = h('div', ['Text2', h('span', 'Span')]); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.childNodes[0].textContent, 'Text'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.childNodes[0].textContent, 'Text2'); + }); + it('handles unmoved comment nodes', function() { + var vnode1 = h('div', [h('!', 'Text'), h('span', 'Span')]); + var vnode2 = h('div', [h('!', 'Text'), h('span', 'Span')]); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.childNodes[0].textContent, 'Text'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.childNodes[0].textContent, 'Text'); + }); + it('handles changing comment text', function() { + var vnode1 = h('div', [h('!', 'Text'), h('span', 'Span')]); + var vnode2 = h('div', [h('!', 'Text2'), h('span', 'Span')]); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.childNodes[0].textContent, 'Text'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.childNodes[0].textContent, 'Text2'); + }); + it('handles changing empty comment', function() { + var vnode1 = h('div', [h('!'), h('span', 'Span')]); + var vnode2 = h('div', [h('!', 'Test'), h('span', 'Span')]); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.childNodes[0].textContent, ''); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.childNodes[0].textContent, 'Test'); + }); + it('prepends element', function() { + var vnode1 = h('div', [h('span', 'World')]); + var vnode2 = h('div', [h('span', 'Hello'), h('span', 'World')]); + elm = patch(vnode0, vnode1).elm; + assert.deepEqual(map(inner, elm.children), ['World']); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['Hello', 'World']); + }); + it('prepends element of different tag type', function() { + var vnode1 = h('div', [h('span', 'World')]); + var vnode2 = h('div', [h('div', 'Hello'), h('span', 'World')]); + elm = patch(vnode0, vnode1).elm; + assert.deepEqual(map(inner, elm.children), ['World']); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(prop('tagName'), elm.children), ['DIV', 'SPAN']); + assert.deepEqual(map(inner, elm.children), ['Hello', 'World']); + }); + it('removes elements', function() { + var vnode1 = h('div', [h('span', 'One'), h('span', 'Two'), h('span', 'Three')]); + var vnode2 = h('div', [h('span', 'One'), h('span', 'Three')]); + elm = patch(vnode0, vnode1).elm; + assert.deepEqual(map(inner, elm.children), ['One', 'Two', 'Three']); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['One', 'Three']); + }); + it('removes a single text node', function() { + var vnode1 = h('div', 'One'); + var vnode2 = h('div'); + patch(vnode0, vnode1); + assert.equal(elm.textContent, 'One'); + patch(vnode1, vnode2); + assert.equal(elm.textContent, ''); + }); + it('removes a single text node when children are updated', function() { + var vnode1 = h('div', 'One'); + var vnode2 = h('div', [ h('div', 'Two'), h('span', 'Three') ]); + patch(vnode0, vnode1); + assert.equal(elm.textContent, 'One'); + patch(vnode1, vnode2); + assert.deepEqual(map(prop('textContent'), elm.childNodes), ['Two', 'Three']); + }); + it('removes a text node among other elements', function() { + var vnode1 = h('div', [ 'One', h('span', 'Two') ]); + var vnode2 = h('div', [ h('div', 'Three')]); + patch(vnode0, vnode1); + assert.deepEqual(map(prop('textContent'), elm.childNodes), ['One', 'Two']); + patch(vnode1, vnode2); + assert.equal(elm.childNodes.length, 1); + assert.equal(elm.childNodes[0].tagName, 'DIV'); + assert.equal(elm.childNodes[0].textContent, 'Three'); + }); + it('reorders elements', function() { + var vnode1 = h('div', [h('span', 'One'), h('div', 'Two'), h('b', 'Three')]); + var vnode2 = h('div', [h('b', 'Three'), h('span', 'One'), h('div', 'Two')]); + elm = patch(vnode0, vnode1).elm; + assert.deepEqual(map(inner, elm.children), ['One', 'Two', 'Three']); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(prop('tagName'), elm.children), ['B', 'SPAN', 'DIV']); + assert.deepEqual(map(inner, elm.children), ['Three', 'One', 'Two']); + }); + it('supports null/undefined children', function() { + var vnode1 = h('i', [null, h('i', '1'), h('i', '2'), null]); + var vnode2 = h('i', [h('i', '2'), undefined, undefined, h('i', '1'), undefined]); + var vnode3 = h('i', [null, h('i', '1'), undefined, null, h('i', '2'), undefined, null]); + elm = patch(vnode0, vnode1).elm; + assert.deepEqual(map(inner, elm.children), ['1', '2']); + elm = patch(vnode1, vnode2).elm; + assert.deepEqual(map(inner, elm.children), ['2', '1']); + elm = patch(vnode2, vnode3).elm; + assert.deepEqual(map(inner, elm.children), ['1', '2']); + }); + it('supports all null/undefined children', function() { + var vnode1 = h('i', [h('i', '1'), h('i', '2')]); + var vnode2 = h('i', [null, undefined]); + var vnode3 = h('i', [h('i', '2'), h('i', '1')]); + patch(vnode0, vnode1); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 0); + elm = patch(vnode2, vnode3).elm; + assert.deepEqual(map(inner, elm.children), ['2', '1']); + }); + }); + }); + describe('hooks', function() { + describe('element hooks', function() { + it('calls `create` listener before inserted into parent but after children', function() { + var result = []; + function cb(empty, vnode) { + assert(vnode.elm instanceof Element); + assert.equal(vnode.elm.children.length, 2); + assert.strictEqual(vnode.elm.parentNode, null); + result.push(vnode); + } + var vnode1 = h('div', [ + h('span', 'First sibling'), + h('div', {hook: {create: cb}}, [ + h('span', 'Child 1'), + h('span', 'Child 2'), + ]), + h('span', 'Can\'t touch me'), + ]); + patch(vnode0, vnode1); + assert.equal(1, result.length); + }); + it('calls `insert` listener after both parents, siblings and children have been inserted', function() { + var result = []; + function cb(vnode) { + assert(vnode.elm instanceof Element); + assert.equal(vnode.elm.children.length, 2); + assert.equal(vnode.elm.parentNode.children.length, 3); + result.push(vnode); + } + var vnode1 = h('div', [ + h('span', 'First sibling'), + h('div', {hook: {insert: cb}}, [ + h('span', 'Child 1'), + h('span', 'Child 2'), + ]), + h('span', 'Can touch me'), + ]); + patch(vnode0, vnode1); + assert.equal(1, result.length); + }); + it('calls `prepatch` listener', function() { + var result = []; + function cb(oldVnode, vnode) { + assert.strictEqual(oldVnode, vnode1.children[1]); + assert.strictEqual(vnode, vnode2.children[1]); + result.push(vnode); + } + var vnode1 = h('div', [ + h('span', 'First sibling'), + h('div', {hook: {prepatch: cb}}, [ + h('span', 'Child 1'), + h('span', 'Child 2'), + ]), + ]); + var vnode2 = h('div', [ + h('span', 'First sibling'), + h('div', {hook: {prepatch: cb}}, [ + h('span', 'Child 1'), + h('span', 'Child 2'), + ]), + ]); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(result.length, 1); + }); + it('calls `postpatch` after `prepatch` listener', function() { + var pre = [], post = []; + function preCb(oldVnode, vnode) { + pre.push(pre); + } + function postCb(oldVnode, vnode) { + assert.equal(pre.length, post.length + 1); + post.push(post); + } + var vnode1 = h('div', [ + h('span', 'First sibling'), + h('div', {hook: {prepatch: preCb, postpatch: postCb}}, [ + h('span', 'Child 1'), + h('span', 'Child 2'), + ]), + ]); + var vnode2 = h('div', [ + h('span', 'First sibling'), + h('div', {hook: {prepatch: preCb, postpatch: postCb}}, [ + h('span', 'Child 1'), + h('span', 'Child 2'), + ]), + ]); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(pre.length, 1); + assert.equal(post.length, 1); + }); + it('calls `update` listener', function() { + var result1 = []; + var result2 = []; + function cb(result, oldVnode, vnode) { + if (result.length > 0) { + console.log(result[result.length-1]); + console.log(oldVnode); + assert.strictEqual(result[result.length-1], oldVnode); + } + result.push(vnode); + } + var vnode1 = h('div', [ + h('span', 'First sibling'), + h('div', {hook: {update: cb.bind(null, result1)}}, [ + h('span', 'Child 1'), + h('span', {hook: {update: cb.bind(null, result2)}}, 'Child 2'), + ]), + ]); + var vnode2 = h('div', [ + h('span', 'First sibling'), + h('div', {hook: {update: cb.bind(null, result1)}}, [ + h('span', 'Child 1'), + h('span', {hook: {update: cb.bind(null, result2)}}, 'Child 2'), + ]), + ]); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(result1.length, 1); + assert.equal(result2.length, 1); + }); + it('calls `remove` listener', function() { + var result = []; + function cb(vnode, rm) { + var parent = vnode.elm.parentNode; + assert(vnode.elm instanceof Element); + assert.equal(vnode.elm.children.length, 2); + assert.equal(parent.children.length, 2); + result.push(vnode); + rm(); + assert.equal(parent.children.length, 1); + } + var vnode1 = h('div', [ + h('span', 'First sibling'), + h('div', {hook: {remove: cb}}, [ + h('span', 'Child 1'), + h('span', 'Child 2'), + ]), + ]); + var vnode2 = h('div', [ + h('span', 'First sibling'), + ]); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(1, result.length); + }); + it('calls `destroy` listener when patching text node over node with children', function() { + var calls = 0; + function cb(vnode) { + calls++; + } + var vnode1 = h('div', [ + h('div', {hook: {destroy: cb}}, [ + h('span', 'Child 1'), + ]), + ]); + var vnode2 = h('div', 'Text node') + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(calls, 1); + }); + it('calls `init` and `prepatch` listeners on root', function() { + var count = 0; + function init(vnode) { + assert.strictEqual(vnode, vnode2); + count += 1; + } + function prepatch(oldVnode, vnode) { + assert.strictEqual(vnode, vnode1); + count += 1; + } + var vnode1 = h('div', {hook: {init: init, prepatch: prepatch}}); + patch(vnode0, vnode1); + assert.equal(1, count); + var vnode2 = h('span', {hook: {init: init, prepatch: prepatch}}); + patch(vnode1, vnode2); + assert.equal(2, count); + }); + it('removes element when all remove listeners are done', function() { + var rm1, rm2, rm3; + var patch = snabbdom.init([ + {remove: function(_, rm) { rm1 = rm; }}, + {remove: function(_, rm) { rm2 = rm; }}, + ]); + var vnode1 = h('div', [h('a', {hook: {remove: function(_, rm) { rm3 = rm; }}})]); + var vnode2 = h('div', []); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.children.length, 1); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.children.length, 1); + rm1(); + assert.equal(elm.children.length, 1); + rm3(); + assert.equal(elm.children.length, 1); + rm2(); + assert.equal(elm.children.length, 0); + }); + it('invokes remove hook on replaced root', function() { + var result = []; + var parent = document.createElement('div'); + var vnode0 = document.createElement('div'); + parent.appendChild(vnode0); + function cb(vnode, rm) { + result.push(vnode); + rm(); + } + var vnode1 = h('div', {hook: {remove: cb}}, [ + h('b', 'Child 1'), + h('i', 'Child 2'), + ]); + var vnode2 = h('span', [ + h('b', 'Child 1'), + h('i', 'Child 2'), + ]); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(1, result.length); + }); + }); + describe('module hooks', function() { + it('invokes `pre` and `post` hook', function() { + var result = []; + var patch = snabbdom.init([ + {pre: function() { result.push('pre'); }}, + {post: function() { result.push('post'); }}, + ]); + var vnode1 = h('div'); + patch(vnode0, vnode1); + assert.deepEqual(result, ['pre', 'post']); + }); + it('invokes global `destroy` hook for all removed children', function() { + var result = []; + function cb(vnode) { result.push(vnode); } + var vnode1 = h('div', [ + h('span', 'First sibling'), + h('div', [ + h('span', {hook: {destroy: cb}}, 'Child 1'), + h('span', 'Child 2'), + ]), + ]); + var vnode2 = h('div'); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(result.length, 1); + }); + it('handles text vnodes with `undefined` `data` property', function() { + var vnode1 = h('div', [ + ' ' + ]); + var vnode2 = h('div', []); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + }); + it('invokes `destroy` module hook for all removed children', function() { + var created = 0; + var destroyed = 0; + var patch = snabbdom.init([ + {create: function() { created++; }}, + {destroy: function() { destroyed++; }}, + ]); + var vnode1 = h('div', [ + h('span', 'First sibling'), + h('div', [ + h('span', 'Child 1'), + h('span', 'Child 2'), + ]), + ]); + var vnode2 = h('div'); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(created, 4); + assert.equal(destroyed, 4); + }); + it('does not invoke `create` and `remove` module hook for text nodes', function() { + var created = 0; + var removed = 0; + var patch = snabbdom.init([ + {create: function() { created++; }}, + {remove: function() { removed++; }}, + ]); + var vnode1 = h('div', [ + h('span', 'First child'), + '', + h('span', 'Third child'), + ]); + var vnode2 = h('div'); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(created, 2); + assert.equal(removed, 2); + }); + it('does not invoke `destroy` module hook for text nodes', function() { + var created = 0; + var destroyed = 0; + var patch = snabbdom.init([ + {create: function() { created++; }}, + {destroy: function() { destroyed++; }}, + ]); + var vnode1 = h('div', [ + h('span', 'First sibling'), + h('div', [ + h('span', 'Child 1'), + h('span', ['Text 1', 'Text 2']), + ]), + ]); + var vnode2 = h('div'); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(created, 4); + assert.equal(destroyed, 4); + }); + }); + }); + describe('short circuiting', function() { + it('does not update strictly equal vnodes', function() { + var result = []; + function cb(vnode) { result.push(vnode); } + var vnode1 = h('div', [ + h('span', {hook: {update: cb}}, 'Hello'), + h('span', 'there'), + ]); + patch(vnode0, vnode1); + patch(vnode1, vnode1); + assert.equal(result.length, 0); + }); + it('does not update strictly equal children', function() { + var result = []; + function cb(vnode) { result.push(vnode); } + var vnode1 = h('div', [ + h('span', {hook: {patch: cb}}, 'Hello'), + h('span', 'there'), + ]); + var vnode2 = h('div'); + vnode2.children = vnode1.children; + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(result.length, 0); + }); + }); +}); diff --git a/src/libs/snabbdom/test/dataset.js b/src/libs/snabbdom/test/dataset.js new file mode 100755 index 00000000..fe72ec4a --- /dev/null +++ b/src/libs/snabbdom/test/dataset.js @@ -0,0 +1,56 @@ +var assert = require('assert'); +var fakeRaf = require('fake-raf'); + +var snabbdom = require('../snabbdom'); +fakeRaf.use(); +var patch = snabbdom.init([ + require('../modules/dataset').default, +]); +var h = require('../h').default; + +describe('dataset', function() { + var elm, vnode0; + beforeEach(function() { + elm = document.createElement('div'); + vnode0 = elm; + }); + it('is set on initial element creation', function() { + elm = patch(vnode0, h('div', {dataset: {foo: 'foo'}})).elm; + assert.equal(elm.dataset.foo, 'foo'); + }); + it('updates dataset', function() { + var vnode1 = h('i', {dataset: {foo: 'foo', bar: 'bar'}}); + var vnode2 = h('i', {dataset: {baz: 'baz'}}); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.dataset.foo, 'foo'); + assert.equal(elm.dataset.bar, 'bar'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.dataset.baz, 'baz'); + assert.equal(elm.dataset.foo, undefined); + }); + it('can be memoized', function() { + var cachedDataset = {foo: 'foo', bar: 'bar'}; + var vnode1 = h('i', {dataset: cachedDataset}); + var vnode2 = h('i', {dataset: cachedDataset}); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.dataset.foo, 'foo'); + assert.equal(elm.dataset.bar, 'bar'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.dataset.foo, 'foo'); + assert.equal(elm.dataset.bar, 'bar'); + }); + it('handles string conversions', function() { + var vnode1 = h('i', {dataset: {empty: '', dash: '-', dashed:'foo-bar', camel: 'fooBar', integer:0, float:0.1}}); + elm = patch(vnode0, vnode1).elm; + + assert.equal(elm.dataset.empty, ''); + assert.equal(elm.dataset.dash, '-'); + assert.equal(elm.dataset.dashed, 'foo-bar'); + assert.equal(elm.dataset.camel, 'fooBar'); + assert.equal(elm.dataset.integer, '0'); + assert.equal(elm.dataset.float, '0.1'); + }); + +}); + +fakeRaf.restore(); diff --git a/src/libs/snabbdom/test/eventlisteners.js b/src/libs/snabbdom/test/eventlisteners.js new file mode 100755 index 00000000..a9e5b664 --- /dev/null +++ b/src/libs/snabbdom/test/eventlisteners.js @@ -0,0 +1,178 @@ +var assert = require('assert'); + +var snabbdom = require('../snabbdom'); +var patch = snabbdom.init([ + require('../modules/eventlisteners.js').default, +]); +var h = require('../h').default; + +describe('event listeners', function() { + var elm, vnode0; + beforeEach(function() { + elm = document.createElement('div'); + vnode0 = elm; + }); + it('attaches click event handler to element', function() { + var result = []; + function clicked(ev) { result.push(ev); } + var vnode = h('div', {on: {click: clicked}}, [ + h('a', 'Click my parent'), + ]); + elm = patch(vnode0, vnode).elm; + elm.click(); + assert.equal(1, result.length); + }); + it('does not attach new listener', function() { + var result = []; + //function clicked(ev) { result.push(ev); } + var vnode1 = h('div', {on: {click: function(ev) { result.push(1); }}}, [ + h('a', 'Click my parent'), + ]); + var vnode2 = h('div', {on: {click: function(ev) { result.push(2); }}}, [ + h('a', 'Click my parent'), + ]); + elm = patch(vnode0, vnode1).elm; + elm.click(); + elm = patch(vnode1, vnode2).elm; + elm.click(); + assert.deepEqual(result, [1, 2]); + }); + it('does calls handler for function in array', function() { + var result = []; + function clicked(ev) { result.push(ev); } + var vnode = h('div', {on: {click: [clicked, 1]}}, [ + h('a', 'Click my parent'), + ]); + elm = patch(vnode0, vnode).elm; + elm.click(); + assert.deepEqual(result, [1]); + }); + it('handles changed value in array', function() { + var result = []; + function clicked(ev) { result.push(ev); } + var vnode1 = h('div', {on: {click: [clicked, 1]}}, [ + h('a', 'Click my parent'), + ]); + var vnode2 = h('div', {on: {click: [clicked, 2]}}, [ + h('a', 'Click my parent'), + ]); + var vnode3 = h('div', {on: {click: [clicked, 3]}}, [ + h('a', 'Click my parent'), + ]); + elm = patch(vnode0, vnode1).elm; + elm.click(); + elm = patch(vnode1, vnode2).elm; + elm.click(); + elm = patch(vnode2, vnode3).elm; + elm.click(); + assert.deepEqual(result, [1, 2, 3]); + }); + it('handles changed several values in array', function() { + var result = []; + function clicked() { result.push([].slice.call(arguments, 0, arguments.length-2)); } + var vnode1 = h('div', {on: {click: [clicked, 1, 2, 3]}}, [ + h('a', 'Click my parent'), + ]); + var vnode2 = h('div', {on: {click: [clicked, 1, 2]}}, [ + h('a', 'Click my parent'), + ]); + var vnode3 = h('div', {on: {click: [clicked, 2, 3]}}, [ + h('a', 'Click my parent'), + ]); + elm = patch(vnode0, vnode1).elm; + elm.click(); + elm = patch(vnode1, vnode2).elm; + elm.click(); + elm = patch(vnode2, vnode3).elm; + elm.click(); + assert.deepEqual(result, [[1, 2, 3], [1, 2], [2, 3]]); + }); + it('detach attached click event handler to element', function() { + var result = []; + function clicked(ev) { result.push(ev); } + var vnode1 = h('div', {on: {click: clicked}}, [ + h('a', 'Click my parent'), + ]); + elm = patch(vnode0, vnode1).elm; + elm.click(); + assert.equal(1, result.length); + var vnode2 = h('div', {on: {}}, [ + h('a', 'Click my parent'), + ]); + elm = patch(vnode1, vnode2).elm; + elm.click(); + assert.equal(1, result.length); + }); + it('multiple event handlers for same event on same element', function() { + var called = 0; + function clicked(ev, vnode) { + ++called; + // Check that the first argument is an event + assert.equal(true, 'target' in ev); + // Check that the second argument was a vnode + assert.equal(vnode.sel, 'div'); + } + var vnode1 = h('div', {on: {click: [[clicked], [clicked], [clicked]]}}, [ + h('a', 'Click my parent'), + ]); + elm = patch(vnode0, vnode1).elm; + elm.click(); + assert.equal(3, called); + var vnode2 = h('div', {on: {click: [[clicked], [clicked]]}}, [ + h('a', 'Click my parent'), + ]); + elm = patch(vnode1, vnode2).elm; + elm.click(); + assert.equal(5, called); + }); + it('access to virtual node in event handler', function() { + var result = []; + function clicked(ev, vnode) { result.push(this); result.push(vnode); } + var vnode1 = h('div', {on: {click: clicked }}, [ + h('a', 'Click my parent'), + ]); + elm = patch(vnode0, vnode1).elm; + elm.click(); + assert.equal(2, result.length); + assert.equal(vnode1, result[0]); + assert.equal(vnode1, result[1]); + }), + it('access to virtual node in event handler with argument', function() { + var result = []; + function clicked(arg, ev, vnode) { result.push(this); result.push(vnode); } + var vnode1 = h('div', {on: {click: [clicked, 1] }}, [ + h('a', 'Click my parent'), + ]); + elm = patch(vnode0, vnode1).elm; + elm.click(); + assert.equal(2, result.length); + assert.equal(vnode1, result[0]); + assert.equal(vnode1, result[1]); + }), + it('access to virtual node in event handler with arguments', function() { + var result = []; + function clicked(arg1, arg2, ev, vnode) { result.push(this); result.push(vnode); } + var vnode1 = h('div', {on: {click: [clicked, 1, "2"] }}, [ + h('a', 'Click my parent'), + ]); + elm = patch(vnode0, vnode1).elm; + elm.click(); + assert.equal(2, result.length); + assert.equal(vnode1, result[0]); + assert.equal(vnode1, result[1]); + }); + it('shared handlers in parent and child nodes', function() { + var result = []; + var sharedHandlers = { + click: function(ev) { result.push(ev); } + }; + var vnode1 = h('div', {on: sharedHandlers}, [ + h('a', {on: sharedHandlers}, 'Click my parent'), + ]); + elm = patch(vnode0, vnode1).elm; + elm.click(); + assert.equal(1, result.length); + elm.firstChild.click(); + assert.equal(3, result.length); + }); +}); diff --git a/src/libs/snabbdom/test/htmldomapi.js b/src/libs/snabbdom/test/htmldomapi.js new file mode 100755 index 00000000..61135520 --- /dev/null +++ b/src/libs/snabbdom/test/htmldomapi.js @@ -0,0 +1,53 @@ +var assert = require('assert'); + +var snabbdom = require('../snabbdom'); +var h = require('../h').default; +var patch = snabbdom.init([ + require('../modules/attributes').default +]); + +describe('svg', function () { + var elm, vnode0; + beforeEach(function() { + elm = document.createElement('svg'); + vnode0 = elm; + }); + + it('removes child svg elements', function(){ + var a = h('svg', {}, [ + h('g'), + h('g') + ]); + var b = h('svg', {}, [ + h('g') + ]); + var result = patch(patch(vnode0, a), b).elm; + assert.equal(result.childNodes.length, 1); + }); + + it('adds correctly xlink namespaced attribute', function(){ + var xlinkNS = 'http://www.w3.org/1999/xlink'; + var testUrl = '/test'; + var a = h('svg', {}, [ + h('use', { + attrs: { 'xlink:href': testUrl } + }, []) + ]); + + var result = patch(vnode0, a).elm; + assert.equal(result.childNodes.length, 1); + assert.equal(result.childNodes[0].getAttribute('xlink:href'), testUrl); + assert.equal(result.childNodes[0].getAttributeNS(xlinkNS,'href'), testUrl); + + }); + + it('adds correctly xml namespaced attribute', function(){ + var xmlNS = 'http://www.w3.org/XML/1998/namespace'; + var testAttrValue = 'und'; + var a = h('svg', { attrs: { 'xml:lang': testAttrValue } }, []); + + var result = patch(vnode0, a).elm; + assert.equal(result.getAttributeNS(xmlNS, 'lang'), testAttrValue); + assert.equal(result.getAttribute('xml:lang'), testAttrValue); + }); +}) \ No newline at end of file diff --git a/src/libs/snabbdom/test/style.js b/src/libs/snabbdom/test/style.js new file mode 100755 index 00000000..33e6aeda --- /dev/null +++ b/src/libs/snabbdom/test/style.js @@ -0,0 +1,151 @@ +var assert = require('assert'); +var fakeRaf = require('fake-raf'); + +var snabbdom = require('../snabbdom'); +fakeRaf.use(); +var patch = snabbdom.init([ + require('../modules/style').default, +]); +var h = require('../h').default; +var toVNode = require('../tovnode').default; + +describe('style', function() { + var elm, vnode0; + beforeEach(function() { + elm = document.createElement('div'); + vnode0 = elm; + }); + it('is being styled', function() { + elm = patch(vnode0, h('div', {style: {fontSize: '12px'}})).elm; + assert.equal(elm.style.fontSize, '12px'); + }); + it('can be memoized', function() { + var cachedStyles = {fontSize: '14px', display: 'inline'}; + var vnode1 = h('i', {style: cachedStyles}); + var vnode2 = h('i', {style: cachedStyles}); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.style.fontSize, '14px'); + assert.equal(elm.style.display, 'inline'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.style.fontSize, '14px'); + assert.equal(elm.style.display, 'inline'); + }); + it('updates styles', function() { + var vnode1 = h('i', {style: {fontSize: '14px', display: 'inline'}}); + var vnode2 = h('i', {style: {fontSize: '12px', display: 'block'}}); + var vnode3 = h('i', {style: {fontSize: '10px', display: 'block'}}); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.style.fontSize, '14px'); + assert.equal(elm.style.display, 'inline'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.style.fontSize, '12px'); + assert.equal(elm.style.display, 'block'); + elm = patch(vnode2, vnode3).elm; + assert.equal(elm.style.fontSize, '10px'); + assert.equal(elm.style.display, 'block'); + }); + it('explicialy removes styles', function() { + var vnode1 = h('i', {style: {fontSize: '14px'}}); + var vnode2 = h('i', {style: {fontSize: ''}}); + var vnode3 = h('i', {style: {fontSize: '10px'}}); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.style.fontSize, '14px'); + patch(vnode1, vnode2); + assert.equal(elm.style.fontSize, ''); + patch(vnode2, vnode3); + assert.equal(elm.style.fontSize, '10px'); + }); + it('implicially removes styles from element', function() { + var vnode1 = h('div', [h('i', {style: {fontSize: '14px'}})]); + var vnode2 = h('div', [h('i')]); + var vnode3 = h('div', [h('i', {style: {fontSize: '10px'}})]); + patch(vnode0, vnode1); + assert.equal(elm.firstChild.style.fontSize, '14px'); + patch(vnode1, vnode2); + assert.equal(elm.firstChild.style.fontSize, ''); + patch(vnode2, vnode3); + assert.equal(elm.firstChild.style.fontSize, '10px'); + }); + it('updates css variables', function() { + var vnode1 = h('div', {style: {'--myVar': 1}}); + var vnode2 = h('div', {style: {'--myVar': 2}}); + var vnode3 = h('div', {style: {'--myVar': 3}}); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.style.getPropertyValue('--myVar'), 1); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.style.getPropertyValue('--myVar'), 2); + elm = patch(vnode2, vnode3).elm; + assert.equal(elm.style.getPropertyValue('--myVar'), 3); + }); + it('explicialy removes css variables', function() { + var vnode1 = h('i', {style: {'--myVar': 1}}); + var vnode2 = h('i', {style: {'--myVar': ''}}); + var vnode3 = h('i', {style: {'--myVar': 2}}); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.style.getPropertyValue('--myVar'), 1); + patch(vnode1, vnode2); + assert.equal(elm.style.getPropertyValue('--myVar'), ''); + patch(vnode2, vnode3); + assert.equal(elm.style.getPropertyValue('--myVar'), 2); + }); + it('implicially removes css variables from element', function() { + var vnode1 = h('div', [h('i', {style: {'--myVar': 1}})]); + var vnode2 = h('div', [h('i')]); + var vnode3 = h('div', [h('i', {style: {'--myVar': 2}})]); + patch(vnode0, vnode1); + assert.equal(elm.firstChild.style.getPropertyValue('--myVar'), 1); + patch(vnode1, vnode2); + assert.equal(elm.firstChild.style.getPropertyValue('--myVar'), ''); + patch(vnode2, vnode3); + assert.equal(elm.firstChild.style.getPropertyValue('--myVar'), 2); + }); + it('updates delayed styles in next frame', function() { + var patch = snabbdom.init([ + require('../modules/style').default, + ]); + var vnode1 = h('i', {style: {fontSize: '14px', delayed: {fontSize: '16px'}}}); + var vnode2 = h('i', {style: {fontSize: '18px', delayed: {fontSize: '20px'}}}); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.style.fontSize, '14px'); + fakeRaf.step(); + fakeRaf.step(); + assert.equal(elm.style.fontSize, '16px'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.style.fontSize, '18px'); + fakeRaf.step(); + fakeRaf.step(); + assert.equal(elm.style.fontSize, '20px'); + }); + it('applies tranform as transition on remove', function(done) { + var btn = h('button', { style: { + transition: 'transform 0.5s', + remove: { transform: 'translateY(100%)' } + }}, ['A button']); + var vnode1 = h('div.parent', {}, [btn]); + var vnode2 = h('div.parent', {}, [null]); + document.body.appendChild(vnode0); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.strictEqual(document.querySelectorAll('button').length, 1); + setTimeout(function () { + assert.strictEqual(document.querySelectorAll('button').length, 0); + done(); + }, 700); + }); + describe('using toVNode()', function () { + it('handles (ignoring) comment nodes', function() { + var comment = document.createComment('yolo'); + var prevElm = document.createElement('div'); + prevElm.appendChild(comment); + var nextVNode = h('div', [h('span', 'Hi')]); + elm = patch(toVNode(prevElm), nextVNode).elm; + assert.strictEqual(elm, prevElm); + assert.equal(elm.tagName, 'DIV'); + assert.strictEqual(elm.childNodes.length, 1); + assert.strictEqual(elm.childNodes[0].tagName, 'SPAN'); + assert.strictEqual(elm.childNodes[0].textContent, 'Hi'); + }); + }); +}); + +fakeRaf.restore(); diff --git a/src/libs/snabbdom/test/thunk.js b/src/libs/snabbdom/test/thunk.js new file mode 100755 index 00000000..457a6368 --- /dev/null +++ b/src/libs/snabbdom/test/thunk.js @@ -0,0 +1,232 @@ +var assert = require('assert'); + +var snabbdom = require('../snabbdom'); +var patch = snabbdom.init([ +]); +var h = require('../h').default; +var thunk = require('../thunk').default; + +describe('thunk', function() { + var elm, vnode0; + beforeEach(function() { + elm = vnode0 = document.createElement('div'); + }); + it('returns vnode with data and render function', function() { + function numberInSpan(n) { + return h('span', 'Number is ' + n); + } + var vnode = thunk('span', 'num', numberInSpan, [22]); + assert.deepEqual(vnode.sel, 'span'); + assert.deepEqual(vnode.data.key, 'num'); + assert.deepEqual(vnode.data.args, [22]); + }); + it('calls render function once on data change', function() { + var called = 0; + function numberInSpan(n) { + called++; + return h('span', {key: 'num'}, 'Number is ' + n); + } + var vnode1 = h('div', [ + thunk('span', 'num', numberInSpan, [1]) + ]); + var vnode2 = h('div', [ + thunk('span', 'num', numberInSpan, [2]) + ]); + patch(vnode0, vnode1); + assert.equal(called, 1); + patch(vnode1, vnode2); + assert.equal(called, 2); + }); + it('does not call render function on data unchanged', function() { + var called = 0; + function numberInSpan(n) { + called++; + return h('span', {key: 'num'}, 'Number is ' + n); + } + var vnode1 = h('div', [ + thunk('span', 'num', numberInSpan, [1]) + ]); + var vnode2 = h('div', [ + thunk('span', 'num', numberInSpan, [1]) + ]); + patch(vnode0, vnode1); + assert.equal(called, 1); + patch(vnode1, vnode2); + assert.equal(called, 1); + }); + it('calls render function once on data-length change', function() { + var called = 0; + function numberInSpan(n) { + called++; + return h('span', {key: 'num'}, 'Number is ' + n); + } + var vnode1 = h('div', [ + thunk('span', 'num', numberInSpan, [1]) + ]); + var vnode2 = h('div', [ + thunk('span', 'num', numberInSpan, [1, 2]) + ]); + patch(vnode0, vnode1); + assert.equal(called, 1); + patch(vnode1, vnode2); + assert.equal(called, 2); + }); + it('calls render function once on function change', function() { + var called = 0; + function numberInSpan(n) { + called++; + return h('span', {key: 'num'}, 'Number is ' + n); + } + function numberInSpan2(n) { + called++; + return h('span', {key: 'num'}, 'Number really is ' + n); + } + var vnode1 = h('div', [ + thunk('span', 'num', numberInSpan, [1]) + ]); + var vnode2 = h('div', [ + thunk('span', 'num', numberInSpan2, [1]) + ]); + patch(vnode0, vnode1); + assert.equal(called, 1); + patch(vnode1, vnode2); + assert.equal(called, 2); + }); + it('renders correctly', function() { + var called = 0; + function numberInSpan(n) { + called++; + return h('span', {key: 'num'}, 'Number is ' + n); + } + var vnode1 = h('div', [ + thunk('span', 'num', numberInSpan, [1]) + ]); + var vnode2 = h('div', [ + thunk('span', 'num', numberInSpan, [1]) + ]); + var vnode3 = h('div', [ + thunk('span', 'num', numberInSpan, [2]) + ]); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.firstChild.tagName.toLowerCase(), 'span'); + assert.equal(elm.firstChild.innerHTML, 'Number is 1'); + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.firstChild.tagName.toLowerCase(), 'span'); + assert.equal(elm.firstChild.innerHTML, 'Number is 1'); + elm = patch(vnode2, vnode3).elm; + assert.equal(elm.firstChild.tagName.toLowerCase(), 'span'); + assert.equal(elm.firstChild.innerHTML, 'Number is 2'); + assert.equal(called, 2); + }); + it('supports leaving out the `key` argument', function() { + function vnodeFn(s) { + return h('span.number', 'Hello ' + s); + } + var vnode1 = thunk('span.number', vnodeFn, ['World!']); + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.innerText, 'Hello World!'); + }); + it('renders correctly when root', function() { + var called = 0; + function numberInSpan(n) { + called++; + return h('span', {key: 'num'}, 'Number is ' + n); + } + var vnode1 = thunk('span', 'num', numberInSpan, [1]); + var vnode2 = thunk('span', 'num', numberInSpan, [1]); + var vnode3 = thunk('span', 'num', numberInSpan, [2]); + + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.tagName.toLowerCase(), 'span'); + assert.equal(elm.innerHTML, 'Number is 1'); + + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.tagName.toLowerCase(), 'span'); + assert.equal(elm.innerHTML, 'Number is 1'); + + elm = patch(vnode2, vnode3).elm; + assert.equal(elm.tagName.toLowerCase(), 'span'); + assert.equal(elm.innerHTML, 'Number is 2'); + assert.equal(called, 2); + }); + it('can be replaced and removed', function() { + function numberInSpan(n) { + return h('span', {key: 'num'}, 'Number is ' + n); + } + function oddEven(n) { + var prefix = (n % 2) === 0 ? 'Even' : 'Odd'; + return h('div', {key: oddEven}, prefix + ': ' + n); + } + var vnode1 = h('div', [thunk('span', 'num', numberInSpan, [1])]); + var vnode2 = h('div', [thunk('div', 'oddEven', oddEven, [4])]); + + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.firstChild.tagName.toLowerCase(), 'span'); + assert.equal(elm.firstChild.innerHTML, 'Number is 1'); + + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.firstChild.tagName.toLowerCase(), 'div'); + assert.equal(elm.firstChild.innerHTML, 'Even: 4'); + }); + it('can be replaced and removed when root', function() { + function numberInSpan(n) { + return h('span', {key: 'num'}, 'Number is ' + n); + } + function oddEven(n) { + var prefix = (n % 2) === 0 ? 'Even' : 'Odd'; + return h('div', {key: oddEven}, prefix + ': ' + n); + } + var vnode1 = thunk('span', 'num', numberInSpan, [1]); + var vnode2 = thunk('div', 'oddEven', oddEven, [4]); + + elm = patch(vnode0, vnode1).elm; + assert.equal(elm.tagName.toLowerCase(), 'span'); + assert.equal(elm.innerHTML, 'Number is 1'); + + elm = patch(vnode1, vnode2).elm; + assert.equal(elm.tagName.toLowerCase(), 'div'); + assert.equal(elm.innerHTML, 'Even: 4'); + }); + it('invokes destroy hook on thunks', function() { + var called = 0; + function destroyHook() { + called++; + } + function numberInSpan(n) { + return h('span', {key: 'num', hook: {destroy: destroyHook}}, 'Number is ' + n); + } + var vnode1 = h('div', [ + h('div', 'Foo'), + thunk('span', 'num', numberInSpan, [1]), + h('div', 'Foo') + ]); + var vnode2 = h('div', [ + h('div', 'Foo'), + h('div', 'Foo') + ]); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(called, 1); + }); + it('invokes remove hook on thunks', function() { + var called = 0; + function hook() { + called++; + } + function numberInSpan(n) { + return h('span', {key: 'num', hook: {remove: hook}}, 'Number is ' + n); + } + var vnode1 = h('div', [ + h('div', 'Foo'), + thunk('span', 'num', numberInSpan, [1]), + h('div', 'Foo') + ]); + var vnode2 = h('div', [ + h('div', 'Foo'), + h('div', 'Foo') + ]); + patch(vnode0, vnode1); + patch(vnode1, vnode2); + assert.equal(called, 1); + }); +}); diff --git a/src/libs/snabbdom/testem.json b/src/libs/snabbdom/testem.json new file mode 100755 index 00000000..1071056f --- /dev/null +++ b/src/libs/snabbdom/testem.json @@ -0,0 +1,13 @@ +{ + "framework": "mocha", + "src_files": [ + "snabbdom.js", + "test/*.js" + ], + "serve_files": [ + "browserified.js" + ], + "before_tests": "browserify -d test/index.js -o browserified.js", + "on_exit": "rm browserified.js", + "launch_in_dev": [ "firefox", "chromium" ] +} diff --git a/src/libs/snabbdom/tsconfig.json b/src/libs/snabbdom/tsconfig.json new file mode 100755 index 00000000..ed1e9b5c --- /dev/null +++ b/src/libs/snabbdom/tsconfig.json @@ -0,0 +1,36 @@ +{ + "compilerOptions": { + "target": "ES5", + "noImplicitAny": true, + "sourceMap": true, + "strictNullChecks": true, + "declaration": true, + "removeComments": false, + "noUnusedLocals": true, + "lib": [ + "dom", + "es5", + "es2015.core" + ] + }, + "files": [ + "src/helpers/attachto.ts", + "src/modules/attributes.ts", + "src/modules/class.ts", + "src/modules/dataset.ts", + "src/modules/eventlisteners.ts", + "src/modules/hero.ts", + "src/modules/props.ts", + "src/modules/module.ts", + "src/modules/style.ts", + "src/h.ts", + "src/htmldomapi.ts", + "src/hooks.ts", + "src/is.ts", + "src/snabbdom.bundle.ts", + "src/snabbdom.ts", + "src/thunk.ts", + "src/tovnode.ts", + "src/vnode.ts" + ] +}