)<[^<]*)*<\/script>/gi,
1222 | scriptTypeRE = /^(?:text|application)\/javascript/i,
1223 | xmlTypeRE = /^(?:text|application)\/xml/i,
1224 | jsonType = 'application/json',
1225 | htmlType = 'text/html',
1226 | blankRE = /^\s*$/,
1227 | originAnchor = document.createElement('a')
1228 |
1229 | originAnchor.href = window.location.href
1230 |
1231 | // trigger a custom event and return false if it was cancelled
1232 | function triggerAndReturn(context, eventName, data) {
1233 | var event = $.Event(eventName)
1234 | $(context).trigger(event, data)
1235 | return !event.isDefaultPrevented()
1236 | }
1237 |
1238 | // trigger an Ajax "global" event
1239 | function triggerGlobal(settings, context, eventName, data) {
1240 | if (settings.global) return triggerAndReturn(context || document, eventName, data)
1241 | }
1242 |
1243 | // Number of active Ajax requests
1244 | $.active = 0
1245 |
1246 | function ajaxStart(settings) {
1247 | if (settings.global && $.active++ === 0) triggerGlobal(settings, null, 'ajaxStart')
1248 | }
1249 | function ajaxStop(settings) {
1250 | if (settings.global && !(--$.active)) triggerGlobal(settings, null, 'ajaxStop')
1251 | }
1252 |
1253 | // triggers an extra global event "ajaxBeforeSend" that's like "ajaxSend" but cancelable
1254 | function ajaxBeforeSend(xhr, settings) {
1255 | var context = settings.context
1256 | if (settings.beforeSend.call(context, xhr, settings) === false ||
1257 | triggerGlobal(settings, context, 'ajaxBeforeSend', [xhr, settings]) === false)
1258 | return false
1259 |
1260 | triggerGlobal(settings, context, 'ajaxSend', [xhr, settings])
1261 | }
1262 | function ajaxSuccess(data, xhr, settings, deferred) {
1263 | var context = settings.context, status = 'success'
1264 | settings.success.call(context, data, status, xhr)
1265 | if (deferred) deferred.resolveWith(context, [data, status, xhr])
1266 | triggerGlobal(settings, context, 'ajaxSuccess', [xhr, settings, data])
1267 | ajaxComplete(status, xhr, settings)
1268 | }
1269 | // type: "timeout", "error", "abort", "parsererror"
1270 | function ajaxError(error, type, xhr, settings, deferred) {
1271 | var context = settings.context
1272 | settings.error.call(context, xhr, type, error)
1273 | if (deferred) deferred.rejectWith(context, [xhr, type, error])
1274 | triggerGlobal(settings, context, 'ajaxError', [xhr, settings, error || type])
1275 | ajaxComplete(type, xhr, settings)
1276 | }
1277 | // status: "success", "notmodified", "error", "timeout", "abort", "parsererror"
1278 | function ajaxComplete(status, xhr, settings) {
1279 | var context = settings.context
1280 | settings.complete.call(context, xhr, status)
1281 | triggerGlobal(settings, context, 'ajaxComplete', [xhr, settings])
1282 | ajaxStop(settings)
1283 | }
1284 |
1285 | function ajaxDataFilter(data, type, settings) {
1286 | if (settings.dataFilter == empty) return data
1287 | var context = settings.context
1288 | return settings.dataFilter.call(context, data, type)
1289 | }
1290 |
1291 | // Empty function, used as default callback
1292 | function empty() {}
1293 |
1294 | $.ajaxJSONP = function(options, deferred){
1295 | if (!('type' in options)) return $.ajax(options)
1296 |
1297 | var _callbackName = options.jsonpCallback,
1298 | callbackName = ($.isFunction(_callbackName) ?
1299 | _callbackName() : _callbackName) || ('Zepto' + (jsonpID++)),
1300 | script = document.createElement('script'),
1301 | originalCallback = window[callbackName],
1302 | responseData,
1303 | abort = function(errorType) {
1304 | $(script).triggerHandler('error', errorType || 'abort')
1305 | },
1306 | xhr = { abort: abort }, abortTimeout
1307 |
1308 | if (deferred) deferred.promise(xhr)
1309 |
1310 | $(script).on('load error', function(e, errorType){
1311 | clearTimeout(abortTimeout)
1312 | $(script).off().remove()
1313 |
1314 | if (e.type == 'error' || !responseData) {
1315 | ajaxError(null, errorType || 'error', xhr, options, deferred)
1316 | } else {
1317 | ajaxSuccess(responseData[0], xhr, options, deferred)
1318 | }
1319 |
1320 | window[callbackName] = originalCallback
1321 | if (responseData && $.isFunction(originalCallback))
1322 | originalCallback(responseData[0])
1323 |
1324 | originalCallback = responseData = undefined
1325 | })
1326 |
1327 | if (ajaxBeforeSend(xhr, options) === false) {
1328 | abort('abort')
1329 | return xhr
1330 | }
1331 |
1332 | window[callbackName] = function(){
1333 | responseData = arguments
1334 | }
1335 |
1336 | script.src = options.url.replace(/\?(.+)=\?/, '?$1=' + callbackName)
1337 | document.head.appendChild(script)
1338 |
1339 | if (options.timeout > 0) abortTimeout = setTimeout(function(){
1340 | abort('timeout')
1341 | }, options.timeout)
1342 |
1343 | return xhr
1344 | }
1345 |
1346 | $.ajaxSettings = {
1347 | // Default type of request
1348 | type: 'GET',
1349 | // Callback that is executed before request
1350 | beforeSend: empty,
1351 | // Callback that is executed if the request succeeds
1352 | success: empty,
1353 | // Callback that is executed the the server drops error
1354 | error: empty,
1355 | // Callback that is executed on request complete (both: error and success)
1356 | complete: empty,
1357 | // The context for the callbacks
1358 | context: null,
1359 | // Whether to trigger "global" Ajax events
1360 | global: true,
1361 | // Transport
1362 | xhr: function () {
1363 | return new window.XMLHttpRequest()
1364 | },
1365 | // MIME types mapping
1366 | // IIS returns Javascript as "application/x-javascript"
1367 | accepts: {
1368 | script: 'text/javascript, application/javascript, application/x-javascript',
1369 | json: jsonType,
1370 | xml: 'application/xml, text/xml',
1371 | html: htmlType,
1372 | text: 'text/plain'
1373 | },
1374 | // Whether the request is to another domain
1375 | crossDomain: false,
1376 | // Default timeout
1377 | timeout: 0,
1378 | // Whether data should be serialized to string
1379 | processData: true,
1380 | // Whether the browser should be allowed to cache GET responses
1381 | cache: true,
1382 | //Used to handle the raw response data of XMLHttpRequest.
1383 | //This is a pre-filtering function to sanitize the response.
1384 | //The sanitized response should be returned
1385 | dataFilter: empty
1386 | }
1387 |
1388 | function mimeToDataType(mime) {
1389 | if (mime) mime = mime.split(';', 2)[0]
1390 | return mime && ( mime == htmlType ? 'html' :
1391 | mime == jsonType ? 'json' :
1392 | scriptTypeRE.test(mime) ? 'script' :
1393 | xmlTypeRE.test(mime) && 'xml' ) || 'text'
1394 | }
1395 |
1396 | function appendQuery(url, query) {
1397 | if (query == '') return url
1398 | return (url + '&' + query).replace(/[&?]{1,2}/, '?')
1399 | }
1400 |
1401 | // serialize payload and append it to the URL for GET requests
1402 | function serializeData(options) {
1403 | if (options.processData && options.data && $.type(options.data) != "string")
1404 | options.data = $.param(options.data, options.traditional)
1405 | if (options.data && (!options.type || options.type.toUpperCase() == 'GET' || 'jsonp' == options.dataType))
1406 | options.url = appendQuery(options.url, options.data), options.data = undefined
1407 | }
1408 |
1409 | $.ajax = function(options){
1410 | var settings = $.extend({}, options || {}),
1411 | deferred = $.Deferred && $.Deferred(),
1412 | urlAnchor, hashIndex
1413 | for (key in $.ajaxSettings) if (settings[key] === undefined) settings[key] = $.ajaxSettings[key]
1414 |
1415 | ajaxStart(settings)
1416 |
1417 | if (!settings.crossDomain) {
1418 | urlAnchor = document.createElement('a')
1419 | urlAnchor.href = settings.url
1420 | // cleans up URL for .href (IE only), see https://github.com/madrobby/zepto/pull/1049
1421 | urlAnchor.href = urlAnchor.href
1422 | settings.crossDomain = (originAnchor.protocol + '//' + originAnchor.host) !== (urlAnchor.protocol + '//' + urlAnchor.host)
1423 | }
1424 |
1425 | if (!settings.url) settings.url = window.location.toString()
1426 | if ((hashIndex = settings.url.indexOf('#')) > -1) settings.url = settings.url.slice(0, hashIndex)
1427 | serializeData(settings)
1428 |
1429 | var dataType = settings.dataType, hasPlaceholder = /\?.+=\?/.test(settings.url)
1430 | if (hasPlaceholder) dataType = 'jsonp'
1431 |
1432 | if (settings.cache === false || (
1433 | (!options || options.cache !== true) &&
1434 | ('script' == dataType || 'jsonp' == dataType)
1435 | ))
1436 | settings.url = appendQuery(settings.url, '_=' + Date.now())
1437 |
1438 | if ('jsonp' == dataType) {
1439 | if (!hasPlaceholder)
1440 | settings.url = appendQuery(settings.url,
1441 | settings.jsonp ? (settings.jsonp + '=?') : settings.jsonp === false ? '' : 'callback=?')
1442 | return $.ajaxJSONP(settings, deferred)
1443 | }
1444 |
1445 | var mime = settings.accepts[dataType],
1446 | headers = { },
1447 | setHeader = function(name, value) { headers[name.toLowerCase()] = [name, value] },
1448 | protocol = /^([\w-]+:)\/\//.test(settings.url) ? RegExp.$1 : window.location.protocol,
1449 | xhr = settings.xhr(),
1450 | nativeSetHeader = xhr.setRequestHeader,
1451 | abortTimeout
1452 |
1453 | if (deferred) deferred.promise(xhr)
1454 |
1455 | if (!settings.crossDomain) setHeader('X-Requested-With', 'XMLHttpRequest')
1456 | setHeader('Accept', mime || '*/*')
1457 | if (mime = settings.mimeType || mime) {
1458 | if (mime.indexOf(',') > -1) mime = mime.split(',', 2)[0]
1459 | xhr.overrideMimeType && xhr.overrideMimeType(mime)
1460 | }
1461 | if (settings.contentType || (settings.contentType !== false && settings.data && settings.type.toUpperCase() != 'GET'))
1462 | setHeader('Content-Type', settings.contentType || 'application/x-www-form-urlencoded')
1463 |
1464 | if (settings.headers) for (name in settings.headers) setHeader(name, settings.headers[name])
1465 | xhr.setRequestHeader = setHeader
1466 |
1467 | xhr.onreadystatechange = function(){
1468 | if (xhr.readyState == 4) {
1469 | xhr.onreadystatechange = empty
1470 | clearTimeout(abortTimeout)
1471 | var result, error = false
1472 | if ((xhr.status >= 200 && xhr.status < 300) || xhr.status == 304 || (xhr.status == 0 && protocol == 'file:')) {
1473 | dataType = dataType || mimeToDataType(settings.mimeType || xhr.getResponseHeader('content-type'))
1474 |
1475 | if (xhr.responseType == 'arraybuffer' || xhr.responseType == 'blob')
1476 | result = xhr.response
1477 | else {
1478 | result = xhr.responseText
1479 |
1480 | try {
1481 | // http://perfectionkills.com/global-eval-what-are-the-options/
1482 | // sanitize response accordingly if data filter callback provided
1483 | result = ajaxDataFilter(result, dataType, settings)
1484 | if (dataType == 'script') (1,eval)(result)
1485 | else if (dataType == 'xml') result = xhr.responseXML
1486 | else if (dataType == 'json') result = blankRE.test(result) ? null : $.parseJSON(result)
1487 | } catch (e) { error = e }
1488 |
1489 | if (error) return ajaxError(error, 'parsererror', xhr, settings, deferred)
1490 | }
1491 |
1492 | ajaxSuccess(result, xhr, settings, deferred)
1493 | } else {
1494 | ajaxError(xhr.statusText || null, xhr.status ? 'error' : 'abort', xhr, settings, deferred)
1495 | }
1496 | }
1497 | }
1498 |
1499 | if (ajaxBeforeSend(xhr, settings) === false) {
1500 | xhr.abort()
1501 | ajaxError(null, 'abort', xhr, settings, deferred)
1502 | return xhr
1503 | }
1504 |
1505 | var async = 'async' in settings ? settings.async : true
1506 | xhr.open(settings.type, settings.url, async, settings.username, settings.password)
1507 |
1508 | if (settings.xhrFields) for (name in settings.xhrFields) xhr[name] = settings.xhrFields[name]
1509 |
1510 | for (name in headers) nativeSetHeader.apply(xhr, headers[name])
1511 |
1512 | if (settings.timeout > 0) abortTimeout = setTimeout(function(){
1513 | xhr.onreadystatechange = empty
1514 | xhr.abort()
1515 | ajaxError(null, 'timeout', xhr, settings, deferred)
1516 | }, settings.timeout)
1517 |
1518 | // avoid sending empty string (#319)
1519 | xhr.send(settings.data ? settings.data : null)
1520 | return xhr
1521 | }
1522 |
1523 | // handle optional data/success arguments
1524 | function parseArguments(url, data, success, dataType) {
1525 | if ($.isFunction(data)) dataType = success, success = data, data = undefined
1526 | if (!$.isFunction(success)) dataType = success, success = undefined
1527 | return {
1528 | url: url
1529 | , data: data
1530 | , success: success
1531 | , dataType: dataType
1532 | }
1533 | }
1534 |
1535 | $.get = function(/* url, data, success, dataType */){
1536 | return $.ajax(parseArguments.apply(null, arguments))
1537 | }
1538 |
1539 | $.post = function(/* url, data, success, dataType */){
1540 | var options = parseArguments.apply(null, arguments)
1541 | options.type = 'POST'
1542 | return $.ajax(options)
1543 | }
1544 |
1545 | $.getJSON = function(/* url, data, success */){
1546 | var options = parseArguments.apply(null, arguments)
1547 | options.dataType = 'json'
1548 | return $.ajax(options)
1549 | }
1550 |
1551 | $.fn.load = function(url, data, success){
1552 | if (!this.length) return this
1553 | var self = this, parts = url.split(/\s/), selector,
1554 | options = parseArguments(url, data, success),
1555 | callback = options.success
1556 | if (parts.length > 1) options.url = parts[0], selector = parts[1]
1557 | options.success = function(response){
1558 | self.html(selector ?
1559 | $('').html(response.replace(rscript, "")).find(selector)
1560 | : response)
1561 | callback && callback.apply(self, arguments)
1562 | }
1563 | $.ajax(options)
1564 | return this
1565 | }
1566 |
1567 | var escape = encodeURIComponent
1568 |
1569 | function serialize(params, obj, traditional, scope){
1570 | var type, array = $.isArray(obj), hash = $.isPlainObject(obj)
1571 | $.each(obj, function(key, value) {
1572 | type = $.type(value)
1573 | if (scope) key = traditional ? scope :
1574 | scope + '[' + (hash || type == 'object' || type == 'array' ? key : '') + ']'
1575 | // handle data in serializeArray() format
1576 | if (!scope && array) params.add(value.name, value.value)
1577 | // recurse into nested objects
1578 | else if (type == "array" || (!traditional && type == "object"))
1579 | serialize(params, value, traditional, key)
1580 | else params.add(key, value)
1581 | })
1582 | }
1583 |
1584 | $.param = function(obj, traditional){
1585 | var params = []
1586 | params.add = function(key, value) {
1587 | if ($.isFunction(value)) value = value()
1588 | if (value == null) value = ""
1589 | this.push(escape(key) + '=' + escape(value))
1590 | }
1591 | serialize(params, obj, traditional)
1592 | return params.join('&').replace(/%20/g, '+')
1593 | }
1594 | })(Zepto)
1595 |
1596 | ;(function($){
1597 | $.fn.serializeArray = function() {
1598 | var name, type, result = [],
1599 | add = function(value) {
1600 | if (value.forEach) return value.forEach(add)
1601 | result.push({ name: name, value: value })
1602 | }
1603 | if (this[0]) $.each(this[0].elements, function(_, field){
1604 | type = field.type, name = field.name
1605 | if (name && field.nodeName.toLowerCase() != 'fieldset' &&
1606 | !field.disabled && type != 'submit' && type != 'reset' && type != 'button' && type != 'file' &&
1607 | ((type != 'radio' && type != 'checkbox') || field.checked))
1608 | add($(field).val())
1609 | })
1610 | return result
1611 | }
1612 |
1613 | $.fn.serialize = function(){
1614 | var result = []
1615 | this.serializeArray().forEach(function(elm){
1616 | result.push(encodeURIComponent(elm.name) + '=' + encodeURIComponent(elm.value))
1617 | })
1618 | return result.join('&')
1619 | }
1620 |
1621 | $.fn.submit = function(callback) {
1622 | if (0 in arguments) this.bind('submit', callback)
1623 | else if (this.length) {
1624 | var event = $.Event('submit')
1625 | this.eq(0).trigger(event)
1626 | if (!event.isDefaultPrevented()) this.get(0).submit()
1627 | }
1628 | return this
1629 | }
1630 |
1631 | })(Zepto)
1632 |
1633 | ;(function(){
1634 | // getComputedStyle shouldn't freak out when called
1635 | // without a valid element as argument
1636 | try {
1637 | getComputedStyle(undefined)
1638 | } catch(e) {
1639 | var nativeGetComputedStyle = getComputedStyle
1640 | window.getComputedStyle = function(element, pseudoElement){
1641 | try {
1642 | return nativeGetComputedStyle(element, pseudoElement)
1643 | } catch(e) {
1644 | return null
1645 | }
1646 | }
1647 | }
1648 | })()
1649 | return Zepto
1650 | }))
1651 |
--------------------------------------------------------------------------------
/src/libs/demo.css:
--------------------------------------------------------------------------------
1 | html {
2 | font-family: sans-serif;
3 | -ms-text-size-adjust: 100%;
4 | -webkit-text-size-adjust: 100%;
5 | text-rendering: optimizeLegibility;
6 | -webkit-font-smoothing: antialiased;
7 | -moz-osx-font-smoothing: grayscale;
8 | }
9 |
10 | body {
11 | margin: 0;
12 | }
13 |
14 | h1,
15 | h2,
16 | h3,
17 | h4,
18 | h5 {
19 | word-wrap: break-word;
20 | }
21 |
22 | img,
23 | canvas {
24 | max-width: 100%;
25 | border: 1px solid #d3d3d3;
26 | }
27 |
28 | .container {
29 | margin: 0 auto;
30 | padding: 0 15px 40px;
31 | max-width: 720px;
32 | border-right: 1px solid #ddd;
33 | border-left: 1px solid #ddd;
34 | overflow: hidden;
35 | }
36 |
37 | .single-line {
38 | font-size: .8em;
39 | color: #666;
40 | white-space: nowrap;
41 | overflow: auto;
42 | -webkit-overflow-scrolling: touch;
43 | }
44 |
45 | pre {
46 | margin-right: 80px;
47 | max-height: 180px;
48 | font-size: .8em;
49 | color: #666;
50 | overflow: auto;
51 | -webkit-overflow-scrolling: touch;
52 | }
53 |
--------------------------------------------------------------------------------
/src/libs/demo.js:
--------------------------------------------------------------------------------
1 | ;(function () {
2 | var file
3 | var fileType
4 | var url
5 | var compressedImageDataURL
6 | var compressedImageBlob
7 | var compressSuccess = false
8 | var contentType // 从 canvas.toDataURL 的结果中获取的 contentType
9 | var binaryString // atob 转码后的 二进制文本
10 | var boundary = 'customFileboundary'
11 | var boundaryString // 构造为 multipart 的文本
12 | var arrayBuffer // 需要用 ajax 发送的 ArrayBuffer
13 |
14 | function asyncClick (doms, i) {
15 | setTimeout(function () {
16 | if (i < doms.length) {
17 | doms[i++].click()
18 | asyncClick(doms, i)
19 | }
20 | }, 50)
21 | }
22 |
23 | function autoClick () {
24 | asyncClick([
25 | J_GetImageFile,
26 | J_LoadImageByURL,
27 | J_DrawImage,
28 | J_CompressImage,
29 | J_Atob,
30 | J_ConcatBinaryStirng,
31 | J_String2ArrayBuffer
32 | ], 0)
33 | }
34 |
35 | // file on change
36 | J_File.addEventListener('change', function (e) {
37 | if (e.target.value) {
38 | J_GetImageFile.removeAttribute('disabled')
39 | } else {
40 | J_GetImageFile.setAttribute('disabled', true)
41 | }
42 | // autoClick() // Test
43 | })
44 |
45 | // get file
46 | J_GetImageFile.addEventListener('click', function () {
47 | var fileName
48 | file = J_File.files[0]
49 | fileName = file.name
50 | fileType = file.type || 'image/' + fileName.substr(fileName.lastIndexOf('.') + 1)
51 | J_ImageObject.innerText = [
52 | 'file.name: ' + fileName,
53 | 'file.type: ' + fileType,
54 | 'file.size: ' + file.size
55 | ].join('\r\n')
56 | J_LoadImageByURL.removeAttribute('disabled')
57 | J_LoadImageByFileReader.removeAttribute('disabled')
58 | })
59 |
60 | // get file directly
61 | J_GetLenaFile.addEventListener('click', function (e) {
62 | var button
63 |
64 | if (e.target && e.target.nodeName === 'BUTTON') {
65 | var fileName
66 | button = e.target
67 | url = button.getAttribute('data-url')
68 | fileName = url.substr(url.lastIndexOf('/') + 1)
69 |
70 | getFile(url + '?t=' + (new Date()).valueOf(), function (err, res) {
71 | if (err) {
72 | return alert(err)
73 | }
74 | file = {
75 | name: fileName,
76 | size: res.contentLength,
77 | type: res.contentType
78 | }
79 | fileType = res.contentType
80 | J_ImageObject.innerText = [
81 | 'file.name: ' + fileName,
82 | 'file.type: ' + fileType,
83 | 'file.size: ' + file.size
84 | ].join('\r\n')
85 | })
86 |
87 | // reset
88 | J_ImageObject.innerText = ''
89 | J_Image.removeAttribute('src')
90 | J_ImageCanvas.getContext('2d').clearRect(0, 0, J_ImageCanvas.width, J_ImageCanvas.height)
91 | J_ImageCanvas.width = 300
92 | J_ImageCanvas.height = 150
93 | setTimeout(function () {
94 | J_Image.src = url
95 | J_ImageURL.innerText = url
96 | }, 0)
97 | }
98 | })
99 |
100 | // image load
101 | J_Image.addEventListener('load', function () {
102 | J_DrawImage.removeAttribute('disabled')
103 | })
104 |
105 | J_Image.addEventListener('error', function () {
106 | alert('image load error')
107 | })
108 |
109 | // get dataURL/BlobURL
110 | // URL
111 | J_LoadImageByURL.addEventListener('click', function () {
112 | if (url) {
113 | window.URL.revokeObjectURL(url)
114 | }
115 | url = window.URL.createObjectURL(file)
116 |
117 | J_Image.removeAttribute('src')
118 | setTimeout(function () {
119 | J_Image.src = url
120 | J_ImageURL.innerText = url
121 | }, 0)
122 | })
123 | // FileReader
124 | J_LoadImageByFileReader.addEventListener('click', function () {
125 | var fileReader = new FileReader()
126 |
127 | J_Image.removeAttribute('src')
128 | fileReader.onload = function (e) {
129 | var dataURL = e.target.result
130 | J_Image.src = dataURL
131 | J_ImageURL.innerText = dataURL
132 | }
133 | fileReader.readAsDataURL(file)
134 | })
135 |
136 | // drawImage to canvas
137 | J_DrawImage.addEventListener('click', function () {
138 | var sourceImage = J_Image
139 | var canvas = J_ImageCanvas
140 | var context = canvas.getContext('2d')
141 |
142 | if (!isCanvasBlank(canvas)) {
143 | context.clearRect(0, 0, canvas.width, canvas.height)
144 | }
145 | canvas.width = sourceImage.naturalWidth
146 | canvas.height = sourceImage.naturalHeight
147 | context.drawImage(sourceImage, 0, 0)
148 |
149 | J_CompressImage.removeAttribute('disabled')
150 | })
151 |
152 | J_CompressImage.addEventListener('click', function () {
153 | /*
154 | * HTMLCanvasElement.toDataURL() 不支持传入的类型非“image/png”，
155 | * 但是值以“data:image/png”开头的类型。
156 | */
157 | var canvas = J_ImageCanvas
158 | var mimeType = fileType || 'image/png'
159 | var quality = J_CompressQuality.value
160 | var startTime
161 | var endTime
162 |
163 |
164 | J_MimeType.innerText = ''
165 | J_CompressedImageDataURL.innerText = ''
166 | J_SourceFileSize.innerText = ''
167 | J_CompressedFileSize.innerText = ''
168 | J_CompressedImage.removeAttribute('src')
169 |
170 | startTime = Date.now()
171 | compressedImageDataURL = canvas.toDataURL(mimeType, quality / 100)
172 | endTime = Date.now()
173 | compressedImageBlob = dataURL2Blob(compressedImageDataURL)
174 |
175 | setTimeout(function () {
176 | J_MimeType.innerText = mimeType
177 | J_CompressedImageDataURL.innerText = compressedImageDataURL
178 | J_SourceFileSize.innerText = file.size
179 | J_CompressedFileSize.innerText = compressedImageBlob.size
180 | J_CompressDuring.innerText = endTime - startTime + 'ms'
181 | J_CompressedImage.src = compressedImageDataURL
182 | J_Atob.removeAttribute('disabled')
183 | J_XHRBlobMultiparty.removeAttribute('disabled')
184 | J_XHRBlobMulter.removeAttribute('disabled')
185 | }, 0)
186 |
187 | if (compressedImageBlob.size > file.size) {
188 | // Compressed file size > Original file size
189 | console.log(compressedImageBlob.size + ' > ' + file.size)
190 | return
191 | }
192 | compressSuccess = true
193 | })
194 |
195 | // atob
196 | J_Atob.addEventListener('click', function () {
197 | // 不包含 /^data:(image\/.+);base64,/ 的 base64 字符串
198 | var pureBase64ImageData = compressedImageDataURL.replace(/^data:(image\/.+);base64,/, function ($0, $1) {
199 | contentType = $1
200 | return ''
201 | })
202 |
203 | // atob
204 | binaryString = atob(pureBase64ImageData)
205 |
206 | J_PureBase64Data.innerText = pureBase64ImageData
207 | J_ContentType.innerText = contentType
208 | J_BinaryString.innerText = binaryString
209 | J_ConcatBinaryStirng.removeAttribute('disabled')
210 | })
211 |
212 | J_ConcatBinaryStirng.addEventListener('click', function () {
213 | boundaryString = [
214 | '--' + boundary,
215 | 'Content-Disposition: form-data; name="file"; filename="' + (file.name || 'blob') + '"',
216 | 'Content-Type: ' + contentType,
217 | '', binaryString,
218 | '--' + boundary + '--', ''
219 | ].join('\r\n')
220 |
221 | J_MultipartBinaryString.innerText = boundaryString
222 | J_String2ArrayBuffer.removeAttribute('disabled')
223 | })
224 |
225 | J_String2ArrayBuffer.addEventListener('click', function () {
226 | arrayBuffer = string2ArrayBuffer(boundaryString)
227 |
228 | J_ArrayBuffer.innerText = arrayBuffer
229 | J_XHRMultiparty.removeAttribute('disabled')
230 | J_XHRMulter.removeAttribute('disabled')
231 | })
232 |
233 | function sendArrayBuffer (url) {
234 | return function () {
235 | var button = this
236 | var buttonText = this.innerText
237 | var xhr = new XMLHttpRequest()
238 |
239 | xhr.open('POST', url, true)
240 | xhr.withCredentials = true
241 | xhr.setRequestHeader('Content-Type', 'multipart/form-data; boundary=' + boundary)
242 |
243 | xhr.upload.addEventListener('progress', function (e) {
244 | var progress
245 | if (e.lengthComputable) {
246 | progress = (e.loaded / e.total * 100).toFixed(2)
247 | button.innerText = progress + '%'
248 | }
249 | })
250 | xhr.addEventListener('load', function () {
251 | if (
252 | xhr.status >= 200 && xhr.status < 300 ||
253 | xhr.status == 304
254 | ) {
255 | J_UploadResult_XHR.innerText = '--- SUCCESS ---\n' + JSON.stringify(JSON.parse(xhr.responseText), null, 2)
256 | } else {
257 | J_UploadResult_XHR.innerText =
258 | '--- ERROR: ' + xhr.status + ' ---\n' + JSON.stringify(JSON.parse(xhr.responseText), null, 2)
259 | }
260 | button.innerText = buttonText
261 | button.removeAttribute('disabled')
262 | })
263 |
264 | button.setAttribute('disabled', 'true')
265 | xhr.send(arrayBuffer)
266 | }
267 | }
268 |
269 | // use XMLHttpRequest send Array Buffer
270 | J_XHRMultiparty.addEventListener('click', sendArrayBuffer('/api/upload/multiparty'))
271 | J_XHRMulter.addEventListener('click', sendArrayBuffer('/api/upload/multer'))
272 |
273 | function sendBlob (url) {
274 | return function () {
275 | var button = this
276 | var buttonText = this.innerText
277 | var formData = new FormData()
278 | var xhr = new XMLHttpRequest()
279 | var blobFile = compressedImageBlob
280 |
281 | formData.append('file', blobFile, file.name)
282 |
283 | xhr.open('POST', url, true)
284 | xhr.withCredentials = true
285 |
286 | xhr.upload.addEventListener('progress', function (e) {
287 | var progress
288 | if (e.lengthComputable) {
289 | progress = (e.loaded / e.total * 100).toFixed(2)
290 | button.innerText = progress + '%'
291 | }
292 | })
293 | xhr.addEventListener('load', function () {
294 | if (
295 | xhr.status >= 200 && xhr.status < 300 ||
296 | xhr.status == 304
297 | ) {
298 | J_UploadResult_XHRBlob.innerText = '--- SUCCESS ---\n' + JSON.stringify(JSON.parse(xhr.responseText), null, 2)
299 | } else {
300 | J_UploadResult_XHRBlob.innerText =
301 | '--- ERROR: ' + xhr.status + ' ---\n' + JSON.stringify(JSON.parse(xhr.responseText), null, 2)
302 | }
303 | button.innerText = buttonText
304 | button.removeAttribute('disabled')
305 | })
306 |
307 | button.setAttribute('disabled', 'true')
308 | xhr.send(formData)
309 | }
310 | }
311 |
312 | // use XMLHttpRequest & FormData send blob
313 | J_XHRBlobMultiparty.addEventListener('click', sendBlob('/api/upload/multiparty'))
314 | J_XHRBlobMulter.addEventListener('click', sendBlob('/api/upload/multer'))
315 | }())
316 |
--------------------------------------------------------------------------------
/src/libs/es6-promise.js:
--------------------------------------------------------------------------------
1 | /*!
2 | * @overview es6-promise - a tiny implementation of Promises/A+.
3 | * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
4 | * @license Licensed under MIT license
5 | * See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
6 | * @version 3.2.2+39aa2571
7 | */
8 |
9 | (function() {
10 | "use strict";
11 | function lib$es6$promise$utils$$objectOrFunction(x) {
12 | return typeof x === 'function' || (typeof x === 'object' && x !== null);
13 | }
14 |
15 | function lib$es6$promise$utils$$isFunction(x) {
16 | return typeof x === 'function';
17 | }
18 |
19 | function lib$es6$promise$utils$$isMaybeThenable(x) {
20 | return typeof x === 'object' && x !== null;
21 | }
22 |
23 | var lib$es6$promise$utils$$_isArray;
24 | if (!Array.isArray) {
25 | lib$es6$promise$utils$$_isArray = function (x) {
26 | return Object.prototype.toString.call(x) === '[object Array]';
27 | };
28 | } else {
29 | lib$es6$promise$utils$$_isArray = Array.isArray;
30 | }
31 |
32 | var lib$es6$promise$utils$$isArray = lib$es6$promise$utils$$_isArray;
33 | var lib$es6$promise$asap$$len = 0;
34 | var lib$es6$promise$asap$$vertxNext;
35 | var lib$es6$promise$asap$$customSchedulerFn;
36 |
37 | var lib$es6$promise$asap$$asap = function asap(callback, arg) {
38 | lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len] = callback;
39 | lib$es6$promise$asap$$queue[lib$es6$promise$asap$$len + 1] = arg;
40 | lib$es6$promise$asap$$len += 2;
41 | if (lib$es6$promise$asap$$len === 2) {
42 | // If len is 2, that means that we need to schedule an async flush.
43 | // If additional callbacks are queued before the queue is flushed, they
44 | // will be processed by this flush that we are scheduling.
45 | if (lib$es6$promise$asap$$customSchedulerFn) {
46 | lib$es6$promise$asap$$customSchedulerFn(lib$es6$promise$asap$$flush);
47 | } else {
48 | lib$es6$promise$asap$$scheduleFlush();
49 | }
50 | }
51 | }
52 |
53 | function lib$es6$promise$asap$$setScheduler(scheduleFn) {
54 | lib$es6$promise$asap$$customSchedulerFn = scheduleFn;
55 | }
56 |
57 | function lib$es6$promise$asap$$setAsap(asapFn) {
58 | lib$es6$promise$asap$$asap = asapFn;
59 | }
60 |
61 | var lib$es6$promise$asap$$browserWindow = (typeof window !== 'undefined') ? window : undefined;
62 | var lib$es6$promise$asap$$browserGlobal = lib$es6$promise$asap$$browserWindow || {};
63 | var lib$es6$promise$asap$$BrowserMutationObserver = lib$es6$promise$asap$$browserGlobal.MutationObserver || lib$es6$promise$asap$$browserGlobal.WebKitMutationObserver;
64 | var lib$es6$promise$asap$$isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
65 |
66 | // test for web worker but not in IE10
67 | var lib$es6$promise$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' &&
68 | typeof importScripts !== 'undefined' &&
69 | typeof MessageChannel !== 'undefined';
70 |
71 | // node
72 | function lib$es6$promise$asap$$useNextTick() {
73 | // node version 0.10.x displays a deprecation warning when nextTick is used recursively
74 | // see https://github.com/cujojs/when/issues/410 for details
75 | return function() {
76 | process.nextTick(lib$es6$promise$asap$$flush);
77 | };
78 | }
79 |
80 | // vertx
81 | function lib$es6$promise$asap$$useVertxTimer() {
82 | return function() {
83 | lib$es6$promise$asap$$vertxNext(lib$es6$promise$asap$$flush);
84 | };
85 | }
86 |
87 | function lib$es6$promise$asap$$useMutationObserver() {
88 | var iterations = 0;
89 | var observer = new lib$es6$promise$asap$$BrowserMutationObserver(lib$es6$promise$asap$$flush);
90 | var node = document.createTextNode('');
91 | observer.observe(node, { characterData: true });
92 |
93 | return function() {
94 | node.data = (iterations = ++iterations % 2);
95 | };
96 | }
97 |
98 | // web worker
99 | function lib$es6$promise$asap$$useMessageChannel() {
100 | var channel = new MessageChannel();
101 | channel.port1.onmessage = lib$es6$promise$asap$$flush;
102 | return function () {
103 | channel.port2.postMessage(0);
104 | };
105 | }
106 |
107 | function lib$es6$promise$asap$$useSetTimeout() {
108 | return function() {
109 | setTimeout(lib$es6$promise$asap$$flush, 1);
110 | };
111 | }
112 |
113 | var lib$es6$promise$asap$$queue = new Array(1000);
114 | function lib$es6$promise$asap$$flush() {
115 | for (var i = 0; i < lib$es6$promise$asap$$len; i+=2) {
116 | var callback = lib$es6$promise$asap$$queue[i];
117 | var arg = lib$es6$promise$asap$$queue[i+1];
118 |
119 | callback(arg);
120 |
121 | lib$es6$promise$asap$$queue[i] = undefined;
122 | lib$es6$promise$asap$$queue[i+1] = undefined;
123 | }
124 |
125 | lib$es6$promise$asap$$len = 0;
126 | }
127 |
128 | function lib$es6$promise$asap$$attemptVertx() {
129 | try {
130 | var r = require;
131 | var vertx = r('vertx');
132 | lib$es6$promise$asap$$vertxNext = vertx.runOnLoop || vertx.runOnContext;
133 | return lib$es6$promise$asap$$useVertxTimer();
134 | } catch(e) {
135 | return lib$es6$promise$asap$$useSetTimeout();
136 | }
137 | }
138 |
139 | var lib$es6$promise$asap$$scheduleFlush;
140 | // Decide what async method to use to triggering processing of queued callbacks:
141 | if (lib$es6$promise$asap$$isNode) {
142 | lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useNextTick();
143 | } else if (lib$es6$promise$asap$$BrowserMutationObserver) {
144 | lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMutationObserver();
145 | } else if (lib$es6$promise$asap$$isWorker) {
146 | lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMessageChannel();
147 | } else if (lib$es6$promise$asap$$browserWindow === undefined && typeof require === 'function') {
148 | lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$attemptVertx();
149 | } else {
150 | lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useSetTimeout();
151 | }
152 | function lib$es6$promise$then$$then(onFulfillment, onRejection) {
153 | var parent = this;
154 |
155 | var child = new this.constructor(lib$es6$promise$$internal$$noop);
156 |
157 | if (child[lib$es6$promise$$internal$$PROMISE_ID] === undefined) {
158 | lib$es6$promise$$internal$$makePromise(child);
159 | }
160 |
161 | var state = parent._state;
162 |
163 | if (state) {
164 | var callback = arguments[state - 1];
165 | lib$es6$promise$asap$$asap(function(){
166 | lib$es6$promise$$internal$$invokeCallback(state, child, callback, parent._result);
167 | });
168 | } else {
169 | lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection);
170 | }
171 |
172 | return child;
173 | }
174 | var lib$es6$promise$then$$default = lib$es6$promise$then$$then;
175 | function lib$es6$promise$promise$resolve$$resolve(object) {
176 | /*jshint validthis:true */
177 | var Constructor = this;
178 |
179 | if (object && typeof object === 'object' && object.constructor === Constructor) {
180 | return object;
181 | }
182 |
183 | var promise = new Constructor(lib$es6$promise$$internal$$noop);
184 | lib$es6$promise$$internal$$resolve(promise, object);
185 | return promise;
186 | }
187 | var lib$es6$promise$promise$resolve$$default = lib$es6$promise$promise$resolve$$resolve;
188 | var lib$es6$promise$$internal$$PROMISE_ID = Math.random().toString(36).substring(16);
189 |
190 | function lib$es6$promise$$internal$$noop() {}
191 |
192 | var lib$es6$promise$$internal$$PENDING = void 0;
193 | var lib$es6$promise$$internal$$FULFILLED = 1;
194 | var lib$es6$promise$$internal$$REJECTED = 2;
195 |
196 | var lib$es6$promise$$internal$$GET_THEN_ERROR = new lib$es6$promise$$internal$$ErrorObject();
197 |
198 | function lib$es6$promise$$internal$$selfFulfillment() {
199 | return new TypeError("You cannot resolve a promise with itself");
200 | }
201 |
202 | function lib$es6$promise$$internal$$cannotReturnOwn() {
203 | return new TypeError('A promises callback cannot return that same promise.');
204 | }
205 |
206 | function lib$es6$promise$$internal$$getThen(promise) {
207 | try {
208 | return promise.then;
209 | } catch(error) {
210 | lib$es6$promise$$internal$$GET_THEN_ERROR.error = error;
211 | return lib$es6$promise$$internal$$GET_THEN_ERROR;
212 | }
213 | }
214 |
215 | function lib$es6$promise$$internal$$tryThen(then, value, fulfillmentHandler, rejectionHandler) {
216 | try {
217 | then.call(value, fulfillmentHandler, rejectionHandler);
218 | } catch(e) {
219 | return e;
220 | }
221 | }
222 |
223 | function lib$es6$promise$$internal$$handleForeignThenable(promise, thenable, then) {
224 | lib$es6$promise$asap$$asap(function(promise) {
225 | var sealed = false;
226 | var error = lib$es6$promise$$internal$$tryThen(then, thenable, function(value) {
227 | if (sealed) { return; }
228 | sealed = true;
229 | if (thenable !== value) {
230 | lib$es6$promise$$internal$$resolve(promise, value);
231 | } else {
232 | lib$es6$promise$$internal$$fulfill(promise, value);
233 | }
234 | }, function(reason) {
235 | if (sealed) { return; }
236 | sealed = true;
237 |
238 | lib$es6$promise$$internal$$reject(promise, reason);
239 | }, 'Settle: ' + (promise._label || ' unknown promise'));
240 |
241 | if (!sealed && error) {
242 | sealed = true;
243 | lib$es6$promise$$internal$$reject(promise, error);
244 | }
245 | }, promise);
246 | }
247 |
248 | function lib$es6$promise$$internal$$handleOwnThenable(promise, thenable) {
249 | if (thenable._state === lib$es6$promise$$internal$$FULFILLED) {
250 | lib$es6$promise$$internal$$fulfill(promise, thenable._result);
251 | } else if (thenable._state === lib$es6$promise$$internal$$REJECTED) {
252 | lib$es6$promise$$internal$$reject(promise, thenable._result);
253 | } else {
254 | lib$es6$promise$$internal$$subscribe(thenable, undefined, function(value) {
255 | lib$es6$promise$$internal$$resolve(promise, value);
256 | }, function(reason) {
257 | lib$es6$promise$$internal$$reject(promise, reason);
258 | });
259 | }
260 | }
261 |
262 | function lib$es6$promise$$internal$$handleMaybeThenable(promise, maybeThenable, then) {
263 | if (maybeThenable.constructor === promise.constructor &&
264 | then === lib$es6$promise$then$$default &&
265 | constructor.resolve === lib$es6$promise$promise$resolve$$default) {
266 | lib$es6$promise$$internal$$handleOwnThenable(promise, maybeThenable);
267 | } else {
268 | if (then === lib$es6$promise$$internal$$GET_THEN_ERROR) {
269 | lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$GET_THEN_ERROR.error);
270 | } else if (then === undefined) {
271 | lib$es6$promise$$internal$$fulfill(promise, maybeThenable);
272 | } else if (lib$es6$promise$utils$$isFunction(then)) {
273 | lib$es6$promise$$internal$$handleForeignThenable(promise, maybeThenable, then);
274 | } else {
275 | lib$es6$promise$$internal$$fulfill(promise, maybeThenable);
276 | }
277 | }
278 | }
279 |
280 | function lib$es6$promise$$internal$$resolve(promise, value) {
281 | if (promise === value) {
282 | lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$selfFulfillment());
283 | } else if (lib$es6$promise$utils$$objectOrFunction(value)) {
284 | lib$es6$promise$$internal$$handleMaybeThenable(promise, value, lib$es6$promise$$internal$$getThen(value));
285 | } else {
286 | lib$es6$promise$$internal$$fulfill(promise, value);
287 | }
288 | }
289 |
290 | function lib$es6$promise$$internal$$publishRejection(promise) {
291 | if (promise._onerror) {
292 | promise._onerror(promise._result);
293 | }
294 |
295 | lib$es6$promise$$internal$$publish(promise);
296 | }
297 |
298 | function lib$es6$promise$$internal$$fulfill(promise, value) {
299 | if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; }
300 |
301 | promise._result = value;
302 | promise._state = lib$es6$promise$$internal$$FULFILLED;
303 |
304 | if (promise._subscribers.length !== 0) {
305 | lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, promise);
306 | }
307 | }
308 |
309 | function lib$es6$promise$$internal$$reject(promise, reason) {
310 | if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; }
311 | promise._state = lib$es6$promise$$internal$$REJECTED;
312 | promise._result = reason;
313 |
314 | lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publishRejection, promise);
315 | }
316 |
317 | function lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection) {
318 | var subscribers = parent._subscribers;
319 | var length = subscribers.length;
320 |
321 | parent._onerror = null;
322 |
323 | subscribers[length] = child;
324 | subscribers[length + lib$es6$promise$$internal$$FULFILLED] = onFulfillment;
325 | subscribers[length + lib$es6$promise$$internal$$REJECTED] = onRejection;
326 |
327 | if (length === 0 && parent._state) {
328 | lib$es6$promise$asap$$asap(lib$es6$promise$$internal$$publish, parent);
329 | }
330 | }
331 |
332 | function lib$es6$promise$$internal$$publish(promise) {
333 | var subscribers = promise._subscribers;
334 | var settled = promise._state;
335 |
336 | if (subscribers.length === 0) { return; }
337 |
338 | var child, callback, detail = promise._result;
339 |
340 | for (var i = 0; i < subscribers.length; i += 3) {
341 | child = subscribers[i];
342 | callback = subscribers[i + settled];
343 |
344 | if (child) {
345 | lib$es6$promise$$internal$$invokeCallback(settled, child, callback, detail);
346 | } else {
347 | callback(detail);
348 | }
349 | }
350 |
351 | promise._subscribers.length = 0;
352 | }
353 |
354 | function lib$es6$promise$$internal$$ErrorObject() {
355 | this.error = null;
356 | }
357 |
358 | var lib$es6$promise$$internal$$TRY_CATCH_ERROR = new lib$es6$promise$$internal$$ErrorObject();
359 |
360 | function lib$es6$promise$$internal$$tryCatch(callback, detail) {
361 | try {
362 | return callback(detail);
363 | } catch(e) {
364 | lib$es6$promise$$internal$$TRY_CATCH_ERROR.error = e;
365 | return lib$es6$promise$$internal$$TRY_CATCH_ERROR;
366 | }
367 | }
368 |
369 | function lib$es6$promise$$internal$$invokeCallback(settled, promise, callback, detail) {
370 | var hasCallback = lib$es6$promise$utils$$isFunction(callback),
371 | value, error, succeeded, failed;
372 |
373 | if (hasCallback) {
374 | value = lib$es6$promise$$internal$$tryCatch(callback, detail);
375 |
376 | if (value === lib$es6$promise$$internal$$TRY_CATCH_ERROR) {
377 | failed = true;
378 | error = value.error;
379 | value = null;
380 | } else {
381 | succeeded = true;
382 | }
383 |
384 | if (promise === value) {
385 | lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$cannotReturnOwn());
386 | return;
387 | }
388 |
389 | } else {
390 | value = detail;
391 | succeeded = true;
392 | }
393 |
394 | if (promise._state !== lib$es6$promise$$internal$$PENDING) {
395 | // noop
396 | } else if (hasCallback && succeeded) {
397 | lib$es6$promise$$internal$$resolve(promise, value);
398 | } else if (failed) {
399 | lib$es6$promise$$internal$$reject(promise, error);
400 | } else if (settled === lib$es6$promise$$internal$$FULFILLED) {
401 | lib$es6$promise$$internal$$fulfill(promise, value);
402 | } else if (settled === lib$es6$promise$$internal$$REJECTED) {
403 | lib$es6$promise$$internal$$reject(promise, value);
404 | }
405 | }
406 |
407 | function lib$es6$promise$$internal$$initializePromise(promise, resolver) {
408 | try {
409 | resolver(function resolvePromise(value){
410 | lib$es6$promise$$internal$$resolve(promise, value);
411 | }, function rejectPromise(reason) {
412 | lib$es6$promise$$internal$$reject(promise, reason);
413 | });
414 | } catch(e) {
415 | lib$es6$promise$$internal$$reject(promise, e);
416 | }
417 | }
418 |
419 | var lib$es6$promise$$internal$$id = 0;
420 | function lib$es6$promise$$internal$$nextId() {
421 | return lib$es6$promise$$internal$$id++;
422 | }
423 |
424 | function lib$es6$promise$$internal$$makePromise(promise) {
425 | promise[lib$es6$promise$$internal$$PROMISE_ID] = lib$es6$promise$$internal$$id++;
426 | promise._state = undefined;
427 | promise._result = undefined;
428 | promise._subscribers = [];
429 | }
430 |
431 | function lib$es6$promise$promise$all$$all(entries) {
432 | return new lib$es6$promise$enumerator$$default(this, entries).promise;
433 | }
434 | var lib$es6$promise$promise$all$$default = lib$es6$promise$promise$all$$all;
435 | function lib$es6$promise$promise$race$$race(entries) {
436 | /*jshint validthis:true */
437 | var Constructor = this;
438 |
439 | if (!lib$es6$promise$utils$$isArray(entries)) {
440 | return new Constructor(function(resolve, reject) {
441 | reject(new TypeError('You must pass an array to race.'));
442 | });
443 | } else {
444 | return new Constructor(function(resolve, reject) {
445 | var length = entries.length;
446 | for (var i = 0; i < length; i++) {
447 | Constructor.resolve(entries[i]).then(resolve, reject);
448 | }
449 | });
450 | }
451 | }
452 | var lib$es6$promise$promise$race$$default = lib$es6$promise$promise$race$$race;
453 | function lib$es6$promise$promise$reject$$reject(reason) {
454 | /*jshint validthis:true */
455 | var Constructor = this;
456 | var promise = new Constructor(lib$es6$promise$$internal$$noop);
457 | lib$es6$promise$$internal$$reject(promise, reason);
458 | return promise;
459 | }
460 | var lib$es6$promise$promise$reject$$default = lib$es6$promise$promise$reject$$reject;
461 |
462 |
463 | function lib$es6$promise$promise$$needsResolver() {
464 | throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
465 | }
466 |
467 | function lib$es6$promise$promise$$needsNew() {
468 | throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
469 | }
470 |
471 | var lib$es6$promise$promise$$default = lib$es6$promise$promise$$Promise;
472 | /**
473 | Promise objects represent the eventual result of an asynchronous operation. The
474 | primary way of interacting with a promise is through its `then` method, which
475 | registers callbacks to receive either a promise's eventual value or the reason
476 | why the promise cannot be fulfilled.
477 |
478 | Terminology
479 | -----------
480 |
481 | - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
482 | - `thenable` is an object or function that defines a `then` method.
483 | - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
484 | - `exception` is a value that is thrown using the throw statement.
485 | - `reason` is a value that indicates why a promise was rejected.
486 | - `settled` the final resting state of a promise, fulfilled or rejected.
487 |
488 | A promise can be in one of three states: pending, fulfilled, or rejected.
489 |
490 | Promises that are fulfilled have a fulfillment value and are in the fulfilled
491 | state. Promises that are rejected have a rejection reason and are in the
492 | rejected state. A fulfillment value is never a thenable.
493 |
494 | Promises can also be said to *resolve* a value. If this value is also a
495 | promise, then the original promise's settled state will match the value's
496 | settled state. So a promise that *resolves* a promise that rejects will
497 | itself reject, and a promise that *resolves* a promise that fulfills will
498 | itself fulfill.
499 |
500 |
501 | Basic Usage:
502 | ------------
503 |
504 | ```js
505 | var promise = new Promise(function(resolve, reject) {
506 | // on success
507 | resolve(value);
508 |
509 | // on failure
510 | reject(reason);
511 | });
512 |
513 | promise.then(function(value) {
514 | // on fulfillment
515 | }, function(reason) {
516 | // on rejection
517 | });
518 | ```
519 |
520 | Advanced Usage:
521 | ---------------
522 |
523 | Promises shine when abstracting away asynchronous interactions such as
524 | `XMLHttpRequest`s.
525 |
526 | ```js
527 | function getJSON(url) {
528 | return new Promise(function(resolve, reject){
529 | var xhr = new XMLHttpRequest();
530 |
531 | xhr.open('GET', url);
532 | xhr.onreadystatechange = handler;
533 | xhr.responseType = 'json';
534 | xhr.setRequestHeader('Accept', 'application/json');
535 | xhr.send();
536 |
537 | function handler() {
538 | if (this.readyState === this.DONE) {
539 | if (this.status === 200) {
540 | resolve(this.response);
541 | } else {
542 | reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
543 | }
544 | }
545 | };
546 | });
547 | }
548 |
549 | getJSON('/posts.json').then(function(json) {
550 | // on fulfillment
551 | }, function(reason) {
552 | // on rejection
553 | });
554 | ```
555 |
556 | Unlike callbacks, promises are great composable primitives.
557 |
558 | ```js
559 | Promise.all([
560 | getJSON('/posts'),
561 | getJSON('/comments')
562 | ]).then(function(values){
563 | values[0] // => postsJSON
564 | values[1] // => commentsJSON
565 |
566 | return values;
567 | });
568 | ```
569 |
570 | @class Promise
571 | @param {function} resolver
572 | Useful for tooling.
573 | @constructor
574 | */
575 | function lib$es6$promise$promise$$Promise(resolver) {
576 | this[lib$es6$promise$$internal$$PROMISE_ID] = lib$es6$promise$$internal$$nextId();
577 | this._result = this._state = undefined;
578 | this._subscribers = [];
579 |
580 | if (lib$es6$promise$$internal$$noop !== resolver) {
581 | typeof resolver !== 'function' && lib$es6$promise$promise$$needsResolver();
582 | this instanceof lib$es6$promise$promise$$Promise ? lib$es6$promise$$internal$$initializePromise(this, resolver) : lib$es6$promise$promise$$needsNew();
583 | }
584 | }
585 |
586 | lib$es6$promise$promise$$Promise.all = lib$es6$promise$promise$all$$default;
587 | lib$es6$promise$promise$$Promise.race = lib$es6$promise$promise$race$$default;
588 | lib$es6$promise$promise$$Promise.resolve = lib$es6$promise$promise$resolve$$default;
589 | lib$es6$promise$promise$$Promise.reject = lib$es6$promise$promise$reject$$default;
590 | lib$es6$promise$promise$$Promise._setScheduler = lib$es6$promise$asap$$setScheduler;
591 | lib$es6$promise$promise$$Promise._setAsap = lib$es6$promise$asap$$setAsap;
592 | lib$es6$promise$promise$$Promise._asap = lib$es6$promise$asap$$asap;
593 |
594 | lib$es6$promise$promise$$Promise.prototype = {
595 | constructor: lib$es6$promise$promise$$Promise,
596 |
597 | /**
598 | The primary way of interacting with a promise is through its `then` method,
599 | which registers callbacks to receive either a promise's eventual value or the
600 | reason why the promise cannot be fulfilled.
601 |
602 | ```js
603 | findUser().then(function(user){
604 | // user is available
605 | }, function(reason){
606 | // user is unavailable, and you are given the reason why
607 | });
608 | ```
609 |
610 | Chaining
611 | --------
612 |
613 | The return value of `then` is itself a promise. This second, 'downstream'
614 | promise is resolved with the return value of the first promise's fulfillment
615 | or rejection handler, or rejected if the handler throws an exception.
616 |
617 | ```js
618 | findUser().then(function (user) {
619 | return user.name;
620 | }, function (reason) {
621 | return 'default name';
622 | }).then(function (userName) {
623 | // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
624 | // will be `'default name'`
625 | });
626 |
627 | findUser().then(function (user) {
628 | throw new Error('Found user, but still unhappy');
629 | }, function (reason) {
630 | throw new Error('`findUser` rejected and we're unhappy');
631 | }).then(function (value) {
632 | // never reached
633 | }, function (reason) {
634 | // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
635 | // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
636 | });
637 | ```
638 | If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
639 |
640 | ```js
641 | findUser().then(function (user) {
642 | throw new PedagogicalException('Upstream error');
643 | }).then(function (value) {
644 | // never reached
645 | }).then(function (value) {
646 | // never reached
647 | }, function (reason) {
648 | // The `PedgagocialException` is propagated all the way down to here
649 | });
650 | ```
651 |
652 | Assimilation
653 | ------------
654 |
655 | Sometimes the value you want to propagate to a downstream promise can only be
656 | retrieved asynchronously. This can be achieved by returning a promise in the
657 | fulfillment or rejection handler. The downstream promise will then be pending
658 | until the returned promise is settled. This is called *assimilation*.
659 |
660 | ```js
661 | findUser().then(function (user) {
662 | return findCommentsByAuthor(user);
663 | }).then(function (comments) {
664 | // The user's comments are now available
665 | });
666 | ```
667 |
668 | If the assimliated promise rejects, then the downstream promise will also reject.
669 |
670 | ```js
671 | findUser().then(function (user) {
672 | return findCommentsByAuthor(user);
673 | }).then(function (comments) {
674 | // If `findCommentsByAuthor` fulfills, we'll have the value here
675 | }, function (reason) {
676 | // If `findCommentsByAuthor` rejects, we'll have the reason here
677 | });
678 | ```
679 |
680 | Simple Example
681 | --------------
682 |
683 | Synchronous Example
684 |
685 | ```javascript
686 | var result;
687 |
688 | try {
689 | result = findResult();
690 | // success
691 | } catch(reason) {
692 | // failure
693 | }
694 | ```
695 |
696 | Errback Example
697 |
698 | ```js
699 | findResult(function(result, err){
700 | if (err) {
701 | // failure
702 | } else {
703 | // success
704 | }
705 | });
706 | ```
707 |
708 | Promise Example;
709 |
710 | ```javascript
711 | findResult().then(function(result){
712 | // success
713 | }, function(reason){
714 | // failure
715 | });
716 | ```
717 |
718 | Advanced Example
719 | --------------
720 |
721 | Synchronous Example
722 |
723 | ```javascript
724 | var author, books;
725 |
726 | try {
727 | author = findAuthor();
728 | books = findBooksByAuthor(author);
729 | // success
730 | } catch(reason) {
731 | // failure
732 | }
733 | ```
734 |
735 | Errback Example
736 |
737 | ```js
738 |
739 | function foundBooks(books) {
740 |
741 | }
742 |
743 | function failure(reason) {
744 |
745 | }
746 |
747 | findAuthor(function(author, err){
748 | if (err) {
749 | failure(err);
750 | // failure
751 | } else {
752 | try {
753 | findBoooksByAuthor(author, function(books, err) {
754 | if (err) {
755 | failure(err);
756 | } else {
757 | try {
758 | foundBooks(books);
759 | } catch(reason) {
760 | failure(reason);
761 | }
762 | }
763 | });
764 | } catch(error) {
765 | failure(err);
766 | }
767 | // success
768 | }
769 | });
770 | ```
771 |
772 | Promise Example;
773 |
774 | ```javascript
775 | findAuthor().
776 | then(findBooksByAuthor).
777 | then(function(books){
778 | // found books
779 | }).catch(function(reason){
780 | // something went wrong
781 | });
782 | ```
783 |
784 | @method then
785 | @param {Function} onFulfilled
786 | @param {Function} onRejected
787 | Useful for tooling.
788 | @return {Promise}
789 | */
790 | then: lib$es6$promise$then$$default,
791 |
792 | /**
793 | `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
794 | as the catch block of a try/catch statement.
795 |
796 | ```js
797 | function findAuthor(){
798 | throw new Error('couldn't find that author');
799 | }
800 |
801 | // synchronous
802 | try {
803 | findAuthor();
804 | } catch(reason) {
805 | // something went wrong
806 | }
807 |
808 | // async with promises
809 | findAuthor().catch(function(reason){
810 | // something went wrong
811 | });
812 | ```
813 |
814 | @method catch
815 | @param {Function} onRejection
816 | Useful for tooling.
817 | @return {Promise}
818 | */
819 | 'catch': function(onRejection) {
820 | return this.then(null, onRejection);
821 | }
822 | };
823 | var lib$es6$promise$enumerator$$default = lib$es6$promise$enumerator$$Enumerator;
824 | function lib$es6$promise$enumerator$$Enumerator(Constructor, input) {
825 | this._instanceConstructor = Constructor;
826 | this.promise = new Constructor(lib$es6$promise$$internal$$noop);
827 |
828 | if (!this.promise[lib$es6$promise$$internal$$PROMISE_ID]) {
829 | lib$es6$promise$$internal$$makePromise(this.promise);
830 | }
831 |
832 | if (lib$es6$promise$utils$$isArray(input)) {
833 | this._input = input;
834 | this.length = input.length;
835 | this._remaining = input.length;
836 |
837 | this._result = new Array(this.length);
838 |
839 | if (this.length === 0) {
840 | lib$es6$promise$$internal$$fulfill(this.promise, this._result);
841 | } else {
842 | this.length = this.length || 0;
843 | this._enumerate();
844 | if (this._remaining === 0) {
845 | lib$es6$promise$$internal$$fulfill(this.promise, this._result);
846 | }
847 | }
848 | } else {
849 | lib$es6$promise$$internal$$reject(this.promise, lib$es6$promise$enumerator$$validationError());
850 | }
851 | }
852 |
853 | function lib$es6$promise$enumerator$$validationError() {
854 | return new Error('Array Methods must be provided an Array');
855 | }
856 |
857 | lib$es6$promise$enumerator$$Enumerator.prototype._enumerate = function() {
858 | var length = this.length;
859 | var input = this._input;
860 |
861 | for (var i = 0; this._state === lib$es6$promise$$internal$$PENDING && i < length; i++) {
862 | this._eachEntry(input[i], i);
863 | }
864 | };
865 |
866 | lib$es6$promise$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) {
867 | var c = this._instanceConstructor;
868 | var resolve = c.resolve;
869 |
870 | if (resolve === lib$es6$promise$promise$resolve$$default) {
871 | var then = lib$es6$promise$$internal$$getThen(entry);
872 |
873 | if (then === lib$es6$promise$then$$default &&
874 | entry._state !== lib$es6$promise$$internal$$PENDING) {
875 | this._settledAt(entry._state, i, entry._result);
876 | } else if (typeof then !== 'function') {
877 | this._remaining--;
878 | this._result[i] = entry;
879 | } else if (c === lib$es6$promise$promise$$default) {
880 | var promise = new c(lib$es6$promise$$internal$$noop);
881 | lib$es6$promise$$internal$$handleMaybeThenable(promise, entry, then);
882 | this._willSettleAt(promise, i);
883 | } else {
884 | this._willSettleAt(new c(function(resolve) { resolve(entry); }), i);
885 | }
886 | } else {
887 | this._willSettleAt(resolve(entry), i);
888 | }
889 | };
890 |
891 | lib$es6$promise$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) {
892 | var promise = this.promise;
893 |
894 | if (promise._state === lib$es6$promise$$internal$$PENDING) {
895 | this._remaining--;
896 |
897 | if (state === lib$es6$promise$$internal$$REJECTED) {
898 | lib$es6$promise$$internal$$reject(promise, value);
899 | } else {
900 | this._result[i] = value;
901 | }
902 | }
903 |
904 | if (this._remaining === 0) {
905 | lib$es6$promise$$internal$$fulfill(promise, this._result);
906 | }
907 | };
908 |
909 | lib$es6$promise$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) {
910 | var enumerator = this;
911 |
912 | lib$es6$promise$$internal$$subscribe(promise, undefined, function(value) {
913 | enumerator._settledAt(lib$es6$promise$$internal$$FULFILLED, i, value);
914 | }, function(reason) {
915 | enumerator._settledAt(lib$es6$promise$$internal$$REJECTED, i, reason);
916 | });
917 | };
918 | function lib$es6$promise$polyfill$$polyfill() {
919 | var local;
920 |
921 | if (typeof global !== 'undefined') {
922 | local = global;
923 | } else if (typeof self !== 'undefined') {
924 | local = self;
925 | } else {
926 | try {
927 | local = Function('return this')();
928 | } catch (e) {
929 | throw new Error('polyfill failed because global object is unavailable in this environment');
930 | }
931 | }
932 |
933 | var P = local.Promise;
934 |
935 | if (P && Object.prototype.toString.call(P.resolve()) === '[object Promise]' && !P.cast) {
936 | return;
937 | }
938 |
939 | local.Promise = lib$es6$promise$promise$$default;
940 | }
941 | var lib$es6$promise$polyfill$$default = lib$es6$promise$polyfill$$polyfill;
942 |
943 | lib$es6$promise$promise$$default.Promise = lib$es6$promise$promise$$default;
944 | lib$es6$promise$promise$$default.polyfill = lib$es6$promise$polyfill$$default;
945 |
946 | /* global define:true module:true window: true */
947 | if (typeof define === 'function' && define['amd']) {
948 | define(function() { return lib$es6$promise$promise$$default; });
949 | } else if (typeof module !== 'undefined' && module['exports']) {
950 | module['exports'] = lib$es6$promise$promise$$default;
951 | } else if (typeof this !== 'undefined') {
952 | this['Promise'] = lib$es6$promise$promise$$default;
953 | }
954 |
955 | lib$es6$promise$polyfill$$default();
956 | }).call(this);
957 |
--------------------------------------------------------------------------------
/src/libs/image-compress.js:
--------------------------------------------------------------------------------
1 | function imageComporess (file, quality, callback) {
2 |
3 | }
4 |
--------------------------------------------------------------------------------
/src/libs/init.js:
--------------------------------------------------------------------------------
1 | // init
2 | window.URL = window.URL || window.webkitURL
3 |
4 | function isCanvasBlank (canvas) {
5 | var blank = document.createElement('canvas')
6 | blank.width = canvas.width
7 | blank.height = canvas.height
8 |
9 | return canvas.toDataURL() == blank.toDataURL()
10 | }
11 |
12 | function newBlob (data, datatype) {
13 | var out
14 | try {
15 | out = new Blob([data], { type: datatype })
16 | } catch (e) {
17 | window.BlobBuilder = window.BlobBuilder ||
18 | window.WebKitBlobBuilder ||
19 | window.MozBlobBuilder ||
20 | window.MSBlobBuilder
21 |
22 | if (e.name == 'TypeError' && window.BlobBuilder) {
23 | var bb = new BlobBuilder()
24 | bb.append(data)
25 | out = bb.getBlob(datatype)
26 | } else if (e.name == 'InvalidStateError') {
27 | out = new Blob([data], { type: datatype })
28 | } else {
29 | throw new Error('Your browser does not support Blob & BlobBuilder!')
30 | }
31 | }
32 | return out
33 | }
34 |
35 | function dataURL2Blob (dataURI) {
36 | var byteStr
37 | var intArray
38 | var ab
39 | var i
40 | var mimetype
41 | var parts
42 |
43 | parts = dataURI.split(',')
44 | parts[1] = parts[1].replace(/\s/g, '')
45 |
46 | if (~parts[0].indexOf('base64')) {
47 | byteStr = atob(parts[1])
48 | } else {
49 | byteStr = decodeURIComponent(parts[1])
50 | }
51 |
52 | ab = new ArrayBuffer(byteStr.length)
53 | intArray = new Uint8Array(ab)
54 |
55 | for (i = 0; i < byteStr.length; i++) {
56 | intArray[i] = byteStr.charCodeAt(i)
57 | }
58 |
59 | mimetype = parts[0].split(':')[1].split(';')[0]
60 |
61 | return new newBlob(ab, mimetype)
62 | }
63 |
64 | function string2ArrayBuffer (string) {
65 | var bytes = Array.prototype.map.call(string, function (c) {
66 | return c.charCodeAt(0) & 0xff
67 | })
68 | return new Uint8Array(bytes).buffer
69 | }
70 |
71 | function getFile (url, callback) {
72 | var obj = new XMLHttpRequest()
73 | obj.open('HEAD', url, true)
74 | obj.onreadystatechange = function () {
75 | if (obj.readyState == 4) {
76 | if (obj.status == 200) {
77 | callback && callback(null, {
78 | contentLength: obj.getResponseHeader('Content-Length'),
79 | contentType: obj.getResponseHeader('Content-Type')
80 | })
81 | } else {
82 | callback && callback(new Error('Load error'))
83 | }
84 | }
85 | }
86 | obj.send(null)
87 | }
88 |
--------------------------------------------------------------------------------
/src/libs/whatwg-fetch.js:
--------------------------------------------------------------------------------
1 | (function(self) {
2 | 'use strict';
3 |
4 | if (self.fetch) {
5 | return
6 | }
7 |
8 | var support = {
9 | searchParams: 'URLSearchParams' in self,
10 | iterable: 'Symbol' in self && 'iterator' in Symbol,
11 | blob: 'FileReader' in self && 'Blob' in self && (function() {
12 | try {
13 | new Blob()
14 | return true
15 | } catch(e) {
16 | return false
17 | }
18 | })(),
19 | formData: 'FormData' in self,
20 | arrayBuffer: 'ArrayBuffer' in self
21 | }
22 |
23 | function normalizeName(name) {
24 | if (typeof name !== 'string') {
25 | name = String(name)
26 | }
27 | if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) {
28 | throw new TypeError('Invalid character in header field name')
29 | }
30 | return name.toLowerCase()
31 | }
32 |
33 | function normalizeValue(value) {
34 | if (typeof value !== 'string') {
35 | value = String(value)
36 | }
37 | return value
38 | }
39 |
40 | // Build a destructive iterator for the value list
41 | function iteratorFor(items) {
42 | var iterator = {
43 | next: function() {
44 | var value = items.shift()
45 | return {done: value === undefined, value: value}
46 | }
47 | }
48 |
49 | if (support.iterable) {
50 | iterator[Symbol.iterator] = function() {
51 | return iterator
52 | }
53 | }
54 |
55 | return iterator
56 | }
57 |
58 | function Headers(headers) {
59 | this.map = {}
60 |
61 | if (headers instanceof Headers) {
62 | headers.forEach(function(value, name) {
63 | this.append(name, value)
64 | }, this)
65 |
66 | } else if (headers) {
67 | Object.getOwnPropertyNames(headers).forEach(function(name) {
68 | this.append(name, headers[name])
69 | }, this)
70 | }
71 | }
72 |
73 | Headers.prototype.append = function(name, value) {
74 | name = normalizeName(name)
75 | value = normalizeValue(value)
76 | var list = this.map[name]
77 | if (!list) {
78 | list = []
79 | this.map[name] = list
80 | }
81 | list.push(value)
82 | }
83 |
84 | Headers.prototype['delete'] = function(name) {
85 | delete this.map[normalizeName(name)]
86 | }
87 |
88 | Headers.prototype.get = function(name) {
89 | var values = this.map[normalizeName(name)]
90 | return values ? values[0] : null
91 | }
92 |
93 | Headers.prototype.getAll = function(name) {
94 | return this.map[normalizeName(name)] || []
95 | }
96 |
97 | Headers.prototype.has = function(name) {
98 | return this.map.hasOwnProperty(normalizeName(name))
99 | }
100 |
101 | Headers.prototype.set = function(name, value) {
102 | this.map[normalizeName(name)] = [normalizeValue(value)]
103 | }
104 |
105 | Headers.prototype.forEach = function(callback, thisArg) {
106 | Object.getOwnPropertyNames(this.map).forEach(function(name) {
107 | this.map[name].forEach(function(value) {
108 | callback.call(thisArg, value, name, this)
109 | }, this)
110 | }, this)
111 | }
112 |
113 | Headers.prototype.keys = function() {
114 | var items = []
115 | this.forEach(function(value, name) { items.push(name) })
116 | return iteratorFor(items)
117 | }
118 |
119 | Headers.prototype.values = function() {
120 | var items = []
121 | this.forEach(function(value) { items.push(value) })
122 | return iteratorFor(items)
123 | }
124 |
125 | Headers.prototype.entries = function() {
126 | var items = []
127 | this.forEach(function(value, name) { items.push([name, value]) })
128 | return iteratorFor(items)
129 | }
130 |
131 | if (support.iterable) {
132 | Headers.prototype[Symbol.iterator] = Headers.prototype.entries
133 | }
134 |
135 | function consumed(body) {
136 | if (body.bodyUsed) {
137 | return Promise.reject(new TypeError('Already read'))
138 | }
139 | body.bodyUsed = true
140 | }
141 |
142 | function fileReaderReady(reader) {
143 | return new Promise(function(resolve, reject) {
144 | reader.onload = function() {
145 | resolve(reader.result)
146 | }
147 | reader.onerror = function() {
148 | reject(reader.error)
149 | }
150 | })
151 | }
152 |
153 | function readBlobAsArrayBuffer(blob) {
154 | var reader = new FileReader()
155 | reader.readAsArrayBuffer(blob)
156 | return fileReaderReady(reader)
157 | }
158 |
159 | function readBlobAsText(blob) {
160 | var reader = new FileReader()
161 | reader.readAsText(blob)
162 | return fileReaderReady(reader)
163 | }
164 |
165 | function Body() {
166 | this.bodyUsed = false
167 |
168 | this._initBody = function(body) {
169 | this._bodyInit = body
170 | if (typeof body === 'string') {
171 | this._bodyText = body
172 | } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
173 | this._bodyBlob = body
174 | } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
175 | this._bodyFormData = body
176 | } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
177 | this._bodyText = body.toString()
178 | } else if (!body) {
179 | this._bodyText = ''
180 | } else if (support.arrayBuffer && ArrayBuffer.prototype.isPrototypeOf(body)) {
181 | // Only support ArrayBuffers for POST method.
182 | // Receiving ArrayBuffers happens via Blobs, instead.
183 | } else {
184 | throw new Error('unsupported BodyInit type')
185 | }
186 |
187 | if (!this.headers.get('content-type')) {
188 | if (typeof body === 'string') {
189 | this.headers.set('content-type', 'text/plain;charset=UTF-8')
190 | } else if (this._bodyBlob && this._bodyBlob.type) {
191 | this.headers.set('content-type', this._bodyBlob.type)
192 | } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
193 | this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')
194 | }
195 | }
196 | }
197 |
198 | if (support.blob) {
199 | this.blob = function() {
200 | var rejected = consumed(this)
201 | if (rejected) {
202 | return rejected
203 | }
204 |
205 | if (this._bodyBlob) {
206 | return Promise.resolve(this._bodyBlob)
207 | } else if (this._bodyFormData) {
208 | throw new Error('could not read FormData body as blob')
209 | } else {
210 | return Promise.resolve(new Blob([this._bodyText]))
211 | }
212 | }
213 |
214 | this.arrayBuffer = function() {
215 | return this.blob().then(readBlobAsArrayBuffer)
216 | }
217 |
218 | this.text = function() {
219 | var rejected = consumed(this)
220 | if (rejected) {
221 | return rejected
222 | }
223 |
224 | if (this._bodyBlob) {
225 | return readBlobAsText(this._bodyBlob)
226 | } else if (this._bodyFormData) {
227 | throw new Error('could not read FormData body as text')
228 | } else {
229 | return Promise.resolve(this._bodyText)
230 | }
231 | }
232 | } else {
233 | this.text = function() {
234 | var rejected = consumed(this)
235 | return rejected ? rejected : Promise.resolve(this._bodyText)
236 | }
237 | }
238 |
239 | if (support.formData) {
240 | this.formData = function() {
241 | return this.text().then(decode)
242 | }
243 | }
244 |
245 | this.json = function() {
246 | return this.text().then(JSON.parse)
247 | }
248 |
249 | return this
250 | }
251 |
252 | // HTTP methods whose capitalization should be normalized
253 | var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']
254 |
255 | function normalizeMethod(method) {
256 | var upcased = method.toUpperCase()
257 | return (methods.indexOf(upcased) > -1) ? upcased : method
258 | }
259 |
260 | function Request(input, options) {
261 | options = options || {}
262 | var body = options.body
263 | if (Request.prototype.isPrototypeOf(input)) {
264 | if (input.bodyUsed) {
265 | throw new TypeError('Already read')
266 | }
267 | this.url = input.url
268 | this.credentials = input.credentials
269 | if (!options.headers) {
270 | this.headers = new Headers(input.headers)
271 | }
272 | this.method = input.method
273 | this.mode = input.mode
274 | if (!body) {
275 | body = input._bodyInit
276 | input.bodyUsed = true
277 | }
278 | } else {
279 | this.url = input
280 | }
281 |
282 | this.credentials = options.credentials || this.credentials || 'omit'
283 | if (options.headers || !this.headers) {
284 | this.headers = new Headers(options.headers)
285 | }
286 | this.method = normalizeMethod(options.method || this.method || 'GET')
287 | this.mode = options.mode || this.mode || null
288 | this.referrer = null
289 |
290 | if ((this.method === 'GET' || this.method === 'HEAD') && body) {
291 | throw new TypeError('Body not allowed for GET or HEAD requests')
292 | }
293 | this._initBody(body)
294 | }
295 |
296 | Request.prototype.clone = function() {
297 | return new Request(this)
298 | }
299 |
300 | function decode(body) {
301 | var form = new FormData()
302 | body.trim().split('&').forEach(function(bytes) {
303 | if (bytes) {
304 | var split = bytes.split('=')
305 | var name = split.shift().replace(/\+/g, ' ')
306 | var value = split.join('=').replace(/\+/g, ' ')
307 | form.append(decodeURIComponent(name), decodeURIComponent(value))
308 | }
309 | })
310 | return form
311 | }
312 |
313 | function headers(xhr) {
314 | var head = new Headers()
315 | var pairs = (xhr.getAllResponseHeaders() || '').trim().split('\n')
316 | pairs.forEach(function(header) {
317 | var split = header.trim().split(':')
318 | var key = split.shift().trim()
319 | var value = split.join(':').trim()
320 | head.append(key, value)
321 | })
322 | return head
323 | }
324 |
325 | Body.call(Request.prototype)
326 |
327 | function Response(bodyInit, options) {
328 | if (!options) {
329 | options = {}
330 | }
331 |
332 | this.type = 'default'
333 | this.status = options.status
334 | this.ok = this.status >= 200 && this.status < 300
335 | this.statusText = options.statusText
336 | this.headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers)
337 | this.url = options.url || ''
338 | this._initBody(bodyInit)
339 | }
340 |
341 | Body.call(Response.prototype)
342 |
343 | Response.prototype.clone = function() {
344 | return new Response(this._bodyInit, {
345 | status: this.status,
346 | statusText: this.statusText,
347 | headers: new Headers(this.headers),
348 | url: this.url
349 | })
350 | }
351 |
352 | Response.error = function() {
353 | var response = new Response(null, {status: 0, statusText: ''})
354 | response.type = 'error'
355 | return response
356 | }
357 |
358 | var redirectStatuses = [301, 302, 303, 307, 308]
359 |
360 | Response.redirect = function(url, status) {
361 | if (redirectStatuses.indexOf(status) === -1) {
362 | throw new RangeError('Invalid status code')
363 | }
364 |
365 | return new Response(null, {status: status, headers: {location: url}})
366 | }
367 |
368 | self.Headers = Headers
369 | self.Request = Request
370 | self.Response = Response
371 |
372 | self.fetch = function(input, init) {
373 | return new Promise(function(resolve, reject) {
374 | var request
375 | if (Request.prototype.isPrototypeOf(input) && !init) {
376 | request = input
377 | } else {
378 | request = new Request(input, init)
379 | }
380 |
381 | var xhr = new XMLHttpRequest()
382 |
383 | function responseURL() {
384 | if ('responseURL' in xhr) {
385 | return xhr.responseURL
386 | }
387 |
388 | // Avoid security warnings on getResponseHeader when not allowed by CORS
389 | if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {
390 | return xhr.getResponseHeader('X-Request-URL')
391 | }
392 |
393 | return
394 | }
395 |
396 | xhr.onload = function() {
397 | var options = {
398 | status: xhr.status,
399 | statusText: xhr.statusText,
400 | headers: headers(xhr),
401 | url: responseURL()
402 | }
403 | var body = 'response' in xhr ? xhr.response : xhr.responseText
404 | resolve(new Response(body, options))
405 | }
406 |
407 | xhr.onerror = function() {
408 | reject(new TypeError('Network request failed'))
409 | }
410 |
411 | xhr.ontimeout = function() {
412 | reject(new TypeError('Network request failed'))
413 | }
414 |
415 | xhr.open(request.method, request.url, true)
416 |
417 | if (request.credentials === 'include') {
418 | xhr.withCredentials = true
419 | }
420 |
421 | if ('responseType' in xhr && support.blob) {
422 | xhr.responseType = 'blob'
423 | }
424 |
425 | request.headers.forEach(function(value, name) {
426 | xhr.setRequestHeader(name, value)
427 | })
428 |
429 | xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)
430 | })
431 | }
432 | self.fetch.polyfill = true
433 | })(typeof self !== 'undefined' ? self : this);
434 |
--------------------------------------------------------------------------------
/src/upload-blob-fetch.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade254353074/image-compress/a899541c578b03805e5ff49fa32c84db4af96f0b/src/upload-blob-fetch.html
--------------------------------------------------------------------------------
/src/upload-blob-jQuery.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade254353074/image-compress/a899541c578b03805e5ff49fa32c84db4af96f0b/src/upload-blob-jQuery.html
--------------------------------------------------------------------------------
/src/upload-blob-xhr.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade254353074/image-compress/a899541c578b03805e5ff49fa32c84db4af96f0b/src/upload-blob-xhr.html
--------------------------------------------------------------------------------
/src/upload-blob-zepto.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/blade254353074/image-compress/a899541c578b03805e5ff49fa32c84db4af96f0b/src/upload-blob-zepto.html
--------------------------------------------------------------------------------