├── .gitignore
├── .npmignore
├── .travis.yml
├── CONTRIBUTING.md
├── MIT-LICENSE
├── README.md
├── examples
    ├── anim.html
    ├── iphone
    │   ├── index.html
    │   └── iphone.css
    ├── load_jquery_on_ie.html
    ├── snow
    │   └── index.html
    └── touch_events.html
├── make
├── package-lock.json
├── package.json
├── script
    ├── bootstrap
    ├── guard
    ├── lint
    └── test
├── src
    ├── ajax.js
    ├── amd_layout.js
    ├── assets.js
    ├── callbacks.js
    ├── data.js
    ├── deferred.js
    ├── detect.js
    ├── event.js
    ├── form.js
    ├── fx.js
    ├── fx_methods.js
    ├── gesture.js
    ├── ie.js
    ├── ios3.js
    ├── selector.js
    ├── stack.js
    ├── touch.js
    └── zepto.js
├── test
    ├── ajax.html
    ├── ajax_deferred.html
    ├── callbacks.html
    ├── data.html
    ├── deferred.html
    ├── detect.html
    ├── event.html
    ├── evidence_runner.js
    ├── fixtures
    │   ├── ajax_load_javascript.js
    │   ├── ajax_load_selector.html
    │   ├── ajax_load_selector_javascript.html
    │   ├── ajax_load_simple.html
    │   ├── iframe_document.html
    │   └── zepto.json
    ├── form.html
    ├── functional
    │   ├── assets.html
    │   ├── fx.html
    │   ├── gesture.html
    │   ├── touch.html
    │   └── touchcancel.html
    ├── fx.html
    ├── ie.html
    ├── index.html
    ├── ios3.html
    ├── runner.js
    ├── selector.html
    ├── server.coffee
    ├── stack.html
    ├── test.css
    ├── touch.html
    └── zepto.html
└── vendor
    └── evidence.js


