bobjoll 1.0.3

package/ts/library/extend.js

@@ -0,0 +1,32 @@
+var extend = function ( defaults, options ) {
+    var extended = {};
+    var prop;
+    for (prop in defaults) {
+        if (Object.prototype.hasOwnProperty.call(defaults, prop)) {
+            extended[prop] = defaults[prop];
+        }
+    }
+    for (prop in options) {
+        if (Object.prototype.hasOwnProperty.call(options, prop)) {
+            if (Object.prototype.toString.call(extended[prop]) === '[object Object]') {
+                if (!extended[prop]) {
+                    extended[prop] = {};
+                }
+
+                extended[prop] = extend(extended[prop], options[prop]);
+            } else {
+                extended[prop] = options[prop];
+            }
+        }
+    }
+    return extended;
+};
+
+(function(){
+    if (typeof define === 'function' && define.amd)
+        define('extend', function () { return extend; });
+    else if (typeof module !== 'undefined' && module.exports)
+        module.exports = extend;
+    else
+        window.extend = extend;
+})();

package/ts/library/gr/dom.q.ts

@@ -0,0 +1,12 @@
+export function q(selector: string, parent: HTMLElement | Document = document): HTMLElement | null {
+	const x = parent.querySelector(selector);
+	return x ? x as HTMLElement : x;
+}
+
+export function qq(selector: string, parent: HTMLElement | Document = document): HTMLElement[] {
+	return Array.prototype.slice.call(parent.querySelectorAll(selector), 0);
+}
+
+export function qi(selector: string, parent: HTMLElement | Document = document): HTMLInputElement {
+	return q(selector, parent) as HTMLInputElement;
+}

package/ts/library/gr/social/dependency/twitter_pu.js

@@ -0,0 +1,66 @@
+var pu_window;
+
+export function pu(pu_url) {
+    var pu_width = window.innerWidth - 200;
+    var pu_height = window.innerHeight - 50;
+    var b = "toolbar=0,statusbar=1,resizable=1,scrollbars=0,menubar=0,location=1,directories=0";
+    if (navigator.userAgent.indexOf("Chrome") != -1) b = "scrollbar=yes";
+    var a = window.open("about:blank", "", b + ",height=" + pu_height + ",width=" + pu_width);
+
+    if (navigator.userAgent.indexOf("rv:2.") != -1) {
+        a.puPop = function(c) {
+            if (navigator.userAgent.indexOf("rv:2.") != -1) this.window.open("about:blank").close();
+            this.document.location.href = c;
+        };
+        a.puPop(pu_url);
+    } else
+        a.document.location.href = pu_url;
+    setTimeout(window.focus, 200);
+    window.focus();
+    if (a) {
+        a.moveTo(window.screenX + 2, window.screenY + 2);
+        a.blur();
+        self.focus();
+    } else {
+        done_pu = null;
+        ifSP2 = false;
+        if (typeof(pu_window) == "undefined") pu_window = false;
+        if (window.SymRealWinOpen) open = SymRealWinOpen;
+        if (window.NS_ActualOpen) open = NS_ActualOpen;
+        ifSP2 = (navigator.userAgent.indexOf("SV1") != -1);
+        if (!ifSP2)
+            do_pu();
+        else {
+            if (window.Event) document.captureEvents(Event.CLICK);
+            document.onclick = do_clicked_pu;
+        }
+        self.focus();
+        do_clicked_pu();
+    }
+    return this;
+}
+
+export function do_pu() {
+    if (!pu_window) {
+        done_pu = open(pu_url, "", "toolbar=1,location=1,directories=0,status=1,menubar=1,scrollbars=1,resizable=1");
+        if (done_pu) {
+            pu_window = true;
+            self.focus();
+        }
+    }
+}
+
+export function do_clicked_pu() {
+    if (!pu_window) {
+        if (!ifSP2) {
+            done_pu = open(pu_url, "", "toolbar=1,location=1,directories=0,status=1,menubar=1,scrollbars=1,resizable=1");
+            self.focus();
+            if (done_pu) pu_window = true;
+        }
+    }
+    if (!pu_window) {
+        if (window.Event) document.captureEvents(Event.CLICK);
+        document.onclick = do_pu;
+        self.focus();
+    }
+}

package/ts/library/gr/social/facebook.ts

