├── min
    └── .gitkeep
├── .gitignore
├── src
    ├── komito
    │   ├── trackers
    │   │   ├── __ns__.js
    │   │   ├── social
    │   │   │   ├── __ns__.js
    │   │   │   ├── twitter.js
    │   │   │   ├── linkedin.js
    │   │   │   ├── users.js
    │   │   │   └── facebook.js
    │   │   ├── dom
    │   │   │   ├── adblock.js
    │   │   │   ├── print.js
    │   │   │   ├── scroll.js
    │   │   │   ├── forms.js
    │   │   │   ├── orientation.js
    │   │   │   ├── __ns__.js
    │   │   │   └── links.js
    │   │   └── media
    │   │   │   ├── __ns__.js
    │   │   │   ├── html5.js
    │   │   │   ├── vimeo.js
    │   │   │   └── youtube.js
    │   └── __ns__.js
    └── glize
    │   ├── net
    │       ├── __ns__.js
    │       └── HttpRequest.js
    │   ├── util
    │       ├── __ns__.js
    │       ├── Base64.js
    │       ├── String.js
    │       ├── Object.js
    │       ├── Date.js
    │       ├── StringUtils.js
    │       └── Array.js
    │   ├── compressors
    │       └── __ns__.js
    │   └── dom
    │       └── __ns__.js
├── .travis.yml
├── CONTRIBUTING.md
├── .github
    ├── FUNDING.yml
    └── workflows
    │   ├── npm-publish.yml
    │   └── codeql-analysis.yml
├── npm
    ├── package.json
    ├── index.js
    └── README.md
├── package.json
├── README.md
├── SECURITY.md
├── CODE_OF_CONDUCT.md
└── LICENSE


/min/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | *.svn
3 | *.svn-base
4 | *.so
5 | .DS_Store
6 | build/lib
7 | min/komito.js
8 | 


--------------------------------------------------------------------------------
/src/komito/trackers/__ns__.js:
--------------------------------------------------------------------------------
1 | /**
2 |  * Defines <code>komito.trackers</code> namespace.
3 |  * @namespace
4 |  */
5 | komito.trackers = {};
6 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | # python and sudo are required for closure linter:
2 | # `sudo python setup.py install`
3 | language: python
4 | python: 2.7
5 | sudo: required
6 | script:
7 |   - ./build/build.sh
8 |   - ./build/npmjs.sh
9 | 


--------------------------------------------------------------------------------
/src/glize/net/__ns__.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @fileoverview Defines <code>net</code> namespace.
 3 |  *
 4 |  * @see http://google.github.io/styleguide/javascriptguide.xml
 5 |  * @see http://developers.google.com/closure/compiler/docs/js-for-compiler
 6 |  */
 7 | 
 8 | 
 9 | /**
10 |  * Defines <code>net</code> namespace.
11 |  * @namespace
12 |  */
13 | var net = {};
14 | 


--------------------------------------------------------------------------------
/src/glize/util/__ns__.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @fileoverview Defines namespace for <code>util</code> package.
 3 |  *
 4 |  * @see http://google.github.io/styleguide/javascriptguide.xml
 5 |  * @see http://developers.google.com/closure/compiler/docs/js-for-compiler
 6 |  */
 7 | 
 8 | 
 9 | /**
10 |  * Defines namespace for <code>util</code> package.
11 |  * @namespace
12 |  */
13 | var util = {};
14 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | ## Contributing
 2 | 
 3 | We use the pull-request model, see [GitHub's help on pull-request](https://help.github.com/articles/using-pull-requests).
 4 | 
 5 | In brief, you will:
 6 | 
 7 | - add an issue about what you plan to change;
 8 | - on GitHub, find and fork the source repository;
 9 | - on your computer, clone your fork repository,
10 | - commit your changes in a new branch;
11 | - push your branch and submit a pull-request for it;
12 | - go through the review process until your pull-request is merged; and
13 | - close your issue.
14 | 


--------------------------------------------------------------------------------
/src/komito/trackers/social/__ns__.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Defines <code>komito.trackers.social</code> namespace.
 3 |  * @namespace
 4 |  */
 5 | komito.trackers.social = {
 6 | 
 7 |   /**
 8 |    * Initializes social events tracking.
 9 |    */
10 |   init: function() {
11 |     /** @type {!Object.<string, !Function>} */ var map = {
12 |       'trackFacebook': komito.trackers.social.Facebook,
13 |       'trackLinkedIn': komito.trackers.social.LinkedIn,
14 |       'trackTwitter': komito.trackers.social.Twitter,
15 |       'trackUsers': komito.trackers.social.Users
16 |     };
17 |     /** @type {string} */ var key;
18 | 
19 |     for (key in map) {
20 |       komito.config[key] && new map[key];
21 |     }
22 |   }
23 | };
24 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
 1 | # These are supported funding model platforms
 2 | 
 3 | github: Datamart # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 4 | #patreon: # Replace with a single Patreon username
 5 | #open_collective: # Replace with a single Open Collective username
 6 | #ko_fi: # Replace with a single Ko-fi username
 7 | #tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 8 | #community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 9 | #liberapay: # Replace with a single Liberapay username
10 | #issuehunt: # Replace with a single IssueHunt username
11 | #otechie: # Replace with a single Otechie username
12 | # custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
13 | custom: ['https://www.paypal.me/vpodk', 'https://amzn.to/3mpgAJh']
14 | 


--------------------------------------------------------------------------------
/npm/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "komito-analytics",
 3 |   "version": "1.0.6",
 4 |   "description": "Komito Analytics is an enhancement for the most popular analytics software.",
 5 |   "homepage": "https://komito.net/",
 6 |   "repository": "github:Datamart/Komito",
 7 |   "license": "Apache-2.0",
 8 |   "bugs": {
 9 |     "url": "https://github.com/Datamart/Komito/issues",
10 |     "email": "support@komito.net"
11 |   },
12 |   "author": {
13 |     "name": "Valentin Podkamennyi",
14 |     "email": "valentin@dtm.io",
15 |     "url": "https://vpodk.com/"
16 |   },
17 |   "keywords": [
18 |     "adobe-analytics",
19 |     "analytics",
20 |     "baidu-analytics",
21 |     "event-tracking",
22 |     "google-analytics",
23 |     "komito",
24 |     "komito-analytics",
25 |     "media-tracking",
26 |     "particles-analytics"
27 |   ],
28 |   "main": "index.js"
29 | }
30 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "komito-analytics",
 3 |   "version": "5.0.0",
 4 |   "description": "Komito Analytics is a free, open-source enhancement for the most popular web analytics software.",
 5 |   "homepage": "https://komito.net",
 6 |   "repository": "github:Datamart/Komito",
 7 |   "license": "Apache-2.0",
 8 |   "bugs": {
 9 |     "url": "https://github.com/Datamart/Komito/issues",
10 |     "email": "support@komito.net"
11 |   },
12 |   "scripts": {
13 |     "build": "./build/build.sh"
14 |   },
15 |   "author": {
16 |     "name": "Valentin Podkamennyi",
17 |     "email": "valentin@dtm.io",
18 |     "url": "https://vpodk.com/"
19 |   },
20 |   "dependencies": {
21 |     "glize": "^21.2.2"
22 |   },
23 |   "keywords": [
24 |     "analytics",
25 |     "google-analytics",
26 |     "event-tracking",
27 |     "adobe-analytics",
28 |     "clicktale",
29 |     "baidu-analytics",
30 |     "media-tracking",
31 |     "komito-analytics",
32 |     "particles-analytics"
33 |   ]
34 | }
35 | 


--------------------------------------------------------------------------------
/src/komito/trackers/dom/adblock.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @fileoverview Tracks pageviews with blocked ads.
 3 |  */
 4 | 
 5 | 
 6 | 
 7 | /**
 8 |  * Defines <code>komito.trackers.dom.AdBlock</code> constructor.
 9 |  * @constructor
10 |  */
11 | komito.trackers.dom.AdBlock = function() {
12 | 
13 |   /**
14 |    * Initializes orientation tracking.
15 |    * @private
16 |    */
17 |   function init_() {
18 |     if (komito.config['trackAdblock']) {
19 |       var node = dom.appendChild(dom.document.body, dom.createElement('DIV'));
20 |       node.id = 'ad-container';
21 |       node.style.position = 'absolute';
22 |       node.innerHTML = '<img src="data:image/svg+xml,%3Csvg/%3E" id="ad" ' +
23 |                        'class="banner" height="5" width="5">';
24 | 
25 |       setTimeout(function() {
26 |         node.offsetHeight < 5 && komito.track(
27 |             komito.EVENT_ACTION_TYPE, 'adblock', 'pageview', location.href);
28 |         dom.removeNode(node);
29 |       }, 1E3);
30 |     }
31 |   }
32 | 
33 |   // Initializing adblock tracking.
34 |   init_();
35 | };
36 | 


--------------------------------------------------------------------------------
/src/komito/trackers/dom/print.js:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 | /**
 5 |  * Defines <code>komito.trackers.dom.print</code> constructor.
 6 |  * @constructor
 7 |  */
 8 | komito.trackers.dom.Print = function() {
 9 | 
10 |   /**
11 |    * Initializes print tracking.
12 |    * @private
13 |    */
14 |   function init_() {
15 |     if (komito.config['trackPrint']) {
16 |       /** @type {function(string): ?MediaQueryList} */
17 |       var matchMedia = dom.context['matchMedia'];
18 |       mql_ = matchMedia && matchMedia('print');
19 | 
20 |       mql_ ?
21 |           mql_['addListener'](listener_) :
22 |           dom.events.addEventListener(dom.context, 'afterprint', listener_);
23 |     }
24 |   }
25 | 
26 |   /**
27 |    * @param {?Event} e The print event.
28 |    * @private
29 |    */
30 |   function listener_(e) {
31 |     komito.track(
32 |         komito.EVENT_ACTION_TYPE, 'print',
33 |         dom.document.title, location.href);
34 |     mql_ ?
35 |         mql_['removeListener'](listener_) :
36 |         dom.events.removeEventListener(dom.context, 'afterprint', listener_);
37 |     mql_ = listener_ = dom.NULL;
38 |   }
39 | 
40 |   /**
41 |    * @type {?MediaQueryList}
42 |    * @private
43 |    */
44 |   var mql_;
45 | 
46 |   // Initializing print events tracking.
47 |   init_();
48 | };
49 | 


--------------------------------------------------------------------------------
/npm/index.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @fileoverview Komito Analytics is an enhancement for the most popular
 3 |  * analytics software. It unlocks power of digital analytics with additional
 4 |  * insights about visitor's behavior.
 5 |  *
 6 |  * @see http://google.github.io/styleguide/javascriptguide.xml
 7 |  * @see http://developers.google.com/closure/compiler/docs/js-for-compiler
 8 |  * @see https://github.com/Datamart/Komito/
 9 |  */