/.gitignore:
--------------------------------------------------------------------------------
 1 | .DS_Store
 2 | dist/
 3 | dist/zepto.min.js
 4 | dist/zepto.js
 5 | pkg
 6 | *.swp
 7 | docs/*
 8 | .jhw-cache
 9 | .rbenv-version
10 | public
11 | node_modules
12 | temp/
13 | npm-debug.log


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | *
2 | !README.md
3 | !MIT-LICENSE
4 | !dist/zepto.js
5 | !dist/zepto.min.js
6 | !src/*.js
7 | src/amd_layout.js
8 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: node_js
 2 | 
 3 | node_js: '0.10'
 4 | 
 5 | sudo: false
 6 | 
 7 | script: script/test
 8 | 
 9 | notifications:
10 |   campfire:
11 |     template: '%{message} [%{branch}] %{repository}/%{commit} %{author} %{build_url}'
12 |     rooms:
13 |       secure: VR6rWk0YhezBWnD8jPjSD8h/Q83S3NT0F34Au1vswt+/+Ku19S8X44vGVUG+NYdYyhg7uOqUaPN1Jr3KCpdcXgHEpUYiyBGJ8ebltavcjeHYWqK6ghcqgSnbDkifuC7Eu/9LcrOMOXgt+zkXjiVXW3+zyGVDcrs4cQ2vGY2DTYA=
14 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | ## Contributing to Zepto
 2 | 
 3 | **Thanks for helping out!**
 4 | 
 5 | In order for your code to make it in, several conditions must be met:
 6 | 
 7 | * It's more likely your pull request will make it in if you adhere to **Zepto's
 8 |   project goals**. Be sure to read the README in its entirety before setting out
 9 |   to code.
10 | * Please talk to the maintainers (@madrobby and @mislav) first if you want
11 |   to write a plugin, those are better kept in their own repositories.
12 | * Fix only ONE thing or have only ONE feature in your pull request. 
13 |   If you have multiple unrelated code updates, please submit a separate pull request for each one.
14 | * **Your pull request must be written in English and be accompanied by a
15 |   detailed description**, ideally something we can use as documentation.
16 |   If you're not fluent in English, try your best and let us know so we'll help!
17 | * Changes to jQuery-based API methods **must match their jQuery counterparts**.
18 | * Please **do not just copy code from jQuery**. Zepto strives for API compatibility,
19 |   but has different goals for code style and size and target platforms.
20 |   In case you do copy code, you must clearly indicate the origin of the code, and
21 |   which license applies to it. However, it is likely your patch will be denied.
22 | * **All code must have tests, and all tests must pass.** See the README on running the test suite.
23 | * Please **also test manually** on as many target platforms you have access to,
24 |   but at least on latest Chrome (desktop) and Firefox (desktop).
25 |   See http://zeptojs.com for a full list of platforms.
26 | * It's required that you follow Zepto's **code style guidelines** (see below)
27 | 
28 | Whew, now that we have that out of the way thanks again!
29 | 
30 | ## Code style guidelines
31 | 
32 | * Two spaces "soft tabs" indentation
33 | * Remove any trailing whitespace from the end of lines
34 | * `function name() { }` for named functions
35 | * `function(){ }` for anonymous functions
36 | * No curly braces for single-line control flow statements such as `if` & friends
37 | * Don't write [semicolons that are optional][optional]
38 | * Put a single semicolon _before_ statements that start with `(` or `[`
39 |   (see above article as for why it's needed)
40 | * Use long, descriptive variable and method names
41 | * Use blank lines to separate "paragraphs" of code for readability
42 | * Use comments to describe non-obvious code behavior
43 | 
44 | 
45 |   [optional]: http://mislav.uniqpath.com/2010/05/semicolons/
46 | 


--------------------------------------------------------------------------------
/MIT-LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2010-2019 Thomas Fuchs
 2 | http://zeptojs.com/
 3 | 
 4 | Permission is hereby granted, free of charge, to any person obtaining
 5 | a copy of this software and associated documentation files (the
 6 | "Software"), to deal in the Software without restriction, including
 7 | without limitation the rights to use, copy, modify, merge, publish,
 8 | distribute, sublicense, and/or sell copies of the Software, and to
 9 | permit persons to whom the Software is furnished to do so, subject to
10 | the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be
13 | included in all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
19 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
20 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Zepto.js – a minimalist JavaScript library
  2 | 
  3 | Zepto is a minimalist JavaScript library for modern browsers with a
  4 | largely jQuery-compatible API. If you use jQuery, you already know how to use Zepto.
  5 | 
  6 | See [zeptojs.com][] for an extended introduction, downloads
  7 | and documentation.
  8 | 
  9 | Zepto.js is licensed under the terms of the MIT License.
 10 | 
 11 | Want to give us money or a tip? Don't.
 12 | Instead please donate to [charity: water](http://charitywater.org/).
 13 | 
 14 | ## Building
 15 | 
 16 | [![Build Status](https://secure.travis-ci.org/madrobby/zepto.svg?branch=master)](http://travis-ci.org/madrobby/zepto)
 17 | 
 18 | The official site offers a download of the default distribution of Zepto. This
 19 | is good for starting out. However, at some point you might want to add some
 20 | optional modules and remove some of the default ones you don't need, to keep the
 21 | size at a minimum. That's when you need to check out Zepto's source code and use
 22 | the build commands.
 23 | 
 24 | You will need Node.js installed on your system.
 25 | 
 26 | ~~~ sh
 27 | $ npm install
 28 | $ npm run-script dist
 29 | 
 30 | # do a custom build
 31 | $ MODULES="zepto event data" npm run-script dist
 32 | 
 33 | # on Windows
 34 | c:\zepto> SET MODULES=zepto event data
 35 | c:\zepto> npm run-script dist
 36 | ~~~
 37 | 
 38 | The resulting files are:
 39 | 
 40 | 1. `dist/zepto.js`
 41 | 2. `dist/zepto.min.js`
 42 | 
 43 | If you install CoffeeScript globally, you can run `make` directly:
 44 | 
 45 | ~~~ sh
 46 | # one-time operation
 47 | $ npm install coffee-script --global
 48 | 
 49 | $ coffee make dist
 50 | $ MODULES="zepto event data ..." ./make dist
 51 | 
 52 | # on Windows
 53 | c:\zepto> SET MODULES=zepto event data
 54 | c:\zepto> coffee make dist
 55 | ~~~
 56 | 
 57 | ## Zepto modules
 58 | 
 59 | Zepto modules are individual files in the "src/" directory.
 60 | 
 61 | <table>
 62 | <thead><tr>
 63 |   <th>module</th> <th>default</th> <th>description</th>
 64 | </tr></thead>
 65 | <tbody>
 66 |   <tr>
 67 |     <th><a href="src/zepto.js#files">zepto</a></th>
 68 |     <td>✔</td>
 69 |     <td>Core module; contains most methods</td>
 70 |   </tr>
 71 |   <tr>
 72 |     <th><a href="src/event.js#files">event</a></th>
 73 |     <td>✔</td>
 74 |     <td>Event handling via <code>on()</code> &amp; <code>off()</code></td>
 75 |   </tr>
 76 |   <tr>
 77 |     <th><a href="src/ajax.js#files">ajax</a></th>
 78 |     <td>✔</td>
 79 |     <td>XMLHttpRequest and JSONP functionality</td>
 80 |   </tr>
 81 |   <tr>
 82 |     <th><a href="src/form.js#files">form</a></th>
 83 |     <td>✔</td>
 84 |     <td>Serialize &amp; submit web forms</td>
 85 |   </tr>
 86 |   <tr>
 87 |     <th><a href="src/ie.js#files">ie</a></th>
 88 |     <td>✔</td>
 89 |     <td>Support for Internet Explorer 10+ on the desktop and Windows Phone 8</td>
 90 |   </tr>
 91 |   <tr>
 92 |     <th><a href="src/detect.js#files">detect</a></th>
 93 |     <td></td>
 94 |     <td>Provides <code>$.os</code> and <code>$.browser</code> information</td>
 95 |   </tr>
 96 |   <tr>
 97 |     <th><a href="src/fx.js#files">fx</a></th>
 98 |     <td></td>
 99 |     <td>The <code>animate()</code> method</td>
100 |   </tr>
101 |   <tr>
102 |     <th><a href="src/fx_methods.js#files">fx_methods</a></th>
103 |     <td></td>
104 |     <td>
105 |       Animated <code>show</code>, <code>hide</code>, <code>toggle</code>,
106 |       and <code>fade*()</code> methods.
107 |     </td>
108 |   </tr>
109 |   <tr>
110 |     <th><a href="src/assets.js#files">assets</a></th>
111 |     <td></td>
112 |     <td>
113 |       Experimental support for cleaning up iOS memory after removing
114 |       image elements from the DOM.
115 |     </td>
116 |   </tr>
117 |   <tr>
118 |     <th><a href="src/data.js#files">data</a></th>
119 |     <td></td>
120 |     <td>
121 |       A full-blown <code>data()</code> method, capable of storing arbitrary
122 |       objects in memory.
123 |     </td>
124 |   </tr>
125 |   <tr>
126 |     <th><a href="src/deferred.js#files">deferred</a></th>
127 |     <td></td>
128 |     <td>
129 |       Provides <code>$.Deferred</code> promises API.
130 |       Depends on the "callbacks" module.
131 |     </td>
132 |   </tr>
133 |   <tr>
134 |     <th><a href="src/callbacks.js#files">callbacks</a></th>
135 |     <td></td>
136 |     <td>
137 |       Provides <code>$.Callbacks</code> for use in "deferred" module.
138 |     </td>
139 |   </tr>
140 |   <tr>
141 |     <th><a href="src/selector.js#files">selector</a></th>
142 |     <td></td>
143 |     <td>
144 |       Experimental <a href="http://api.jquery.com/category/selectors/jquery-selector-extensions/">jQuery
145 |       CSS extensions</a> support for functionality such as <code>$('div:first')</code> and
146 |       <code>el.is(':visible')</code>.
147 |     </td>
148 |   </tr>
149 |   <tr>
150 |     <th><a href="src/touch.js#files">touch</a></th>
151 |     <td></td>
152 |     <td>
153 |       Fires tap– and swipe–related events on touch devices. This works with both
154 |       `touch` (iOS, Android) and `pointer` events (Windows Phone).
155 |     </td>
156 |   </tr>
157 |   <tr>
158 |     <th><a href="src/gesture.js#files">gesture</a></th>
159 |     <td></td>
160 |     <td>Fires pinch gesture events on touch devices</td>
161 |   </tr>
162 |   <tr>
163 |     <th><a href="src/stack.js#files">stack</a></th>
164 |     <td></td>
165 |     <td>Provides <code>andSelf</code> &amp; <code>end()</code> chaining methods</td>
166 |   </tr>
167 |   <tr>
168 |     <th><a href="src/ios3.js#files">ios3</a></th>
169 |     <td></td>
170 |     <td>
171 |       String.prototype.trim and Array.prototype.reduce methods
172 |       (if they are missing) for compatibility with iOS 3.x.
173 |     </td>
174 |   </tr>
175 | </tbody>
176 | </table>
177 | 
178 | ## Contributing
179 | 
180 | Please read our [contribution guidelines](https://github.com/madrobby/zepto/blob/master/CONTRIBUTING.md)
181 | for information on how to contribute.
182 | 
183 | Get in touch:
184 | 
185 | * @[zeptojs](http://twitter.com/zeptojs)
186 | 
187 | ### Write documentation
188 | 
189 | Zepto docs are written in Markdown and live in the ["gh-pages" branch][docs].
190 | They are published on [zeptojs.com][zeptojs.com].
191 | 
192 | You can use GitHub's web interface to make quick changes to documentation for
193 | specific Zepto features
194 | ([example: ajaxSettings](https://github.com/madrobby/zepto/blob/gh-pages/ajax/_posts/1900-01-01-Z-ajaxSettings.md)).
195 | This will submit a pull request to us that we can review.
196 | 
197 | ### Report a bug
198 | 
199 | 1. Check if the bug is already fixed in the master branch since the last release.
200 | 2. Check [existing issues][issues]. Open a new one, including exact browser &
201 |    platform information. For better formatting of your report, see
202 |    [GitHub-flavored Markdown][mkd].
203 | 
204 | ### Running tests
205 | 
206 | You will need to install [PhantomJS][phantomjs]. On OS X, that's easy:
207 | 
208 | ~~~ sh
209 | $ brew install phantomjs
210 | ~~~
211 | 
212 | To run the automated tests:
213 | 
214 | ~~~ sh
215 | $ npm test
216 | ~~~
217 | 
218 | To run a test server, which you can hit with your browsers and devices:
219 | 
220 | ~~~ sh
221 | $ npm start
222 | ~~~
223 | 
224 | Go to `http://your-ip-address:3000/` on your browser and follow the
225 | instructions. For your convenience test failures and exceptions will be
226 | reported to the the console you started the test server in (as well as
227 | the browser console if available).
228 | 
229 |   [zeptojs.com]: http://zeptojs.com
230 |   [issues]: https://github.com/madrobby/zepto/issues
231 |   [docs]: https://github.com/madrobby/zepto/tree/gh-pages#readme
232 |   [mkd]: https://help.github.com/articles/creating-and-highlighting-code-blocks/
233 |   [evidence.js]: https://github.com/tobie/Evidence
234 |   [phantomjs]: http://phantomjs.org/download.html
235 | 


--------------------------------------------------------------------------------
/examples/anim.html:
--------------------------------------------------------------------------------
 1 | <div style="width:100px;height:100px;border:1px solid black">HELLO WORLD</div>
 2 | 
 3 | <script src="../src/zepto.js"></script>
 4 | <script src="../src/event.js"></script>
 5 | <script src="../src/fx.js"></script>
 6 | 
 7 | <script>
 8 |   $('div').anim({ rotate: '720deg', opacity: .5 }, 2, 'ease-out')
 9 | </script>
10 | 


--------------------------------------------------------------------------------
/examples/iphone/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |     <head>
 4 |       <title>iPhone.Zepto</title>
 5 |       <link href="iphone.css" media="screen" rel="stylesheet" type="text/css" />
 6 |       <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0"/>
 7 |       <meta name="apple-mobile-web-app-capable" content="yes" />
 8 |       <meta name="format-detection" content="telephone=no" />
 9 |     </head>
10 |     <body>
11 |       <section id="menu">
12 |         <div class="toolbar">
13 |           <h1>Title</h1>
14 |         </div>
15 |         <ul class="menu">
16 |           <li class="arrow"><a href="#menu_1">Menu 1</a></li>
17 |           <li>Menu 1</li>
18 |           <li>Menu 1</li>
19 |           <li>Menu 1</li>
20 |           <li>Menu 1</li>
21 |         </ul>
22 |       </section>
23 |       <section id="menu_1">
24 |         <div class="toolbar">
25 |           <h1>Menu 1</h1>
26 |         </div>
27 |         <ul class="menu">
28 |           <li>SubMenu 1</li>
29 |           <li>SubMenu 2</li>
30 |         </ul>
31 |       </section>
32 |       <script src="../../src/zepto.js"></script>
33 |       <script src="../../src/event.js"></script>
34 |       <script src="../../src/touch.js"></script>
35 |       <script>
36 |         $(document).ready(function(){
37 |           var activate = ('createTouch' in document) ? 'touchstart' : 'click'
38 | 
39 |           $("body > section").first().addClass("current")
40 | 
41 |           $("a.back").live(activate, function(event) {
42 |             var current = $(this).attr("href")
43 |             $(".current").removeClass("current").addClass("reverse")
44 |             $(current).addClass("current")
45 |           })
46 | 
47 |           $(".menu a[href]").live(activate, function(event) {
48 |             var link = $(this), section = link.closest('section'),
49 |               prev_element = "#"+(section.removeClass("current").addClass("reverse").attr("id"))
50 |             $(link.attr("href")).addClass("current")
51 |             $(".current .back").remove()
52 |             $(".current .toolbar").prepend("<a href=\""+prev_element+"\" class=\"back\">Back</a>")
53 |           })
54 |         })
55 |       </script>
56 |     </body>
57 | </html>
58 | 


--------------------------------------------------------------------------------
/examples/iphone/iphone.css:
--------------------------------------------------------------------------------
  1 | * {
  2 |   margin: 0px;
  3 |   padding: 0px;
  4 | }
  5 | .toolbar {
  6 |   -webkit-box-sizing: border-box;
  7 |   background: #6D84A2 url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAArCAIAAAA2QHWOAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAEpJREFUeNpNjCEOgEAQA5v9/9eQaAQCd57L0WXTDSmimXZEse1HnNcIIINZYTPVv7Ac4/EWe7OTsC/ec+nDgcj/dpcH7EXt8up4AfRWcOjLIqWFAAAAAElFTkSuQmCC) repeat-x;
  8 |   border-bottom: 1px solid #2D3642;
  9 |   height: 45px;
 10 |   padding: 10px;
 11 |   position: relative;
 12 | }
 13 | body {
 14 |   -webkit-perspective: 800;
 15 |   -webkit-text-size-adjust: none;
 16 |   -webkit-transform-style: preserve-3d;
 17 |   -webkit-user-select: none;
 18 |   font-family: Helvetica;
 19 |   overflow-x: hidden;
 20 |   height: 100%;
 21 |   width: 100%;
 22 | }
 23 | 
 24 | body > section {
 25 |   background: #C5CCD3 url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAcAAAABCAIAAACdaSOZAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAABdJREFUeNpiPHrmCgMC/GNjYwNSAAEGADdNA3dnzPlQAAAAAElFTkSuQmCC);
 26 |   display: block;
 27 |   left: 0px;
 28 |   position: absolute;
 29 |   width: 100%;
 30 |   -webkit-transform: translate3d(100%,0%,0%);
 31 |   opacity: 0;
 32 |   -webkit-transition: all 0.25s ease-in-out;
 33 |   -webkit-transform-style: preserve-3d;
 34 |   z-index: -10;
 35 | }
 36 | 
 37 | .reverse {
 38 |   -webkit-transform: translate3d(-100%, 0%, 0%);
 39 |   opacity: 0;
 40 | }
 41 | 
 42 | .current {
 43 |   -webkit-transform: translate3d(0%,0%, 0%);
 44 |   opacity: 1;
 45 |   z-index: 1;
 46 | }
 47 | h1, h2 {
 48 |   color: #4C566C;
 49 |   font: normal normal bold 18px/normal Helvetica;
 50 |   margin: 10px 20px 6px;
 51 |   text-shadow: rgba(255, 255, 255, 0.19)
 52 | }
 53 | body.landscape .toolbar > h1 {
 54 |   margin-left: -125px;
 55 |   width: 250px;
 56 | }
 57 | 
 58 | .toolbar > h1 {
 59 |   color: white;
 60 |   font-size: 20px;
 61 |   font-weight: bold;
 62 |   height: 40px;
 63 |   left: 50%;
 64 |   line-height: 1em;
 65 |   margin: 1px 0px 0px -75px;
 66 |   overflow: hidden;
 67 |   position: absolute;
 68 |   text-align: center;
 69 |   text-overflow: ellipsis;
 70 |   text-shadow: rgba(0, 0, 0, 0.398438) 0px -1px 0px;
 71 |   top: 10px;
 72 |   white-space: nowrap;
 73 |   width: 150px;
 74 | }
 75 | 
 76 | ul {
 77 |   background: white;
 78 |   border: 1px solid #B4B4B4;
 79 |   border-bottom-left-radius: 8px 8px;
 80 |   border-bottom-right-radius: 8px 8px;
 81 |   border-top-left-radius: 8px 8px;
 82 |   border-top-right-radius: 8px 8px;
 83 |   color: black;
 84 |   font: normal normal bold 17px/normal Helvetica;
 85 |   margin: 15px 10px 17px;
 86 |   padding: 0px;
 87 | }
 88 | 
 89 | ul li {
 90 |   color: black;
 91 |   font-size: 14px;
 92 |   border-top: 1px solid #B4B4B4;
 93 |   color: #666;
 94 |   list-style-type: none;
 95 |   padding: 10px;
 96 | }
 97 | 
 98 | li:first-child, li:first-child a {
 99 |   border-top: 0px;
100 |   border-top-left-radius: 8px 8px;
101 |   border-top-right-radius: 8px 8px;
102 | }
103 | 
104 | ul li.arrow {
105 |   background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABkAAAAUCAYAAAB4d5a9AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAKVJREFUeNpi/P//PwOtARMDHcDwsYQFRJSXl8P4dVC6CZvizs5O8i1BsqARid9Ei+BiQ2KDLKumhSU1QNyKxG+hlkXoEQ+yqAPNogpapK5KNIvaKbUIVxKeAsTvkPg5QCxETUukgfgAkqFPgdgBzVKKLIFZoIJmwR1qBRdNLEC2BJQpV9LCAmRL/gBxAtRwqlqAXqzcgRrOQE0LQIBxtNIiBQAEGAA7xCa2yF9zEgAAAABJRU5ErkJggg==);
106 |   background-position: 100% 50%;
107 |   background-repeat: no-repeat;
108 | }
109 | 
110 | body > .current {
111 |   display: block !important;
112 | }
113 | 
114 | body.landscape > * {
115 |   min-height: 320px;
116 | }
117 | 
118 | 
119 | ul li a, li.img a + a {
120 |   color: black;
121 |   display: block;
122 |   margin: -10px;
123 |   overflow: hidden;
124 |   padding: 12px 10px;
125 |   text-decoration: none;
126 |   text-overflow: ellipsis;
127 |   white-space: nowrap;
128 | }
129 | 
130 | 
131 | .button, .back, .cancel, .add {
132 | -webkit-border-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAeCAIAAACqmwlGAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAatJREFUeNqVlMtKw0AUhqfJSRpTk5Za1FAvxS6sgrVeFrpQdOcT+IpuBVHcuVBQpCDYjeAdkSpavDTGNJkz43FpFZz8DISZ+b75J5tJbWwfMsZuby7rh/vN5v1H+539TMZxPa84v7g0WirTFISQR/t7jdOTcqVaGp+ze50uIfDbL62H3a3NqerMwtIqXF9dnF+dL6+t9/S6hmFqut4luHns80aKpcrxwY43PKK7+f6J2ZVcYTCl6ZIxKuwatEhbpmU72UKjfgCakXFz/TwW7L8QlgIbTNtBwVAgU0g644IGZoycqYVgQGRRLBQFggEpHJUFBI4iUhYIBhSSPooCwUB0zEWiBsERlRsECJSIUlEgOHmDH3TM909FgWBgqe8oCgRrLGGADlcvIDB5A2nfQ7kD6D5J/jn5lZILBoAUQgWVUgDoWi5r8zhUEXgU5nOOVp0sB+0W+f8WEDY9MabpYNUqQ29Pd1Hoi79eA1qkLQIIY5CGIOwUvYHBQr5xdvn4/BSGnS7BstIDhexUbVo3jNarD1Ky5xfftszF+WqPZcKvp5IjfoYRoYHv0/QLHvXjAb8xkEMAAAAASUVORK5CYII=) 0 5 0 5 stretch stretch;
133 | background: none;
134 | border-width: 0px 5px;
135 | color: white;
136 | font-family: inherit;
137 | font-size: 12px;
138 | font-weight: bold;
139 | height: 30px;
140 | line-height: 30px;
141 | margin: 0px;
142 | overflow: ;
143 | padding: 0px 3px;
144 | position: absolute;
145 | right: 6px;
146 | text-decoration: none;
147 | text-overflow: ellipsis;
148 | text-shadow: rgba(0, 0, 0, 0.496094) 0px -1px 0px;
149 | top: 8px;
150 | white-space: nowrap;
151 | width: auto;
152 | }
153 | 
154 | .back {
155 |   -webkit-border-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACsAAAAeCAIAAAA6iHCJAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAArFJREFUeNrF0mtPE2EQBeB5t9vSRqEUKiAFkasggmC5x3CRECHx8sH/qMHEoKkiMUQTNJIIaAjeiFGUcEsotN22u9vtOzMKogYL39rlyfkBk3NG3HsyC8dLJhOzM8+/fvkcjexAtghRXVN/dXCkvOIcAKhEDMdY+7ESejgeqKpv7x3J9/ogS5hoc33l0YPxju6+YFefSkRwlI311cnQRM/gbd+ZUpfb43CokD2nCv2lFbVvZib9JaUqMUEGTYtNPZ7oHLpZXBJQFIUYSCJkj3A4830lrd3Di2/nVcxYwTSMift3m4LXCovKCYGQIDe8vrJveNQfTE+Fys9f8pdVSSTILeFyF/z/B8uflnSLG+qakRlRQo45XO5DHejJxOtXLzsG7yA7ME2Qe0hw6A+mn4ZqLvY4XR6UCLZAxH8rfFx6Z6BaXVJlSQS7SKSDC+JabGFurrnvBvJ+NXZBYpX4oP9AQ5eietKSAMDuDt4vLkhHfr6/XCKCvZBIjezuLMzPN/XcIhIADPYiZPXFs8lAQ7dwOA8KsL8Dr7/CoDzSDDgJCT2ljI0OOzBGKMVJACGUXU2/3h/Uo5vMDCdBQSRLcn9nox7bEgLsDoDCDKYli4p89ZXFZjJ6Ah3wvlhcb2mqPa1a0jIBhJ1RiPl3wpH4QG+bTGwDo51DKPwHMccS5mBvSzyyCcB2rgB/k5aoqK72xgo9FrbxgsMSulkZOBvwu1O6BjnGhO48p8IZfj1EsPWCR+jSMiCX0pbh9xXsrZCZrW1toOcy6mFMpyA3mNnUwi2NtQoxZwaZwzF9bKhTpHaN+C7KNGQPobTMhBZe7Wyts1iox729RNyOJkeHOj4sf19Z3YgmsraI251X6ve2BYMEIqIlVebjd0rj2la0rrrySkuDU1UhSySiYVrbkbiZ2qv2J5+53J2yzo3SAAAAAElFTkSuQmCC) 0 8 0 14 stretch stretch;
156 | border-width: 0px 8px 0px 14px;
157 | left: 6px;
158 | max-width: 55px;
159 | padding: 0px;
160 | right: auto;
161 | }
162 | 


--------------------------------------------------------------------------------
/examples/load_jquery_on_ie.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <title>Load jQuery if Zepto is not supported</title>
 5 | </head>
 6 | <body>
 7 |   <h1>Load jQuery if Zepto is not supported</h1>
 8 | </body>
 9 | <script>document.write('<script src='+('__proto__' in {} ? '../dist/zepto' : 'https://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery')+'.js><\/script>')</script>
10 | <script>
11 |   $('body').append('<p>Hello from '+('Zepto' in window ? 'Zepto' : 'jQuery')+'!</p>')
12 | 
13 |   $('script').each(function(index,script){
14 |     if (script.src)
15 |       $('<p>&lt;script src="'+script.src+'"&gt;</p>').appendTo('body')
16 |   })
17 | </script>
18 | </html>
19 | 


--------------------------------------------------------------------------------
/examples/snow/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <title>Let it snow with Zepto.js</title>
 5 |     <meta name="name" content="content">
 6 |     <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
 7 |     <style>
 8 |       body { background: #000; color: #fff; overflow: hidden }
 9 |       div { position: absolute; }
10 |     </style>
11 |   </head>
12 |   <body>
13 | 
14 |   <script src="../../src/zepto.js"></script>
15 |   <script src="../../src/event.js"></script>
16 |   <script src="../../src/fx.js"></script>
17 | 
18 |   <a href="https://twitter.com/share" class="twitter-share-button" data-url="http://zeptojs.com/let-it-snow" data-text="Let it snow with Zepto.js" data-via="zeptojs" data-lang="en">Tweet</a>
19 |   <script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0];if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src="//platform.twitter.com/widgets.js";fjs.parentNode.insertBefore(js,fjs);}}(document,"script","twitter-wjs")</script>
20 | 
21 |   <script>
22 |     $(document).ready(function(){
23 |       var i = 100, glyphs = '❄❅❆'.split('')
24 | 
25 |       function rand(max){ return Math.floor(Math.random()*max) }
26 | 
27 |       function addFlake(){
28 |         var el = $('<div><div>' + glyphs[rand(glyphs.length)] + '</div></div>')
29 |         $('body').append(el)
30 |         el.css({ left: rand(100)+'%', top: -100-rand(500), fontSize: 20+rand(30) })
31 |         el.anim(
32 |           { translateY: 1500+rand(500)+'px', translateX: 50-rand(100)+'px', rotate: (2e3-rand(4e3))+'deg' },
33 |           6+rand(10),
34 |           'linear',
35 |           function(){
36 |             addFlake()
37 |             el.remove() // garbage collect
38 |           }
39 |         )
40 |       }
41 | 
42 |       while(i--) addFlake()
43 | 
44 |       // enable for extra fun
45 |       //window.ondeviceorientation = function(event){
46 |       //  ('alpha' in event) && $('body').css({ '-webkit-transform': 'rotate('+event.alpha+'deg)'})
47 |       //}
48 |     })
49 |   </script>
50 |   </body>
51 | </html>
52 | 


--------------------------------------------------------------------------------
/examples/touch_events.html:
--------------------------------------------------------------------------------
 1 | <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0"/>
 2 | 
 3 | <script src="../src/zepto.js"></script>
 4 | <script src="../src/event.js"></script>
 5 | <script src="../src/touch.js"></script>
 6 | 
 7 | <style>
 8 |   .delete {
 9 |     display: none;
10 |     color: red;
11 |   }
12 | </style>
13 | 
14 | <ul id=items>
15 |   <li>List item 1 <span class=delete>DELETE</span></li>
16 |   <li>List item 2 <span class=delete>DELETE</span></li>
17 |   <li>List item 3 <span class=delete>DELETE</span></li>
18 |   <li>List item 4 <span class=delete>DELETE</span></li>
19 | </ul>
20 | 
21 | <script>
22 | $('#items li').swipe(function(){
23 |   $('.delete').hide()
24 |   $('.delete', this).show()
25 | })
26 | 
27 | $('.delete').tap(function(){
28 |   $(this).parent('li').remove()
29 | })
30 | </script>
31 | 


--------------------------------------------------------------------------------
/make:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env coffee
  2 | require 'shelljs/make'
  3 | fs = require 'fs'
  4 | 
  5 | zepto_js  = 'dist/zepto.js'
  6 | zepto_min = 'dist/zepto.min.js'
  7 | zepto_gz  = 'dist/zepto.min.gz'
  8 | 
  9 | port = 3999
 10 | root = __dirname + '/'
 11 | 
 12 | target.all = ->
 13 |   target[zepto_js]()
 14 |   target.test()
 15 | 
 16 | ## TASKS ##
 17 | 
 18 | target.test = ->
 19 |   test_app = require './test/server'
 20 |   server = test_app.listen port
 21 |   exec "phantomjs --disk-cache=true test/runner.js 'http://localhost:#{port}/'", (code) ->
 22 |     server.close -> exit(code)
 23 | 
 24 | target[zepto_js] = ->
 25 |   target.build() unless test('-e', zepto_js)
 26 | 
 27 | target[zepto_min] = ->
 28 |   target.minify() if stale(zepto_min, zepto_js)
 29 | 
 30 | target[zepto_gz] = ->
 31 |   target.compress() if stale(zepto_gz, zepto_min)
 32 | 
 33 | target.dist = ->
 34 |   target.build()
 35 |   target.minify()
 36 |   target.compress()
 37 | 
 38 | target.build = ->
 39 |   cd __dirname
 40 |   mkdir '-p', 'dist'
 41 |   modules = (env['MODULES'] || 'zepto event ajax form ie').split(' ')
 42 |   module_files = ( "src/#{module}.js" for module in modules )
 43 |   intro = "/* Zepto #{describe_version()} - #{modules.join(' ')} - zeptojs.com/license */\n"
 44 |   dist = cat(module_files).replace(/^\/[\/*].*$/mg, '').replace(/\n{3,}/g, "\n\n")
 45 |   dist = cat('src/amd_layout.js').replace(/YIELD/, -> dist.trim()) unless env['NOAMD']
 46 |   (intro + dist).to(zepto_js)
 47 |   report_size(zepto_js)
 48 | 
 49 | target.minify = ->
 50 |   target.build() unless test('-e', zepto_js)
 51 |   zepto_code = cat(zepto_js)
 52 |   intro = zepto_code.slice(0, zepto_code.indexOf("\n") + 1)
 53 |   (intro + minify(zepto_code)).to(zepto_min)
 54 |   report_size(zepto_min)
 55 | 
 56 | target.compress = ->
 57 |   gzip = require('zlib').createGzip()
 58 |   inp = fs.createReadStream(zepto_min)
 59 |   out = fs.createWriteStream(zepto_gz)
 60 |   inp.pipe(gzip).pipe(out)
 61 |   out.on 'close', ->
 62 |     report_size(zepto_gz)
 63 |     factor = fsize(zepto_js) / fsize(zepto_gz)
 64 |     echo "compression factor: #{format_number(factor)}"
 65 | 
 66 | target.publish = ->
 67 |   tag = 'v' + package_version()
 68 |   if git_version() == tag
 69 |     rm '-f', zepto_js
 70 |     env['MODULES'] = env['NOAMD'] = ''
 71 |     target.dist()
 72 |     res = exec 'npm publish'
 73 |     exit res.code
 74 |   else
 75 |     console.error 'error: latest commit should be tagged with ' + tag
 76 |     exit 1
 77 | 
 78 | ## HELPERS ##
 79 | 
 80 | stale = (file, source) ->
 81 |   target[source]()
 82 |   !test('-e', file) || mtime(file) < mtime(source)
 83 | 
 84 | mtime = (file) ->
 85 |   fs.statSync(file).mtime.getTime()
 86 | 
 87 | fsize = (file) ->
 88 |   fs.statSync(file).size
 89 | 
 90 | format_number = (size, precision = 1) ->
 91 |   factor = Math.pow(10, precision)
 92 |   decimal = Math.round(size * factor) % factor
 93 |   parseInt(size) + "." + decimal
 94 | 
 95 | report_size = (file) ->
 96 |   echo "#{file}: #{format_number(fsize(file) / 1024)} KiB"
 97 | 
 98 | package_version = ->
 99 |   JSON.parse(cat('package.json')).version
100 | 
101 | git_version = ->
102 |   desc = exec "git --git-dir='#{root + '.git'}' describe --tags HEAD", silent: true
103 |   desc.output.replace(/\s+$/, '') if desc.code is 0
104 | 
105 | describe_version = ->
106 |   git_version() || package_version()
107 | 
108 | minify = (source_code) ->
109 |   uglify = require('uglify-js')
110 |   compressor = uglify.Compressor()
111 |   ast = uglify.parse(source_code)
112 |   ast.figure_out_scope()
113 |   ast.compute_char_frequency()
114 |   ast.mangle_names()
115 |   ast = ast.transform(compressor)
116 |   return ast.print_to_string()
117 | 


--------------------------------------------------------------------------------
/package-lock.json:
--------------------------------------------------------------------------------
  1 | {
  2 |     "name": "zepto",
  3 |     "version": "1.2.0",
  4 |     "lockfileVersion": 1,
  5 |     "dependencies": {
  6 |         "amdefine": {
  7 |             "version": "1.0.1",
  8 |             "resolved": "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz",
  9 |             "integrity": "sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU=",
 10 |             "dev": true
 11 |         },
 12 |         "async": {
 13 |             "version": "0.2.10",
 14 |             "resolved": "https://registry.npmjs.org/async/-/async-0.2.10.tgz",
 15 |             "integrity": "sha1-trvgsGdLnXGXCMo43owjfLUmw9E=",
 16 |             "dev": true
 17 |         },
 18 |         "buffer-crc32": {
 19 |             "version": "0.2.13",
 20 |             "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
 21 |             "integrity": "sha1-DTM+PwDqxQqhRUq9MO+MKl2ackI=",
 22 |             "dev": true
 23 |         },
 24 |         "bytes": {
 25 |             "version": "0.2.0",
 26 |             "resolved": "https://registry.npmjs.org/bytes/-/bytes-0.2.0.tgz",
 27 |             "integrity": "sha1-qtM+wU49wsp06OfUUfm6BTrU96A=",
 28 |             "dev": true
 29 |         },
 30 |         "camelcase": {
 31 |             "version": "1.2.1",
 32 |             "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-1.2.1.tgz",
 33 |             "integrity": "sha1-m7UwTS4LVmmLLHWLCKPqqdqlijk=",
 34 |             "dev": true
 35 |         },
 36 |         "coffee-script": {
 37 |             "version": "1.5.0",
 38 |             "resolved": "https://registry.npmjs.org/coffee-script/-/coffee-script-1.5.0.tgz",
 39 |             "integrity": "sha1-GKZqC2hnnrG+AA5Q39A5jXk/nhU=",
 40 |             "dev": true
 41 |         },
 42 |         "commander": {
 43 |             "version": "0.6.1",
 44 |             "resolved": "https://registry.npmjs.org/commander/-/commander-0.6.1.tgz",
 45 |             "integrity": "sha1-+mihT2qUXVTbvlDYzbMyDp47GgY=",
 46 |             "dev": true
 47 |         },
 48 |         "connect": {
 49 |             "version": "2.7.5",
 50 |             "resolved": "https://registry.npmjs.org/connect/-/connect-2.7.5.tgz",
 51 |             "integrity": "sha1-E5ERtLA/BTOlJJJ6iKZGrkZ7LAI=",
 52 |             "dev": true,
 53 |             "dependencies": {
 54 |                 "buffer-crc32": {
 55 |                     "version": "0.1.1",
 56 |                     "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.1.1.tgz",
 57 |                     "integrity": "sha1-fhENyZU5CKt8MqzccMn5RbHLxSY=",
 58 |                     "dev": true
 59 |                 }
 60 |             }
 61 |         },
 62 |         "cookie": {
 63 |             "version": "0.0.5",
 64 |             "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.0.5.tgz",
 65 |             "integrity": "sha1-+az521frdWjJ/MWWJWt7si4wfIE=",
 66 |             "dev": true
 67 |         },
 68 |         "cookie-signature": {
 69 |             "version": "1.0.0",
 70 |             "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.0.tgz",
 71 |             "integrity": "sha1-AETzMqxiPfhRyRTojqzFfwyXBP4=",
 72 |             "dev": true
 73 |         },
 74 |         "debug": {
 75 |             "version": "2.6.8",
 76 |             "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.8.tgz",
 77 |             "integrity": "sha1-5zFTHKLt4n0YgiJCfaF4IdaP9Pw=",
 78 |             "dev": true
 79 |         },
 80 |         "decamelize": {
 81 |             "version": "1.2.0",
 82 |             "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
 83 |             "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=",
 84 |             "dev": true
 85 |         },
 86 |         "express": {
 87 |             "version": "3.1.2",
 88 |             "resolved": "https://registry.npmjs.org/express/-/express-3.1.2.tgz",
 89 |             "integrity": "sha1-UqAsjbjyK7+g10eNhHzUUWH5hfc=",
 90 |             "dev": true
 91 |         },
 92 |         "formidable": {
 93 |             "version": "1.0.11",
 94 |             "resolved": "https://registry.npmjs.org/formidable/-/formidable-1.0.11.tgz",
 95 |             "integrity": "sha1-aPYzJaA15kS297s9ESQ7l2HeGzA=",
 96 |             "dev": true
 97 |         },
 98 |         "fresh": {
 99 |             "version": "0.1.0",
100 |             "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.1.0.tgz",
101 |             "integrity": "sha1-A+SwF4Qk5MLV0ZpU2IFM3JeTSFA=",
102 |             "dev": true
103 |         },
104 |         "methods": {
105 |             "version": "0.0.1",
106 |             "resolved": "https://registry.npmjs.org/methods/-/methods-0.0.1.tgz",
107 |             "integrity": "sha1-J3yQ+L7zlwlkWoNxxRw7bGSOBow=",
108 |             "dev": true
109 |         },
110 |         "mime": {
111 |             "version": "1.2.6",
112 |             "resolved": "https://registry.npmjs.org/mime/-/mime-1.2.6.tgz",
113 |             "integrity": "sha1-sfhsdowCX6h7SAdfFwnyiuryA2U=",
114 |             "dev": true
115 |         },
116 |         "mkdirp": {
117 |             "version": "0.3.5",
118 |             "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.3.5.tgz",
119 |             "integrity": "sha1-3j5fiWHIjHh+4TaN+EmsRBPsqNc=",
120 |             "dev": true
121 |         },
122 |         "ms": {
123 |             "version": "2.0.0",
124 |             "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
125 |             "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
126 |             "dev": true
127 |         },
128 |         "pause": {
129 |             "version": "0.0.1",
130 |             "resolved": "https://registry.npmjs.org/pause/-/pause-0.0.1.tgz",
131 |             "integrity": "sha1-HUCLP9t2kjuVQ9lvtMnf1TXZy10=",
132 |             "dev": true
133 |         },
134 |         "qs": {
135 |             "version": "0.5.1",
136 |             "resolved": "https://registry.npmjs.org/qs/-/qs-0.5.1.tgz",
137 |             "integrity": "sha1-n2v12axsdjhOldNtFbSJgOXkrdA=",
138 |             "dev": true
139 |         },
140 |         "range-parser": {
141 |             "version": "0.0.4",
142 |             "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-0.0.4.tgz",
143 |             "integrity": "sha1-wEJ//vUcEKy6B4KkbJYC50T/Ygs=",
144 |             "dev": true
145 |         },
146 |         "send": {
147 |             "version": "0.1.0",
148 |             "resolved": "https://registry.npmjs.org/send/-/send-0.1.0.tgz",
149 |             "integrity": "sha1-z7COvTzsm3/Bo32f+eh1qXHPRkA=",
150 |             "dev": true
151 |         },
152 |         "shelljs": {
153 |             "version": "0.1.4",
154 |             "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.1.4.tgz",
155 |             "integrity": "sha1-37vnjVbDwBaNL7eeEOzR28sH7A4=",
156 |             "dev": true
157 |         },
158 |         "source-map": {
159 |             "version": "0.1.34",
160 |             "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.1.34.tgz",
161 |             "integrity": "sha1-p8/omux7FoLDsZjQrPtH19CQVms=",
162 |             "dev": true
163 |         },
164 |         "uglify-js": {
165 |             "version": "2.4.24",
166 |             "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-2.4.24.tgz",
167 |             "integrity": "sha1-+tV1XB4Vd2WLsG/5q25UjJW+vW4=",
168 |             "dev": true
169 |         },
170 |         "uglify-to-browserify": {
171 |             "version": "1.0.2",
172 |             "resolved": "https://registry.npmjs.org/uglify-to-browserify/-/uglify-to-browserify-1.0.2.tgz",
173 |             "integrity": "sha1-bgkk1r2mta/jSeOabWMoUKD4grc=",
174 |             "dev": true
175 |         },
176 |         "window-size": {
177 |             "version": "0.1.0",
178 |             "resolved": "https://registry.npmjs.org/window-size/-/window-size-0.1.0.tgz",
179 |             "integrity": "sha1-VDjNLqk7IC76Ohn+iIeu58lPnJ0=",
180 |             "dev": true
181 |         },
182 |         "wordwrap": {
183 |             "version": "0.0.2",
184 |             "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.2.tgz",
185 |             "integrity": "sha1-t5Zpu0LstAn4PVg8rVLKF+qhZD8=",
186 |             "dev": true
187 |         },
188 |         "yargs": {
189 |             "version": "3.5.4",
190 |             "resolved": "https://registry.npmjs.org/yargs/-/yargs-3.5.4.tgz",
191 |             "integrity": "sha1-2K/49mXpTDS9JZvevRv68N3TU2E=",
192 |             "dev": true
193 |         }
194 |     }
195 | }
196 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "zepto",
 3 |     "version": "1.2.0",
 4 |     "main": "dist/zepto.js",
 5 |     "homepage": "http://zeptojs.com",
 6 |     "scripts": {
 7 |         "test": "coffee make test",
 8 |         "dist": "coffee make dist",
 9 |         "start": "coffee test/server.coffee"
10 |     },
11 |     "repository": "madrobby/zepto",
12 |     "license": "MIT",
13 |     "devDependencies": {
14 |         "uglify-js": "2.4.x",
15 |         "express": "3.1.x",
16 |         "coffee-script": "1.5.x",
17 |         "shelljs": "0.1.x"
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/script/bootstrap:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | set -e
 3 | 
 4 | npm install
 5 | 
 6 | if phantom_version="$(phantomjs --version)"; then
 7 |   echo "phantomjs ${phantom_version}"
 8 | else
 9 |   echo "You should install PhantomJS for \`script/test' to work." >&2
10 | fi
11 | 


--------------------------------------------------------------------------------
/script/guard:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | if [ -z "$BUNDLE_GEMFILE" ]; then
3 |   export BUNDLE_GEMFILE=shutup
4 | fi
5 | 
6 | exec guard --no-notify "$@"
7 | 


--------------------------------------------------------------------------------
/script/lint:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/awk -f
 2 | 
 3 | BEGIN { if (length(ARGV) < 2) exit 0 }
 4 | 
 5 | /<script/ { script=FILENAME }
 6 | /<\/script/ { script="" }
 7 | 
 8 | /;\s*$/ && (FILENAME !~ /.html$/ || script == FILENAME) {
 9 |   printf("%s:%d: no semicolons, please\n", FILENAME, FNR)
10 |   warns++
11 | }
12 | /\t/ {
13 |   printf("%s:%d: use spaces instead of tabs\n", FILENAME, FNR)
14 |   warns++
15 | }
16 | 
17 | END { if (warns) exit 1 }
18 | 


--------------------------------------------------------------------------------
/script/test:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | set -e
 3 | 
 4 | port=3999
 5 | test_url="http://localhost:${port}/"
 6 | 
 7 | export PATH=node_modules/.bin:"$PATH"
 8 | 
 9 | git ls-files \*.js \*.html | grep -v ^vendor/ | xargs script/lint
10 | 
11 | coffee test/server.coffee $port &
12 | pid=$!
13 | 
14 | check_test_server() {
15 |   curl -fsI "$test_url" >/dev/null
16 | }
17 | 
18 | terminate_test_server() {
19 |   kill $pid
20 | }
21 | 
22 | tries=1
23 | while ! check_test_server; do
24 |   if [ $((tries++)) -eq 20 ]; then
25 |     echo "error: timed out while waiting for test server" >&2
26 |     exit 1
27 |   fi
28 |   sleep .05
29 | done
30 | 
31 | trap terminate_test_server EXIT
32 | 
33 | phantomjs --disk-cache=true \
34 |   test/runner.js "$test_url" "$@" \
35 |   2> >(grep -v "CoreText performance note" >&2)
36 | 


--------------------------------------------------------------------------------
/src/ajax.js:
--------------------------------------------------------------------------------
  1 | //     Zepto.js
  2 | //     (c) 2010-2016 Thomas Fuchs
  3 | //     Zepto.js may be freely distributed under the MIT license.
  4 | 
  5 | ;(function($){
  6 |   var jsonpID = +new Date(),
  7 |       document = window.document,
  8 |       key,
  9 |       name,
 10 |       rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
 11 |       scriptTypeRE = /^(?:text|application)\/javascript/i,
 12 |       xmlTypeRE = /^(?:text|application)\/xml/i,
 13 |       jsonType = 'application/json',
 14 |       htmlType = 'text/html',
 15 |       blankRE = /^\s*$/,
 16 |       originAnchor = document.createElement('a')
 17 | 
 18 |   originAnchor.href = window.location.href
 19 | 
 20 |   // trigger a custom event and return false if it was cancelled
 21 |   function triggerAndReturn(context, eventName, data) {
 22 |     var event = $.Event(eventName)
 23 |     $(context).trigger(event, data)
 24 |     return !event.isDefaultPrevented()
 25 |   }
 26 | 
 27 |   // trigger an Ajax "global" event
 28 |   function triggerGlobal(settings, context, eventName, data) {
 29 |     if (settings.global) return triggerAndReturn(context || document, eventName, data)
 30 |   }
 31 | 
 32 |   // Number of active Ajax requests
 33 |   $.active = 0
 34 | 
 35 |   function ajaxStart(settings) {
 36 |     if (settings.global && $.active++ === 0) triggerGlobal(settings, null, 'ajaxStart')
 37 |   }
 38 |   function ajaxStop(settings) {
 39 |     if (settings.global && !(--$.active)) triggerGlobal(settings, null, 'ajaxStop')
 40 |   }
 41 | 
 42 |   // triggers an extra global event "ajaxBeforeSend" that's like "ajaxSend" but cancelable
 43 |   function ajaxBeforeSend(xhr, settings) {
 44 |     var context = settings.context
 45 |     if (settings.beforeSend.call(context, xhr, settings) === false ||
 46 |         triggerGlobal(settings, context, 'ajaxBeforeSend', [xhr, settings]) === false)
 47 |       return false
 48 | 
 49 |     triggerGlobal(settings, context, 'ajaxSend', [xhr, settings])
 50 |   }
 51 |   function ajaxSuccess(data, xhr, settings, deferred) {
 52 |     var context = settings.context, status = 'success'
 53 |     settings.success.call(context, data, status, xhr)
 54 |     if (deferred) deferred.resolveWith(context, [data, status, xhr])
 55 |     triggerGlobal(settings, context, 'ajaxSuccess', [xhr, settings, data])
 56 |     ajaxComplete(status, xhr, settings)
 57 |   }
 58 |   // type: "timeout", "error", "abort", "parsererror"
 59 |   function ajaxError(error, type, xhr, settings, deferred) {
 60 |     var context = settings.context
 61 |     settings.error.call(context, xhr, type, error)
 62 |     if (deferred) deferred.rejectWith(context, [xhr, type, error])
 63 |     triggerGlobal(settings, context, 'ajaxError', [xhr, settings, error || type])
 64 |     ajaxComplete(type, xhr, settings)
 65 |   }
 66 |   // status: "success", "notmodified", "error", "timeout", "abort", "parsererror"
 67 |   function ajaxComplete(status, xhr, settings) {
 68 |     var context = settings.context
 69 |     settings.complete.call(context, xhr, status)
 70 |     triggerGlobal(settings, context, 'ajaxComplete', [xhr, settings])
 71 |     ajaxStop(settings)
 72 |   }
 73 | 
 74 |   function ajaxDataFilter(data, type, settings) {
 75 |     if (settings.dataFilter == empty) return data
 76 |     var context = settings.context
 77 |     return settings.dataFilter.call(context, data, type)
 78 |   }
 79 | 
 80 |   // Empty function, used as default callback
 81 |   function empty() {}
 82 | 
 83 |   $.ajaxJSONP = function(options, deferred){
 84 |     if (!('type' in options)) return $.ajax(options)
 85 | 
 86 |     var _callbackName = options.jsonpCallback,
 87 |       callbackName = ($.isFunction(_callbackName) ?
 88 |         _callbackName() : _callbackName) || ('Zepto' + (jsonpID++)),
 89 |       script = document.createElement('script'),
 90 |       originalCallback = window[callbackName],
 91 |       responseData,
 92 |       abort = function(errorType) {
 93 |         $(script).triggerHandler('error', errorType || 'abort')
 94 |       },
 95 |       xhr = { abort: abort }, abortTimeout
 96 | 
 97 |     if (deferred) deferred.promise(xhr)
 98 | 
 99 |     $(script).on('load error', function(e, errorType){
100 |       clearTimeout(abortTimeout)
101 |       $(script).off().remove()
102 | 
103 |       if (e.type == 'error' || !responseData) {
104 |         ajaxError(null, errorType || 'error', xhr, options, deferred)
105 |       } else {
106 |         ajaxSuccess(responseData[0], xhr, options, deferred)
107 |       }
108 | 
109 |       window[callbackName] = originalCallback
110 |       if (responseData && $.isFunction(originalCallback))
111 |         originalCallback(responseData[0])
112 | 
113 |       originalCallback = responseData = undefined
114 |     })
115 | 
116 |     if (ajaxBeforeSend(xhr, options) === false) {
117 |       abort('abort')
118 |       return xhr
119 |     }
120 | 
121 |     window[callbackName] = function(){
122 |       responseData = arguments
123 |     }
124 | 
125 |     script.src = options.url.replace(/\?(.+)=\?/, '?$1=' + callbackName)
126 |     document.head.appendChild(script)
127 | 
128 |     if (options.timeout > 0) abortTimeout = setTimeout(function(){
129 |       abort('timeout')
130 |     }, options.timeout)
131 | 
132 |     return xhr
133 |   }
134 | 
135 |   $.ajaxSettings = {
136 |     // Default type of request
137 |     type: 'GET',
138 |     // Callback that is executed before request
139 |     beforeSend: empty,
140 |     // Callback that is executed if the request succeeds
141 |     success: empty,
142 |     // Callback that is executed the the server drops error
143 |     error: empty,
144 |     // Callback that is executed on request complete (both: error and success)
145 |     complete: empty,
146 |     // The context for the callbacks
147 |     context: null,
148 |     // Whether to trigger "global" Ajax events
149 |     global: true,
150 |     // Transport
151 |     xhr: function () {
152 |       return new window.XMLHttpRequest()
153 |     },
154 |     // MIME types mapping
155 |     // IIS returns Javascript as "application/x-javascript"
156 |     accepts: {
157 |       script: 'text/javascript, application/javascript, application/x-javascript',
158 |       json:   jsonType,
159 |       xml:    'application/xml, text/xml',
160 |       html:   htmlType,
161 |       text:   'text/plain'
162 |     },
163 |     // Whether the request is to another domain
164 |     crossDomain: false,
165 |     // Default timeout
166 |     timeout: 0,
167 |     // Whether data should be serialized to string
168 |     processData: true,
169 |     // Whether the browser should be allowed to cache GET responses
170 |     cache: true,
171 |     //Used to handle the raw response data of XMLHttpRequest.
172 |     //This is a pre-filtering function to sanitize the response.
173 |     //The sanitized response should be returned
174 |     dataFilter: empty
175 |   }
176 | 
177 |   function mimeToDataType(mime) {
178 |     if (mime) mime = mime.split(';', 2)[0]
179 |     return mime && ( mime == htmlType ? 'html' :
180 |       mime == jsonType ? 'json' :
181 |       scriptTypeRE.test(mime) ? 'script' :
182 |       xmlTypeRE.test(mime) && 'xml' ) || 'text'
183 |   }
184 | 
185 |   function appendQuery(url, query) {
186 |     if (query == '') return url
187 |     return (url + '&' + query).replace(/[&?]{1,2}/, '?')
188 |   }
189 | 
190 |   // serialize payload and append it to the URL for GET requests
191 |   function serializeData(options) {
192 |     if (options.processData && options.data && $.type(options.data) != "string")
193 |       options.data = $.param(options.data, options.traditional)
194 |     if (options.data && (!options.type || options.type.toUpperCase() == 'GET' || 'jsonp' == options.dataType))
195 |       options.url = appendQuery(options.url, options.data), options.data = undefined
196 |   }
197 | 
198 |   $.ajax = function(options){
199 |     var settings = $.extend({}, options || {}),
200 |         deferred = $.Deferred && $.Deferred(),
201 |         urlAnchor, hashIndex
202 |     for (key in $.ajaxSettings) if (settings[key] === undefined) settings[key] = $.ajaxSettings[key]
203 | 
204 |     ajaxStart(settings)
205 | 
206 |     if (!settings.crossDomain) {
207 |       urlAnchor = document.createElement('a')
208 |       urlAnchor.href = settings.url
209 |       // cleans up URL for .href (IE only), see https://github.com/madrobby/zepto/pull/1049
210 |       urlAnchor.href = urlAnchor.href
211 |       settings.crossDomain = (originAnchor.protocol + '//' + originAnchor.host) !== (urlAnchor.protocol + '//' + urlAnchor.host)
212 |     }
213 | 
214 |     if (!settings.url) settings.url = window.location.toString()
215 |     if ((hashIndex = settings.url.indexOf('#')) > -1) settings.url = settings.url.slice(0, hashIndex)
216 |     serializeData(settings)
217 | 
218 |     var dataType = settings.dataType, hasPlaceholder = /\?.+=\?/.test(settings.url)
219 |     if (hasPlaceholder) dataType = 'jsonp'
220 | 
221 |     if (settings.cache === false || (
222 |          (!options || options.cache !== true) &&
223 |          ('script' == dataType || 'jsonp' == dataType)
224 |         ))
225 |       settings.url = appendQuery(settings.url, '_=' + Date.now())
226 | 
227 |     if ('jsonp' == dataType) {
228 |       if (!hasPlaceholder)
229 |         settings.url = appendQuery(settings.url,
230 |           settings.jsonp ? (settings.jsonp + '=?') : settings.jsonp === false ? '' : 'callback=?')
231 |       return $.ajaxJSONP(settings, deferred)
232 |     }
233 | 
234 |     var mime = settings.accepts[dataType],
235 |         headers = { },
236 |         setHeader = function(name, value) { headers[name.toLowerCase()] = [name, value] },
237 |         protocol = /^([\w-]+:)\/\//.test(settings.url) ? RegExp.$1 : window.location.protocol,
238 |         xhr = settings.xhr(),
239 |         nativeSetHeader = xhr.setRequestHeader,
240 |         abortTimeout
241 | 
242 |     if (deferred) deferred.promise(xhr)
243 | 
244 |     if (!settings.crossDomain) setHeader('X-Requested-With', 'XMLHttpRequest')
245 |     setHeader('Accept', mime || '*/*')
246 |     if (mime = settings.mimeType || mime) {
247 |       if (mime.indexOf(',') > -1) mime = mime.split(',', 2)[0]
248 |       xhr.overrideMimeType && xhr.overrideMimeType(mime)
249 |     }
250 |     if (settings.contentType || (settings.contentType !== false && settings.data && settings.type.toUpperCase() != 'GET'))
251 |       setHeader('Content-Type', settings.contentType || 'application/x-www-form-urlencoded')
252 | 
253 |     if (settings.headers) for (name in settings.headers) setHeader(name, settings.headers[name])
254 |     xhr.setRequestHeader = setHeader
255 | 
256 |     xhr.onreadystatechange = function(){
257 |       if (xhr.readyState == 4) {
258 |         xhr.onreadystatechange = empty
259 |         clearTimeout(abortTimeout)
260 |         var result, error = false
261 |         if ((xhr.status >= 200 && xhr.status < 300) || xhr.status == 304 || (xhr.status == 0 && protocol == 'file:')) {
262 |           dataType = dataType || mimeToDataType(settings.mimeType || xhr.getResponseHeader('content-type'))
263 | 
264 |           if (xhr.responseType == 'arraybuffer' || xhr.responseType == 'blob')
265 |             result = xhr.response
266 |           else {
267 |             result = xhr.responseText
268 | 
269 |             try {
270 |               // http://perfectionkills.com/global-eval-what-are-the-options/
271 |               // sanitize response accordingly if data filter callback provided
272 |               result = ajaxDataFilter(result, dataType, settings)
273 |               if (dataType == 'script')    (1,eval)(result)
274 |               else if (dataType == 'xml')  result = xhr.responseXML
275 |               else if (dataType == 'json') result = blankRE.test(result) ? null : $.parseJSON(result)
276 |             } catch (e) { error = e }
277 | 
278 |             if (error) return ajaxError(error, 'parsererror', xhr, settings, deferred)
279 |           }
280 | 
281 |           ajaxSuccess(result, xhr, settings, deferred)
282 |         } else {
283 |           ajaxError(xhr.statusText || null, xhr.status ? 'error' : 'abort', xhr, settings, deferred)
284 |         }
285 |       }
286 |     }
287 | 
288 |     if (ajaxBeforeSend(xhr, settings) === false) {
289 |       xhr.abort()
290 |       ajaxError(null, 'abort', xhr, settings, deferred)
291 |       return xhr
292 |     }
293 | 
294 |     var async = 'async' in settings ? settings.async : true
295 |     xhr.open(settings.type, settings.url, async, settings.username, settings.password)
296 | 
297 |     if (settings.xhrFields) for (name in settings.xhrFields) xhr[name] = settings.xhrFields[name]
298 | 
299 |     for (name in headers) nativeSetHeader.apply(xhr, headers[name])
300 | 
301 |     if (settings.timeout > 0) abortTimeout = setTimeout(function(){
302 |         xhr.onreadystatechange = empty
303 |         xhr.abort()
304 |         ajaxError(null, 'timeout', xhr, settings, deferred)
305 |       }, settings.timeout)
306 | 
307 |     // avoid sending empty string (#319)
308 |     xhr.send(settings.data ? settings.data : null)
309 |     return xhr
310 |   }
311 | 
312 |   // handle optional data/success arguments
313 |   function parseArguments(url, data, success, dataType) {
314 |     if ($.isFunction(data)) dataType = success, success = data, data = undefined
315 |     if (!$.isFunction(success)) dataType = success, success = undefined
316 |     return {
317 |       url: url
318 |     , data: data
319 |     , success: success
320 |     , dataType: dataType
321 |     }
322 |   }
323 | 
324 |   $.get = function(/* url, data, success, dataType */){
325 |     return $.ajax(parseArguments.apply(null, arguments))
326 |   }
327 | 
328 |   $.post = function(/* url, data, success, dataType */){
329 |     var options = parseArguments.apply(null, arguments)
330 |     options.type = 'POST'
331 |     return $.ajax(options)
332 |   }
333 | 
334 |   $.getJSON = function(/* url, data, success */){
335 |     var options = parseArguments.apply(null, arguments)
336 |     options.dataType = 'json'
337 |     return $.ajax(options)
338 |   }
339 | 
340 |   $.fn.load = function(url, data, success){
341 |     if (!this.length) return this
342 |     var self = this, parts = url.split(/\s/), selector,
343 |         options = parseArguments(url, data, success),
344 |         callback = options.success
345 |     if (parts.length > 1) options.url = parts[0], selector = parts[1]
346 |     options.success = function(response){
347 |       self.html(selector ?
348 |         $('<div>').html(response.replace(rscript, "")).find(selector)
349 |         : response)
350 |       callback && callback.apply(self, arguments)
351 |     }
352 |     $.ajax(options)
353 |     return this
354 |   }
355 | 
356 |   var escape = encodeURIComponent
357 | 
358 |   function serialize(params, obj, traditional, scope){
359 |     var type, array = $.isArray(obj), hash = $.isPlainObject(obj)
360 |     $.each(obj, function(key, value) {
361 |       type = $.type(value)
362 |       if (scope) key = traditional ? scope :
363 |         scope + '[' + (hash || type == 'object' || type == 'array' ? key : '') + ']'
364 |       // handle data in serializeArray() format
365 |       if (!scope && array) params.add(value.name, value.value)
366 |       // recurse into nested objects
367 |       else if (type == "array" || (!traditional && type == "object"))
368 |         serialize(params, value, traditional, key)
369 |       else params.add(key, value)
370 |     })
371 |   }
372 | 
373 |   $.param = function(obj, traditional){
374 |     var params = []
375 |     params.add = function(key, value) {
376 |       if ($.isFunction(value)) value = value()
377 |       if (value == null) value = ""
378 |       this.push(escape(key) + '=' + escape(value))
379 |     }
380 |     serialize(params, obj, traditional)
381 |     return params.join('&').replace(/%20/g, '+')
382 |   }
383 | })(Zepto)
384 | 