@@ -0,0 +1,154 @@
+/// <reference types="facebook-js-sdk" />
+
+namespace facebook {
+    export interface FacebookStatic extends fb.FacebookStatic {
+        getUserID(): string;
+    }
+}
+
+declare const FB: facebook.FacebookStatic;
+declare const FACEBOOK_APP_ID: string;
+
+import Social from './index';
+
+export default class Facebook extends Social {
+    public static getInstance() {
+        Facebook.init();
+
+        return Facebook;
+    }
+
+    public static async connect() {
+        const response = await new Promise((resolve, reject) => {
+            if ('' === FB.getUserID()) {
+                FB.login(
+                    response => {
+                        if (response.authResponse) {
+                            resolve(response);
+                        } else {
+                            reject(response);
+                        }
+                    },
+                    {
+                        scope: 'public_profile, email',
+                    },
+                );
+            } else {
+                FB.getLoginStatus(response => resolve(response));
+            }
+        });
+
+        return Facebook.status(<fb.AuthResponse>response);
+    }
+
+    public static disconnect() {
+        if (Facebook.gr) {
+            FB.api('/me/permissions', 'delete', function() {
+                try {
+                    Facebook.connected = false;
+                    Facebook.gr.logout();
+                } catch (e) {
+                    console.error(`There has been an error on the logout request. Error: ${e}`);
+                }
+            });
+        }
+    }
+
+    private static sdk() {
+        if (!document.getElementById('facebook-jssdk')) {
+            (function(d, s, id) {
+                var js,
+                    fjs = d.getElementsByTagName(s)[0];
+
+                if (d.getElementById(id)) return;
+
+                js = d.createElement(s) as HTMLScriptElement;
+                js.id = id;
+                js.src = '//connect.facebook.net/en_US/sdk.js';
+
+                if (fjs.parentNode) fjs.parentNode.insertBefore(js, fjs);
+            })(document, 'script', 'facebook-jssdk');
+        }
+    }
+
+    private static init() {
+        Facebook.setup();
+        Facebook.sdk();
+    }
+
+    private static setup() {
+        (window as any).fbAsyncInit = () => {
+            FB.init({
+                appId: FACEBOOK_APP_ID,
+                cookie: true,
+                xfbml: false,
+                version: 'v3.2',
+            });
+
+            FB.getLoginStatus(() => {});
+
+            delete (window as any).fbAsyncInit;
+        };
+    }
+
+    private static async status(response: any) {
+        let action: 'login' | 'register' | 'connect' = 'login';
+        let data = new FormData();
+
+        if (response) {
+            if ('connected' === response.status) {
+                data.append('facebook_id', response.authResponse.userID);
+                data.append('social_network', 'facebook');
+
+                if (Facebook.gr && Facebook.gr.isLogged()) action = 'connect';
+            } else if ('register' === response.status) {
+                await new Promise((resolve, reject) => {
+                    try {
+                        FB.api('/me?fields=id,email,name,locale,token_for_business', (fields: any) => {
+                            FB.api(
+                                '/me/picture',
+                                {
+                                    redirect: false,
+                                    height: '200',
+                                    type: 'normal',
+                                    width: '200',
+                                },
+                                (picture: any) => {
+                                    action = 'register';
+
+                                    data.append('facebook_id', fields.id);
+                                    data.append('email', fields.email);
+                                    data.append('name', fields.name);
+                                    data.append('language', fields.locale);
+                                    data.append('avatar', picture && !picture.error && !picture.data.is_silhouette ? picture.data.url : false);
+                                    data.append('fb_token', fields.token_for_business);
+
+                                    resolve({
+                                        fields: fields,
+                                        picture: picture,
+                                    });
+                                },
+                            );
+                        });
+                    } catch (err) {
+                        reject(err);
+                    }
+                });
+            }
+        }
+
+        let auth: any = await Facebook.auth(action, data);
+
+        if ('register' === auth.data.status) {
+            auth = await Facebook.status({
+                status: 'register',
+            });
+
+            if (true === auth.data.status) {
+                auth = await Facebook.connect();
+            }
+        }
+
+        return auth;
+    }
+}

package/ts/library/gr/social/google.ts

