glitch-javascript-sdk 0.1.2 → 0.1.4

package/dist/esm/util/Data.d.ts

@@ -0,0 +1,5 @@
+declare class Data {
+    static dataURItoBlob(dataURI: string): Blob;
+    static convertToHHMMSS(time: string | undefined): string | undefined;
+}
+export default Data;

package/dist/esm/util/Parser.d.ts

@@ -0,0 +1,11 @@
+declare class Parser {
+    /**
+     * To be used inside a catch close, this function will parse out any JSON in a error response from the api.
+     *
+     * @param error The Error object from the catch clause
+     *
+     * @returns Either returns a JSON object or false.
+     */
+    static parseJSONFromError(error: Error): object | boolean;
+}
+export default Parser;

package/dist/esm/util/Session.d.ts

@@ -0,0 +1,24 @@
+declare class Session {
+    private static _id_key;
+    private static _first_name_key;
+    private static _last_name_key;
+    private static _username_key;
+    private static _email_key;
+    static isLoggedIn(): boolean;
+    static getAuthToken(): string | null;
+    static getID(): string | null;
+    static getFirstName(): string | null;
+    static getLastName(): string | null;
+    static getEmail(): string | null;
+    static end(): void;
+    static processAuthentication(data: {
+        token: {
+            access_token: string;
+        };
+        id: string;
+        first_name: string;
+        last_name: string;
+        email: string;
+    }): void;
+}
+export default Session;

package/dist/esm/util/Storage.d.ts

@@ -0,0 +1,11 @@
+declare class Storage {
+    private static data;
+    static set(key: string, value: any): void;
+    static get(key: string): any;
+    static setAuthToken(token: string | null): void;
+    static getAuthToken(): string | null;
+    private static setCookie;
+    private static getCookie;
+    static eraseCookie(name: string): void;
+}
+export default Storage;

package/dist/index.d.ts

@@ -1129,6 +1129,105 @@ declare class Waitlists {
     static delete<T>(waitlist_id: string): AxiosPromise<Response<T>>;
 }
 