--------------------------------------------------------------------------------
/src/amd_layout.js:
--------------------------------------------------------------------------------
 1 | (function(global, factory) {
 2 |   if (typeof define === 'function' && define.amd)
 3 |     define(function() { return factory(global) })
 4 |   else
 5 |     factory(global)
 6 | }(window, function(window) {
 7 |   YIELD
 8 |   return Zepto
 9 | }))
10 | 


--------------------------------------------------------------------------------
/src/assets.js:
--------------------------------------------------------------------------------
 1 | //     Zepto.js
 2 | //     (c) 2010-2016 Thomas Fuchs
 3 | //     Zepto.js may be freely distributed under the MIT license.
 4 | 
 5 | ;(function($){
 6 |   var cache = [], timeout
 7 | 
 8 |   $.fn.remove = function(){
 9 |     return this.each(function(){
10 |       if(this.parentNode){
11 |         if(this.tagName === 'IMG'){
12 |           cache.push(this)
13 |           this.src = 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs='
14 |           if (timeout) clearTimeout(timeout)
15 |           timeout = setTimeout(function(){ cache = [] }, 60000)
16 |         }
17 |         this.parentNode.removeChild(this)
18 |       }
19 |     })
20 |   }
21 | })(Zepto)
22 | 


--------------------------------------------------------------------------------
/src/callbacks.js:
--------------------------------------------------------------------------------
  1 | //     Zepto.js
  2 | //     (c) 2010-2016 Thomas Fuchs
  3 | //     Zepto.js may be freely distributed under the MIT license.
  4 | 
  5 | ;(function($){
  6 |   // Create a collection of callbacks to be fired in a sequence, with configurable behaviour
  7 |   // Option flags:
  8 |   //   - once: Callbacks fired at most one time.
  9 |   //   - memory: Remember the most recent context and arguments
 10 |   //   - stopOnFalse: Cease iterating over callback list
 11 |   //   - unique: Permit adding at most one instance of the same callback
 12 |   $.Callbacks = function(options) {
 13 |     options = $.extend({}, options)
 14 | 
 15 |     var memory, // Last fire value (for non-forgettable lists)
 16 |         fired,  // Flag to know if list was already fired
 17 |         firing, // Flag to know if list is currently firing
 18 |         firingStart, // First callback to fire (used internally by add and fireWith)
 19 |         firingLength, // End of the loop when firing
 20 |         firingIndex, // Index of currently firing callback (modified by remove if needed)
 21 |         list = [], // Actual callback list
 22 |         stack = !options.once && [], // Stack of fire calls for repeatable lists
 23 |         fire = function(data) {
 24 |           memory = options.memory && data
 25 |           fired = true
 26 |           firingIndex = firingStart || 0
 27 |           firingStart = 0
 28 |           firingLength = list.length
 29 |           firing = true
 30 |           for ( ; list && firingIndex < firingLength ; ++firingIndex ) {
 31 |             if (list[firingIndex].apply(data[0], data[1]) === false && options.stopOnFalse) {
 32 |               memory = false
 33 |               break
 34 |             }
 35 |           }
 36 |           firing = false
 37 |           if (list) {
 38 |             if (stack) stack.length && fire(stack.shift())
 39 |             else if (memory) list.length = 0
 40 |             else Callbacks.disable()
 41 |           }
 42 |         },
 43 | 
 44 |         Callbacks = {
 45 |           add: function() {
 46 |             if (list) {
 47 |               var start = list.length,
 48 |                   add = function(args) {
 49 |                     $.each(args, function(_, arg){
 50 |                       if (typeof arg === "function") {
 51 |                         if (!options.unique || !Callbacks.has(arg)) list.push(arg)
 52 |                       }
 53 |                       else if (arg && arg.length && typeof arg !== 'string') add(arg)
 54 |                     })
 55 |                   }
 56 |               add(arguments)
 57 |               if (firing) firingLength = list.length
 58 |               else if (memory) {
 59 |                 firingStart = start
 60 |                 fire(memory)
 61 |               }
 62 |             }
 63 |             return this
 64 |           },
 65 |           remove: function() {
 66 |             if (list) {
 67 |               $.each(arguments, function(_, arg){
 68 |                 var index
 69 |                 while ((index = $.inArray(arg, list, index)) > -1) {
 70 |                   list.splice(index, 1)
 71 |                   // Handle firing indexes
 72 |                   if (firing) {
 73 |                     if (index <= firingLength) --firingLength
 74 |                     if (index <= firingIndex) --firingIndex
 75 |                   }
 76 |                 }
 77 |               })
 78 |             }
 79 |             return this
 80 |           },
 81 |           has: function(fn) {
 82 |             return !!(list && (fn ? $.inArray(fn, list) > -1 : list.length))
 83 |           },
 84 |           empty: function() {
 85 |             firingLength = list.length = 0
 86 |             return this
 87 |           },
 88 |           disable: function() {
 89 |             list = stack = memory = undefined
 90 |             return this
 91 |           },
 92 |           disabled: function() {
 93 |             return !list
 94 |           },
 95 |           lock: function() {
 96 |             stack = undefined
 97 |             if (!memory) Callbacks.disable()
 98 |             return this
 99 |           },
100 |           locked: function() {
101 |             return !stack
102 |           },
103 |           fireWith: function(context, args) {
104 |             if (list && (!fired || stack)) {
105 |               args = args || []
106 |               args = [context, args.slice ? args.slice() : args]
107 |               if (firing) stack.push(args)
108 |               else fire(args)
109 |             }
110 |             return this
111 |           },
112 |           fire: function() {
113 |             return Callbacks.fireWith(this, arguments)
114 |           },
115 |           fired: function() {
116 |             return !!fired
117 |           }
118 |         }
119 | 
120 |     return Callbacks
121 |   }
122 | })(Zepto)
123 | 


--------------------------------------------------------------------------------
/src/data.js:
--------------------------------------------------------------------------------
 1 | //     Zepto.js
 2 | //     (c) 2010-2016 Thomas Fuchs
 3 | //     Zepto.js may be freely distributed under the MIT license.
 4 | 
 5 | // The following code is heavily inspired by jQuery's $.fn.data()
 6 | 
 7 | ;(function($){
 8 |   var data = {}, dataAttr = $.fn.data, camelize = $.camelCase,
 9 |     exp = $.expando = 'Zepto' + (+new Date()), emptyArray = []
10 | 
11 |   // Get value from node:
12 |   // 1. first try key as given,
13 |   // 2. then try camelized key,
14 |   // 3. fall back to reading "data-*" attribute.
15 |   function getData(node, name) {
16 |     var id = node[exp], store = id && data[id]
17 |     if (name === undefined) return store || setData(node)
18 |     else {
19 |       if (store) {
20 |         if (name in store) return store[name]
21 |         var camelName = camelize(name)
22 |         if (camelName in store) return store[camelName]
23 |       }
24 |       return dataAttr.call($(node), name)
25 |     }
26 |   }
27 | 
28 |   // Store value under camelized key on node
29 |   function setData(node, name, value) {
30 |     var id = node[exp] || (node[exp] = ++$.uuid),
31 |       store = data[id] || (data[id] = attributeData(node))
32 |     if (name !== undefined) store[camelize(name)] = value
33 |     return store
34 |   }
35 | 
36 |   // Read all "data-*" attributes from a node
37 |   function attributeData(node) {
38 |     var store = {}
39 |     $.each(node.attributes || emptyArray, function(i, attr){
40 |       if (attr.name.indexOf('data-') == 0)
41 |         store[camelize(attr.name.replace('data-', ''))] =
42 |           $.zepto.deserializeValue(attr.value)
43 |     })
44 |     return store
45 |   }
46 | 
47 |   $.fn.data = function(name, value) {
48 |     return value === undefined ?
49 |       // set multiple values via object
50 |       $.isPlainObject(name) ?
51 |         this.each(function(i, node){
52 |           $.each(name, function(key, value){ setData(node, key, value) })
53 |         }) :
54 |         // get value from first element
55 |         (0 in this ? getData(this[0], name) : undefined) :
56 |       // set value on all elements
57 |       this.each(function(){ setData(this, name, value) })
58 |   }
59 | 
60 |   $.data = function(elem, name, value) {
61 |     return $(elem).data(name, value)
62 |   }
63 | 
64 |   $.hasData = function(elem) {
65 |     var id = elem[exp], store = id && data[id]
66 |     return store ? !$.isEmptyObject(store) : false
67 |   }
68 | 
69 |   $.fn.removeData = function(names) {
70 |     if (typeof names == 'string') names = names.split(/\s+/)
71 |     return this.each(function(){
72 |       var id = this[exp], store = id && data[id]
73 |       if (store) $.each(names || store, function(key){
74 |         delete store[names ? camelize(this) : key]
75 |       })
76 |     })
77 |   }
78 | 
79 |   // Generate extended `remove` and `empty` functions
80 |   ;['remove', 'empty'].forEach(function(methodName){
81 |     var origFn = $.fn[methodName]
82 |     $.fn[methodName] = function() {
83 |       var elements = this.find('*')
84 |       if (methodName === 'remove') elements = elements.add(this)
85 |       elements.removeData()
86 |       return origFn.call(this)
87 |     }
88 |   })
89 | })(Zepto)
90 | 


--------------------------------------------------------------------------------
/src/deferred.js:
--------------------------------------------------------------------------------
  1 | //     Zepto.js
  2 | //     (c) 2010-2016 Thomas Fuchs
  3 | //     Zepto.js may be freely distributed under the MIT license.
  4 | //
  5 | //     Some code (c) 2005, 2013 jQuery Foundation, Inc. and other contributors
  6 | 
  7 | ;(function($){
  8 |   var slice = Array.prototype.slice
  9 | 
 10 |   function Deferred(func) {
 11 |     var tuples = [
 12 |           // action, add listener, listener list, final state
 13 |           [ "resolve", "done", $.Callbacks({once:1, memory:1}), "resolved" ],
 14 |           [ "reject", "fail", $.Callbacks({once:1, memory:1}), "rejected" ],
 15 |           [ "notify", "progress", $.Callbacks({memory:1}) ]
 16 |         ],
 17 |         state = "pending",
 18 |         promise = {
 19 |           state: function() {
 20 |             return state
 21 |           },
 22 |           always: function() {
 23 |             deferred.done(arguments).fail(arguments)
 24 |             return this
 25 |           },
 26 |           then: function(/* fnDone [, fnFailed [, fnProgress]] */) {
 27 |             var fns = arguments
 28 |             return Deferred(function(defer){
 29 |               $.each(tuples, function(i, tuple){
 30 |                 var fn = $.isFunction(fns[i]) && fns[i]
 31 |                 deferred[tuple[1]](function(){
 32 |                   var returned = fn && fn.apply(this, arguments)
 33 |                   if (returned && $.isFunction(returned.promise)) {
 34 |                     returned.promise()
 35 |                       .done(defer.resolve)
 36 |                       .fail(defer.reject)
 37 |                       .progress(defer.notify)
 38 |                   } else {
 39 |                     var context = this === promise ? defer.promise() : this,
 40 |                         values = fn ? [returned] : arguments
 41 |                     defer[tuple[0] + "With"](context, values)
 42 |                   }
 43 |                 })
 44 |               })
 45 |               fns = null
 46 |             }).promise()
 47 |           },
 48 | 
 49 |           promise: function(obj) {
 50 |             return obj != null ? $.extend( obj, promise ) : promise
 51 |           }
 52 |         },
 53 |         deferred = {}
 54 | 
 55 |     $.each(tuples, function(i, tuple){
 56 |       var list = tuple[2],
 57 |           stateString = tuple[3]
 58 | 
 59 |       promise[tuple[1]] = list.add
 60 | 
 61 |       if (stateString) {
 62 |         list.add(function(){
 63 |           state = stateString
 64 |         }, tuples[i^1][2].disable, tuples[2][2].lock)
 65 |       }
 66 | 
 67 |       deferred[tuple[0]] = function(){
 68 |         deferred[tuple[0] + "With"](this === deferred ? promise : this, arguments)
 69 |         return this
 70 |       }
 71 |       deferred[tuple[0] + "With"] = list.fireWith
 72 |     })
 73 | 
 74 |     promise.promise(deferred)
 75 |     if (func) func.call(deferred, deferred)
 76 |     return deferred
 77 |   }
 78 | 
 79 |   $.when = function(sub) {
 80 |     var resolveValues = slice.call(arguments),
 81 |         len = resolveValues.length,
 82 |         i = 0,
 83 |         remain = len !== 1 || (sub && $.isFunction(sub.promise)) ? len : 0,
 84 |         deferred = remain === 1 ? sub : Deferred(),
 85 |         progressValues, progressContexts, resolveContexts,
 86 |         updateFn = function(i, ctx, val){
 87 |           return function(value){
 88 |             ctx[i] = this
 89 |             val[i] = arguments.length > 1 ? slice.call(arguments) : value
 90 |             if (val === progressValues) {
 91 |               deferred.notifyWith(ctx, val)
 92 |             } else if (!(--remain)) {
 93 |               deferred.resolveWith(ctx, val)
 94 |             }
 95 |           }
 96 |         }
 97 | 
 98 |     if (len > 1) {
 99 |       progressValues = new Array(len)
100 |       progressContexts = new Array(len)
101 |       resolveContexts = new Array(len)
102 |       for ( ; i < len; ++i ) {
103 |         if (resolveValues[i] && $.isFunction(resolveValues[i].promise)) {
104 |           resolveValues[i].promise()
105 |             .done(updateFn(i, resolveContexts, resolveValues))
106 |             .fail(deferred.reject)
107 |             .progress(updateFn(i, progressContexts, progressValues))
108 |         } else {
109 |           --remain
110 |         }
111 |       }
112 |     }
113 |     if (!remain) deferred.resolveWith(resolveContexts, resolveValues)
114 |     return deferred.promise()
115 |   }
116 | 
117 |   $.Deferred = Deferred
118 | })(Zepto)
119 | 