@@ -0,0 +1,127 @@
+/// <reference types="gapi.auth2" />
+
+import Social from './index';
+
+export default class Google extends Social {
+    private static loaded: boolean = false;
+    private static auth2: gapi.auth2.GoogleAuth;
+
+    public static getInstance() {
+        Google.init();
+
+        return Google;
+    }
+
+    public static async connect() {
+        if (!Google.loaded) {
+            return;
+        }
+
+        return gapi.auth2
+            .getAuthInstance()
+            .signIn({
+                scope: 'email profile',
+            })
+            .then(() => Google.status());
+    }
+
+    public static disconnect() {
+        if (Google.gr && Google.gr.isLogged()) {
+            gapi.auth2
+                .getAuthInstance()
+                .signOut()
+                .then((response: GoogleApiOAuth2TokenObject) => {
+                    if (response && !response.error) {
+                        let data = new FormData();
+
+                        try {
+                            var result = gapi.auth.getToken();
+                            var request = new XMLHttpRequest();
+
+                            request.open('GET', 'https://accounts.google.com/o/oauth2/revoke?token=' + result.access_token, false);
+                            request.send();
+                        } catch (e) {}
+
+                        data.append('social_network', 'google');
+
+                        Google.request('DELETE', 'profile/connect', data);
+                        Google.connected = false;
+                    }
+                });
+        }
+    }
+
+    private static sdk() {
+        if (!document.getElementById('google-jssdk')) {
+            (function(d, s, id) {
+                var js,
+                    fjs = d.getElementsByTagName(s)[0];
+
+                if (d.getElementById(id)) return;
+
+                js = d.createElement(s) as HTMLScriptElement;
+
+                js.id = id;
+                js.src = 'https://apis.google.com/js/api:client.js?onload=google_init';
+
+                if (fjs.parentNode) fjs.parentNode.insertBefore(js, fjs);
+            })(document, 'script', 'google-jssdk');
+        }
+    }
+
+    private static init() {
+        Google.setup();
+        Google.sdk();
+    }
+
+    private static setup() {
+        (window as any).google_init = async function() {
+            await new Promise(resolve => {
+                gapi.load('client:auth2', () => resolve());
+            });
+
+            Google.auth2 = gapi.auth2.init({
+                client_id: GOOGLE_CLIENT_ID,
+            });
+
+            Google.loaded = true;
+
+            delete (window as any).google_init;
+        };
+    }
+
+    private static async status() {
+        let user: gapi.auth2.GoogleUser;
+        if (true == this.auth2.isSignedIn.get()) {
+            user = Google.auth2.currentUser.get();
+        } else {
+            user = await new Promise(resolve => {
+                Google.auth2.signIn().then(function() {
+                    resolve(Google.auth2.currentUser.get());
+                });
+            });
+        }
+        try {
+            const token = user.getAuthResponse().id_token;
+            let action: 'login' | 'connect' = 'connect';
+            let form: FormData = new FormData();
+            if (Google.gr && Google.gr.isLogged()) {
+                action = 'connect';
+                Google.connected = true;
+                form.append('token', token);
+                form.append('social_network', 'google');
+            } else {
+                const profile = user.getBasicProfile();
+                action = 'login';
+                form.append('token', token);
+                form.append('email', profile.getEmail());
+                form.append('name', profile.getGivenName());
+                form.append('avatar', profile.getImageUrl());
+            }
+
+            return Google.auth(action, form);
+        } catch (e) {
+            throw Error(e);
+        }
+    }
+}

package/ts/library/gr/social/index.ts

@@ -0,0 +1,35 @@
+declare var gr: any;
+
+export default class Social {
+    public static connected: boolean = false;
+    public static gr = 'undefined' === typeof gr ? undefined : gr;
+
+    public static request(method: 'DELETE' | 'POST', url: string, data?: FormData) {
+        return new Promise((resolve, reject) => {
+            const req = new XMLHttpRequest();
+
+            req.addEventListener('load', () => {
+                try {
+                    if (req.status !== 200) {
+                        reject(req.response);
+                    }
+
+                    resolve(JSON.parse(req.response));
+                }
+                catch (e) {
+                    reject('Error reading response (json):' + req.response);
+                }
+            });
+
+            req.open(method, url);
+            req.setRequestHeader('X-Requested-With', 'xmlhttprequest');
+            req.send.apply(null, data);
+        });
+    }
+
+    public static auth(action: 'login' | 'register' | 'connect', data: FormData) {
+        if ('undefined' !== typeof gr) {
+            return gr.socialAuthHandler(action, data);
+        }
+    }
+}