+interface Route {
+    url: string;
+    method: string;
+}
+
+declare class Requests {
+    config: Config;
+    private static baseUrl;
+    private static authToken;
+    constructor(config: Config);
+    /**
+     * Sets the base url of the API.
+     *
+     * @param url The url to of the API.
+     */
+    static setBaseUrl(url: string): void;
+    /**
+     * Sets the JSON Web token
+     *
+     * @param token
+     */
+    static setAuthToken(token: string): void;
+    private static request;
+    /**
+     * Calls a GET request to the url endpoint.
+     *
+     * @param url
+     * @returns
+     */
+    static get<T>(url: string): AxiosPromise<Response<T>>;
+    static post<T>(url: string, data: any): AxiosPromise<Response<T>>;
+    static put<T>(url: string, data: any): AxiosPromise<Response<T>>;
+    static delete<T>(url: string): AxiosPromise<Response<T>>;
+    static uploadFile<T>(url: string, filename: string, file: File, data?: any): AxiosPromise<Response<T>>;
+    static uploadBlob<T>(url: string, filename: string, blob: Blob, data?: any): AxiosPromise<Response<T>>;
+    /**
+     *  The Route class contains the method and url, thereforce items can be
+     *  automatically routed depending on the configuration.
+     *
+     * @param route
+     * @param data
+     * @returns
+     */
+    static processRoute<T>(route: Route, data?: object, routeReplace?: {
+        [key: string]: any;
+    }): AxiosPromise<Response<T>>;
+}
+
+declare class Parser {
+    /**
+     * To be used inside a catch close, this function will parse out any JSON in a error response from the api.
+     *
+     * @param error The Error object from the catch clause
+     *
+     * @returns Either returns a JSON object or false.
+     */
+    static parseJSONFromError(error: Error): object | boolean;
+}
+
+declare class Session {
+    private static _id_key;
+    private static _first_name_key;
+    private static _last_name_key;
+    private static _username_key;
+    private static _email_key;
+    static isLoggedIn(): boolean;
+    static getAuthToken(): string | null;
+    static getID(): string | null;
+    static getFirstName(): string | null;
+    static getLastName(): string | null;
+    static getEmail(): string | null;
+    static end(): void;
+    static processAuthentication(data: {
+        token: {
+            access_token: string;
+        };
+        id: string;
+        first_name: string;
+        last_name: string;
+        email: string;
+    }): void;
+}
+
+declare class Storage {
+    private static data;
+    static set(key: string, value: any): void;
+    static get(key: string): any;
+    static setAuthToken(token: string | null): void;
+    static getAuthToken(): string | null;
+    private static setCookie;
+    private static getCookie;
+    static eraseCookie(name: string): void;
+}
+
+declare class Data {
+    static dataURItoBlob(dataURI: string): Blob;
+    static convertToHHMMSS(time: string | undefined): string | undefined;
+}
+
 declare class Glitch {
     static config: {
         Config: typeof Config;
@@ -1141,6 +1240,13 @@ declare class Glitch {
         Teams: typeof Teams;
         Waitlists: typeof Waitlists;
     };
+    static util: {
+        Requests: typeof Requests;
+        Parser: typeof Parser;
+        Session: typeof Session;
+        Storage: typeof Storage;
+        Data: typeof Data;
+    };
 }
 
 export { Glitch as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glitch-javascript-sdk",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Javascrip SDK for GLitch",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",

package/src/index.ts

@@ -3,13 +3,19 @@
 import { Config } from "./config";
 
 //API
-import { Auth } from "./api";
-import { Competitions } from "./api";
+import Auth  from "./api/Auth";
+import Competitions  from "./api/Competitions";
 import { Users } from "./api";
 import { Events } from "./api";
 import { Teams } from "./api";
 import { Waitlists } from "./api";
 
+import Requests from "./util/Requests";
+import Parser from "./util/Parser";
+import Session from "./util/Session";
+import Storage from "./util/Storage";
+import Data from './util/Data';
+
 class Glitch {
 
     public static config =  {
@@ -25,6 +31,14 @@ class Glitch {
         Waitlists: Waitlists
     }
 
+    public static util = {
+        Requests : Requests,
+        Parser : Parser,
+        Session: Session,
+        Storage : Storage,
+        Data : Data,
+    }
+
 
 }
 

package/src/util/Data.ts

@@ -0,0 +1,41 @@
+class Data {
+    
+    public static dataURItoBlob(dataURI: string): Blob {
+      const byteString = atob(dataURI.split(',')[1]);
+      const mimeString = dataURI.split(',')[0].split(':')[1].split(';')[0];
+      const ab = new ArrayBuffer(byteString.length);
+      const ia = new Uint8Array(ab);
+    
+      for (let i = 0; i < byteString.length; i++) {
+        ia[i] = byteString.charCodeAt(i);
+      }
+    
+      const blob = new Blob([ab], { type: mimeString });
+      return blob;
+    }
+  
+    public static convertToHHMMSS(time: string | undefined): string | undefined {
+      if (!time) {
+        return time;
+      }
+  
+      const sec_num = parseInt(time, 10);
+      let hours = Math.floor(sec_num / 3600);
+      let minutes = Math.floor((sec_num - (hours * 3600)) / 60);
+      let seconds = sec_num - (hours * 3600) - (minutes * 60);
+  
+      if (hours < 10) {
+        hours = Number('0' + hours);
+      }
+      if (minutes < 10) {
+        minutes = Number('0' + minutes);
+      }
+      if (seconds < 10) {
+        seconds = Number('0' + seconds);
+      }
+  
+      return `${hours}:${minutes}:${seconds}`;
+    }
+  }
+  
+  export default Data;

package/src/util/Parser.ts

@@ -0,0 +1,24 @@
+class Parser {
+
+    /**
+     * To be used inside a catch close, this function will parse out any JSON in a error response from the api.
+     * 
+     * @param error The Error object from the catch clause
+     * 
+     * @returns Either returns a JSON object or false. 
+     */
+    public static parseJSONFromError(error: Error): object | boolean {
+
+        let errorString = error.toString();
+
+        errorString = errorString.replace('Error: ', '');
+
+        try {
+            return JSON.parse(errorString);
+        } catch (e) {
+            return false;
+        }
+    }
+}
+
+export default Parser;

package/src/util/Session.ts

@@ -0,0 +1,53 @@
+import Storage from "./Storage";
+
+class Session {
+
+  private static _id_key = 'user_id';
+  private static _first_name_key = 'user_first_name';
+  private static _last_name_key = 'user_last_name';
+  private static _username_key = 'username';
+  private static _email_key = 'email';
+
+  public static isLoggedIn(): boolean {
+    const authToken = Storage.getAuthToken();
+    return authToken !== null && authToken !== 'null' && authToken !== undefined;
+  }
+
+  public static getAuthToken(): string | null {
+    return Storage.getAuthToken();
+  }
+
+  public static getID(): string | null {
+    return Storage.get(Session._id_key);
+  }
+
+  public static getFirstName(): string | null {
+    return Storage.get(Session._first_name_key);
+  }
+
+  public static getLastName(): string | null {
+    return Storage.get(Session._last_name_key);
+  }
+
+  public static getEmail(): string | null {
+    return Storage.get(Session._email_key);
+  }
+
+  public static end(): void {
+    Storage.setAuthToken(null);
+    Storage.set(Session._id_key, null);
+    Storage.set(Session._first_name_key, null);
+    Storage.set(Session._last_name_key, null);
+    Storage.set(Session._email_key, null);
+  }
+
+  public static processAuthentication(data: { token: { access_token: string }, id: string, first_name: string, last_name: string, email: string }): void {
+    Storage.setAuthToken(data.token.access_token);
+    Storage.set(Session._id_key, data.id);
+    Storage.set(Session._first_name_key, data.first_name);
+    Storage.set(Session._last_name_key, data.last_name);
+    Storage.set(Session._email_key, data.email);
+  }
+}
+
+export default Session;

package/src/util/Storage.ts

@@ -0,0 +1,85 @@
+class Storage {
+
+    //Back up data type if no storage is working.
+
+    private static data: { [key: string]: any } = {};
+
+  
+    public static set(key: string, value: any) {
+      try {
+        window.localStorage.setItem(key, value);
+      } catch (e) {
+        try {
+          window.sessionStorage.setItem(key, value);
+        } catch (e) {
+          this.setCookie(key, value, 31);
+          //fallback if set cookie fails
+          Storage.data[key] = value;
+        }
+      }
+    }
+  
+    public static get(key: string): any {
+      try {
+        return window.localStorage.getItem(key);
+      } catch (e) {
+        try {
+          return window.sessionStorage.getItem(key);
+        } catch (e) {
+          let value = Storage.getCookie(key);
+  
+          if (!value) {
+            value = Storage.data[key];
+          }
+  
+          return value;
+        }
+      }
+    }
+  
+    public static setAuthToken(token: string | null) {
+      Storage.set('glitch_auth_token', token);
+    }
+  
+    public static getAuthToken(): string | null {
+      return Storage.get('glitch_auth_token');
+    }
+  
+    private static setCookie(name: string, value: string, days: number) {
+      let expires = '';
+      if (days) {
+        const date = new Date();
+        date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000);
+        expires = '; expires=' + date.toUTCString();
+      }
+  
+      //IFrames require HttpyOnly to be false, Chrome require SameSite to be none, and must be secure
+      document.cookie =
+        name +
+        '=' +
+        (value || '') +
+        expires +
+        '; path=/; HttpOnly=false; SameSite=none; Secure';
+    }
+  
+    private static getCookie(name: string): string | null {
+      const nameEQ = name + '=';
+      const ca = document.cookie.split(';');
+      for (let i = 0; i < ca.length; i++) {
+        let c = ca[i];
+        while (c.charAt(0) == ' ') c = c.substring(1, c.length);
+        if (c.indexOf(nameEQ) == 0)
+          return c.substring(nameEQ.length, c.length);
+      }
+      return null;
+    }
+  
+    public static eraseCookie(name: string) {
+      document.cookie =
+        name +
+        '=; Secure; HttpOnly=false; SameSite=none; Path=/; Expires=Thu, 01 Jan 1970 00:00:01 GMT;';
+    }
+  }
+  
+  export default Storage;
+