--------------------------------------------------------------------------------
/src/detect.js:
--------------------------------------------------------------------------------
 1 | //     Zepto.js
 2 | //     (c) 2010-2016 Thomas Fuchs
 3 | //     Zepto.js may be freely distributed under the MIT license.
 4 | 
 5 | ;(function($){
 6 |   function detect(ua, platform){
 7 |     var os = this.os = {}, browser = this.browser = {},
 8 |       webkit = ua.match(/Web[kK]it[\/]{0,1}([\d.]+)/),
 9 |       android = ua.match(/(Android);?[\s\/]+([\d.]+)?/),
10 |       osx = !!ua.match(/\(Macintosh\; Intel /),
11 |       ipad = ua.match(/(iPad).*OS\s([\d_]+)/),
12 |       ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/),
13 |       iphone = !ipad && ua.match(/(iPhone\sOS)\s([\d_]+)/),
14 |       webos = ua.match(/(webOS|hpwOS)[\s\/]([\d.]+)/),
15 |       win = /Win\d{2}|Windows/.test(platform),
16 |       wp = ua.match(/Windows Phone ([\d.]+)/),
17 |       touchpad = webos && ua.match(/TouchPad/),
18 |       kindle = ua.match(/Kindle\/([\d.]+)/),
19 |       silk = ua.match(/Silk\/([\d._]+)/),
20 |       blackberry = ua.match(/(BlackBerry).*Version\/([\d.]+)/),
21 |       bb10 = ua.match(/(BB10).*Version\/([\d.]+)/),
22 |       rimtabletos = ua.match(/(RIM\sTablet\sOS)\s([\d.]+)/),
23 |       playbook = ua.match(/PlayBook/),
24 |       chrome = ua.match(/Chrome\/([\d.]+)/) || ua.match(/CriOS\/([\d.]+)/),
25 |       firefox = ua.match(/Firefox\/([\d.]+)/),
26 |       firefoxos = ua.match(/\((?:Mobile|Tablet); rv:([\d.]+)\).*Firefox\/[\d.]+/),
27 |       ie = ua.match(/MSIE\s([\d.]+)/) || ua.match(/Trident\/[\d](?=[^\?]+).*rv:([0-9.].)/),
28 |       webview = !chrome && ua.match(/(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/),
29 |       safari = webview || ua.match(/Version\/([\d.]+)([^S](Safari)|[^M]*(Mobile)[^S]*(Safari))/)
30 | 
31 |     // Todo: clean this up with a better OS/browser seperation:
32 |     // - discern (more) between multiple browsers on android
33 |     // - decide if kindle fire in silk mode is android or not
34 |     // - Firefox on Android doesn't specify the Android version
35 |     // - possibly devide in os, device and browser hashes
36 | 
37 |     if (browser.webkit = !!webkit) browser.version = webkit[1]
38 | 
39 |     if (android) os.android = true, os.version = android[2]
40 |     if (iphone && !ipod) os.ios = os.iphone = true, os.version = iphone[2].replace(/_/g, '.')
41 |     if (ipad) os.ios = os.ipad = true, os.version = ipad[2].replace(/_/g, '.')
42 |     if (ipod) os.ios = os.ipod = true, os.version = ipod[3] ? ipod[3].replace(/_/g, '.') : null
43 |     if (wp) os.wp = true, os.version = wp[1]
44 |     if (webos) os.webos = true, os.version = webos[2]
45 |     if (touchpad) os.touchpad = true
46 |     if (blackberry) os.blackberry = true, os.version = blackberry[2]
47 |     if (bb10) os.bb10 = true, os.version = bb10[2]
48 |     if (rimtabletos) os.rimtabletos = true, os.version = rimtabletos[2]
49 |     if (playbook) browser.playbook = true
50 |     if (kindle) os.kindle = true, os.version = kindle[1]
51 |     if (silk) browser.silk = true, browser.version = silk[1]
52 |     if (!silk && os.android && ua.match(/Kindle Fire/)) browser.silk = true
53 |     if (chrome) browser.chrome = true, browser.version = chrome[1]
54 |     if (firefox) browser.firefox = true, browser.version = firefox[1]
55 |     if (firefoxos) os.firefoxos = true, os.version = firefoxos[1]
56 |     if (ie) browser.ie = true, browser.version = ie[1]
57 |     if (safari && (osx || os.ios || win)) {
58 |       browser.safari = true
59 |       if (!os.ios) browser.version = safari[1]
60 |     }
61 |     if (webview) browser.webview = true
62 | 
63 |     os.tablet = !!(ipad || playbook || (android && !ua.match(/Mobile/)) ||
64 |       (firefox && ua.match(/Tablet/)) || (ie && !ua.match(/Phone/) && ua.match(/Touch/)))
65 |     os.phone  = !!(!os.tablet && !os.ipod && (android || iphone || webos || blackberry || bb10 ||
66 |       (chrome && ua.match(/Android/)) || (chrome && ua.match(/CriOS\/([\d.]+)/)) ||
67 |       (firefox && ua.match(/Mobile/)) || (ie && ua.match(/Touch/))))
68 |   }
69 | 
70 |   detect.call($, navigator.userAgent, navigator.platform)
71 |   // make available to unit tests
72 |   $.__detect = detect
73 | 
74 | })(Zepto)
75 | 


--------------------------------------------------------------------------------
/src/event.js:
--------------------------------------------------------------------------------
  1 | //     Zepto.js
  2 | //     (c) 2010-2016 Thomas Fuchs
  3 | //     Zepto.js may be freely distributed under the MIT license.
  4 | 
  5 | ;(function($){
  6 |   var _zid = 1, undefined,
  7 |       slice = Array.prototype.slice,
  8 |       isFunction = $.isFunction,
  9 |       isString = function(obj){ return typeof obj == 'string' },
 10 |       handlers = {},
 11 |       specialEvents={},
 12 |       focusinSupported = 'onfocusin' in window,
 13 |       focus = { focus: 'focusin', blur: 'focusout' },
 14 |       hover = { mouseenter: 'mouseover', mouseleave: 'mouseout' }
 15 | 
 16 |   specialEvents.click = specialEvents.mousedown = specialEvents.mouseup = specialEvents.mousemove = 'MouseEvents'
 17 | 
 18 |   function zid(element) {
 19 |     return element._zid || (element._zid = _zid++)
 20 |   }
 21 |   function findHandlers(element, event, fn, selector) {
 22 |     event = parse(event)
 23 |     if (event.ns) var matcher = matcherFor(event.ns)
 24 |     return (handlers[zid(element)] || []).filter(function(handler) {
 25 |       return handler
 26 |         && (!event.e  || handler.e == event.e)
 27 |         && (!event.ns || matcher.test(handler.ns))
 28 |         && (!fn       || zid(handler.fn) === zid(fn))
 29 |         && (!selector || handler.sel == selector)
 30 |     })
 31 |   }
 32 |   function parse(event) {
 33 |     var parts = ('' + event).split('.')
 34 |     return {e: parts[0], ns: parts.slice(1).sort().join(' ')}
 35 |   }
 36 |   function matcherFor(ns) {
 37 |     return new RegExp('(?:^| )' + ns.replace(' ', ' .* ?') + '(?: |$)')
 38 |   }
 39 | 
 40 |   function eventCapture(handler, captureSetting) {
 41 |     return handler.del &&
 42 |       (!focusinSupported && (handler.e in focus)) ||
 43 |       !!captureSetting
 44 |   }
 45 | 
 46 |   function realEvent(type) {
 47 |     return hover[type] || (focusinSupported && focus[type]) || type
 48 |   }
 49 | 
 50 |   function add(element, events, fn, data, selector, delegator, capture){
 51 |     var id = zid(element), set = (handlers[id] || (handlers[id] = []))
 52 |     events.split(/\s/).forEach(function(event){
 53 |       if (event == 'ready') return $(document).ready(fn)
 54 |       var handler   = parse(event)
 55 |       handler.fn    = fn
 56 |       handler.sel   = selector
 57 |       // emulate mouseenter, mouseleave
 58 |       if (handler.e in hover) fn = function(e){
 59 |         var related = e.relatedTarget
 60 |         if (!related || (related !== this && !$.contains(this, related)))
 61 |           return handler.fn.apply(this, arguments)
 62 |       }
 63 |       handler.del   = delegator
 64 |       var callback  = delegator || fn
 65 |       handler.proxy = function(e){
 66 |         e = compatible(e)
 67 |         if (e.isImmediatePropagationStopped()) return
 68 |         e.data = data
 69 |         var result = callback.apply(element, e._args == undefined ? [e] : [e].concat(e._args))
 70 |         if (result === false) e.preventDefault(), e.stopPropagation()
 71 |         return result
 72 |       }
 73 |       handler.i = set.length
 74 |       set.push(handler)
 75 |       if ('addEventListener' in element)
 76 |         element.addEventListener(realEvent(handler.e), handler.proxy, eventCapture(handler, capture))
 77 |     })
 78 |   }
 79 |   function remove(element, events, fn, selector, capture){
 80 |     var id = zid(element)
 81 |     ;(events || '').split(/\s/).forEach(function(event){
 82 |       findHandlers(element, event, fn, selector).forEach(function(handler){
 83 |         delete handlers[id][handler.i]
 84 |       if ('removeEventListener' in element)
 85 |         element.removeEventListener(realEvent(handler.e), handler.proxy, eventCapture(handler, capture))
 86 |       })
 87 |     })
 88 |   }
 89 | 
 90 |   $.event = { add: add, remove: remove }
 91 | 
 92 |   $.proxy = function(fn, context) {
 93 |     var args = (2 in arguments) && slice.call(arguments, 2)
 94 |     if (isFunction(fn)) {
 95 |       var proxyFn = function(){ return fn.apply(context, args ? args.concat(slice.call(arguments)) : arguments) }
 96 |       proxyFn._zid = zid(fn)
 97 |       return proxyFn
 98 |     } else if (isString(context)) {
 99 |       if (args) {
100 |         args.unshift(fn[context], fn)
101 |         return $.proxy.apply(null, args)
102 |       } else {
103 |         return $.proxy(fn[context], fn)
104 |       }
105 |     } else {
106 |       throw new TypeError("expected function")
107 |     }
108 |   }
109 | 
110 |   $.fn.bind = function(event, data, callback){
111 |     return this.on(event, data, callback)
112 |   }
113 |   $.fn.unbind = function(event, callback){
114 |     return this.off(event, callback)
115 |   }
116 |   $.fn.one = function(event, selector, data, callback){
117 |     return this.on(event, selector, data, callback, 1)
118 |   }
119 | 
120 |   var returnTrue = function(){return true},
121 |       returnFalse = function(){return false},
122 |       ignoreProperties = /^([A-Z]|returnValue$|layer[XY]$|webkitMovement[XY]$)/,
123 |       eventMethods = {
124 |         preventDefault: 'isDefaultPrevented',
125 |         stopImmediatePropagation: 'isImmediatePropagationStopped',
126 |         stopPropagation: 'isPropagationStopped'
127 |       }
128 | 
129 |   function compatible(event, source) {
130 |     if (source || !event.isDefaultPrevented) {
131 |       source || (source = event)
132 | 
133 |       $.each(eventMethods, function(name, predicate) {
134 |         var sourceMethod = source[name]
135 |         event[name] = function(){
136 |           this[predicate] = returnTrue
137 |           return sourceMethod && sourceMethod.apply(source, arguments)
138 |         }
139 |         event[predicate] = returnFalse
140 |       })
141 | 
142 |       try {
143 |         event.timeStamp || (event.timeStamp = Date.now())
144 |       } catch (ignored) { }
145 | 
146 |       if (source.defaultPrevented !== undefined ? source.defaultPrevented :
147 |           'returnValue' in source ? source.returnValue === false :
148 |           source.getPreventDefault && source.getPreventDefault())
149 |         event.isDefaultPrevented = returnTrue
150 |     }
151 |     return event
152 |   }
153 | 
154 |   function createProxy(event) {
155 |     var key, proxy = { originalEvent: event }
156 |     for (key in event)
157 |       if (!ignoreProperties.test(key) && event[key] !== undefined) proxy[key] = event[key]
158 | 
159 |     return compatible(proxy, event)
160 |   }
161 | 
162 |   $.fn.delegate = function(selector, event, callback){
163 |     return this.on(event, selector, callback)
164 |   }
165 |   $.fn.undelegate = function(selector, event, callback){
166 |     return this.off(event, selector, callback)
167 |   }
168 | 
169 |   $.fn.live = function(event, callback){
170 |     $(document.body).delegate(this.selector, event, callback)
171 |     return this
172 |   }
173 |   $.fn.die = function(event, callback){
174 |     $(document.body).undelegate(this.selector, event, callback)
175 |     return this
176 |   }
177 | 
178 |   $.fn.on = function(event, selector, data, callback, one){
179 |     var autoRemove, delegator, $this = this
180 |     if (event && !isString(event)) {
181 |       $.each(event, function(type, fn){
182 |         $this.on(type, selector, data, fn, one)
183 |       })
184 |       return $this
185 |     }
186 | 
187 |     if (!isString(selector) && !isFunction(callback) && callback !== false)
188 |       callback = data, data = selector, selector = undefined
189 |     if (callback === undefined || data === false)
190 |       callback = data, data = undefined
191 | 
192 |     if (callback === false) callback = returnFalse
193 | 
194 |     return $this.each(function(_, element){
195 |       if (one) autoRemove = function(e){
196 |         remove(element, e.type, callback)
197 |         return callback.apply(this, arguments)
198 |       }
199 | 
200 |       if (selector) delegator = function(e){
201 |         var evt, match = $(e.target).closest(selector, element).get(0)
202 |         if (match && match !== element) {
203 |           evt = $.extend(createProxy(e), {currentTarget: match, liveFired: element})
204 |           return (autoRemove || callback).apply(match, [evt].concat(slice.call(arguments, 1)))
205 |         }
206 |       }
207 | 
208 |       add(element, event, callback, data, selector, delegator || autoRemove)
209 |     })
210 |   }
211 |   $.fn.off = function(event, selector, callback){
212 |     var $this = this
213 |     if (event && !isString(event)) {
214 |       $.each(event, function(type, fn){
215 |         $this.off(type, selector, fn)
216 |       })
217 |       return $this
218 |     }
219 | 
220 |     if (!isString(selector) && !isFunction(callback) && callback !== false)
221 |       callback = selector, selector = undefined
222 | 
223 |     if (callback === false) callback = returnFalse
224 | 
225 |     return $this.each(function(){
226 |       remove(this, event, callback, selector)
227 |     })
228 |   }
229 | 
230 |   $.fn.trigger = function(event, args){
231 |     event = (isString(event) || $.isPlainObject(event)) ? $.Event(event) : compatible(event)
232 |     event._args = args
233 |     return this.each(function(){
234 |       // handle focus(), blur() by calling them directly
235 |       if (event.type in focus && typeof this[event.type] == "function") this[event.type]()
236 |       // items in the collection might not be DOM elements
237 |       else if ('dispatchEvent' in this) this.dispatchEvent(event)
238 |       else $(this).triggerHandler(event, args)
239 |     })
240 |   }
241 | 
242 |   // triggers event handlers on current element just as if an event occurred,
243 |   // doesn't trigger an actual event, doesn't bubble
244 |   $.fn.triggerHandler = function(event, args){
245 |     var e, result
246 |     this.each(function(i, element){
247 |       e = createProxy(isString(event) ? $.Event(event) : event)
248 |       e._args = args
249 |       e.target = element
250 |       $.each(findHandlers(element, event.type || event), function(i, handler){
251 |         result = handler.proxy(e)
252 |         if (e.isImmediatePropagationStopped()) return false
253 |       })
254 |     })
255 |     return result
256 |   }
257 | 
258 |   // shortcut methods for `.bind(event, fn)` for each event type
259 |   ;('focusin focusout focus blur load resize scroll unload click dblclick '+
260 |   'mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave '+
261 |   'change select keydown keypress keyup error').split(' ').forEach(function(event) {
262 |     $.fn[event] = function(callback) {
263 |       return (0 in arguments) ?
264 |         this.bind(event, callback) :
265 |         this.trigger(event)
266 |     }
267 |   })
268 | 
269 |   $.Event = function(type, props) {
270 |     if (!isString(type)) props = type, type = props.type
271 |     var event = document.createEvent(specialEvents[type] || 'Events'), bubbles = true
272 |     if (props) for (var name in props) (name == 'bubbles') ? (bubbles = !!props[name]) : (event[name] = props[name])
273 |     event.initEvent(type, bubbles, true)
274 |     return compatible(event)
275 |   }
276 | 
277 | })(Zepto)
278 | 


--------------------------------------------------------------------------------
/src/form.js:
--------------------------------------------------------------------------------
 1 | //     Zepto.js
 2 | //     (c) 2010-2016 Thomas Fuchs
 3 | //     Zepto.js may be freely distributed under the MIT license.
 4 | 
 5 | ;(function($){
 6 |   $.fn.serializeArray = function() {
 7 |     var name, type, result = [],
 8 |       add = function(value) {
 9 |         if (value.forEach) return value.forEach(add)
10 |         result.push({ name: name, value: value })
11 |       }
12 |     if (this[0]) $.each(this[0].elements, function(_, field){
13 |       type = field.type, name = field.name
14 |       if (name && field.nodeName.toLowerCase() != 'fieldset' &&
15 |         !field.disabled && type != 'submit' && type != 'reset' && type != 'button' && type != 'file' &&
16 |         ((type != 'radio' && type != 'checkbox') || field.checked))
17 |           add($(field).val())
18 |     })
19 |     return result
20 |   }
21 | 
22 |   $.fn.serialize = function(){
23 |     var result = []
24 |     this.serializeArray().forEach(function(elm){
25 |       result.push(encodeURIComponent(elm.name) + '=' + encodeURIComponent(elm.value))
26 |     })
27 |     return result.join('&')
28 |   }
29 | 
30 |   $.fn.submit = function(callback) {
31 |     if (0 in arguments) this.bind('submit', callback)
32 |     else if (this.length) {
33 |       var event = $.Event('submit')
34 |       this.eq(0).trigger(event)
35 |       if (!event.isDefaultPrevented()) this.get(0).submit()
36 |     }
37 |     return this
38 |   }
39 | 
40 | })(Zepto)
41 | 


--------------------------------------------------------------------------------
/src/fx.js:
--------------------------------------------------------------------------------
  1 | //     Zepto.js
  2 | //     (c) 2010-2016 Thomas Fuchs
  3 | //     Zepto.js may be freely distributed under the MIT license.
  4 | 
  5 | ;(function($, undefined){
  6 |   var prefix = '', eventPrefix,
  7 |     vendors = { Webkit: 'webkit', Moz: '', O: 'o' },
  8 |     testEl = document.createElement('div'),
  9 |     supportedTransforms = /^((translate|rotate|scale)(X|Y|Z|3d)?|matrix(3d)?|perspective|skew(X|Y)?)$/i,
 10 |     transform,
 11 |     transitionProperty, transitionDuration, transitionTiming, transitionDelay,
 12 |     animationName, animationDuration, animationTiming, animationDelay,
 13 |     cssReset = {}
 14 | 
 15 |   function dasherize(str) { return str.replace(/([A-Z])/g, '-$1').toLowerCase() }
 16 |   function normalizeEvent(name) { return eventPrefix ? eventPrefix + name : name.toLowerCase() }
 17 | 
 18 |   if (testEl.style.transform === undefined) $.each(vendors, function(vendor, event){
 19 |     if (testEl.style[vendor + 'TransitionProperty'] !== undefined) {
 20 |       prefix = '-' + vendor.toLowerCase() + '-'
 21 |       eventPrefix = event
 22 |       return false
 23 |     }
 24 |   })
 25 | 
 26 |   transform = prefix + 'transform'
 27 |   cssReset[transitionProperty = prefix + 'transition-property'] =
 28 |   cssReset[transitionDuration = prefix + 'transition-duration'] =
 29 |   cssReset[transitionDelay    = prefix + 'transition-delay'] =
 30 |   cssReset[transitionTiming   = prefix + 'transition-timing-function'] =
 31 |   cssReset[animationName      = prefix + 'animation-name'] =
 32 |   cssReset[animationDuration  = prefix + 'animation-duration'] =
 33 |   cssReset[animationDelay     = prefix + 'animation-delay'] =
 34 |   cssReset[animationTiming    = prefix + 'animation-timing-function'] = ''
 35 | 
 36 |   $.fx = {
 37 |     off: (eventPrefix === undefined && testEl.style.transitionProperty === undefined),
 38 |     speeds: { _default: 400, fast: 200, slow: 600 },
 39 |     cssPrefix: prefix,
 40 |     transitionEnd: normalizeEvent('TransitionEnd'),
 41 |     animationEnd: normalizeEvent('AnimationEnd')
 42 |   }
 43 | 
 44 |   $.fn.animate = function(properties, duration, ease, callback, delay){
 45 |     if ($.isFunction(duration))
 46 |       callback = duration, ease = undefined, duration = undefined
 47 |     if ($.isFunction(ease))
 48 |       callback = ease, ease = undefined
 49 |     if ($.isPlainObject(duration))
 50 |       ease = duration.easing, callback = duration.complete, delay = duration.delay, duration = duration.duration
 51 |     if (duration) duration = (typeof duration == 'number' ? duration :
 52 |                     ($.fx.speeds[duration] || $.fx.speeds._default)) / 1000
 53 |     if (delay) delay = parseFloat(delay) / 1000
 54 |     return this.anim(properties, duration, ease, callback, delay)
 55 |   }
 56 | 
 57 |   $.fn.anim = function(properties, duration, ease, callback, delay){
 58 |     var key, cssValues = {}, cssProperties, transforms = '',
 59 |         that = this, wrappedCallback, endEvent = $.fx.transitionEnd,
 60 |         fired = false
 61 | 
 62 |     if (duration === undefined) duration = $.fx.speeds._default / 1000
 63 |     if (delay === undefined) delay = 0
 64 |     if ($.fx.off) duration = 0
 65 | 
 66 |     if (typeof properties == 'string') {
 67 |       // keyframe animation
 68 |       cssValues[animationName] = properties
 69 |       cssValues[animationDuration] = duration + 's'
 70 |       cssValues[animationDelay] = delay + 's'
 71 |       cssValues[animationTiming] = (ease || 'linear')
 72 |       endEvent = $.fx.animationEnd
 73 |     } else {
 74 |       cssProperties = []
 75 |       // CSS transitions
 76 |       for (key in properties)
 77 |         if (supportedTransforms.test(key)) transforms += key + '(' + properties[key] + ') '
 78 |         else cssValues[key] = properties[key], cssProperties.push(dasherize(key))
 79 | 
 80 |       if (transforms) cssValues[transform] = transforms, cssProperties.push(transform)
 81 |       if (duration > 0 && typeof properties === 'object') {
 82 |         cssValues[transitionProperty] = cssProperties.join(', ')
 83 |         cssValues[transitionDuration] = duration + 's'
 84 |         cssValues[transitionDelay] = delay + 's'
 85 |         cssValues[transitionTiming] = (ease || 'linear')
 86 |       }
 87 |     }
 88 | 
 89 |     wrappedCallback = function(event){
 90 |       if (typeof event !== 'undefined') {
 91 |         if (event.target !== event.currentTarget) return // makes sure the event didn't bubble from "below"
 92 |         $(event.target).unbind(endEvent, wrappedCallback)
 93 |       } else
 94 |         $(this).unbind(endEvent, wrappedCallback) // triggered by setTimeout
 95 | 
 96 |       fired = true
 97 |       $(this).css(cssReset)
 98 |       callback && callback.call(this)
 99 |     }
100 |     if (duration > 0){
101 |       this.bind(endEvent, wrappedCallback)
102 |       // transitionEnd is not always firing on older Android phones
103 |       // so make sure it gets fired
104 |       setTimeout(function(){
105 |         if (fired) return
106 |         wrappedCallback.call(that)
107 |       }, ((duration + delay) * 1000) + 25)
108 |     }
109 | 
110 |     // trigger page reflow so new elements can animate
111 |     this.size() && this.get(0).clientLeft
112 | 
113 |     this.css(cssValues)
114 | 
115 |     if (duration <= 0) setTimeout(function() {
116 |       that.each(function(){ wrappedCallback.call(this) })
117 |     }, 0)
118 | 
119 |     return this
120 |   }
121 | 
122 |   testEl = null
123 | })(Zepto)
124 | 


--------------------------------------------------------------------------------
/src/fx_methods.js:
--------------------------------------------------------------------------------
 1 | //     Zepto.js
 2 | //     (c) 2010-2016 Thomas Fuchs
 3 | //     Zepto.js may be freely distributed under the MIT license.
 4 | 
 5 | ;(function($, undefined){
 6 |   var document = window.document,
 7 |     origShow = $.fn.show, origHide = $.fn.hide, origToggle = $.fn.toggle
 8 | 
 9 |   function anim(el, speed, opacity, scale, callback) {
10 |     if (typeof speed == 'function' && !callback) callback = speed, speed = undefined
11 |     var props = { opacity: opacity }
12 |     if (scale) {
13 |       props.scale = scale
14 |       el.css($.fx.cssPrefix + 'transform-origin', '0 0')
15 |     }
16 |     return el.animate(props, speed, null, callback)
17 |   }
18 | 
19 |   function hide(el, speed, scale, callback) {
20 |     return anim(el, speed, 0, scale, function(){
21 |       origHide.call($(this))
22 |       callback && callback.call(this)
23 |     })
24 |   }
25 | 
26 |   $.fn.show = function(speed, callback) {
27 |     origShow.call(this)
28 |     if (speed === undefined) speed = 0
29 |     else this.css('opacity', 0)
30 |     return anim(this, speed, 1, '1,1', callback)
31 |   }
32 | 
33 |   $.fn.hide = function(speed, callback) {
34 |     if (speed === undefined) return origHide.call(this)
35 |     else return hide(this, speed, '0,0', callback)
36 |   }
37 | 
38 |   $.fn.toggle = function(speed, callback) {
39 |     if (speed === undefined || typeof speed == 'boolean')
40 |       return origToggle.call(this, speed)
41 |     else return this.each(function(){
42 |       var el = $(this)
43 |       el[el.css('display') == 'none' ? 'show' : 'hide'](speed, callback)
44 |     })
45 |   }
46 | 
47 |   $.fn.fadeTo = function(speed, opacity, callback) {
48 |     return anim(this, speed, opacity, null, callback)
49 |   }
50 | 
51 |   $.fn.fadeIn = function(speed, callback) {
52 |     var target = this.css('opacity')
53 |     if (target > 0) this.css('opacity', 0)
54 |     else target = 1
55 |     return origShow.call(this).fadeTo(speed, target, callback)
56 |   }
57 | 
58 |   $.fn.fadeOut = function(speed, callback) {
59 |     return hide(this, speed, null, callback)
60 |   }
61 | 
62 |   $.fn.fadeToggle = function(speed, callback) {
63 |     return this.each(function(){
64 |       var el = $(this)
65 |       el[
66 |         (el.css('opacity') == 0 || el.css('display') == 'none') ? 'fadeIn' : 'fadeOut'
67 |       ](speed, callback)
68 |     })
69 |   }
70 | 
71 | })(Zepto)
72 | 


--------------------------------------------------------------------------------
/src/gesture.js:
--------------------------------------------------------------------------------
 1 | //     Zepto.js
 2 | //     (c) 2010-2016 Thomas Fuchs
 3 | //     Zepto.js may be freely distributed under the MIT license.
 4 | 
 5 | ;(function($){
 6 |   if ($.os.ios) {
 7 |     var gesture = {}, gestureTimeout
 8 | 
 9 |     function parentIfText(node){
10 |       return 'tagName' in node ? node : node.parentNode
11 |     }
12 | 
13 |     $(document).bind('gesturestart', function(e){
14 |       var now = Date.now(), delta = now - (gesture.last || now)
15 |       gesture.target = parentIfText(e.target)
16 |       gestureTimeout && clearTimeout(gestureTimeout)
17 |       gesture.e1 = e.scale
18 |       gesture.last = now
19 |     }).bind('gesturechange', function(e){
20 |       gesture.e2 = e.scale
21 |     }).bind('gestureend', function(e){
22 |       if (gesture.e2 > 0) {
23 |         Math.abs(gesture.e1 - gesture.e2) != 0 && $(gesture.target).trigger('pinch') &&
24 |           $(gesture.target).trigger('pinch' + (gesture.e1 - gesture.e2 > 0 ? 'In' : 'Out'))
25 |         gesture.e1 = gesture.e2 = gesture.last = 0
26 |       } else if ('last' in gesture) {
27 |         gesture = {}
28 |       }
29 |     })
30 | 
31 |     ;['pinch', 'pinchIn', 'pinchOut'].forEach(function(m){
32 |       $.fn[m] = function(callback){ return this.bind(m, callback) }
33 |     })
34 |   }
35 | })(Zepto)
36 | 


--------------------------------------------------------------------------------
/src/ie.js:
--------------------------------------------------------------------------------
 1 | //     Zepto.js
 2 | //     (c) 2010-2016 Thomas Fuchs
 3 | //     Zepto.js may be freely distributed under the MIT license.
 4 | 
 5 | ;(function(){
 6 |   // getComputedStyle shouldn't freak out when called
 7 |   // without a valid element as argument
 8 |   try {
 9 |     getComputedStyle(undefined)
10 |   } catch(e) {
11 |     var nativeGetComputedStyle = getComputedStyle
12 |     window.getComputedStyle = function(element, pseudoElement){
13 |       try {
14 |         return nativeGetComputedStyle(element, pseudoElement)
15 |       } catch(e) {
16 |         return null
17 |       }
18 |     }
19 |   }
20 | })()
21 | 


--------------------------------------------------------------------------------
/src/ios3.js:
--------------------------------------------------------------------------------
 1 | //     Zepto.js
 2 | //     (c) 2010-2016 Thomas Fuchs
 3 | //     Zepto.js may be freely distributed under the MIT license.
 4 | 
 5 | ;(function(undefined){
 6 |   if (String.prototype.trim === undefined) // fix for iOS 3.2
 7 |     String.prototype.trim = function(){ return this.replace(/^\s+|\s+$/g, '') }
 8 | 
 9 |   // For iOS 3.x
10 |   // from https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/reduce
11 |   if (Array.prototype.reduce === undefined)
12 |     Array.prototype.reduce = function(fun){
13 |       if(this === void 0 || this === null) throw new TypeError()
14 |       var t = Object(this), len = t.length >>> 0, k = 0, accumulator
15 |       if(typeof fun != 'function') throw new TypeError()
16 |       if(len == 0 && arguments.length == 1) throw new TypeError()
17 | 
18 |       if(arguments.length >= 2)
19 |        accumulator = arguments[1]
20 |       else
21 |         do{
22 |           if(k in t){
23 |             accumulator = t[k++]
24 |             break
25 |           }
26 |           if(++k >= len) throw new TypeError()
27 |         } while (true)
28 | 
29 |       while (k < len){
30 |         if(k in t) accumulator = fun.call(undefined, accumulator, t[k], k, t)
31 |         k++
32 |       }
33 |       return accumulator
34 |     }
35 | 
36 | })()
37 | 


--------------------------------------------------------------------------------
/src/selector.js:
--------------------------------------------------------------------------------
 1 | //     Zepto.js
 2 | //     (c) 2010-2016 Thomas Fuchs
 3 | //     Zepto.js may be freely distributed under the MIT license.
 4 | 
 5 | ;(function($){
 6 |   var zepto = $.zepto, oldQsa = zepto.qsa, oldMatches = zepto.matches
 7 | 
 8 |   function visible(elem){
 9 |     elem = $(elem)
10 |     return !!(elem.width() || elem.height()) && elem.css("display") !== "none"
11 |   }
12 | 
13 |   // Implements a subset from:
14 |   // http://api.jquery.com/category/selectors/jquery-selector-extensions/
15 |   //
16 |   // Each filter function receives the current index, all nodes in the
17 |   // considered set, and a value if there were parentheses. The value
18 |   // of `this` is the node currently being considered. The function returns the
19 |   // resulting node(s), null, or undefined.
20 |   //
21 |   // Complex selectors are not supported:
22 |   //   li:has(label:contains("foo")) + li:has(label:contains("bar"))
23 |   //   ul.inner:first > li
24 |   var filters = $.expr[':'] = {
25 |     visible:  function(){ if (visible(this)) return this },
26 |     hidden:   function(){ if (!visible(this)) return this },
27 |     selected: function(){ if (this.selected) return this },
28 |     checked:  function(){ if (this.checked) return this },
29 |     parent:   function(){ return this.parentNode },
30 |     first:    function(idx){ if (idx === 0) return this },
31 |     last:     function(idx, nodes){ if (idx === nodes.length - 1) return this },
32 |     eq:       function(idx, _, value){ if (idx === value) return this },
33 |     contains: function(idx, _, text){ if ($(this).text().indexOf(text) > -1) return this },
34 |     has:      function(idx, _, sel){ if (zepto.qsa(this, sel).length) return this }
35 |   }
36 | 
37 |   var filterRe = new RegExp('(.*):(\\w+)(?:\\(([^)]+)\\))?$\\s*'),
38 |       childRe  = /^\s*>/,
39 |       classTag = 'Zepto' + (+new Date())
40 | 
41 |   function process(sel, fn) {
42 |     // quote the hash in `a[href^=#]` expression
43 |     sel = sel.replace(/=#\]/g, '="#"]')
44 |     var filter, arg, match = filterRe.exec(sel)
45 |     if (match && match[2] in filters) {
46 |       filter = filters[match[2]], arg = match[3]
47 |       sel = match[1]
48 |       if (arg) {
49 |         var num = Number(arg)
50 |         if (isNaN(num)) arg = arg.replace(/^["']|["']$/g, '')
51 |         else arg = num
52 |       }
53 |     }
54 |     return fn(sel, filter, arg)
55 |   }
56 | 
57 |   zepto.qsa = function(node, selector) {
58 |     return process(selector, function(sel, filter, arg){
59 |       try {
60 |         var taggedParent
61 |         if (!sel && filter) sel = '*'
62 |         else if (childRe.test(sel))
63 |           // support "> *" child queries by tagging the parent node with a
64 |           // unique class and prepending that classname onto the selector
65 |           taggedParent = $(node).addClass(classTag), sel = '.'+classTag+' '+sel
66 | 
67 |         var nodes = oldQsa(node, sel)
68 |       } catch(e) {
69 |         console.error('error performing selector: %o', selector)
70 |         throw e
71 |       } finally {
72 |         if (taggedParent) taggedParent.removeClass(classTag)
73 |       }
74 |       return !filter ? nodes :
75 |         zepto.uniq($.map(nodes, function(n, i){ return filter.call(n, i, nodes, arg) }))
76 |     })
77 |   }
78 | 
79 |   zepto.matches = function(node, selector){
80 |     return process(selector, function(sel, filter, arg){
81 |       return (!sel || oldMatches(node, sel)) &&
82 |         (!filter || filter.call(node, null, arg) === node)
83 |     })
84 |   }
85 | })(Zepto)
86 | 


--------------------------------------------------------------------------------
/src/stack.js:
--------------------------------------------------------------------------------
 1 | //     Zepto.js
 2 | //     (c) 2010-2016 Thomas Fuchs
 3 | //     Zepto.js may be freely distributed under the MIT license.
 4 | 
 5 | ;(function($){
 6 |   $.fn.end = function(){
 7 |     return this.prevObject || $()
 8 |   }
 9 | 
10 |   $.fn.andSelf = function(){
11 |     return this.add(this.prevObject || $())
12 |   }
13 | 
14 |   'filter,add,not,eq,first,last,find,closest,parents,parent,children,siblings'.split(',').forEach(function(property){
15 |     var fn = $.fn[property]
16 |     $.fn[property] = function(){
17 |       var ret = fn.apply(this, arguments)
18 |       ret.prevObject = this
19 |       return ret
20 |     }
21 |   })
22 | })(Zepto)
23 | 


--------------------------------------------------------------------------------
/src/touch.js:
--------------------------------------------------------------------------------
  1 | //     Zepto.js
  2 | //     (c) 2010-2016 Thomas Fuchs
  3 | //     Zepto.js may be freely distributed under the MIT license.
  4 | 
  5 | ;(function($){
  6 |   var touch = {},
  7 |     touchTimeout, tapTimeout, swipeTimeout, longTapTimeout,
  8 |     longTapDelay = 750,
  9 |     gesture,
 10 |     down, up, move,
 11 |     eventMap,
 12 |     initialized = false
 13 | 
 14 |   function swipeDirection(x1, x2, y1, y2) {
 15 |     return Math.abs(x1 - x2) >=
 16 |       Math.abs(y1 - y2) ? (x1 - x2 > 0 ? 'Left' : 'Right') : (y1 - y2 > 0 ? 'Up' : 'Down')
 17 |   }
 18 | 
 19 |   function longTap() {
 20 |     longTapTimeout = null
 21 |     if (touch.last) {
 22 |       touch.el.trigger('longTap')
 23 |       touch = {}
 24 |     }
 25 |   }
 26 | 
 27 |   function cancelLongTap() {
 28 |     if (longTapTimeout) clearTimeout(longTapTimeout)
 29 |     longTapTimeout = null
 30 |   }
 31 | 
 32 |   function cancelAll() {
 33 |     if (touchTimeout) clearTimeout(touchTimeout)
 34 |     if (tapTimeout) clearTimeout(tapTimeout)
 35 |     if (swipeTimeout) clearTimeout(swipeTimeout)
 36 |     if (longTapTimeout) clearTimeout(longTapTimeout)
 37 |     touchTimeout = tapTimeout = swipeTimeout = longTapTimeout = null
 38 |     touch = {}
 39 |   }
 40 | 
 41 |   function isPrimaryTouch(event){
 42 |     return (event.pointerType == 'touch' ||
 43 |       event.pointerType == event.MSPOINTER_TYPE_TOUCH)
 44 |       && event.isPrimary
 45 |   }
 46 | 
 47 |   function isPointerEventType(e, type){
 48 |     return (e.type == 'pointer'+type ||
 49 |       e.type.toLowerCase() == 'mspointer'+type)
 50 |   }
 51 | 
 52 |   // helper function for tests, so they check for different APIs
 53 |   function unregisterTouchEvents(){
 54 |     if (!initialized) return
 55 |     $(document).off(eventMap.down, down)
 56 |       .off(eventMap.up, up)
 57 |       .off(eventMap.move, move)
 58 |       .off(eventMap.cancel, cancelAll)
 59 |     $(window).off('scroll', cancelAll)
 60 |     cancelAll()
 61 |     initialized = false
 62 |   }
 63 | 
 64 |   function setup(__eventMap){
 65 |     var now, delta, deltaX = 0, deltaY = 0, firstTouch, _isPointerType
 66 | 
 67 |     unregisterTouchEvents()
 68 | 
 69 |     eventMap = (__eventMap && ('down' in __eventMap)) ? __eventMap :
 70 |       ('ontouchstart' in document ?
 71 |       { 'down': 'touchstart', 'up': 'touchend',
 72 |         'move': 'touchmove', 'cancel': 'touchcancel' } :
 73 |       'onpointerdown' in document ?
 74 |       { 'down': 'pointerdown', 'up': 'pointerup',
 75 |         'move': 'pointermove', 'cancel': 'pointercancel' } :
 76 |        'onmspointerdown' in document ?
 77 |       { 'down': 'MSPointerDown', 'up': 'MSPointerUp',
 78 |         'move': 'MSPointerMove', 'cancel': 'MSPointerCancel' } : false)
 79 | 
 80 |     // No API availables for touch events
 81 |     if (!eventMap) return
 82 | 
 83 |     if ('MSGesture' in window) {
 84 |       gesture = new MSGesture()
 85 |       gesture.target = document.body
 86 | 
 87 |       $(document)
 88 |         .bind('MSGestureEnd', function(e){
 89 |           var swipeDirectionFromVelocity =
 90 |             e.velocityX > 1 ? 'Right' : e.velocityX < -1 ? 'Left' : e.velocityY > 1 ? 'Down' : e.velocityY < -1 ? 'Up' : null
 91 |           if (swipeDirectionFromVelocity) {
 92 |             touch.el.trigger('swipe')
 93 |             touch.el.trigger('swipe'+ swipeDirectionFromVelocity)
 94 |           }
 95 |         })
 96 |     }
 97 | 
 98 |     down = function(e){
 99 |       if((_isPointerType = isPointerEventType(e, 'down')) &&
100 |         !isPrimaryTouch(e)) return
101 |       firstTouch = _isPointerType ? e : e.touches[0]
102 |       if (e.touches && e.touches.length === 1 && touch.x2) {
103 |         // Clear out touch movement data if we have it sticking around
104 |         // This can occur if touchcancel doesn't fire due to preventDefault, etc.
105 |         touch.x2 = undefined
106 |         touch.y2 = undefined
107 |       }
108 |       now = Date.now()
109 |       delta = now - (touch.last || now)
110 |       touch.el = $('tagName' in firstTouch.target ?
111 |         firstTouch.target : firstTouch.target.parentNode)
112 |       touchTimeout && clearTimeout(touchTimeout)
113 |       touch.x1 = firstTouch.pageX
114 |       touch.y1 = firstTouch.pageY
115 |       if (delta > 0 && delta <= 250) touch.isDoubleTap = true
116 |       touch.last = now
117 |       longTapTimeout = setTimeout(longTap, longTapDelay)
118 |       // adds the current touch contact for IE gesture recognition
119 |       if (gesture && _isPointerType) gesture.addPointer(e.pointerId)
120 |     }
121 | 
122 |     move = function(e){
123 |       if((_isPointerType = isPointerEventType(e, 'move')) &&
124 |         !isPrimaryTouch(e)) return
125 |       firstTouch = _isPointerType ? e : e.touches[0]
126 |       cancelLongTap()
127 |       touch.x2 = firstTouch.pageX
128 |       touch.y2 = firstTouch.pageY
129 | 
130 |       deltaX += Math.abs(touch.x1 - touch.x2)
131 |       deltaY += Math.abs(touch.y1 - touch.y2)
132 |     }
133 | 
134 |     up = function(e){
135 |       if((_isPointerType = isPointerEventType(e, 'up')) &&
136 |         !isPrimaryTouch(e)) return
137 |       cancelLongTap()
138 | 
139 |       // swipe
140 |       if ((touch.x2 && Math.abs(touch.x1 - touch.x2) > 30) ||
141 |           (touch.y2 && Math.abs(touch.y1 - touch.y2) > 30))
142 | 
143 |         swipeTimeout = setTimeout(function() {
144 |           if (touch.el){
145 |             touch.el.trigger('swipe')
146 |             touch.el.trigger('swipe' + (swipeDirection(touch.x1, touch.x2, touch.y1, touch.y2)))
147 |           }
148 |           touch = {}
149 |         }, 0)
150 | 
151 |       // normal tap
152 |       else if ('last' in touch)
153 |         // don't fire tap when delta position changed by more than 30 pixels,
154 |         // for instance when moving to a point and back to origin
155 |         if (deltaX < 30 && deltaY < 30) {
156 |           // delay by one tick so we can cancel the 'tap' event if 'scroll' fires
157 |           // ('tap' fires before 'scroll')
158 |           tapTimeout = setTimeout(function() {
159 | 
160 |             // trigger universal 'tap' with the option to cancelTouch()
161 |             // (cancelTouch cancels processing of single vs double taps for faster 'tap' response)
162 |             var event = $.Event('tap')
163 |             event.cancelTouch = cancelAll
164 |             // [by paper] fix -> "TypeError: 'undefined' is not an object (evaluating 'touch.el.trigger'), when double tap
165 |             if (touch.el) touch.el.trigger(event)
166 | 
167 |             // trigger double tap immediately
168 |             if (touch.isDoubleTap) {
169 |               if (touch.el) touch.el.trigger('doubleTap')
170 |               touch = {}
171 |             }
172 | 
173 |             // trigger single tap after 250ms of inactivity
174 |             else {
175 |               touchTimeout = setTimeout(function(){
176 |                 touchTimeout = null
177 |                 if (touch.el) touch.el.trigger('singleTap')
178 |                 touch = {}
179 |               }, 250)
180 |             }
181 |           }, 0)
182 |         } else {
183 |           touch = {}
184 |         }
185 |         deltaX = deltaY = 0
186 |     }
187 | 
188 |     $(document).on(eventMap.up, up)
189 |       .on(eventMap.down, down)
190 |       .on(eventMap.move, move)
191 | 
192 |     // when the browser window loses focus,
193 |     // for example when a modal dialog is shown,
194 |     // cancel all ongoing events
195 |     $(document).on(eventMap.cancel, cancelAll)
196 | 
197 |     // scrolling the window indicates intention of the user
198 |     // to scroll, not tap or swipe, so cancel all ongoing events
199 |     $(window).on('scroll', cancelAll)
200 | 
201 |     initialized = true
202 |   }
203 | 
204 |   ;['swipe', 'swipeLeft', 'swipeRight', 'swipeUp', 'swipeDown',
205 |     'doubleTap', 'tap', 'singleTap', 'longTap'].forEach(function(eventName){
206 |     $.fn[eventName] = function(callback){ return this.on(eventName, callback) }
207 |   })
208 | 
209 |   $.touch = { setup: setup }
210 | 
211 |   $(document).ready(setup)
212 | })(Zepto)
213 | 


--------------------------------------------------------------------------------
/test/ajax_deferred.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | <head>
  4 |   <meta charset="utf-8">
  5 |   <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  6 |   <link rel="stylesheet" href="test.css">
  7 |   <title>Zepto Ajax deferred</title>
  8 |   <script src="../vendor/evidence.js"></script>
  9 |   <script src="evidence_runner.js"></script>
 10 |   <script>
 11 |     // avoid caching
 12 |     (function(){
 13 |       function load(scripts){
 14 |         scripts.split(' ').forEach(function(script){
 15 |           document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
 16 |         })
 17 |       }
 18 | 
 19 |       load('zepto event ajax ie callbacks deferred')
 20 |     })()
 21 |   </script>
 22 | </head>
 23 | <body>
 24 |   <h1>Zepto Ajax deferred</h1>
 25 |   <p id="results">
 26 |     Running… see browser console for results
 27 |   </p>
 28 |   <div id="fixtures">
 29 |   </div>
 30 | 
 31 |   <script>
 32 |   (function(){
 33 | 
 34 |     function toArray(list) {
 35 |       if ($.type(list) == "string") return list.split(/(?:\s*,\s*|\s+)/)
 36 |       else return list
 37 |     }
 38 | 
 39 |     Evidence.Assertions.assertEqualList = function(expected, actual, message) {
 40 |       var expectedList = toArray(expected),
 41 |           actualList   = toArray(actual)
 42 | 
 43 |       this._assertExpression(
 44 |         expectedList.join(' ') == actualList.join(' '),
 45 |         message || "Lists don't match.",
 46 |         'Expected %o, got %o.', expectedList, actualList
 47 |       )
 48 |     }
 49 | 
 50 |     var OriginalXHR = $.ajaxSettings.xhr
 51 | 
 52 |     function MockXHR() {
 53 |       this.requestHeaders = {}
 54 |       this.responseHeaders = {}
 55 |       MockXHR.last = this
 56 |     }
 57 |     MockXHR.prototype = {
 58 |       open: function(method, url) {
 59 |         this.method = method
 60 |         this.url = url
 61 |       },
 62 |       setRequestHeader: function(name, value) {
 63 |         this.requestHeaders[name.toLowerCase()] = value
 64 |       },
 65 |       getResponseHeader: function(name) {
 66 |         return this.responseHeaders[name]
 67 |       },
 68 |       send: function(data) {
 69 |         this.data = data
 70 |       },
 71 |       abort: function() {
 72 |         this.aborted = true
 73 |       },
 74 |       ready: function(readyState, status, responseText, headers) {
 75 |         this.readyState = readyState
 76 |         this.status = status
 77 |         this.responseText = responseText
 78 |         $.extend(this.responseHeaders, headers)
 79 |         this.onreadystatechange()
 80 |       },
 81 |       onreadystatechange: function() {}
 82 |     }
 83 | 
 84 |     Evidence('ZeptoAjaxDeferred', {
 85 |       setUp: function() {
 86 |         $.ajaxSettings.xhr = function(){ return new MockXHR }
 87 |       },
 88 | 
 89 |       tearDown: function() {
 90 |         $.ajaxSettings.xhr = OriginalXHR
 91 |         $(document).off()
 92 |         $.active = 0
 93 | 
 94 |         for (var key in window)
 95 |           if (/^Zepto\d+$/.test(key) && window[key] === undefined)
 96 |             delete window[key]
 97 |       },
 98 | 
 99 |       testDone: function(t) {
100 |         var log = []
101 | 
102 |         var xhr = $.ajax({
103 |           success: function() { log.push('success') }
104 |         })
105 |           .done(function(response, status, gotXhr){
106 |             t.assertEqual('hello', response)
107 |             t.assertEqual('success', status)
108 |             t.assertIdentical(xhr, gotXhr)
109 |             log.push('done1')
110 |           })
111 |           .fail(function(){ log.push('fail') })
112 |           .always(function(){ log.push('always') })
113 |           .done(function(){ log.push('done2') })
114 | 
115 |         xhr.ready(3, 0)
116 |         t.assertEqual(0, log.length)
117 | 
118 |         xhr.ready(4, 200, 'hello')
119 |         t.assertEqualList('success done1 always done2', log)
120 | 
121 |         xhr.done(function(){ log.push('done3') })
122 |         t.assertEqualList('success done1 always done2 done3', log)
123 |       },
124 | 
125 |       testFail: function(t) {
126 |         var log = []
127 | 
128 |         var xhr = $.ajax({
129 |           error: function() { log.push('error') }
130 |         })
131 |           .done(function(){ log.push('done') })
132 |           .fail(function(gotXhr, status, error){
133 |             t.assertIdentical(xhr, gotXhr)
134 |             t.assertEqual('error', status)
135 |             log.push('fail1')
136 |           })
137 |           .always(function(){ log.push('always') })
138 |           .fail(function(){ log.push('fail2') })
139 | 
140 |         xhr.ready(3, 0)
141 |         t.assertEqual(0, log.length)
142 | 
143 |         xhr.ready(4, 404)
144 |         t.assertEqualList('error fail1 always fail2', log)
145 | 
146 |         xhr.fail(function(){ log.push('fail3') })
147 |         t.assertEqualList('error fail1 always fail2 fail3', log)
148 |       },
149 | 
150 |       testAbortInBeforeSend: function(t) {
151 |         var log = []
152 | 
153 |         var xhr = $.ajax({
154 |           beforeSend: function() { return false }
155 |         })
156 | 
157 |         xhr.done(function(){ log.push('done') })
158 |           .fail(function(gotXhr, status, error){
159 |             t.assertIdentical(xhr, gotXhr)
160 |             t.assertEqual('abort', status)
161 |             log.push('fail1')
162 |           })
163 | 
164 |         t.assertEqualList('fail1', log)
165 |       },
166 | 
167 |       testJSONP: function(t) {
168 |         var log = []
169 |         t.pause()
170 | 
171 |         var xhr = $.ajax({
172 |           url: 'jsonp',
173 |           dataType: 'jsonp',
174 |           success: function() { log.push('success') }
175 |         })
176 |           .done(function(){ log.push('done1') })
177 |           .always(function(){
178 |             setTimeout(function(){
179 |               t.resume(function(){
180 |                 t.assertEqualList('success done1', log)
181 |                 xhr.done(function(){ log.push('done2') })
182 |                 t.assertEqualList('success done1 done2', log)
183 |               })
184 |             }, 10)
185 |           })
186 | 
187 |         t.assertEqual(0, log.length)
188 |       },
189 | 
190 |       testJSONPAbortInBeforeSend: function(t) {
191 |         var log = []
192 | 
193 |         var xhr = $.ajax({
194 |           url: 'jsonp',
195 |           dataType: 'jsonp',
196 |           beforeSend: function() { return false }
197 |         })
198 | 
199 |         xhr.done(function(){ log.push('done') })
200 |           .fail(function(gotXhr, status, error){
201 |             t.assertIdentical(xhr, gotXhr)
202 |             t.assertEqual('abort', status)
203 |             log.push('fail1')
204 |           })
205 | 
206 |         t.assertEqualList('fail1', log)
207 |       }
208 | 
209 |     })
210 |   })()
211 |   </script>
212 | </body>
213 | </html>
214 | 


--------------------------------------------------------------------------------
/test/callbacks.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | <head>
  4 |   <meta charset="utf-8">
  5 |   <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  6 |   <link rel="stylesheet" href="test.css">
  7 |   <title>Zepto Callbacks unit tests</title>
  8 |   <script src="../vendor/evidence.js"></script>
  9 |   <script src="evidence_runner.js"></script>
 10 |   <script>
 11 |     // avoid caching
 12 |     (function(){
 13 |       function load(scripts){
 14 |         scripts.split(' ').forEach(function(script){
 15 |           document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
 16 |         })
 17 |       }
 18 | 
 19 |       load('zepto callbacks')
 20 |     })()
 21 |   </script>
 22 | </head>
 23 | <body>
 24 |   <h1>Zepto Callbacks unit tests</h1>
 25 |   <p id="results">
 26 |     Running… see browser console for results
 27 |   </p>
 28 | 
 29 |   <script>
 30 |   (function(){
 31 |     var output = "", cb
 32 |     function a() { output += "A" }
 33 |     function b() { output += "B" }
 34 |     function c() { output += "C" }
 35 |     function str(str) { output += str }
 36 | 
 37 |     Evidence('ZeptoCallbacksTest', {
 38 | 
 39 |       testOptionsAreCopied: function(t) {
 40 |         var options = {"unique": true},
 41 |             cb = $.Callbacks(options),
 42 |             count = 0,
 43 |             fn = function() {
 44 |               t.assertTrue(!(count++), "called once")
 45 |             }
 46 |         options["unique"] = false
 47 |         cb.add(fn, fn)
 48 |         cb.fire()
 49 |       },
 50 | 
 51 |       testFireWithOptionsAreCopied: function(t) {
 52 |         var cb = $.Callbacks({memory:1}),
 53 |             args = ["hello"]
 54 | 
 55 |         cb.fireWith(null, args)
 56 |         args[0] = "world"
 57 | 
 58 |         cb.add(function(hello) {
 59 |           t.assertEqual("hello", hello, "arguments are copied internally")
 60 |         })
 61 |       },
 62 | 
 63 |       testRemoveDeletesAllInstances: function(t) {
 64 |         var cb = $.Callbacks()
 65 |         function fn() {
 66 |           t.fail("function wasn't removed")
 67 |         }
 68 |         cb.add( fn, fn, function() {
 69 |           t.assertTrue(true, "end of test")
 70 |         }).remove(fn).fire()
 71 |       },
 72 | 
 73 |       testCallbacksHas: function(t) {
 74 |         var cb = $.Callbacks()
 75 |         cb.add(a, b, c)
 76 |         t.assertTrue(cb.has(), "No arguments to .has() returns whether callback function(s) are attached or not")
 77 |         t.assertTrue(cb.has(a), "Check if a specific callback function is in the Callbacks list" )
 78 | 
 79 |         cb.remove(b)
 80 |         t.assertFalse(cb.has(b), "Remove a specific callback function and make sure its no longer there" )
 81 |         t.assertTrue(cb.has(a), "Remove a specific callback function and make sure other callback function is still there" )
 82 | 
 83 |         cb.empty()
 84 |         t.assertFalse(cb.has(), "Empty list and make sure there are no callback function(s)" )
 85 |         t.assertFalse(cb.has(a), "Check for a specific function in an empty() list" )
 86 | 
 87 |         cb.add(a, b, function(){
 88 |           t.assertTrue(cb.has(), "Check if list has callback function(s) from within a callback function" )
 89 |           t.assertTrue(cb.has(a), "Check if list has a specific callback from within a callback function" )
 90 |         }).fire()
 91 | 
 92 |         t.assertTrue(cb.has(), "Callbacks list has callback function(s) after firing" )
 93 | 
 94 |         cb.disable()
 95 |         t.assertFalse(cb.has(), "disabled() list has no callback functions (returns false)" )
 96 |         t.assertFalse(cb.has(a), "Check for a specific function in a disabled() list" )
 97 | 
 98 |         cb = $.Callbacks({unique:1})
 99 |         cb.add(a)
100 |         cb.add(a)
101 |         t.assertTrue(cb.has(), "Check if unique list has callback function(s) attached" )
102 |         cb.lock()
103 |         t.assertFalse(cb.has(), "locked() list is empty and returns false" )
104 |       },
105 | 
106 |       testAddStringNoCrash: function(t) {
107 |         $.Callbacks().add("hello world")
108 |         t.assertTrue(true, "no crash adding string" )
109 |       },
110 | 
111 |       testUniqueAddIdenticalFn: function(t) {
112 |         output = "X"
113 |         $.Callbacks({unique:1}).add(a, function() { output += "A" }).fire()
114 |         t.assertEqual("XAA", output, "Unique can add different, identical definitions of same function")
115 |       },
116 | 
117 |       testUniqueAddSameFn: function(t) {
118 |         output = "X"
119 |         $.Callbacks({unique:1}).add(a, a).fire()
120 |         t.assertEqual("XA", output, "Unique can not add multiple functions with the same reference")
121 |       },
122 | 
123 |       testUniqueAddSameFnMultiRef: function(t) {
124 |         var x = a
125 |         output = "X"
126 |         $.Callbacks({unique:1}).add(a, x).fire()
127 |         t.assertEqual("XA", output, "Unique can not add multiple references to the same function")
128 |       }
129 | 
130 |     })
131 | 
132 |     var configs = {
133 |       'Undefined': undefined,
134 |       'Null': null,
135 |       'Once': {once:1},
136 |       'Memory': {memory:1},
137 |       'Unique': {unique:1},
138 |       'StopOnFalse': {stopOnFalse:1},
139 |       'OnceMemory': {once:1, memory:1},
140 |       'OnceUnique': {once:1, unique:1},
141 |       'OnceStopOnFalse': {once:1, stopOnFalse:1},
142 |       'MemoryUnique': {memory:1, unique:1},
143 |       'MemoryStopOnFalse': {memory:1, stopOnFalse:1},
144 |       'UniqueStopOnFalse': {unique:1, stopOnFalse:1}
145 |     }
146 |     var ordering = {
147 |       "Undefined":         "XABC   X     XABCABCC  X  XBB X   XABA  X   XX",
148 |       "Null":              "XABC   X     XABCABCC  X  XBB X   XABA  X   XX",
149 |       "Once":              "XABC   X     X         X  X   X   XABA  X   XX",
150 |       "Memory":            "XABC   XABC  XABCABCCC XA XBB XB  XABA  XC  XX",
151 |       "Unique":            "XABC   X     XABCA     X  XB  X   XAB   X   X",
152 |       "StopOnFalse":       "XABC   X     XABCABCC  X  XBB X   XA    X   XX",
153 |       "OnceMemory":        "XABC   XABC  X         XA X   XA  XABA  XC  XX",
154 |       "OnceUnique":        "XABC   X     X         X  X   X   XAB   X   X",
155 |       "OnceStopOnFalse":   "XABC   X     X         X  X   X   XA    X   XX",
156 |       "MemoryUnique":      "XABC   XA    XABCA     X  XB  X   XAB   XC  X",
157 |       "MemoryStopOnFalse": "XABC   XABC  XABCABCCC XA XBB XB  XA    X   XX",
158 |       "UniqueStopOnFalse": "XABC   X     XABCA     X  XB  X   XA    X   X"
159 |     }
160 | 
161 |     $.each(configs, function(name, config) {
162 |       var results = ordering[name].split(/\s+/)
163 | 
164 |       Evidence("ZeptoCallbacksTest#" + name, {
165 | 
166 |         testBindAndFire: function(t) {
167 |           output = "X", cb = $.Callbacks(config).add(str).fire("A")
168 |           t.assertEqual("XA", output, "Basic binding and firing")
169 |           t.assertTrue(cb.fired(), ".fired() detects firing")
170 |           output = "X"
171 |           cb.disable().add(str)
172 |           t.assertEqual( "X", output, "Adding a callback after disabling" )
173 |           cb.fire("A")
174 |           t.assertEqual( "X", output, "Firing after disabling" )
175 |         },
176 | 
177 |         testNoEmptyWhileFiring: function(t) {
178 |           var cb = $.Callbacks(config)
179 |           cb.add(cb.empty, function() { t.fail("not emptied") }).fire()
180 |         },
181 | 
182 |         testNoDisablingWhileFiring: function(t) {
183 |           var cb = $.Callbacks(config)
184 |           cb.add(cb.disable, function() { t.fail("not disabled") }).fire()
185 |         },
186 | 
187 |         testBindFireWithContextAndArgs: function(t) {
188 |           output = "X"
189 |           $.Callbacks(config).add(function() {
190 |             t.assertEqual(window, this, "Basic binding and firing (context)" )
191 |             output += Array.prototype.join.call(arguments, "")
192 |           }).fireWith(window, [ "A", "B" ])
193 |           t.assertEqual( "XAB", output, "Basic binding and firing (arguments)" )
194 |         },
195 | 
196 |         testFireWithNoArgs: function(t) {
197 |           $.Callbacks(config).add(function() {
198 |             t.assertEqual(window, this, "fireWith with no arguments (context is window)")
199 |             t.assertEqual(0, arguments.length, "fireWith with no arguments (no arguments)")
200 |           }).fireWith()
201 |         },
202 | 
203 |         testBindRemoveFire: function(t) {
204 |           output = "X"
205 |           $.Callbacks(config).add(a, b, c).remove(b, c).fire()
206 |           t.assertEqual("XA", output)
207 |         },
208 | 
209 |         testEmpty: function(t) {
210 |           output = "X"
211 |           $.Callbacks(config).add(a, b, c).empty().fire()
212 |           t.assertEqual( "X", output, "Empty" )
213 |         },
214 | 
215 |         testLocking: function(t) {
216 |           output = "X"
217 |           $.Callbacks(config).add(str).lock().add(str).fire("A").add(str)
218 |           t.assertEqual("X", output, "Lock early")
219 |         },
220 | 
221 |         testOrdering: function(t) {
222 |           output = "X", cb = $.Callbacks(config)
223 |           cb.add(function() {
224 |             cb.add(c)
225 |             a()
226 |           }, b).fire()
227 |           t.assertEqual( results.shift(), output, "Proper ordering" )
228 | 
229 |           output = "X"
230 |           cb.add(function() {
231 |             cb.add(c)
232 |             a()
233 |           }, b)
234 |           t.assertEqual(results.shift(), output, "Add after fire")
235 |           output = "X"
236 |           cb.fire()
237 |           t.assertEqual(results.shift(), output, "Fire again")
238 | 
239 |           output = "X", cb = $.Callbacks(config)
240 |           cb.add(str).fire("A")
241 |           t.assertEqual("XA", output, "Multiple fire (first fire)")
242 |           output = "X"
243 |           cb.add(str)
244 |           t.assertEqual(results.shift(), output, "Multiple fire (first new callback)")
245 |           output = "X"
246 |           cb.fire("B")
247 |           t.assertEqual(results.shift(), output, "Multiple fire (second fire)")
248 |           output = "X"
249 |           cb.add(str)
250 |           t.assertEqual(results.shift(), output, "Multiple fire (second new callback)")
251 | 
252 |           output = "X", cb = $.Callbacks(config).add(a, function() { return false }, b).add(a).fire()
253 |           t.assertEqual(results.shift(), output, "Callback returning false")
254 | 
255 |           output = "X"
256 |           cb.add(c)
257 |           t.assertEqual(results.shift(), output, "Adding a callback after one returned false")
258 | 
259 |           output = ""
260 |           function handler() { output += "X" }
261 |           handler.method = function() { output += "!" }
262 |           cb = $.Callbacks(config).add(handler).add(handler).fire()
263 |           t.assertEqual(results.shift(), output, "No callback iteration")
264 |         }
265 | 
266 |       })
267 | 
268 |     })
269 |   })()
270 |   </script>
271 | </body>
272 | </html>
273 | 


--------------------------------------------------------------------------------
/test/data.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | <head>
  4 |   <meta charset="utf-8">
  5 |   <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  6 |   <link rel="stylesheet" href="test.css">
  7 |   <title>Zepto Data unit tests</title>
  8 |   <script src="../vendor/evidence.js"></script>
  9 |   <script src="evidence_runner.js"></script>
 10 |   <script>
 11 |     // avoid caching
 12 |     (function(){
 13 |       function load(scripts){
 14 |         scripts.split(' ').forEach(function(script){
 15 |           document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
 16 |         })
 17 |       }
 18 | 
 19 |       load('zepto data ie')
 20 |     })()
 21 |   </script>
 22 | </head>
 23 | <body>
 24 |   <h1>Zepto Data unit tests</h1>
 25 |   <p id="results">
 26 |     Running… see browser console for results
 27 |   </p>
 28 |   <div id="fixtures">
 29 |   <div id="data_attr"
 30 |     data-one="uno"
 31 |     data-two="due"
 32 |     data-foo-bar="baz"
 33 |     data-under_score="kuuq"
 34 |     ></div>
 35 |   <div id="data_full" data-mode="awesome"></div>
 36 |   <div id="data_obj" data-mode="awesome"></div>
 37 |   <ol id="data_list">
 38 |     <li data-category="arts"></li>
 39 |     <li data-category="science"></li>
 40 |   </ol>
 41 |   <ol id="data_list2">
 42 |     <li></li>
 43 |     <li></li>
 44 |   </ol>
 45 |   </div>
 46 | 
 47 |   <script>
 48 |     Evidence('ZeptoExtendedDataTest', {
 49 |       testEmptyCollection: function(t){
 50 |         var el = $('#does_not_exist')
 51 |         t.assertUndefined(el.data('one'))
 52 |       },
 53 | 
 54 |       testAttributeDoesNotExist: function(t){
 55 |         var el = $('#data_attr')
 56 |         t.assertUndefined(el.data('missing'))
 57 |       },
 58 | 
 59 |       testReadingAttribute: function(t){
 60 |         var el = $('#data_attr')
 61 |         t.assertEqual('uno', el.data('one'))
 62 |       },
 63 | 
 64 |       testCamelized: function(t){
 65 |         var el = $('#data_attr')
 66 |         t.assertEqual('baz', el.data('foo-bar'))
 67 |         t.assertEqual('baz', el.data('fooBar'))
 68 | 
 69 |         el.data('fooBar', 'bam')
 70 |         t.assertEqual('bam', el.data('foo-bar'))
 71 |         t.assertEqual('bam', el.data('fooBar'))
 72 | 
 73 |         el.data('a-b', 'c')
 74 |         t.assertEqual('c', el.data().aB)
 75 |         t.assertUndefined(el.data()['a-b'])
 76 |       },
 77 | 
 78 |       testUnderscore: function(t){
 79 |         var el = $('#data_attr')
 80 |         t.assertEqual('kuuq', el.data('under_score'))
 81 |         t.assertUndefined(el.data('under-score'))
 82 |         t.assertUndefined(el.data('underScore'))
 83 |       },
 84 | 
 85 |       testNotChangingAttribute: function(t){
 86 |         var el = $('#data_attr')
 87 |         t.assertEqual('due', el.data('two'))
 88 |         el.data('two', 'changed')
 89 |         t.assertEqual('due', el.attr('data-two'))
 90 |       },
 91 | 
 92 |       testExtendedData: function(t){
 93 |         var els = $('#data_attr'),
 94 |           els2 = $('#data_attr'),
 95 |           obj  = { a: 'A', b: 'B' }
 96 | 
 97 |         els.data('obj', obj)
 98 |         t.assertIdentical(obj, els.data('obj'))
 99 |         t.assertIdentical(obj, els2.data('obj'))
100 | 
101 |         els2.data('els', els)
102 |         t.assertIdentical(els, els.data('els'))
103 |       },
104 | 
105 |       testMultipleElements: function(t){
106 |         var items = $('#data_list li')
107 | 
108 |         items.data('each', 'mark')
109 | 
110 |         var values = items.map(function(){ return $(this).data('each') }).get()
111 |         t.assertEqual('mark, mark', values.join(', '))
112 |       },
113 | 
114 |       testFunctionArg: function(t){
115 |         var els = $('#data_attr')
116 | 
117 |         var data = "hello"
118 | 
119 |         els.data("addio", function () {
120 |           data = "goodbye"
121 |         })
122 | 
123 |         t.assertEqual('hello', data)
124 | 
125 |         els.data("addio")()
126 | 
127 |         t.assertEqual('goodbye', data)
128 |       },
129 | 
130 |       testAllData: function(t){
131 |         var el = $('#data_full')
132 | 
133 |         el.data().samurai = 7
134 |         el.data('one', 'ichi').data('two', 'ni')
135 |         el.data('person', {name: 'Kurosawa'})
136 | 
137 |         var all = el.data()
138 |         t.assertEqual(7, all.samurai)
139 |         t.assertEqual('ichi', all.one)
140 |         t.assertEqual('ni', all.two)
141 |         t.assertEqual('Kurosawa', all.person.name)
142 |       },
143 | 
144 |       testInitialDataFromAttributes: function(t){
145 |         var el = $('<div data-foo=bar data-foo-bar=baz data-empty data-num=42 />'),
146 |             store = el.data()
147 | 
148 |         t.assertEqual('bar', store.foo)
149 |         t.assertEqual('baz', store.fooBar)
150 |         t.assertUndefined(store['foo-bar'])
151 |         t.assertIdentical('', store.empty)
152 |         t.assertIdentical(42, store.num)
153 |       },
154 | 
155 |       testGettingBlanks: function(t){
156 |         var el = $('#data_attr'),
157 |             store = el.data()
158 | 
159 |         store.nil = null
160 |         store.undef = undefined
161 |         store.blank = ''
162 |         store.bool = false
163 | 
164 |         t.assertNull(el.data('nil'))
165 |         t.assertUndefined(el.data('undef'))
166 |         t.assertIdentical('', el.data('blank'))
167 |         t.assertFalse(el.data('bool'))
168 |       },
169 | 
170 |       testRemoveData: function(t){
171 |         var el = $('<div data-foo=bar />')
172 | 
173 |         el.data('foo', 'bam').data('bar', 'baz')
174 |         el.removeData('foo').removeData('bar')
175 |         t.assertEqual('bar', el.data('foo'))
176 |         t.assertUndefined(el.data('bar'))
177 | 
178 |         el.data('uno', 'one').data('due', 'two')
179 |         el.removeData('uno due')
180 |         t.assertUndefined(el.data('uno'))
181 |         t.assertUndefined(el.data('due'))
182 | 
183 |         el.data('one', 1).data('twoThree', 23)
184 |         el.removeData(['one', 'two-three'])
185 |         t.assertUndefined(el.data('one'))
186 |         t.assertUndefined(el.data('twoThree'))
187 |       },
188 | 
189 |       testRemoveAllData: function(t){
190 |         var el = $('<div data-attr-test=val />')
191 | 
192 |         el.data('one', { foo: 'bar' })
193 |         el.data('two', 'two').data('three', 3)
194 |         el.removeData()
195 | 
196 |         t.assertEqual('val', el.data('attrTest'))
197 |         t.assertUndefined(el.data('one'))
198 |         t.assertUndefined(el.data('two'))
199 |         t.assertUndefined(el.data('three'))
200 |       },
201 | 
202 |       testRemoveDataNoop: function(t){
203 |         var empty = $(),
204 |             vanilla = $('<div />')
205 | 
206 |         t.assertIdentical(empty, empty.removeData('foo'))
207 |         t.assertIdentical(vanilla, vanilla.removeData('foo'))
208 |       },
209 | 
210 |       testRemoveDataOnElementRemoval: function(t){
211 |         var el = $('<div data-attr-test=val />'),
212 |           childEl = $('<span />').appendTo(el),
213 |           elData = { foo: 'bar' }
214 | 
215 |         el.data('test', elData)
216 |         childEl.data('test', 1)
217 | 
218 |         el.remove()
219 |         t.assertEqual('val', el.data('attrTest'))
220 |         t.assertUndefined(el.data('test'))
221 |         t.assertUndefined(childEl.data('test'))
222 |       },
223 | 
224 |       testRemoveDataOnElementEmpty: function(t){
225 |         var el = $('<div data-attr-test=val />'),
226 |           childEl = $('<span />').appendTo(el),
227 |           elData = { foo: 'bar' }
228 | 
229 |         el.data('test', elData)
230 |         childEl.data('test', 1)
231 | 
232 |         el.empty()
233 |         t.assertEqual('val', el.data('attrTest'))
234 |         t.assertEqual(elData, el.data('test'))
235 |         t.assertUndefined(childEl.data('test'))
236 |       },
237 | 
238 |       testRemoveDataOnElementReplacement: function(t){
239 |         var el = $('<div data-attr-test=val />'),
240 |           childEl = $('<span />').appendTo(el),
241 |           elData = { foo: 'bar' }
242 | 
243 |         el.data('test', elData)
244 |         childEl.data('test', 1)
245 | 
246 |         el.replaceWith('<div />')
247 |         t.assertEqual('val', el.data('attrTest'))
248 |         t.assertUndefined(el.data('test'))
249 |         t.assertUndefined(childEl.data('test'))
250 |       },
251 | 
252 |       testRemoveDataOnElementReplacementHtml: function(t){
253 |         var el = $('<div data-attr-test=val />'),
254 |           childEl = $('<span />').appendTo(el),
255 |           wrapper = $('<div />'),
256 |           elData = { foo: 'bar' }
257 | 
258 |         el.wrap(wrapper).data('test', elData)
259 |         childEl.data('test', 1)
260 | 
261 |         wrapper.html('<b>New content</b>')
262 |         t.assertEqual('val', el.data('attrTest'))
263 |         t.assertUndefined(el.data('test'))
264 |         t.assertUndefined(childEl.data('test'))
265 |       },
266 | 
267 |       testKeepDataOnElementDetach: function(t){
268 |         var el = $('<div data-attr-test=val />'),
269 |           childEl = $('<span />').appendTo(el),
270 |           elData = { foo: 'bar' }
271 | 
272 |         el.data('test', elData)
273 |         childEl.data('test', 1)
274 | 
275 |         el.detach()
276 |         t.assertEqual('val', el.data('attrTest'))
277 |         t.assertEqual(elData, el.data('test'))
278 |         t.assertEqual(1, childEl.data('test'))
279 |       },
280 | 
281 |       testSettingDataWithObj: function(t){
282 |           var el = $('#data_obj')
283 | 
284 |           el.data({
285 |               'foo': 'bar',
286 |               'answer': 42,
287 |               'color': 'blue'
288 |           })
289 | 
290 |           var all = el.data()
291 | 
292 |           t.assertEqual(all.answer, 42)
293 |           t.assertEqual(all.color, 'blue')
294 |           t.assertEqual(all.foo, 'bar')
295 | 
296 |           el.data('foo', 'baz')
297 | 
298 |           t.assertEqual(all.foo, 'baz')
299 |           t.assertEqual(all.answer, 42)
300 |       },
301 | 
302 |       testSettingDataWithObjOnManyElements: function(t){
303 |           var items = $('#data_list2 li')
304 | 
305 |           items.data({
306 |               'foo': 'bar',
307 |               'answer': 42,
308 |               'color': 'purple'
309 |           })
310 | 
311 |           var values = items.map(function(){ return $(this).data('foo') }).get()
312 |           t.assertEqual('bar, bar', values.join(', '))
313 | 
314 |           var values2 = items.map(function(){ return $(this).data('answer') }).get()
315 |           t.assertEqual('42, 42', values2.join(', '))
316 |       },
317 | 
318 |       testSettingDataOnObjectWithoutAttributes: function(t) {
319 |         var el = $(window)
320 | 
321 |         t.assertUndefined(el.data('foo'))
322 |         el.data('foo', 'bar')
323 |         t.assertEqual(el.data('foo'), 'bar')
324 | 
325 |         delete window[$.expando]
326 |       },
327 | 
328 |       testDollarData: function(t) {
329 |         var el = $('<div>')
330 |         el.data('hello', 'world')
331 |         t.assertEqual($.data(el, 'hello'), 'world')
332 |         t.assertEqual($.data(el[0], 'hello'), 'world')
333 | 
334 |         $.data(el[0], 'hello', 'again')
335 |         t.assertEqual($.data(el, 'hello'), 'again')
336 |         t.assertEqual($.data(el[0], 'hello'), 'again')
337 |       },
338 | 
339 |       testDollarHasData: function(t) {
340 |         var el = $('<div>')
341 |         t.assertFalse($.hasData(el[0]))
342 | 
343 |         el.data('hello', 'world')
344 |         t.assertTrue($.hasData(el[0]))
345 | 
346 |         el.removeData()
347 |         t.assertFalse($.hasData(el[0]))
348 | 
349 |         var error
350 |         try {
351 |           $.hasData()
352 |         } catch (e) {
353 |           error = e
354 |         }
355 |         t.assert(error)
356 |       }
357 | 
358 |     })
359 |   </script>
360 | </body>
361 | </html>
362 | 


--------------------------------------------------------------------------------
/test/event.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | <head>
  4 |   <meta charset="utf-8">
  5 |   <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  6 |   <link rel="stylesheet" href="test.css">
  7 |   <title>Zepto Event unit tests</title>
  8 |   <script src="../vendor/evidence.js"></script>
  9 |   <script src="evidence_runner.js"></script>
 10 |   <script>
 11 |     // avoid caching
 12 |     (function(){
 13 |       function load(scripts){
 14 |         scripts.split(' ').forEach(function(script){
 15 |           document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
 16 |         })
 17 |       }
 18 | 
 19 |       load('zepto event ie')
 20 |     })()
 21 |   </script>
 22 | </head>
 23 | <body>
 24 |   <h1>Zepto Event unit tests</h1>
 25 |   <p id="results">
 26 |     Running… see browser console for results
 27 |   </p>
 28 |   <div id="fixtures">
 29 |   </div><!-- fixtures -->
 30 | 
 31 |   <script>
 32 |   (function(){
 33 | 
 34 |     function click(el){
 35 |       var event = document.createEvent('MouseEvents')
 36 |       event.initMouseEvent('click', true, true, document.defaultView, 1, 0, 0, 0, 0, false, false, false, false, 0, null)
 37 |       $(el).get(0).dispatchEvent(event)
 38 |     }
 39 | 
 40 |     Evidence('ProxyTest', {
 41 |       testProxyFnContext: function(t){
 42 |         var a = {name: 'A', fn: function(n, o){ return this.name + n + o }},
 43 |             b = {name: 'B'}
 44 | 
 45 |         t.assertEqual('A13', a.fn(1, 3))
 46 |         t.assertEqual('B52', $.proxy(a.fn, b)(5, 2))
 47 |       },
 48 | 
 49 |       testProxyInvalidFn: function(t){
 50 |         try {
 51 |           $.proxy(null)
 52 |           t.fail("shouldn't be here")
 53 |         } catch(e) {
 54 |           t.assertEqual('TypeError', e.name)
 55 |           t.assertEqual("expected function", e.message)
 56 |         }
 57 |       },
 58 | 
 59 |       testProxyContextName: function(t){
 60 |         var b = {name: 'B', fn: function(n, o){ return this.name + n + o }},
 61 |             oldFn = b.fn
 62 | 
 63 |         t.assertEqual('B52', $.proxy(b, 'fn')(5, 2))
 64 |         t.assertIdentical(oldFn, b.fn)
 65 |       },
 66 | 
 67 |       testProxyUndefinedProperty: function(t){
 68 |         try {
 69 |           $.proxy({}, 'nonexistent')
 70 |           t.fail("shouldn't be here")
 71 |         } catch(e) {
 72 |           t.assertEqual('TypeError', e.name)
 73 |           t.assertEqual("expected function", e.message)
 74 |         }
 75 |       },
 76 | 
 77 |       testProxyAdditionalArguments: function(t){
 78 |         var a = {name: 'A', fn: function(){ return this.name + [].slice.call(arguments).join('') }}
 79 |         t.assertEqual('A123', $.proxy(a.fn, a)(1, 2, 3))
 80 |         t.assertEqual('A456', $.proxy(a.fn, a, 4, 5, 6)())
 81 |         t.assertEqual('A456123', $.proxy(a.fn, a, 4, 5, 6)(1, 2, 3))
 82 |       },
 83 | 
 84 |       testProxyContextNameAdditionalArguments: function(t){
 85 |         var a = {name: 'A', fn: function(){ return this.name + [].slice.call(arguments).join('') }}
 86 |         t.assertEqual('A123', $.proxy(a, 'fn')(1, 2, 3))
 87 |         t.assertEqual('A456', $.proxy(a, 'fn', 4, 5, 6)())
 88 |         t.assertEqual('A456123', $.proxy(a, 'fn', 4, 5, 6)(1, 2, 3))
 89 |       },
 90 | 
 91 |       testProxyInvalidProperty: function(t){
 92 |         try {
 93 |           $.proxy({num:3}, 'num')
 94 |           t.fail("shouldn't be here")
 95 |         } catch(e) {
 96 |           t.assertEqual('TypeError', e.name)
 97 |           t.assertEqual("expected function", e.message)
 98 |         }
 99 |       }
100 |     })
101 | 
102 |     Evidence('EventTest', {
103 |       setUp: function(){
104 |         this.el = $('<div />').appendTo('#fixtures')
105 |       },
106 | 
107 |       tearDown: function(){
108 |         this.el.off().remove()
109 |         $([document, document.body]).off()
110 |       },
111 | 
112 |       testProxiedHandlerCanBeUnboundWithOriginal: function(t){
113 |         var obj = {times:0, fn: function(){ this.times++ }}
114 | 
115 |         this.el.on('click', $.proxy(obj, 'fn'))
116 |         click(this.el)
117 |         t.assertEqual(1, obj.times)
118 | 
119 |         this.el.off('click', obj.fn)
120 |         click(this.el)
121 |         t.assertEqual(1, obj.times)
122 |       },
123 | 
124 |       testOneHandlerCanBeUnboundWithOriginal: function(t){
125 |         var count = 0, fn = function(){ count++ }
126 | 
127 |         this.el.one('click', fn)
128 |         this.el.off('click', fn)
129 |         click(this.el)
130 |         t.assertEqual(0, count)
131 |       },
132 | 
133 |       testOneDelegation: function(t){
134 |         var context, count = 0
135 |         $(document).one('click', 'div', function(){ context = this; count++ })
136 | 
137 |         click(this.el)
138 |         click(this.el)
139 |         t.assertEqual(1, count)
140 |         t.assertIdentical(this.el.get(0), context)
141 |       },
142 | 
143 |       testOneWithData: function(t){
144 |         var obj = {}, gotObj, count = 0
145 |         $(document).one('click', obj, function(e){ gotObj = e.data; count++ })
146 | 
147 |         click(this.el)
148 |         click(this.el)
149 |         t.assertEqual(1, count)
150 |         t.assertIdentical(obj, gotObj)
151 |       },
152 | 
153 |       testHandlerArity: function(t){
154 |         var numArgs
155 |         this.el.on('click', function(){ numArgs = arguments.length })
156 | 
157 |         click(this.el)
158 |         t.assertEqual(1, numArgs)
159 |       },
160 | 
161 |       testOnWithObject: function(t){
162 |         var log = []
163 |         this.el.on({ click: function(){ log.push('a') } }).
164 |                 on({ click: function(){ log.push('b') } }, null)
165 | 
166 |         click(this.el)
167 |         t.assertEqual('a b', log.sort().join(' '))
168 |       },
169 | 
170 |       testOnWithBlankData: function(t){
171 |         var log = [], fn = function(e){ log.push(e.data) }
172 |         this.el
173 |           .on('click', null, fn)
174 |           .on('click', undefined, fn)
175 | 
176 |         click(this.el)
177 |         t.assertEqual(2, log.length)
178 |         t.assertIdentical(null, log[0])
179 |         t.assertIdentical(undefined, log[1])
180 |       },
181 | 
182 |       testOffWithObject: function(t){
183 |         var log = [],
184 |             fn = function(){ log.push('a') },
185 |             fn2 = function(){ log.push('b') },
186 |             fn3 = function(){ log.push('c') }
187 | 
188 |         this.el.on('click', fn).on('click', fn2).on('click', fn3)
189 |         click(this.el)
190 |         t.assertEqual('a b c', log.sort().join(' '))
191 | 
192 |         this.el.off({ click: fn }).off({ click: fn2 }, null)
193 |         click(this.el)
194 |         t.assertEqual('a b c c', log.sort().join(' '))
195 |       },
196 | 
197 |       testDelegateEventProperties: function(t){
198 |         var type, target, currentTarget
199 |         $(document).on('click', 'div', function(e){
200 |           type = e.type
201 |           target = e.target
202 |           currentTarget = e.currentTarget
203 |         })
204 |         click($('<span>').appendTo(this.el))
205 |         t.assertEqual('click', type)
206 |         t.assertIdentical(this.el.find('span').get(0), target)
207 |         t.assertIdentical(this.el.get(0), currentTarget)
208 |       },
209 | 
210 |       testDelegateEventTimestamp: function(t){
211 |         var timestamp
212 |         $(document).on('click', 'div', function(e){
213 |           timestamp = e.timeStamp
214 |         })
215 |         click($('<span>').appendTo(this.el))
216 |         t.assert(timestamp > 0, 'timestamp was ' + timestamp)
217 |       },
218 | 
219 |       testPreventDefaultWithDelegatedEvent: function(t){
220 |         var isDefaultPrevented, span = $('<span>').appendTo(this.el)
221 | 
222 |         span.on('click', function(event){
223 |           event.preventDefault()
224 |         })
225 |         $(document).on('click', 'div', function(event){
226 |           isDefaultPrevented = event.isDefaultPrevented()
227 |         })
228 | 
229 |         click(span)
230 |         t.assertTrue(isDefaultPrevented, "isDefaultPrevented() value invalid for delegate proxy")
231 |       },
232 | 
233 |       testEventsOnPlainObjects: function (t){
234 |         var obj = {},
235 |           log = [],
236 |           fn1 = function(){ log.push('a') },
237 |           fn2 = function(evt, value){ log.push(value)    },
238 |           fn3 = function(evt, value){ log.push("event2") }
239 |         $(obj)
240 |           .on('event', fn1)
241 |           .on('event', fn2)
242 |           .on('event2', fn3)
243 | 
244 |         $(obj).trigger('event', 'b')
245 |         t.assertEqual('a b', log.join(' '))
246 | 
247 |         log = []
248 |         $(obj).trigger('event', 'c')
249 |         t.assertEqual('a c', log.join(' '))
250 | 
251 |         log = []
252 |         $(obj).off('event', fn1)
253 |         $(obj).trigger('event', 'd')
254 |         t.assertEqual('d', log.join(' '))
255 | 
256 |         log = []
257 |         $(obj).trigger('event2')
258 |         t.assertEqual('event2', log.join(' '))
259 |       },
260 | 
261 |       testHandlerWithoutData: function(t){
262 |         var gotData
263 | 
264 |         $(document).on('click', function(event){
265 |           gotData = event.data
266 |         })
267 |         t.assertUndefined(gotData)
268 | 
269 |         click(this.el)
270 |         t.assertUndefined(gotData)
271 |       },
272 | 
273 |       testHandlerWithData: function(t){
274 |         var data = {}, gotData, numArgs
275 | 
276 |         $(document).on('click', data, function(event){
277 |           gotData = event.data
278 |           numArgs = arguments.length
279 |         })
280 |         t.assertUndefined(gotData)
281 | 
282 |         click(this.el)
283 |         t.assertEqual(1, numArgs)
284 |         t.assertIdentical(data, gotData)
285 |       },
286 |       
287 |       testHandlerWithFunctionAsData: function(t){
288 |         var data = function () { console.log('foo') },
289 |             gotData, numArgs
290 |         
291 |         $(document).on('click', data, function(event){
292 |           gotData = event.data
293 |           numArgs = arguments.length
294 |         })
295 |         t.assertUndefined(gotData)
296 | 
297 |         click(this.el)
298 |         t.assertEqual(1, numArgs)
299 |         t.assertIdentical(data, gotData)
300 |       },
301 | 
302 |       testDelegatedWithData: function(t){
303 |         var data = {}, gotData, numArgs
304 | 
305 |         $(document).on('click', 'div', data, function(event){
306 |           gotData = event.data
307 |           numArgs = arguments.length
308 |         })
309 |         t.assertUndefined(gotData)
310 | 
311 |         click(this.el)
312 |         t.assertEqual(1, numArgs)
313 |         t.assertIdentical(data, gotData)
314 |       },
315 | 
316 |       testTriggerWithData: function(t){
317 |         var data = {}, gotData
318 | 
319 |         $(document).on('myevent', data, function(event){
320 |           gotData = event.data
321 |         })
322 |         t.assertUndefined(gotData)
323 | 
324 |         this.el.trigger('myevent')
325 |         t.assertIdentical(data, gotData)
326 |       },
327 | 
328 |       testDelegateEventMethods: function(t){
329 |         var methodName,
330 |             eventMethods = {
331 |               preventDefault: 'isDefaultPrevented',
332 |               stopImmediatePropagation: 'isImmediatePropagationStopped',
333 |               stopPropagation: 'isPropagationStopped'
334 |             },
335 |             eventMethodResults = {}
336 | 
337 |         $(document).on('click', 'div', function(event){
338 |           $.each(eventMethods, function(methodName, predicate){
339 |             if (event[methodName]) {
340 |               event[methodName]()
341 |               eventMethodResults[predicate] = event[predicate]()
342 |             } else {
343 |               console.warn("method not available: ", methodName)
344 |             }
345 |           })
346 |         })
347 | 
348 |         click($('<span>').appendTo(this.el))
349 | 
350 |         $.each(eventMethodResults, function(predicate, value){
351 |           t.assertTrue(value, predicate)
352 |         })
353 |       },
354 | 
355 |       testIsDefaultPreventedOnAllEvents: function(t){
356 |         var isDefaultPrevented
357 | 
358 |         $(this.el).on('click', function(event){
359 |           event.preventDefault()
360 |         })
361 |         $(document).on('click', function(event){
362 |           isDefaultPrevented = event.isDefaultPrevented()
363 |         })
364 | 
365 |         click(this.el)
366 |         t.assertTrue(isDefaultPrevented)
367 |       },
368 | 
369 |       testIsDefaultPreventedOnOriginalEventAfterDelegate: function(t){
370 |         var isDefaultPrevented
371 | 
372 |         this.el.on('click', 'span', function(event){
373 |           event.preventDefault()
374 |         })
375 |         $(document).on('click', function(event){
376 |           isDefaultPrevented = event.isDefaultPrevented()
377 |         })
378 | 
379 |         click($('<span>').appendTo(this.el))
380 | 
381 |         t.assertTrue(isDefaultPrevented)
382 |       },
383 | 
384 |       testStopImmediatePropagation: function(t){
385 |         var log = ''
386 | 
387 |         this.el
388 |           .on('click', function(e){ log += 'A' })
389 |           .on('click', function(e){ log += 'B'; e.stopImmediatePropagation() })
390 |           .on('click', function(e){ log += 'C' })
391 | 
392 |         $(document).on('click', function(e){ log += 'D' })
393 | 
394 |         click(this.el)
395 | 
396 |         t.assertEqual('AB', log)
397 |       },
398 | 
399 |       testDelegateSelectorLookupDoesNotIncludeParent: function(t){
400 |         var fired = false
401 | 
402 |         this.el
403 |           .addClass('offender')
404 |           .on('click', '.offender', function(){ fired = true })
405 | 
406 |         click(this.el)
407 | 
408 |         t.assertFalse(fired)
409 |       },
410 | 
411 |       testFalseLiteralAsCallback: function(t){
412 |         var event = $.Event('click')
413 | 
414 |         this.el.on('click', false)
415 | 
416 |         this.el.trigger(event)
417 |         t.assertTrue(event.isDefaultPrevented())
418 |         t.assertTrue(event.isPropagationStopped())
419 |       },
420 | 
421 |       testFalseLiteralAsCallbackForShorthand: function(t){
422 |         var event = $.Event('click')
423 | 
424 |         this.el.click(false)
425 | 
426 |         this.el.trigger(event)
427 |         t.assertTrue(event.isDefaultPrevented())
428 |         t.assertTrue(event.isPropagationStopped())
429 |       },
430 | 
431 |       testUnbindingFalseLiteral: function(t){
432 |         var event = $.Event('click'), fired
433 | 
434 |         this.el
435 |           .on('click', function() { fired = true })
436 |           .on('click', false)
437 |           .off('click', false)
438 | 
439 |         this.el.trigger(event)
440 | 
441 |         t.assertTrue(fired)
442 |         t.assertFalse(event.isDefaultPrevented())
443 |         t.assertFalse(event.isPropagationStopped())
444 |       },
445 | 
446 |       testFalseLiteralAsCallbackWithDataArgument: function(t){
447 |         var event = $.Event('click')
448 | 
449 |         this.el.on('click', null, false)
450 | 
451 |         this.el.trigger(event)
452 |         t.assertTrue(event.isDefaultPrevented())
453 |         t.assertTrue(event.isPropagationStopped())
454 |       },
455 | 
456 |       testFalseLiteralAsCallbackForDelegation: function(t){
457 |         var span = $('<span>').appendTo(this.el),
458 |             event = $.Event('click')
459 | 
460 |         this.el.on('click', 'span', false)
461 | 
462 |         span.trigger(event)
463 |         t.assertTrue(event.isDefaultPrevented())
464 |         t.assertTrue(event.isPropagationStopped())
465 |       },
466 | 
467 |       testFalseLiteralAsCallbackForDelegationWithDataArgument: function(t){
468 |         var span = $('<span>').appendTo(this.el),
469 |             event = $.Event('click')
470 | 
471 |         this.el.on('click', 'span', null, false)
472 | 
473 |         span.trigger(event)
474 |         t.assertTrue(event.isDefaultPrevented())
475 |         t.assertTrue(event.isPropagationStopped())
476 |       }
477 | 
478 |     })
479 |   })()
480 |   </script>
481 | </body>
482 | </html>
483 | 


--------------------------------------------------------------------------------
/test/evidence_runner.js:
--------------------------------------------------------------------------------
  1 | (function(){
  2 |   var ConsoleTestRunner = Evidence.AutoRunner.RUNNERS.console,
  3 |       ConsoleTestResult = Evidence.UI.Console.TestResult,
  4 |       AutoRunner = Evidence.AutoRunner,
  5 |       printf = Evidence.UI.printf
  6 | 
  7 |   function inherit(superclass, extra) {
  8 |     var klass = function(){
  9 |       this.initialize.apply(this, arguments)
 10 |     }
 11 |     var tmp = function(){}
 12 |     tmp.prototype = superclass.prototype
 13 |     klass.prototype = new tmp()
 14 |     klass.prototype.constructor = klass
 15 |     klass.prototype.initialize = function(){
 16 |       superclass.apply(this, arguments)
 17 |     }
 18 | 
 19 |     if (extra) {
 20 |       var methods = extra.call(klass, superclass.prototype)
 21 |       for (var method in methods) klass.prototype[method] = methods[method]
 22 |     }
 23 |     return klass
 24 |   }
 25 | 
 26 |   var TestRunner = inherit(ConsoleTestRunner, function(_super) {
 27 |     AutoRunner.RUNNERS.zepto = this
 28 |     return {
 29 |       _makeResult: function() { return new TestResult(this.logger) }
 30 |     }
 31 |   })
 32 | 
 33 |   var TestResult = inherit(ConsoleTestResult, function(_super) {
 34 |     return {
 35 |       start: function(t0) {
 36 |         Evidence.TestResult.prototype.start.call(this, t0)
 37 |         this.logger.debug('Started tests.')
 38 |       },
 39 |       stop: function(t1) {
 40 |         _super.stop.call(this, t1)
 41 |         displayResults(this, (t1-this.t0)/1000)
 42 |         checkLeakedGlobals()
 43 |       },
 44 |       pauseTest: function(testcase) {
 45 |         this.logger.debug('Paused testcase ' + testcase + '.')
 46 |       },
 47 |       restartTest: function(testcase) {
 48 |         this.logger.debug('Restarted testcase ' + testcase + '.')
 49 |       },
 50 |       startSuite: function(suite) {
 51 |         this.logger.debug('Started suite ' + suite + '.')
 52 |       },
 53 |       addFailure: function(testcase, reason) {
 54 |         this.logToServer(testcase, reason)
 55 |         _super.addFailure.call(this, testcase, reason)
 56 |       },
 57 |       addError: function(testcase, error) {
 58 |         this.logToServer(testcase, error)
 59 |         _super.addError.call(this, testcase, error)
 60 |       },
 61 |       logToServer: function(testcase, error) {
 62 |         if (location.protocol == 'file:') return
 63 |         var name = testcase.parent.name + '#' + testcase.name,
 64 |             message = error.template ?
 65 |               Evidence.UI.printf(error.template, error.args) + (error.message ? ' ' + error.message : '') :
 66 |               error.message,
 67 |             body = 'name=' + encodeURIComponent(name) + '&' +
 68 |                    'message=' + encodeURIComponent(message) + '&' +
 69 |                    'trace=' + encodeURIComponent(error.stack || '')
 70 | 
 71 |         var xhr = new XMLHttpRequest()
 72 |         xhr.open('POST', '/test/log', true)
 73 |         xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded')
 74 |         xhr.send(body)
 75 |       }
 76 |     }
 77 |   })
 78 | 
 79 |   Evidence.TestCase.prototype.debug = function(message) {
 80 |     this._result.logToServer(this, { message: message })
 81 |   }
 82 | 
 83 |   // HACK: force our test runner as default
 84 |   ;(function(){
 85 |     var _super = AutoRunner.prototype.retrieveOptions
 86 |     AutoRunner.prototype.retrieveOptions = function() {
 87 |       var options = _super.call(this)
 88 |       if (!options.runner) options.runner = 'zepto'
 89 |       return options
 90 |     }
 91 |   })()
 92 | 
 93 |   function $(id) { return document.getElementById(id) }
 94 | 
 95 |   function displayResults(results, seconds) {
 96 |     var container = $('results')
 97 |     if (container) {
 98 |       if (results.failureCount || results.errorCount) {
 99 |         container.className = 'failed'
100 |         container.innerHTML = printf("Finished in %d s. &ndash; <em>%d failures, %d errors</em> (%d assertions)",
101 |                                      [seconds, results.failureCount, results.errorCount, results.assertionCount])
102 |       } else {
103 |         container.className = 'passed'
104 |         container.innerHTML = printf("Finished in %d s. &ndash; <em>%d tests passed</em> (%d assertions)",
105 |                                      [seconds, results.testCount, results.assertionCount])
106 |       }
107 |       container.className += ' finished'
108 |     }
109 |   }
110 | 
111 |   var globals = [], expected = ['Zepto', '$', 'Evidence', '_zid', 'jsonpDummy']
112 |   for (var key in window) globals.push(key)
113 | 
114 |   function checkLeakedGlobals() {
115 |     var opera = /^Opera\b/.test(navigator.userAgent)
116 |     for (var key in window)
117 |       if ( globals.indexOf(key) < 0 && expected.indexOf(key) < 0 &&
118 |           (!opera || typeof window[key] != 'object' || window[key].id != key) &&
119 |           window.console && console.warn
120 |           )
121 |         console.warn("unexpected global: " + key)
122 |   }
123 | })()
124 | 


--------------------------------------------------------------------------------
/test/fixtures/ajax_load_javascript.js:
--------------------------------------------------------------------------------
1 | window.testValue = 1
2 | 


--------------------------------------------------------------------------------
/test/fixtures/ajax_load_selector.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <title>testAjaxLoad</title>
 6 | </head>
 7 | <body>
 8 | <div id="ajax_load_test_div">ajax load with selector</div>
 9 | <div>
10 |   Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
11 | </div>
12 | </body>
13 | </html>
14 | 


--------------------------------------------------------------------------------
/test/fixtures/ajax_load_selector_javascript.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <title>testAjaxLoad</title>
 6 | </head>
 7 | <body>
 8 | <div id="ajax_load_test_div">ajax load with selector</div>
 9 | <div>
10 |   Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
11 | </div>
12 | <script>
13 |   window.testValue = 1
14 | </script>
15 | </body>
16 | </html>
17 | 


--------------------------------------------------------------------------------
/test/fixtures/ajax_load_simple.html:
--------------------------------------------------------------------------------
1 | simple ajax load
2 | 


--------------------------------------------------------------------------------
/test/fixtures/iframe_document.html:
--------------------------------------------------------------------------------
1 | <b>Hello from iframe!</b>
2 | 


--------------------------------------------------------------------------------
/test/fixtures/zepto.json:
--------------------------------------------------------------------------------
1 | {
2 |   "zepto": "awesomeness"
3 | }
4 | 


--------------------------------------------------------------------------------
/test/form.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | <head>
  4 |   <meta charset="utf-8">
  5 |   <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  6 |   <link rel="stylesheet" href="test.css">
  7 |   <title>Zepto Form unit tests</title>
  8 |   <script src="../vendor/evidence.js"></script>
  9 |   <script src="evidence_runner.js"></script>
 10 |   <script>
 11 |     // avoid caching
 12 |     (function(){
 13 |       function load(scripts){
 14 |         scripts.split(' ').forEach(function(script){
 15 |           document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
 16 |         })
 17 |       }
 18 | 
 19 |       load('zepto event form ie')
 20 |     })()
 21 |   </script>
 22 | </head>
 23 | <body>
 24 |   <h1>Zepto Form unit tests</h1>
 25 |   <p id="results">
 26 |     Running… see browser console for results
 27 |   </p>
 28 | 
 29 |   <div id="fixtures">
 30 |   <form id="login_form" target="formtarget" action="./idontexist.html">
 31 |     <input name="email" value="koss@nocorp.me">
 32 |     <input name="password" value="123456">
 33 |     <input name="unchecked_hasValue" value="myValue" type="checkbox">
 34 |     <input name="unchecked_noValue" type="checkbox">
 35 |     <input name="checked_hasValue" checked value="myValue" type="checkbox">
 36 |     <input name="checked_disabled" checked value="ImDisabled" type="checkbox" disabled>
 37 |     <input name="checked_noValue" checked type="checkbox">
 38 |     <input type="text" id="no_name">
 39 |     <input type="file" name="file_upload">
 40 | 
 41 |     <fieldset>
 42 |       <input type="radio" name="radio1" value="r1">
 43 |       <input type="radio" name="radio1" checked value="r2">
 44 |       <input type="radio" name="radio1" value="r3">
 45 |     </fieldset>
 46 | 
 47 |     <select name="selectbox">
 48 |       <option value="selectopt1">select1</option>
 49 |       <option value="selectopt2">select2</option>
 50 |       <option value="selectopt3">select3</option>
 51 |     </select>
 52 | 
 53 |     <select name="users[id][]" multiple>
 54 |       <option value="1">a</option>
 55 |       <option value="2" selected>b</option>
 56 |       <option value="3" selected>c</option>
 57 |       <option value="4">d</option>
 58 |     </select>
 59 | 
 60 |     <div class="actions">
 61 |       <!--
 62 |         The name of the following element can't be "submit",
 63 |         as this breaks on IE 10 (the form's "submit" method
 64 |         is overwritten by an accessor to the input field
 65 |         with the "submit" name). Yes, that's a dumb bug.
 66 |       -->
 67 |       <input type="submit" name="submit_button" value="Save">
 68 | 
 69 |       <input type="button" name="preview" value="Preview">
 70 |       <input type="reset" name="clear" value="Clear form">
 71 |       <button name="button">I'm a button</button>
 72 |     </div>
 73 |   </form>
 74 | 
 75 |   <iframe name="formtarget"></iframe>
 76 |   </div>
 77 | 
 78 |   <script>
 79 |   (function(){
 80 | 
 81 |     // TODO: do we really need this function? This should be refactored.
 82 |     var isObjectEquals = function(obj1, obj2){
 83 |       for (var key in obj1)
 84 |         switch(typeof(obj1[key])) {
 85 |           case 'object':
 86 |             if (!isObjectEquals(obj1[key], obj2[key]))
 87 |               return false
 88 |             break
 89 | 
 90 |           case 'function':
 91 |             if (typeof(obj2[key]) == 'undefined' ||
 92 |               (obj1[key].toString() != obj2[key].toString()))
 93 |               return false
 94 |             break
 95 | 
 96 |           default:
 97 |             if (obj1[key] != obj2[key])
 98 |               return false
 99 |         }
100 | 
101 |       for (key in obj2)
102 |         if (typeof(obj1[key]) == 'undefined')
103 |           return false
104 | 
105 |       return true
106 |     }
107 | 
108 |     Evidence.Assertions.assertEqualObject = function(expected, actual, message) {
109 |       this._assertExpression(
110 |         isObjectEquals(expected, actual),
111 |         message || 'Failed assertion.',
112 |         'Expected %o, got %o.', expected, actual
113 |       )
114 |     }
115 | 
116 |     Evidence('FormTest', {
117 | 
118 |       testSerializeArray: function(t){
119 |         var loginForm = $('#login_form')
120 |         t.assertEqualObject(
121 |           [
122 |               { name: 'email', value: 'koss@nocorp.me' },
123 |               { name: 'password', value: '123456' },
124 |               { name: 'checked_hasValue', value: 'myValue' },
125 |               { name: 'checked_noValue', value: 'on' },
126 |               { name: 'radio1', value: 'r2' },
127 |               { name: 'selectbox', value: 'selectopt1' },
128 |               { name: 'users[id][]', value: '2' },
129 |               { name: 'users[id][]', value: '3' }
130 |           ],
131 |           loginForm.serializeArray()
132 |         )
133 |       },
134 | 
135 |       testSerialize: function(t){
136 |         var loginForm = $('#login_form')
137 |         t.assertEqual('email=koss%40nocorp.me&password=123456&checked_hasValue=myValue&checked_noValue=on&radio1=r2&selectbox=selectopt1&users%5Bid%5D%5B%5D=2&users%5Bid%5D%5B%5D=3', loginForm.serialize())
138 |       },
139 | 
140 |       testFormSubmit: function(t){
141 |         var eventTriggered = false
142 |         $('#login_form').submit(function(event){
143 |           eventTriggered = true
144 |           event.preventDefault()
145 |         })
146 |         $('#login_form').submit()
147 |         t.assert(eventTriggered)
148 |       },
149 | 
150 |       testFormSubmitBindFalse: function(t){
151 |         var eventPropagated = false
152 |         $(document).on('submit', function(){
153 |           eventPropagated = true
154 |         })
155 | 
156 |         try {
157 |           var form = $('#login_form')
158 |           form.submit(false)
159 |           form.submit()
160 |           t.assertFalse(eventPropagated)
161 |         } finally {
162 |           $(document).off('submit')
163 |         }
164 |       },
165 | 
166 |       testSerializeEmptyCollection: function(t){
167 |         t.assertIdentical(0, $().serializeArray().length)
168 |         t.assertIdentical("", $().serialize())
169 |       }
170 | 
171 |     })
172 |   })()
173 |   </script>
174 | </body>
175 | </html>
176 | 


--------------------------------------------------------------------------------
/test/functional/assets.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <title>Zepto assets functional test</title>
 6 |   <link rel="stylesheet" href="../test.css">
 7 |   <meta name="viewport" content="maximum-scale=1,initial-scale=1,user-scalable=0">
 8 |   <script src="../../src/zepto.js"></script>
 9 |   <script src="../../src/ie.js"></script>
10 |   <style>
11 |     #container div {
12 |       margin: 2px;
13 |       padding: 2px;
14 |       display: block;
15 |       background-color: #ccc;
16 |     }
17 |     img {
18 |       margin: 0;
19 |       height: 100px;
20 |       vertical-align: middle;
21 |     }
22 |   </style>
23 | </head>
24 | <body>
25 |   <h1>Zepto assets functional test</h1>
26 | 
27 |   <div id="browser"></div>
28 | 
29 |   <ul>
30 |     <li><a href="?without">Run without the assets plugin</a></li>
31 |     <li><a href="?with">Run with the assets plugin</a></li>
32 |     <li><a href="?">Stop</a></li>
33 |   </ul>
34 | 
35 |   <p>When you run this test without the assets plugin, Mobile Safari will stop loading after on average 8 images (that's on the iPad with 1 MB images). It might also crash.</p>
36 |   <p><strong>PLEASE NOTE:</strong> You <strong>must restart Safari</strong> between runs (click the home button to return to the home screen, double-click the home button, tap-and-hold the Safari icon, then tap the minus badge).</p>
37 | 
38 |   <div id="container"></div>
39 | 
40 |   <script>
41 |     var prefix = 'http://stuff.vandervossen.net/temporary/zepto_assets_test/sintel-',
42 |         mode = window.location.search.slice(1),
43 |         timeout,
44 |         i
45 |     if (mode === 'with') {
46 |       document.write('<script src="../src/assets.js"></s'+'cript>')
47 |       document.write('RUNNING WITH ASSETS PLUGIN')
48 |     }
49 |     if (mode !== '') {
50 |       i = 1
51 |       ;(function frame() {
52 |         $('#image' + (i - 4)).remove()
53 |         $('#container').prepend('<div>' + i + ': <img id="image' + i + '" src="' + prefix + i + '.jpg"></div>')
54 |         if (i++ < 51) timeout = setTimeout(frame, 6000)
55 |       })()
56 |     }
57 | 
58 |     $('#browser').text(navigator.userAgent)
59 |   </script>
60 | </body>
61 | </html>
62 | 


--------------------------------------------------------------------------------
/test/functional/fx.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <meta name="viewport" content="maximum-scale=1,initial-scale=1,user-scalable=0">
 6 |   <link rel="stylesheet" href="../test.css">
 7 |   <title>Zepto fx functional test</title>
 8 |   <script src="../../src/zepto.js"></script>
 9 |   <script src="../../src/event.js"></script>
10 |   <script src="../../src/fx.js"></script>
11 |   <script src="../../src/fx_methods.js"></script>
12 |   <script src="../../src/ie.js"></script>
13 |   <style>
14 |     #fx_test, #fx_test_2  { text-align: center; background: darkred; color: white; font-size: x-large; }
15 |     #fx_test_2 { background: darkblue; }
16 |   </style>
17 | </head>
18 | <body>
19 |   <h1>Zepto fx functional</h1>
20 | 
21 |   <div style="width: 280px; height: 180px; background: #ddd; -webkit-user-select: none; margin-bottom: 1em">
22 |     <div id="fx_test" style="height: 100%; line-height: 170px">I  ♥ fx</div>
23 |   </div>
24 | 
25 |   <div style="width: 280px; height: 180px; background: #ddd; -webkit-user-select: none; margin-bottom: 1em">
26 |     <div id="fx_test_2" style="height: 100%; line-height: 170px">I  ♥ fx</div>
27 |   </div>
28 | 
29 |   <button onclick="$('#fx_test').hide('slow')">Hide</button>
30 |   <button onclick="$('#fx_test').show('slow')">Show</button>
31 |   <button onclick="$('#fx_test').show()">Reg. show</button>
32 |   <button onclick="$('#fx_test').toggle('slow')">Toggle</button>
33 |   <button onclick="$('#fx_test, #fx_test_2').toggle('slow')">Both: Toggle ('slow')</button>
34 |   <button onclick="$('#fx_test, #fx_test_2').toggle()">Both: Toggle</button>
35 |   <br>
36 |   <button onclick="$('#fx_test').fadeIn('slow')">Fade in</button>
37 |   <button onclick="$('#fx_test').fadeOut('slow')">Fade out</button>
38 |   <button onclick="$('#fx_test').fadeToggle('slow')">Fade toggle</button>
39 |   <button onclick="$('#fx_test, #fx_test_2').fadeToggle('slow')">Both: Fade toggle</button>
40 | 
41 |   <div id="browser"> </div>
42 | 
43 |   <script>
44 |     $('#browser').text(navigator.userAgent)
45 |     $('#fx_test_2').toggle()
46 |   </script>
47 | </body>
48 | </html>
49 | 


--------------------------------------------------------------------------------
/test/functional/gesture.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <title>Zepto gesture functional test</title>
 6 |   <meta name="viewport" content="maximum-scale=1,initial-scale=1,user-scalable=0">
 7 |   <link rel="stylesheet" href="../test.css">
 8 |   <script src="../../src/zepto.js"></script>
 9 |   <script src="../../src/event.js"></script>
10 |   <script src="../../src/detect.js"></script>
11 |   <script src="../../src/gesture.js"></script>
12 |   <script src="../../src/ie.js"></script>
13 | </head>
14 | <body>
15 |   <h1>Zepto gestures functional test</h1>
16 | 
17 |   <div id="gesture_test" style="width: 200px; height: 200px; background: #ddd; -webkit-user-select: none">
18 |     gesture events test
19 |   </div>
20 | 
21 |   <div id="browser"> </div>
22 | 
23 |   <script>
24 |     $('#browser').text(navigator.userAgent)
25 | 
26 |     $('#gesture_test')
27 |       .pinch(function(){
28 |         $(this).append(' | pinch!')
29 |       })
30 |       .pinchIn(function(){
31 |         $(this).append(' | pinch in!')
32 |       })
33 |       .pinchOut(function(){
34 |         $(this).append(' | pinch out!')
35 |       })
36 |   </script>
37 | </body>
38 | </html>
39 | 


--------------------------------------------------------------------------------
/test/functional/touch.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | <head>
  4 |   <meta charset="utf-8">
  5 |   <title>Zepto touch functional test</title>
  6 |   <meta name="viewport" content="maximum-scale=1,initial-scale=1,user-scalable=0">
  7 |   <link rel="stylesheet" href="../test.css">
  8 |   <script src="../../src/zepto.js"></script>
  9 |   <script src="../../src/event.js"></script>
 10 |   <script src="../../src/ie.js"></script>
 11 |   <script src="../../src/touch.js"></script>
 12 | </head>
 13 | <body>
 14 |   <h1>Zepto touch functional test</h1>
 15 | 
 16 |   <p>
 17 |     Browser supports touch events?
 18 |     <script>document.write('ontouchstart' in window)</script><br>
 19 | 
 20 |     Browser supports MS pointer events?
 21 |     <script>document.write(!!navigator.msPointerEnabled)</script>
 22 |   </p>
 23 | 
 24 |   <div id="touch_test" style="width: 200px; height: 200px; background: #cce; -webkit-user-select: none">
 25 |     touch events test
 26 |   </div>
 27 | 
 28 |   <div id='touch_test_scrollable' style="width: 200px; height: 200px; background: #cec; -webkit-user-select: none">
 29 |     touch events test (scrollable cancel)
 30 |   </div>
 31 | 
 32 |   <div id='touch_test_single' style="width: 200px; height: 200px; background: #ecc; -webkit-user-select: none">
 33 |     touch events test (scrollable cancel, single tap only)
 34 |   </div>
 35 | 
 36 |   <div id="browser"> </div>
 37 | 
 38 |   <script>
 39 |     $('#browser').text(navigator.userAgent)
 40 | 
 41 |     /**
 42 |      * #touch_test
 43 |      * Container that captures all touch events.
 44 |      *
 45 |      * Prevents default on touchmove, disabling scrolling.
 46 |      * Captures swipes in all directions.
 47 |      * Captures tap, singleTap (after delay), doubleTap, longTap
 48 |      */
 49 |     $('#touch_test').bind('touchmove', function(e) { e.preventDefault() })
 50 |     listen_to('#touch_test')
 51 | 
 52 |     /**
 53 |      * #touch_test_scrollable
 54 |      * Container that allows scrolling while capturing all events except swipes in the direction of scroll
 55 |      *
 56 |      * Captures swipes in non-scrolling directions
 57 |      * Captures tap, singleTap (after delay), doubleTap, longTap
 58 |      */
 59 |     listen_to('#touch_test_scrollable')
 60 | 
 61 |     /**
 62 |      * #touch_test_single
 63 |      * Container that allows scrolling and captures only simple, single taps
 64 |      * eg: a button or a tappable list item
 65 |      *
 66 |      * Cancels touch after tap, disabling other touch events (singleTap, doubleTap)
 67 |      * Captures tap
 68 |      */
 69 |     $('#touch_test_single').bind('tap', function(e) {
 70 |       e.cancelTouch()
 71 |     })
 72 |     listen_to('#touch_test_single')
 73 | 
 74 | 
 75 | 
 76 |     function listen_to(el) {
 77 |       $(el).tap(function(){
 78 |         $(this).append(' | tap!')
 79 |       })
 80 |       .doubleTap(function(){
 81 |         $(this).append(' | double tap!')
 82 |       })
 83 |       .swipe(function(){
 84 |         $(this).append(' | swipe!')
 85 |       })
 86 |       .swipeLeft(function(){
 87 |         $(this).append(' | swipe left!')
 88 |       })
 89 |       .swipeRight(function(){
 90 |         $(this).append(' | swipe right!')
 91 |       })
 92 |       .swipeUp(function(){
 93 |         $(this).append(' | swipe up!')
 94 |       })
 95 |       .swipeDown(function(){
 96 |         $(this).append(' | swipe down!')
 97 |       })
 98 |       .longTap(function(){
 99 |         $(this).append(' | long tap!')
100 |       })
101 |       .singleTap(function(){
102 |         $(this).append(' | single tap!')
103 |       })
104 |     }
105 |   </script>
106 | </body>
107 | </html>
108 | 


--------------------------------------------------------------------------------
/test/functional/touchcancel.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <title>Zepto touch functional test</title>
 6 |   <meta name="viewport" content="maximum-scale=1,initial-scale=1,user-scalable=0">
 7 |   <link rel="stylesheet" href="../test.css">
 8 |   <script src="../../src/zepto.js"></script>
 9 |   <script src="../../src/event.js"></script>
10 |   <script src="../../src/ie.js"></script>
11 |   <script src="../../src/touch.js"></script>
12 | </head>
13 | <body>
14 |   <h1>Zepto touch functional test</h1>
15 | 
16 |   <p>
17 |     Double-tap and hold until the JavaScript alert occurs. After closing the
18 |     alert, tap again. Without touchcancel you will see a double tap instead of a tap.
19 |   </p>
20 | 
21 |   <div id="touch_test" style="width: 200px; height: 200px; background: #ddd">
22 |     touch events test
23 |   </div>
24 | 
25 |   <div id="browser"> </div>
26 | 
27 |   <script>
28 |     $('#browser').text(navigator.userAgent)
29 | 
30 |     setTimeout(function(){
31 |       alert("Alert! Now tap again, you should see a tap!, not a double tap!")
32 |     }, 3000)
33 | 
34 |     $('body').bind('touchmove', function(e){ e.preventDefault() })
35 |     $('#touch_test')
36 |       .tap(function(){
37 |         $(this).append(' | tap!')
38 |       })
39 |       .doubleTap(function(){
40 |         $(this).append(' | double tap!')
41 |       })
42 |       .swipe(function(){
43 |         $(this).append(' | swipe!')
44 |       })
45 |       .swipeLeft(function(){
46 |         $(this).append(' | swipe left!')
47 |       })
48 |       .swipeRight(function(){
49 |         $(this).append(' | swipe right!')
50 |       })
51 |       .swipeUp(function(){
52 |         $(this).append(' | swipe up!')
53 |       })
54 |       .swipeDown(function(){
55 |         $(this).append(' | swipe down!')
56 |       })
57 | 
58 |   </script>
59 | </body>
60 | </html>
61 | 


--------------------------------------------------------------------------------
/test/fx.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | <head>
  4 |   <meta charset="utf-8">
  5 |   <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  6 |   <link rel="stylesheet" href="test.css">
  7 |   <title>Zepto Fx unit tests</title>
  8 |   <script src="../vendor/evidence.js"></script>
  9 |   <script src="evidence_runner.js"></script>
 10 |   <script>
 11 |     // avoid caching
 12 |     (function(){
 13 |       function load(scripts){
 14 |         scripts.split(' ').forEach(function(script){
 15 |           document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
 16 |         })
 17 |       }
 18 | 
 19 |       load('zepto event fx ie')
 20 |     })()
 21 |   </script>
 22 |   <style>
 23 |     @-webkit-keyframes animName {
 24 |       0% {
 25 |         -webkit-transform: rotate(180deg) scale(.8);
 26 |         opacity: 1;
 27 |       }
 28 |       100% {
 29 |         -webkit-transform: rotate(0deg) scale(1) translate3d(80px, 20px, 0);
 30 |         opacity: 0.5;
 31 |       }
 32 |     }
 33 |     @-moz-keyframes animName {
 34 |       from {
 35 |         -moz-transform: rotate(180deg) scale(.8) translate(0, 0);
 36 |         opacity: 1;
 37 |       }
 38 |       to {
 39 |         -moz-transform: rotate(0deg) scale(1) translate(80px, 20px);
 40 |         opacity: 0.5;
 41 |       }
 42 |     }
 43 |      @keyframes animName {
 44 |       from {
 45 |         transform: rotate(180deg) scale(.8) translate(0, 0);
 46 |         opacity: 1;
 47 |       }
 48 |       to {
 49 |         transform: rotate(0deg) scale(1) translate(80px, 20px);
 50 |         opacity: 0.5;
 51 |       }
 52 |     }
 53 | 
 54 |     #keyframetest {
 55 |       opacity: 0.5;
 56 |       -webkit-transform: translate3d(80px, 20px, 0);
 57 |       -moz-transform: translate3d(80px, 20px, 0);
 58 |       transform: translate3d(80px, 20px, 0);
 59 |     }
 60 | 
 61 |     .fixtures-left {
 62 |       width: 120px;
 63 |       float: left;
 64 |     }
 65 |     .fixtures-right {
 66 |       margin-left: 120px;
 67 |     }
 68 |   </style>
 69 | </head>
 70 | <body>
 71 |   <h1>Zepto Fx unit tests</h1>
 72 |   <p id="results">
 73 |     Running… see browser console for results
 74 |   </p>
 75 | 
 76 |   <div class=fixtures-left>
 77 |     <div id="animtest_1" style="width:40px;height:40px;background:red"></div>
 78 |     <div id="animtest_2" style="width:40px;height:40px;background:red"></div>
 79 |     <div id="durationtest_1" style="width:40px;height:40px;background:red"></div>
 80 |     <div id="durationtest_2" style="width:40px;height:40px;background:red"></div>
 81 |     <div id="delaytest" style="width:40px;height:40px;background:red"></div>
 82 |   </div>
 83 |   <div class=fixtures-right>
 84 |     <div id="durationtest_3" style="width:40px;height:40px;background:red"></div>
 85 |     <div id="callbacktest" style="width:40px;height:40px;background:red"><div style="width:40px;height:40px;background:blue"></div></div>
 86 |     <div id="keyframetest" style="width:40px;height:40px;background:red;"></div>
 87 |   </div>
 88 | 
 89 |   <div id="anim_zero_duration_callback_test"></div>
 90 | 
 91 |   <script>
 92 |   (function(){
 93 | 
 94 |     function colorToHex (color) {
 95 |       if (color.substr(0, 1) === '#') {
 96 |         return color
 97 |       }
 98 | 
 99 |       var digits = /(.*?)rgb\((\d+), (\d+), (\d+)\)/.exec( color.toLowerCase() ),
100 |           red    = parseInt(digits[2]),
101 |           green  = parseInt(digits[3]),
102 |           blue   = parseInt(digits[4]),
103 |           rgb = blue | (green << 8) | (red << 16)
104 | 
105 |       return digits[1] + '#' + rgb.toString(16)
106 |     }
107 | 
108 |     function defer(delay, fn) {
109 |       setTimeout(fn, delay || 0)
110 |     }
111 | 
112 |     function camelize(str) {
113 |       return str.replace(/-+(.)?/g, function(_, chr){ return chr ? chr.toUpperCase() : '' })
114 |     }
115 | 
116 |     var stylePrefix = $.fx.cssPrefix
117 | 
118 |     Evidence.Assertions.assertStyle = function(expected, object, property, message) {
119 |       if (/^(transform|transition|animation)/.test(property)) property = stylePrefix + property
120 |       if (!('nodeName' in object)) object = object.get(0)
121 | 
122 |       var actual = object.style[camelize(property)],
123 |         expression = expected instanceof RegExp ? expected.test(actual) : expected === actual
124 | 
125 |       this._assertExpression(expression, message || 'Failed assertion.',
126 |         'Expected '+property+' to be '+expected+', got '+actual+'.\n'+
127 |         $.fx.stylePrefix +':\n' +
128 |         object.style.cssText)
129 |     }
130 | 
131 |     Evidence('ZeptoFXTest', {
132 | 
133 |       testAnimate: function(t){
134 |         var el = $('#animtest_1'), el2 = $('#animtest_2')
135 | 
136 |         el.animate({
137 |           translate3d: '80px, 20px, 100px',
138 |           rotateZ: '90deg',
139 |           scale: '0.8',
140 |           opacity: 0.5,
141 |           backgroundColor: '#BADA55',
142 |           backgroundPositionY: '50%'
143 |         }, 200, 'ease-out')
144 | 
145 |         el2.animate({
146 |           translate3d: '80px, 20px, 100px',
147 |           rotateZ: '-90deg',
148 |           backgroundColor: '#BADA55'
149 |         }, {
150 |           duration: 180,
151 |           easing: 'ease-out'
152 |         })
153 | 
154 |         t.assertStyle('ease-out', el, 'transition-timing-function')
155 |         t.assertStyle('0.2s', el, 'transition-duration')
156 |         t.assertStyle(/\bbackground-color\b/, el, 'transition-property')
157 |         t.assertStyle(/\bbackground-position-y\b/, el, 'transition-property')
158 |         t.assertStyle(/\btransform\b/, el, 'transition-property')
159 |         t.assertStyle('0.18s', el2, 'transition-duration')
160 | 
161 |         t.pause()
162 |         defer(250, function(){
163 |           t.resume(function(){
164 |             t.assertStyle('translate3d(80px, 20px, 100px) rotateZ(90deg) scale(0.8)', el, 'transform')
165 |             t.assertStyle('0.5', el, 'opacity')
166 |             t.assertStyle(/^(50%|center)$/, el, 'background-position-y')
167 |             t.assertEqual('#BADA55', colorToHex(el.get(0).style.backgroundColor).toUpperCase())
168 |           })
169 |         })
170 |       },
171 | 
172 |       testDuration: function(t){
173 |         var el1 = $('#durationtest_1').anim({
174 |           translate3d: '80px, 20px, 100px',
175 |           rotateZ: '90deg',
176 |           opacity: 0.5
177 |         })
178 | 
179 |         var el2 = $('#durationtest_2').anim({
180 |           translate3d: '80px, 20px, 100px',
181 |           rotateZ: '90deg',
182 |           opacity: 0.5
183 |         }, 0)
184 | 
185 |         t.assertStyle('0.4s', el1, 'transition-duration', 'expected default duration')
186 |         t.assertStyle('', el2, 'transition-duration', 'expected no animation')
187 |       },
188 | 
189 |       testDurationString: function(t){
190 |         var el = $('#durationtest_3').animate({
191 |           translate3d: '80px, 20px, 100px',
192 |           rotateZ: '90deg',
193 |           opacity: 0.5
194 |         }, 'fast')
195 | 
196 |         t.assertStyle('0.2s', el, 'transition-duration', 'expected fast duration')
197 |       },
198 | 
199 |       testDelay: function(t){
200 |         var duration = 100, delay = 50,
201 |           start = new Date().getTime()
202 | 
203 |         t.pause()
204 |         var el1 = $('#delaytest').animate({
205 |           translate3d: '80px, 20px, 100px',
206 |           rotateZ: '90deg',
207 |           opacity: 0.5
208 |         }, {
209 |           duration: duration,
210 |           delay: delay,
211 |           complete: function() {
212 |             t.resume(function(){
213 |               var ms = new Date().getTime() - start
214 |               t.assert(ms >= (duration + delay),
215 |                 'Fired too early (' + ms + ' ms) after having delay')
216 |             })
217 |           }
218 |         })
219 | 
220 |         t.assertStyle('0.05s', el1, 'transition-delay', 'expected delay to be set')
221 |       },
222 | 
223 |       testCallback: function(t){
224 |         var duration = 250, start = new Date().getTime()
225 | 
226 |         t.pause()
227 |         $('#callbacktest').animate({
228 |           translate3d: '80px, 20px, 100px',
229 |           rotateZ: '90deg',
230 |           opacity: 0.5
231 |         }, duration, 'linear',
232 |         function(){
233 |           var context = this
234 |           t.resume(function(){
235 |             t.assert($(context).is('#callbacktest'), "context for callback is wrong")
236 |             t.assert((new Date().getTime() - start) >= duration, 'Fired too early')
237 |             t.assertStyle('', context, 'transition')
238 |             t.assertStyle('', context, 'transition-property')
239 |             t.assertStyle('', context, 'transition-timing-function')
240 |             t.assertStyle('', context, 'transition-duration')
241 |             t.assertStyle('', context, 'animation-name')
242 |             t.assertStyle('', context, 'animation-duration')
243 |           })
244 |         })
245 |       },
246 | 
247 |       testCallbackWithoutEasing: function(t){
248 |         var duration = 250, start = new Date().getTime()
249 | 
250 |         t.pause()
251 |         $('#callbacktest').animate({
252 |           translate3d: '10px, 20px, 400px',
253 |           rotateZ: '-90deg',
254 |           opacity: 0.2
255 |         }, duration,
256 |         function(){
257 |           var context = this
258 |           t.resume(function(){
259 |             t.assert($(context).is('#callbacktest'), "context for callback is wrong")
260 |             t.assert((new Date().getTime() - start) >= duration, 'Fired too early')
261 |             t.assertStyle('', context, 'transition')
262 |             t.assertStyle('', context, 'transition-property')
263 |             t.assertStyle('', context, 'transition-timing-function')
264 |             t.assertStyle('', context, 'transition-duration')
265 |             t.assertStyle('', context, 'animation-name')
266 |             t.assertStyle('', context, 'animation-duration')
267 |           })
268 |         })
269 |       },
270 | 
271 |       testCallbackWithoutEasingAndWithoutDuration: function(t){
272 |         var duration = 250, start = new Date().getTime()
273 | 
274 |         t.pause()
275 |         $('#callbacktest').animate({
276 |           translate3d: '30px, 220px, 40px',
277 |           rotateZ: '180deg',
278 |           opacity: 0.9
279 |         },
280 |         function(){
281 |           var context = this
282 |           t.resume(function(){
283 |             t.assert($(context).is('#callbacktest'), "context for callback is wrong")
284 |             t.assert((new Date().getTime() - start) >= duration, 'Fired too early')
285 |             t.assertStyle('', context, 'transition')
286 |             t.assertStyle('', context, 'transition-property')
287 |             t.assertStyle('', context, 'transition-timing-function')
288 |             t.assertStyle('', context, 'transition-duration')
289 |             t.assertStyle('', context, 'animation-name')
290 |             t.assertStyle('', context, 'animation-duration')
291 |           })
292 |         })
293 |       },
294 | 
295 |       testBubbling: function(t){
296 |         $('#callbacktest div').anim({ opacity: 0.0 }, 0.1, 'linear')
297 | 
298 |         var el = $('#anim_zero_duration_callback_test'),
299 |           callbackCalled = false
300 | 
301 |         el.anim({ opacity: 0.5 }, 0, 'linear', function () {
302 |           t.assert($(this).is('#anim_zero_duration_callback_test'), "context for callback is wrong")
303 |           t.assertStyle('0.5', this, 'opacity')
304 |           callbackCalled = true
305 |         })
306 | 
307 |         t.pause()
308 |         defer(30, function(){
309 |           t.resume(function(){
310 |             t.assert(callbackCalled)
311 |           })
312 |         })
313 |       },
314 | 
315 |       testKeyFrameAnimation: function(t){
316 |         var el = $('#keyframetest').animate('animName', 200)
317 | 
318 |         t.assertStyle('animName', el, 'animation-name')
319 |         t.assertStyle('0.2s',     el, 'animation-duration')
320 |         t.assertStyle('linear',   el, 'animation-timing-function')
321 |       },
322 | 
323 |       testEmptyCollection: function(t){
324 |         t.assert($(null).animate({opacity:0}))
325 |       }
326 |     })
327 |   })()
328 |   </script>
329 | </body>
330 | </html>
331 | 


--------------------------------------------------------------------------------
/test/ie.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
 6 |   <link rel="stylesheet" href="test.css">
 7 |   <title>Zepto Touch unit tests</title>
 8 |   <script src="../vendor/evidence.js"></script>
 9 |   <script src="evidence_runner.js"></script>
10 |   <script>
11 |     // avoid caching
12 |     (function(){
13 |       function load(scripts){
14 |         scripts.split(' ').forEach(function(script){
15 |           document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
16 |         })
17 |       }
18 | 
19 |       load('ie')
20 |     })()
21 |   </script>
22 |   <style>
23 |       body {
24 |           height: 50px;
25 |       }
26 |       body:after {
27 |           content: 'abc';
28 |       }
29 |   </style>
30 | </head>
31 | <body>
32 |   <h1>Zepto ie unit tests</h1>
33 |   <p id="results">
34 |     Running… see browser console for results
35 |   </p>
36 | 
37 |   <script>
38 |     (function(){
39 | 
40 |       Evidence('getComputedStyle', {
41 | 
42 |         //Test to check if getComputedStyle does not blow up when no element are provided
43 |         testGetComputedStyleNoElem: function(t){
44 |           t.assertEqual(null, getComputedStyle())
45 |         },
46 | 
47 |         //Test to check if computed styles for elements are returned correctly
48 |         testGetComputedStyle: function(t){
49 |           t.assertEqual('50px', getComputedStyle(document.body).height)
50 |         },
51 | 
52 |         //Test to check if computed styles for pseudo-elements are returned correctly
53 |         //Assertion a bit hacky as IE returns the value in double quotes
54 |         testGetComputedStylePseudoElem: function(t){
55 |           t.assert(getComputedStyle(document.body, ':after').content.indexOf('abc') >  -1)
56 |         }
57 | 
58 |       })
59 |     })()
60 |   </script>
61 | 
62 | </body>
63 | </html>
64 | 


--------------------------------------------------------------------------------
/test/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
 6 |   <link rel="stylesheet" href="test.css">
 7 |   <title>Zepto tests</title>
 8 | </head>
 9 | <body>
10 |   <h1>Zepto tests</h1>
11 |   <p>
12 |     This file is provided for manual testing. If there's a test failure,
13 |     please report the user agent:
14 |     <b><script>document.write(navigator.userAgent)</script></b>
15 |   </p>
16 |   <p>
17 |     Start a test server with (you'll need to have <a href="https://npmjs.org">npm</a> installed):<br>
18 |     <br>
19 |     <b>$ npm install</b> (if you haven't installed dependencies yet)<br>
20 |     <b>$ npm run-script start</b>
21 |     <br><br>
22 |     On your device, go to<br>
23 |     <b>http://your-ip-address:3000/test</b>
24 |   </p>
25 |   <p>
26 |     To start a test, click or tap it. Use the back button of
27 |     your browser to return to this index page.
28 |     Functional tests may require manual interaction.
29 |   </p>
30 | 
31 |   <h2>Default modules unit tests</h2>
32 |   <ul>
33 |     <li><a href="zepto.html">zepto</a> (core module, test this first!)</li>
34 |     <li><a href="event.html">event</a></li>
35 |     <li><a href="ajax.html">ajax</a></li>
36 |     <li><a href="form.html">form</a></li>
37 |   </ul>
38 | 
39 |   <h2>Other modules unit test</h2>
40 |   <ul>
41 |     <li><a href="fx.html">fx</a></li>
42 |     <li><a href="detect.html">detect</a></li>
43 |     <li><a href="data.html">data</a></li>
44 |     <li><a href="selector.html">selector</a></li>
45 |     <li><a href="stack.html">stack</a></li>
46 |     <li><a href="touch.html">touch</a></li>
47 |     <li><a href="deferred.html">deferred</a></li>
48 |     <li><a href="ajax_deferred.html">ajax + deferred</a></li>
49 |     <li><a href="callbacks.html">callbacks</a></li>
50 |     <li><a href="ios3.html">ios3</a></li>
51 |     <li><a href="ie.html">ie</a></li>
52 |   </ul>
53 | 
54 |   <h2>Functional tests</h2>
55 |   <ul>
56 |     <li><a href="functional/assets.html">assets</a></li>
57 |     <li><a href="functional/fx.html">fx</a></li>
58 |     <li><a href="functional/gesture.html">gesture</a></li>
59 |     <li><a href="functional/touch.html">touch</a></li>
60 |     <li><a href="functional/touchcancel.html">touchcancel</a></li>
61 |   </ul>
62 | 
63 |   <script>
64 |     // avoid caching
65 |     (function(){
66 |       [].slice.apply(document.getElementsByTagName('a')).forEach(function(link){
67 |         link.href += '?' + (+new Date)
68 |       })
69 |     })()
70 |   </script>
71 | </body>
72 | 


--------------------------------------------------------------------------------
/test/ios3.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
 6 |   <link rel="stylesheet" href="test.css">
 7 |   <title>Zepto iOS3 unit tests</title>
 8 |   <script src="../vendor/evidence.js"></script>
 9 |   <script src="evidence_runner.js"></script>  <script>
10 |     // avoid caching
11 |     (function(){
12 |       function load(scripts){
13 |         scripts.split(' ').forEach(function(script){
14 |           document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
15 |         })
16 |       }
17 | 
18 |       load('ios3 zepto ie')
19 |     })()
20 |   </script>
21 | </head>
22 | <body>
23 |   <h1>Zepto iOS3 unit tests</h1>
24 |   <p id="results">
25 |     Running… see browser console for results
26 |   </p>
27 |   <script>
28 |   (function(){
29 | 
30 |     Evidence('PolyfillTest', {
31 | 
32 |       // test to see if we augment String.prototype.trim if not supported natively
33 |       testTrim: function(t){
34 |         t.assertEqual("blah", " blah ".trim())
35 |         t.assertEqual("bl \n ah", " bl \n ah ".trim())
36 |       },
37 | 
38 |       // test to see if we augment Array.prototype.reduceif not supported natively
39 |       testReduce: function(t){
40 |         t.assertEqual(
41 |           10,
42 |           [0,1,2,3,4].reduce(function(p,c){ return p+c })
43 |         )
44 | 
45 |         t.assertEqual(
46 |           20,
47 |           [0,1,2,3,4].reduce(function(p,c){ return p+c }, 10)
48 |         )
49 | 
50 |         var flattened = [[0,1], [2,3], [4,5]].reduce(function(a,b){
51 |           return a.concat(b)
52 |         })
53 | 
54 |         t.assertEqual(6, flattened.length)
55 | 
56 |         for(var i=0;i<6;i++) t.assertEqual(i, flattened[i])
57 |       }
58 |     })
59 |   })()
60 |   </script>
61 | </body>
62 | </html>
63 | 


--------------------------------------------------------------------------------
/test/runner.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   var fs = require('fs')
 3 |   var system = require('system')
 4 |   var args = system.args.slice(1)
 5 | 
 6 |   var prefix = args.shift() || ("file://" + fs.workingDirectory + "/")
 7 | 
 8 |   var suites
 9 |   if (args.length > 0) {
10 |     suites = args
11 |   } else {
12 |     var modules = 'zepto ajax callbacks data deferred ajax_deferred detect touch event form fx selector stack'.split(/\s+/)
13 |     suites = modules.map(function(name) {
14 |       return "test/" + name + ".html"
15 |     })
16 |   }
17 | 
18 |   var page = require('webpage').create()
19 | 
20 |   page.onConsoleMessage = function(msg) {
21 |     console.log(msg)
22 |   }
23 | 
24 |   page.onError = function(msg, trace) {
25 |     console.log('ERROR: ' + msg)
26 |   }
27 | 
28 |   function waitFor(testFn, onReady, timeout) {
29 |     if (timeout == null) {
30 |       timeout = 30000
31 |     }
32 |     var start = new Date()
33 |     var interval = setInterval(function() {
34 |       if (testFn()) {
35 |         clearInterval(interval)
36 |         onReady()
37 |       } else if (new Date() - start > timeout) {
38 |         console.log("timed out.")
39 |         phantom.exit(1)
40 |       }
41 |     }, 100)
42 |   }
43 | 
44 |   function loadNextSuite() {
45 |     if (!suites.length) {
46 |       phantom.exit()
47 |     } else {
48 |       var url = suites.shift() + "?verbosity=WARN"
49 |       if (!/:\/\//.test(url)) {
50 |         url = prefix + url
51 |       }
52 |       page.open(url, function(status) {
53 |         if (status !== "success") {
54 |           console.log("failed opening " + url)
55 |           return phantom.exit(1)
56 |         }
57 |         waitFor(function() {
58 |           return page.evaluate(function() {
59 |             var res = document.getElementById('results')
60 |             if (res) {
61 |               return /finished/.test(res.className)
62 |             }
63 |           })
64 |         }, function() {
65 |           var passed = page.evaluate(function() {
66 |             var res = document.getElementById('results')
67 |             var paths = location.pathname.split('/')
68 |             console.log((paths[paths.length - 1] + " - ") + res.textContent)
69 |             return /passed/.test(res.className)
70 |           })
71 |           if (passed) {
72 |             loadNextSuite()
73 |           } else {
74 |             phantom.exit(1)
75 |           }
76 |         })
77 |       })
78 |     }
79 |   }
80 | 
81 |   loadNextSuite()
82 | 
83 | }).call(this)
84 | 


--------------------------------------------------------------------------------
/test/selector.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
 6 |   <link rel="stylesheet" href="test.css">
 7 |   <title>Zepto Selector unit tests</title>
 8 |   <script src="../vendor/evidence.js"></script>
 9 |   <script src="evidence_runner.js"></script>
10 |   <script src="../src/zepto.js"></script>
11 |   <script src="../src/selector.js"></script>
12 |   <script src="../src/ie.js"></script>
13 | </head>
14 | <body>
15 |   <h1>Zepto Selector unit tests</h1>
16 |   <p id="results">
17 |     Running… see browser console for results
18 |   </p>
19 |   <div id="fixtures">
20 |     <ul id=list><li>one</li><li>two</li></ul>
21 |     <div class=visibility id=vis>look at me!</div>
22 |     <div class=visibility id=invis style="display:none">can't see me</div>
23 |     <ol id=child class=test>
24 |       <li><span>child1</span></li>
25 |       <li><span>child2</span>
26 |         <ul>
27 |           <li><span>child3</span></li>
28 |           <li><span>child4</span></li>
29 |         </ul>
30 |       </li>
31 |     </ol>
32 |   </div><!-- fixtures -->
33 | 
34 |   <script>
35 |   (function(){
36 |     Evidence('SelectorTest', {
37 |       testFirst: function(t) {
38 |         var li = $('#list li:first')
39 |         t.assertEqual(1, li.size())
40 |         t.assertEqual('one', li.text())
41 |         t.assertEqual('two', $('#list li:eq(1)').text())
42 |       },
43 |       testLast: function(t) {
44 |         var li = $('#list li:last')
45 |         t.assertEqual(1, li.size())
46 |         t.assertEqual('two', li.text())
47 |       },
48 |       testParent: function(t) {
49 |         var list = $('#list li:parent')
50 |         t.assertEqual(1, list.size())
51 |         t.assertEqual('list', list.attr('id'))
52 |       },
53 |       testContains: function(t) {
54 |         t.assertEqual('two', $('#list li:contains("two")').text())
55 |       },
56 |       testVisibility: function(t) {
57 |         t.assertEqual('vis', $('.visibility:visible').attr('id'))
58 |         t.assertEqual('invis', $('.visibility:hidden').attr('id'))
59 |       },
60 |       testIs: function(t) {
61 |         t.assert($('#list').is('ul'))
62 |         t.assert($('#vis').is(':visible'))
63 |         t.refute($('#invis').is(':visible'))
64 |       },
65 |       testChild: function(t) {
66 |         var items = $('#child').find('> li'),
67 |             results = items.map(function(){
68 |               return $(this).find('> span').text()
69 |             }).get()
70 | 
71 |         t.assertEqual('child1 child2', results.join(' '))
72 |         t.assertEqual('test', $('#child').prop('class'))
73 |       },
74 |       testChildHas: function(t) {
75 |         var items = $('#child').find('> li:has(ul)'),
76 |             results = items.map(function(){
77 |               return $(this).find('> span').text()
78 |             }).get()
79 | 
80 |         t.assertEqual('child2', results.join(' '))
81 |       },
82 |       testEmptyHref: function(t) {
83 |         var result, el = $('<div><a href="#">one</a><a href="#">two</a></div>')
84 |         result = el.find('a[href=#]')
85 |         t.assertEqual('one two', result.map(function(){ return $(this).text() }).get().join(' '))
86 |       }
87 |     })
88 |   })()
89 |   </script>
90 | </body>
91 | </html>
92 | 


--------------------------------------------------------------------------------
/test/server.coffee:
--------------------------------------------------------------------------------
  1 | express = require 'express'
  2 | app     = express()
  3 | path    = require 'path'
  4 | 
  5 | module.exports = app
  6 | 
  7 | project_root = path.resolve(__dirname, '..')
  8 | app.use express.static(project_root)
  9 | app.use express.static(project_root + 'node_modules/mocha')
 10 | app.use express.static(project_root + 'node_modules/chai')
 11 | 
 12 | app.use express.bodyParser()
 13 | 
 14 | mime = (req) ->
 15 |   type = req.headers['content-type'] or ''
 16 |   type.split(';')[0]
 17 | 
 18 | dump = (obj) ->
 19 |   obj = '' unless obj
 20 |   obj = JSON.stringify(obj) if obj and typeof obj isnt "string"
 21 |   obj
 22 | 
 23 | cleanTrace = (traceStr) ->
 24 |   trace = traceStr.split("\n")
 25 |   filtered = []
 26 |   for line in trace
 27 |     if /\.html:/.test line
 28 |       line = line.replace(/^.+?@/, '')
 29 |       line = line.replace(/http:\/\/.+?\//, '')
 30 |       line = line.replace(/(:\d+):\d+$/, '$1')
 31 |       filtered.push line
 32 |   filtered
 33 | 
 34 | browser = (ua) ->
 35 |   if m = ua.match /(Android .+?);/
 36 |     m[1]
 37 |   else if m = ua.match /(iPhone|iPad|iPod).*?OS ([\d_]+)/
 38 |     'iOS ' + m[2].replace(/_/g, '.')
 39 |   else if m = ua.match /(Chrome\/[\d.]+)/
 40 |     m[1].replace '/', ' '
 41 |   else if m = ua.match /(Safari\/[\d.]+)/
 42 |     m[1].replace '/', ' '
 43 |   else if m = ua.match /(Firefox\/[\d.]+)/
 44 |     m[1].replace '/', ' '
 45 |   else if m = ua.match /\bMS(IE [\d.]+)/
 46 |     m[1]
 47 |   else
 48 |     ua
 49 | 
 50 | app.all '/', (req, res) ->
 51 |   res.redirect '/test'
 52 | 
 53 | app.all '/test/echo=?', (req, res) ->
 54 |   res.set 'Cache-Control', 'no-cache'
 55 |   res.send """
 56 |            #{req.method} ?#{dump(req.query)}
 57 |            content-type: #{mime(req)}
 58 |            accept: #{req.headers['accept']}
 59 |            #{dump(req.body)}
 60 |            """
 61 | 
 62 | app.get '/test/jsonp', (req, res) ->
 63 |   res.jsonp
 64 |     query: req.query
 65 |     hello: 'world'
 66 | 
 67 | # send JSONP response despite callback not being set
 68 | app.get '/test/jsonpBlah', (req, res) ->
 69 |   res.set 'Content-Type', 'text/javascript'
 70 |   res.send 'blah()'
 71 | 
 72 | app.get '/test/json', (req, res) ->
 73 |   res.set 'Cache-Control', 'no-cache'
 74 |   expectedType = req.headers['accept']
 75 |   if expectedType is '*/*' or /json/.test expectedType
 76 |     if req.query.invalid
 77 |       res.set 'Content-Type', 'application/json'
 78 |       res.send 'invalidJSON'
 79 |     else
 80 |       res.json
 81 |         query: req.query
 82 |         hello: 'world'
 83 |   else
 84 |     res.send 400, 'FAIL'
 85 | 
 86 | app.get '/test/taintedJSON', (req, res) ->
 87 |   res.set 'Content-Type', 'application/json'
 88 |   res.send 'while(1);{"hello" : "world"}'
 89 | 
 90 | app.post '/test/create', (req, res) ->
 91 |   res.json
 92 |     action: 'created'
 93 |     query: req.query
 94 |     payload: req.body
 95 | 
 96 | app.all '/test/slow', (req, res) ->
 97 |   setTimeout ->
 98 |     res.jsonp result: 'ok'
 99 |   , 200
100 | 
101 | app.get '/test/cached', (req, res) ->
102 |   res.set 'Cache-Control', 'max-age=2'
103 |   res.set 'Expires', new Date(Date.now() + 2000).toUTCString()
104 |   now = new Date()
105 |   res.send now.getTime().toString()
106 | 
107 | app.get '/test/auth', (req, res) ->
108 |   if req.headers.authorization is 'Basic emVwdG86ZG9nZQ=='
109 |     res.send 200
110 |   else
111 |     res.set 'WWW-Authenticate', "Basic realm=\"#{req.query.realm}\""
112 |     res.send 401
113 | 
114 | app.post '/test/log', (req, res) ->
115 |   params = req.body
116 |   trace = cleanTrace params.trace
117 |   console.log "[%s] %s: %s", browser(req.headers['user-agent']), params.name, params.message
118 |   console.log trace.join("\n").replace(/^/mg, '  ') if trace.length
119 |   res.send 200
120 | 
121 | app.all '/test/error', (req, res) ->
122 |   res.send 500, 'BOOM'
123 | 
124 | if process.argv[1] is __filename
125 |   port = process.argv[2]
126 |   unless port
127 |     port = 3000
128 |     console.log "Listening on port #{port}"
129 |   app.listen port
130 | 


--------------------------------------------------------------------------------
/test/stack.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
 6 |   <link rel="stylesheet" href="test.css">
 7 |   <title>Zepto Stack unit tests</title>
 8 |   <script src="../vendor/evidence.js"></script>
 9 |   <script src="evidence_runner.js"></script>
10 |   <script>
11 |     // avoid caching
12 |     (function(){
13 |       function load(scripts){
14 |         scripts.split(' ').forEach(function(script){
15 |           document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
16 |         })
17 |       }
18 | 
19 |       load('zepto stack ie')
20 |     })()
21 |   </script>
22 | </head>
23 | <body>
24 |   <h1>Zepto Stack unit tests</h1>
25 |   <p id="results">
26 |     Running… see browser console for results
27 |   </p>
28 |   <div id="fixtures">
29 | 
30 |   <div id="end_test">
31 |     <div class="end_one"><b><span></span></b></div>
32 |     <div class="end_two"><b><span>1</span><span>2</span></b></div>
33 |   </div>
34 | 
35 |   <div id="andself_test">
36 |     <div class="one"></div>
37 |     <div class="two"></div>
38 |     <div class="three"></div>
39 |     <div class="four"></div>
40 |   </div>
41 | 
42 |   </div><!-- fixtures -->
43 | 
44 |   <script>
45 |   (function(){
46 | 
47 |     Evidence('ZeptoTest', {
48 | 
49 |       testEnd: function (t) {
50 |         t.assert($().end().length == 0)
51 | 
52 |         var $endTest = $('#end_test')
53 |         var $endTest2 = $('#end_test').find('div').find('span').end().end()
54 |         t.assertEqual($endTest.length, $endTest2.length)
55 |         t.assertEqual($endTest.get(0), $endTest2.get(0))
56 |       },
57 | 
58 |       testAndSelf: function (t) {
59 |         var testDiv  = $('#andself_test'),
60 |             secondEl = $('.two', testDiv),
61 |             thirdEl  = $('.three', testDiv),
62 |             nextAndSelf = secondEl.next().andSelf()
63 | 
64 |         t.assert(secondEl.get(0), nextAndSelf.get(0))
65 |         t.assert(thirdEl.get(0),  nextAndSelf.get(1))
66 |       }
67 | 
68 |     })
69 | 
70 |   })()
71 |   </script>
72 | </body>
73 | </html>
74 | 


--------------------------------------------------------------------------------
/test/test.css:
--------------------------------------------------------------------------------
 1 | * {
 2 |   font-family: -apple-system-font, Helvetica, sans-serif;
 3 | }
 4 | body {
 5 |   padding: 1em;
 6 | }
 7 | a:link, a:visited { color: darkblue; }
 8 | #results.failed em { font-style: normal; color: crimson; }
 9 | #results.passed em { font-style: normal; color: darkgreen; }
10 | #fixtures {
11 |   position: absolute;
12 |   top: -10000px;
13 |   left: -10000px;
14 | }
15 | #nav {
16 |   list-style: none;
17 |   padding: 0;
18 |   margin: 2em 0 0 0;
19 |   font-size: 12px;
20 |   max-width: 30em;
21 | }
22 | #nav a {
23 |   padding: .8em 1.5em;
24 |   background: #eee;
25 |   border-top: 2px solid white;
26 |   text-decoration: none;
27 |   text-transform: uppercase;
28 |   letter-spacing: .1em;
29 |   display: block;
30 |   color: #555;
31 | }
32 | #nav .current a { background: #ccc; color: black; }
33 | #nav a:active { background: #555; color: white; }
34 | 
35 | ul {
36 |   padding: 0;
37 | }
38 | 
39 | li {
40 |   list-style-type: none;
41 |   padding: 0 0 15px;
42 | }
43 | 
44 | li a {
45 |   font-size: 16px;
46 |   border: 1px solid darkblue;
47 |   padding: 3px 10px;
48 |   text-decoration: none;
49 | }
50 | li a:visited {
51 |   border-color: #888;
52 |   color: #aaa;
53 | }
54 | 
55 | @media only screen and (max-device-width:480px) {
56 |   body { margin: 7px; font-size: small; }
57 |   h1 { margin: 0; }
58 |   h1, #results { text-align: center; }
59 |   #results { min-height: 3em; }
60 |   #nav { font-size: 14px; max-width: auto; }
61 | }
62 | 


--------------------------------------------------------------------------------
/test/touch.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | <head>
  4 |   <meta charset="utf-8">
  5 |   <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=0">
  6 |   <link rel="stylesheet" href="test.css">
  7 |   <title>Zepto Touch unit tests</title>
  8 |   <script src="../vendor/evidence.js"></script>
  9 |   <script src="evidence_runner.js"></script>
 10 |   <script>
 11 |     // avoid caching
 12 |     (function(){
 13 |       function load(scripts){
 14 |         scripts.split(' ').forEach(function(script){
 15 |           document.write('<script src="../src/'+script+'.js?'+(+new Date)+'"></scr'+'ipt>')
 16 |         })
 17 |       }
 18 | 
 19 |       load('zepto event ie touch')
 20 |     })()
 21 |   </script>
 22 | </head>
 23 | <body>
 24 |   <h1>Zepto Touch unit tests</h1>
 25 |   <p id="results">
 26 |     Running… see browser console for results
 27 |   </p>
 28 | 
 29 |   <style>
 30 |     #test {
 31 |       position: absolute;
 32 |       left: 0;
 33 |       top: 0;
 34 |       width: 100px;
 35 |       height: 50px;
 36 |     }
 37 |   </style>
 38 | 
 39 |   <script>
 40 |   (function(){
 41 |     var emitEvent, tests, lastLoaded
 42 | 
 43 |     // Fire a simulated touch event.
 44 |     // While it is possible to fire real touch events,
 45 |     // there are cross-browser issues, and this way we
 46 |     // can test touch events in browsers that don't
 47 |     // actually support touch input (like desktop Safari).
 48 |     //
 49 |     // Zepto's touch module only uses the `pageX/Y` and `target`
 50 |     // properties of the first touch in the `touches` TouchList
 51 |     function emitTouchEvent(type, element, x, y) {
 52 |       var event = document.createEvent('Event'),
 53 |         touch = { pageX: x, pageY: y, target: element }
 54 | 
 55 |       event.initEvent('touch'+type, true, true)
 56 |       event.touches = [touch]
 57 | 
 58 |       element.dispatchEvent(event)
 59 |     }
 60 | 
 61 |     // IE 10, Windows Phone 8
 62 |     // MSPointer events, same idea, different implementation.
 63 |     // For compatibility accepts the same arguments as `touchEvent`
 64 |     // (touch event names will be mapped to MSPointer event names)
 65 |     function emitMSPointerEvent(type, element, x, y) {
 66 |       var event = document.createEvent('Event'),
 67 |         eventMap = { start: 'Down', move: 'Move', end: 'Up'}
 68 | 
 69 |       event.initEvent('MSPointer'+eventMap[type], true, true)
 70 |       event.pageX = x
 71 |       event.pageY = y
 72 |       event.pointerType = 666
 73 |       event.MSPOINTER_TYPE_TOUCH = 666
 74 |       event.isPrimary = true
 75 | 
 76 |       element.dispatchEvent(event)
 77 |     }
 78 | 
 79 |     // IE 11
 80 |     // Pointer events, same idea again, yet different implementation.
 81 |     // For compatibility accepts the same arguments as `touchEvent`
 82 |     // (touch event names will be mapped to pointer event names)
 83 |     function emitPointerEvent(type, element, x, y) {
 84 |       var event = document.createEvent('Event'),
 85 |         eventMap = { start: 'down', move: 'move', end: 'up'}
 86 | 
 87 |       event.initEvent('pointer'+eventMap[type], true, true)
 88 |       event.pageX = x
 89 |       event.pageY = y
 90 |       event.pointerType = 'touch'
 91 |       event.isPrimary = true
 92 | 
 93 |       element.dispatchEvent(event)
 94 |     }
 95 | 
 96 |     function down(element, x, y) {
 97 |       emitEvent('start', element, x, y)
 98 |     }
 99 |     function move(element, x,y) {
100 |       emitEvent('move', element, x, y)
101 |     }
102 |     function up(element) {
103 |       emitEvent('end', element)
104 |     }
105 | 
106 |     tests = {
107 |       setUp: function(){
108 |         emitEvent = this.emitEvent
109 |         this.setupTouchLibrary()
110 |         $('<div id=test>').appendTo('body')
111 |       },
112 | 
113 |       tearDown: function(){
114 |         $('#test').off()
115 |         $('#test').remove()
116 |       },
117 | 
118 |       testTap: function(t){
119 |         var count = 0, element = $('#test').get(0)
120 | 
121 |         $('#test').on('tap', function(){
122 |           count++
123 |         })
124 | 
125 |         down(element, 10, 10)
126 |         up(element)
127 | 
128 |         t.pause()
129 |         setTimeout(function(){
130 |           t.resume(function(){
131 |             t.assertEqual(1, count)
132 |           })
133 |         }, 50)
134 |       },
135 | 
136 |       testOnlyOneTouchAPIIsActive: function(t){
137 |         var count = 0, element = $('#test').get(0)
138 | 
139 |         $('#test').on('tap', function(){
140 |           count++
141 |         })
142 | 
143 |         emitTouchEvent('start', element, 10, 10)
144 |         emitPointerEvent('start', element, 10, 10)
145 |         emitMSPointerEvent('start', element, 10, 10)
146 |         emitTouchEvent('end', element)
147 |         emitPointerEvent('end', element)
148 |         emitMSPointerEvent('end', element)
149 | 
150 |         t.pause()
151 |         setTimeout(function(){
152 |           t.resume(function(){
153 |             t.assertEqual(1, count)
154 |           })
155 |         }, 50)
156 |       },
157 | 
158 |       testScrollDoesNotFireTap: function(t){
159 |         var element = $('#test').get(0), count = 0
160 | 
161 |         $('#test').on('tap', function () {
162 |           count++
163 |         })
164 | 
165 |         down(element, 0, 0)
166 |         move(element, 0, 20)
167 |         move(element, 0, 20)
168 |         up(element)
169 | 
170 |         t.pause()
171 |         setTimeout(function(){
172 |           t.resume(function(){
173 |             t.assertEqual(0, count)
174 |           })
175 |         }, 50)
176 |       },
177 | 
178 |       testSingleTapDoesNotInterfereWithTappingTwice: function(t){
179 |         var count = 0, element = $('#test').get(0)
180 | 
181 |         $('#test').on('tap', function(){
182 |           count++
183 |         })
184 | 
185 |         down(element, 10, 10)
186 |         up(element)
187 | 
188 |         t.pause()
189 |         setTimeout(function(){
190 |           down(element, 10, 10)
191 |           up(element)
192 | 
193 |           t.resume(function(){
194 |             t.pause()
195 | 
196 |             setTimeout(function(){
197 |               t.resume(function(){
198 |                 t.assertEqual(2, count)
199 |               })
200 |             }, 200)
201 |           })
202 |         }, 200)
203 |       },
204 | 
205 |       // should be fired if there is one tap within 250ms
206 |       testSingleTap: function(t){
207 |         var singleCount = 0, doubleCount = 0, element = $('#test').get(0)
208 | 
209 |         $('#test').on('singleTap', function(){
210 |           singleCount++
211 |         }).on('doubleTap', function(){
212 |           doubleCount++
213 |         })
214 | 
215 |         down(element, 10, 10)
216 |         up(element)
217 | 
218 |         t.pause()
219 |         setTimeout(function(){
220 |           t.resume(function(){
221 |             t.assertEqual(1, singleCount)
222 |             t.assertEqual(0, doubleCount)
223 |           })
224 |         }, 300)
225 |       },
226 | 
227 |       // should be fired if there are two taps within 250ms
228 |       testDoubleTap: function(t){
229 |         var singleCount = 0, doubleCount = 0, element = $('#test').get(0)
230 | 
231 |         $('#test').on('singleTap', function(){
232 |           singleCount++
233 |         }).on('doubleTap', function(){
234 |           doubleCount++
235 |         })
236 | 
237 |         down(element, 10, 10)
238 |         up(element)
239 | 
240 |         t.pause()
241 |         setTimeout(function(){
242 |           down(element, 12, 12)
243 |           up(element)
244 | 
245 |           t.resume(function(){
246 |             t.pause()
247 | 
248 |             setTimeout(function(){
249 |               t.resume(function(){
250 |                 t.assertEqual(0, singleCount)
251 |                 t.assertEqual(1, doubleCount)
252 |               })
253 |             }, 100)
254 |           })
255 |         }, 100)
256 |       },
257 | 
258 |       // should be fired if the finger is down in the same location for >750ms
259 |       testLongTap: function(t){
260 |         var count = 0, element = $('#test').get(0)
261 | 
262 |         $('#test').on('longTap', function(){
263 |           count++
264 |         })
265 | 
266 |         down(element, 10, 10)
267 | 
268 |         t.pause()
269 |         setTimeout(function(){
270 |           up(element)
271 | 
272 |           t.resume(function(){
273 |             t.assertEqual(1, count)
274 |           })
275 |         }, 900)
276 |       },
277 | 
278 |       testLongTapDoesNotFireIfFingerIsMoved: function(t){
279 |         var count = 0, element = $('#test').get(0)
280 | 
281 |         $('#test').on('longTap', function(){
282 |           count++
283 |         })
284 | 
285 |         down(element, 10, 10)
286 | 
287 |         t.pause()
288 |         setTimeout(function(){
289 |           move(element, 50, 10)
290 |           t.resume(function(){
291 |             t.pause()
292 |             setTimeout(function(){
293 |               up(element)
294 |               t.resume(function(){
295 |                 t.assertEqual(0, count)
296 |               })
297 |             }, 450)
298 |           })
299 |         }, 450)
300 |       },
301 | 
302 |       testSwipe: function(t){
303 |         var swipeCount = 0, element = $('#test').get(0)
304 | 
305 |         $('#test').on('swipe', function(){
306 |           swipeCount++
307 |         })
308 | 
309 |         down(element, 10, 10)
310 | 
311 |         t.pause()
312 |         setTimeout(function(){
313 |           move(element, 70, 10)
314 |           up(element)
315 | 
316 |           t.resume(function(){
317 |             t.pause()
318 | 
319 |             setTimeout(function(){
320 |               t.resume(function(){
321 |                 t.assertEqual(1, swipeCount)
322 |               })
323 |             }, 50)
324 |           })
325 |         }, 50)
326 |       },
327 | 
328 |       testTapDoNotFireWhenMoveToPointAndBack: function (t) {
329 |         var tapCount = 0, element = $('#test').get(0)
330 | 
331 |         $('#test').on('tap', function(){
332 |           tapCount++
333 |         })
334 |         down(element, 10, 10)
335 |         move(element, 60, 10)
336 | 
337 |         t.pause()
338 |         setTimeout(function(){
339 |           t.resume(function(){
340 |             move(element, 10, 10)
341 |             up(element)
342 |             t.pause()
343 |             setTimeout(function(){
344 |               t.resume( function () {
345 |                 t.assertEqual(0, tapCount)
346 |               })
347 |             }, 100)
348 |           })
349 |         }, 100)
350 |       }
351 | 
352 |       // TODO: test swipes in specific directions
353 |     }
354 | 
355 |     Evidence('TouchTest', $.extend({
356 |       setupTouchLibrary: function(){
357 |         console.info('Setting up touch library for TouchEvent test')
358 |         $.touch.setup({
359 |           'down': 'touchstart', 'up': 'touchend',
360 |           'move': 'touchmove', 'cancel': 'touchcancel'
361 |         })
362 |       },
363 |       emitEvent: emitTouchEvent
364 |     }, tests))
365 | 
366 |     Evidence('PointerTest', $.extend({
367 |       setupTouchLibrary: function(){
368 |         console.info('Setting up touch library for PointerEvent test')
369 |         $.touch.setup({
370 |           'down': 'pointerdown', 'up': 'pointerup',
371 |           'move': 'pointermove', 'cancel': 'pointercancel'
372 |         })
373 |       },
374 |       emitEvent: emitPointerEvent
375 |     }, tests))
376 | 
377 |     Evidence('MSPointerTest', $.extend({
378 |       setupTouchLibrary: function(){
379 |         console.info('Setting up touch library for MSPointerEvent test')
380 |         $.touch.setup({
381 |           'down': 'MSPointerDown', 'up': 'MSPointerUp',
382 |           'move': 'MSPointerMove', 'cancel': 'MSPointerCancel'
383 |         })
384 |       },
385 |       emitEvent: emitMSPointerEvent
386 |     }, tests))
387 | 
388 |   })()
389 |   </script>
390 | </body>
391 | </html>
392 | 


--------------------------------------------------------------------------------