package/ts/library/gr/social/twitter.ts

@@ -0,0 +1,65 @@
+import Social from './index';
+import { pu } from './dependency/twitter_pu.js';
+
+declare const gr: any;
+
+export default class Twitter extends Social {
+    public static register: Function;
+
+    public static getInstance() {
+        return Twitter;
+    }
+
+    public static status(args: {
+        result: 'login' | 'register' | 'connect';
+        twitter_id?: string;
+        username?: string;
+        language?: string;
+        avatar?: string;
+        message?: string;
+        [name: string]: any;
+    }) {
+        let data = new FormData();
+
+        if ('function' === typeof Twitter.register) {
+            data.append('twitter_id', args.twitter_id || '0');
+
+            if (args.result.match(/error/) && args.message) {
+                throw Error(args.message);
+            }
+
+            if (args.result.match(/login|connect/)) {
+                Twitter.auth(args.result, data);
+            }
+
+            if (args.result.match(/register/) && 'function' === typeof Twitter.register) {
+                data.append('username', args.username || '');
+                data.append('avatar', args.avatar || '');
+
+                Twitter.register(data);
+            }
+        }
+    }
+
+    public static async connect() {
+        pu('/profile/twitter/redirect_authorize_url');
+
+        const response = await new Promise((resolve, reject) => {
+            (window as any).twitter_connection_status = function(response: any) {
+                resolve(response);
+            };
+
+            setTimeout(reject, 5000);
+        });
+
+        Twitter.status(<any>response);
+    }
+
+    public static disconnect() {
+        if (gr.auth.logged) {
+            gr.request.delete('profile/connect', { social_network: 'twitter' });
+
+            Twitter.connected = false;
+        }
+    }
+}

package/ts/library/helpers.ts

@@ -0,0 +1,9 @@
+export function IsUrlValid(url: string) {
+    let regexp = /^(?:(?:https?|ftp):\/\/)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,})))(?::\d{2,5})?(?:\/\S*)?$/;
+
+    if (regexp.test(url)) {
+        return true;
+    }
+
+    return false;
+}

package/ts/library/number-abbreviate.js

@@ -0,0 +1,57 @@
+(function (root) {
+    'use strict';
+
+    function NumberAbbreviate() {
+        var units
+        if (!(this instanceof NumberAbbreviate)) {
+            // function usage: abbrev(n, decPlaces, units)
+            var n = arguments[0]
+            var decPlaces = arguments[1]
+            var floor = !!arguments[2]
+            units = arguments[3]
+            var ab = new NumberAbbreviate(units)
+            return ab.abbreviate(n, decPlaces, floor)
+        }
+        // class usage: new NumberAbbreviate(units)
+        units = arguments[0]
+        this.units = units == null ? ['k', 'm', 'b', 't'] : units
+    }
+
+    NumberAbbreviate.prototype._abbreviate = function (number, decPlaces, floor) {
+        decPlaces = Math.pow(10, decPlaces)
+
+        for (var i = this.units.length - 1; i >= 0; i--) {
+
+            var size = Math.pow(10, (i + 1) * 3)
+
+            if (size <= number) {
+                number = Math[floor ? 'floor' : 'round'](number * decPlaces / size) / decPlaces
+
+                if ((number === 1000) && (i < this.units.length - 1)) {
+                    number = 1
+                    i++
+                }
+
+                number += this.units[i]
+
+                break
+            }
+        }
+
+        return number
+    }
+
+    NumberAbbreviate.prototype.abbreviate = function (number, decPlaces, floor) {
+        var isNegative = number < 0
+        var abbreviatedNumber = this._abbreviate(Math.abs(number), decPlaces || 0, floor)
+
+        return isNegative ? '-' + abbreviatedNumber : abbreviatedNumber;
+    }
+
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = NumberAbbreviate
+    } else {
+        root.NumberAbbreviate = NumberAbbreviate
+    }
+
+})(this);

package/ts/library/settings.ts

@@ -0,0 +1,7 @@
+var Settings = require('Project/settings.json');
+
+Object.keys(Settings.breakpoints).map(function(key) {
+	Settings.breakpoints[key] = parseFloat(Settings.breakpoints[key]);
+});
+
+export { Settings };