10 | 
11 | 
12 | 
13 | module.exports = {
14 |   /**
15 |    * Initializes Komito Analytics extension.
16 |    * @param {!Object=} opt_options Optional tracking options.
17 |    */
18 |   init: (opt_options) => {
19 |     const root = ('object' === typeof self && self.self === self && self) ||
20 |                  ('object' === typeof global && global.global === global && global);
21 |     const doc = root.document;
22 | 
23 |     if (doc) {
24 |       root['_komito'] = root['_komito'] || {};
25 | 
26 |       if (opt_options) {
27 |         for (let key in opt_options) {
28 |           if (opt_options.hasOwnProperty(key)) {
29 |             root['_komito'][key] = opt_options[key];
30 |           }
31 |         }
32 |       }
33 | 
34 |       const script = doc.createElement('SCRIPT');
35 |       const scripts = doc.getElementsByTagName('SCRIPT');
36 |       const parent = scripts[scripts.length - 1].parentNode;
37 | 
38 |       script.async = true;
39 |       script.src = 'https://komito.net/komito.js';
40 |       (parent || doc.body).appendChild(script);
41 |     }
42 |   }
43 | };
44 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Komito Analytics [![Tweet](https://img.shields.io/twitter/url/http/shields.io.svg?style=social)](https://twitter.com/intent/tweet?text=Komito%20Analytics%20-%20Unlock%20the%20power%20of%20digital%20analytics%20with%20additional%20insights%20about%20visitor%27s%20behavior.&url=https://komito.net/&via=GitHub&hashtags=KomitoAnalytics,GoogleAnalytics,AdobeAnalytics,EventTracking,MediaTracking)
2 | [![License](http://img.shields.io/:license-apache-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0.html) [![Website](https://img.shields.io/website-up-down-green-red/https/komito.net.svg?style=flat)](https://komito.net) [![NPM version](https://img.shields.io/npm/v/komito-analytics.svg?style=flat)](https://npmjs.org/package/komito-analytics) [![NPM downloads](https://img.shields.io/npm/dm/komito-analytics.svg?style=flat)](https://npmjs.org/package/komito-analytics) [![Featured on Openbase](https://badges.openbase.com/js/featured/komito-analytics.svg?token=M+/9hZajk/0wvVbSAegFdsqngROcpFxgW93PereSBU0=)](https://openbase.com/js/komito-analytics?utm_source=embedded&amp;utm_medium=badge&amp;utm_campaign=rate-badge)
3 | 
4 | Komito Analytics is a free, open-source enhancement for the most popular web analytics software.<br>
5 | It unlocks power of digital analytics with additional insights about visitor's behavior.<br>
6 | For more information please visit [Komito Analytics project page](https://komito.net).
7 | 
8 | ![Analytics](https://www.google-analytics.com/collect?v=1&tid=UA-5065160-14&t=pageview&dh=github.com&dp=/Datamart/Komito&dt=GitHub%20README)
9 | 


--------------------------------------------------------------------------------
/SECURITY.md:
--------------------------------------------------------------------------------
 1 | # Security Policies and Procedures
 2 | 
 3 | This document outlines security procedures and general policies for the
 4 | `Komito Analytics` project.
 5 | 
 6 |   * [Reporting a Bug](#reporting-a-bug)
 7 |   * [Disclosure Policy](#disclosure-policy)
 8 |   * [Comments on this Policy](#comments-on-this-policy)
 9 | 
10 | ## Reporting a Bug
11 | 
12 | Thank you for improving the security of `Komito Analytics`. We appreciate your
13 | efforts and responsible disclosure and will make every effort to acknowledge
14 | your contributions.
15 | 
16 | Report security bugs by emailing the lead maintainer at support@komito.net.
17 | 
18 | The lead maintainer will acknowledge your email within 48 hours, and will send a
19 | more detailed response within 48 hours indicating the next steps in handling
20 | your report. After the initial reply to your report, our team will
21 | endeavor to keep you informed of the progress towards a fix and full
22 | announcement, and may ask for additional information or guidance.
23 | 
24 | ## Disclosure Policy
25 | 
26 | When our team receives a security bug report, they will assign it to a
27 | primary handler. This person will coordinate the fix and release process,
28 | involving the following steps:
29 | 
30 |   * Confirm the problem and determine the affected versions.
31 |   * Audit code to find any potential similar problems.
32 |   * Prepare fixes for all releases still under maintenance.
33 | 
34 | ## Comments on this Policy
35 | 
36 | If you have suggestions on how this process could be improved please submit a
37 | pull request.
38 | 


--------------------------------------------------------------------------------
/.github/workflows/npm-publish.yml:
--------------------------------------------------------------------------------
 1 | # This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
 2 | # For more information see: https://help.github.com/actions/language-and-framework-guides/publishing-nodejs-packages
 3 | 
 4 | name: Publish NPM Package
 5 | 
 6 | on:
 7 |   release:
 8 |     types: [created]
 9 | 
10 | defaults:
11 |   run:
12 |     working-directory: ./npm
13 |     
14 | jobs:
15 |   build:
16 |     runs-on: ubuntu-latest
17 |     steps:
18 |       - uses: actions/checkout@v2
19 |       - uses: actions/setup-node@v1
20 |         with:
21 |           node-version: 12
22 |       - run: npm i
23 |       - run: npm ci
24 |       - run: npm test
25 | 
26 |   publish-npm:
27 |     needs: build
28 |     runs-on: ubuntu-latest
29 |     steps:
30 |       - uses: actions/checkout@v2
31 |       - uses: actions/setup-node@v1
32 |         with:
33 |           node-version: 12
34 |           registry-url: https://registry.npmjs.org/
35 |       - run: npm i
36 |       - run: npm ci
37 |       - run: npm publish
38 |         env:
39 |           NODE_AUTH_TOKEN: ${{secrets.npm_token}}
40 | 
41 | #   publish-gpr:
42 | #     needs: build
43 | #     runs-on: ubuntu-latest
44 | #     steps:
45 | #       - uses: actions/checkout@v2
46 | #       - uses: actions/setup-node@v1
47 | #         with:
48 | #           node-version: 12
49 | #           registry-url: https://npm.pkg.github.com/
50 | #       - run: npm i
51 | #       - run: npm ci
52 | #       - run: npm publish
53 | #         env:
54 | #           NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
55 | 


--------------------------------------------------------------------------------
/src/komito/trackers/media/__ns__.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @fileoverview Komito Analytics namespace for Media trackers.
 3 |  *
 4 |  * @link http://google.github.io/styleguide/javascriptguide.xml
 5 |  * @link http://developers.google.com/closure/compiler/docs/js-for-compiler
 6 |  */
 7 | 
 8 | 
 9 | /**
10 |  * Defines <code>komito.trackers.media</code> namespace.
11 |  * @namespace
12 |  */
13 | komito.trackers.media = {
14 | 
15 |   /**
16 |    * Initializes media tracking enabled by <code>trackMedia</code> parameter.
17 |    *
18 |    * @see komito.config
19 |    * @see komito.trackers.media.HTML5
20 |    * @see komito.trackers.media.Vimeo
21 |    * @see komito.trackers.media.YouTube
22 |    */
23 |   init: function() {
24 |     /** @type {!Array|!Function|number|string} */
25 |     var trackMedia = komito.config['trackMedia'];
26 |     /** @type {!Array.<string>} */ var types = ['html5', 'vimeo', 'youtube'];
27 |     /** @type {string} */ var type;
28 |     /** @type {number} */ var length;
29 | 
30 |     if (trackMedia) {
31 |       if (util.Array.isArray(trackMedia)) {
32 |         types = /** @type {!Array.<string>} */ (trackMedia);
33 |       }
34 | 
35 |       length = types.length;
36 |       for (; length--;) {
37 |         type = types[length].toLowerCase();
38 |         if ('html5' == type)
39 |           komito.trackers.media.HTML5 && new komito.trackers.media.HTML5;
40 |         else if ('vimeo' == type)
41 |           komito.trackers.media.Vimeo && new komito.trackers.media.Vimeo;
42 |         else if ('youtube' == type)
43 |           komito.trackers.media.YouTube && new komito.trackers.media.YouTube;
44 |       }
45 |     }
46 |   }
47 | };
48 | 


--------------------------------------------------------------------------------
/src/komito/trackers/dom/scroll.js:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 | /**
 5 |  * Defines <code>komito.trackers.dom.scroll</code> constructor.
 6 |  * @constructor
 7 |  */
 8 | komito.trackers.dom.Scroll = function() {
 9 | 
10 |   /**
11 |    * Initializes scroll tracking.
12 |    * @private
13 |    */
14 |   function init_() {
15 |     /** @type {!Array|!Function|number|string} */
16 |     var trackScroll = komito.config['trackScroll'];
17 |     if (trackScroll) {
18 |       /** @type {!Array.<number>} */ var percentages = [25, 50, 75, 100];
19 |       if (util.Array.isArray(trackScroll)) {
20 |         percentages = /** @type {!Array.<number>} */ (trackScroll);
21 |       }
22 | 
23 |       /** @type {?Element} */ var root = dom.document.documentElement;
24 |       /** @type {?Element} */ var body = dom.document.body;
25 |       /** @type {!Object} */ var map = {};
26 |       /** @type {number} */ var depth = percentages.length;
27 |       for (; depth--;) { map[percentages[depth]] = 0; }
28 | 
29 |       dom.events.addEventListener(
30 |           dom.context, dom.events.TYPE.SCROLL, function() {
31 |             var screenHeight = root.clientHeight || dom.context.innerHeight;
32 |             var scrollHeight = root.scrollHeight || body.offsetHeight;
33 |             var scrollTop = root.scrollTop || body.scrollTop;
34 |             var percent = scrollTop / (scrollHeight - screenHeight) * 100;
35 |             depth = ~~(percent / 25) * 25;
36 |             if (depth && depth in map && !map[depth]) {
37 |               map[depth] = 1;
38 |               komito.track(
39 |                   komito.EVENT_ACTION_TYPE, 'scroll', 'depth', depth + '%');
40 |             }
41 |           });
42 |     }
43 |   }
44 | 
45 |   // Initializing print events tracking.
46 |   init_();
47 | };
48 | 


--------------------------------------------------------------------------------
/src/komito/trackers/social/twitter.js:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 | /**
 5 |  * Defines <code>komito.trackers.social.Twitter</code> constructor.
 6 |  * @constructor
 7 |  */
 8 | komito.trackers.social.Twitter = function() {
 9 |   /**
10 |    * List of Twitter events to track.
11 |    * @const {!Array.<string>}
12 |    * @see https://dev.twitter.com/web/javascript/events
13 |    */
14 |   var EVENTS = ['tweet', 'retweet', 'like', 'follow'];
15 | 
16 |   /**
17 |    * Mapping of event's data keys.
18 |    * @const {!Object.<string, string>}
19 |    */
20 |   var DATA_KEYS = {
21 |     'follow': 'screen_name',
22 |     'retweet': 'source_tweet_id',
23 |     'like': 'tweet_id',
24 |     'tweet': 'url'
25 |   };
26 | 
27 |   /**
28 |    * Tries to attach listener to Twitter widget object if it presents on page.
29 |    * @see https://dev.twitter.com/web/javascript/events
30 |    * @private
31 |    */
32 |   function init_() {
33 |     if (9 > counter_++) {
34 |       if (dom.context['twttr'] && dom.context['twttr']['ready']) {
35 |         dom.context['twttr']['ready'](function(twttr) {
36 |           var config = komito.config['trackTwitter'];
37 |           var type;
38 |           var data;
39 |           var key;
40 | 
41 |           var events = /** @type {!Array.<string>} */ (
42 |               util.Array.isArray(config) ? config : EVENTS);
43 | 
44 |           util.Array.forEach(events, function(event) {
45 |             twttr['events']['bind'](event, function(e) {
46 |               type = e['type'];
47 |               if (!fired_[type]) {
48 |                 fired_[type] = 1;
49 |                 key = DATA_KEYS[type];
50 |                 data = (key && e['data'] && e['data'][key]) || location.href;
51 |                 komito.track(komito.SOCIAL_ACTION_TYPE, 'Twitter', type, data);
52 |               }
53 |             });
54 |           });
55 |         });
56 |       } else setTimeout(init_, 5e3);
57 |     }
58 |   }
59 | 
60 | 
61 |   /**
62 |    * @type {number}
63 |    * @private
64 |    */
65 |   var counter_ = 0;
66 | 
67 |   /**
68 |    * @type {!Object.<string, number>}
69 |    * @private
70 |    */
71 |   var fired_ = {};
72 | 
73 |   // Initializing Twitter events tracking.
74 |   init_();
75 | };
76 | 


--------------------------------------------------------------------------------
/src/komito/trackers/dom/forms.js:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 | /**
 5 |  * Defines <code>komito.trackers.dom.forms</code> constructor.
 6 |  * @constructor
 7 |  */
 8 | komito.trackers.dom.Forms = function() {
 9 | 
10 |   /**
11 |    * Initializes forms tracking.
12 |    * @private
13 |    */
14 |   function init_() {
15 |     if (komito.config['trackForms']) {
16 |       /** @type {?HTMLCollection} */ var forms = dom.document.forms;
17 |       /** @type {number} */ var length = forms.length;
18 |       /** @type {!Element} */ var element;
19 | 
20 |       for (; length;) {
21 |         element = forms[--length];
22 |         if (!komito.DynamicContentTracker.isRegistered(element)) {
23 |           komito.DynamicContentTracker.register(element);
24 | 
25 |           dom.events.addEventListener(
26 |               element, dom.events.TYPE.SUBMIT, listener_);
27 |         }
28 |       }
29 |     }
30 | 
31 |     komito.DynamicContentTracker.track(init_);
32 |   }
33 | 
34 |   /**
35 |    * @param {?Event} e The form submit event.
36 |    * @private
37 |    */
38 |   function listener_(e) {
39 |     /** @type {!HTMLFormElement} */
40 |     var form = /** @type {!HTMLFormElement} */ (dom.events.getEventTarget(e));
41 | 
42 |     /** @type {!HTMLCollection} */ var elements = form.elements;
43 |     /** @type {number} */ var length = elements.length;
44 |     /** @type {number} */ var i = 0;
45 | 
46 |     /** @type {string} */ var action = form.getAttribute('action');
47 |     /** @type {string} */ var identifier = form.getAttribute('name') ||
48 |         form.getAttribute('id') ||
49 |         form.className.replace(/\W+/g, '-') ||
50 |         (action && util.StringUtils.hash(action)) ||
51 |         ('form-' + ++index_);
52 | 
53 |     /** @type {!Element} */ var element;
54 | 
55 |     for (; i < length;) {
56 |       element = elements[i++];
57 |       element.name && komito.track(
58 |           komito.EVENT_ACTION_TYPE, 'form', identifier,
59 |           element.name + ':' + (element.type || element.tagName));
60 |     }
61 | 
62 |     dom.events.removeEventListener(form, dom.events.TYPE.SUBMIT, listener_);
63 |   }
64 | 
65 |   /**
66 |    * The last submitted form index.
67 |    * @type {number}
68 |    * @private
69 |    */
70 |   var index_ = 0;
71 | 
72 |   // Initializing forms events tracking.
73 |   init_();
74 | };
75 | 


--------------------------------------------------------------------------------
/src/glize/util/Base64.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @fileoverview Base64 utility methods.
 3 |  *
 4 |  * @see https://en.wikipedia.org/wiki/Base64
 5 |  * @see http://google.github.io/styleguide/javascriptguide.xml
 6 |  * @see http://developers.google.com/closure/compiler/docs/js-for-compiler
 7 |  */
 8 | 
 9 | 
10 | /**
11 |  * Base64 utility methods.
12 |  * @namespace
13 |  * @see https://en.wikipedia.org/wiki/Base64
14 |  */
15 | util.Base64 = {
16 |   /**
17 |    * @type {string}
18 |    * @const
19 |    */
20 |   BASE64_CHARACTER_TABLE:
21 |       'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
22 | 
23 |   /**
24 |    * Encodes string to base64.
25 |    * @param {string} str String to encode.
26 |    * @return {string} Returns encoded string.
27 |    */
28 |   encode: function(str) {
29 |     /** @type {string} */
30 |     var result = dom.context.btoa ? dom.context.btoa(str) : '';
31 | 
32 |     if (!result) {
33 |       /** @type {!Array.<string>} */
34 |       var table = util.Base64.BASE64_CHARACTER_TABLE.split('');
35 |       /** @type {!Array.<string>} */ var buffer = str.split('');
36 |       /** @type {number} */ var block = 0;
37 |       /** @type {number} */ var index = 0;
38 | 
39 |       for (; buffer[index | 0] || (table = ['='], index % 1);
40 |            result += table[63 & block >> 8 - index % 1 * 8]) {
41 |         block = block << 8 | str.charCodeAt(index -= -3 / 4);
42 |       }
43 |     }
44 | 
45 |     return result;
46 |   },
47 | 
48 |   /**
49 |    * Decodes base64-encoded string.
50 |    * @param {string} str Encoded string.
51 |    * @return {string} Returns decoded string.
52 |    */
53 |   decode: function(str) {
54 |     /** @type {string} */
55 |     var result = dom.context.atob ? dom.context.atob(str) : '';
56 | 
57 |     if (!result) {
58 |       /** @type {!Array.<string>} */ var buffer = str.split('');
59 |       /** @type {number} */ var bit = 0;
60 |       /** @type {number} */ var counter = 0;
61 |       /** @type {number} */ var index = 0;
62 |       /** @type {string} */ var character = '';
63 |       /** @type {number} */ var i = 0;
64 | 
65 |       for (; character = buffer[i++];) {
66 |         index = util.Base64.BASE64_CHARACTER_TABLE.indexOf(character);
67 |         if (~index) {
68 |           bit = counter % 4 ? bit * 64 + index : index;
69 |           if (counter++ % 4) {
70 |             result += String.fromCharCode(255 & bit >> (-2 * counter & 6));
71 |           }
72 |         }
73 |       }
74 |     }
75 | 
76 |     return result;
77 |   }
78 | };
79 | 


--------------------------------------------------------------------------------
/src/komito/trackers/social/linkedin.js:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 | /**
 5 |  * Defines <code>komito.trackers.social.LinkedIn</code> constructor.
 6 |  * @constructor
 7 |  */
 8 | komito.trackers.social.LinkedIn = function() {
 9 |   /**
10 |    * Tries to attach listener to LinkedIn plugin if it presents on page.
11 |    * @see https://developer.linkedin.com/plugins
12 |    * @private
13 |    */
14 |   function init_() {
15 |     /** @type {!Array|?NodeList} */
16 |     var elements = dom.getElementsByTagName(dom.document, 'SCRIPT');
17 |     /** @type {number} */ var length = elements.length;
18 |     /** @type {number} */ var i = 0;
19 |     /** @type {!Element} */ var element;
20 |     /** @type {string} */ var type;
21 | 
22 |     for (; i < length;) {
23 |       element = elements[i++];
24 |       type = (element.getAttribute('type') || '').toLowerCase();
25 |       // type: IN/Share+init, IN/FollowCompany+init
26 |       type.indexOf('in/') || subscribe_(element, type.substr(3).split('+')[0]);
27 |     }
28 | 
29 |     komito.DynamicContentTracker.track(init_);
30 |   }
31 | 
32 |   /**
33 |    * @param {!Element} element The script element.
34 |    * @param {string} action The social action type.
35 |    * @private
36 |    */
37 |   function subscribe_(element, action) {
38 |     if (!komito.DynamicContentTracker.isRegistered(element)) {
39 |       komito.DynamicContentTracker.register(element);
40 | 
41 |       /** @type {string} */ var type = 'onsuccess';
42 |       /** @type {string} */ var cb = ['cb', type, action, +new Date].join('_');
43 |       /** @type {?Node} */ var widget;
44 | 
45 |       function handler() {
46 |         if (!fired_[action]) {
47 |           fired_[action] = 1;
48 |           komito.track(
49 |               komito.SOCIAL_ACTION_TYPE, 'LinkedIn', action, location.href);
50 |           widget && dom.events.removeEventListener(
51 |               widget, dom.events.TYPE.CLICK, handler);
52 |         }
53 |       }
54 | 
55 |       element[type] = (element[type] ? element[type] + ',' : '') + cb;
56 |       element.setAttribute('data-' + type, cb);
57 | 
58 |       dom.context[cb] = handler;
59 | 
60 |       setTimeout(function() {
61 |         widget = element.previousSibling;
62 |         if (widget && 'IN-widget' === widget.className) {
63 |           dom.events.addEventListener(widget, dom.events.TYPE.CLICK, handler);
64 |         }
65 |       }, 1E3);
66 |     }
67 |   }
68 | 
69 |   /**
70 |    * @type {!Object.<string, number>}
71 |    * @private
72 |    */
73 |   var fired_ = {};
74 | 
75 |   // Initializing LinkedIn events tracking.
76 |   init_();
77 | };
78 | 


--------------------------------------------------------------------------------
/src/komito/trackers/dom/orientation.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @fileoverview The orientation tracking plug-in.
 3 |  *
 4 |  * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/matchMedia
 5 |  * @see https://developer.mozilla.org/en-US/docs/Web/API/Screen/orientation
 6 |  * @see https://developer.mozilla.org/en-US/docs/Web/Events/orientationchange
 7 |  */
 8 | 
 9 | 
10 | 
11 | /**
12 |  * Defines <code>komito.trackers.dom.Orientation</code> constructor.
13 |  * @constructor
14 |  */
15 | komito.trackers.dom.Orientation = function() {
16 |   /** @const {string} */ var EVENT = 'orientationchange';
17 |   /** @const {string} */ var QUERY = '(orientation: portrait)';
18 | 
19 |   /**
20 |    * Initializes orientation tracking.
21 |    * @private
22 |    */
23 |   function init_() {
24 |     var mobile = dom.device.maxTouchPoints || 'ontouchstart' in dom.document;
25 | 
26 |     if (mobile && komito.config['trackOrientation']) {
27 |       /** @type {function(string): ?MediaQueryList} */
28 |       var matchMedia = dom.context['matchMedia'];
29 |       mql_ = matchMedia && matchMedia(QUERY);
30 | 
31 |       komito.track(
32 |           komito.EVENT_ACTION_TYPE, 'orientation', 'initial', getType_(mql_));
33 | 
34 |       mql_ ?
35 |           mql_['addListener'](listener_) :
36 |           dom.events.addEventListener(dom.context, EVENT, listener_);
37 |     }
38 |   }
39 | 
40 |   /**
41 |    * @param {?Event} e The orientation change event.
42 |    * @private
43 |    */
44 |   function listener_(e) {
45 |     komito.track(
46 |         komito.EVENT_ACTION_TYPE, 'orientation', 'change', getType_(e));
47 | 
48 |     // mql_ ?
49 |     //     mql_['removeListener'](listener_) :
50 |     //     dom.events.removeEventListener(dom.context, EVENT, listener_);
51 | 
52 |     // mql_ = listener_ = dom.NULL;
53 |   }
54 | 
55 |   /**
56 |    * @param {?Event|?MediaQueryList} e The orientation event.
57 |    * @return {string} Return current orientation type.
58 |    * @see http://developer.mozilla.org/en-US/docs/Web/API/ScreenOrientation/type
59 |    * @private
60 |    */
61 |   function getType_(e) {
62 |     /** @type {?ScreenOrientation} */ var orientation = screen['orientation'] ||
63 |         screen['mozOrientation'] ||
64 |         screen['msOrientation'];
65 |     /** @type {string} */ var type = orientation ? orientation['type'] :
66 |         (e['matches'] ? 'portrait' : 'landscape');
67 | 
68 |     return type.split('-')[0];
69 |   }
70 | 
71 |   /**
72 |    * @type {?MediaQueryList}
73 |    * @private
74 |    */
75 |   var mql_;
76 | 
77 |   // Initializing orientation events tracking.
78 |   init_();
79 | };
80 | 


--------------------------------------------------------------------------------
/.github/workflows/codeql-analysis.yml:
--------------------------------------------------------------------------------
 1 | # For most projects, this workflow file will not need changing; you simply need
 2 | # to commit it to your repository.
 3 | #
 4 | # You may wish to alter this file to override the set of languages analyzed,
 5 | # or to provide custom queries or build logic.
 6 | #
 7 | # ******** NOTE ********
 8 | # We have attempted to detect the languages in your repository. Please check
 9 | # the `language` matrix defined below to confirm you have the correct set of
10 | # supported CodeQL languages.
11 | #
12 | name: "analyze"
13 | 
14 | on:
15 |   push:
16 |     branches: [ master ]
17 |   pull_request:
18 |     # The branches below must be a subset of the branches above
19 |     branches: [ master ]
20 |   schedule:
21 |     - cron: '45 18 * * 6'
22 | 
23 | jobs:
24 |   analyze:
25 |     name: Analyze
26 |     runs-on: ubuntu-latest
27 |     permissions:
28 |       actions: read
29 |       contents: read
30 |       security-events: write
31 | 
32 |     strategy:
33 |       fail-fast: false
34 |       matrix:
35 |         language: [ 'javascript' ]
36 |         # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
37 |         # Learn more:
38 |         # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
39 | 
40 |     steps:
41 |     - name: Checkout repository
42 |       uses: actions/checkout@v2
43 | 
44 |     # Initializes the CodeQL tools for scanning.
45 |     - name: Initialize CodeQL
46 |       uses: github/codeql-action/init@v1
47 |       with:
48 |         languages: ${{ matrix.language }}
49 |         # If you wish to specify custom queries, you can do so here or in a config file.
50 |         # By default, queries listed here will override any specified in a config file.
51 |         # Prefix the list here with "+" to use these queries and those in the config file.
52 |         # queries: ./path/to/local/query, your-org/your-repo/queries@main
53 | 
54 |     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
55 |     # If this step fails, then you should remove it and run the build manually (see below)
56 |     - name: Autobuild
57 |       uses: github/codeql-action/autobuild@v1
58 | 
59 |     # ℹ️ Command-line programs to run using the OS shell.
60 |     # 📚 https://git.io/JvXDl
61 | 
62 |     # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
63 |     #    and modify them (or add more) to build your code if your project
64 |     #    uses a compiled language
65 | 
66 |     #- run: |
67 |     #   make bootstrap
68 |     #   make release
69 | 
70 |     - name: Perform CodeQL Analysis
71 |       uses: github/codeql-action/analyze@v1
72 | 


--------------------------------------------------------------------------------
/npm/README.md:
--------------------------------------------------------------------------------
 1 | # Komito Analytics [![Tweet](https://img.shields.io/twitter/url/http/shields.io.svg?style=social)](https://twitter.com/intent/tweet?text=Komito%20Analytics%20-%20Unlock%20the%20power%20of%20digital%20analytics%20with%20additional%20insights%20about%20visitor%27s%20behavior.&url=https://komito.net/&via=GitHub&hashtags=KomitoAnalytics,GoogleAnalytics,AdobeAnalytics,EventTracking,MediaTracking)
 2 | [![License](http://img.shields.io/:license-apache-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0.html) [![Website](https://img.shields.io/website-up-down-green-red/https/komito.net.svg?style=flat)](https://komito.net) [![NPM version](https://img.shields.io/npm/v/komito-analytics.svg?style=flat)](https://npmjs.org/package/komito-analytics) [![NPM downloads](https://img.shields.io/npm/dm/komito-analytics.svg?style=flat)](https://npmjs.org/package/komito-analytics)
 3 | 
 4 | Komito Analytics is a free, open-source enhancement for the most popular web analytics software.<br>
 5 | It unlocks power of digital analytics with additional insights about visitor's behavior.<br>
 6 | For more information please visit [Komito Analytics project page](https://komito.net).
 7 | 
 8 | ## Install
 9 | 
10 | ```
11 | $ npm install komito-analytics
12 | ```
13 | 
14 | ## Usage
15 | 
16 | ```js
17 | const komito = require('komito-analytics');
18 | 
19 | // The default configuration can be omitted and only changed properties can be included.
20 | // @see https://komito.net/integration/
21 | komito.init({
22 |   'trackTwitter': 1,     // Tracks Twitter events if widget is presented on page.
23 |   'trackFacebook': 1,    // Tracks Facebook events if widget is presented on page.
24 |   'trackLinkedIn': 1,    // Tracks LinkedIn events if plugin is presented on page.
25 |   'trackDownloads': 1,   // Tracks files download links.
26 |   'trackOutbound': 1,    // Tracks outbound links.
27 |   'trackForms': 1,       // Tracks forms submissions.
28 |   'trackUsers': 1,       // Tracks pageviews by users logged in to social networks.
29 |   'trackActions': 1,     // Tracks 'mailto', 'tel', 'sms' and 'skype' actions.
30 |   'trackPrint': 1,       // Tracks page print actions.
31 |   'trackOrientation': 1, // Tracks orientation change on mobile devices.
32 |   'trackAdblock': 0,     // Tracks page views with blocked ads. (Experimental)
33 |   'trackErrorPages': 0,  // Tracks error pages. (Experimental)
34 |   'sendHeartbeat': 0,    // Sends heartbeat event. (Default interval 30 seconds)
35 |   'debugMode': 0,        // Prints all requests to console.
36 |   'trackScroll': [25, 50, 75, 100], // Tracks scroll depth.
37 |   'trackMedia': ['html5', 'vimeo', 'youtube'], // Tracks HTML5 video, audio, Vimeo and YouTube players events.
38 |   'nonInteraction': ['adblock', 'audio', 'form', 'heartbeat',
39 |                      'orientation', 'print', 'scroll', 'video'] // List of non interaction events.
40 | });
41 | ```


--------------------------------------------------------------------------------
/src/komito/trackers/social/users.js:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 | /**
 5 |  * Defines <code>komito.trackers.social.Users</code> constructor.
 6 |  * @constructor
 7 |  */
 8 | komito.trackers.social.Users = function() {
 9 | 
10 |   /**
11 |    * Mapping for tracking logged in users.
12 |    * @type {!Object.<string, string>}
13 |    */
14 |   var USERS = {
15 |     'Google': 'https://accounts.google.com/CheckCookie?continue=' +
16 |         'https%3A%2F%2Fwww.google.com%2Fintl%2Fen%2Fimages%2Flogos%2F' +
17 |         'accounts_logo.png&amp;followup=https%3A%2F%2Fwww.google.com%2F' +
18 |         'intl%2Fen%2Fimages%2Flogos%2Faccounts_logo.png&amp;' +
19 |         'chtml=LoginDoneHtml&amp;checkedDomains=youtube&amp;' +
20 |         'checkConnection=youtube%3A291%3A1'
21 |   };
22 | 
23 |   /**
24 |    * Tracks pageviews by users logged in to social networks.
25 |    * @private
26 |    */
27 |   function init_() {
28 |     /** @type {number} */ var sent = 0;
29 |     /** @type {number} */ var attempts = 5;
30 |     /** @type {string} */ var network;
31 | 
32 |     /**
33 |      * @param {string} network The social network name.
34 |      */
35 |     function pageview(network) {
36 |       komito.track(
37 |           komito.SOCIAL_ACTION_TYPE, network, 'pageview', location.href);
38 |     }
39 | 
40 |     /**
41 |      * @param {!HTMLImageElement|!Image} image The image object.
42 |      * @param {string} network The social network name.
43 |      */
44 |     function subscribe(image, network) {
45 |       dom.events.addEventListener(image, dom.events.TYPE.LOAD, function() {
46 |         pageview(network);
47 |       });
48 |       image.src = USERS[network];
49 |     }
50 | 
51 |     /**
52 |      * @param {function(function(?Object), boolean=)} fn getLoginStatus function.
53 |      * @see https://developers.facebook.com/docs/reference/javascript/FB.getLoginStatus/
54 |      */
55 |     function getStatus(fn) {
56 |       fn(function(response) {
57 |         if (response && 'unknown' !== response['status'] && !sent++)
58 |           pageview('Facebook');
59 |       }, true);
60 |     }
61 | 
62 |     function status() {
63 |       /** @type {function(function(?Object), boolean=)} */
64 |       var fn = dom.context['FB'] && dom.context['FB']['getLoginStatus'];
65 |       if (fn) {
66 |         getStatus(fn);
67 | 
68 |         dom.events.addEventListener(dom.context, 'message', function(e) {
69 |           try {
70 |             if ('facebook.com' === e['origin'].substr(-12) &&
71 |                 e['data'] &&
72 |                 ~e['data'].indexOf('xd_action=proxy_ready')) {
73 |               getStatus(fn);
74 |             }
75 |           } catch (ex) {}
76 |         });
77 | 
78 |       } else if (--attempts) {
79 |         setTimeout(status, 2e3);
80 |       }
81 |     }
82 | 
83 |     for (network in USERS) {
84 |       /** @type {!Image} */ var image = new Image(1, 1);
85 |       subscribe(image, network);
86 |     }
87 | 
88 |     komito.trackers.social.Facebook.init(status);
89 |   }
90 | 
91 |   // Initializing Users events tracking.
92 |   init_();
93 | };
94 | 


--------------------------------------------------------------------------------
/src/glize/util/String.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @fileoverview String utility methods.
 3 |  *
 4 |  * @see http://google.github.io/styleguide/javascriptguide.xml
 5 |  * @see http://developers.google.com/closure/compiler/docs/js-for-compiler
 6 |  */
 7 | 
 8 | 
 9 | /**
10 |  * String utility methods.
11 |  * @namespace
12 |  */
13 | util.String = {
14 |   /**
15 |    * Trims leading and trailing whitespace from the given string.
16 |    * @param {string} str The string to trim.
17 |    * @return {string} Returns the string stripped of whitespace.
18 |    * @see {@link http://www.ecma-international.org/ecma-262/5.1/#sec-15.5.4.20}
19 |    */
20 |   trim: function(str) {
21 |     return str.trim ? str.trim() : util.String.trimRight(
22 |         util.String.trimLeft(str));
23 |   },
24 | 
25 |   /**
26 |    * Removes whitespace from the left end of the string.
27 |    * @param {string} str The string to trim.
28 |    * @return {string} Returns the string stripped of whitespace from left end.
29 |    */
30 |   trimLeft: function(str) {
31 |     return str.trimLeft ? str.trimLeft() : str.replace(/^[\s\xa0]+/, '');
32 |   },
33 | 
34 |   /**
35 |    * Removes whitespace from the right end of the string.
36 |    * @param {string} str The string to trim.
37 |    * @return {string} Returns the string stripped of whitespace from right end.
38 |    */
39 |   trimRight: function(str) {
40 |     return str.trimRight ? str.trimRight() : str.replace(/[\s\xa0]+$/, '');
41 |   },
42 | 
43 |   /**
44 |    * Checks whether <code>str</code> starts with <code>prefix</code>.
45 |    * @param {string} str The string to be checked.
46 |    * @param {string} prefix A string to look for at the start of
47 |    *     <code>str</code>.
48 |    * @return {boolean} Returns <code>true</code> if string <code>str</code>
49 |    *     starts with the <code>prefix</code>.
50 |    */
51 |   startsWith: function(str, prefix) {
52 |     return 0 === str.lastIndexOf(prefix, 0);
53 |   },
54 | 
55 |   /**
56 |    * Checks whether <code>str</code> ends with <code>suffix</code>.
57 |    * @param {string} str The string to be checked.
58 |    * @param {string} suffix A string to look for at the end of <code>str</code>.
59 |    * @return {boolean} Returns <code>true</code> if string <code>str</code>
60 |    *     ends with the <code>suffix</code>.
61 |    */
62 |   endsWith: function(str, suffix) {
63 |     /** @type {number} */ var index = str.lastIndexOf(suffix);
64 |     return 0 <= index && index === str.length - suffix.length;
65 |   },
66 | 
67 |   /**
68 |    * Transforms the first character of each word to uppercase; other
69 |    * characters are unaffected..
70 |    * @param {string} str The string to be transformed.
71 |    * @return {string} Returns transformed string.
72 |    * @see http://www.w3.org/wiki/CSS/Properties/text-transform
73 |    */
74 |   capitalize: function(str) {
75 |     /** @type {!Array.<string>} */ var words = str.split(/\s+/);
76 |     /** @type {number} */ var length = words.length;
77 |     /** @type {number} */ var i = 0;
78 |     /** @type {string} */ var word;
79 | 
80 |     for (; i < length; ++i) {
81 |       word = words[i];
82 |       words[i] = word.charAt(0).toUpperCase() + word.slice(1);
83 |     }
84 | 
85 |     return words.join(' ');
86 |   }
87 | };
88 | 


--------------------------------------------------------------------------------
/src/komito/trackers/dom/__ns__.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Defines <code>komito.trackers.dom</code> namespace.
 3 |  * @namespace
 4 |  */
 5 | komito.trackers.dom = {
 6 |   init: function() {
 7 |     komito.trackers.dom.Forms && new komito.trackers.dom.Forms;
 8 |     komito.trackers.dom.Links && new komito.trackers.dom.Links;
 9 |     komito.trackers.dom.Print && new komito.trackers.dom.Print;
10 |     komito.trackers.dom.Scroll && new komito.trackers.dom.Scroll;
11 |     komito.trackers.dom.Orientation && new komito.trackers.dom.Orientation;
12 |     komito.trackers.dom.AdBlock && new komito.trackers.dom.AdBlock;
13 | 
14 |     komito.trackers.dom.trackHeartBeat_(+komito.config['sendHeartbeat']);
15 |     komito.trackers.dom.trackErrorPages_();
16 |     komito.trackers.dom.trackColorScheme_();
17 |     komito.trackers.dom.trackRuntimeErrors_();
18 |   },
19 | 
20 |   /**
21 |    * Tracks heartbeat event.
22 |    * @param {number} interval The heartbeat interval in seconds.
23 |    * @see https://www.w3.org/TR/page-visibility/
24 |    * @private
25 |    */
26 |   trackHeartBeat_: function(interval) {
27 |     if (interval) {
28 |       /** @type {number} */ var timer;
29 |       interval = Math.max(interval, 30);
30 | 
31 |       dom.events.addEventListener(dom.document, 'visibilitychange', function() {
32 |         if ('visible' === dom.document['visibilityState']) {
33 |           timer = setInterval(function() {
34 |             komito.track(komito.EVENT_ACTION_TYPE, 'heartbeat', interval + 's');
35 |           }, 1E3 * interval);
36 |         } else {
37 |           timer && clearInterval(timer);
38 |         }
39 |       });
40 |     }
41 |   },
42 | 
43 |   /**
44 |    * Tracks error pages.
45 |    * @private
46 |    */
47 |   trackErrorPages_: function() {
48 |     var page = komito.config['trackErrorPages'] && location.href;
49 | 
50 |     if (page) {
51 |       komito.markAsNonInteractionEvent('errors');
52 |       (new net.HttpRequest).doHead(/** @type {string} */(page), function(req) {
53 |         if (399 < req.status) {
54 |           komito.track(komito.EVENT_ACTION_TYPE, 'errors', req.status, page);
55 |         }
56 |       });
57 |     }
58 |   },
59 | 
60 |   /**
61 |    * Tracks javascript runtime errors.
62 |    * @see https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent
63 |    * @private
64 |    */
65 |   trackRuntimeErrors_: function() {
66 |     if (komito.config['trackErrors']) {
67 |       komito.markAsNonInteractionEvent('errors');
68 |       dom.events.addEventListener(dom.context, 'error', function(e) {
69 |         komito.track(komito.EVENT_ACTION_TYPE, 'errors', e.message, e.filename);
70 |       });
71 |     }
72 |   },
73 | 
74 |   /**
75 |    * Tracks user preferred color scheme.
76 |    * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme
77 |    * @private
78 |    */
79 |   trackColorScheme_: function() {
80 |     if (komito.config['trackColorScheme'] && dom.context.matchMedia) {
81 |       // https://github.com/Datamart/Komito/issues/38
82 |       komito.markAsNonInteractionEvent('color-scheme');
83 | 
84 |       var query = '(prefers-color-scheme: dark)';
85 |       var scheme = dom.context.matchMedia(query).matches ? 'dark' : 'light';
86 |       komito.track(komito.EVENT_ACTION_TYPE, 'color-scheme', scheme);
87 |     }
88 |   }
89 | };
90 | 


--------------------------------------------------------------------------------
/src/komito/trackers/media/html5.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @fileoverview Komito Analytics tracker for HTML5 media elements.
 3 |  *
 4 |  * Adds DOM event listeners to <audio> and <video> elements found on webpage.
 5 |  * Supported event types: 'play', 'pause', 'ended' and 'fullscreenchange'.
 6 |  * Sends 'audio:html5' and 'video:html5' as event category name.
 7 |  *
 8 |  * @link http://html.spec.whatwg.org/multipage/embedded-content.html#mediaevents
 9 |  * @link http://developer.mozilla.org/en-US/docs/Web/Events/fullscreenchange
10 |  *
11 |  * @link http://google.github.io/styleguide/javascriptguide.xml
12 |  * @link http://developers.google.com/closure/compiler/docs/js-for-compiler
13 |  */
14 | 
15 | 
16 | 
17 | /**
18 |  * Defines <code>komito.trackers.media.html5</code> constructor.
19 |  * Tracks media (video and audio) events on page.
20 |  * @constructor
21 |  */
22 | komito.trackers.media.HTML5 = function() {
23 | 
24 |   /**
25 |    * Initializes HTML5 media tracking.
26 |    * @private
27 |    */
28 |   function init_() {
29 |     /** @type {!Array.<string>} */ var events = [
30 |       'ended', 'pause', 'play',
31 |       'webkitfullscreenchange', 'mozfullscreenchange', 'fullscreenchange'];
32 |     /** @type {!Array.<!Element>} */ var elements = toArray_('AUDIO', 'VIDEO');
33 | 
34 |     /** @type {number} */ var length = elements.length;
35 |     /** @type {!Element} */ var element;
36 |     /** @type {string} */ var type;
37 |     /** @type {number} */ var i;
38 | 
39 |     /** @param {?Event} e The event */
40 |     function listener(e) {
41 |       element = /** @type {!Element} */ (dom.events.getEventTarget(e));
42 |       type = e.type;
43 | 
44 |       if (~type.indexOf('fullscreen')) {
45 |         type = (dom.document['fullScreen'] || dom.document['mozFullScreen'] ||
46 |                 dom.document['webkitIsFullScreen']) ? 'fullscreen' : '';
47 |       }
48 | 
49 |       type && komito.track(
50 |           komito.EVENT_ACTION_TYPE, element.tagName.toLowerCase() + ':html5',
51 |           type, element['currentSrc'] || element['src']);
52 |     }
53 | 
54 |     for (; length--;) {
55 |       element = elements[length];
56 |       if (!komito.DynamicContentTracker.isRegistered(element)) {
57 |         komito.DynamicContentTracker.register(element);
58 |         for (i = 0; i < 6;) { // 6 == events.length
59 |           dom.events.addEventListener(element, events[i++], listener);
60 |         }
61 |       }
62 |     }
63 | 
64 |     komito.DynamicContentTracker.track(init_);
65 |   }
66 | 
67 |   /**
68 |    * Creates an array of element by specified tag names.
69 |    * @param {...string} var_args The elements tag names to convert.
70 |    * @return {!Array.<!Element>} Returns converted elements to array.
71 |    * @private
72 |    */
73 |   function toArray_(var_args) {
74 |     /** @type {!Array.<!Element>} */ var elements = [];
75 |     /** @type {number} */ var length = arguments.length;
76 |     /** @type {?NodeList} */ var nodes;
77 |     /** @type {number} */ var i;
78 | 
79 |     for (; length;) {
80 |       nodes = dom.getElementsByTagName(dom.document, arguments[--length]);
81 |       for (i = 0; i < nodes.length;) {
82 |         elements.push(nodes[i++]);
83 |       }
84 |     }
85 | 
86 |     return elements;
87 |   }
88 | 
89 |   // Initializing HTML5 media events tracking.
90 |   init_();
91 | };
92 | 


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
 1 | # Contributor Covenant Code of Conduct
 2 | 
 3 | ## Our Pledge
 4 | 
 5 | In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
 6 | 
 7 | ## Our Standards
 8 | 
 9 | Examples of behavior that contributes to creating a positive environment include:
10 | 
11 | * Using welcoming and inclusive language
12 | * Being respectful of differing viewpoints and experiences
13 | * Gracefully accepting constructive criticism
14 | * Focusing on what is best for the community
15 | * Showing empathy towards other community members
16 | 
17 | Examples of unacceptable behavior by participants include:
18 | 
19 | * The use of sexualized language or imagery and unwelcome sexual attention or advances
20 | * Trolling, insulting/derogatory comments, and personal or political attacks
21 | * Public or private harassment
22 | * Publishing others' private information, such as a physical or electronic address, without explicit permission
23 | * Other conduct which could reasonably be considered inappropriate in a professional setting
24 | 
25 | ## Our Responsibilities
26 | 
27 | Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
28 | 
29 | Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
30 | 
31 | ## Scope
32 | 
33 | This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
34 | 
35 | ## Enforcement
36 | 
37 | Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at support@komito.net. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
38 | 
39 | Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
40 | 
41 | ## Attribution
42 | 
43 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
44 | 
45 | [homepage]: http://contributor-covenant.org
46 | [version]: http://contributor-covenant.org/version/1/4/
47 | 


--------------------------------------------------------------------------------
/src/komito/trackers/media/vimeo.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @fileoverview Komito Analytics tracker for Vimeo player.
  3 |  *
  4 |  * Searches for IFRAMEs in DOM loaded from 'player.vimeo.com' domain.
  5 |  * Loads Vimeo Player API if needed.
  6 |  * Adds event listeners to Vimeo players for videos found on webpage.
  7 |  * Supported event types: 'play', 'pause' and 'ended'.
  8 |  * Sends 'video:vimeo' as event category name.
  9 |  *
 10 |  * @link https://github.com/vimeo/player.js
 11 |  *
 12 |  * @link http://google.github.io/styleguide/javascriptguide.xml
 13 |  * @link http://developers.google.com/closure/compiler/docs/js-for-compiler
 14 |  */
 15 | 
 16 | 
 17 | 
 18 | /**
 19 |  * Tracks vimeo events on page.
 20 |  * @constructor
 21 |  */
 22 | komito.trackers.media.Vimeo = function() {
 23 | 
 24 |   /** @const {!RegExp} */
 25 |   var PATTERN = /^(https?:)?\/\/player\.vimeo\.com\/video\/\d+/;
 26 | 
 27 |   /** @const {string} */
 28 |   var PLAYERJS = 'https://player.vimeo.com/api/player.js';
 29 | 
 30 |   /**
 31 |    * Initializes Vimeo player events tracking.
 32 |    * @private
 33 |    */
 34 |   function init_() {
 35 |     /** @type {?NodeList} */
 36 |     var elements = dom.getElementsByTagName(dom.document, 'IFRAME');
 37 |     /** @type {number} */ var length = elements.length;
 38 |     /** @type {!Array.<!HTMLIFrameElement>} */ var iframes = [];
 39 |     /** @type {!HTMLIFrameElement} */ var element;
 40 | 
 41 |     for (; length;) {
 42 |       element = elements[--length];
 43 |       if (PATTERN.test(element.src)) {
 44 |         if (!komito.DynamicContentTracker.isRegistered(element)) {
 45 |           komito.DynamicContentTracker.register(element);
 46 |           iframes.push(element);
 47 |         }
 48 |       }
 49 |     }
 50 | 
 51 |     if (iframes.length) {
 52 |       if (dom.context['Vimeo'] && dom.context['Vimeo']['Player']) {
 53 |         initListeners_(iframes);
 54 |       } else {
 55 |         dom.scripts.load(PLAYERJS, function() {
 56 |           initListeners_(iframes);
 57 |         });
 58 |       }
 59 |     }
 60 | 
 61 |     komito.DynamicContentTracker.track(init_);
 62 |   }
 63 | 
 64 |   /**
 65 |    * Initializes event listeners.
 66 |    * @param {!Array.<!HTMLIFrameElement>} iframes The list of found iframes.
 67 |    * @private
 68 |    */
 69 |   function initListeners_(iframes) {
 70 |     var Player = dom.context['Vimeo'] && dom.context['Vimeo']['Player'];
 71 | 
 72 |     if (Player) {
 73 |       /** @type {number} */ var length = iframes.length;
 74 |       /** @type {!HTMLIFrameElement} */ var element;
 75 | 
 76 |       for (; length;) {
 77 |         element = iframes[--length];
 78 |         addListeners_(new Player(element), element.src.split('?')[0]);
 79 |       }
 80 |     }
 81 |   }
 82 | 
 83 |   /**
 84 |    * Adds event listener for Vimeo player.
 85 |    * @param {!Object} player The instance of 'Vimeo.Player'.
 86 |    * @param {string} video The video source URL.
 87 |    * @private
 88 |    */
 89 |   function addListeners_(player, video) {
 90 |     player['on']('ended', function() {
 91 |       komito.track(komito.EVENT_ACTION_TYPE, 'video:vimeo', 'ended', video);
 92 |     });
 93 |     player['on']('play', function() {
 94 |       komito.track(komito.EVENT_ACTION_TYPE, 'video:vimeo', 'play', video);
 95 |     });
 96 |     player['on']('pause', function() {
 97 |       komito.track(komito.EVENT_ACTION_TYPE, 'video:vimeo', 'pause', video);
 98 |     });
 99 |   }
100 | 
101 |   // Initializing Vimeo player events tracking.
102 |   init_();
103 | };
104 | 


--------------------------------------------------------------------------------
/src/komito/trackers/media/youtube.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @fileoverview Komito Analytics tracker for YouTube player.
  3 |  *
  4 |  * Searches for IFRAMEs in DOM loaded from '*.youtube.com' domain.
  5 |  * Loads YouTube Iframe API script if needed.
  6 |  * Adds event listeners to YouTube videos found on webpage.
  7 |  * Supported event types: 'play', 'pause' and 'ended'.
  8 |  * Sends 'video:youtube' as event category name.
  9 |  *
 10 |  * @link https://developers.google.com/youtube/iframe_api_reference
 11 |  *
 12 |  * @link http://google.github.io/styleguide/javascriptguide.xml
 13 |  * @link http://developers.google.com/closure/compiler/docs/js-for-compiler
 14 |  */
 15 | 
 16 | 
 17 | 
 18 | /**
 19 |  * Defines <code>komito.trackers.media.youtube</code> constructor.
 20 |  * Tracks youtube events on page.
 21 |  * @constructor
 22 |  */
 23 | komito.trackers.media.YouTube = function() {
 24 |   /** @const {!RegExp} */ var PATTERN =
 25 |       /^(https?:)?\/\/(www\.)?youtube(\-nocookie)?\.com\/(embed|watch|v)/;
 26 | 
 27 |   /** @const {string} */
 28 |   var PLAYERJS = 'https://www.youtube.com/iframe_api';
 29 | 
 30 |   /**
 31 |    * Initializes YouTube media tracking.
 32 |    * @private
 33 |    */
 34 |   function init_() {
 35 |     /** @type {!Array|?NodeList} */
 36 |     var elements = dom.getElementsByTagName(dom.document, 'IFRAME');
 37 |     /** @type {number} */ var length = elements.length;
 38 |     /** @type {number} */ var i = 0;
 39 |     /** @type {!Array} */ var iframes = [];
 40 |     /** @type {!HTMLIFrameElement} */ var element;
 41 |     /** @type {string} */ var source;
 42 |     /** @type {?Object} */ var player;
 43 |     /** @type {?Function} */ var listener;
 44 | 
 45 |     for (; length--;) {
 46 |       element = elements[length];
 47 |       source = element.src;
 48 |       if (PATTERN.test(source)) {
 49 |         if (!komito.DynamicContentTracker.isRegistered(element)) {
 50 |           komito.DynamicContentTracker.register(element);
 51 | 
 52 |           if (0 > source.indexOf('enablejsapi')) {
 53 |             element.src += (~source.indexOf('?') ? '&' : '?') + 'enablejsapi=1';
 54 |           }
 55 |           iframes.push(element);
 56 |         }
 57 |       }
 58 |     }
 59 | 
 60 |     length = iframes.length;
 61 |     if (length) {
 62 |       // Save the reference to the YouTube event listener if it exists.
 63 |       listener = dom.context['onYouTubeIframeAPIReady'];
 64 |       dom.context['onYouTubeIframeAPIReady'] = function() {
 65 |         listener && listener();
 66 |         for (; length--;) {
 67 |           element = iframes[length];
 68 |           player = dom.context['YT']['get'](element.id) ||
 69 |                    new dom.context['YT']['Player'](element);
 70 |           dom.events.addEventListener(player, 'onStateChange', listener_);
 71 |         }
 72 |       };
 73 | 
 74 |       dom.context['YT'] || dom.scripts.load(PLAYERJS);
 75 |     }
 76 | 
 77 |     komito.DynamicContentTracker.track(init_);
 78 |   }
 79 | 
 80 |   /**
 81 |    * The 'onStateChange' event listener attached to YouTube player.
 82 |    * @param {?Event} e The event
 83 |    * @private
 84 |    */
 85 |   function listener_(e) {
 86 |     /** @type {string} */ var type = ['ended', 'play', 'pause'][e['data']];
 87 | 
 88 |     type && komito.track(
 89 |         komito.EVENT_ACTION_TYPE, 'video:youtube', type, getVideoUrl_(e));
 90 |   }
 91 | 
 92 |   /**
 93 |    * Gets the YouTube.com URL for the currently loaded/playing video.
 94 |    * @param {?Event} e The event
 95 |    * @return {string} Returns the video URL.
 96 |    * @see https://developers.google.com/youtube/iframe_api_reference
 97 |    * @private
 98 |    */
 99 |   function getVideoUrl_(e) {
100 |     var player = e.target;
101 | 
102 |     return player['getVideoUrl'] ?
103 |         player['getVideoUrl']() :
104 |         player['getIframe']()['src'].split('?')[0];
105 |   }
106 | 
107 |   // Initializing YouTube video events tracking.
108 |   init_();
109 | };
110 | 


--------------------------------------------------------------------------------
/src/komito/trackers/social/facebook.js:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | 
  4 | /**
  5 |  * Defines <code>komito.trackers.social.Facebook</code> constructor.
  6 |  * @constructor
  7 |  */
  8 | komito.trackers.social.Facebook = function() {
  9 |   /**
 10 |    * Tries to attach listener to Facebook widget object if it presents on page.
 11 |    * @see http://developers.facebook.com/docs/reference/javascript/FB.Event.subscribe
 12 |    * @see https://developers.facebook.com/blog/post/2017/11/07/changes-developer-offerings/
 13 |    * @private
 14 |    */
 15 |   function init_() {
 16 |     dom.events.addEventListener(dom.context, dom.events.TYPE.BLUR, function() {
 17 |       var iframe = dom.document.activeElement;
 18 |       if (iframe && iframe.tagName == 'IFRAME') {
 19 |         if (iframe.src.indexOf('https://www.facebook.com/') == 0) {
 20 |           // "fb:like Facebook Social Plugin"
 21 |           // "fb:share_button Facebook Social Plugin"
 22 |           var action = iframe.title.split(' ')[0];
 23 |           if (action.indexOf('fb:') == 0) {
 24 |             action = action.slice(3).split('_')[0];
 25 |             listener_(action);
 26 |           }
 27 |         }
 28 |       }
 29 |     });
 30 |   }
 31 | 
 32 |   /**
 33 |    * @param {string} action The Facebook event type.
 34 |    * @private
 35 |    */
 36 |   function listener_(action) {
 37 |     komito.track(
 38 |         komito.SOCIAL_ACTION_TYPE, 'Facebook', action, location.href);
 39 |   }
 40 | 
 41 |   /**
 42 |    * @type {number}
 43 |    * @private
 44 |    */
 45 |   var counter_ = 0;
 46 | 
 47 |   // Initializing Facebook events tracking.
 48 |   komito.trackers.social.Facebook.init(init_);
 49 | };
 50 | 
 51 | 
 52 | /**
 53 |  * Gets Facebook App ID.
 54 |  * @return {string} Returns Facebook App ID.
 55 |  * @private
 56 |  */
 57 | komito.trackers.social.Facebook.getAppId_ = function() {
 58 |   var appId = komito.trackers.social.Facebook.appId_;
 59 | 
 60 |   if (!appId) {
 61 |     appId = komito.config['trackFacebook'];
 62 | 
 63 |     if (appId) {
 64 |       appId = '' + appId;
 65 |       if (appId.length < 9) {
 66 |         var nodes = dom.getElementsByTagName(dom.document, 'META');
 67 |         var array = util.Array.toArray(/** @type {!NodeList} */ (nodes));
 68 |         var length = array.length;
 69 |         var node;
 70 |         for (; length--;) {
 71 |           node = array[length];
 72 |           // <meta property="fb:app_id" content="490025408049997">
 73 |           if ('fb:app_id' == node.getAttribute('property')) {
 74 |             appId = node.getAttribute('content');
 75 |             break;
 76 |           }
 77 |         }
 78 |       }
 79 |     }
 80 | 
 81 |     komito.trackers.social.Facebook.appId_ = appId.length < 9 ? '' : appId;
 82 |   }
 83 | 
 84 |   return /** @type {string} */ (komito.trackers.social.Facebook.appId_);
 85 | };
 86 | 
 87 | 
 88 | /**
 89 |  * Loads and initializes Facebook SDK.
 90 |  * @param {!Function} callback The callback function.
 91 |  * @see https://developers.facebook.com/docs/javascript/quickstart
 92 |  * @see https://developers.facebook.com/docs/javascript/reference/FB.init/v3.2
 93 |  */
 94 | komito.trackers.social.Facebook.init = function(callback) {
 95 |   /** @type {string} */ var appId;
 96 | 
 97 |   if (!komito.trackers.social.Facebook.initialized_) {
 98 |     komito.trackers.social.Facebook.initialized_ = 1;
 99 | 
100 |     if (!dom.context['FB']) {
101 |       appId = komito.trackers.social.Facebook.getAppId_();
102 |       if (appId) {
103 |         /** @type {?Element} */ var script = dom.createElement('SCRIPT');
104 |         script.async = 1;
105 |         script.id = 'facebook-jssdk';
106 |         script.src = 'https://connect.facebook.net/en_US/sdk.js#' +
107 |                      'xfbml=1&version=v3.2&status=1&cookie=1&' +
108 |                      'appId=' + appId;
109 |         dom.appendChild(dom.document.body, script);
110 |         setTimeout(callback, 3E3);
111 |       }
112 |     }
113 |   }
114 | 
115 |   appId || callback();
116 | };
117 | 


--------------------------------------------------------------------------------
/src/glize/compressors/__ns__.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @fileoverview Defines compressors utility methods.
  3 |  *
  4 |  * @see http://google.github.io/styleguide/javascriptguide.xml
  5 |  * @see http://developers.google.com/closure/compiler/docs/js-for-compiler
  6 |  */
  7 | 
  8 | 
  9 | /**
 10 |  * Defines compressors utility methods.
 11 |  * @namespace
 12 |  */
 13 | var compressors = {
 14 | 
 15 |   /**
 16 |    * Compress data string using specified compression type.
 17 |    * @param {string} data Data to compress.
 18 |    * @param {string=} opt_type Optional compression type.
 19 |    * @return {string} Returns compressed data.
 20 |    */
 21 |   compress: function(data, opt_type) {
 22 |     opt_type = opt_type || compressors.TYPE.LZW;
 23 |     /** @type {string} */ var result;
 24 | 
 25 |     if (compressors.TYPE.LZW === opt_type) {
 26 |       result = compressors.LZW.compress(data);
 27 |     }
 28 | 
 29 |     return result;
 30 |   },
 31 | 
 32 |   /**
 33 |    * Decompress data string using specified compression type.
 34 |    * @param {string} data Data to compress.
 35 |    * @param {string=} opt_type Optional compression type.
 36 |    * @return {string} Returns compressed data.
 37 |    */
 38 |   decompress: function(data, opt_type) {
 39 |     opt_type = opt_type || compressors.TYPE.LZW;
 40 |     /** @type {string} */ var result;
 41 | 
 42 |     if (compressors.TYPE.LZW === opt_type) {
 43 |       result = compressors.LZW.decompress(data);
 44 |     }
 45 | 
 46 |     return result;
 47 |   }
 48 | };
 49 | 
 50 | 
 51 | /**
 52 |  * Enumeration of available compression types.
 53 |  * @enum {string}
 54 |  */
 55 | compressors.TYPE = {
 56 |   LZW: 'lzw'
 57 | };
 58 | 
 59 | 
 60 | /**
 61 |  * LZW compression utility.
 62 |  * @see http://en.wikipedia.org/wiki/Lempel–Ziv–Welch
 63 |  * @namespace
 64 |  */
 65 | compressors.LZW = {
 66 | 
 67 |   /**
 68 |    * Encodes string using LZW algorithm.
 69 |    * @param {string} str The input string.
 70 |    * @return {string} Returns compressed string using LZW algorithm.
 71 |    */
 72 |   compress: function(str) {
 73 |     /** @type {!Object.<string, number>} */ var dict = {};
 74 |     /** @type {!Array.<string>} */ var data = str.split('');
 75 |     /** @type {!Array} */ var out = [];
 76 |     /** @type {number} */ var code = 256;
 77 |     /** @type {string} */ var phrase = data.shift();
 78 |     /** @type {number} */ var i = 0;
 79 |     /** @type {string} */ var next;
 80 | 
 81 |     while (data.length) {
 82 |       next = data.shift();
 83 |       if (dom.NULL != dict[phrase + next]) {
 84 |         phrase += next;
 85 |       } else {
 86 |         out.push(phrase.length > 1 ? dict[phrase] : phrase.charCodeAt(0));
 87 |         dict[phrase + next] = code++;
 88 |         phrase = next;
 89 |       }
 90 |     }
 91 |     out.push(phrase.length > 1 ? dict[phrase] : phrase.charCodeAt(0));
 92 |     for (; i < out.length; i++) {
 93 |       out[i] = String.fromCharCode(/** @type {number} */ (out[i]));
 94 |     }
 95 | 
 96 |     return out.join('');
 97 |   },
 98 | 
 99 |   /**
100 |    * Decodes string encoded with LZW algorithm.
101 |    * @param {string} str The input string encoded with LZW algorithm.
102 |    * @return {string} Returns decoded string.
103 |    * @static
104 |    */
105 |   decompress: function(str) {
106 |     /** @type {!Object} */ var dict = {};
107 |     /** @type {!Array.<string>} */ var data = str.split('');
108 |     /** @type {!Array.<string>} */ var out = [data.shift()];
109 |     /** @type {number} */ var code = 256;
110 |     /** @type {string} */ var chr = out[0];
111 |     /** @type {string} */ var tmp = chr;
112 |     /** @type {number} */ var i = 0;
113 |     /** @type {number} */ var next;
114 |     /** @type {string} */ var phrase;
115 | 
116 |     for (; i < data.length; i++) {
117 |       next = data[i].charCodeAt(0);
118 |       phrase = next < 256 ? data[i] : (dict[next] ? dict[next] : (tmp + chr));
119 |       out.push(phrase);
120 |       chr = phrase.charAt(0);
121 |       dict[code++] = tmp + chr;
122 |       tmp = phrase;
123 |     }
124 | 
125 |     return out.join('');
126 |   }
127 | };
128 | 


--------------------------------------------------------------------------------
/src/glize/util/Object.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @fileoverview Object utility methods.
  3 |  *
  4 |  * @see http://google.github.io/styleguide/javascriptguide.xml
  5 |  * @see http://developers.google.com/closure/compiler/docs/js-for-compiler
  6 |  */
  7 | 
  8 | 
  9 | /**
 10 |  * Object utility methods.
 11 |  * @requires util.StringUtils.JSON
 12 |  * @namespace
 13 |  */
 14 | util.Object = {
 15 | 
 16 |   /**
 17 |    * Reference to <code>Object.prototype</code>.
 18 |    * Used to reduce size after compilation.
 19 |    * @const
 20 |    */
 21 |   PROTO: Object.prototype,
 22 | 
 23 |   /**
 24 |    * Copies the values of all enumerable own properties from one or more source
 25 |    * objects to a target object.
 26 |    * @param {!Object} target The target object.
 27 |    * @param {...!Object} var_args The source object(s).
 28 |    * @return {?Object} Returns the target object.
 29 |    * @see http://www.ecma-international.org/ecma-262/6.0/#sec-object.assign
 30 |    */
 31 |   assign: function(target, var_args) {
 32 |     /** @type {?Function} */ var fn = Object.assign;
 33 |     /** @type {number} */ var i = 1;
 34 |     /** @type {!Object} */ var source;
 35 |     /** @type {string} */ var key;
 36 | 
 37 |     target = fn ? fn.apply(null, arguments) : target;
 38 | 
 39 |     if (!fn) {
 40 |       for (; i < arguments.length;) {
 41 |         source = arguments[i++];
 42 |         if (source) {
 43 |           for (key in source) {
 44 |             if (util.Object.PROTO.hasOwnProperty.call(source, key)) {
 45 |               target[key] = source[key];
 46 |             }
 47 |           }
 48 |         }
 49 |       }
 50 |     }
 51 | 
 52 |     return target;
 53 |   },
 54 | 
 55 |   /**
 56 |    * Returns list of object keys.
 57 |    * @param {!Object} obj Target Object.
 58 |    * @return {!Array.<string>} List of target object keys.
 59 |    * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.2.3.14
 60 |    */
 61 |   keys: function(obj) {
 62 |     /** @type {?Function} */ var fn = Object.keys;
 63 |     /** @type {!Array.<string>} */ var keys = fn ? fn(obj) : [];
 64 |     /** @type {string|number} */ var key;
 65 | 
 66 |     if (!fn) {
 67 |       for (key in obj) {
 68 |         keys.push(key);
 69 |       }
 70 |     }
 71 | 
 72 |     return keys;
 73 |   },
 74 | 
 75 |   /**
 76 |    * Extends <code>target</code> with another object's properties.
 77 |    * @param {!Object} target The target object.
 78 |    * @param {...?Object} var_args The sources which properties will be copied.
 79 |    * @return {!Object} Returns reference to updated <code>target</code> object.
 80 |    */
 81 |   extend: function(target, var_args) {
 82 |     /** @type {number} */ var i = 1;
 83 |     /** @type {!Object} */ var source;
 84 |     /** @type {string} */ var key;
 85 |     /** @type {*} */ var value;
 86 | 
 87 |     for (; i < arguments.length;) {
 88 |       source = arguments[i++];
 89 |       for (key in source) {
 90 |         value = source[key];
 91 |         if (util.Array.isArray(value)) {
 92 |           target[key] = [].concat(value);
 93 |         } else if ('object' === typeof value) {
 94 |           target[key] = util.Object.extend(
 95 |               /** @type {!Object} */ (target[key] || {}),
 96 |               /** @type {!Object} */ (value));
 97 |         } else if (util.Object.PROTO.hasOwnProperty.call(source, key)) {
 98 |           target[key] = value;
 99 |         }
100 |       }
101 |     }
102 | 
103 |     return /** @type {!Object} */ (target);
104 |   },
105 | 
106 |   /**
107 |    * Filters object.
108 |    * @param {!Object} obj The target object.
109 |    * @param {function(*): boolean} func The filter function.
110 |    * @return {!Object} Returns filtered object.
111 |    */
112 |   filter: function(obj, func) {
113 |     /** @type {!Object} */ var result = {};
114 |     /** @type {string|number} */ var key;
115 | 
116 |     for (key in obj) {
117 |       if (func(obj[key])) {
118 |         result[key] = obj[key];
119 |       }
120 |     }
121 | 
122 |     return result;
123 |   },
124 | 
125 |   /**
126 |    * Flattens the object.
127 |    * @param {!Object} obj The target object.
128 |    * @param {string=} opt_delimiter The optional delimiter.
129 |    * @return {!Object} Return an object one level deep.
130 |    */
131 |   flatten: function(obj, opt_delimiter) {
132 |     /** @type {!Object} */ var result = {};
133 |     /** @type {string|number} */ var key;
134 |     opt_delimiter = opt_delimiter || '.';
135 | 
136 |     /**
137 |      * @param {!Object} target The target object.
138 |      * @param {string=} opt_prefix The optional key prefix.
139 |      */
140 |     function flatten_(target, opt_prefix) {
141 |       for (key in target) {
142 |         var value = target[key];
143 |         var name = opt_prefix ? opt_prefix + opt_delimiter + key : key;
144 | 
145 |         if (util.Object.isObject(value)) {
146 |           flatten_(value, name);
147 |         } else {
148 |           result[name] = value;
149 |         }
150 |       }
151 |     }
152 | 
153 |     flatten_(obj);
154 |     return result;
155 |   },
156 | 
157 |   isObject: function(obj) {
158 |     return '[object Object]' === util.Object.PROTO.toString.call(obj);
159 |   },
160 | 
161 |   /**
162 |    * Returns a string representation of <code>obj</code> object.
163 |    * @param {!Object} obj The representing object.
164 |    * @return {string} Returns a string representing object.
165 |    * @see util.StringUtils.JSON.stringify
166 |    */
167 |   toString: function(obj) {
168 |     return util.StringUtils.JSON.stringify(obj);
169 |   }
170 | };
171 | 


--------------------------------------------------------------------------------
/src/glize/util/Date.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @fileoverview Date utility methods.
  3 |  *
  4 |  * @see http://google.github.io/styleguide/javascriptguide.xml
  5 |  * @see http://developers.google.com/closure/compiler/docs/js-for-compiler
  6 |  */
  7 | 
  8 | 
  9 | /**
 10 |  * Date utility methods.
 11 |  * @namespace
 12 |  */
 13 | util.Date = {
 14 |   /**
 15 |    * Shortcut for <code>Date</code> constructor.
 16 |    * Used to reduce size after compilation.
 17 |    * @constructor
 18 |    */
 19 |   DateTime: Date,
 20 | 
 21 |   /**
 22 |    * Shortcut for <code>new Date()</code>.
 23 |    * Used to reduce size after compilation.
 24 |    * @return {!Date} Returns current <code>Date</code> object.
 25 |    */
 26 |   getDate: function() {
 27 |     return new util.Date.DateTime;
 28 |   },
 29 | 
 30 |   /**
 31 |    * @return {number} Returns the number of milliseconds elapsed since
 32 |    *                  1 January 1970 00:00:00 UTC.
 33 |    * @see https://es5.github.io/x15.9.html#x15.9.4.4
 34 |    */
 35 |   now: function() {
 36 |     return +util.Date.getDate();
 37 |   },
 38 | 
 39 |   /**
 40 |    * Converts a <code>date</code> object into a string using the ISO standard.
 41 |    * As alternative method {@link formatters.DateFormatter.format} can be used.
 42 |    * @param {!Date} date The date to format.
 43 |    * @return {string} Returns a string in simplified extended ISO format.
 44 |    * @see https://es5.github.io/x15.9.html#x15.9.5.43
 45 |    * @see https://en.wikipedia.org/wiki/ISO_8601
 46 |    * @see formatters.DateFormatter.format
 47 |    * @example
 48 |    * var date = new Date(2013, 5, 15, 13, 30);
 49 |    * var iso = '2013-06-15T13:30:00.000Z';
 50 |    * util.Date.toISOString(date) == iso;
 51 |    * formatters.DateFormatter.format(date, 'YYYY-MM-ddThh:mm:ss.000Z') == iso;
 52 |    */
 53 |   toISOString: function(date) {
 54 |     /** @type {function():string} */ var fn = date['toISOString'];
 55 | 
 56 |     return fn ? fn.call(date) :
 57 |         (1e3 - ~date.getUTCMonth() * 10 + date.toUTCString() + 1e3 + date / 1).
 58 |         replace(/1(..).*?(\d\d)\D+(\d+).(\S+).*(...)/, '$3-$1-$2T$4.$5Z');
 59 |   },
 60 | 
 61 |   /**
 62 |    * Converts 24-hour time string to 12-hour time string.
 63 |    * @param {string} time The time string ("00:30", "01:45", "12:00", "22:15").
 64 |    * @return {string} Return converted 24-hour time string to 12-hour time.
 65 |    * @example
 66 |    * util.Date.toAmPmTime('00:30'); // 12:30 AM
 67 |    * util.Date.toAmPmTime('01:15'); // 1:15 AM
 68 |    * util.Date.toAmPmTime('11:45'); // 11:45 AM
 69 |    * util.Date.toAmPmTime('12:15'); // 12:15 PM
 70 |    * util.Date.toAmPmTime('13:15'); // 1:15 PM
 71 |    * util.Date.toAmPmTime('23:15'); // 11:15 PM
 72 |    */
 73 |   toAmPmTime: function(time) {
 74 |     /** @type {string} */ var hours = time.slice(0, 2);
 75 |     return (hours % 12 || 12) + ':' + time.slice(3, 5) + ' ' +
 76 |            (12 > hours ? 'AM' : 'PM');
 77 |   },
 78 | 
 79 |   /**
 80 |    * Gets week date.
 81 |    * @param {!Date=} opt_date The optional date object.
 82 |    * @return {string} Returns week date in ISO 8601 format.
 83 |    * @see https://en.wikipedia.org/wiki/ISO_8601#Week_dates
 84 |    * @see https://en.wikipedia.org/wiki/ISO_week_date
 85 |    * @example
 86 |    * var weekDate = util.Date.getWeekDate(new Date(2015, 9, 26));
 87 |    * var expected = '2015-W44';
 88 |    * weekDate == expected;
 89 |    */
 90 |   getWeekDate: function(opt_date) {
 91 |     opt_date = opt_date || util.Date.getDate();
 92 |     /** @type {number} */ var number = util.Date.getWeekNumber(opt_date);
 93 |     /** @type {string} */ var week = ('0' + number).slice(-2);
 94 | 
 95 |     return opt_date.getFullYear() + '-W' + week;
 96 |   },
 97 | 
 98 |   /**
 99 |    * Gets week number.
100 |    * @param {!Date=} opt_date The optional date object.
101 |    * @return {number} Returns week number.
102 |    * @see https://en.wikipedia.org/wiki/ISO_8601#Week_dates
103 |    * @see https://en.wikipedia.org/wiki/ISO_week_date
104 |    */
105 |   getWeekNumber: function(opt_date) {
106 |     opt_date = opt_date || util.Date.getDate();
107 |     opt_date.setHours(0, 0, 0, 0);
108 |     opt_date.setDate(opt_date.getDate() + 3 - (opt_date.getDay() + 6) % 7);
109 |     /** @type {!Date} */ var jan4 = new Date(opt_date.getFullYear(), 0, 4);
110 |     /** @type {number} */ var diff = opt_date - jan4;
111 | 
112 |     return 1 + Math.round((diff / 864e5 - 3 + (jan4.getDay() + 6) % 7) / 7);
113 |   },
114 | 
115 |   /**
116 |    * Converts value to Date object.
117 |    * NOTE: Currently supported only ISO 8601 week date format.
118 |    * @param {string} value The value to convert.
119 |    * @return {!Date} Returns converted value to Date object.
120 |    * @see util.Date.getWeekDate
121 |    * @example
122 |    * var date = util.Date.toDate('2015-W44');
123 |    * var str = 'Mon Oct 26 2015 00:00:00 GMT+0200 (EET)';
124 |    * date.toString() == str;
125 |    */
126 |   toDate: function(value) {
127 |     /** @type {?Array.<string>} */
128 |     var weekDate = value.match(/^([12]\d{3})\-w([012345]\d)(\-\d+)*$/i);
129 |     /** @type {number} */ var year;
130 |     /** @type {number} */ var week;
131 |     /** @type {!Date} */ var date;
132 |     /** @type {number} */ var offset;
133 | 
134 |     if (weekDate) {
135 |       year = +weekDate[1];
136 |       week = +weekDate[2];
137 | 
138 |       date = new Date(year, 0, 1 + (week - 1) * 7);
139 |       offset = date.getDay() <= 4 ? 1 : 8;
140 |       date.setDate(date.getDate() - date.getDay() + offset);
141 |     }
142 | 
143 |     return date;
144 |   }
145 | };
146 | 


--------------------------------------------------------------------------------
/src/komito/trackers/dom/links.js:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | 
  4 | /**
  5 |  * Defines <code>komito.trackers.dom.links</code> constructor.
  6 |  * @constructor
  7 |  */
  8 | komito.trackers.dom.Links = function() {
  9 |   /**
 10 |    * Map of social networks.
 11 |    * @type {!Object.<string, string>}
 12 |    */
 13 |   var NETWORKS = {
 14 |     'plus.google.com': 'Google+',
 15 |     'plus.url.google.com': 'Google+',
 16 |     'blogspot.com': 'Blogger',
 17 |     'facebook.com': 'Facebook',
 18 |     'on.fb.me': 'Facebook',
 19 |     'fb.me': 'Facebook',
 20 |     'fb.com': 'Facebook',
 21 |     'twitter.com': 'Twitter',
 22 |     't.co': 'Twitter',
 23 |     'linkedin.com': 'LinkedIn',
 24 |     'myspace.com': 'MySpace',
 25 |     'vk.com': 'VKontakte',
 26 |     'odnoklassniki.ru': 'Odnoklassniki',
 27 |     'xing.com': 'Xing',
 28 |     'youtube.com': 'YouTube',
 29 |     'youtu.be': 'YouTube',
 30 |     'twoo.com': 'Twoo',
 31 |     'reddit.com': 'Reddit',
 32 |     'pinterest.com': 'Pinterest',
 33 |     'digg.com': 'Digg',
 34 |     '4sq.com': 'Foursquare',
 35 |     'foursquare.com': 'Foursquare',
 36 |     'hi.baidu.com': 'Baidu Space'
 37 |   };
 38 | 
 39 |   /** @type {!RegExp} */
 40 |   var HTTP_PATTERN = /^(https?:)?\/\//;
 41 | 
 42 |   /**
 43 |    * Initializes links tracking.
 44 |    * @private
 45 |    */
 46 |   function init_() {
 47 |     /** @type {?NodeList} */ var links = dom.getElementsByTagName(dom.document, 'A');
 48 |     /** @type {number} */ var length = links.length;
 49 |     /** @type {!Element} */ var element;
 50 | 
 51 |     for (; length;) {
 52 |       element = links[--length];
 53 |       if (!komito.DynamicContentTracker.isRegistered(element)) {
 54 |         komito.DynamicContentTracker.register(element);
 55 |         addEventListeners_(/** @type {!HTMLAnchorElement} */ (element));
 56 |       }
 57 |     }
 58 | 
 59 |     komito.DynamicContentTracker.track(init_);
 60 |   }
 61 | 
 62 |   /**
 63 |    * Attaches event listener if passed link is outbound, social or downloadable.
 64 |    * The attached listener sends event to trackers.
 65 |    * @param {!HTMLAnchorElement} link The link element.
 66 |    * @private
 67 |    */
 68 |   function addEventListeners_(link) {
 69 |     /** @type {string} */ var href = getURL_(link);
 70 |     /** @type {boolean} */ var isHttp = HTTP_PATTERN.test(href);
 71 |     /** @type {?Array} */ var match = href.match(komito.EXT_PATTERN);
 72 |     /** @type {string} */ var ext = (match || ['']).pop().toLowerCase();
 73 | 
 74 |     if (komito.config['trackOutbound'] &&
 75 |         isHttp &&
 76 |         !~link.hostname.indexOf(location.hostname))
 77 |       dom.events.addEventListener(
 78 |           link, dom.events.TYPE.MOUSEDOWN, trackOutboundListener_);
 79 | 
 80 |     if (komito.config['trackDownloads'] &&
 81 |         (ext ? ~komito.DOWNLOADS.indexOf(',' + ext + ',') : 0))
 82 |       dom.events.addEventListener(
 83 |           link, dom.events.TYPE.MOUSEDOWN, trackDownloadsListener_);
 84 | 
 85 |     if (komito.config['trackActions'] && !isHttp)
 86 |       dom.events.addEventListener(
 87 |           link, dom.events.TYPE.MOUSEDOWN, trackActionsListener_);
 88 |   }
 89 | 
 90 |   /**
 91 |    * @param {?Event} e The mousedown event.
 92 |    * @private
 93 |    */
 94 |   function trackOutboundListener_(e) {
 95 |     /** @type {!HTMLAnchorElement} */ var link = getLinkEventTarget_(e);
 96 |     /** @type {string} */ var type = 'outbound';
 97 |     /** @type {string} */ var host = link.hostname;
 98 |     /** @type {!Array.<string>} */ var path = link.pathname.split('/');
 99 |     /** @type {string} */ var href = getURL_(link);
100 |     /** @type {string} */ var social = NETWORKS[host.replace(/^www\./, '')];
101 | 
102 |     komito.track(komito.EVENT_ACTION_TYPE, type, host, href);
103 |     if (social) {
104 |       if ('twitter.com' === host.substr(-11) &&
105 |           'intent' === path[path.length - 2])
106 |         type = 'intent-' + path.pop();
107 |       komito.track(komito.SOCIAL_ACTION_TYPE, social, type, href);
108 |     }
109 | 
110 |     dom.events.removeEventListener(
111 |         link, dom.events.TYPE.MOUSEDOWN, trackOutboundListener_);
112 |   }
113 | 
114 |   /**
115 |    * @param {?Event} e The mousedown event.
116 |    * @private
117 |    */
118 |   function trackDownloadsListener_(e) {
119 |     /** @type {!HTMLAnchorElement} */ var link = getLinkEventTarget_(e);
120 |     /** @type {string} */ var href = getURL_(link);
121 |     var type = (href.match(komito.EXT_PATTERN) || ['']).pop().toLowerCase();
122 | 
123 |     komito.track(komito.EVENT_ACTION_TYPE, 'download', type, href);
124 | 
125 |     dom.events.removeEventListener(
126 |         link, dom.events.TYPE.MOUSEDOWN, trackDownloadsListener_);
127 |   }
128 | 
129 |   /**
130 |    * @param {?Event} e The mousedown event.
131 |    * @private
132 |    */
133 |   function trackActionsListener_(e) {
134 |     /** @type {!HTMLAnchorElement} */ var link = getLinkEventTarget_(e);
135 |     /** @type {string} */ var proto = link.protocol.slice(0, -1);
136 |     /** @type {string} */ var href = getURL_(link);
137 | 
138 |     if (!HTTP_PATTERN.test(href)) {
139 |       // 'tel:1234567890'.slice('tel'.length + 1) == '1234567890';
140 |       // 'mailto:hr@dtm.io'.slice('mailto'.length + 1) == 'hr@dtm.io';
141 |       // var type = href.slice(proto.length + 1).split('?')[0];
142 |       komito.track(
143 |           komito.EVENT_ACTION_TYPE, 'cta:' + proto,
144 |           href.slice(proto.length + 1).split('?')[0], href);
145 | 
146 |       dom.events.removeEventListener(
147 |           link, dom.events.TYPE.MOUSEDOWN, trackActionsListener_);
148 |     }
149 |   }
150 | 
151 |   /**
152 |    * @param {?Event} e The mousedown event.
153 |    * @return {!HTMLAnchorElement}
154 |    * @private
155 |    */
156 |   function getLinkEventTarget_(e) {
157 |     /** @type {?Node} */
158 |     var target = /** @type {?Node} */ (dom.events.getEventTarget(e));
159 | 
160 |     while (target && 'A' !== target.tagName) {
161 |       target = target.parentNode;
162 |     }
163 | 
164 |     return /** @type {!HTMLAnchorElement} */ (target);
165 |   }
166 | 
167 |   /**
168 |    * @param {!HTMLAnchorElement} link The link element.
169 |    * @return {string} Returns link URL.
170 |    * @private
171 |    */
172 |   function getURL_(link) {
173 |     return link.href || link.getAttribute('href') || '';
174 |   }
175 | 
176 |   // Initializing links events tracking.
177 |   init_();
178 | };
179 | 


--------------------------------------------------------------------------------
/src/glize/util/StringUtils.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @fileoverview Miscellaneous String utility methods.
  3 |  *
  4 |  * @see http://google.github.io/styleguide/javascriptguide.xml
  5 |  * @see http://developers.google.com/closure/compiler/docs/js-for-compiler
  6 |  */
  7 | 
  8 | 
  9 | /**
 10 |  * Miscellaneous String utility methods.
 11 |  * @namespace
 12 |  */
 13 | util.StringUtils = {
 14 |   /**
 15 |    * Converts HTML to plain text.
 16 |    * @param {string} str The input string.
 17 |    * @return {string} Converted string.
 18 |    * @static
 19 |    */
 20 |   toPlainText: function(str) {
 21 |     return str.replace(/<|>/gm, function(m) {
 22 |       return '&' + ('<' == m ? 'l' : 'g') + 't;';
 23 |     });
 24 |   },
 25 | 
 26 |   /**
 27 |    * Converts <code>obj</code> to query string.
 28 |    * @param {!Object} obj The key-value pairs object.
 29 |    * @param {string=} opt_prefix Optional query prefix.
 30 |    * @return {string} Returns query string or empty string if no parameters
 31 |    *     given.
 32 |    * @static
 33 |    */
 34 |   toQueryString: function(obj, opt_prefix) {
 35 |     /** @type {string} */ var result = opt_prefix || '?';
 36 |     /** @type {string} */ var key;
 37 | 
 38 |     for (key in obj) {
 39 |       result += util.StringUtils.URI.encode(key) + '=' +
 40 |           util.StringUtils.URI.encode(obj[key]) + '&';
 41 |     }
 42 | 
 43 |     return result.slice(0, -1);
 44 |   },
 45 | 
 46 |   /**
 47 |    * Generates a random UUID (v4).
 48 |    * @return {string} Returns generated random UUID.
 49 |    * @link http://en.wikipedia.org/wiki/Universally_unique_identifier
 50 |    * @link http://en.wikipedia.org/wiki/Globally_unique_identifier
 51 |    * @link http://www.ietf.org/rfc/rfc4122.txt
 52 |    * @static
 53 |    */
 54 |   uuid: function() {
 55 |     return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
 56 |       /** @type {number} */ var r = Math.random() * 16 | 0;
 57 |       return ('x' == c ? r : (r & 0x3 | 0x8)).toString(16);
 58 |     });
 59 |   },
 60 | 
 61 |   /**
 62 |    * Converts <code>str</code> to hashed string.
 63 |    * @param {string} str The input string.
 64 |    * @return {string} Returns hashed string.
 65 |    * @static
 66 |    */
 67 |   hash: function(str) {
 68 |     /** @type {number} */ var result = 0;
 69 |     /** @type {number} */ var length = str.length;
 70 |     /** @type {number} */ var j = 0;
 71 |     /** @type {number} */ var i = 0;
 72 | 
 73 |     for (; i < length;) {
 74 |       result ^= str.charCodeAt(i++) << j;
 75 |       j += 8;
 76 |       j %= 24;
 77 |     }
 78 | 
 79 |     return result.toString(36).toUpperCase();
 80 |   },
 81 | 
 82 |   /**
 83 |    * Methods to manipulate with UTF-8 strings.
 84 |    * @type {!Object.<string, function(string): string>}
 85 |    * @static
 86 |    */
 87 |   UTF8: {
 88 |     /**
 89 |      * @param {string} str String to encode.
 90 |      * @return {string} Returns encoded string.
 91 |      * @static
 92 |      */
 93 |     encode: function(str) {
 94 |       return unescape(util.StringUtils.URI.encode(str));
 95 |     },
 96 | 
 97 |     /**
 98 |      * @param {string} str String to decode.
 99 |      * @return {string} Returns decoded string.
100 |      * @static
101 |      */
102 |     decode: function(str) {
103 |       return util.StringUtils.URI.decode(escape(str));
104 |     }
105 |   },
106 | 
107 |   /**
108 |    * Methods to manipulate with URI strings.
109 |    * @type {!Object.<string, function(string): string>}
110 |    * @static
111 |    */
112 |   URI: {
113 |     /**
114 |      * @param {string} str String to encode.
115 |      * @return {string} Returns encoded string.
116 |      * @static
117 |      */
118 |     encode: encodeURIComponent || escape,
119 | 
120 |     /**
121 |      * @param {string} str String to decode.
122 |      * @return {string} Returns decoded string.
123 |      * @static
124 |      */
125 |     decode: decodeURIComponent || unescape
126 |   }
127 | };
128 | 
129 | 
130 | /**
131 |  * Simple implementation of JSON methods.
132 |  * @type {!Object.<string, function(string):string>}
133 |  * @namespace
134 |  */
135 | util.StringUtils.JSON = {
136 |   /**
137 |    * This method parses a JSON text to produce an object or array.
138 |    * @param {string} value String to parse.
139 |    * @return {?Object} Returns parsed object from string.
140 |    */
141 |   parse: function(value) {
142 |     return /** @type {?Object} */ ((dom.context.JSON ?
143 |         JSON.parse(value) : eval('(' + value + ')')) || dom.NULL);
144 |   },
145 | 
146 |   /**
147 |    * This method produces a JSON text from a JavaScript value.
148 |    * @param {*} obj Any JavaScript value, usually an object or array.
149 |    * @return {string} Returns serialized object as string.
150 |    */
151 |   stringify: dom.context.JSON ? JSON.stringify : function(obj) {
152 |     /** @type {string} */ var type = typeof obj;
153 |     /** @type {!Array.<string>} */ var buffer = [];
154 |     /** @type {boolean} */ var isArray;
155 |     /** @type {string} */ var result;
156 |     /** @type {string} */ var key;
157 |     /** @type {string|?Object} */ var value;
158 | 
159 |     if ('object' !== type || dom.NULL === obj) {
160 |       result = 'string' === type ? '"' + obj + '"' : '' + obj;
161 |     } else {
162 |       isArray = util.Array.isArray(obj);
163 |       for (key in obj) {
164 |         value = obj[key];
165 |         type = typeof value;
166 |         if ('string' === type) {
167 |           value = '"' + value + '"';
168 |         } else if ('object' === type && dom.NULL !== value) {
169 |           value = util.StringUtils.JSON.stringify(/** @type {!Object}*/ (value));
170 |         }
171 |         buffer.push((isArray ? '' : '"' + key + '":') + value);
172 |       }
173 | 
174 |       result = (isArray ? '[' : '{') + buffer + (isArray ? ']' : '}');
175 |     }
176 | 
177 |     return result;
178 |   }
179 | };
180 | 
181 | 
182 | /**
183 |  * Converts string to a byte array.
184 |  * @param {string} str The input string.
185 |  * @return {!Array.<number>} Returns byte array.
186 |  */
187 | util.StringUtils.toByteArray = function(str) {
188 |   /** @type {!Array.<number>} */ var result = [];
189 |   /** @type {number} */ var i = 0;
190 |   /** @type {number} */ var length = str.length;
191 | 
192 |   for (; i < length;) {
193 |     /** @type {number} */ var code = str.charCodeAt(i++);
194 |     if (128 > code) {
195 |       result.push(code);
196 |     } else if (2048 > code) {
197 |       result.push((code >> 6) | 192);
198 |       result.push((code & 63) | 128);
199 |     } else if (65535 >= code) {
200 |       result.push((code >> 12) | 224); // 192 + 32
201 |       result.push(((code >> 6) & 63) | 128);
202 |       result.push((code & 63) | 128);
203 |     } else {
204 |       result.push((code >> 18) | 240); // 224 + 16
205 |       result.push(((code >> 12) & 63) | 128);
206 |       result.push(((code >> 6) & 63) | 128);
207 |       result.push((code & 63) | 128);
208 |     }
209 |   }
210 |   return result;
211 | };
212 | 


--------------------------------------------------------------------------------
/src/glize/net/HttpRequest.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @fileoverview Simple implementation of HttpRequest.
  3 |  *
  4 |  * @see http://google.github.io/styleguide/javascriptguide.xml
  5 |  * @see http://developers.google.com/closure/compiler/docs/js-for-compiler
  6 |  */
  7 | 
  8 | 
  9 | 
 10 | /**
 11 |  * The constructor initiates a HttpRequest.
 12 |  * @constructor
 13 |  */
 14 | net.HttpRequest = function() {
 15 |   /**
 16 |    * Performs DELETE request.
 17 |    * @param {string} url The URL to which to send the request.
 18 |    * @param {function(!XMLHttpRequest)} callback A JavaScript function object
 19 |    *     that is called whenever the <code>readyState</code> attribute equals
 20 |    *     to 4 (DONE).
 21 |    * @return {!XMLHttpRequest} Returns instance of XMLHttpRequest.
 22 |    */
 23 |   this.doDelete = function(url, callback) {
 24 |     return doRequest_('DELETE', url, callback);
 25 |   };
 26 | 
 27 |   /**
 28 |    * Performs GET request.
 29 |    * @param {string} url The URL to which to send the request.
 30 |    * @param {function(!XMLHttpRequest)} callback A JavaScript function object
 31 |    *     that is called whenever the <code>readyState</code> attribute equals
 32 |    *     to 4 (DONE).
 33 |    * @param {boolean=} opt_skipRFC Optional, skips RFC 2616 checking.
 34 |    * @return {!XMLHttpRequest} Returns instance of XMLHttpRequest.
 35 |    */
 36 |   this.doGet = function(url, callback, opt_skipRFC) {
 37 |     // @link http://tools.ietf.org/html/rfc2616#section-3.2.1
 38 |     if (!opt_skipRFC && 255 < url.length) {
 39 |       /** @type {!Array} */ var parts = url.split('?');
 40 |       return self_.doPost(parts[0], callback, parts[1]);
 41 |     }
 42 | 
 43 |     return doRequest_('GET', url, callback);
 44 |   };
 45 | 
 46 |   /**
 47 |    * Performs HEAD request.
 48 |    * @param {string} url The URL to which to send the request.
 49 |    * @param {function(!XMLHttpRequest)} callback A JavaScript function object
 50 |    *     that is called whenever the <code>readyState</code> attribute equals
 51 |    *     to 4 (DONE).
 52 |    * @return {!XMLHttpRequest} Returns instance of XMLHttpRequest.
 53 |    */
 54 |   this.doHead = function(url, callback) {
 55 |     return doRequest_('HEAD', url, callback);
 56 |   };
 57 | 
 58 |   /**
 59 |    * Performs POST request.
 60 |    * @param {string} url The URL to which to send the request.
 61 |    * @param {function(!XMLHttpRequest)} callback A JavaScript function object
 62 |    *     that is called whenever the <code>readyState</code> attribute equals
 63 |    *     to 4 (DONE).
 64 |    * @param {?Object|string} data Provides the request entity body.
 65 |    * @return {!XMLHttpRequest} Returns instance of XMLHttpRequest.
 66 |    */
 67 |   this.doPost = function(url, callback, data) {
 68 |     return doRequest_('POST', url, callback, data);
 69 |   };
 70 | 
 71 |   /**
 72 |    * Performs PUT request.
 73 |    * @param {string} url The URL to which to send the request.
 74 |    * @param {function(!XMLHttpRequest)} callback A JavaScript function object
 75 |    *     that is called whenever the <code>readyState</code> attribute equals
 76 |    *     to 4 (DONE).
 77 |    * @param {?Object|string} data Provides the request entity body.
 78 |    * @return {!XMLHttpRequest} Returns instance of XMLHttpRequest.
 79 |    */
 80 |   this.doPut = function(url, callback, data) {
 81 |     return doRequest_('PUT', url, callback, data);
 82 |   };
 83 | 
 84 |   /**
 85 |    * Gets count of active requests.
 86 |    * @return {number} Returns count of active requests.
 87 |    */
 88 |   this.getCount = function() {
 89 |     return net.HttpRequest.count_ || 0;
 90 |   };
 91 | 
 92 |   /**
 93 |    * Performs HTTP request.
 94 |    * @param {string} method The HTTP method to use, such as "GET", "POST",
 95 |    *     "PUT", "DELETE", etc. Ignored for non-HTTP(S) URLs.
 96 |    * @param {string} url The URL to which to send the request.
 97 |    * @param {function(!XMLHttpRequest)} callback A JavaScript function object
 98 |    *     that is called whenever the <code>readyState</code> attribute equals
 99 |    *     to 4 (DONE).
100 |    * @param {string|?Object=} opt_data Provides the request entity body.
101 |    *     If opt_data is Object, request will be sent as application/json.
102 |    * @return {!XMLHttpRequest} Returns instance of XMLHttpRequest.
103 |    * @private
104 |    */
105 |   function doRequest_(method, url, callback, opt_data) {
106 |     url = url.replace(/^\/+/, '/');
107 |     url += (~url.indexOf('?') ? '&' : '?') + 'nocache=' + util.Date.now();
108 |     net.HttpRequest.count_++;
109 | 
110 |     /** @type {!XMLHttpRequest} */
111 |     var req = dom.context.XMLHttpRequest ?
112 |         new XMLHttpRequest : new ActiveXObject('Microsoft.XMLHTTP');
113 |     req.onreadystatechange = function() {
114 |       if (4 === req.readyState) {
115 |         net.HttpRequest.count_--;
116 |         callback(req);
117 |       }
118 |     };
119 |     req.open(method, url, true);
120 |     req.send(prepare_(req, method, opt_data));
121 | 
122 |     return req;
123 |   }
124 | 
125 |   /**
126 |    * Sets request <code>request</code> headers depending to request
127 |    * <code>method</code> and <code>opt_data</code>.
128 |    * @param {!XMLHttpRequest} request The instance of XMLHttpRequest.
129 |    * @param {string} method The HTTP method to use, such as "GET", "POST",
130 |    *     "PUT", "DELETE", etc. Ignored for non-HTTP(S) URLs.
131 |    * @param {string|?Object=} opt_data Provides the request entity body.
132 |    *     If opt_data is Object, request will be sent as application/json.
133 |    * @return {string} Returns modified <code>opt_data</code>.
134 |    * @private
135 |    */
136 |   function prepare_(request, method, opt_data) {
137 |     for (/** @type {string} */ var name in net.HttpRequest.headers_) {
138 |       request.setRequestHeader(name, net.HttpRequest.headers_[name]);
139 |     }
140 | 
141 |     request.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
142 | 
143 |     if (opt_data && typeof opt_data == 'object') {
144 |       request.setRequestHeader('Content-Type',
145 |           'application/json; charset=' + dom.CHARSET);
146 |       opt_data = util.StringUtils.JSON.stringify(
147 |           /** @type {!Object} */ (opt_data));
148 |     } else if (method == 'POST') {
149 |       request.setRequestHeader('Content-Type',
150 |           'application/x-www-form-urlencoded; charset=' + dom.CHARSET);
151 |     }
152 | 
153 |     return /** @type {string} */ (opt_data);
154 |   }
155 | 
156 |   /**
157 |    * The reference to current class instance.
158 |    * Used in private methods and for preventing jslint errors.
159 |    * @type {!net.HttpRequest}
160 |    * @private
161 |    */
162 |   var self_ = this;
163 | 
164 |   /**
165 |    * The count of active requests.
166 |    * @static
167 |    * @type {number}
168 |    * @see net.HttpRequest#getCount
169 |    * @private
170 |    */
171 |   net.HttpRequest.count_ = net.HttpRequest.count_ || 0;
172 | };
173 | 
174 | 
175 | /**
176 |  * @static
177 |  * @type {!Object.<string, string>}
178 |  * @see net.HttpRequest.setRequestHeader
179 |  * @private
180 |  */
181 | net.HttpRequest.headers_ = {};
182 | 
183 | 
184 | /**
185 |  * Sets custom header.
186 |  * @param {string} name The header name.
187 |  * @param {string} value The header value.
188 |  * @static
189 |  */
190 | net.HttpRequest.setRequestHeader = function(name, value) {
191 |   net.HttpRequest.headers_[name] = value;
192 | };
193 | 


--------------------------------------------------------------------------------
/src/glize/util/Array.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @fileoverview Array utility methods.
  3 |  *
  4 |  * @see http://google.github.io/styleguide/javascriptguide.xml
  5 |  * @see http://developers.google.com/closure/compiler/docs/js-for-compiler
  6 |  */
  7 | 
  8 | 
  9 | /**
 10 |  * Array utility methods.
 11 |  * @namespace
 12 |  */
 13 | util.Array = {
 14 |   /**
 15 |    * Reference to <code>Array.prototype.slice</code>.
 16 |    * Used to reduce size after compilation.
 17 |    * @type {function(number=, number=): !Array}
 18 |    * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.10
 19 |    */
 20 |   slice: Array.prototype.slice,
 21 | 
 22 |   /**
 23 |    * Searches the array for the specified element, and returns its position.
 24 |    * @param {!Arguments|!Array|!NodeList|string} obj The array-like object.
 25 |    * @param {*} element The element to locate in the array.
 26 |    * @param {number=} opt_fromIndex The optional index to start the search at.
 27 |    * @return {number} Returns the first index at which a given element can be
 28 |    *                  found in the array, or -1 if it is not present.
 29 |    * @see https://es5.github.io/#x15.4.4.14
 30 |    */
 31 |   indexOf: function(obj, element, opt_fromIndex) {
 32 |     opt_fromIndex = opt_fromIndex | 0;
 33 | 
 34 |     /** @type {!Array} */ var list = util.Array.toArray(obj);
 35 |     /** @type {number} */ var length = list.length;
 36 |     /** @type {function(*, number=): number} */ var fn = list.indexOf;
 37 |     /** @type {number} */ var result = fn ?
 38 |         fn.call(list, element, opt_fromIndex) : -1;
 39 | 
 40 |     if (!fn) {
 41 |       for (; opt_fromIndex < length && !~result; opt_fromIndex++) {
 42 |         result = list[opt_fromIndex] === element ? opt_fromIndex : result;
 43 |       }
 44 |     }
 45 | 
 46 |     return result;
 47 |   },
 48 | 
 49 |   /**
 50 |    * Determines whether an object is an array.
 51 |    * @param {*} obj The object to be checked.
 52 |    * @return {boolean} Returns <code>true</code> if an object is an
 53 |    *                   array, <code>false</code> if it is not.
 54 |    * @see https://es5.github.io/#x15.4.3.2
 55 |    */
 56 |   isArray: function(obj) {
 57 |     /** @type {function(*):boolean} */ var fn = Array['isArray'];
 58 | 
 59 |     return fn ?
 60 |         fn(obj) : '[object Array]' === Object.prototype.toString.call(obj);
 61 |   },
 62 | 
 63 |   /**
 64 |    * Creates a new array with all elements that pass the test implemented
 65 |    * by the provided function.
 66 |    * @param {!Arguments|!Array|!NodeList|string} obj The array-like object.
 67 |    * @param {function(*, number, !Array):boolean} callback The callback function
 68 |    * @param {?Object=} opt_context The optional context object.
 69 |    * @return {!Array} Returns filtered array.
 70 |    * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.20
 71 |    */
 72 |   filter: function(obj, callback, opt_context) {
 73 |     /** @type {!Array} */ var list = util.Array.toArray(obj);
 74 |     /** @type {number} */ var length = list.length;
 75 |     /** @type {number} */ var i = 0;
 76 |     /** @type {number} */ var j = 0;
 77 |     /** @type {function(!Function, ?Object=): !Array} */ var fn = list.filter;
 78 |     /** @type {!Array} */ var result = fn ?
 79 |         fn.call(list, callback, opt_context) : [];
 80 |     /** @type {*} */ var element;
 81 | 
 82 |     if (!fn) {
 83 |       for (; i < length;) {
 84 |         element = list[i++];
 85 |         if (callback.call(opt_context, element, i, list)) {
 86 |           result[j++] = element;
 87 |         }
 88 |       }
 89 |     }
 90 | 
 91 |     return result;
 92 |   },
 93 | 
 94 |   /**
 95 |    * Creates a new array with the results of calling a provided function on
 96 |    * every element in this array.
 97 |    * @param {!Arguments|!Array|!NodeList|string} obj The array-like object.
 98 |    * @param {function(*, number, !Array):*} callback The callback function.
 99 |    * @param {?Object=} opt_context The optional context object.
100 |    * @return {!Array} Returns filtered array.
101 |    * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.19
102 |    */
103 |   map: function(obj, callback, opt_context) {
104 |     /** @type {!Array} */ var list = util.Array.toArray(obj);
105 |     /** @type {number} */ var length = list.length;
106 |     /** @type {number} */ var i = 0;
107 |     /** @type {function(!Function, ?Object=): !Array} */ var fn = list.map;
108 |     /** @type {!Array} */ var result = fn ?
109 |         fn.call(list, callback, opt_context) : new Array(length);
110 | 
111 |     if (!fn) {
112 |       for (; i < length;) {
113 |         result[i] = callback.call(opt_context, list[i], i++, list);
114 |       }
115 |     }
116 | 
117 |     return result;
118 |   },
119 | 
120 |   /**
121 |    * Executes a provided function once per array element.
122 |    * @param {!Arguments|!Array|!NodeList|string} obj The array-like object.
123 |    * @param {function(*, number, !Array): *} callback The callback function.
124 |    * @param {?Object=} opt_context The optional context object.
125 |    * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18
126 |    */
127 |   forEach: function(obj, callback, opt_context) {
128 |     /** @type {!Array} */ var list = util.Array.toArray(obj);
129 |     /** @type {number} */ var length = list.length;
130 |     /** @type {number} */ var i = 0;
131 |     /** @type {function(!Function, ?Object=)} */ var fn = list.forEach;
132 | 
133 |     if (fn) {
134 |       fn.call(list, callback, opt_context);
135 |     } else {
136 |       for (; i < length;) {
137 |         callback.call(opt_context, list[i], i++, list);
138 |       }
139 |     }
140 |   },
141 | 
142 |   /**
143 |    * Calls the specified <code>callback</code> function for all the elements
144 |    * in an array-like object <code>obj</code>.
145 |    * @param {!Arguments|!Array|!NodeList|string} obj The array-like object.
146 |    * @param {function(*, *, number, !Array): *} callback The callback function.
147 |    * @param {*=} opt_initial The initial value to use as the first argument
148 |    *     to the first call of the <code>callback</code>.
149 |    * @return {*} Returns accumulated result from the last call to
150 |    *     the <code>callback</code> function.
151 |    * @see http://es5.github.io/#x15.4.4.21
152 |    */
153 |   reduce: function(obj, callback, opt_initial) {
154 |     /** @type {!Array} */ var list = util.Array.toArray(obj);
155 |     /** @type {number} */ var length = list.length;
156 |     /** @type {number} */ var i = arguments.length > 2 ? 0 : 1;
157 |     /** @type {function(!Function, *=): *} */ var fn = list.reduce;
158 | 
159 |     if (fn) {
160 |       opt_initial = fn.call(list, callback, opt_initial);
161 |     } else {
162 |       opt_initial = i ? list[0] : opt_initial;
163 |       for (; i < length;) {
164 |         opt_initial = callback(opt_initial, list[i], i++, list);
165 |       }
166 |     }
167 | 
168 |     return opt_initial;
169 |   },
170 | 
171 |   /**
172 |    * Checks if array contains the given element.
173 |    * @param {!Array} arr The array to test for the presence of the element.
174 |    * @param {*} element The element to search.
175 |    * @return {boolean} Returns <code>true</code> if element is present.
176 |    */
177 |   contains: function(arr, element) {
178 |     return 0 <= util.Array.indexOf(arr, element);
179 |   },
180 | 
181 |   /**
182 |    * Gets random element from array.
183 |    * @param {!Arguments|!Array|!NodeList|string} obj The array-like object.
184 |    * @return {*} Returns random element from array <code>obj</code>.
185 |    */
186 |   random: function(obj) {
187 |     /** @type {!Array} */ var list = util.Array.toArray(obj);
188 |     return list[Math.random() * list.length | 0];
189 |   },
190 | 
191 |   /**
192 |    * Converts object <code>obj</code> to <code>Array</code>.
193 |    * @param {!Arguments|!Array|!NodeList|string} obj The array-like object.
194 |    * @return {!Array} Returns <code>obj</code> converted to <code>Array</code>.
195 |    */
196 |   toArray: function(obj) {
197 |     return util.Array.isArray(obj) ?
198 |         /** @type {!Array} */ (obj) : util.Array.slice.call(obj);
199 |   }
200 | };
201 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "{}"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright {yyyy} {name of copyright owner}
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 
203 | 


--------------------------------------------------------------------------------
/src/komito/__ns__.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @fileoverview Komito Analytics is an enhancement for the most popular
  3 |  * analytics software. It unlocks power of digital analytics with additional
  4 |  * insights about visitor's behavior.
  5 |  *
  6 |  * @link http://google.github.io/styleguide/javascriptguide.xml
  7 |  * @link http://developers.google.com/closure/compiler/docs/js-for-compiler
  8 |  *
  9 |  * @link http://developers.google.com/analytics/devguides/collection/gajs
 10 |  * @link http://developers.google.com/analytics/devguides/collection/analyticsjs
 11 |  * @link http://tongji.baidu.com/open/api/more?p=ref_trackEvent
 12 |  *
 13 |  * Include script before closing <code>&lt;/body&gt;</code> tag.
 14 |  * <code>
 15 |  *   &lt;script src="//komito.net/komito.js"&gt;&lt;/script&gt;
 16 |  * </code>
 17 |  */
 18 | 
 19 | 
 20 | /**
 21 |  * Defines <code>komito</code> namespace.
 22 |  * @namespace
 23 |  */
 24 | var komito = {
 25 |   /**
 26 |    * Default tracking options.
 27 |    * @type {!Object.<string, !Array|!Function|number|string>}
 28 |    * @see komito.config
 29 |    */
 30 |   DEFAULTS: {
 31 |     'gtag': 1, // GA4 by default
 32 |     'trackTwitter': 1,
 33 |     'trackFacebook': 1,
 34 |     'trackLinkedIn': 1,
 35 |     'trackDownloads': 1,
 36 |     'trackOutbound': 1,
 37 |     'trackForms': 1,
 38 |     'trackUsers': 1,
 39 |     'trackActions': 1,
 40 |     'trackPrint': 1,
 41 |     'trackMedia': 1,
 42 |     'trackScroll': 1,
 43 |     'trackOrientation': 1,
 44 |     'trackColorScheme': 1,
 45 |     'nonInteraction': [
 46 |       'adblock', 'audio', 'color-scheme', 'form', 'heartbeat', 'orientation',
 47 |       'print', 'scroll', 'video'],
 48 |     'debugMode': /[?&]debug=1/.test(location.search)
 49 |     // 'trackAdblock': 0, // Experimental feature.
 50 |     // 'trackErrorPages': 0, // Experimental feature.
 51 |     // 'sendHeartbeat': 0, // Experimental feature.
 52 |     // 'trackingIds': ['List of tracking Ids'],
 53 |     // 'onBeforeTrack': function(event) {},
 54 |     // 'propIndex': 0,
 55 |     // 'trackDynamicContent': 0
 56 |   },
 57 | 
 58 |   /**
 59 |    * List of file extensions treated as downloadable.
 60 |    * @const {string}
 61 |    */
 62 |   DOWNLOADS: ',mp3,mp4,wma,mov,avi,wmv,mkv' + // Media
 63 |       ',eot,woff,ttf' +                       // Fonts
 64 |       ',txt,csv,tsv' +                        // Text
 65 |       ',pdf,doc,docx,xls,xlsx,ppt,pptx' +     // Docs
 66 |       ',zip,tar,tgz,bz2,gz,rar,dmg,pkg,7z' +  // Archives
 67 |       ',ida,exe,sh,bat,',                     // Other
 68 | 
 69 |   /**
 70 |    * File extension pattern.
 71 |    * @const {!RegExp}
 72 |    */
 73 |   EXT_PATTERN: /\.([0-9a-z]+)(?:[\?#]|$)/i,
 74 | 
 75 |   /**
 76 |    * @type {string}
 77 |    */
 78 |   GA_KEY: dom.context['GoogleAnalyticsObject'] || 'ga',
 79 | 
 80 |   /**
 81 |    * @const {number}
 82 |    */
 83 |   EVENT_ACTION_TYPE: 0,
 84 | 
 85 |   /**
 86 |    * @const {number}
 87 |    */
 88 |   SOCIAL_ACTION_TYPE: 1,
 89 | 
 90 |   /**
 91 |    * Sign of registered HTML element.
 92 |    * Used to track dynamic content to avoid adding event listeners twice.
 93 |    * @const {string}
 94 |    */
 95 |   REGISTERED_ELEMENT_KEY: 'data-kmt',
 96 | 
 97 |   /**
 98 |    * Performs trackers function execution.
 99 |    * @param {...*} var_args
100 |    *
101 |    * _gaq.push(['_trackEvent', category, action, opt_label, opt_value]);
102 |    * ga('send', 'event', category, action, opt_label, opt_value);
103 |    * __utmTrackEvent(category, action, opt_label, opt_value);
104 |    * ClickTaleEvent('category:action:opt_label:opt_value');
105 |    * _hmt.push(['_trackEvent', category, action, opt_label, opt_value]);
106 |    *
107 |    * _gaq.push(['_trackSocial', network, action, target]);
108 |    * ga('send', 'social', network, action, target);
109 |    * __utmTrackEvent('social:action', network, target);
110 |    * ClickTaleEvent('social:action:network:target');
111 |    * _hmt.push(['_trackEvent', 'social:action', network, target]);
112 |    */
113 |   track: function(var_args) {
114 |     /** @type {?Array} */ var args = komito.getTrackingData_(
115 |         util.Array.toArray(arguments));
116 |     /** @type {!Array} */ var argv;
117 | 
118 |     if (args) {
119 |       komito.config['gtag'] ? komito.sendGtag_(args) : komito.sendGa_(args);
120 |       komito.sendTagLoader_(args);
121 |       argv = komito.convert_(args);
122 |       komito.send_([dom.context], 'ClickTaleEvent', [argv.join(':')]);
123 |       komito.send_([dom.context], '__utmTrackEvent', argv);
124 |       dom.context['_hmt'] && komito.send_(
125 |           [dom.context['_hmt']], 'push', [['_trackEvent'].concat(argv)]);
126 |       komito.sendClassicGa_(args);
127 |       komito.sendYm_(args);
128 |     }
129 |   },
130 | 
131 |   /**
132 |    *
133 |    */
134 |   DynamicContentTracker: {
135 |     /**
136 |      * @param {!Function} listener The dynamic content listener.
137 |      */
138 |     track: function(listener) {
139 |       if (komito.config['trackDynamicContent']) {
140 |         /** @type {number} */ var timer = setTimeout(function() {
141 |           timer && clearTimeout(timer);
142 |           listener();
143 |         }, 1E3);
144 |       }
145 |     },
146 | 
147 |     /**
148 |      * @param {!Element} element An HTML element.
149 |      */
150 |     register: function(element) {
151 |       element.setAttribute(komito.REGISTERED_ELEMENT_KEY, 1);
152 |     },
153 | 
154 |     /**
155 |      * @param {!Element} element An HTML element.
156 |      * @return {boolean} Returns 'true' if the element is registered.
157 |      */
158 |     isRegistered: function(element) {
159 |       return element.hasAttribute(komito.REGISTERED_ELEMENT_KEY);
160 |     }
161 |   },
162 | 
163 |   /**
164 |    * Marks event as a non-interaction event.
165 |    * @param {string} event The event name to mark as non-interaction event.
166 |    * @see https://support.google.com/analytics/answer/1033068#NonInteractionEvents
167 |    * @see https://github.com/Datamart/Komito/issues/38
168 |    */
169 |   markAsNonInteractionEvent: function(event) {
170 |     var events = /** @type {?Array} */ (komito.config['nonInteraction']);
171 |     if (events && util.Array.isArray(events) && !util.Array.contains(events, event)) {
172 |       events.push(event);
173 |     }
174 |   },
175 | 
176 |   /**
177 |    * Initializes extension.
178 |    * @private
179 |    */
180 |   init_: function() {
181 |     if (!komito.initialized_) {
182 |       komito.initialized_ = 1; // Initialize Komito Analytics only once.
183 |       /** @type {string} */ var key = dom.document.readyState;
184 | 
185 |       function ready() {
186 |         komito.config = dom.context['_komito'] || {};
187 | 
188 |         for (key in komito.DEFAULTS) {
189 |           if (!(key in komito.config)) {
190 |             komito.config[key] = komito.DEFAULTS[key];
191 |           }
192 |         }
193 | 
194 |         komito.trackers.dom.init();
195 |         komito.trackers.media.init();
196 |         komito.trackers.social.init();
197 |       }
198 | 
199 |       'interactive' === key || 'complete' === key ?
200 |           setTimeout(ready, 1E3) :
201 |           dom.events.addEventListener(dom.context, 'DOMContentLoaded', ready);
202 |     }
203 |   },
204 | 
205 |   /**
206 |    * Performs Adobe Tag Loader execution.
207 |    * @param {!Array} args The arguments to send.
208 |    * @private
209 |    */
210 |   sendTagLoader_: function(args) {
211 |     /** @type {number} */ var index = +komito.config['propIndex'] || 0;
212 |     /** @type {?Function} */ var loader = dom.context['TagLoader'] ||
213 |                                           dom.context['AppMeasurement'];
214 |     /** @type {?Object} */ var tracker = dom.context['s'];
215 |     /** @type {!Array} */ var vars = [];
216 |     /** @type {number} */ var i = 1;
217 |     /** @type {string} */ var key;
218 | 
219 |     if (loader && tracker && (tracker instanceof loader)) {
220 |       for (; i < args.length; i++) {
221 |         key = 'prop' + (i + index);
222 |         vars.push(key);
223 |         tracker[key] = args[i];
224 |       }
225 | 
226 |       tracker['linkTrackEvents'] = 'None';
227 |       tracker['linkTrackVars'] = vars.join(',');
228 |       komito.send_(
229 |           [tracker], 'tl', // 'tl' is 'trackLink' method.
230 |           [tracker, 'download' === args[1] ? 'd' : 'o', args[0]]);
231 |     }
232 |   },
233 | 
234 |   /**
235 |    * Performs Google Analytics execution.
236 |    * @param {!Array} args The arguments to send.
237 |    * @private
238 |    */
239 |   sendGa_: function(args) {
240 |     if ('function' === typeof dom.context[komito.GA_KEY]) {
241 |       /** @type {?Array.<!Object>} */ var trackers =
242 |           dom.context[komito.GA_KEY]['getAll'] &&
243 |           dom.context[komito.GA_KEY]['getAll']();
244 |       /** @type {*} */ var trackingIds = komito.config['trackingIds'];
245 |       /** @type {!Object.<string, boolean>} */ var uniques = {};
246 | 
247 |       if (trackers && trackingIds) {
248 |         if (!util.Array.isArray(trackingIds)) {
249 |           trackingIds = ['' + trackingIds];
250 |         }
251 | 
252 |         trackers = util.Array.filter(
253 |             /** @type {!Array.<!Object>} */ (trackers), function(tracker) {
254 |               /** @type {string} */
255 |               var trackingId = tracker['get']('trackingId');
256 |               /** @type {boolean} */ var result = util.Array.contains(
257 |                   /** @type {!Array} */ (trackingIds), trackingId);
258 | 
259 |               return result;
260 |             });
261 |       }
262 | 
263 |       trackers = util.Array.filter(
264 |           /** @type {!Array.<!Object>} */ (trackers), function(tracker) {
265 |             /** @type {string} */ var trackingId = tracker['get']('trackingId');
266 |             /** @type {boolean} */ var result = !uniques[trackingId];
267 |             uniques[trackingId] = true;
268 |             return result;
269 |           });
270 | 
271 |       var data = komito.isNonInteraction_(args) ?
272 |           args.concat([{'nonInteraction': 1}]) : args;
273 |       trackers && komito.send_(trackers, 'send', data);
274 |     }
275 |   },
276 | 
277 |   /**
278 |    * Sends Google Analytics Events using gtag.js
279 |    * @param {!Array} args The arguments to send.
280 |    * @private
281 |    * @see https://developers.google.com/analytics/devguides/collection/gtagjs/events
282 |    * @see https://developers.google.com/gtagjs/reference/event
283 |    */
284 |   sendGtag_: function(args) {
285 |     /** @type {?Array} */ var dataLayer = dom.context['dataLayer'];
286 | 
287 |     if (util.Array.isArray(dataLayer) && dataLayer.length > 0) {
288 |       /** @type {string} */ var type = args[0];
289 |       /** @type {string} */ var action = args[2];
290 |       /** @type {!Function} */ var gtag = function() {dataLayer.push(arguments);};
291 | 
292 |       // Social: ['social', 'network', 'action', 'target']
293 |       // Event: ['event', 'category', 'action', 'label']
294 |       if ('social' === type && action === 'share') {
295 |         gtag('event', action, {
296 |           'method' : args[1],
297 |           'target': args[3],
298 |           'social_target': args[3]
299 |         });
300 |       } else {
301 |         gtag('event', action, {
302 |           'event_category': args[1],
303 |           'event_label': args[3],
304 |           'non_interaction': komito.isNonInteraction_(args)
305 |         });
306 |       }
307 |     } else {
308 |       komito.sendGa_(args);
309 |     }
310 |   },
311 | 
312 |   /**
313 |    * Performs Classic Google Analytics execution.
314 |    * @param {!Array} args The arguments to send.
315 |    * @private
316 |    */
317 |   sendClassicGa_: function(args) {
318 |     if (dom.context['_gat'] || dom.context['_gaq']) {
319 |       /** @type {?Array.<!Object>} */
320 |       var trackers = dom.context['_gat'] &&
321 |                      dom.context['_gat']['_getTrackers'] &&
322 |                      dom.context['_gat']['_getTrackers']();
323 |       var data = komito.isNonInteraction_(args) ? args.concat([1]) : args;
324 |       data[0] = ({'social': '_trackSocial', 'event': '_trackEvent'})[data[0]];
325 | 
326 |       if (trackers) {
327 |         komito.send_(trackers, data[0], data.slice(1));
328 |       } else if (dom.context['_gaq']) {
329 |         komito.send_([dom.context['_gaq']], 'push', [data]);
330 |       }
331 |     }
332 |   },
333 | 
334 |   /**
335 |    * Performs Yandex Metrica execution.
336 |    * @param {!Array} args The arguments to send.
337 |    * @see https://yandex.com/support/metrica/objects/_method-reference.html
338 |    * @see https://yandex.com/support/metrica/objects/extlink.html
339 |    * @see https://yandex.com/support/metrica/objects/file.html
340 |    * @private
341 |    */
342 |   sendYm_: function(args) {
343 |     /** @type {!Array.<!Object>} */ var trackers = [];
344 |     /** @type {string} */ var func = 'params';
345 |     /** @type {string} */ var key;
346 | 
347 |     for (key in dom.context) {
348 |       if (0 == key.indexOf('yaCounter')) {
349 |         trackers.push(dom.context[key]);
350 |       }
351 |     }
352 | 
353 |     key = args[1];
354 |     if ('outbound' === key) {
355 |       func = 'extLink';
356 |       args = [args.pop()]; // Outbound link URL.
357 |     } else if ('download' === key) {
358 |       func = 'file';
359 |       args = [args.pop()]; // URL of downloaded file.
360 |     }
361 | 
362 |     komito.send_(trackers, func, args);
363 |   },
364 | 
365 |   /**
366 |    * @param {!Array} trackers The list of trackers.
367 |    * @param {string} func The function name.
368 |    * @param {!Array} args The func arguments.
369 |    * @private
370 |    */
371 |   send_: function(trackers, func, args) {
372 |     /** @type {number} */ var length = trackers.length;
373 |     /** @type {?Object} */ var tracker;
374 | 
375 |     komito.debug_(func, args);
376 |     for (; length;) {
377 |       tracker = trackers[--length];
378 |       if ('function' === typeof tracker[func])
379 |         tracker[func].apply(tracker, args);
380 |     }
381 |   },
382 | 
383 |   /**
384 |    * Converts 'social' interaction to 'event'.
385 |    * @param {!Array} args The arguments to convert.
386 |    * @return {!Array} Returns converted arguments.
387 |    * @private
388 |    */
389 |   convert_: function(args) {
390 |     /** @type {!Array} */ var argv = [].concat(args);
391 | 
392 |     if ('social' === argv[0]) {
393 |       // from: ['social', 'network', 'action', 'target']
394 |       // to: ['social', 'social:action', 'network', 'target']
395 |       argv[1] = 'social' + ':' + argv.splice(2, 1, argv[1])[0];
396 |     }
397 | 
398 |     return argv.slice(1);
399 |   },
400 | 
401 |   /**
402 |    * @param {...*} var_args Arguments to log.
403 |    * @private
404 |    */
405 |   debug_: function(var_args) {
406 |     /** @type {?Console} */ var logger = dom.context.console;
407 |     if (komito.config['debugMode'] && logger)
408 |       logger.log.apply(logger, arguments);
409 |   },
410 | 
411 |   /**
412 |    * @param {!Array} args The arguments to send.
413 |    * @return {boolean} Return 'true' if is non interaction event.
414 |    * @private
415 |    */
416 |   isNonInteraction_: function(args) {
417 |     var type = args[1]; // video:html5, cta:mailto, color-scheme, scroll.
418 |     var list = /** @type {!Array} */ (komito.config['nonInteraction']);
419 |     return util.Array.contains(list, type) ||
420 |            util.Array.contains(list, type.split(/\W/)[0]);
421 |   },
422 | 
423 |   /**
424 |    * Prepares data to send to the trackers.
425 |    * @param {!Array} args The arguments to prepare.
426 |    * @return {?Array} Returns prepared arguments.
427 |    * @private
428 |    */
429 |   getTrackingData_: function(args) {
430 |     args[0] = args[0] ? 'social' : 'event'; // Action type: 1 or 0;
431 | 
432 |     /** @type {boolean} */ var hasData = true;
433 |     /** @type {!Object.<string, *>} */ var data = {
434 |       'type': args[0],
435 |       'category': args[1],
436 |       'action': args[2],
437 |       'label': args[3],
438 |       'preventDefault': function() {
439 |         hasData = false;
440 |       }
441 |     };
442 | 
443 |     komito.config['onBeforeTrack'] &&
444 |         /** @type {!Function}*/ (komito.config['onBeforeTrack'])(data);
445 | 
446 |     return hasData ?
447 |         [data['type'], data['category'], data['action'], data['label']] :
448 |         dom.NULL;
449 |   },
450 | 
451 |   /**
452 |    * The configuration options.
453 |    * @type {!Object.<string, !Array|!Function|number|string>}
454 |    * @see komito.DEFAULTS
455 |    * @see komito.init_
456 |    */
457 |   config: {}
458 | };
459 | 
460 | 'web.archive.org' !== location.hostname && komito.init_();
461 | 


--------------------------------------------------------------------------------
/src/glize/dom/__ns__.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @fileoverview Defines <code>dom</code> namespace.
  3 |  *
  4 |  * @see http://google.github.io/styleguide/javascriptguide.xml
  5 |  * @see http://developers.google.com/closure/compiler/docs/js-for-compiler
  6 |  */
  7 | 
  8 | 
  9 | /**
 10 |  * Defines <code>dom</code> namespace.
 11 |  * @namespace
 12 |  */
 13 | var dom = dom || {};
 14 | 
 15 | 
 16 | /**
 17 |  * Defines <code>dom.events</code> namespace.
 18 |  * @namespace
 19 |  */
 20 | dom.events = dom.events || {};
 21 | 
 22 | 
 23 | /**
 24 |  * Defines <code>dom.scripts</code> namespace.
 25 |  * @namespace
 26 |  */
 27 | dom.scripts = dom.scripts || {};
 28 | 
 29 | 
 30 | /**
 31 |  * Defines <code>dom.css</code> namespace.
 32 |  * @namespace
 33 |  */
 34 | dom.css = dom.css || {};
 35 | 
 36 | 
 37 | /**
 38 |  * Reference to the <code>document</code> object.
 39 |  * Used to reduce size after compilation.
 40 |  * @type {!Document}
 41 |  */
 42 | dom.document = document;
 43 | 
 44 | 
 45 | /**
 46 |  * Reference to the <code>window</code> object.
 47 |  * Used to reduce size after compilation.
 48 |  * @type {!Window}
 49 |  */
 50 | dom.context = window;
 51 | 
 52 | 
 53 | /**
 54 |  * Reference to the <code>navigator</code> object.
 55 |  * Used to reduce size after compilation.
 56 |  * @type {!Navigator}
 57 |  */
 58 | dom.device = navigator;
 59 | 
 60 | 
 61 | /**
 62 |  * Defines default document charset.
 63 |  * @type {string}
 64 |  * @const
 65 |  */
 66 | dom.CHARSET = (dom.document.charset ||
 67 |                dom.document.characterSet ||
 68 |                'utf-8').toLowerCase();
 69 | 
 70 | 
 71 | /**
 72 |  * The "null" shortcut.
 73 |  */
 74 | dom.NULL = null;
 75 | 
 76 | 
 77 | /**
 78 |  * Alias of W3C <code>document.createElement</code>.
 79 |  * Used to reduce size after compilation.
 80 |  * @param {string} tagName Tag name.
 81 |  * @return {?Element} Returns created element.
 82 |  * @static
 83 |  */
 84 | dom.createElement = function(tagName) {
 85 |   return tagName ? dom.document.createElement(tagName) : dom.NULL;
 86 | };
 87 | 
 88 | 
 89 | /**
 90 |  * Alias of W3C <code>document.getElementById</code>.
 91 |  * Used to reduce size after compilation.
 92 |  * @param {string} id A case-sensitive string representing the unique ID of the
 93 |  *     element being sought.
 94 |  * @return {?Element} Returns reference to an Element object, or null if an
 95 |  *     element with the specified ID is not in the document.
 96 |  * @static
 97 |  */
 98 | dom.getElementById = function(id) {
 99 |   return id ? dom.document.getElementById(id) : dom.NULL;
100 | };
101 | 
102 | 
103 | /**
104 |  * Alias of W3C <code>element.getElementsByTagName</code>.
105 |  * Used to reduce size after compilation.
106 |  * @param {!Element|!Node} element Element to search tags.
107 |  * @param {string} tagName Tag name.
108 |  * @return {?NodeList} Returns list of found elements in the
109 |  *     order they appear in the tree.
110 |  * @static
111 |  */
112 | dom.getElementsByTagName = function(element, tagName) {
113 |   return element && element.getElementsByTagName(tagName);
114 | };
115 | 
116 | 
117 | /**
118 |  * Alias of W3C <code>element.getElementsByClassName</code>.
119 |  * Used to reduce size after compilation.
120 |  * @param {!Element|!Node} element Element to start searching.
121 |  * @param {string} className Class name to match.
122 |  * @return {!Array.<!Node>|?NodeList} Array of found elements.
123 |  * @static
124 |  */
125 | dom.getElementsByClassName = function(element, className) {
126 |   if (element.getElementsByClassName) {
127 |     return element.getElementsByClassName(className);
128 |   }
129 | 
130 |   if (element.querySelectorAll) {
131 |     return element.querySelectorAll('.' + className);
132 |   }
133 | 
134 |   /** @type {!RegExp} */ var re = new RegExp('(?:^|\\s)' + className + '(?!\\S)');
135 |   /** @type {!Array.<!Node>} */ var result = [];
136 |   /** @type {?NodeList} */ var nodes = dom.getElementsByTagName(element, '*');
137 |   /** @type {number} */ var i = 0;
138 | 
139 |   for (; i < nodes.length; ++i) {
140 |     if (re.test(nodes[i].className)) {
141 |       result.push(nodes[i]);
142 |     }
143 |   }
144 | 
145 |   return result;
146 | };
147 | 
148 | 
149 | /**
150 |  * Alias of W3C <code>element.querySelectorAll</code>.
151 |  * Used to reduce size after compilation.
152 |  * @param {!Element|!DocumentFragment} element Element to start searching.
153 |  * @param {string} selectors One or more CSS selectors separated by commas.
154 |  * @return {?NodeList} Returns a list of the elements within the document that
155 |  *     match the specified group of selectors.
156 |  * @see https://www.w3.org/TR/selectors-api/#queryselectorall
157 |  * @static
158 |  */
159 | dom.querySelectorAll = function(element, selectors) {
160 |   return element && element.querySelectorAll(selectors);
161 | };
162 | 
163 | 
164 | /**
165 |  * Alias of W3C <code>element.querySelector</code>.
166 |  * Used to reduce size after compilation.
167 |  * @param {!Element|!DocumentFragment} element Element to start searching.
168 |  * @param {string} selectors One or more CSS selectors separated by commas.
169 |  * @return {?Element} Returns the first element that is a descendant of the
170 |  *     element on which it is invoked that matches the specified group of
171 |  *     selectors.
172 |  * @see https://www.w3.org/TR/selectors-api/#queryselector
173 |  * @static
174 |  */
175 | dom.querySelector = function(element, selectors) {
176 |   return element && element.querySelector(selectors);
177 | };
178 | 
179 | 
180 | /**
181 |  * Alias of W3C <code>element.getBoundingClientRect</code>.
182 |  * Used to reduce size after compilation.
183 |  * @param {?Element} element Element for calculating bounding rect.
184 |  * @return {!Object} Returns dict {top, left, width, height, right, bottom}.
185 |  * @static
186 |  */
187 | dom.getBoundingClientRect = function(element) {
188 |   /** @type {!Object|?ClientRect} */ var rect;
189 | 
190 |   if (element) {
191 |     rect = element.getBoundingClientRect && element.getBoundingClientRect();
192 |     if (!rect) {
193 |       rect = {'top': 0, 'left': 0, 'width': element.offsetWidth,
194 |         'height': element.offsetHeight};
195 |       while (element && !isNaN(element.offsetLeft) &&
196 |              !isNaN(element.offsetTop)) {
197 |         rect['left'] += element.offsetLeft - element.scrollLeft;
198 |         rect['top'] += element.offsetTop - element.scrollTop;
199 |         element = element.offsetParent;
200 |       }
201 |       rect['right'] = rect['left'] + rect['width'];
202 |       rect['bottom'] = rect['top'] + rect['height'];
203 |     }
204 |   }
205 | 
206 |   return /** @type {!Object.<string, number>} */ (rect);
207 | };
208 | 
209 | 
210 | /**
211 |  * Alias of W3C <code>document.defaultView.getComputedStyle</code>.
212 |  * Used to reduce size after compilation.
213 |  * @param {!Element|!Node} element Element for getting style.
214 |  * @param {string} prop Style property name.
215 |  * @return {string|number} Returns element style value.
216 |  * @static
217 |  */
218 | dom.getComputedStyle = function(element, prop) {
219 |   if (dom.context['getComputedStyle']) {
220 |     return dom.context['getComputedStyle'](
221 |         element, dom.NULL).getPropertyValue(prop);
222 |   }
223 | 
224 |   // Converting 'css-property-name' to 'cssPropertyName'.
225 |   prop = prop.replace(/\-\w/g, function(match) {
226 |     return match.toUpperCase().slice(1);
227 |   });
228 | 
229 |   return (element.currentStyle || element.style)[prop];
230 | };
231 | 
232 | 
233 | /**
234 |  * Clears element content.
235 |  * @param {?Element} element The element to clear.
236 |  * @static
237 |  */
238 | dom.clearElement = function(element) {
239 |   if (element) {
240 |     switch (element.nodeName.toUpperCase()) {
241 |       case 'TABLE':
242 |       case 'THEAD':
243 |       case 'TBODY':
244 |       case 'TFOOT':
245 |       case 'TR':
246 |       case 'SELECT':
247 |         while (element.lastChild) {
248 |           element.removeChild(element.lastChild);
249 |         }
250 |         break;
251 |       default:
252 |         element.innerHTML = '';
253 |     }
254 |   }
255 | };
256 | 
257 | 
258 | /**
259 |  * Removes the object from the document hierarchy.
260 |  * @param {?Node} element The element to remove.
261 |  * @see https://developer.mozilla.org/en-US/docs/Web/API/ChildNode/remove
262 |  * @see https://developer.mozilla.org/en-US/docs/Web/API/Node/removeChild
263 |  * @see https://msdn.microsoft.com/en-us/library/ms536708%28v=vs.85%29.aspx
264 |  * @static
265 |  */
266 | dom.removeNode = function(element) {
267 |   element && element.parentNode && element.parentNode.removeChild(element);
268 | };
269 | 
270 | 
271 | /**
272 |  * Alias of W3C <code>element.appendChild</code>.
273 |  * Used to reduce size after compilation.
274 |  * @param {?Node|?Element} parent The parent element.
275 |  * @param {?Node|?Element} child The child element.
276 |  * @return {!Node} Returns a reference to the <code>child</code> that
277 |  *     is appended to the parent.
278 |  * @static
279 |  */
280 | dom.appendChild = function(parent, child) {
281 |   return parent.appendChild(child);
282 | };
283 | 
284 | 
285 | /**
286 |  * Returns true if an element has a class.
287 |  * @param {?Node} element The element to test.
288 |  * @param {string} className The class name to test for.
289 |  * @return {boolean} Whether element has the class.
290 |  */
291 | dom.css.hasClass = function(element, className) {
292 |   // Note: `element.classList.contains` throws 'TypeError: Illegal invocation'
293 |   // if element is not appended into the DOM.
294 |   if (element) {
295 |     /** @type {!Array.<string>} */ var classes = element.className.split(' ');
296 |     /** @type {number} */ var i = 0;
297 | 
298 |     for (; i < classes.length;) {
299 |       if (className == classes[i++]) {
300 |         return true;
301 |       }
302 |     }
303 |   }
304 | 
305 |   return false;
306 | };
307 | 
308 | 
309 | /**
310 |  * Sets the entire class name of an element.
311 |  * @param {?Node} element The element to set class of.
312 |  * @param {...string} var_args The class name(s) to apply to element.
313 |  */
314 | dom.css.setClass = function(element, var_args) {
315 |   if (element) {
316 |     element.className = util.Array.slice.call(arguments, 1).join(' ');
317 |   }
318 | };
319 | 
320 | 
321 | /**
322 |  * Adds a class or classes to an element. Does not add multiples of class names.
323 |  * @param {?Node} element The element to add class to.
324 |  * @param {...string} var_args The class name(s) to add.
325 |  */
326 | dom.css.addClass = function(element, var_args) {
327 |   // Note: `element.classList.add` throws 'TypeError: Illegal invocation'
328 |   // if element is not appended into the DOM.
329 |   if (element) {
330 |     dom.css.removeClass.apply(dom.NULL, arguments);
331 |     element.className += ' ' + util.Array.slice.call(arguments, 1).join(' ');
332 |   }
333 | };
334 | 
335 | 
336 | /**
337 |  * Removes a class or classes from an element.
338 |  * @param {?Node} element The element to remove class from.
339 |  * @param {...string} var_args The class name(s) to remove.
340 |  */
341 | dom.css.removeClass = function(element, var_args) {
342 |   // Note: `element.classList.remove` throws 'TypeError: Illegal invocation'
343 |   // if element is not appended into the DOM.
344 |   if (element) {
345 |     /** @type {!Array.<string>} */
346 |     var args = util.Array.slice.call(arguments, 1);
347 |     dom.css.setClass(element, element.className.replace(
348 |         new RegExp('\\s?\\b(' + args.join('|') + ')\\b', 'g'), ''));
349 |   }
350 | };
351 | 
352 | 
353 | /**
354 |  * Toggles element class name.
355 |  * @param {?Node} element The element to add or remove the class on.
356 |  * @param {string} className The class name to toggle.
357 |  */
358 | dom.css.toggleClass = function(element, className) {
359 |   (dom.css.hasClass(element, className) ?
360 |       dom.css.removeClass : dom.css.addClass)(element, className);
361 | };
362 | 
363 | 
364 | /**
365 |  * Enum of event types.
366 |  * @enum {string}
367 |  */
368 | dom.events.TYPE = {
369 |   // Mouse events.
370 |   CLICK: 'click',
371 |   DBLCLICK: 'dblclick',
372 |   MOUSEDOWN: 'mousedown',
373 |   MOUSEMOVE: 'mousemove',
374 |   MOUSEOUT: 'mouseout',
375 |   MOUSEOVER: 'mouseover',
376 |   MOUSEUP: 'mouseup',
377 |   MOUSEWHEEL: 'onmousewheel' in dom.document ? 'mousewheel' : 'DOMMouseScroll',
378 | 
379 |   // Keyboard events.
380 |   KEYDOWN: 'keydown',
381 |   KEYPRESS: 'keypress',
382 |   KEYUP: 'keyup',
383 | 
384 |   // Touch events.
385 |   TOUCHCANCEL: 'touchcancel',
386 |   TOUCHEND: 'touchend',
387 |   TOUCHMOVE: 'touchmove',
388 |   TOUCHSTART: 'touchstart',
389 | 
390 |   // Forms events.
391 |   BLUR: 'blur',
392 |   CHANGE: 'change',
393 |   FOCUS: 'focus',
394 |   INPUT: 'input',
395 |   RESET: 'reset',
396 |   SELECT: 'select',
397 |   SUBMIT: 'submit',
398 | 
399 |   // Drag and drop events.
400 |   DRAG: 'drag',
401 |   DRAGEND: 'dragend',
402 |   DRAGENTER: 'dragenter',
403 |   DRAGLEAVE: 'dragleave',
404 |   DRAGOVER: 'dragover',
405 |   DRAGSTART: 'dragstart',
406 |   DROP: 'drop',
407 | 
408 |   // Window and document events.
409 |   BEFOREUNLOAD: 'beforeunload',
410 |   DOMCONTENTLOADED: 'DOMContentLoaded',
411 |   ERROR: 'error',
412 |   LOAD: 'load',
413 |   ORIENTATIONCHANGE: 'orientationchange',
414 |   READYSTATECHANGE: 'readystatechange',
415 |   RESIZE: 'resize',
416 |   SCROLL: 'scroll',
417 |   UNLOAD: 'unload'
418 | };
419 | 
420 | 
421 | /**
422 |  * Alias of W3C <code>element.addEventListener</code>.
423 |  * Used to reduce size after compilation.
424 |  * @param {!Element|!Node|!Window} element Element to which attach event.
425 |  * @param {string} type Type of event.
426 |  * @param {function(!Event, ...)} listener Event listener.
427 |  * @static
428 |  */
429 | dom.events.addEventListener = function(element, type, listener) {
430 |   if (element.attachEvent) {
431 |     element.attachEvent('on' + type, listener);
432 |   } else {
433 |     element.addEventListener(type, listener, false);
434 |   }
435 | };
436 | 
437 | 
438 | /**
439 |  * Alias of W3C <code>element.removeEventListener</code>.
440 |  * Used to reduce size after compilation.
441 |  * @param {!Element|!Node|!Window} element Element to which attach event.
442 |  * @param {string} type Type of event.
443 |  * @param {function(!Event, ...)} listener Event listener.
444 |  * @static
445 |  */
446 | dom.events.removeEventListener = function(element, type, listener) {
447 |   if (element.attachEvent) {
448 |     element.detachEvent('on' + type, listener);
449 |   } else {
450 |     element.removeEventListener(type, listener, false);
451 |   }
452 | };
453 | 
454 | 
455 | /**
456 |  * Alias of W3C <code>element.dispatchEvent</code>.
457 |  * Used to reduce size after compilation.
458 |  * @param {!Element|!Node|!Window} element Element to dispatch event.
459 |  * @param {string} type Type of event.
460 |  * @return {boolean} Returns <code>true</code> if event dispatched successfully.
461 |  * @static
462 |  */
463 | dom.events.dispatchEvent = function(element, type) {
464 |   /** @type {?Event} */ var evt = dom.NULL;
465 |   /** @type {boolean} */ var result = false;
466 | 
467 |   if (dom.document.createEvent) {
468 |     evt = dom.document.createEvent('HTMLEvents');
469 |     // initEvent(type, bubbling, cancelable)
470 |     evt.initEvent(type, true, true);
471 |     result = element.dispatchEvent(evt);
472 |   } else if (dom.document.createEventObject) {
473 |     evt = dom.document.createEventObject();
474 |     try {
475 |       // MSIE throws error on invalid event type.
476 |       result = element.fireEvent('on' + type, evt);
477 |     } catch (e) {}
478 |   }
479 | 
480 |   return result;
481 | };
482 | 
483 | 
484 | /**
485 |  * Alias of W3C <code>event.preventDefault</code>.
486 |  * Used to reduce size after compilation.
487 |  * @param {?Event} e The event to stop.
488 |  * @static
489 |  */
490 | dom.events.preventDefault = function(e) {
491 |   e = dom.events.getEvent(e);
492 |   e.stopPropagation && e.stopPropagation();
493 |   e.preventDefault && e.preventDefault();
494 |   e.returnValue = false;
495 |   e.cancelBubble = true;
496 | };
497 | 
498 | 
499 | /**
500 |  * Gets event object.
501 |  * Used to reduce size after compilation.
502 |  * @param {?Event} e The event to stop.
503 |  * @return {!Event} Returns event object.
504 |  * @static
505 |  */
506 | dom.events.getEvent = function(e) {
507 |   return e || dom.context.event;
508 | };
509 | 
510 | 
511 | /**
512 |  * Gets event target object.
513 |  * Used to reduce size after compilation.
514 |  * @param {?Event} e The event to stop.
515 |  * @return {?EventTarget} Returns event target object.
516 |  * @static
517 |  */
518 | dom.events.getEventTarget = function(e) {
519 |   e = dom.events.getEvent(e);
520 |   return e.target || e.srcElement;
521 | };
522 | 
523 | 
524 | /**
525 |  * Gets reference to script element is currently being processed.
526 |  * @return {?Element} Reference to script element is currently being processed.
527 |  * @link https://developer.mozilla.org/en/DOM/document.currentScript
528 |  */
529 | dom.scripts.getCurrent = function() {
530 |   return dom.document['currentScript'] || dom.scripts.last_;
531 | };
532 | 
533 | 
534 | /**
535 |  * Gets reference to last script element.
536 |  * @return {?Element} Reference to last script element.
537 |  */
538 | dom.scripts.getLast = function() {
539 |   /** @type {?NodeList} */
540 |   var scripts = dom.getElementsByTagName(dom.document, 'SCRIPT');
541 |   return scripts && scripts[scripts.length - 1];
542 | };
543 | 
544 | 
545 | /**
546 |  * Loads script.
547 |  * @param {string} src The script source.
548 |  * @param {!Function=} opt_callback The optional callback function.
549 |  */
550 | dom.scripts.load = function(src, opt_callback) {
551 |   /** @type {?Element} */ var script = dom.createElement('SCRIPT');
552 |   /** @type {boolean} */ var loaded = false;
553 |   /** @type {string} */ var state;
554 | 
555 |   script['src'] = src;
556 |   script['onload'] = script['onreadystatechange'] = function() {
557 |     state = script['readyState'] || 'complete';
558 |     if (!loaded && ('loaded' === state || 'complete' === state)) {
559 |       loaded = true;
560 |       // Handle memory leak in IE.
561 |       script['onload'] = script['onreadystatechange'] = dom.NULL;
562 |       dom.removeNode(script);
563 |       opt_callback && opt_callback();
564 |     }
565 |   };
566 |   dom.appendChild(dom.scripts.last_.parentNode, script);
567 | };
568 | 
569 | 
570 | /**
571 |  * The reference to last script element.
572 |  * @type {?Node}
573 |  * @private
574 |  */
575 | dom.scripts.last_ = dom.scripts.getLast();
576 | 


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