stack methods added

Author: yusufshakeel

README.md

@@ -5,19 +5,15 @@ Cache data using JavaScript in the browser.
 ### Status
 
 [![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/yusufshakeel/dyCacheJS)
-[![npm version](https://img.shields.io/badge/npm-1.1.0-blue.svg)](https://www.npmjs.com/package/dycachejs)
+[![npm version](https://img.shields.io/badge/npm-1.3.0-blue.svg)](https://www.npmjs.com/package/dycachejs)
 [![Build Status](https://travis-ci.org/yusufshakeel/dyCacheJS.svg?branch=master)](https://travis-ci.org/yusufshakeel/dyCacheJS)
-
+[![](https://data.jsdelivr.com/v1/package/npm/dycachejs/badge)](https://www.jsdelivr.com/package/npm/dycachejs)
 
 ### Getting Started
 * Download the [latest release](https://github.com/yusufshakeel/dyCacheJS/releases) of the project.
 * Clone the repo: `git clone https://github.com/yusufshakeel/dyCacheJS.git`
 * Install via npm: `npm install --save dycachejs`
-* Use from jsDelivr CDN: `https://cdn.jsdelivr.net/npm/dycachejs@version/dist/js/dyCache.min.js`
-
-Note! For jsDelive CDN, replace `@version` with the version you want to use like `@1.1.0`.
-
-Example `https://cdn.jsdelivr.net/npm/dycachejs@1.1.0/dist/js/dyCache.min.js`
+* Use from jsDelivr CDN: `https://www.jsdelivr.com/package/npm/dycachejs`
 
 
 ### Documentation

dist/js/dyCache.min.js

@@ -436,6 +436,135 @@ var dyCache = /** @class */ (function () {
         }
         return -1;
     };
+    /**
+     * This will initialise a new stack in the cache and will refer it by key.
+     * @param {string} key
+     */
+    dyCache.prototype.stackInit = function (key) {
+        this._cache[key] = [];
+    };
+    /**
+     * This will create a stack in the cache and will refer it by key.
+     *
+     * @param {string} key
+     * @param value
+     */
+    dyCache.prototype.stackPush = function (key, value) {
+        // create array for the key if not exists
+        if (!this.exists(key)) {
+            this._cache[key] = [];
+        }
+        this._cache[key].push(value);
+    };
+    /**
+     * This will pop the last element from the right side of the stack
+     * referred by key in the cache.
+     *
+     * On success return the element. Otherwise undefined.
+     *
+     * @param {string} key
+     * @returns {any}
+     */
+    dyCache.prototype.stackPop = function (key) {
+        // if stack referred by the key exists in the cache
+        if (typeof key !== 'undefined' && typeof this._cache[key] !== "undefined") {
+            return this._cache[key].pop();
+        }
+        return undefined;
+    };
+    /**
+     * This will check if stack referred by the key in the cache exists.
+     *
+     * On success return true. Otherwise false.
+     *
+     * @param {string} key
+     * @returns {boolean}
+     */
+    dyCache.prototype.stackExists = function (key) {
+        return typeof this._cache[key] !== "undefined";
+    };
+    /**
+     * This will return the last element in the stack referred by key
+     * in the cache.
+     *
+     * On success return the value. Otherwise, null.
+     *
+     * @param {string} key
+     * @returns {any}
+     */
+    dyCache.prototype.stackPeek = function (key) {
+        // if stack referred by the key exists in the cache
+        if (typeof key !== 'undefined' && typeof this._cache[key] !== "undefined") {
+            // return just the element like: 10
+            // and not in an array like: [10]
+            return this._cache[key].slice(-1)[0];
+        }
+        return null;
+    };
+    /**
+     * This will return total number of elements in the stack referred by
+     * key in the cache.
+     *
+     * On success return a number representing total number of elements.
+     * Otherwise, -1.
+     *
+     * @param {string} key
+     * @returns {number}
+     */
+    dyCache.prototype.stackLength = function (key) {
+        // if stack referred by the key exists in the cache
+        if (typeof key !== 'undefined' && typeof this._cache[key] !== "undefined") {
+            return Object.keys(this._cache[key]).length;
+        }
+        return -1;
+    };
+    /**
+     * This will return true if stack referred by key in the cache is empty.
+     * Otherwise false.
+     *
+     * @param {string} key
+     * @returns {boolean}
+     */
+    dyCache.prototype.stackIsEmpty = function (key) {
+        // if stack referred by key does not exists then return false
+        if (!this.stackExists(key)) {
+            return undefined;
+        }
+        return this.stackLength(key) === 0;
+    };
+    /**
+     * This will remove all the elements from the stack referred by key
+     * in the cache.
+     *
+     * On success return true. Otherwise, false.
+     *
+     * @param {string} key
+     * @returns {boolean}
+     */
+    dyCache.prototype.stackPurge = function (key) {
+        // if stack referred by key does not exists then return false
+        if (!this.stackExists(key)) {
+            return false;
+        }
+        this.stackInit(key);
+        return true;
+    };
+    /**
+     * This will delete the stack from the cache.
+     *
+     * On success return true. Otherwise false.
+     *
+     * @param {string} key
+     * @returns {boolean}
+     */
+    dyCache.prototype.stackDelete = function (key) {
+        // if stack referred by key does not exists then return false
+        if (!this.stackExists(key)) {
+            return false;
+        }
+        this.del(key);
+        return true;
+    };
     return dyCache;
 }());