4185 lines
139 KiB
JavaScript
Executable File
4185 lines
139 KiB
JavaScript
Executable File
/**
|
|
* Modules in this bundle
|
|
* @license
|
|
*
|
|
* smartphoto:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: appleple
|
|
* homepage: http://developer.a-blogcms.jp
|
|
* version: 1.0.1
|
|
*
|
|
* a-template:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: steelydylan
|
|
* version: 0.4.4
|
|
*
|
|
* array.prototype.find:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Paul Miller <http://paulmillr.com>
|
|
* contributors: Duncan Hall <himself@duncanhall.net>
|
|
* version: 2.0.4
|
|
*
|
|
* custom-event-polyfill:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: NO AUTHOR!
|
|
* contributors: Frank Panetta (http://www.savvi.io), Mikhail Reenko <reenko@yandex.ru>, Joscha Feth <joscha@feth.com> (http://www.feth.com)
|
|
* version: 0.3.0
|
|
*
|
|
* define-properties:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Jordan Harband
|
|
* version: 1.1.2
|
|
*
|
|
* es-abstract:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Jordan Harband <ljharb@gmail.com>
|
|
* contributors: Jordan Harband <ljharb@gmail.com>
|
|
* version: 1.7.0
|
|
*
|
|
* es-to-primitive:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Jordan Harband
|
|
* version: 1.1.1
|
|
*
|
|
* es6-promise-polyfill:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Roman Dvornov <rdvornov@gmail.com>
|
|
* version: 1.2.0
|
|
*
|
|
* foreach:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Manuel Stofer <manuel@takimata.ch>
|
|
* contributors: Manuel Stofer, Jordan Harband
|
|
* version: 2.0.5
|
|
*
|
|
* function-bind:
|
|
* licenses: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Raynos <raynos2@gmail.com>
|
|
* contributors: Raynos, Jordan Harband
|
|
* homepage: https://github.com/Raynos/function-bind
|
|
* version: 1.1.0
|
|
*
|
|
* has:
|
|
* licenses: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Thiago de Arruda <tpadilha84@gmail.com>
|
|
* homepage: https://github.com/tarruda/has
|
|
* version: 1.0.1
|
|
*
|
|
* is-callable:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Jordan Harband <ljharb@gmail.com>
|
|
* contributors: Jordan Harband <ljharb@gmail.com>
|
|
* version: 1.1.3
|
|
*
|
|
* is-date-object:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Jordan Harband
|
|
* version: 1.0.1
|
|
*
|
|
* is-regex:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Jordan Harband
|
|
* homepage: https://github.com/ljharb/is-regex
|
|
* version: 1.0.4
|
|
*
|
|
* is-symbol:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Jordan Harband
|
|
* version: 1.0.1
|
|
*
|
|
* morphdom:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Patrick Steele-Idem <pnidem@gmail.com>
|
|
* version: 2.3.1
|
|
*
|
|
* object-keys:
|
|
* license: MIT (http://opensource.org/licenses/MIT)
|
|
* author: Jordan Harband <ljharb@gmail.com>
|
|
* contributors: Jordan Harband <ljharb@gmail.com>, Raynos <raynos2@gmail.com>, Nathan Rajlich <nathan@tootallnate.net>, Ivan Starkov <istarkov@gmail.com>, Gary Katsevman <git@gkatsev.com>
|
|
* version: 1.0.11
|
|
*
|
|
* This header is generated by licensify (https://github.com/twada/licensify)
|
|
*/
|
|
(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.SmartPhoto = 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<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _util = require('./util');
|
|
|
|
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var morphdom = require('morphdom');
|
|
var find = require('array.prototype.find');
|
|
|
|
var eventType = 'input paste copy click change keydown keyup contextmenu mouseup mousedown mousemove touchstart touchend touchmove compositionstart compositionend focus';
|
|
var bindType = 'input change click';
|
|
var dataAction = eventType.replace(/([a-z]+)/g, '[data-action-$1],') + '[data-action]';
|
|
|
|
var aTemplate = function () {
|
|
function aTemplate(opt) {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, aTemplate);
|
|
|
|
this.atemplate = [];
|
|
if (opt) {
|
|
Object.keys(opt).forEach(function (key) {
|
|
_this[key] = opt[key];
|
|
});
|
|
}
|
|
if (!this.data) {
|
|
this.data = {};
|
|
}
|
|
if (!this.templates) {
|
|
this.templates = [];
|
|
}
|
|
var templates = this.templates;
|
|
var length = templates.length;
|
|
for (var i = 0, n = length; i < n; i += 1) {
|
|
var template = this.templates[i];
|
|
var html = (0, _util.selector)('#' + template).innerHTML;
|
|
this.atemplate.push({ id: template, html: html, binded: false });
|
|
}
|
|
}
|
|
|
|
_createClass(aTemplate, [{
|
|
key: 'addDataBind',
|
|
value: function addDataBind(ele) {
|
|
var _this2 = this;
|
|
|
|
(0, _util.on)(ele, '[data-bind]', bindType, function (e) {
|
|
var target = e.delegateTarget;
|
|
var data = target.getAttribute('data-bind');
|
|
var attr = target.getAttribute('href');
|
|
var value = target.value;
|
|
if (attr) {
|
|
value = value.replace('#', '');
|
|
}
|
|
if (target.getAttribute('type') === 'checkbox') {
|
|
(function () {
|
|
var arr = [];
|
|
var items = document.querySelectorAll('[data-bind="' + data + '"]');
|
|
[].forEach.call(items, function (item) {
|
|
if (item.checked) {
|
|
arr.push(item.value);
|
|
}
|
|
});
|
|
})();
|
|
} else if (target.getAttribute('type') !== 'radio') {
|
|
_this2.updateDataByString(data, value);
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: 'addActionBind',
|
|
value: function addActionBind(ele) {
|
|
var _this3 = this;
|
|
|
|
(0, _util.on)(ele, dataAction, eventType, function (e) {
|
|
var target = e.delegateTarget;
|
|
var events = eventType.split(' ');
|
|
var action = 'action';
|
|
events.forEach(function (event) {
|
|
if (target.getAttribute('data-action-' + event)) {
|
|
if (e.type === event) {
|
|
action += '-' + event;
|
|
}
|
|
}
|
|
});
|
|
var string = target.getAttribute('data-' + action);
|
|
if (!string) {
|
|
return;
|
|
}
|
|
var method = string.replace(/\(.*?\);?/, '');
|
|
var parameter = string.replace(/(.*?)\((.*?)\);?/, '$2');
|
|
var pts = parameter.split(','); // 引き数
|
|
_this3.e = e;
|
|
if (_this3.method && _this3.method[method]) {
|
|
var _method;
|
|
|
|
(_method = _this3.method)[method].apply(_method, _toConsumableArray(pts));
|
|
} else if (_this3[method]) {
|
|
_this3[method].apply(_this3, _toConsumableArray(pts));
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: 'addTemplate',
|
|
value: function addTemplate(id, html) {
|
|
this.atemplate.push({ id: id, html: html, binded: false });
|
|
this.templates.push(id);
|
|
}
|
|
|
|
// loadHtml() {
|
|
// const templates = this.templates;
|
|
// const promises = [];
|
|
// templates.forEach((template) => {
|
|
// const d = new $.Deferred();
|
|
// promises.push(d);
|
|
// const src = selector(`#${template}`).getAttribute('src');
|
|
// $.ajax({
|
|
// url: src,
|
|
// type: 'GET',
|
|
// dataType: 'text'
|
|
// }).success((data) => {
|
|
// selector(`#${template}`).innerHTML = data;
|
|
// d.resolve();
|
|
// });
|
|
// });
|
|
// return $.when(...promises);
|
|
// }
|
|
|
|
}, {
|
|
key: 'getData',
|
|
value: function getData() {
|
|
return JSON.parse(JSON.stringify(this.data));
|
|
}
|
|
}, {
|
|
key: 'saveData',
|
|
value: function saveData(key) {
|
|
var data = JSON.stringify(this.data);
|
|
localStorage.setItem(key, data);
|
|
}
|
|
}, {
|
|
key: 'setData',
|
|
value: function setData(opt) {
|
|
var _this4 = this;
|
|
|
|
Object.keys(opt).forEach(function (key) {
|
|
if (typeof opt[key] !== 'function') {
|
|
_this4.data[key] = opt[key];
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: 'loadData',
|
|
value: function loadData(key) {
|
|
var data = JSON.parse(localStorage.getItem(key));
|
|
if (data) {
|
|
this.setData(data);
|
|
}
|
|
}
|
|
}, {
|
|
key: 'getRand',
|
|
value: function getRand(a, b) {
|
|
return ~~(Math.random() * (b - a + 1)) + a;
|
|
}
|
|
}, {
|
|
key: 'getRandText',
|
|
value: function getRandText(limit) {
|
|
var ret = '';
|
|
var strings = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
|
|
var length = strings.length;
|
|
for (var i = 0; i < limit; i += 1) {
|
|
ret += strings.charAt(Math.floor(this.getRand(0, length)));
|
|
}
|
|
return ret;
|
|
}
|
|
}, {
|
|
key: 'getDataFromObj',
|
|
value: function getDataFromObj(s, o) {
|
|
s = s.replace(/\[([\w\-\.ぁ-んァ-ヶ亜-熙]+)\]/g, '.$1'); // convert indexes to properties
|
|
s = s.replace(/^\./, ''); // strip leading dot
|
|
var a = s.split('.');
|
|
while (a.length) {
|
|
var n = a.shift();
|
|
if (n in o) {
|
|
o = o[n];
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
return o;
|
|
}
|
|
}, {
|
|
key: 'getDataByString',
|
|
value: function getDataByString(s) {
|
|
var o = this.data;
|
|
return this.getDataFromObj(s, o);
|
|
}
|
|
}, {
|
|
key: 'updateDataByString',
|
|
value: function updateDataByString(path, newValue) {
|
|
var object = this.data;
|
|
var stack = path.split('.');
|
|
while (stack.length > 1) {
|
|
object = object[stack.shift()];
|
|
}
|
|
object[stack.shift()] = newValue;
|
|
}
|
|
}, {
|
|
key: 'removeDataByString',
|
|
value: function removeDataByString(path) {
|
|
var object = this.data;
|
|
var stack = path.split('.');
|
|
while (stack.length > 1) {
|
|
object = object[stack.shift()];
|
|
}
|
|
var shift = stack.shift();
|
|
if (shift.match(/^\d+$/)) {
|
|
object.splice(Number(shift), 1);
|
|
} else {
|
|
delete object[shift];
|
|
}
|
|
}
|
|
}, {
|
|
key: 'resolveBlock',
|
|
value: function resolveBlock(html, item, i) {
|
|
var that = this;
|
|
var touchs = html.match(/<!-- BEGIN ([\w\-\.ぁ-んァ-ヶ亜-熙]+):touch#([\w\-\.ぁ-んァ-ヶ亜-熙]+) -->/g);
|
|
var touchnots = html.match(/<!-- BEGIN ([\w\-\.ぁ-んァ-ヶ亜-熙]+):touchnot#([\w\-\.ぁ-んァ-ヶ亜-熙]+) -->/g);
|
|
var exists = html.match(/<!-- BEGIN ([\w\-\.ぁ-んァ-ヶ亜-熙]+):exist -->/g);
|
|
var empties = html.match(/<!-- BEGIN ([\w\-\.ぁ-んァ-ヶ亜-熙]+):empty -->/g);
|
|
/* タッチブロック解決*/
|
|
if (touchs) {
|
|
for (var k = 0, n = touchs.length; k < n; k += 1) {
|
|
var start = touchs[k];
|
|
start = start.replace(/([\w\-\.ぁ-んァ-ヶ亜-熙]+):touch#([\w\-\.ぁ-んァ-ヶ亜-熙]+)/, '($1):touch#($2)');
|
|
var end = start.replace(/BEGIN/, 'END');
|
|
var reg = new RegExp(start + '(([\\n\\r\\t]|.)*?)' + end, 'g');
|
|
html = html.replace(reg, function (m, key2, val, next) {
|
|
var itemkey = typeof item[key2] === 'function' ? item[key2].apply(that) : that.getDataFromObj(key2, item);
|
|
if ('' + itemkey === val) {
|
|
return next;
|
|
}
|
|
return '';
|
|
});
|
|
}
|
|
}
|
|
/* タッチノットブロック解決*/
|
|
if (touchnots) {
|
|
for (var _k = 0, _n = touchnots.length; _k < _n; _k += 1) {
|
|
var _start = touchnots[_k];
|
|
_start = _start.replace(/([\w\-\.ぁ-んァ-ヶ亜-熙]+):touchnot#([\w\-\.ぁ-んァ-ヶ亜-熙]+)/, '($1):touchnot#($2)');
|
|
var _end = _start.replace(/BEGIN/, 'END');
|
|
var _reg = new RegExp(_start + '(([\\n\\r\\t]|.)*?)' + _end, 'g');
|
|
html = html.replace(_reg, function (m, key2, val, next) {
|
|
var itemkey = typeof item[key2] === 'function' ? item[key2].apply(that) : that.getDataFromObj(key2, item);
|
|
if ('' + itemkey !== val) {
|
|
return next;
|
|
}
|
|
return '';
|
|
});
|
|
}
|
|
}
|
|
/* existブロックを解決*/
|
|
if (exists) {
|
|
for (var _k2 = 0, _n2 = exists.length; _k2 < _n2; _k2 += 1) {
|
|
var _start2 = exists[_k2];
|
|
_start2 = _start2.replace(/([\w\-\.ぁ-んァ-ヶ亜-熙]+):exist/, '($1):exist');
|
|
var _end2 = _start2.replace(/BEGIN/, 'END');
|
|
var _reg2 = new RegExp(_start2 + '(([\\n\\r\\t]|.)*?)' + _end2, 'g');
|
|
html = html.replace(_reg2, function (m, key2, next) {
|
|
var itemkey = typeof item[key2] === 'function' ? item[key2].apply(that) : that.getDataFromObj(key2, item);
|
|
if (itemkey || itemkey === 0) {
|
|
return next;
|
|
}
|
|
return '';
|
|
});
|
|
}
|
|
}
|
|
/* emptyブロックを解決*/
|
|
if (empties) {
|
|
for (var _k3 = 0, _n3 = empties.length; _k3 < _n3; _k3 += 1) {
|
|
var _start3 = empties[_k3];
|
|
_start3 = _start3.replace(/([\w\-\.ぁ-んァ-ヶ亜-熙]+):empty/, '($1):empty');
|
|
var _end3 = _start3.replace(/BEGIN/, 'END');
|
|
var empty = new RegExp(_start3 + '(([\\n\\r\\t]|.)*?)' + _end3, 'g');
|
|
html = html.replace(empty, function (m, key2, next) {
|
|
var itemkey = typeof item[key2] === 'function' ? item[key2].apply(that) : that.getDataFromObj(key2, item);
|
|
if (!itemkey && itemkey !== 0) {
|
|
return next;
|
|
}
|
|
return '';
|
|
});
|
|
}
|
|
}
|
|
/* 変数解決*/
|
|
html = html.replace(/{([\w\-\.ぁ-んァ-ヶ亜-熙]+)}(\[([\w\-\.ぁ-んァ-ヶ亜-熙]+)\])*/g, function (n, key3, key4, converter) {
|
|
var data = void 0;
|
|
if ('' + key3 === 'i') {
|
|
data = i;
|
|
} else if (item[key3] || item[key3] === 0) {
|
|
if (typeof item[key3] === 'function') {
|
|
data = item[key3].apply(that);
|
|
} else {
|
|
data = item[key3];
|
|
}
|
|
} else {
|
|
if (converter && that.convert && that.convert[converter]) {
|
|
return that.convert[converter].call(that, '');
|
|
}
|
|
return '';
|
|
}
|
|
if (converter && that.convert && that.convert[converter]) {
|
|
return that.convert[converter].call(that, data);
|
|
}
|
|
return data;
|
|
});
|
|
return html;
|
|
}
|
|
/* 絶対パス形式の変数を解決*/
|
|
|
|
}, {
|
|
key: 'resolveAbsBlock',
|
|
value: function resolveAbsBlock(html) {
|
|
var that = this;
|
|
html = html.replace(/{(.*?)}/g, function (n, key3) {
|
|
var data = that.getDataByString(key3);
|
|
if (typeof data !== 'undefined') {
|
|
if (typeof data === 'function') {
|
|
return data.apply(that);
|
|
}
|
|
return data;
|
|
}
|
|
return n;
|
|
});
|
|
return html;
|
|
}
|
|
}, {
|
|
key: 'resolveInclude',
|
|
value: function resolveInclude(html) {
|
|
var include = /<!-- #include id="(.*?)" -->/g;
|
|
html = html.replace(include, function (m, key) {
|
|
return (0, _util.selector)('#' + key).innerHTML;
|
|
});
|
|
return html;
|
|
}
|
|
}, {
|
|
key: 'resolveWith',
|
|
value: function resolveWith(html) {
|
|
var width = /<!-- BEGIN ([\w\-\.ぁ-んァ-ヶ亜-熙]+):with -->(([\n\r\t]|.)*?)<!-- END ([\w\-\.ぁ-んァ-ヶ亜-熙]+):with -->/g;
|
|
html = html.replace(width, function (m, key) {
|
|
m = m.replace(/data\-bind=['"](.*?)['"]/g, 'data-bind=\'' + key + '.$1\'');
|
|
return m;
|
|
});
|
|
return html;
|
|
}
|
|
}, {
|
|
key: 'resolveLoop',
|
|
value: function resolveLoop(html) {
|
|
var loop = /<!-- BEGIN ([\w\-\.ぁ-んァ-ヶ亜-熙]+?):loop -->(([\n\r\t]|.)*?)<!-- END ([\w\-\.ぁ-んァ-ヶ亜-熙]+?):loop -->/g;
|
|
var that = this;
|
|
/* ループ文解決*/
|
|
html = html.replace(loop, function (m, key, val) {
|
|
var keyItem = that.getDataByString(key);
|
|
var keys = [];
|
|
if (typeof keyItem === 'function') {
|
|
keys = keyItem.apply(that);
|
|
} else {
|
|
keys = keyItem;
|
|
}
|
|
var ret = '';
|
|
if (keys instanceof Array) {
|
|
for (var i = 0, n = keys.length; i < n; i += 1) {
|
|
ret += that.resolveBlock(val, keys[i], i);
|
|
}
|
|
}
|
|
/* エスケープ削除*/
|
|
ret = ret.replace(/\\([^\\])/g, '$1');
|
|
return ret;
|
|
});
|
|
return html;
|
|
}
|
|
}, {
|
|
key: 'removeData',
|
|
value: function removeData(arr) {
|
|
var data = this.data;
|
|
Object.keys(data).forEach(function (i) {
|
|
for (var t = 0, n = arr.length; t < n; t += 1) {
|
|
if (i === arr[t]) {
|
|
delete data[i];
|
|
}
|
|
}
|
|
});
|
|
return this;
|
|
}
|
|
}, {
|
|
key: 'hasLoop',
|
|
value: function hasLoop(txt) {
|
|
var loop = /<!-- BEGIN ([\w\-\.ぁ-んァ-ヶ亜-熙]+?):loop -->(([\n\r\t]|.)*?)<!-- END ([\w\-\.ぁ-んァ-ヶ亜-熙]+?):loop -->/g;
|
|
if (txt.match(loop)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, {
|
|
key: 'getHtml',
|
|
value: function getHtml(query, row) {
|
|
var template = find(this.atemplate, function (item) {
|
|
return item.id === query;
|
|
});
|
|
var html = '';
|
|
if (template && template.html) {
|
|
html = template.html;
|
|
}
|
|
if (row) {
|
|
html = query;
|
|
}
|
|
if (!html) {
|
|
return '';
|
|
}
|
|
var data = this.data;
|
|
/* インクルード解決*/
|
|
html = this.resolveInclude(html);
|
|
/* with解決*/
|
|
html = this.resolveWith(html);
|
|
/* ループ解決*/
|
|
while (this.hasLoop(html)) {
|
|
html = this.resolveLoop(html);
|
|
}
|
|
/* 変数解決*/
|
|
html = this.resolveBlock(html, data);
|
|
/* エスケープ削除*/
|
|
html = html.replace(/\\([^\\])/g, '$1');
|
|
/* 絶対パスで指定された変数を解決*/
|
|
html = this.resolveAbsBlock(html);
|
|
/* 空行削除*/
|
|
return html.replace(/^([\t ])*\n/gm, '');
|
|
}
|
|
}, {
|
|
key: 'update',
|
|
value: function update() {
|
|
var _this5 = this;
|
|
|
|
var renderWay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'html';
|
|
var part = arguments[1];
|
|
|
|
var templates = this.templates;
|
|
if (this.beforeUpdated) {
|
|
this.beforeUpdated();
|
|
}
|
|
|
|
var _loop = function _loop(i, n) {
|
|
var tem = templates[i];
|
|
var query = '#' + tem;
|
|
var html = _this5.getHtml(tem);
|
|
var target = (0, _util.selector)('[data-id=\'' + tem + '\']');
|
|
if (!target) {
|
|
(0, _util.selector)(query).insertAdjacentHTML('afterend', '<div data-id="' + tem + '"></div>');
|
|
if (renderWay === 'text') {
|
|
(0, _util.selector)('[data-id=\'' + tem + '\']').innerText = html;
|
|
} else {
|
|
(0, _util.selector)('[data-id=\'' + tem + '\']').innerHTML = html;
|
|
}
|
|
} else if (renderWay === 'text') {
|
|
target.innerText = html;
|
|
} else if (part) {
|
|
var parser = new DOMParser();
|
|
var doc = parser.parseFromString(html, 'text/html');
|
|
var partHtml = doc.querySelector(part).outerHTML;
|
|
morphdom(target.querySelector(part), partHtml);
|
|
} else {
|
|
morphdom(target, '<div data-id=\'' + tem + '\'>' + html + '</div>');
|
|
}
|
|
var template = find(_this5.atemplate, function (item) {
|
|
return item.id === tem;
|
|
});
|
|
if (!template.binded) {
|
|
template.binded = true;
|
|
_this5.addDataBind((0, _util.selector)('[data-id=\'' + tem + '\']'));
|
|
_this5.addActionBind((0, _util.selector)('[data-id=\'' + tem + '\']'));
|
|
}
|
|
};
|
|
|
|
for (var i = 0, n = templates.length; i < n; i += 1) {
|
|
_loop(i, n);
|
|
}
|
|
this.updateBindingData(part);
|
|
if (this.onUpdated) {
|
|
this.onUpdated(part);
|
|
}
|
|
return this;
|
|
}
|
|
}, {
|
|
key: 'updateBindingData',
|
|
value: function updateBindingData(part) {
|
|
var _this6 = this;
|
|
|
|
var templates = this.templates;
|
|
for (var i = 0, n = templates.length; i < n; i += 1) {
|
|
var temp = templates[i];
|
|
var _template = (0, _util.selector)('[data-id=\'' + temp + '\']');
|
|
if (part) {
|
|
_template = _template.querySelector(part);
|
|
}
|
|
var binds = _template.querySelectorAll('[data-bind]');
|
|
[].forEach.call(binds, function (item) {
|
|
var data = _this6.getDataByString(item.getAttribute('data-bind'));
|
|
if (item.getAttribute('type') === 'checkbox' || item.getAttribute('type') === 'radio') {
|
|
if (data === item.value) {
|
|
item.checked = true;
|
|
}
|
|
} else {
|
|
// if(item !== document.activeElement) {
|
|
item.value = data;
|
|
// }
|
|
}
|
|
});
|
|
}
|
|
return this;
|
|
}
|
|
}, {
|
|
key: 'applyMethod',
|
|
value: function applyMethod(method) {
|
|
var _method2;
|
|
|
|
for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
args[_key - 1] = arguments[_key];
|
|
}
|
|
|
|
return (_method2 = this.method)[method].apply(_method2, args);
|
|
}
|
|
}, {
|
|
key: 'getComputedProp',
|
|
value: function getComputedProp(prop) {
|
|
return this.data[prop].apply(this);
|
|
}
|
|
}, {
|
|
key: 'remove',
|
|
value: function remove(path) {
|
|
var object = this.data;
|
|
var stack = path.split('.');
|
|
while (stack.length > 1) {
|
|
object = object[stack.shift()];
|
|
}
|
|
var shift = stack.shift();
|
|
if (shift.match(/^\d+$/)) {
|
|
object.splice(Number(shift), 1);
|
|
} else {
|
|
delete object[shift];
|
|
}
|
|
return this;
|
|
}
|
|
}]);
|
|
|
|
return aTemplate;
|
|
}();
|
|
|
|
exports.default = aTemplate;
|
|
module.exports = exports['default'];
|
|
},{"./util":2,"array.prototype.find":4,"morphdom":29}],2:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var matches = exports.matches = function matches(element, query) {
|
|
var matches = (element.document || element.ownerDocument).querySelectorAll(query);
|
|
var i = matches.length;
|
|
while (--i >= 0 && matches.item(i) !== element) {}
|
|
return i > -1;
|
|
};
|
|
|
|
var selector = exports.selector = function selector(_selector) {
|
|
return document.querySelector(_selector);
|
|
};
|
|
|
|
var findAncestor = exports.findAncestor = function findAncestor(element, selector) {
|
|
if (typeof element.closest === 'function') {
|
|
return element.closest(selector) || null;
|
|
}
|
|
while (element && element !== document) {
|
|
if (matches(element, selector)) {
|
|
return element;
|
|
}
|
|
element = element.parentElement;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
var on = exports.on = function on(element, query, eventNames, fn) {
|
|
var events = eventNames.split(' ');
|
|
events.forEach(function (event) {
|
|
element.addEventListener(event, function (e) {
|
|
var target = e.target;
|
|
var delegateTarget = findAncestor(e.target, query);
|
|
if (delegateTarget) {
|
|
e.delegateTarget = delegateTarget;
|
|
fn(e);
|
|
}
|
|
});
|
|
});
|
|
};
|
|
},{}],3:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var ES = require('es-abstract/es6');
|
|
|
|
module.exports = function find(predicate) {
|
|
var list = ES.ToObject(this);
|
|
var length = ES.ToInteger(ES.ToLength(list.length));
|
|
if (!ES.IsCallable(predicate)) {
|
|
throw new TypeError('Array#find: predicate must be a function');
|
|
}
|
|
if (length === 0) {
|
|
return undefined;
|
|
}
|
|
var thisArg = arguments[1];
|
|
for (var i = 0, value; i < length; i++) {
|
|
value = list[i];
|
|
if (ES.Call(predicate, thisArg, [value, i, list])) {
|
|
return value;
|
|
}
|
|
}
|
|
return undefined;
|
|
};
|
|
|
|
},{"es-abstract/es6":10}],4:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var define = require('define-properties');
|
|
var ES = require('es-abstract/es6');
|
|
|
|
var implementation = require('./implementation');
|
|
var getPolyfill = require('./polyfill');
|
|
var shim = require('./shim');
|
|
|
|
var slice = Array.prototype.slice;
|
|
|
|
var polyfill = getPolyfill();
|
|
|
|
var boundFindShim = function find(array, predicate) { // eslint-disable-line no-unused-vars
|
|
ES.RequireObjectCoercible(array);
|
|
var args = slice.call(arguments, 1);
|
|
return polyfill.apply(array, args);
|
|
};
|
|
|
|
define(boundFindShim, {
|
|
getPolyfill: getPolyfill,
|
|
implementation: implementation,
|
|
shim: shim
|
|
});
|
|
|
|
module.exports = boundFindShim;
|
|
|
|
},{"./implementation":3,"./polyfill":5,"./shim":6,"define-properties":8,"es-abstract/es6":10}],5:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
module.exports = function getPolyfill() {
|
|
// Detect if an implementation exists
|
|
// Detect early implementations which skipped holes in sparse arrays
|
|
// eslint-disable-next-line no-sparse-arrays
|
|
var implemented = Array.prototype.find && [, 1].find(function () {
|
|
return true;
|
|
}) !== 1;
|
|
|
|
// eslint-disable-next-line global-require
|
|
return implemented ? Array.prototype.find : require('./implementation');
|
|
};
|
|
|
|
},{"./implementation":3}],6:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var define = require('define-properties');
|
|
var getPolyfill = require('./polyfill');
|
|
|
|
module.exports = function shimArrayPrototypeFind() {
|
|
var polyfill = getPolyfill();
|
|
|
|
define(Array.prototype, { find: polyfill }, {
|
|
find: function () {
|
|
return Array.prototype.find !== polyfill;
|
|
}
|
|
});
|
|
|
|
return polyfill;
|
|
};
|
|
|
|
},{"./polyfill":5,"define-properties":8}],7:[function(require,module,exports){
|
|
// Polyfill for creating CustomEvents on IE9/10/11
|
|
|
|
// code pulled from:
|
|
// https://github.com/d4tocchini/customevent-polyfill
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent#Polyfill
|
|
|
|
try {
|
|
var ce = new window.CustomEvent('test');
|
|
ce.preventDefault();
|
|
if (ce.defaultPrevented !== true) {
|
|
// IE has problems with .preventDefault() on custom events
|
|
// http://stackoverflow.com/questions/23349191
|
|
throw new Error('Could not prevent default');
|
|
}
|
|
} catch(e) {
|
|
var CustomEvent = function(event, params) {
|
|
var evt, origPrevent;
|
|
params = params || {
|
|
bubbles: false,
|
|
cancelable: false,
|
|
detail: undefined
|
|
};
|
|
|
|
evt = document.createEvent("CustomEvent");
|
|
evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
|
|
origPrevent = evt.preventDefault;
|
|
evt.preventDefault = function () {
|
|
origPrevent.call(this);
|
|
try {
|
|
Object.defineProperty(this, 'defaultPrevented', {
|
|
get: function () {
|
|
return true;
|
|
}
|
|
});
|
|
} catch(e) {
|
|
this.defaultPrevented = true;
|
|
}
|
|
};
|
|
return evt;
|
|
};
|
|
|
|
CustomEvent.prototype = window.Event.prototype;
|
|
window.CustomEvent = CustomEvent; // expose definition to window
|
|
}
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var keys = require('object-keys');
|
|
var foreach = require('foreach');
|
|
var hasSymbols = typeof Symbol === 'function' && typeof Symbol() === 'symbol';
|
|
|
|
var toStr = Object.prototype.toString;
|
|
|
|
var isFunction = function (fn) {
|
|
return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
|
|
};
|
|
|
|
var arePropertyDescriptorsSupported = function () {
|
|
var obj = {};
|
|
try {
|
|
Object.defineProperty(obj, 'x', { enumerable: false, value: obj });
|
|
/* eslint-disable no-unused-vars, no-restricted-syntax */
|
|
for (var _ in obj) { return false; }
|
|
/* eslint-enable no-unused-vars, no-restricted-syntax */
|
|
return obj.x === obj;
|
|
} catch (e) { /* this is IE 8. */
|
|
return false;
|
|
}
|
|
};
|
|
var supportsDescriptors = Object.defineProperty && arePropertyDescriptorsSupported();
|
|
|
|
var defineProperty = function (object, name, value, predicate) {
|
|
if (name in object && (!isFunction(predicate) || !predicate())) {
|
|
return;
|
|
}
|
|
if (supportsDescriptors) {
|
|
Object.defineProperty(object, name, {
|
|
configurable: true,
|
|
enumerable: false,
|
|
value: value,
|
|
writable: true
|
|
});
|
|
} else {
|
|
object[name] = value;
|
|
}
|
|
};
|
|
|
|
var defineProperties = function (object, map) {
|
|
var predicates = arguments.length > 2 ? arguments[2] : {};
|
|
var props = keys(map);
|
|
if (hasSymbols) {
|
|
props = props.concat(Object.getOwnPropertySymbols(map));
|
|
}
|
|
foreach(props, function (name) {
|
|
defineProperty(object, name, map[name], predicates[name]);
|
|
});
|
|
};
|
|
|
|
defineProperties.supportsDescriptors = !!supportsDescriptors;
|
|
|
|
module.exports = defineProperties;
|
|
|
|
},{"foreach":21,"object-keys":30}],9:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var $isNaN = require('./helpers/isNaN');
|
|
var $isFinite = require('./helpers/isFinite');
|
|
|
|
var sign = require('./helpers/sign');
|
|
var mod = require('./helpers/mod');
|
|
|
|
var IsCallable = require('is-callable');
|
|
var toPrimitive = require('es-to-primitive/es5');
|
|
|
|
// https://es5.github.io/#x9
|
|
var ES5 = {
|
|
ToPrimitive: toPrimitive,
|
|
|
|
ToBoolean: function ToBoolean(value) {
|
|
return Boolean(value);
|
|
},
|
|
ToNumber: function ToNumber(value) {
|
|
return Number(value);
|
|
},
|
|
ToInteger: function ToInteger(value) {
|
|
var number = this.ToNumber(value);
|
|
if ($isNaN(number)) { return 0; }
|
|
if (number === 0 || !$isFinite(number)) { return number; }
|
|
return sign(number) * Math.floor(Math.abs(number));
|
|
},
|
|
ToInt32: function ToInt32(x) {
|
|
return this.ToNumber(x) >> 0;
|
|
},
|
|
ToUint32: function ToUint32(x) {
|
|
return this.ToNumber(x) >>> 0;
|
|
},
|
|
ToUint16: function ToUint16(value) {
|
|
var number = this.ToNumber(value);
|
|
if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; }
|
|
var posInt = sign(number) * Math.floor(Math.abs(number));
|
|
return mod(posInt, 0x10000);
|
|
},
|
|
ToString: function ToString(value) {
|
|
return String(value);
|
|
},
|
|
ToObject: function ToObject(value) {
|
|
this.CheckObjectCoercible(value);
|
|
return Object(value);
|
|
},
|
|
CheckObjectCoercible: function CheckObjectCoercible(value, optMessage) {
|
|
/* jshint eqnull:true */
|
|
if (value == null) {
|
|
throw new TypeError(optMessage || 'Cannot call method on ' + value);
|
|
}
|
|
return value;
|
|
},
|
|
IsCallable: IsCallable,
|
|
SameValue: function SameValue(x, y) {
|
|
if (x === y) { // 0 === -0, but they are not identical.
|
|
if (x === 0) { return 1 / x === 1 / y; }
|
|
return true;
|
|
}
|
|
return $isNaN(x) && $isNaN(y);
|
|
},
|
|
|
|
// http://www.ecma-international.org/ecma-262/5.1/#sec-8
|
|
Type: function Type(x) {
|
|
if (x === null) {
|
|
return 'Null';
|
|
}
|
|
if (typeof x === 'undefined') {
|
|
return 'Undefined';
|
|
}
|
|
if (typeof x === 'function' || typeof x === 'object') {
|
|
return 'Object';
|
|
}
|
|
if (typeof x === 'number') {
|
|
return 'Number';
|
|
}
|
|
if (typeof x === 'boolean') {
|
|
return 'Boolean';
|
|
}
|
|
if (typeof x === 'string') {
|
|
return 'String';
|
|
}
|
|
}
|
|
};
|
|
|
|
module.exports = ES5;
|
|
|
|
},{"./helpers/isFinite":12,"./helpers/isNaN":13,"./helpers/mod":15,"./helpers/sign":16,"es-to-primitive/es5":17,"is-callable":25}],10:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var toStr = Object.prototype.toString;
|
|
var hasSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol';
|
|
var symbolToStr = hasSymbols ? Symbol.prototype.toString : toStr;
|
|
|
|
var $isNaN = require('./helpers/isNaN');
|
|
var $isFinite = require('./helpers/isFinite');
|
|
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1;
|
|
|
|
var assign = require('./helpers/assign');
|
|
var sign = require('./helpers/sign');
|
|
var mod = require('./helpers/mod');
|
|
var isPrimitive = require('./helpers/isPrimitive');
|
|
var toPrimitive = require('es-to-primitive/es6');
|
|
var parseInteger = parseInt;
|
|
var bind = require('function-bind');
|
|
var strSlice = bind.call(Function.call, String.prototype.slice);
|
|
var isBinary = bind.call(Function.call, RegExp.prototype.test, /^0b[01]+$/i);
|
|
var isOctal = bind.call(Function.call, RegExp.prototype.test, /^0o[0-7]+$/i);
|
|
var nonWS = ['\u0085', '\u200b', '\ufffe'].join('');
|
|
var nonWSregex = new RegExp('[' + nonWS + ']', 'g');
|
|
var hasNonWS = bind.call(Function.call, RegExp.prototype.test, nonWSregex);
|
|
var invalidHexLiteral = /^[-+]0x[0-9a-f]+$/i;
|
|
var isInvalidHexLiteral = bind.call(Function.call, RegExp.prototype.test, invalidHexLiteral);
|
|
|
|
// whitespace from: http://es5.github.io/#x15.5.4.20
|
|
// implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324
|
|
var ws = [
|
|
'\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003',
|
|
'\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028',
|
|
'\u2029\uFEFF'
|
|
].join('');
|
|
var trimRegex = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');
|
|
var replace = bind.call(Function.call, String.prototype.replace);
|
|
var trim = function (value) {
|
|
return replace(value, trimRegex, '');
|
|
};
|
|
|
|
var ES5 = require('./es5');
|
|
|
|
var hasRegExpMatcher = require('is-regex');
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-abstract-operations
|
|
var ES6 = assign(assign({}, ES5), {
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-call-f-v-args
|
|
Call: function Call(F, V) {
|
|
var args = arguments.length > 2 ? arguments[2] : [];
|
|
if (!this.IsCallable(F)) {
|
|
throw new TypeError(F + ' is not a function');
|
|
}
|
|
return F.apply(V, args);
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toprimitive
|
|
ToPrimitive: toPrimitive,
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toboolean
|
|
// ToBoolean: ES5.ToBoolean,
|
|
|
|
// http://www.ecma-international.org/ecma-262/6.0/#sec-tonumber
|
|
ToNumber: function ToNumber(argument) {
|
|
var value = isPrimitive(argument) ? argument : toPrimitive(argument, 'number');
|
|
if (typeof value === 'symbol') {
|
|
throw new TypeError('Cannot convert a Symbol value to a number');
|
|
}
|
|
if (typeof value === 'string') {
|
|
if (isBinary(value)) {
|
|
return this.ToNumber(parseInteger(strSlice(value, 2), 2));
|
|
} else if (isOctal(value)) {
|
|
return this.ToNumber(parseInteger(strSlice(value, 2), 8));
|
|
} else if (hasNonWS(value) || isInvalidHexLiteral(value)) {
|
|
return NaN;
|
|
} else {
|
|
var trimmed = trim(value);
|
|
if (trimmed !== value) {
|
|
return this.ToNumber(trimmed);
|
|
}
|
|
}
|
|
}
|
|
return Number(value);
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tointeger
|
|
// ToInteger: ES5.ToNumber,
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toint32
|
|
// ToInt32: ES5.ToInt32,
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint32
|
|
// ToUint32: ES5.ToUint32,
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toint16
|
|
ToInt16: function ToInt16(argument) {
|
|
var int16bit = this.ToUint16(argument);
|
|
return int16bit >= 0x8000 ? int16bit - 0x10000 : int16bit;
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint16
|
|
// ToUint16: ES5.ToUint16,
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toint8
|
|
ToInt8: function ToInt8(argument) {
|
|
var int8bit = this.ToUint8(argument);
|
|
return int8bit >= 0x80 ? int8bit - 0x100 : int8bit;
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint8
|
|
ToUint8: function ToUint8(argument) {
|
|
var number = this.ToNumber(argument);
|
|
if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; }
|
|
var posInt = sign(number) * Math.floor(Math.abs(number));
|
|
return mod(posInt, 0x100);
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint8clamp
|
|
ToUint8Clamp: function ToUint8Clamp(argument) {
|
|
var number = this.ToNumber(argument);
|
|
if ($isNaN(number) || number <= 0) { return 0; }
|
|
if (number >= 0xFF) { return 0xFF; }
|
|
var f = Math.floor(argument);
|
|
if (f + 0.5 < number) { return f + 1; }
|
|
if (number < f + 0.5) { return f; }
|
|
if (f % 2 !== 0) { return f + 1; }
|
|
return f;
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tostring
|
|
ToString: function ToString(argument) {
|
|
if (typeof argument === 'symbol') {
|
|
throw new TypeError('Cannot convert a Symbol value to a string');
|
|
}
|
|
return String(argument);
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toobject
|
|
ToObject: function ToObject(value) {
|
|
this.RequireObjectCoercible(value);
|
|
return Object(value);
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-topropertykey
|
|
ToPropertyKey: function ToPropertyKey(argument) {
|
|
var key = this.ToPrimitive(argument, String);
|
|
return typeof key === 'symbol' ? symbolToStr.call(key) : this.ToString(key);
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
|
|
ToLength: function ToLength(argument) {
|
|
var len = this.ToInteger(argument);
|
|
if (len <= 0) { return 0; } // includes converting -0 to +0
|
|
if (len > MAX_SAFE_INTEGER) { return MAX_SAFE_INTEGER; }
|
|
return len;
|
|
},
|
|
|
|
// http://www.ecma-international.org/ecma-262/6.0/#sec-canonicalnumericindexstring
|
|
CanonicalNumericIndexString: function CanonicalNumericIndexString(argument) {
|
|
if (toStr.call(argument) !== '[object String]') {
|
|
throw new TypeError('must be a string');
|
|
}
|
|
if (argument === '-0') { return -0; }
|
|
var n = this.ToNumber(argument);
|
|
if (this.SameValue(this.ToString(n), argument)) { return n; }
|
|
return void 0;
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-requireobjectcoercible
|
|
RequireObjectCoercible: ES5.CheckObjectCoercible,
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isarray
|
|
IsArray: Array.isArray || function IsArray(argument) {
|
|
return toStr.call(argument) === '[object Array]';
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-iscallable
|
|
// IsCallable: ES5.IsCallable,
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isconstructor
|
|
IsConstructor: function IsConstructor(argument) {
|
|
return typeof argument === 'function' && !!argument.prototype; // unfortunately there's no way to truly check this without try/catch `new argument`
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isextensible-o
|
|
IsExtensible: function IsExtensible(obj) {
|
|
if (!Object.preventExtensions) { return true; }
|
|
if (isPrimitive(obj)) {
|
|
return false;
|
|
}
|
|
return Object.isExtensible(obj);
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isinteger
|
|
IsInteger: function IsInteger(argument) {
|
|
if (typeof argument !== 'number' || $isNaN(argument) || !$isFinite(argument)) {
|
|
return false;
|
|
}
|
|
var abs = Math.abs(argument);
|
|
return Math.floor(abs) === abs;
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ispropertykey
|
|
IsPropertyKey: function IsPropertyKey(argument) {
|
|
return typeof argument === 'string' || typeof argument === 'symbol';
|
|
},
|
|
|
|
// http://www.ecma-international.org/ecma-262/6.0/#sec-isregexp
|
|
IsRegExp: function IsRegExp(argument) {
|
|
if (!argument || typeof argument !== 'object') {
|
|
return false;
|
|
}
|
|
if (hasSymbols) {
|
|
var isRegExp = argument[Symbol.match];
|
|
if (typeof isRegExp !== 'undefined') {
|
|
return ES5.ToBoolean(isRegExp);
|
|
}
|
|
}
|
|
return hasRegExpMatcher(argument);
|
|
},
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevalue
|
|
// SameValue: ES5.SameValue,
|
|
|
|
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero
|
|
SameValueZero: function SameValueZero(x, y) {
|
|
return (x === y) || ($isNaN(x) && $isNaN(y));
|
|
},
|
|
|
|
/**
|
|
* 7.3.2 GetV (V, P)
|
|
* 1. Assert: IsPropertyKey(P) is true.
|
|
* 2. Let O be ToObject(V).
|
|
* 3. ReturnIfAbrupt(O).
|
|
* 4. Return O.[[Get]](P, V).
|
|
*/
|
|
GetV: function GetV(V, P) {
|
|
// 7.3.2.1
|
|
if (!this.IsPropertyKey(P)) {
|
|
throw new TypeError('Assertion failed: IsPropertyKey(P) is not true');
|
|
}
|
|
|
|
// 7.3.2.2-3
|
|
var O = this.ToObject(V);
|
|
|
|
// 7.3.2.4
|
|
return O[P];
|
|
},
|
|
|
|
/**
|
|
* 7.3.9 - http://www.ecma-international.org/ecma-262/6.0/#sec-getmethod
|
|
* 1. Assert: IsPropertyKey(P) is true.
|
|
* 2. Let func be GetV(O, P).
|
|
* 3. ReturnIfAbrupt(func).
|
|
* 4. If func is either undefined or null, return undefined.
|
|
* 5. If IsCallable(func) is false, throw a TypeError exception.
|
|
* 6. Return func.
|
|
*/
|
|
GetMethod: function GetMethod(O, P) {
|
|
// 7.3.9.1
|
|
if (!this.IsPropertyKey(P)) {
|
|
throw new TypeError('Assertion failed: IsPropertyKey(P) is not true');
|
|
}
|
|
|
|
// 7.3.9.2
|
|
var func = this.GetV(O, P);
|
|
|
|
// 7.3.9.4
|
|
if (func == null) {
|
|
return undefined;
|
|
}
|
|
|
|
// 7.3.9.5
|
|
if (!this.IsCallable(func)) {
|
|
throw new TypeError(P + 'is not a function');
|
|
}
|
|
|
|
// 7.3.9.6
|
|
return func;
|
|
},
|
|
|
|
/**
|
|
* 7.3.1 Get (O, P) - http://www.ecma-international.org/ecma-262/6.0/#sec-get-o-p
|
|
* 1. Assert: Type(O) is Object.
|
|
* 2. Assert: IsPropertyKey(P) is true.
|
|
* 3. Return O.[[Get]](P, O).
|
|
*/
|
|
Get: function Get(O, P) {
|
|
// 7.3.1.1
|
|
if (this.Type(O) !== 'Object') {
|
|
throw new TypeError('Assertion failed: Type(O) is not Object');
|
|
}
|
|
// 7.3.1.2
|
|
if (!this.IsPropertyKey(P)) {
|
|
throw new TypeError('Assertion failed: IsPropertyKey(P) is not true');
|
|
}
|
|
// 7.3.1.3
|
|
return O[P];
|
|
},
|
|
|
|
Type: function Type(x) {
|
|
if (typeof x === 'symbol') {
|
|
return 'Symbol';
|
|
}
|
|
return ES5.Type(x);
|
|
},
|
|
|
|
// http://www.ecma-international.org/ecma-262/6.0/#sec-speciesconstructor
|
|
SpeciesConstructor: function SpeciesConstructor(O, defaultConstructor) {
|
|
if (this.Type(O) !== 'Object') {
|
|
throw new TypeError('Assertion failed: Type(O) is not Object');
|
|
}
|
|
var C = O.constructor;
|
|
if (typeof C === 'undefined') {
|
|
return defaultConstructor;
|
|
}
|
|
if (this.Type(C) !== 'Object') {
|
|
throw new TypeError('O.constructor is not an Object');
|
|
}
|
|
var S = hasSymbols && Symbol.species ? C[Symbol.species] : undefined;
|
|
if (S == null) {
|
|
return defaultConstructor;
|
|
}
|
|
if (this.IsConstructor(S)) {
|
|
return S;
|
|
}
|
|
throw new TypeError('no constructor found');
|
|
}
|
|
});
|
|
|
|
delete ES6.CheckObjectCoercible; // renamed in ES6 to RequireObjectCoercible
|
|
|
|
module.exports = ES6;
|
|
|
|
},{"./es5":9,"./helpers/assign":11,"./helpers/isFinite":12,"./helpers/isNaN":13,"./helpers/isPrimitive":14,"./helpers/mod":15,"./helpers/sign":16,"es-to-primitive/es6":18,"function-bind":23,"is-regex":27}],11:[function(require,module,exports){
|
|
var has = Object.prototype.hasOwnProperty;
|
|
module.exports = Object.assign || function assign(target, source) {
|
|
for (var key in source) {
|
|
if (has.call(source, key)) {
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
return target;
|
|
};
|
|
|
|
},{}],12:[function(require,module,exports){
|
|
var $isNaN = Number.isNaN || function (a) { return a !== a; };
|
|
|
|
module.exports = Number.isFinite || function (x) { return typeof x === 'number' && !$isNaN(x) && x !== Infinity && x !== -Infinity; };
|
|
|
|
},{}],13:[function(require,module,exports){
|
|
module.exports = Number.isNaN || function isNaN(a) {
|
|
return a !== a;
|
|
};
|
|
|
|
},{}],14:[function(require,module,exports){
|
|
module.exports = function isPrimitive(value) {
|
|
return value === null || (typeof value !== 'function' && typeof value !== 'object');
|
|
};
|
|
|
|
},{}],15:[function(require,module,exports){
|
|
module.exports = function mod(number, modulo) {
|
|
var remain = number % modulo;
|
|
return Math.floor(remain >= 0 ? remain : remain + modulo);
|
|
};
|
|
|
|
},{}],16:[function(require,module,exports){
|
|
module.exports = function sign(number) {
|
|
return number >= 0 ? 1 : -1;
|
|
};
|
|
|
|
},{}],17:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var toStr = Object.prototype.toString;
|
|
|
|
var isPrimitive = require('./helpers/isPrimitive');
|
|
|
|
var isCallable = require('is-callable');
|
|
|
|
// https://es5.github.io/#x8.12
|
|
var ES5internalSlots = {
|
|
'[[DefaultValue]]': function (O, hint) {
|
|
var actualHint = hint || (toStr.call(O) === '[object Date]' ? String : Number);
|
|
|
|
if (actualHint === String || actualHint === Number) {
|
|
var methods = actualHint === String ? ['toString', 'valueOf'] : ['valueOf', 'toString'];
|
|
var value, i;
|
|
for (i = 0; i < methods.length; ++i) {
|
|
if (isCallable(O[methods[i]])) {
|
|
value = O[methods[i]]();
|
|
if (isPrimitive(value)) {
|
|
return value;
|
|
}
|
|
}
|
|
}
|
|
throw new TypeError('No default value');
|
|
}
|
|
throw new TypeError('invalid [[DefaultValue]] hint supplied');
|
|
}
|
|
};
|
|
|
|
// https://es5.github.io/#x9
|
|
module.exports = function ToPrimitive(input, PreferredType) {
|
|
if (isPrimitive(input)) {
|
|
return input;
|
|
}
|
|
return ES5internalSlots['[[DefaultValue]]'](input, PreferredType);
|
|
};
|
|
|
|
},{"./helpers/isPrimitive":19,"is-callable":25}],18:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var hasSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol';
|
|
|
|
var isPrimitive = require('./helpers/isPrimitive');
|
|
var isCallable = require('is-callable');
|
|
var isDate = require('is-date-object');
|
|
var isSymbol = require('is-symbol');
|
|
|
|
var ordinaryToPrimitive = function OrdinaryToPrimitive(O, hint) {
|
|
if (typeof O === 'undefined' || O === null) {
|
|
throw new TypeError('Cannot call method on ' + O);
|
|
}
|
|
if (typeof hint !== 'string' || (hint !== 'number' && hint !== 'string')) {
|
|
throw new TypeError('hint must be "string" or "number"');
|
|
}
|
|
var methodNames = hint === 'string' ? ['toString', 'valueOf'] : ['valueOf', 'toString'];
|
|
var method, result, i;
|
|
for (i = 0; i < methodNames.length; ++i) {
|
|
method = O[methodNames[i]];
|
|
if (isCallable(method)) {
|
|
result = method.call(O);
|
|
if (isPrimitive(result)) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
throw new TypeError('No default value');
|
|
};
|
|
|
|
var GetMethod = function GetMethod(O, P) {
|
|
var func = O[P];
|
|
if (func !== null && typeof func !== 'undefined') {
|
|
if (!isCallable(func)) {
|
|
throw new TypeError(func + ' returned for property ' + P + ' of object ' + O + ' is not a function');
|
|
}
|
|
return func;
|
|
}
|
|
};
|
|
|
|
// http://www.ecma-international.org/ecma-262/6.0/#sec-toprimitive
|
|
module.exports = function ToPrimitive(input, PreferredType) {
|
|
if (isPrimitive(input)) {
|
|
return input;
|
|
}
|
|
var hint = 'default';
|
|
if (arguments.length > 1) {
|
|
if (PreferredType === String) {
|
|
hint = 'string';
|
|
} else if (PreferredType === Number) {
|
|
hint = 'number';
|
|
}
|
|
}
|
|
|
|
var exoticToPrim;
|
|
if (hasSymbols) {
|
|
if (Symbol.toPrimitive) {
|
|
exoticToPrim = GetMethod(input, Symbol.toPrimitive);
|
|
} else if (isSymbol(input)) {
|
|
exoticToPrim = Symbol.prototype.valueOf;
|
|
}
|
|
}
|
|
if (typeof exoticToPrim !== 'undefined') {
|
|
var result = exoticToPrim.call(input, hint);
|
|
if (isPrimitive(result)) {
|
|
return result;
|
|
}
|
|
throw new TypeError('unable to convert exotic object to primitive');
|
|
}
|
|
if (hint === 'default' && (isDate(input) || isSymbol(input))) {
|
|
hint = 'string';
|
|
}
|
|
return ordinaryToPrimitive(input, hint === 'default' ? 'number' : hint);
|
|
};
|
|
|
|
},{"./helpers/isPrimitive":19,"is-callable":25,"is-date-object":26,"is-symbol":28}],19:[function(require,module,exports){
|
|
arguments[4][14][0].apply(exports,arguments)
|
|
},{"dup":14}],20:[function(require,module,exports){
|
|
(function (global){
|
|
(function(global){
|
|
|
|
//
|
|
// Check for native Promise and it has correct interface
|
|
//
|
|
|
|
var NativePromise = global['Promise'];
|
|
var nativePromiseSupported =
|
|
NativePromise &&
|
|
// Some of these methods are missing from
|
|
// Firefox/Chrome experimental implementations
|
|
'resolve' in NativePromise &&
|
|
'reject' in NativePromise &&
|
|
'all' in NativePromise &&
|
|
'race' in NativePromise &&
|
|
// Older version of the spec had a resolver object
|
|
// as the arg rather than a function
|
|
(function(){
|
|
var resolve;
|
|
new NativePromise(function(r){ resolve = r; });
|
|
return typeof resolve === 'function';
|
|
})();
|
|
|
|
|
|
//
|
|
// export if necessary
|
|
//
|
|
|
|
if (typeof exports !== 'undefined' && exports)
|
|
{
|
|
// node.js
|
|
exports.Promise = nativePromiseSupported ? NativePromise : Promise;
|
|
exports.Polyfill = Promise;
|
|
}
|
|
else
|
|
{
|
|
// AMD
|
|
if (typeof define == 'function' && define.amd)
|
|
{
|
|
define(function(){
|
|
return nativePromiseSupported ? NativePromise : Promise;
|
|
});
|
|
}
|
|
else
|
|
{
|
|
// in browser add to global
|
|
if (!nativePromiseSupported)
|
|
global['Promise'] = Promise;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Polyfill
|
|
//
|
|
|
|
var PENDING = 'pending';
|
|
var SEALED = 'sealed';
|
|
var FULFILLED = 'fulfilled';
|
|
var REJECTED = 'rejected';
|
|
var NOOP = function(){};
|
|
|
|
function isArray(value) {
|
|
return Object.prototype.toString.call(value) === '[object Array]';
|
|
}
|
|
|
|
// async calls
|
|
var asyncSetTimer = typeof setImmediate !== 'undefined' ? setImmediate : setTimeout;
|
|
var asyncQueue = [];
|
|
var asyncTimer;
|
|
|
|
function asyncFlush(){
|
|
// run promise callbacks
|
|
for (var i = 0; i < asyncQueue.length; i++)
|
|
asyncQueue[i][0](asyncQueue[i][1]);
|
|
|
|
// reset async asyncQueue
|
|
asyncQueue = [];
|
|
asyncTimer = false;
|
|
}
|
|
|
|
function asyncCall(callback, arg){
|
|
asyncQueue.push([callback, arg]);
|
|
|
|
if (!asyncTimer)
|
|
{
|
|
asyncTimer = true;
|
|
asyncSetTimer(asyncFlush, 0);
|
|
}
|
|
}
|
|
|
|
|
|
function invokeResolver(resolver, promise) {
|
|
function resolvePromise(value) {
|
|
resolve(promise, value);
|
|
}
|
|
|
|
function rejectPromise(reason) {
|
|
reject(promise, reason);
|
|
}
|
|
|
|
try {
|
|
resolver(resolvePromise, rejectPromise);
|
|
} catch(e) {
|
|
rejectPromise(e);
|
|
}
|
|
}
|
|
|
|
function invokeCallback(subscriber){
|
|
var owner = subscriber.owner;
|
|
var settled = owner.state_;
|
|
var value = owner.data_;
|
|
var callback = subscriber[settled];
|
|
var promise = subscriber.then;
|
|
|
|
if (typeof callback === 'function')
|
|
{
|
|
settled = FULFILLED;
|
|
try {
|
|
value = callback(value);
|
|
} catch(e) {
|
|
reject(promise, e);
|
|
}
|
|
}
|
|
|
|
if (!handleThenable(promise, value))
|
|
{
|
|
if (settled === FULFILLED)
|
|
resolve(promise, value);
|
|
|
|
if (settled === REJECTED)
|
|
reject(promise, value);
|
|
}
|
|
}
|
|
|
|
function handleThenable(promise, value) {
|
|
var resolved;
|
|
|
|
try {
|
|
if (promise === value)
|
|
throw new TypeError('A promises callback cannot return that same promise.');
|
|
|
|
if (value && (typeof value === 'function' || typeof value === 'object'))
|
|
{
|
|
var then = value.then; // then should be retrived only once
|
|
|
|
if (typeof then === 'function')
|
|
{
|
|
then.call(value, function(val){
|
|
if (!resolved)
|
|
{
|
|
resolved = true;
|
|
|
|
if (value !== val)
|
|
resolve(promise, val);
|
|
else
|
|
fulfill(promise, val);
|
|
}
|
|
}, function(reason){
|
|
if (!resolved)
|
|
{
|
|
resolved = true;
|
|
|
|
reject(promise, reason);
|
|
}
|
|
});
|
|
|
|
return true;
|
|
}
|
|
}
|
|
} catch (e) {
|
|
if (!resolved)
|
|
reject(promise, e);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function resolve(promise, value){
|
|
if (promise === value || !handleThenable(promise, value))
|
|
fulfill(promise, value);
|
|
}
|
|
|
|
function fulfill(promise, value){
|
|
if (promise.state_ === PENDING)
|
|
{
|
|
promise.state_ = SEALED;
|
|
promise.data_ = value;
|
|
|
|
asyncCall(publishFulfillment, promise);
|
|
}
|
|
}
|
|
|
|
function reject(promise, reason){
|
|
if (promise.state_ === PENDING)
|
|
{
|
|
promise.state_ = SEALED;
|
|
promise.data_ = reason;
|
|
|
|
asyncCall(publishRejection, promise);
|
|
}
|
|
}
|
|
|
|
function publish(promise) {
|
|
var callbacks = promise.then_;
|
|
promise.then_ = undefined;
|
|
|
|
for (var i = 0; i < callbacks.length; i++) {
|
|
invokeCallback(callbacks[i]);
|
|
}
|
|
}
|
|
|
|
function publishFulfillment(promise){
|
|
promise.state_ = FULFILLED;
|
|
publish(promise);
|
|
}
|
|
|
|
function publishRejection(promise){
|
|
promise.state_ = REJECTED;
|
|
publish(promise);
|
|
}
|
|
|
|
/**
|
|
* @class
|
|
*/
|
|
function Promise(resolver){
|
|
if (typeof resolver !== 'function')
|
|
throw new TypeError('Promise constructor takes a function argument');
|
|
|
|
if (this instanceof Promise === false)
|
|
throw new TypeError('Failed to construct \'Promise\': Please use the \'new\' operator, this object constructor cannot be called as a function.');
|
|
|
|
this.then_ = [];
|
|
|
|
invokeResolver(resolver, this);
|
|
}
|
|
|
|
Promise.prototype = {
|
|
constructor: Promise,
|
|
|
|
state_: PENDING,
|
|
then_: null,
|
|
data_: undefined,
|
|
|
|
then: function(onFulfillment, onRejection){
|
|
var subscriber = {
|
|
owner: this,
|
|
then: new this.constructor(NOOP),
|
|
fulfilled: onFulfillment,
|
|
rejected: onRejection
|
|
};
|
|
|
|
if (this.state_ === FULFILLED || this.state_ === REJECTED)
|
|
{
|
|
// already resolved, call callback async
|
|
asyncCall(invokeCallback, subscriber);
|
|
}
|
|
else
|
|
{
|
|
// subscribe
|
|
this.then_.push(subscriber);
|
|
}
|
|
|
|
return subscriber.then;
|
|
},
|
|
|
|
'catch': function(onRejection) {
|
|
return this.then(null, onRejection);
|
|
}
|
|
};
|
|
|
|
Promise.all = function(promises){
|
|
var Class = this;
|
|
|
|
if (!isArray(promises))
|
|
throw new TypeError('You must pass an array to Promise.all().');
|
|
|
|
return new Class(function(resolve, reject){
|
|
var results = [];
|
|
var remaining = 0;
|
|
|
|
function resolver(index){
|
|
remaining++;
|
|
return function(value){
|
|
results[index] = value;
|
|
if (!--remaining)
|
|
resolve(results);
|
|
};
|
|
}
|
|
|
|
for (var i = 0, promise; i < promises.length; i++)
|
|
{
|
|
promise = promises[i];
|
|
|
|
if (promise && typeof promise.then === 'function')
|
|
promise.then(resolver(i), reject);
|
|
else
|
|
results[i] = promise;
|
|
}
|
|
|
|
if (!remaining)
|
|
resolve(results);
|
|
});
|
|
};
|
|
|
|
Promise.race = function(promises){
|
|
var Class = this;
|
|
|
|
if (!isArray(promises))
|
|
throw new TypeError('You must pass an array to Promise.race().');
|
|
|
|
return new Class(function(resolve, reject) {
|
|
for (var i = 0, promise; i < promises.length; i++)
|
|
{
|
|
promise = promises[i];
|
|
|
|
if (promise && typeof promise.then === 'function')
|
|
promise.then(resolve, reject);
|
|
else
|
|
resolve(promise);
|
|
}
|
|
});
|
|
};
|
|
|
|
Promise.resolve = function(value){
|
|
var Class = this;
|
|
|
|
if (value && typeof value === 'object' && value.constructor === Class)
|
|
return value;
|
|
|
|
return new Class(function(resolve){
|
|
resolve(value);
|
|
});
|
|
};
|
|
|
|
Promise.reject = function(reason){
|
|
var Class = this;
|
|
|
|
return new Class(function(resolve, reject){
|
|
reject(reason);
|
|
});
|
|
};
|
|
|
|
})(typeof window != 'undefined' ? window : typeof global != 'undefined' ? global : typeof self != 'undefined' ? self : this);
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{}],21:[function(require,module,exports){
|
|
|
|
var hasOwn = Object.prototype.hasOwnProperty;
|
|
var toString = Object.prototype.toString;
|
|
|
|
module.exports = function forEach (obj, fn, ctx) {
|
|
if (toString.call(fn) !== '[object Function]') {
|
|
throw new TypeError('iterator must be a function');
|
|
}
|
|
var l = obj.length;
|
|
if (l === +l) {
|
|
for (var i = 0; i < l; i++) {
|
|
fn.call(ctx, obj[i], i, obj);
|
|
}
|
|
} else {
|
|
for (var k in obj) {
|
|
if (hasOwn.call(obj, k)) {
|
|
fn.call(ctx, obj[k], k, obj);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
},{}],22:[function(require,module,exports){
|
|
var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
|
|
var slice = Array.prototype.slice;
|
|
var toStr = Object.prototype.toString;
|
|
var funcType = '[object Function]';
|
|
|
|
module.exports = function bind(that) {
|
|
var target = this;
|
|
if (typeof target !== 'function' || toStr.call(target) !== funcType) {
|
|
throw new TypeError(ERROR_MESSAGE + target);
|
|
}
|
|
var args = slice.call(arguments, 1);
|
|
|
|
var bound;
|
|
var binder = function () {
|
|
if (this instanceof bound) {
|
|
var result = target.apply(
|
|
this,
|
|
args.concat(slice.call(arguments))
|
|
);
|
|
if (Object(result) === result) {
|
|
return result;
|
|
}
|
|
return this;
|
|
} else {
|
|
return target.apply(
|
|
that,
|
|
args.concat(slice.call(arguments))
|
|
);
|
|
}
|
|
};
|
|
|
|
var boundLength = Math.max(0, target.length - args.length);
|
|
var boundArgs = [];
|
|
for (var i = 0; i < boundLength; i++) {
|
|
boundArgs.push('$' + i);
|
|
}
|
|
|
|
bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
|
|
|
|
if (target.prototype) {
|
|
var Empty = function Empty() {};
|
|
Empty.prototype = target.prototype;
|
|
bound.prototype = new Empty();
|
|
Empty.prototype = null;
|
|
}
|
|
|
|
return bound;
|
|
};
|
|
|
|
},{}],23:[function(require,module,exports){
|
|
var implementation = require('./implementation');
|
|
|
|
module.exports = Function.prototype.bind || implementation;
|
|
|
|
},{"./implementation":22}],24:[function(require,module,exports){
|
|
var bind = require('function-bind');
|
|
|
|
module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
|
|
|
|
},{"function-bind":23}],25:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var fnToStr = Function.prototype.toString;
|
|
|
|
var constructorRegex = /^\s*class /;
|
|
var isES6ClassFn = function isES6ClassFn(value) {
|
|
try {
|
|
var fnStr = fnToStr.call(value);
|
|
var singleStripped = fnStr.replace(/\/\/.*\n/g, '');
|
|
var multiStripped = singleStripped.replace(/\/\*[.\s\S]*\*\//g, '');
|
|
var spaceStripped = multiStripped.replace(/\n/mg, ' ').replace(/ {2}/g, ' ');
|
|
return constructorRegex.test(spaceStripped);
|
|
} catch (e) {
|
|
return false; // not a function
|
|
}
|
|
};
|
|
|
|
var tryFunctionObject = function tryFunctionObject(value) {
|
|
try {
|
|
if (isES6ClassFn(value)) { return false; }
|
|
fnToStr.call(value);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
var toStr = Object.prototype.toString;
|
|
var fnClass = '[object Function]';
|
|
var genClass = '[object GeneratorFunction]';
|
|
var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
|
|
|
|
module.exports = function isCallable(value) {
|
|
if (!value) { return false; }
|
|
if (typeof value !== 'function' && typeof value !== 'object') { return false; }
|
|
if (hasToStringTag) { return tryFunctionObject(value); }
|
|
if (isES6ClassFn(value)) { return false; }
|
|
var strClass = toStr.call(value);
|
|
return strClass === fnClass || strClass === genClass;
|
|
};
|
|
|
|
},{}],26:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var getDay = Date.prototype.getDay;
|
|
var tryDateObject = function tryDateObject(value) {
|
|
try {
|
|
getDay.call(value);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
var toStr = Object.prototype.toString;
|
|
var dateClass = '[object Date]';
|
|
var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
|
|
|
|
module.exports = function isDateObject(value) {
|
|
if (typeof value !== 'object' || value === null) { return false; }
|
|
return hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;
|
|
};
|
|
|
|
},{}],27:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var has = require('has');
|
|
var regexExec = RegExp.prototype.exec;
|
|
var gOPD = Object.getOwnPropertyDescriptor;
|
|
|
|
var tryRegexExecCall = function tryRegexExec(value) {
|
|
try {
|
|
var lastIndex = value.lastIndex;
|
|
value.lastIndex = 0;
|
|
|
|
regexExec.call(value);
|
|
return true;
|
|
} catch (e) {
|
|
return false;
|
|
} finally {
|
|
value.lastIndex = lastIndex;
|
|
}
|
|
};
|
|
var toStr = Object.prototype.toString;
|
|
var regexClass = '[object RegExp]';
|
|
var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
|
|
|
|
module.exports = function isRegex(value) {
|
|
if (!value || typeof value !== 'object') {
|
|
return false;
|
|
}
|
|
if (!hasToStringTag) {
|
|
return toStr.call(value) === regexClass;
|
|
}
|
|
|
|
var descriptor = gOPD(value, 'lastIndex');
|
|
var hasLastIndexDataProperty = descriptor && has(descriptor, 'value');
|
|
if (!hasLastIndexDataProperty) {
|
|
return false;
|
|
}
|
|
|
|
return tryRegexExecCall(value);
|
|
};
|
|
|
|
},{"has":24}],28:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var toStr = Object.prototype.toString;
|
|
var hasSymbols = typeof Symbol === 'function' && typeof Symbol() === 'symbol';
|
|
|
|
if (hasSymbols) {
|
|
var symToStr = Symbol.prototype.toString;
|
|
var symStringRegex = /^Symbol\(.*\)$/;
|
|
var isSymbolObject = function isSymbolObject(value) {
|
|
if (typeof value.valueOf() !== 'symbol') { return false; }
|
|
return symStringRegex.test(symToStr.call(value));
|
|
};
|
|
module.exports = function isSymbol(value) {
|
|
if (typeof value === 'symbol') { return true; }
|
|
if (toStr.call(value) !== '[object Symbol]') { return false; }
|
|
try {
|
|
return isSymbolObject(value);
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
} else {
|
|
module.exports = function isSymbol(value) {
|
|
// this environment does not support Symbols.
|
|
return false;
|
|
};
|
|
}
|
|
|
|
},{}],29:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var range; // Create a range object for efficently rendering strings to elements.
|
|
var NS_XHTML = 'http://www.w3.org/1999/xhtml';
|
|
|
|
var doc = typeof document === 'undefined' ? undefined : document;
|
|
|
|
var testEl = doc ?
|
|
doc.body || doc.createElement('div') :
|
|
{};
|
|
|
|
// Fixes <https://github.com/patrick-steele-idem/morphdom/issues/32>
|
|
// (IE7+ support) <=IE7 does not support el.hasAttribute(name)
|
|
var actualHasAttributeNS;
|
|
|
|
if (testEl.hasAttributeNS) {
|
|
actualHasAttributeNS = function(el, namespaceURI, name) {
|
|
return el.hasAttributeNS(namespaceURI, name);
|
|
};
|
|
} else if (testEl.hasAttribute) {
|
|
actualHasAttributeNS = function(el, namespaceURI, name) {
|
|
return el.hasAttribute(name);
|
|
};
|
|
} else {
|
|
actualHasAttributeNS = function(el, namespaceURI, name) {
|
|
return el.getAttributeNode(namespaceURI, name) != null;
|
|
};
|
|
}
|
|
|
|
var hasAttributeNS = actualHasAttributeNS;
|
|
|
|
|
|
function toElement(str) {
|
|
if (!range && doc.createRange) {
|
|
range = doc.createRange();
|
|
range.selectNode(doc.body);
|
|
}
|
|
|
|
var fragment;
|
|
if (range && range.createContextualFragment) {
|
|
fragment = range.createContextualFragment(str);
|
|
} else {
|
|
fragment = doc.createElement('body');
|
|
fragment.innerHTML = str;
|
|
}
|
|
return fragment.childNodes[0];
|
|
}
|
|
|
|
/**
|
|
* Returns true if two node's names are the same.
|
|
*
|
|
* NOTE: We don't bother checking `namespaceURI` because you will never find two HTML elements with the same
|
|
* nodeName and different namespace URIs.
|
|
*
|
|
* @param {Element} a
|
|
* @param {Element} b The target element
|
|
* @return {boolean}
|
|
*/
|
|
function compareNodeNames(fromEl, toEl) {
|
|
var fromNodeName = fromEl.nodeName;
|
|
var toNodeName = toEl.nodeName;
|
|
|
|
if (fromNodeName === toNodeName) {
|
|
return true;
|
|
}
|
|
|
|
if (toEl.actualize &&
|
|
fromNodeName.charCodeAt(0) < 91 && /* from tag name is upper case */
|
|
toNodeName.charCodeAt(0) > 90 /* target tag name is lower case */) {
|
|
// If the target element is a virtual DOM node then we may need to normalize the tag name
|
|
// before comparing. Normal HTML elements that are in the "http://www.w3.org/1999/xhtml"
|
|
// are converted to upper case
|
|
return fromNodeName === toNodeName.toUpperCase();
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create an element, optionally with a known namespace URI.
|
|
*
|
|
* @param {string} name the element name, e.g. 'div' or 'svg'
|
|
* @param {string} [namespaceURI] the element's namespace URI, i.e. the value of
|
|
* its `xmlns` attribute or its inferred namespace.
|
|
*
|
|
* @return {Element}
|
|
*/
|
|
function createElementNS(name, namespaceURI) {
|
|
return !namespaceURI || namespaceURI === NS_XHTML ?
|
|
doc.createElement(name) :
|
|
doc.createElementNS(namespaceURI, name);
|
|
}
|
|
|
|
/**
|
|
* Copies the children of one DOM element to another DOM element
|
|
*/
|
|
function moveChildren(fromEl, toEl) {
|
|
var curChild = fromEl.firstChild;
|
|
while (curChild) {
|
|
var nextChild = curChild.nextSibling;
|
|
toEl.appendChild(curChild);
|
|
curChild = nextChild;
|
|
}
|
|
return toEl;
|
|
}
|
|
|
|
function morphAttrs(fromNode, toNode) {
|
|
var attrs = toNode.attributes;
|
|
var i;
|
|
var attr;
|
|
var attrName;
|
|
var attrNamespaceURI;
|
|
var attrValue;
|
|
var fromValue;
|
|
|
|
for (i = attrs.length - 1; i >= 0; --i) {
|
|
attr = attrs[i];
|
|
attrName = attr.name;
|
|
attrNamespaceURI = attr.namespaceURI;
|
|
attrValue = attr.value;
|
|
|
|
if (attrNamespaceURI) {
|
|
attrName = attr.localName || attrName;
|
|
fromValue = fromNode.getAttributeNS(attrNamespaceURI, attrName);
|
|
|
|
if (fromValue !== attrValue) {
|
|
fromNode.setAttributeNS(attrNamespaceURI, attrName, attrValue);
|
|
}
|
|
} else {
|
|
fromValue = fromNode.getAttribute(attrName);
|
|
|
|
if (fromValue !== attrValue) {
|
|
fromNode.setAttribute(attrName, attrValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove any extra attributes found on the original DOM element that
|
|
// weren't found on the target element.
|
|
attrs = fromNode.attributes;
|
|
|
|
for (i = attrs.length - 1; i >= 0; --i) {
|
|
attr = attrs[i];
|
|
if (attr.specified !== false) {
|
|
attrName = attr.name;
|
|
attrNamespaceURI = attr.namespaceURI;
|
|
|
|
if (attrNamespaceURI) {
|
|
attrName = attr.localName || attrName;
|
|
|
|
if (!hasAttributeNS(toNode, attrNamespaceURI, attrName)) {
|
|
fromNode.removeAttributeNS(attrNamespaceURI, attrName);
|
|
}
|
|
} else {
|
|
if (!hasAttributeNS(toNode, null, attrName)) {
|
|
fromNode.removeAttribute(attrName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function syncBooleanAttrProp(fromEl, toEl, name) {
|
|
if (fromEl[name] !== toEl[name]) {
|
|
fromEl[name] = toEl[name];
|
|
if (fromEl[name]) {
|
|
fromEl.setAttribute(name, '');
|
|
} else {
|
|
fromEl.removeAttribute(name, '');
|
|
}
|
|
}
|
|
}
|
|
|
|
var specialElHandlers = {
|
|
/**
|
|
* Needed for IE. Apparently IE doesn't think that "selected" is an
|
|
* attribute when reading over the attributes using selectEl.attributes
|
|
*/
|
|
OPTION: function(fromEl, toEl) {
|
|
syncBooleanAttrProp(fromEl, toEl, 'selected');
|
|
},
|
|
/**
|
|
* The "value" attribute is special for the <input> element since it sets
|
|
* the initial value. Changing the "value" attribute without changing the
|
|
* "value" property will have no effect since it is only used to the set the
|
|
* initial value. Similar for the "checked" attribute, and "disabled".
|
|
*/
|
|
INPUT: function(fromEl, toEl) {
|
|
syncBooleanAttrProp(fromEl, toEl, 'checked');
|
|
syncBooleanAttrProp(fromEl, toEl, 'disabled');
|
|
|
|
if (fromEl.value !== toEl.value) {
|
|
fromEl.value = toEl.value;
|
|
}
|
|
|
|
if (!hasAttributeNS(toEl, null, 'value')) {
|
|
fromEl.removeAttribute('value');
|
|
}
|
|
},
|
|
|
|
TEXTAREA: function(fromEl, toEl) {
|
|
var newValue = toEl.value;
|
|
if (fromEl.value !== newValue) {
|
|
fromEl.value = newValue;
|
|
}
|
|
|
|
if (fromEl.firstChild) {
|
|
// Needed for IE. Apparently IE sets the placeholder as the
|
|
// node value and vise versa. This ignores an empty update.
|
|
if (newValue === '' && fromEl.firstChild.nodeValue === fromEl.placeholder) {
|
|
return;
|
|
}
|
|
|
|
fromEl.firstChild.nodeValue = newValue;
|
|
}
|
|
},
|
|
SELECT: function(fromEl, toEl) {
|
|
if (!hasAttributeNS(toEl, null, 'multiple')) {
|
|
var selectedIndex = -1;
|
|
var i = 0;
|
|
var curChild = toEl.firstChild;
|
|
while(curChild) {
|
|
var nodeName = curChild.nodeName;
|
|
if (nodeName && nodeName.toUpperCase() === 'OPTION') {
|
|
if (hasAttributeNS(curChild, null, 'selected')) {
|
|
selectedIndex = i;
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
curChild = curChild.nextSibling;
|
|
}
|
|
|
|
fromEl.selectedIndex = i;
|
|
}
|
|
}
|
|
};
|
|
|
|
var ELEMENT_NODE = 1;
|
|
var TEXT_NODE = 3;
|
|
var COMMENT_NODE = 8;
|
|
|
|
function noop() {}
|
|
|
|
function defaultGetNodeKey(node) {
|
|
return node.id;
|
|
}
|
|
|
|
function morphdomFactory(morphAttrs) {
|
|
|
|
return function morphdom(fromNode, toNode, options) {
|
|
if (!options) {
|
|
options = {};
|
|
}
|
|
|
|
if (typeof toNode === 'string') {
|
|
if (fromNode.nodeName === '#document' || fromNode.nodeName === 'HTML') {
|
|
var toNodeHtml = toNode;
|
|
toNode = doc.createElement('html');
|
|
toNode.innerHTML = toNodeHtml;
|
|
} else {
|
|
toNode = toElement(toNode);
|
|
}
|
|
}
|
|
|
|
var getNodeKey = options.getNodeKey || defaultGetNodeKey;
|
|
var onBeforeNodeAdded = options.onBeforeNodeAdded || noop;
|
|
var onNodeAdded = options.onNodeAdded || noop;
|
|
var onBeforeElUpdated = options.onBeforeElUpdated || noop;
|
|
var onElUpdated = options.onElUpdated || noop;
|
|
var onBeforeNodeDiscarded = options.onBeforeNodeDiscarded || noop;
|
|
var onNodeDiscarded = options.onNodeDiscarded || noop;
|
|
var onBeforeElChildrenUpdated = options.onBeforeElChildrenUpdated || noop;
|
|
var childrenOnly = options.childrenOnly === true;
|
|
|
|
// This object is used as a lookup to quickly find all keyed elements in the original DOM tree.
|
|
var fromNodesLookup = {};
|
|
var keyedRemovalList;
|
|
|
|
function addKeyedRemoval(key) {
|
|
if (keyedRemovalList) {
|
|
keyedRemovalList.push(key);
|
|
} else {
|
|
keyedRemovalList = [key];
|
|
}
|
|
}
|
|
|
|
function walkDiscardedChildNodes(node, skipKeyedNodes) {
|
|
if (node.nodeType === ELEMENT_NODE) {
|
|
var curChild = node.firstChild;
|
|
while (curChild) {
|
|
|
|
var key = undefined;
|
|
|
|
if (skipKeyedNodes && (key = getNodeKey(curChild))) {
|
|
// If we are skipping keyed nodes then we add the key
|
|
// to a list so that it can be handled at the very end.
|
|
addKeyedRemoval(key);
|
|
} else {
|
|
// Only report the node as discarded if it is not keyed. We do this because
|
|
// at the end we loop through all keyed elements that were unmatched
|
|
// and then discard them in one final pass.
|
|
onNodeDiscarded(curChild);
|
|
if (curChild.firstChild) {
|
|
walkDiscardedChildNodes(curChild, skipKeyedNodes);
|
|
}
|
|
}
|
|
|
|
curChild = curChild.nextSibling;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes a DOM node out of the original DOM
|
|
*
|
|
* @param {Node} node The node to remove
|
|
* @param {Node} parentNode The nodes parent
|
|
* @param {Boolean} skipKeyedNodes If true then elements with keys will be skipped and not discarded.
|
|
* @return {undefined}
|
|
*/
|
|
function removeNode(node, parentNode, skipKeyedNodes) {
|
|
if (onBeforeNodeDiscarded(node) === false) {
|
|
return;
|
|
}
|
|
|
|
if (parentNode) {
|
|
parentNode.removeChild(node);
|
|
}
|
|
|
|
onNodeDiscarded(node);
|
|
walkDiscardedChildNodes(node, skipKeyedNodes);
|
|
}
|
|
|
|
// // TreeWalker implementation is no faster, but keeping this around in case this changes in the future
|
|
// function indexTree(root) {
|
|
// var treeWalker = document.createTreeWalker(
|
|
// root,
|
|
// NodeFilter.SHOW_ELEMENT);
|
|
//
|
|
// var el;
|
|
// while((el = treeWalker.nextNode())) {
|
|
// var key = getNodeKey(el);
|
|
// if (key) {
|
|
// fromNodesLookup[key] = el;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// // NodeIterator implementation is no faster, but keeping this around in case this changes in the future
|
|
//
|
|
// function indexTree(node) {
|
|
// var nodeIterator = document.createNodeIterator(node, NodeFilter.SHOW_ELEMENT);
|
|
// var el;
|
|
// while((el = nodeIterator.nextNode())) {
|
|
// var key = getNodeKey(el);
|
|
// if (key) {
|
|
// fromNodesLookup[key] = el;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
function indexTree(node) {
|
|
if (node.nodeType === ELEMENT_NODE) {
|
|
var curChild = node.firstChild;
|
|
while (curChild) {
|
|
var key = getNodeKey(curChild);
|
|
if (key) {
|
|
fromNodesLookup[key] = curChild;
|
|
}
|
|
|
|
// Walk recursively
|
|
indexTree(curChild);
|
|
|
|
curChild = curChild.nextSibling;
|
|
}
|
|
}
|
|
}
|
|
|
|
indexTree(fromNode);
|
|
|
|
function handleNodeAdded(el) {
|
|
onNodeAdded(el);
|
|
|
|
var curChild = el.firstChild;
|
|
while (curChild) {
|
|
var nextSibling = curChild.nextSibling;
|
|
|
|
var key = getNodeKey(curChild);
|
|
if (key) {
|
|
var unmatchedFromEl = fromNodesLookup[key];
|
|
if (unmatchedFromEl && compareNodeNames(curChild, unmatchedFromEl)) {
|
|
curChild.parentNode.replaceChild(unmatchedFromEl, curChild);
|
|
morphEl(unmatchedFromEl, curChild);
|
|
}
|
|
}
|
|
|
|
handleNodeAdded(curChild);
|
|
curChild = nextSibling;
|
|
}
|
|
}
|
|
|
|
function morphEl(fromEl, toEl, childrenOnly) {
|
|
var toElKey = getNodeKey(toEl);
|
|
var curFromNodeKey;
|
|
|
|
if (toElKey) {
|
|
// If an element with an ID is being morphed then it is will be in the final
|
|
// DOM so clear it out of the saved elements collection
|
|
delete fromNodesLookup[toElKey];
|
|
}
|
|
|
|
if (toNode.isSameNode && toNode.isSameNode(fromNode)) {
|
|
return;
|
|
}
|
|
|
|
if (!childrenOnly) {
|
|
if (onBeforeElUpdated(fromEl, toEl) === false) {
|
|
return;
|
|
}
|
|
|
|
morphAttrs(fromEl, toEl);
|
|
onElUpdated(fromEl);
|
|
|
|
if (onBeforeElChildrenUpdated(fromEl, toEl) === false) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (fromEl.nodeName !== 'TEXTAREA') {
|
|
var curToNodeChild = toEl.firstChild;
|
|
var curFromNodeChild = fromEl.firstChild;
|
|
var curToNodeKey;
|
|
|
|
var fromNextSibling;
|
|
var toNextSibling;
|
|
var matchingFromEl;
|
|
|
|
outer: while (curToNodeChild) {
|
|
toNextSibling = curToNodeChild.nextSibling;
|
|
curToNodeKey = getNodeKey(curToNodeChild);
|
|
|
|
while (curFromNodeChild) {
|
|
fromNextSibling = curFromNodeChild.nextSibling;
|
|
|
|
if (curToNodeChild.isSameNode && curToNodeChild.isSameNode(curFromNodeChild)) {
|
|
curToNodeChild = toNextSibling;
|
|
curFromNodeChild = fromNextSibling;
|
|
continue outer;
|
|
}
|
|
|
|
curFromNodeKey = getNodeKey(curFromNodeChild);
|
|
|
|
var curFromNodeType = curFromNodeChild.nodeType;
|
|
|
|
var isCompatible = undefined;
|
|
|
|
if (curFromNodeType === curToNodeChild.nodeType) {
|
|
if (curFromNodeType === ELEMENT_NODE) {
|
|
// Both nodes being compared are Element nodes
|
|
|
|
if (curToNodeKey) {
|
|
// The target node has a key so we want to match it up with the correct element
|
|
// in the original DOM tree
|
|
if (curToNodeKey !== curFromNodeKey) {
|
|
// The current element in the original DOM tree does not have a matching key so
|
|
// let's check our lookup to see if there is a matching element in the original
|
|
// DOM tree
|
|
if ((matchingFromEl = fromNodesLookup[curToNodeKey])) {
|
|
if (curFromNodeChild.nextSibling === matchingFromEl) {
|
|
// Special case for single element removals. To avoid removing the original
|
|
// DOM node out of the tree (since that can break CSS transitions, etc.),
|
|
// we will instead discard the current node and wait until the next
|
|
// iteration to properly match up the keyed target element with its matching
|
|
// element in the original tree
|
|
isCompatible = false;
|
|
} else {
|
|
// We found a matching keyed element somewhere in the original DOM tree.
|
|
// Let's moving the original DOM node into the current position and morph
|
|
// it.
|
|
|
|
// NOTE: We use insertBefore instead of replaceChild because we want to go through
|
|
// the `removeNode()` function for the node that is being discarded so that
|
|
// all lifecycle hooks are correctly invoked
|
|
fromEl.insertBefore(matchingFromEl, curFromNodeChild);
|
|
|
|
fromNextSibling = curFromNodeChild.nextSibling;
|
|
|
|
if (curFromNodeKey) {
|
|
// Since the node is keyed it might be matched up later so we defer
|
|
// the actual removal to later
|
|
addKeyedRemoval(curFromNodeKey);
|
|
} else {
|
|
// NOTE: we skip nested keyed nodes from being removed since there is
|
|
// still a chance they will be matched up later
|
|
removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */);
|
|
}
|
|
|
|
curFromNodeChild = matchingFromEl;
|
|
}
|
|
} else {
|
|
// The nodes are not compatible since the "to" node has a key and there
|
|
// is no matching keyed node in the source tree
|
|
isCompatible = false;
|
|
}
|
|
}
|
|
} else if (curFromNodeKey) {
|
|
// The original has a key
|
|
isCompatible = false;
|
|
}
|
|
|
|
isCompatible = isCompatible !== false && compareNodeNames(curFromNodeChild, curToNodeChild);
|
|
if (isCompatible) {
|
|
// We found compatible DOM elements so transform
|
|
// the current "from" node to match the current
|
|
// target DOM node.
|
|
morphEl(curFromNodeChild, curToNodeChild);
|
|
}
|
|
|
|
} else if (curFromNodeType === TEXT_NODE || curFromNodeType == COMMENT_NODE) {
|
|
// Both nodes being compared are Text or Comment nodes
|
|
isCompatible = true;
|
|
// Simply update nodeValue on the original node to
|
|
// change the text value
|
|
curFromNodeChild.nodeValue = curToNodeChild.nodeValue;
|
|
}
|
|
}
|
|
|
|
if (isCompatible) {
|
|
// Advance both the "to" child and the "from" child since we found a match
|
|
curToNodeChild = toNextSibling;
|
|
curFromNodeChild = fromNextSibling;
|
|
continue outer;
|
|
}
|
|
|
|
// No compatible match so remove the old node from the DOM and continue trying to find a
|
|
// match in the original DOM. However, we only do this if the from node is not keyed
|
|
// since it is possible that a keyed node might match up with a node somewhere else in the
|
|
// target tree and we don't want to discard it just yet since it still might find a
|
|
// home in the final DOM tree. After everything is done we will remove any keyed nodes
|
|
// that didn't find a home
|
|
if (curFromNodeKey) {
|
|
// Since the node is keyed it might be matched up later so we defer
|
|
// the actual removal to later
|
|
addKeyedRemoval(curFromNodeKey);
|
|
} else {
|
|
// NOTE: we skip nested keyed nodes from being removed since there is
|
|
// still a chance they will be matched up later
|
|
removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */);
|
|
}
|
|
|
|
curFromNodeChild = fromNextSibling;
|
|
}
|
|
|
|
// If we got this far then we did not find a candidate match for
|
|
// our "to node" and we exhausted all of the children "from"
|
|
// nodes. Therefore, we will just append the current "to" node
|
|
// to the end
|
|
if (curToNodeKey && (matchingFromEl = fromNodesLookup[curToNodeKey]) && compareNodeNames(matchingFromEl, curToNodeChild)) {
|
|
fromEl.appendChild(matchingFromEl);
|
|
morphEl(matchingFromEl, curToNodeChild);
|
|
} else {
|
|
var onBeforeNodeAddedResult = onBeforeNodeAdded(curToNodeChild);
|
|
if (onBeforeNodeAddedResult !== false) {
|
|
if (onBeforeNodeAddedResult) {
|
|
curToNodeChild = onBeforeNodeAddedResult;
|
|
}
|
|
|
|
if (curToNodeChild.actualize) {
|
|
curToNodeChild = curToNodeChild.actualize(fromEl.ownerDocument || doc);
|
|
}
|
|
fromEl.appendChild(curToNodeChild);
|
|
handleNodeAdded(curToNodeChild);
|
|
}
|
|
}
|
|
|
|
curToNodeChild = toNextSibling;
|
|
curFromNodeChild = fromNextSibling;
|
|
}
|
|
|
|
// We have processed all of the "to nodes". If curFromNodeChild is
|
|
// non-null then we still have some from nodes left over that need
|
|
// to be removed
|
|
while (curFromNodeChild) {
|
|
fromNextSibling = curFromNodeChild.nextSibling;
|
|
if ((curFromNodeKey = getNodeKey(curFromNodeChild))) {
|
|
// Since the node is keyed it might be matched up later so we defer
|
|
// the actual removal to later
|
|
addKeyedRemoval(curFromNodeKey);
|
|
} else {
|
|
// NOTE: we skip nested keyed nodes from being removed since there is
|
|
// still a chance they will be matched up later
|
|
removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */);
|
|
}
|
|
curFromNodeChild = fromNextSibling;
|
|
}
|
|
}
|
|
|
|
var specialElHandler = specialElHandlers[fromEl.nodeName];
|
|
if (specialElHandler) {
|
|
specialElHandler(fromEl, toEl);
|
|
}
|
|
} // END: morphEl(...)
|
|
|
|
var morphedNode = fromNode;
|
|
var morphedNodeType = morphedNode.nodeType;
|
|
var toNodeType = toNode.nodeType;
|
|
|
|
if (!childrenOnly) {
|
|
// Handle the case where we are given two DOM nodes that are not
|
|
// compatible (e.g. <div> --> <span> or <div> --> TEXT)
|
|
if (morphedNodeType === ELEMENT_NODE) {
|
|
if (toNodeType === ELEMENT_NODE) {
|
|
if (!compareNodeNames(fromNode, toNode)) {
|
|
onNodeDiscarded(fromNode);
|
|
morphedNode = moveChildren(fromNode, createElementNS(toNode.nodeName, toNode.namespaceURI));
|
|
}
|
|
} else {
|
|
// Going from an element node to a text node
|
|
morphedNode = toNode;
|
|
}
|
|
} else if (morphedNodeType === TEXT_NODE || morphedNodeType === COMMENT_NODE) { // Text or comment node
|
|
if (toNodeType === morphedNodeType) {
|
|
morphedNode.nodeValue = toNode.nodeValue;
|
|
return morphedNode;
|
|
} else {
|
|
// Text node to something else
|
|
morphedNode = toNode;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (morphedNode === toNode) {
|
|
// The "to node" was not compatible with the "from node" so we had to
|
|
// toss out the "from node" and use the "to node"
|
|
onNodeDiscarded(fromNode);
|
|
} else {
|
|
morphEl(morphedNode, toNode, childrenOnly);
|
|
|
|
// We now need to loop over any keyed nodes that might need to be
|
|
// removed. We only do the removal if we know that the keyed node
|
|
// never found a match. When a keyed node is matched up we remove
|
|
// it out of fromNodesLookup and we use fromNodesLookup to determine
|
|
// if a keyed node has been matched up or not
|
|
if (keyedRemovalList) {
|
|
for (var i=0, len=keyedRemovalList.length; i<len; i++) {
|
|
var elToRemove = fromNodesLookup[keyedRemovalList[i]];
|
|
if (elToRemove) {
|
|
removeNode(elToRemove, elToRemove.parentNode, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!childrenOnly && morphedNode !== fromNode && fromNode.parentNode) {
|
|
if (morphedNode.actualize) {
|
|
morphedNode = morphedNode.actualize(fromNode.ownerDocument || doc);
|
|
}
|
|
// If we had to swap out the from node with a new node because the old
|
|
// node was not compatible with the target node then we need to
|
|
// replace the old DOM node in the original DOM tree. This is only
|
|
// possible if the original DOM node was part of a DOM tree which
|
|
// we know is the case if it has a parent node.
|
|
fromNode.parentNode.replaceChild(morphedNode, fromNode);
|
|
}
|
|
|
|
return morphedNode;
|
|
};
|
|
}
|
|
|
|
var morphdom = morphdomFactory(morphAttrs);
|
|
|
|
module.exports = morphdom;
|
|
|
|
},{}],30:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
// modified from https://github.com/es-shims/es5-shim
|
|
var has = Object.prototype.hasOwnProperty;
|
|
var toStr = Object.prototype.toString;
|
|
var slice = Array.prototype.slice;
|
|
var isArgs = require('./isArguments');
|
|
var isEnumerable = Object.prototype.propertyIsEnumerable;
|
|
var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
|
|
var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
|
|
var dontEnums = [
|
|
'toString',
|
|
'toLocaleString',
|
|
'valueOf',
|
|
'hasOwnProperty',
|
|
'isPrototypeOf',
|
|
'propertyIsEnumerable',
|
|
'constructor'
|
|
];
|
|
var equalsConstructorPrototype = function (o) {
|
|
var ctor = o.constructor;
|
|
return ctor && ctor.prototype === o;
|
|
};
|
|
var excludedKeys = {
|
|
$console: true,
|
|
$external: true,
|
|
$frame: true,
|
|
$frameElement: true,
|
|
$frames: true,
|
|
$innerHeight: true,
|
|
$innerWidth: true,
|
|
$outerHeight: true,
|
|
$outerWidth: true,
|
|
$pageXOffset: true,
|
|
$pageYOffset: true,
|
|
$parent: true,
|
|
$scrollLeft: true,
|
|
$scrollTop: true,
|
|
$scrollX: true,
|
|
$scrollY: true,
|
|
$self: true,
|
|
$webkitIndexedDB: true,
|
|
$webkitStorageInfo: true,
|
|
$window: true
|
|
};
|
|
var hasAutomationEqualityBug = (function () {
|
|
/* global window */
|
|
if (typeof window === 'undefined') { return false; }
|
|
for (var k in window) {
|
|
try {
|
|
if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
|
|
try {
|
|
equalsConstructorPrototype(window[k]);
|
|
} catch (e) {
|
|
return true;
|
|
}
|
|
}
|
|
} catch (e) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}());
|
|
var equalsConstructorPrototypeIfNotBuggy = function (o) {
|
|
/* global window */
|
|
if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
|
|
return equalsConstructorPrototype(o);
|
|
}
|
|
try {
|
|
return equalsConstructorPrototype(o);
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
var keysShim = function keys(object) {
|
|
var isObject = object !== null && typeof object === 'object';
|
|
var isFunction = toStr.call(object) === '[object Function]';
|
|
var isArguments = isArgs(object);
|
|
var isString = isObject && toStr.call(object) === '[object String]';
|
|
var theKeys = [];
|
|
|
|
if (!isObject && !isFunction && !isArguments) {
|
|
throw new TypeError('Object.keys called on a non-object');
|
|
}
|
|
|
|
var skipProto = hasProtoEnumBug && isFunction;
|
|
if (isString && object.length > 0 && !has.call(object, 0)) {
|
|
for (var i = 0; i < object.length; ++i) {
|
|
theKeys.push(String(i));
|
|
}
|
|
}
|
|
|
|
if (isArguments && object.length > 0) {
|
|
for (var j = 0; j < object.length; ++j) {
|
|
theKeys.push(String(j));
|
|
}
|
|
} else {
|
|
for (var name in object) {
|
|
if (!(skipProto && name === 'prototype') && has.call(object, name)) {
|
|
theKeys.push(String(name));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hasDontEnumBug) {
|
|
var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
|
|
|
|
for (var k = 0; k < dontEnums.length; ++k) {
|
|
if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
|
|
theKeys.push(dontEnums[k]);
|
|
}
|
|
}
|
|
}
|
|
return theKeys;
|
|
};
|
|
|
|
keysShim.shim = function shimObjectKeys() {
|
|
if (Object.keys) {
|
|
var keysWorksWithArguments = (function () {
|
|
// Safari 5.0 bug
|
|
return (Object.keys(arguments) || '').length === 2;
|
|
}(1, 2));
|
|
if (!keysWorksWithArguments) {
|
|
var originalKeys = Object.keys;
|
|
Object.keys = function keys(object) {
|
|
if (isArgs(object)) {
|
|
return originalKeys(slice.call(object));
|
|
} else {
|
|
return originalKeys(object);
|
|
}
|
|
};
|
|
}
|
|
} else {
|
|
Object.keys = keysShim;
|
|
}
|
|
return Object.keys || keysShim;
|
|
};
|
|
|
|
module.exports = keysShim;
|
|
|
|
},{"./isArguments":31}],31:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var toStr = Object.prototype.toString;
|
|
|
|
module.exports = function isArguments(value) {
|
|
var str = toStr.call(value);
|
|
var isArgs = str === '[object Arguments]';
|
|
if (!isArgs) {
|
|
isArgs = str !== '[object Array]' &&
|
|
value !== null &&
|
|
typeof value === 'object' &&
|
|
typeof value.length === 'number' &&
|
|
value.length >= 0 &&
|
|
toStr.call(value.callee) === '[object Function]';
|
|
}
|
|
return isArgs;
|
|
};
|
|
|
|
},{}],32:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _aTemplate = require('a-template');
|
|
|
|
var _aTemplate2 = _interopRequireDefault(_aTemplate);
|
|
|
|
require('custom-event-polyfill');
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
|
|
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
|
|
|
|
var template = '<div class="\\{classNames.smartPhoto\\}"<!-- BEGIN hide:exist --> aria-hidden="true"<!-- END hide:exist --><!-- BEGIN hide:empty --> aria-hidden="false"<!-- END hide:empty --> role="dialog">\n\t<div class="\\{classNames.smartPhotoBody\\}">\n\t\t<div class="\\{classNames.smartPhotoInner\\}">\n\t\t\t <div class="\\{classNames.smartPhotoHeader\\}">\n\t\t\t\t\t<span class="\\{classNames.smartPhotoCount\\}">{currentIndex}[increment]/{total}</span>\n\t\t\t\t\t<span class="\\{classNames.smartPhotoCaption\\}" aria-live="polite" tabindex="-1"><!-- BEGIN groupItems:loop --><!-- \\BEGIN currentIndex:touch#{index} -->{caption}<!-- \\END currentIndex:touch#{index} --><!-- END groupItems:loop --></span>\n\t\t\t\t\t<button class="\\{classNames.smartPhotoDismiss\\}" data-action-click="hidePhoto()"><span class="smartphoto-sr-only">\\{message.closeDialog\\}</span></button>\n\t\t\t\t</div>\n\t\t\t\t<div class="\\{classNames.smartPhotoContent\\}"<!-- BEGIN isSmartPhone:exist --> data-action-touchstart="beforeDrag" data-action-touchmove="onDrag" data-action-touchend="afterDrag(false)"<!-- END isSmartPhone:exist --><!-- BEGIN isSmartPhone:empty --> data-action-click="hidePhoto()"<!-- END isSmartPhone:empty -->>\n\t\t\t\t</div>\n\t\t\t\t<ul style="transform:translate({translateX}px,{translateY}px);" class="\\{classNames.smartPhotoList\\}<!-- BEGIN onMoveClass:exist --> \\{classNames.smartPhotoListOnMove\\}<!-- END onMoveClass:exist -->">\n\t\t\t\t\t<!-- BEGIN groupItems:loop -->\n\t\t\t\t\t<li style="transform:translate({translateX}px,{translateY}px);" class="<!-- \\BEGIN currentIndex:touch#{index} -->current<!-- \\END currentIndex:touch#{index} -->">\n\t\t\t\t\t\t<!-- BEGIN processed:exist -->\n\t\t\t\t\t\t<div style="transform:translate({x}px,{y}px) scale({scale});" class="\\\\{classNames.smartPhotoImgWrap\\\\}"<!-- \\BEGIN isSmartPhone:empty --> data-action-mousemove="onDrag" data-action-mousedown="beforeDrag" data-action-mouseup="afterDrag"<!-- \\END isSmartPhone:empty --><!-- \\BEGIN isSmartPhone:exist --> data-action-touchstart="beforeDrag" data-action-touchmove="onDrag" data-action-touchend="afterDrag"<!-- \\END isSmartPhone:exist -->>\n\t\t\t\t\t\t\t<img style="<!-- \\BEGIN currentIndex:touch#{index} -->transform:translate(\\{photoPosX\\}[virtualPos]px,\\{photoPosY\\}[virtualPos]px) scale(\\{scaleSize\\});<!-- \\END currentIndex:touch#{index} -->width:{width}px;" src="{src}" class="\\\\{classNames.smartPhotoImg\\\\}<!-- \\BEGIN scale:exist --> \\\\{classNames.smartPhotoImgOnMove\\\\}<!-- \\END scale:exist --><!-- \\BEGIN elastic:exist --> \\\\{classNames.smartPhotoImgElasticMove\\\\}<!-- \\END elastic:exist --><!-- \\BEGIN appear:exist --> active<!-- \\END appear:exist -->" ondragstart="return false;">\n\t\t\t\t\t\t</div>\n\t\t\t\t\t\t<!-- END processed:exist -->\n\t\t\t\t\t\t<!-- BEGIN processed:empty -->\n\t\t\t\t\t\t<div class="\\\\{classNames.smartPhotoLoaderWrap\\\\}">\n\t\t\t\t\t\t\t<span class="\\\\{classNames.smartPhotoLoader\\\\}"></span>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t\t<!-- END processed:empty -->\n\t\t\t\t\t</li>\n\t\t\t\t\t<!-- END groupItems:loop -->\n\t\t\t\t</ul>\n\t\t\t\t<!-- BEGIN arrows:exist -->\n\t\t\t\t<ul class="\\{classNames.smartPhotoArrows\\}"<!-- BEGIN hideUi:exist --> aria-hidden="true"<!-- END hideUi:exist --><!-- BEGIN hideUi:exist --> aria-hidden="false"<!-- END hideUi:exist -->>\n\t\t\t\t\t<li class="\\{classNames.smartPhotoArrowLeft\\}"<!-- BEGIN showPrevArrow:empty --> aria-hidden="true"<!-- END showPrevArrow:empty -->><a href="#" data-action-click="gotoSlide({prev})" role="button"><span class="smartphoto-sr-only">\\{message.gotoPrevImage\\}</span></a></li>\n\t\t\t\t\t<li class="\\{classNames.smartPhotoArrowRight\\}"<!-- BEGIN showNextArrow:empty --> aria-hidden="true"<!-- END showNextArrow:empty -->><a href="#" data-action-click="gotoSlide({next})" role="button"><span class="smartphoto-sr-only">\\{message.gotoNextImage\\}</span></a></li>\n\t\t\t\t</ul>\n\t\t\t\t<!-- END arrows:exist -->\n\t\t\t\t<!-- BEGIN nav:exist -->\n\t\t\t\t<div class="smartphoto_txt"><div class="titbo"><a href="#" class="tit1">2년 6개월 억류됐다 풀려난..<span>웹 - 609x448</span></a><a href="#" class="tit2">연관</a><a href="#" class="tit3"></a></div></div><nav class="\\{classNames.smartPhotoNav\\}"<!-- BEGIN hideUi:exist --> aria-hidden="true"<!-- END hideUi:exist --><!-- BEGIN hideUi:exist --> aria-hidden="false"<!-- END hideUi:exist -->>\n\t\t\t\t\t<ul>\n\t\t\t\t\t\t<!-- BEGIN groupItems:loop -->\n\t\t\t\t\t\t<li><a href="#" data-action-click="gotoSlide({index})" class="<!-- \\BEGIN currentIndex:touch#{index} -->current<!-- \\END currentIndex:touch#{index} -->" style="background-image:url({src});" role="button"><span class="smartphoto-sr-only">go to {caption}</span></a></li>\n\t\t\t\t\t\t<!-- END groupItems:loop -->\n\t\t\t\t\t</ul>\n\t\t\t\t</nav>\n\t\t\t\t<!-- END nav:exist -->\n\t\t</div>\n\t\t<!-- BEGIN appearEffect:exist -->\n\t\t<img src=\\{appearEffect.img\\}\n\t\tclass="\\{classNames.smartPhotoImgClone\\}"\n\t\tstyle="width:\\{appearEffect.width\\}px;height:\\{appearEffect.height\\}px;transform:translate(\\{appearEffect.left\\}px,\\{appearEffect.top\\}px) scale(1)" />\n\t\t<!-- END appearEffect:exist -->\n\t</div>\n</div>\n';
|
|
|
|
|
|
var util = require('../lib/util');
|
|
var Promise = require('es6-promise-polyfill').Promise;
|
|
|
|
var defaults = {
|
|
classNames: {
|
|
smartPhoto: 'smartphoto',
|
|
smartPhotoClose: 'smartphoto-close',
|
|
smartPhotoBody: 'smartphoto-body',
|
|
smartPhotoInner: 'smartphoto-inner',
|
|
smartPhotoContent: 'smartphoto-content',
|
|
smartPhotoImg: 'smartphoto-img',
|
|
smartPhotoImgOnMove: 'smartphoto-img-onmove',
|
|
smartPhotoImgElasticMove: 'smartphoto-img-elasticmove',
|
|
smartPhotoImgWrap: 'smartphoto-img-wrap',
|
|
smartPhotoArrows: 'smartphoto-arrows',
|
|
smartPhotoNav: 'smartphoto-nav',
|
|
smartPhotoArrowRight: 'smartphoto-arrow-right',
|
|
smartPhotoArrowLeft: 'smartphoto-arrow-left',
|
|
smartPhotoImgLeft: 'smartphoto-img-left',
|
|
smartPhotoImgRight: 'smartphoto-img-right',
|
|
smartPhotoList: 'smartphoto-list',
|
|
smartPhotoListOnMove: 'smartphoto-list-onmove',
|
|
smartPhotoHeader: 'smartphoto-header',
|
|
smartPhotoCount: 'smartphoto-count',
|
|
smartPhotoCaption: 'smartphoto-caption',
|
|
smartPhotoDismiss: 'smartphoto-dismiss',
|
|
smartPhotoLoader: 'smartphoto-loader',
|
|
smartPhotoLoaderWrap: 'smartphoto-loader-wrap',
|
|
smartPhotoImgClone: 'smartphoto-img-clone'
|
|
},
|
|
message: {
|
|
gotoNextImage: 'go to the next image',
|
|
gotoPrevImage: 'go to the previous image',
|
|
closeDialog: 'close the image dialog'
|
|
},
|
|
arrows: true,
|
|
nav: true,
|
|
animationSpeed: 300,
|
|
swipeOffset: 100,
|
|
headerHeight: 60,
|
|
footerHeight: 60,
|
|
forceInterval: 10,
|
|
registance: 0.5,
|
|
resizeStyle: 'fit',
|
|
verticalGravity: false,
|
|
useOrientationApi: false,
|
|
useHistoryApi: true
|
|
};
|
|
|
|
var SmartPhoto = function (_ATemplate) {
|
|
_inherits(SmartPhoto, _ATemplate);
|
|
|
|
function SmartPhoto(selector, settings) {
|
|
_classCallCheck(this, SmartPhoto);
|
|
|
|
var _this = _possibleConstructorReturn(this, (SmartPhoto.__proto__ || Object.getPrototypeOf(SmartPhoto)).call(this));
|
|
|
|
_this.data = util.extend({}, defaults, settings);
|
|
_this.data.currentIndex = 0;
|
|
_this.data.oldIndex = 0;
|
|
_this.data.hide = true;
|
|
_this.data.group = {};
|
|
_this.data.scaleSize = 1;
|
|
_this.data.scale = false;
|
|
_this.pos = { x: 0, y: 0 };
|
|
_this.data.photoPosX = 0;
|
|
_this.data.photoPosY = 0;
|
|
_this.convert = {
|
|
increment: _this.increment,
|
|
virtualPos: _this.virtualPos
|
|
};
|
|
_this.data.groupItems = _this.groupItems;
|
|
_this.elements = typeof selector === 'string' ? document.querySelectorAll(selector) : selector;
|
|
var date = new Date();
|
|
_this.tapSecond = date.getTime();
|
|
_this.onListMove = false;
|
|
_this.clicked = false;
|
|
_this.id = _this._getUniqId();
|
|
_this.vx = 0;
|
|
_this.vy = 0;
|
|
_this.data.appearEffect = null;
|
|
_this.addTemplate(_this.id, template);
|
|
_this.data.isSmartPhone = _this._isSmartPhone();
|
|
var body = document.querySelector('body');
|
|
util.append(body, '<div data-id=\'' + _this.id + '\'></div>');
|
|
[].forEach.call(_this.elements, function (element) {
|
|
_this.addNewItem(element);
|
|
});
|
|
|
|
_this.update();
|
|
_this._getEachImageSize().then(function () {
|
|
_this._fireEvent('loadall');
|
|
var currentItem = _this._getCurrentItemByHash();
|
|
if (currentItem) {
|
|
util.triggerEvent(currentItem.element, 'click');
|
|
}
|
|
});
|
|
|
|
setInterval(function () {
|
|
_this._doAnim();
|
|
}, _this.data.forceInterval);
|
|
|
|
if (!_this.data.isSmartPhone) {
|
|
window.addEventListener('resize', function () {
|
|
if (!_this.groupItems()) {
|
|
return;
|
|
}
|
|
_this._resetTranslate();
|
|
_this._setPosByCurrentIndex();
|
|
_this._setSizeByScreen();
|
|
_this.update();
|
|
});
|
|
|
|
window.addEventListener('keydown', function (e) {
|
|
var code = e.keyCode || e.which;
|
|
if (_this.data.hide === true) {
|
|
return;
|
|
}
|
|
if (code === 37) {
|
|
_this.gotoSlide(_this.data.prev);
|
|
} else if (code === 39) {
|
|
_this.gotoSlide(_this.data.next);
|
|
} else if (code === 27) {
|
|
_this.hidePhoto();
|
|
}
|
|
});
|
|
return _possibleConstructorReturn(_this);
|
|
}
|
|
|
|
window.addEventListener('orientationchange', function () {
|
|
if (!_this.groupItems()) {
|
|
return;
|
|
}
|
|
_this._resetTranslate();
|
|
_this._setPosByCurrentIndex();
|
|
_this._setHashByCurrentIndex();
|
|
_this._setSizeByScreen();
|
|
_this.update();
|
|
});
|
|
|
|
if (!_this.data.useOrientationApi) {
|
|
return _possibleConstructorReturn(_this);
|
|
}
|
|
|
|
window.addEventListener('deviceorientation', function (e) {
|
|
var orientation = window.orientation;
|
|
if (!e || !e.gamma || _this.data.appearEffect) {
|
|
return;
|
|
}
|
|
if (!_this.isBeingZoomed && !_this.photoSwipable && !_this.data.elastic && _this.data.scale) {
|
|
if (orientation === 0) {
|
|
_this._calcGravity(e.gamma, e.beta);
|
|
} else if (orientation === 90) {
|
|
_this._calcGravity(e.beta, e.gamma);
|
|
} else if (orientation === -90) {
|
|
_this._calcGravity(-e.beta, -e.gamma);
|
|
} else if (orientation === 180) {
|
|
_this._calcGravity(-e.gamma, -e.beta);
|
|
}
|
|
}
|
|
});
|
|
return _this;
|
|
}
|
|
|
|
_createClass(SmartPhoto, [{
|
|
key: 'on',
|
|
value: function on(event, fn) {
|
|
var _this2 = this;
|
|
|
|
var photo = this._getElementByClass(this.data.classNames.smartPhoto);
|
|
photo.addEventListener(event, function (e) {
|
|
fn.call(_this2, e);
|
|
});
|
|
}
|
|
}, {
|
|
key: 'increment',
|
|
value: function increment(item) {
|
|
return item + 1;
|
|
}
|
|
}, {
|
|
key: 'virtualPos',
|
|
value: function virtualPos(pos) {
|
|
pos = parseInt(pos, 10);
|
|
var item = this._getSelectedItem();
|
|
return pos / item.scale / this.data.scaleSize;
|
|
}
|
|
}, {
|
|
key: 'groupItems',
|
|
value: function groupItems() {
|
|
return this.data.group[this.data.currentGroup];
|
|
}
|
|
}, {
|
|
key: '_getEachImageSize',
|
|
value: function _getEachImageSize() {
|
|
var arr = [];
|
|
var group = this.data.group;
|
|
var loadItems = function loadItems(item) {
|
|
var promise = new Promise(function (resolve, reject) {
|
|
var img = new Image();
|
|
img.onload = function () {
|
|
item.width = img.width;
|
|
item.height = img.height;
|
|
item.loaded = true;
|
|
resolve();
|
|
};
|
|
img.onerror = function () {
|
|
reject();
|
|
};
|
|
img.src = item.src;
|
|
});
|
|
arr.push(promise);
|
|
};
|
|
Object.keys(group).forEach(function (key) {
|
|
group[key].forEach(loadItems);
|
|
});
|
|
return Promise.all(arr);
|
|
}
|
|
}, {
|
|
key: '_resetTranslate',
|
|
value: function _resetTranslate() {
|
|
var _this3 = this;
|
|
|
|
var items = this.groupItems();
|
|
items.forEach(function (item, index) {
|
|
item.translateX = _this3._getWindowWidth() * index;
|
|
});
|
|
}
|
|
}, {
|
|
key: 'addNewItem',
|
|
value: function addNewItem(element) {
|
|
var _this4 = this;
|
|
|
|
var groupId = element.getAttribute('data-group') || 'nogroup';
|
|
var group = this.data.group;
|
|
if (groupId === 'nogroup') {
|
|
element.setAttribute('data-group', 'nogroup');
|
|
}
|
|
if (!group[groupId]) {
|
|
group[groupId] = [];
|
|
}
|
|
var index = group[groupId].length;
|
|
var item = {
|
|
src: element.getAttribute('href'),
|
|
caption: element.getAttribute('data-caption'),
|
|
groupId: groupId,
|
|
translateX: this._getWindowWidth() * index,
|
|
index: index,
|
|
translateY: 0,
|
|
width: 50,
|
|
height: 50,
|
|
id: element.getAttribute('data-id') || index,
|
|
loaded: false,
|
|
processed: false,
|
|
element: element
|
|
};
|
|
group[groupId].push(item);
|
|
this.data.currentGroup = groupId;
|
|
var id = element.getAttribute('data-id');
|
|
if (!id) {
|
|
element.setAttribute('data-id', index);
|
|
}
|
|
element.setAttribute('data-index', index);
|
|
element.addEventListener('click', function (event) {
|
|
event.preventDefault();
|
|
_this4.data.currentGroup = element.getAttribute('data-group');
|
|
_this4.data.currentIndex = parseInt(element.getAttribute('data-index'), 10);
|
|
_this4._setHashByCurrentIndex();
|
|
var currentItem = _this4._getSelectedItem();
|
|
if (currentItem.loaded) {
|
|
_this4._initPhoto();
|
|
_this4.addAppearEffect(element, currentItem);
|
|
_this4.clicked = true;
|
|
_this4.update();
|
|
_this4._fireEvent('open');
|
|
} else {
|
|
_this4._loadItem(currentItem).then(function () {
|
|
_this4._initPhoto();
|
|
_this4.addAppearEffect(element, currentItem);
|
|
_this4.clicked = true;
|
|
_this4.update();
|
|
_this4._fireEvent('open');
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: '_initPhoto',
|
|
value: function _initPhoto() {
|
|
this.data.total = this.groupItems().length;
|
|
this.data.hide = false;
|
|
this.data.photoPosX = 0;
|
|
this.data.photoPosY = 0;
|
|
this._setPosByCurrentIndex();
|
|
this._setSizeByScreen();
|
|
this.setArrow();
|
|
if (this.data.resizeStyle === 'fill' && this.data.isSmartPhone) {
|
|
this.data.scale = true;
|
|
this.data.hideUi = true;
|
|
this.data.scaleSize = this._getScaleBoarder();
|
|
}
|
|
}
|
|
}, {
|
|
key: 'onUpdated',
|
|
value: function onUpdated() {
|
|
var _this5 = this;
|
|
|
|
if (this.data.appearEffect && this.data.appearEffect.once) {
|
|
this.data.appearEffect.once = false;
|
|
this.execEffect().then(function () {
|
|
_this5.data.appearEffect = null;
|
|
_this5.data.appear = true;
|
|
_this5.update();
|
|
});
|
|
}
|
|
if (this.clicked) {
|
|
this.clicked = false;
|
|
var classNames = this.data.classNames;
|
|
var caption = this._getElementByClass(classNames.smartPhotoCaption);
|
|
caption.focus();
|
|
}
|
|
}
|
|
}, {
|
|
key: 'execEffect',
|
|
value: function execEffect() {
|
|
var _this6 = this;
|
|
|
|
return new Promise(function (resolve) {
|
|
var appearEffect = _this6.data.appearEffect;
|
|
var classNames = _this6.data.classNames;
|
|
var effect = _this6._getElementByClass(classNames.smartPhotoImgClone);
|
|
var handler = function handler() {
|
|
effect.removeEventListener('transitionend', handler, true);
|
|
resolve();
|
|
};
|
|
effect.addEventListener('transitionend', handler, true);
|
|
setTimeout(function () {
|
|
effect.style.transform = 'translate(' + appearEffect.afterX + 'px, ' + appearEffect.afterY + 'px) scale(' + appearEffect.scale + ')';
|
|
}, 10);
|
|
});
|
|
}
|
|
}, {
|
|
key: 'addAppearEffect',
|
|
value: function addAppearEffect(element, item) {
|
|
var img = element.querySelector('img');
|
|
var pos = util.getViewPos(img);
|
|
var appear = {};
|
|
var scale = 1;
|
|
appear.width = img.offsetWidth;
|
|
appear.height = img.offsetHeight;
|
|
appear.top = pos.top;
|
|
appear.left = pos.left;
|
|
appear.once = true;
|
|
appear.img = img.getAttribute('src');
|
|
var toX = this._getWindowWidth();
|
|
var toY = this._getWindowHeight();
|
|
var screenY = toY - this.data.headerHeight - this.data.footerHeight;
|
|
|
|
if (this.data.resizeStyle === 'fill' && this.data.isSmartPhone) {
|
|
if (img.offsetWidth > img.offsetHeight) {
|
|
scale = toY / img.offsetHeight;
|
|
} else {
|
|
scale = toX / img.offsetWidth;
|
|
}
|
|
} else {
|
|
if (appear.width > appear.height) {
|
|
if (item.height < screenY) {
|
|
scale = item.width / appear.width;
|
|
} else {
|
|
scale = screenY / appear.height;
|
|
}
|
|
} else if (appear.height > appear.width) {
|
|
if (item.height < screenY) {
|
|
scale = item.height / appear.height;
|
|
} else {
|
|
scale = screenY / appear.height;
|
|
}
|
|
}
|
|
if (appear.width * scale > toX) {
|
|
scale = toX / appear.width;
|
|
}
|
|
}
|
|
|
|
var x = (scale - 1) / 2 * img.offsetWidth + (toX - img.offsetWidth * scale) / 2;
|
|
var y = (scale - 1) / 2 * img.offsetHeight + (toY - img.offsetHeight * scale) / 2;
|
|
appear.afterX = x;
|
|
appear.afterY = y;
|
|
appear.scale = scale;
|
|
this.data.appearEffect = appear;
|
|
}
|
|
}, {
|
|
key: 'hidePhoto',
|
|
value: function hidePhoto() {
|
|
var _this7 = this;
|
|
|
|
this.data.hide = true;
|
|
this.data.appear = false;
|
|
this.data.appearEffect = null;
|
|
this.data.hideUi = false;
|
|
this.data.scale = false;
|
|
this.data.scaleSize = 1;
|
|
var scrollX = window.scrollX;
|
|
var scrollY = window.scrollY;
|
|
if (location.hash) {
|
|
this._setHash('');
|
|
}
|
|
window.scroll(scrollX, scrollY);
|
|
this._doHideEffect().then(function () {
|
|
_this7.update();
|
|
_this7._fireEvent('close');
|
|
});
|
|
}
|
|
}, {
|
|
key: '_doHideEffect',
|
|
value: function _doHideEffect() {
|
|
var _this8 = this;
|
|
|
|
return new Promise(function (resolve) {
|
|
var classNames = _this8.data.classNames;
|
|
var photo = _this8._getElementByClass(classNames.smartPhoto);
|
|
var img = _this8._getElementByQuery('.current .' + classNames.smartPhotoImg);
|
|
var height = _this8._getWindowHeight();
|
|
var handler = function handler() {
|
|
photo.removeEventListener('transitionend', handler, true);
|
|
resolve();
|
|
};
|
|
photo.style.opacity = 0;
|
|
img.style.transform = 'translateY(' + height + 'px)';
|
|
photo.addEventListener('transitionend', handler, true);
|
|
});
|
|
}
|
|
}, {
|
|
key: '_getElementByClass',
|
|
value: function _getElementByClass(className) {
|
|
return document.querySelector('[data-id="' + this.id + '"] .' + className);
|
|
}
|
|
}, {
|
|
key: '_getElementByQuery',
|
|
value: function _getElementByQuery(query) {
|
|
return document.querySelector('[data-id="' + this.id + '"] ' + query);
|
|
}
|
|
}, {
|
|
key: '_getTouchPos',
|
|
value: function _getTouchPos() {
|
|
var x = 0;
|
|
var y = 0;
|
|
var e = typeof event === 'undefined' ? this.e : event;
|
|
if (this._isTouched(e)) {
|
|
x = e.touches[0].pageX;
|
|
y = e.touches[0].pageY;
|
|
} else if (e.pageX) {
|
|
x = e.pageX;
|
|
y = e.pageY;
|
|
}
|
|
return { x: x, y: y };
|
|
}
|
|
}, {
|
|
key: '_getGesturePos',
|
|
value: function _getGesturePos(e) {
|
|
var touches = e.touches;
|
|
return [{ x: touches[0].pageX, y: touches[0].pageY }, { x: touches[1].pageX, y: touches[1].pageY }];
|
|
}
|
|
}, {
|
|
key: '_setPosByCurrentIndex',
|
|
value: function _setPosByCurrentIndex() {
|
|
var _this9 = this;
|
|
|
|
var items = this.groupItems();
|
|
var moveX = -1 * items[this.data.currentIndex].translateX;
|
|
this.pos.x = moveX;
|
|
setTimeout(function () {
|
|
_this9.data.translateX = moveX;
|
|
_this9.data.translateY = 0;
|
|
_this9._listUpdate();
|
|
}, 1);
|
|
}
|
|
}, {
|
|
key: '_setHashByCurrentIndex',
|
|
value: function _setHashByCurrentIndex() {
|
|
var scrollX = window.scrollX;
|
|
var scrollY = window.scrollY;
|
|
var items = this.groupItems();
|
|
var id = items[this.data.currentIndex].id;
|
|
var group = this.data.currentGroup;
|
|
var hash = 'group=' + group + '&photo=' + id;
|
|
this._setHash(hash);
|
|
window.scroll(scrollX, scrollY);
|
|
}
|
|
}, {
|
|
key: '_setHash',
|
|
value: function _setHash(hash) {
|
|
if (!(window.history && window.history.pushState) || !this.data.useHistoryApi) {
|
|
return;
|
|
}
|
|
if (hash) {
|
|
window.history.replaceState(null, null, '' + location.pathname + location.search + '#' + hash);
|
|
} else {
|
|
window.history.replaceState(null, null, '' + location.pathname + location.search);
|
|
}
|
|
}
|
|
}, {
|
|
key: '_getCurrentItemByHash',
|
|
value: function _getCurrentItemByHash() {
|
|
var group = this.data.group;
|
|
var hash = location.hash.substr(1);
|
|
var hashObj = util.parseQuery(hash);
|
|
var currentItem = null;
|
|
var getCurrentItem = function getCurrentItem(item) {
|
|
if (hashObj.group === item.groupId && hashObj.photo === item.id) {
|
|
currentItem = item;
|
|
}
|
|
};
|
|
Object.keys(group).forEach(function (key) {
|
|
group[key].forEach(getCurrentItem);
|
|
});
|
|
return currentItem;
|
|
}
|
|
}, {
|
|
key: '_loadItem',
|
|
value: function _loadItem(item) {
|
|
return new Promise(function (resolve) {
|
|
var img = new Image();
|
|
img.onload = function () {
|
|
item.width = img.width;
|
|
item.height = img.height;
|
|
item.loaded = true;
|
|
resolve();
|
|
};
|
|
img.onerror = function () {
|
|
resolve();
|
|
};
|
|
img.src = item.src;
|
|
});
|
|
}
|
|
}, {
|
|
key: '_setSizeByScreen',
|
|
value: function _setSizeByScreen() {
|
|
var windowX = this._getWindowWidth();
|
|
var windowY = this._getWindowHeight();
|
|
var headerHeight = this.data.headerHeight;
|
|
var footerHeight = this.data.footerHeight;
|
|
var screenY = windowY - (headerHeight + footerHeight);
|
|
var items = this.groupItems();
|
|
items.forEach(function (item) {
|
|
if (!item.loaded) {
|
|
return;
|
|
}
|
|
item.processed = true;
|
|
item.scale = screenY / item.height;
|
|
if (item.height < screenY) {
|
|
item.scale = 1;
|
|
}
|
|
item.x = (item.scale - 1) / 2 * item.width + (windowX - item.width * item.scale) / 2;
|
|
item.y = (item.scale - 1) / 2 * item.height + (windowY - item.height * item.scale) / 2;
|
|
if (item.width * item.scale > windowX) {
|
|
item.scale = windowX / item.width;
|
|
item.x = (item.scale - 1) / 2 * item.width;
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: '_slideList',
|
|
value: function _slideList() {
|
|
var _this10 = this;
|
|
|
|
this.data.scaleSize = 1;
|
|
this.isBeingZoomed = false;
|
|
this.data.hideUi = false;
|
|
this.data.scale = false;
|
|
this.data.photoPosX = 0;
|
|
this.data.photoPosY = 0;
|
|
this.data.onMoveClass = true;
|
|
this._setPosByCurrentIndex();
|
|
this._setHashByCurrentIndex();
|
|
this._setSizeByScreen();
|
|
setTimeout(function () {
|
|
_this10.data.onMoveClass = false;
|
|
_this10.setArrow();
|
|
_this10.update();
|
|
if (_this10.data.oldIndex !== _this10.data.currentIndex) {
|
|
_this10._fireEvent('change');
|
|
}
|
|
_this10.data.oldIndex = _this10.data.currentIndex;
|
|
}, 200);
|
|
}
|
|
}, {
|
|
key: 'gotoSlide',
|
|
value: function gotoSlide(index) {
|
|
if (this.e && this.e.preventDefault) {
|
|
this.e.preventDefault();
|
|
}
|
|
this.data.currentIndex = parseInt(index, 10);
|
|
if (!this.data.currentIndex) {
|
|
this.data.currentIndex = 0;
|
|
}
|
|
this._slideList();
|
|
}
|
|
}, {
|
|
key: 'setArrow',
|
|
value: function setArrow() {
|
|
var items = this.groupItems();
|
|
var length = items.length;
|
|
var next = this.data.currentIndex + 1;
|
|
var prev = this.data.currentIndex - 1;
|
|
this.data.showNextArrow = false;
|
|
this.data.showPrevArrow = false;
|
|
if (next !== length) {
|
|
this.data.next = next;
|
|
this.data.showNextArrow = true;
|
|
}
|
|
if (prev !== -1) {
|
|
this.data.prev = prev;
|
|
this.data.showPrevArrow = true;
|
|
}
|
|
}
|
|
}, {
|
|
key: 'beforeDrag',
|
|
value: function beforeDrag() {
|
|
if (this._isGestured(this.e)) {
|
|
this.beforeGesture();
|
|
return;
|
|
}
|
|
this.isBeingZoomed = false;
|
|
if (this.data.scale) {
|
|
this.beforePhotoDrag();
|
|
return;
|
|
}
|
|
var pos = this._getTouchPos();
|
|
this.isSwipable = true;
|
|
this.dragStart = true;
|
|
this.firstPos = pos;
|
|
this.oldPos = pos;
|
|
}
|
|
}, {
|
|
key: 'afterDrag',
|
|
value: function afterDrag() {
|
|
var items = this.groupItems();
|
|
var date = new Date();
|
|
var tapSecond = date.getTime();
|
|
var offset = this.tapSecond - tapSecond;
|
|
var swipeWidth = 0;
|
|
var swipeHeight = 0;
|
|
this.isSwipable = false;
|
|
this.onListMove = false;
|
|
|
|
if (this.oldPos) {
|
|
swipeWidth = this.oldPos.x - this.firstPos.x;
|
|
swipeHeight = this.oldPos.y - this.firstPos.y;
|
|
}
|
|
if (this.isBeingZoomed) {
|
|
this.afterGesture();
|
|
return;
|
|
}
|
|
if (this.data.scale) {
|
|
this.afterPhotoDrag();
|
|
return;
|
|
} else if (!util.isSmartPhone() && swipeWidth === 0 && swipeHeight === 0) {
|
|
this.zoomPhoto();
|
|
return;
|
|
}
|
|
if (Math.abs(offset) <= 500 && swipeWidth === 0 && swipeHeight === 0) {
|
|
this.e.preventDefault();
|
|
this.zoomPhoto();
|
|
return;
|
|
}
|
|
this.tapSecond = tapSecond;
|
|
this._fireEvent('swipeend');
|
|
if (this.moveDir === 'horizontal') {
|
|
if (swipeWidth >= this.data.swipeOffset && this.data.currentIndex !== 0) {
|
|
this.data.currentIndex -= 1;
|
|
} else if (swipeWidth <= -this.data.swipeOffset && this.data.currentIndex !== items.length - 1) {
|
|
this.data.currentIndex += 1;
|
|
}
|
|
this._slideList();
|
|
}
|
|
if (this.moveDir === 'vertical') {
|
|
if (swipeHeight >= this.data.swipeOffset) {
|
|
this.hidePhoto();
|
|
} else {
|
|
this.data.translateY = 0;
|
|
this._slideList();
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: 'onDrag',
|
|
value: function onDrag() {
|
|
this.e.preventDefault();
|
|
if (this._isGestured(this.e) && this.onListMove === false) {
|
|
this.onGesture();
|
|
return;
|
|
}
|
|
if (this.isBeingZoomed) {
|
|
return;
|
|
}
|
|
if (this.data.scale) {
|
|
this.onPhotoDrag();
|
|
return;
|
|
}
|
|
if (!this.isSwipable) {
|
|
return;
|
|
}
|
|
|
|
var pos = this._getTouchPos();
|
|
var x = pos.x - this.oldPos.x;
|
|
var y = pos.y - this.firstPos.y;
|
|
|
|
if (this.dragStart) {
|
|
this._fireEvent('swipestart');
|
|
this.dragStart = false;
|
|
if (Math.abs(x) > Math.abs(y)) {
|
|
this.moveDir = 'horizontal';
|
|
} else {
|
|
this.moveDir = 'vertical';
|
|
}
|
|
}
|
|
|
|
if (this.moveDir === 'horizontal') {
|
|
this.pos.x += x;
|
|
this.data.translateX = this.pos.x;
|
|
} else {
|
|
this.data.translateY = y;
|
|
}
|
|
this.onListMove = true;
|
|
this.oldPos = pos;
|
|
this._listUpdate();
|
|
}
|
|
}, {
|
|
key: 'zoomPhoto',
|
|
value: function zoomPhoto() {
|
|
var _this11 = this;
|
|
|
|
this.data.hideUi = true;
|
|
this.data.scaleSize = this._getScaleBoarder();
|
|
if (this.data.scaleSize <= 1) {
|
|
return;
|
|
}
|
|
this.data.photoPosX = 0;
|
|
this.data.photoPosY = 0;
|
|
this._photoUpdate();
|
|
setTimeout(function () {
|
|
_this11.data.scale = true;
|
|
_this11._photoUpdate();
|
|
_this11._fireEvent('zoomin');
|
|
}, 300);
|
|
}
|
|
}, {
|
|
key: 'zoomOutPhoto',
|
|
value: function zoomOutPhoto() {
|
|
this.data.scaleSize = 1;h
|
|
this.isBeingZoomed = false;
|
|
this.data.hideUi = false;
|
|
this.data.scale = false;
|
|
this.data.photoPosX = 0;
|
|
this.data.photoPosY = 0;
|
|
this._photoUpdate();
|
|
this._fireEvent('zoomout');
|
|
}
|
|
}, {
|
|
key: 'beforePhotoDrag',
|
|
value: function beforePhotoDrag() {
|
|
var pos = this._getTouchPos();
|
|
this.photoSwipable = true;
|
|
if (!this.data.photoPosX) {
|
|
this.data.photoPosX = 0;
|
|
}
|
|
if (!this.data.photoPosY) {
|
|
this.data.photoPosY = 0;
|
|
}
|
|
this.oldPhotoPos = pos;
|
|
this.firstPhotoPos = pos;
|
|
}
|
|
}, {
|
|
key: 'onPhotoDrag',
|
|
value: function onPhotoDrag() {
|
|
if (!this.photoSwipable) {
|
|
return;
|
|
}
|
|
this.e.preventDefault();
|
|
var pos = this._getTouchPos();
|
|
var x = pos.x - this.oldPhotoPos.x;
|
|
var y = pos.y - this.oldPhotoPos.y;
|
|
var moveX = this._round(this.data.scaleSize * x, 6);
|
|
var moveY = this._round(this.data.scaleSize * y, 6);
|
|
if (typeof moveX === 'number') {
|
|
this.data.photoPosX += moveX;
|
|
this.photoVX = moveX;
|
|
}
|
|
if (typeof moveY === 'number') {
|
|
this.data.photoPosY += moveY;
|
|
this.photoVY = moveY;
|
|
}
|
|
this.oldPhotoPos = pos;
|
|
this._photoUpdate();
|
|
}
|
|
}, {
|
|
key: 'afterPhotoDrag',
|
|
value: function afterPhotoDrag() {
|
|
if (this.oldPhotoPos.x === this.firstPhotoPos.x && this.photoSwipable) {
|
|
this.photoSwipable = false;
|
|
this.zoomOutPhoto();
|
|
} else {
|
|
this.photoSwipable = false;
|
|
var item = this._getSelectedItem();
|
|
var bound = this._makeBound(item);
|
|
var offset = this.data.swipeOffset * this.data.scaleSize;
|
|
var flagX = 0;
|
|
var flagY = 0;
|
|
if (this.data.photoPosX > bound.maxX) {
|
|
flagX = -1;
|
|
} else if (this.data.photoPosX < bound.minX) {
|
|
flagX = 1;
|
|
}
|
|
if (this.data.photoPosY > bound.maxY) {
|
|
flagY = -1;
|
|
} else if (this.data.photoPosY < bound.minY) {
|
|
flagY = 1;
|
|
}
|
|
|
|
if (this.data.photoPosX - bound.maxX > offset && this.data.currentIndex !== 0) {
|
|
this.gotoSlide(this.data.prev);
|
|
return;
|
|
}
|
|
|
|
if (bound.minX - this.data.photoPosX > offset && this.data.currentIndex + 1 !== this.data.total) {
|
|
this.gotoSlide(this.data.next);
|
|
return;
|
|
}
|
|
|
|
// todo
|
|
// if(this.data.photoPosY - bound.maxY > offset) {
|
|
// this.hidePhoto();
|
|
// return;
|
|
// }
|
|
|
|
if (flagX === 0 && flagY === 0) {
|
|
this.vx = this.photoVX / 5;
|
|
this.vy = this.photoVY / 5;
|
|
} else {
|
|
this._registerElasticForce(flagX, flagY);
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: 'beforeGesture',
|
|
value: function beforeGesture() {
|
|
this._fireEvent('gesturestart');
|
|
var pos = this._getGesturePos(this.e);
|
|
var distance = this._getDistance(pos[0], pos[1]);
|
|
this.isBeingZoomed = true;
|
|
this.oldDistance = distance;
|
|
this.data.scale = true;
|
|
this.e.preventDefault();
|
|
}
|
|
}, {
|
|
key: 'onGesture',
|
|
value: function onGesture() {
|
|
var pos = this._getGesturePos(this.e);
|
|
var distance = this._getDistance(pos[0], pos[1]);
|
|
var size = (distance - this.oldDistance) / 100;
|
|
var oldScaleSize = this.data.scaleSize;
|
|
var posX = this.data.photoPosX;
|
|
var posY = this.data.photoPosY;
|
|
this.isBeingZoomed = true;
|
|
this.data.scaleSize += this._round(size, 6);
|
|
if (this.data.scaleSize < 0.2) {
|
|
this.data.scaleSize = 0.2;
|
|
}
|
|
// todo
|
|
if (this.data.scaleSize < oldScaleSize) {
|
|
this.data.photoPosX = (1 + this.data.scaleSize - oldScaleSize) * posX;
|
|
this.data.photoPosY = (1 + this.data.scaleSize - oldScaleSize) * posY;
|
|
}
|
|
|
|
if (this.data.scaleSize < 1 || this.data.scaleSize > this._getScaleBoarder()) {
|
|
this.data.hideUi = true;
|
|
} else {
|
|
this.data.hideUi = false;
|
|
}
|
|
this.oldDistance = distance;
|
|
this.e.preventDefault();
|
|
this._photoUpdate();
|
|
}
|
|
}, {
|
|
key: 'afterGesture',
|
|
value: function afterGesture() {
|
|
if (this.data.scaleSize > this._getScaleBoarder()) {
|
|
return;
|
|
}
|
|
this.data.photoPosX = 0;
|
|
this.data.photoPosY = 0;
|
|
this.data.scale = false;
|
|
this.data.scaleSize = 1;
|
|
this.data.hideUi = false;
|
|
this._fireEvent('gestureend');
|
|
this._photoUpdate();
|
|
}
|
|
}, {
|
|
key: '_getForceAndTheta',
|
|
value: function _getForceAndTheta(vx, vy) {
|
|
return {
|
|
force: Math.sqrt(vx * vx + vy * vy),
|
|
theta: Math.atan2(vy, vx)
|
|
};
|
|
}
|
|
}, {
|
|
key: '_getScaleBoarder',
|
|
value: function _getScaleBoarder() {
|
|
var item = this._getSelectedItem();
|
|
var windowWidth = this._getWindowWidth();
|
|
var windowHeight = this._getWindowHeight();
|
|
if (!util.isSmartPhone()) {
|
|
return 1 / item.scale;
|
|
}
|
|
if (item.width > item.height) {
|
|
return windowHeight / (item.height * item.scale);
|
|
}
|
|
return windowWidth / (item.width * item.scale);
|
|
}
|
|
}, {
|
|
key: '_makeBound',
|
|
value: function _makeBound(item) {
|
|
var width = item.width * item.scale * this.data.scaleSize;
|
|
var height = item.height * item.scale * this.data.scaleSize;
|
|
var minX = void 0;
|
|
var minY = void 0;
|
|
var maxX = void 0;
|
|
var maxY = void 0;
|
|
var windowWidth = this._getWindowWidth();
|
|
var windowHeight = this._getWindowHeight();
|
|
if (windowWidth > width) {
|
|
maxX = (windowWidth - width) / 2;
|
|
minX = -1 * maxX;
|
|
} else {
|
|
maxX = (width - windowWidth) / 2;
|
|
minX = -1 * maxX;
|
|
}
|
|
if (windowHeight > height) {
|
|
maxY = (windowHeight - height) / 2;
|
|
minY = -1 * maxY;
|
|
} else {
|
|
maxY = (height - windowHeight) / 2;
|
|
minY = -1 * maxY;
|
|
}
|
|
return {
|
|
minX: this._round(minX, 6) * this.data.scaleSize,
|
|
minY: this._round(minY, 6) * this.data.scaleSize,
|
|
maxX: this._round(maxX, 6) * this.data.scaleSize,
|
|
maxY: this._round(maxY, 6) * this.data.scaleSize
|
|
};
|
|
}
|
|
}, {
|
|
key: '_registerElasticForce',
|
|
value: function _registerElasticForce(x, y) {
|
|
var _this12 = this;
|
|
|
|
var item = this._getSelectedItem();
|
|
var bound = this._makeBound(item);
|
|
this.data.elastic = true;
|
|
if (x === 1) {
|
|
this.data.photoPosX = bound.minX;
|
|
} else if (x === -1) {
|
|
this.data.photoPosX = bound.maxX;
|
|
}
|
|
if (y === 1) {
|
|
this.data.photoPosY = bound.minY;
|
|
} else if (y === -1) {
|
|
this.data.photoPosY = bound.maxY;
|
|
}
|
|
this._photoUpdate();
|
|
setTimeout(function () {
|
|
_this12.data.elastic = false;
|
|
_this12._photoUpdate();
|
|
}, 300);
|
|
}
|
|
}, {
|
|
key: '_getSelectedItem',
|
|
value: function _getSelectedItem() {
|
|
var data = this.data;
|
|
var index = data.currentIndex;
|
|
return data.group[data.currentGroup][index];
|
|
}
|
|
}, {
|
|
key: '_getUniqId',
|
|
value: function _getUniqId() {
|
|
return (Date.now().toString(36) + Math.random().toString(36).substr(2, 5)).toUpperCase();
|
|
}
|
|
}, {
|
|
key: '_getDistance',
|
|
value: function _getDistance(point1, point2) {
|
|
var x = point1.x - point2.x;
|
|
var y = point1.y - point2.y;
|
|
return Math.sqrt(x * x + y * y);
|
|
}
|
|
}, {
|
|
key: '_round',
|
|
value: function _round(val, precision) {
|
|
var digit = Math.pow(10, precision);
|
|
val *= digit;
|
|
val = Math.round(val);
|
|
val /= digit;
|
|
return val;
|
|
}
|
|
}, {
|
|
key: '_isTouched',
|
|
value: function _isTouched(e) {
|
|
if (e && e.touches) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, {
|
|
key: '_isGestured',
|
|
value: function _isGestured(e) {
|
|
if (e && e.touches && e.touches.length > 1) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, {
|
|
key: '_isSmartPhone',
|
|
value: function _isSmartPhone() {
|
|
var agent = navigator.userAgent;
|
|
if (agent.indexOf('iPhone') > 0 || agent.indexOf('iPad') > 0 || agent.indexOf('ipod') > 0 || agent.indexOf('Android') > 0) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, {
|
|
key: '_calcGravity',
|
|
value: function _calcGravity(gamma, beta) {
|
|
if (gamma > 5 || gamma < -5) {
|
|
this.vx += gamma * 0.05;
|
|
}
|
|
if (this.data.verticalGravity === false) {
|
|
return;
|
|
}
|
|
if (beta > 5 || beta < -5) {
|
|
this.vy += beta * 0.05;
|
|
}
|
|
}
|
|
}, {
|
|
key: '_photoUpdate',
|
|
value: function _photoUpdate() {
|
|
var classNames = this.data.classNames;
|
|
var current = this._getElementByQuery('.current');
|
|
var img = current.querySelector('.' + classNames.smartPhotoImg);
|
|
var nav = this._getElementByQuery('.' + classNames.smartPhotoNav);
|
|
var arrows = this._getElementByQuery('.' + classNames.smartPhotoArrows);
|
|
var photoPosX = this.virtualPos(this.data.photoPosX);
|
|
var photoPosY = this.virtualPos(this.data.photoPosY);
|
|
var scaleSize = this.data.scaleSize;
|
|
var transform = 'translate(' + photoPosX + 'px,' + photoPosY + 'px) scale(' + scaleSize + ')';
|
|
|
|
img.style.transform = transform;
|
|
if (this.data.scale) {
|
|
util.addClass(img, classNames.smartPhotoImgOnMove);
|
|
} else {
|
|
util.removeClass(img, classNames.smartPhotoImgOnMove);
|
|
}
|
|
if (this.data.elastic) {
|
|
util.addClass(img, classNames.smartPhotoImgElasticMove);
|
|
} else {
|
|
util.removeClass(img, classNames.smartPhotoImgElasticMove);
|
|
}
|
|
if (this.data.hideUi) {
|
|
if (nav) {
|
|
nav.setAttribute('aria-hidden', 'true');
|
|
}
|
|
if (arrows) {
|
|
arrows.setAttribute('aria-hidden', 'true');
|
|
}
|
|
} else {
|
|
if (nav) {
|
|
nav.setAttribute('aria-hidden', 'false');
|
|
}
|
|
if (arrows) {
|
|
arrows.setAttribute('aria-hidden', 'false');
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
key: '_getWindowWidth',
|
|
value: function _getWindowWidth() {
|
|
return document.documentElement.clientWidth;
|
|
}
|
|
}, {
|
|
key: '_getWindowHeight',
|
|
value: function _getWindowHeight() {
|
|
return window.innerHeight;
|
|
}
|
|
}, {
|
|
key: '_listUpdate',
|
|
value: function _listUpdate() {
|
|
var classNames = this.data.classNames;
|
|
var list = this._getElementByQuery('.' + classNames.smartPhotoList);
|
|
var transform = 'translate(' + this.data.translateX + 'px,' + this.data.translateY + 'px)';
|
|
list.style.transform = transform;
|
|
// $list
|
|
if (this.data.onMoveClass) {
|
|
util.addClass(list, classNames.smartPhotoListOnMove);
|
|
} else {
|
|
util.removeClass(list, classNames.smartPhotoListOnMove);
|
|
}
|
|
}
|
|
}, {
|
|
key: '_fireEvent',
|
|
value: function _fireEvent(eventName) {
|
|
var photo = this._getElementByClass(this.data.classNames.smartPhoto);
|
|
util.triggerEvent(photo, eventName);
|
|
}
|
|
}, {
|
|
key: '_doAnim',
|
|
value: function _doAnim() {
|
|
if (this.isBeingZoomed || this.isSwipable || this.photoSwipable || this.data.elastic || !this.data.scale) {
|
|
return;
|
|
}
|
|
this.data.photoPosX += this.vx;
|
|
this.data.photoPosY += this.vy;
|
|
var item = this._getSelectedItem();
|
|
var bound = this._makeBound(item);
|
|
if (this.data.photoPosX < bound.minX) {
|
|
this.data.photoPosX = bound.minX;
|
|
this.vx *= -0.2;
|
|
} else if (this.data.photoPosX > bound.maxX) {
|
|
this.data.photoPosX = bound.maxX;
|
|
this.vx *= -0.2;
|
|
}
|
|
if (this.data.photoPosY < bound.minY) {
|
|
this.data.photoPosY = bound.minY;
|
|
this.vy *= -0.2;
|
|
} else if (this.data.photoPosY > bound.maxY) {
|
|
this.data.photoPosY = bound.maxY;
|
|
this.vy *= -0.2;
|
|
}
|
|
var power = this._getForceAndTheta(this.vx, this.vy);
|
|
var force = power.force;
|
|
var theta = power.theta;
|
|
force -= this.data.registance;
|
|
if (Math.abs(force) < 0.5) {
|
|
return;
|
|
}
|
|
this.vx = Math.cos(theta) * force;
|
|
this.vy = Math.sin(theta) * force;
|
|
this._photoUpdate();
|
|
}
|
|
}]);
|
|
|
|
return SmartPhoto;
|
|
}(_aTemplate2.default);
|
|
|
|
exports.default = SmartPhoto;
|
|
module.exports = exports['default'];
|
|
|
|
},{"../lib/util":34,"a-template":1,"custom-event-polyfill":7,"es6-promise-polyfill":20}],33:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
module.exports = require('./core/');
|
|
|
|
},{"./core/":32}],34:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
|
|
|
|
module.exports.isSmartPhone = function () {
|
|
var agent = navigator.userAgent;
|
|
if (agent.indexOf('iPhone') > 0 || agent.indexOf('iPad') > 0 || agent.indexOf('ipod') > 0 || agent.indexOf('Android') > 0) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
function deepExtend(out) {
|
|
out = out || {};
|
|
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var obj = arguments[i];
|
|
if (!obj) {
|
|
continue;
|
|
}
|
|
|
|
for (var key in obj) {
|
|
if (obj.hasOwnProperty(key)) {
|
|
if (_typeof(obj[key]) === 'object') out[key] = deepExtend(out[key], obj[key]);else out[key] = obj[key];
|
|
}
|
|
}
|
|
}
|
|
|
|
return out;
|
|
};
|
|
|
|
module.exports.extend = deepExtend;
|
|
|
|
module.exports.triggerEvent = function (el, eventName, options) {
|
|
var event = void 0;
|
|
if (window.CustomEvent) {
|
|
event = new CustomEvent(eventName, { cancelable: true });
|
|
} else {
|
|
event = document.createEvent('CustomEvent');
|
|
event.initCustomEvent(eventName, false, false, options);
|
|
}
|
|
el.dispatchEvent(event);
|
|
};
|
|
|
|
module.exports.parseQuery = function (query) {
|
|
var s = query.split('&'),
|
|
data = {},
|
|
i = 0,
|
|
iz = s.length,
|
|
param,
|
|
key,
|
|
value;
|
|
for (; i < iz; i++) {
|
|
param = s[i].split('=');
|
|
if (param[0] !== void 0) {
|
|
key = param[0];
|
|
value = param[1] !== void 0 ? param.slice(1).join('=') : key;
|
|
data[key] = decodeURIComponent(value);
|
|
}
|
|
}
|
|
return data;
|
|
};
|
|
|
|
module.exports.getViewPos = function (element) {
|
|
return {
|
|
left: element.getBoundingClientRect().left,
|
|
top: element.getBoundingClientRect().top
|
|
};
|
|
};
|
|
|
|
module.exports.removeElement = function (element) {
|
|
if (element && element.parentNode) {
|
|
element.parentNode.removeChild(element);
|
|
}
|
|
};
|
|
|
|
module.exports.append = function (element, string) {
|
|
var parser = new DOMParser();
|
|
var doc = parser.parseFromString(string, 'text/html');
|
|
element.appendChild(doc.querySelector('body').childNodes[0]);
|
|
};
|
|
|
|
module.exports.addClass = function (element, className) {
|
|
if (element.classList) {
|
|
element.classList.add(className);
|
|
} else {
|
|
element.className += ' ' + className;
|
|
}
|
|
};
|
|
|
|
module.exports.removeClass = function (element, className) {
|
|
if (element.classList) {
|
|
element.classList.remove(className);
|
|
} else {
|
|
element.className = element.className.replace(new RegExp('(^|\\b)' + className.split(' ').join('|') + '(\\b|$)', 'gi'), ' ');
|
|
}
|
|
};
|
|
|
|
},{}]},{},[33])(33)
|
|
|
|
/**
|
|
var ua = navigator.userAgent;
|
|
var match = ua.match(/Android\s([0-9\.]*)/);
|
|
if( ua.indexOf("Android") >= 0 )
|
|
{
|
|
var androidversion = parseFloat(match[1], 10);
|
|
if (androidversion < 4)
|
|
{
|
|
this.supportAnimations = false;
|
|
this.supportTransitions = false;
|
|
}
|
|
}
|
|
**/
|
|
var ua = navigator.userAgent;
|
|
if( ua.indexOf("Android") > -1 && ua.indexOf("Chrome") === -1 && ua.indexOf("Firefox") === -1) {
|
|
this.supportAnimations = false;
|
|
this.supportTransitions = false;
|
|
}
|
|
});
|
|
|