@ohos-ports/cross-storage 1.0.0-beta.0

package/lib/hub.js

@@ -0,0 +1,299 @@
+;(function(root) {
+  var CrossStorageHub = {};
+
+  /**
+   * In Node.js/OHOS in-process mode, _storage holds a localStorage-compatible
+   * object. When set, all hub methods use this instead of window.localStorage.
+   *
+   * @private
+   */
+  CrossStorageHub._storage = null;
+
+  /**
+   * Returns the active storage backend. Uses _storage if set (in-process mode),
+   * otherwise falls back to window.localStorage (browser mode).
+   *
+   * @private
+   * @returns {object} localStorage-compatible storage
+   */
+  CrossStorageHub._getStorage = function() {
+    if (CrossStorageHub._storage) {
+      return CrossStorageHub._storage;
+    }
+    return window.localStorage;
+  };
+
+  /**
+   * Accepts an array of objects with two keys: origin and allow. The value
+   * of origin is expected to be a RegExp, and allow, an array of strings.
+   * The cross storage hub is then initialized to accept requests from any of
+   * the matching origins, allowing access to the associated lists of methods.
+   * Methods may include any of: get, set, del, getKeys and clear. A 'ready'
+   * message is sent to the parent window once complete.
+   *
+   * @example
+   * // Subdomain can get, but only root domain can set and del
+   * CrossStorageHub.init([
+   *   {origin: /\.example.com$/,        allow: ['get']},
+   *   {origin: /:(www\.)?example.com$/, allow: ['get', 'set', 'del']}
+   * ]);
+   *
+   * @param {array} permissions An array of objects with origin and allow
+   */
+  CrossStorageHub.init = function(permissions) {
+    // In-process mode: skip browser checks
+    if (CrossStorageHub._storage) {
+      CrossStorageHub._permissions = permissions || [];
+      return;
+    }
+
+    var available = true;
+
+    // Return if localStorage is unavailable, or third party
+    // access is disabled
+    try {
+      if (!window.localStorage) available = false;
+    } catch (e) {
+      available = false;
+    }
+
+    if (!available) {
+      try {
+        return window.parent.postMessage('cross-storage:unavailable', '*');
+      } catch (e) {
+        return;
+      }
+    }
+
+    CrossStorageHub._permissions = permissions || [];
+    CrossStorageHub._installListener();
+    window.parent.postMessage('cross-storage:ready', '*');
+  };
+
+  /**
+   * Installs the necessary listener for the window message event. Accommodates
+   * IE8 and up.
+   *
+   * @private
+   */
+  CrossStorageHub._installListener = function() {
+    var listener = CrossStorageHub._listener;
+    if (window.addEventListener) {
+      window.addEventListener('message', listener, false);
+    } else {
+      window.attachEvent('onmessage', listener);
+    }
+  };
+
+  /**
+   * The message handler for all requests posted to the window. It ignores any
+   * messages having an origin that does not match the originally supplied
+   * pattern. Given a JSON object with one of get, set, del or getKeys as the
+   * method, the function performs the requested action and returns its result.
+   *
+   * @param {MessageEvent} message A message to be processed
+   */
+  CrossStorageHub._listener = function(message) {
+    var origin, targetOrigin, request, method, error, result, response;
+
+    // postMessage returns the string "null" as the origin for "file://"
+    origin = (message.origin === 'null') ? 'file://' : message.origin;
+
+    // Handle polling for a ready message
+    if (message.data === 'cross-storage:poll') {
+      return window.parent.postMessage('cross-storage:ready', message.origin);
+    }
+
+    // Ignore the ready message when viewing the hub directly
+    if (message.data === 'cross-storage:ready') return;
+
+    // Check whether message.data is a valid json
+    try {
+      request = JSON.parse(message.data);
+    } catch (err) {
+      return;
+    }
+
+    // Check whether request.method is a string
+    if (!request || typeof request.method !== 'string') {
+      return;
+    }
+
+    method = request.method.split('cross-storage:')[1];
+
+    if (!method) {
+      return;
+    } else if (!CrossStorageHub._permitted(origin, method)) {
+      error = 'Invalid permissions for ' + method;
+    } else {
+      try {
+        result = CrossStorageHub['_' + method](request.params);
+      } catch (err) {
+        error = err.message;
+      }
+    }
+
+    response = JSON.stringify({
+      id: request.id,
+      error: error,
+      result: result
+    });
+
+    // postMessage requires that the target origin be set to "*" for "file://"
+    targetOrigin = (origin === 'file://') ? '*' : origin;
+
+    window.parent.postMessage(response, targetOrigin);
+  };
+
+  /**
+   * Returns a boolean indicating whether or not the requested method is
+   * permitted for the given origin. The argument passed to method is expected
+   * to be one of 'get', 'set', 'del' or 'getKeys'.
+   *
+   * @param   {string} origin The origin for which to determine permissions
+   * @param   {string} method Requested action
+   * @returns {bool}   Whether or not the request is permitted
+   */
+  CrossStorageHub._permitted = function(origin, method) {
+    var available, i, entry, match;
+
+    available = ['get', 'set', 'del', 'clear', 'getKeys'];
+    if (!CrossStorageHub._inArray(method, available)) {
+      return false;
+    }
+
+    for (i = 0; i < CrossStorageHub._permissions.length; i++) {
+      entry = CrossStorageHub._permissions[i];
+      if (!(entry.origin instanceof RegExp) || !(entry.allow instanceof Array)) {
+        continue;
+      }
+
+      match = entry.origin.test(origin);
+      if (match && CrossStorageHub._inArray(method, entry.allow)) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+
+  /**
+   * Sets a key to the specified value.
+   *
+   * @param {object} params An object with key and value
+   */
+  CrossStorageHub._set = function(params) {
+    CrossStorageHub._getStorage().setItem(params.key, params.value);
+  };
+
+  /**
+   * Accepts an object with an array of keys for which to retrieve their values.
+   * Returns a single value if only one key was supplied, otherwise it returns
+   * an array. Any keys not set result in a null element in the resulting array.
+   *
+   * @param   {object} params An object with an array of keys
+   * @returns {*|*[]}  Either a single value, or an array
+   */
+  CrossStorageHub._get = function(params) {
+    var storage, result, i, value;
+
+    storage = CrossStorageHub._getStorage();
+    result = [];
+
+    for (i = 0; i < params.keys.length; i++) {
+      try {
+        value = storage.getItem(params.keys[i]);
+      } catch (e) {
+        value = null;
+      }
+
+      result.push(value);
+    }
+
+    return (result.length > 1) ? result : result[0];
+  };
+
+  /**
+   * Deletes all keys specified in the array found at params.keys.
+   *
+   * @param {object} params An object with an array of keys
+   */
+  CrossStorageHub._del = function(params) {
+    var storage = CrossStorageHub._getStorage();
+    for (var i = 0; i < params.keys.length; i++) {
+      storage.removeItem(params.keys[i]);
+    }
+  };
+
+  /**
+   * Clears localStorage.
+   */
+  CrossStorageHub._clear = function() {
+    CrossStorageHub._getStorage().clear();
+  };
+
+  /**
+   * Returns an array of all keys stored in localStorage.
+   *
+   * @returns {string[]} The array of keys
+   */
+  CrossStorageHub._getKeys = function(params) {
+    var i, length, keys, storage;
+
+    storage = CrossStorageHub._getStorage();
+    keys = [];
+    length = storage.length;
+
+    for (i = 0; i < length; i++) {
+      keys.push(storage.key(i));
+    }
+
+    return keys;
+  };
+
+  /**
+   * Returns whether or not a value is present in the array. Consists of an
+   * alternative to extending the array prototype for indexOf, since it's
+   * unavailable for IE8.
+   *
+   * @param   {*}    value The value to find
+   * @parma   {[]*}  array The array in which to search
+   * @returns {bool} Whether or not the value was found
+   */
+  CrossStorageHub._inArray = function(value, array) {
+    for (var i = 0; i < array.length; i++) {
+      if (value === array[i]) return true;
+    }
+
+    return false;
+  };
+
+  /**
+   * A cross-browser version of Date.now compatible with IE8 that avoids
+   * modifying the Date object.
+   *
+   * @return {int} The current timestamp in milliseconds
+   */
+  CrossStorageHub._now = function() {
+    if (typeof Date.now === 'function') {
+      return Date.now();
+    }
+
+    return new Date().getTime();
+  };
+
+  /**
+   * Export for various environments.
+   */
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = CrossStorageHub;
+  } else if (typeof exports !== 'undefined') {
+    exports.CrossStorageHub = CrossStorageHub;
+  } else if (typeof define === 'function' && define.amd) {
+    define([], function() {
+      return CrossStorageHub;
+    });
+  } else {
+    root.CrossStorageHub = CrossStorageHub;
+  }
+}(typeof global !== 'undefined' ? global : this));

package/lib/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  CrossStorageClient: require('./client.js'),
+  CrossStorageHub:    require('./hub.js')
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@ohos-ports/cross-storage",
+  "version": "1.0.0-beta.0",
+  "description": "Cross domain local storage",
+  "keywords": [
+    "local",
+    "storage",
+    "cross",
+    "domain"
+  ],
+  "main": "lib/index.js",
+  "author": "Daniel St. Jules <danielst.jules@gmail.com>",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/zendesk/cross-storage",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/cross-storage/1.0.0"
+  },
+  "devDependencies": {
+    "connect": "^2.25.7",
+    "expect.js": "^0.3.1",
+    "gulp": "*",
+    "gulp-header": "^1.1.1",
+    "gulp-jshint": "^1.8.4",
+    "gulp-rename": "^1.2.0",
+    "gulp-rimraf": "^0.1.0",
+    "gulp-uglify": "^0.3.1",
+    "serve-static": "^1.5.3",
+    "zuul": "~3.10.1"
+  },
+  "scripts": {
+    "test": "node test/ohos-test.js",
+    "saucetest": "./node_modules/.bin/zuul --ui mocha-bdd -- test/test.js"
+  },
+  "dependencies": {},
+  "files": [
+    "lib/",
+    "dist/"
+  ]
+}