react-qml/dist/common/AsyncStorage.js

React QML

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.AsyncStorage = void 0;

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

// @see https://facebook.github.io/react-native/docs/asyncstorage
var DB_NAME = 'ReactQML_AsyncStorage';
var DB_VERSION = '0.1';
var TABLE_NAME = 'data';
var db;

try {
  db = LocalStorage.openDatabaseSync(DB_NAME, DB_VERSION, DB_NAME, 1000000);
} catch (error) {
  throw new Error("\n  Unable to start AsyncStorage engine. Make sure LocalStorage is imported in your index.qml:\n    \n  `import QtQuick.LocalStorage 2.0`\n  \n  ");
}

try {
  db.transaction(function (tx) {
    return tx.executeSql("CREATE TABLE IF NOT EXISTS ".concat(TABLE_NAME, " (key TEXT NOT NULL UNIQUE, value TEXT)"));
  });
} catch (err) {
  throw new Error("Unable to start AsyncStorage engine. Error details: ".concat(err));
}

var AsyncStorage =
/*#__PURE__*/
function () {
  function AsyncStorage() {
    _classCallCheck(this, AsyncStorage);
  }

  _createClass(AsyncStorage, null, [{
    key: "getItem",
    value: function getItem(key, callback) {
      return new Promise(function (resolve, reject) {
        db.transaction(function (tx) {
          try {
            var rs = tx.executeSql("SELECT * from ".concat(TABLE_NAME, " WHERE key = '").concat(key, "'"));
            var result = rs.rows.length > 0 ? rs.rows[0].value : '';
            callback && callback(undefined, result);
            resolve(result);
          } catch (error) {
            callback && callback(error);
            reject(error);
          }
        });
      });
    }
  }, {
    key: "setItem",
    value: function setItem(key, value, callback) {
      return new Promise(function (resolve, reject) {
        db.transaction(function (tx) {
          try {
            tx.executeSql("INSERT OR REPLACE INTO ".concat(TABLE_NAME, " (key, value) VALUES (?, ?)"), [key, value]);
            callback && callback();
            resolve();
          } catch (error) {
            callback && callback(error);
            reject(error);
          }
        });
      });
    }
  }, {
    key: "removeItem",
    value: function removeItem(key, callback) {
      return new Promise(function (resolve, reject) {
        db.transaction(function (tx) {
          try {
            tx.executeSql("DELETE FROM ".concat(TABLE_NAME, " WHERE key = '").concat(key, "'"));
            callback && callback();
            resolve();
          } catch (error) {
            callback && callback(error);
            reject(error);
          }
        });
      });
    }
  }, {
    key: "mergeItem",
    value: function mergeItem(key, value, callback) {
      return Promise.reject(new Error('Not implemented'));
    }
  }, {
    key: "clear",
    value: function clear(callback) {
      return new Promise(function (resolve, reject) {
        db.transaction(function (tx) {
          try {
            tx.executeSql("DELETE FROM ".concat(TABLE_NAME));
            callback && callback();
            resolve();
          } catch (error) {
            callback && callback(error);
            reject(error);
          }
        });
      });
    }
  }, {
    key: "getAllKeys",
    value: function getAllKeys(callback) {
      return new Promise(function (resolve, reject) {
        db.transaction(function (tx) {
          try {
            var rs = tx.executeSql("SELECT key FROM ".concat(TABLE_NAME)); // cannot use map() here, sad

            var results = [];

            for (var index = 0; index < rs.rows.length; index++) {
              var row = rs.rows[index];
              results.push(row.key);
            }

            callback && callback(undefined, results);
            resolve(results);
          } catch (error) {
            callback && callback(error);
            reject(error);
          }
        });
      });
    }
  }, {
    key: "multiGet",
    value: function multiGet(keys, callback) {
      return Promise.reject([new Error('Not implemented')]);
    }
  }, {
    key: "multiSet",
    value: function multiSet(keyValuePairs, callback) {
      return Promise.reject([new Error('Not implemented')]);
    }
  }, {
    key: "multiRemove",
    value: function multiRemove(keys, callback) {
      return Promise.reject([new Error('Not implemented')]);
    }
  }, {
    key: "multiMerge",
    value: function multiMerge(keyValuePairs, callback) {
      return Promise.reject([new Error('Not implemented')]);
    }
  }]);

  return AsyncStorage;
}();

exports.AsyncStorage = AsyncStorage;
var _default = AsyncStorage;
exports.default = _default;