Storage.js

  1. /* global platypus, window */
  2. import DataMap from './DataMap.js';
  3. import {UserData} from 'springroll';
  5. /**
  6.  * This class is used to create the Platypus storage system accessible at `platypus.storage`. It uses Springroll UserData if available, with a fallback to local storage if not.
  7.  *
  8.  * @memberof platypus
  9.  * @class Storage
  10.  * @param {*} springroll 
  11.  * @param {*} options 
  12.  * @return {Data} Returns the new Storage object.
  13.  */
  14. class Storage {
  15.     constructor (springroll, options) {
  16.         const
  17.             gameId = options.name,
  18.             storageKey = gameId + '-data',
  19.             unconnectedData = window.localStorage.getItem(storageKey),
  20.             keys = options.storageKeys || null,
  21.             handleData = (resp) => {
  22.                 const
  23.                     data = resp && resp.data ? resp.data : resp;
  25.                 if (data) {
  26.                     for (const key in data) {
  27.                         if (data.hasOwnProperty(key)) {
  28.                             if (this.map.has(key)) {
  29.                                 this.map.set(key, data[key]);
  30.                             } else {
  31.                                 this.addKey(key, data[key]);
  32.                             }
  33.                         }
  34.                     }
  35.                 }
  36.             };
  38.         this.map = DataMap.setUp();
  40.         /**
  41.          * The storage key being used to store data.
  42.          *
  43.          * @property storageKey
  44.          * @type String
  45.          * @default options.name+'-data'
  46.          */
  47.         this.storageKey = storageKey;
  49.         /**
  50.          * Whether Springroll is connected to a hosting page.
  51.          *
  52.          * @property connected
  53.          * @type Boolean
  54.          * @default false
  55.          */
  56.         this.connected = false;
  58.         if (keys) {
  59.             for (let i = 0; i < keys.length; i++) {
  60.                 this.addKey(keys[i], null);
  61.             }
  62.         }
  64.         try { // May throw if data is not parseable. If so, we'll just ignore it.
  65.             handleData(JSON.parse(unconnectedData));
  66.         } catch (e) {}
  68.         springroll.container.on('connected', () => {
  69.             this.connected = true;
  70.             UserData.read(this.storageKey).then(handleData).catch((e) => {
  71.                 platypus.debug.warn('Storage: connected but received an error', e);
  72.             });
  73.         });
  74.     }
  76.     /**
  77.      * Adds a storage key to the game's storage.
  78.      *
  79.      * @param {String} key The key to add.
  80.      * @param {*} value The data to store at this defined key.
  81.      */
  82.     addKey (key, value) {
  83.         this.map.set(key, value);
  84.         Object.defineProperty(this, key, {
  85.             get: function () {
  86.                 return this.map.get(key);
  87.             },
  88.             set: function (value) {
  89.                 this.map.set(key, value);
  91.                 this.save();
  92.             },
  93.             enumerable: true
  94.         });
  95.     }
  97.     /**
  98.      * Gets a value from storage for the provided storage key.
  99.      *
  100.      * @param {String} key The key for the data to return
  101.      * @return {*}
  102.      */
  103.     get (key) {
  104.         if (!this.map.has(key)) {
  105.             this.addKey(key, null);
  106.         }
  108.         return this[key];
  109.     }
  111.     /**
  112.      * Takes the current game storage and saves it to local storage or Springroll UserData
  113.      *
  114.      */
  115.     save () {
  116.         const save = this.map.toJSON();
  117.         
  118.         if (this.connected) {
  119.             UserData.write(this.storageKey, save).catch((e) => {
  120.                 platypus.debug.warn('Storage: tried to save but received an error', e);
  121.             });
  122.         } else {
  123.             window.localStorage.setItem(this.storageKey, JSON.stringify(save));
  124.         }
  125.     }
  127.     /**
  128.      * Updates a storage key's data. Creates the key if it does not exist.
  129.      *
  130.      * @param {String} key The key to update.
  131.      * @param {*} value The data to store at this key.
  132.      */
  133.     set (key, value) {
  134.         if (!this.map.has(key)) {
  135.             this.addKey(key, value);
  136.             this.save();
  137.         } else {
  138.             this[key] = value;
  139.         }
  140.     }
  141. };
  143. export default Storage;