cachejs

Author: rajkumardusad

Diff for: .gitignore

@@ -0,0 +1,3 @@
+node_modules
+package-lock.json
+

Diff for: README.md

@@ -0,0 +1,222 @@
+## Cachejs
+
+[![NPM Version][npm-version-image]][npm-url]
+[![NPM Install Size][npm-install-size-image]][npm-install-size-url]
+[![NPM Downloads][npm-downloads-image]][npm-downloads-url]
+
+Cachejs is a fast and lightweight caching library for javascript.
+
+## Features
+
+- Super Fast
+- Lightweight
+- Multiple cache eviction policy (FIFO, LIFO, LRU, MRU)
+- TTL support
+- Custom cache-miss value
+
+## Installation
+
+Install using npm:
+
+```console
+$ npm i @opensnip/cachejs
+```
+
+Install using yarn:
+
+```console
+$ yarn add @opensnip/cachejs
+```
+
+## Example
+
+A simple cachejs cache example:
+
+```js
+const Cache = require("@opensnip/cachejs");
+
+// Create cache object
+const cache = new Cache();
+
+// Add data in cache
+cache.set("a", 10);
+
+// Check data exists in cache
+cache.has("a");
+
+// Get data from cache
+console.log(cache.get("a"));
+
+// Get all data from cache
+cache.forEach(function (data) {
+  console.log(data); // { a: 10 }
+});
+
+// Get all data to array
+console.log(cache.toArray());
+
+// Delete data from cache
+cache.delete("a");
+
+// Delete all data from cache
+cache.clear();
+```
+
+## Create a new cache object
+
+To create a new cache we need to create a new instance of cachejs. While creating a new cache we can set the configuration like eviction policy, cache max length and ttl, but it is not mandatory and if we not set any configuration then the default values are used.
+
+Defination:
+```js
+const cache = new Cache(options);
+```
+
+Where options are the following:
+- `evictionPolicy` : eviction policy is can be any valid cache eviction policy, supported eviction policy are FIFO, LIFO, LRU, MRU
+- `maxLength` : max length is a cache max length, max length is a positive integer value. The default value is 0, if the value is 0 then it will not check the max length.
+- `ttl` : is cache expires time in milliseconds, the default value is 0 and if value if 0 it will not check the ttl.
+- `interval` : interval is the time interval in milliseconds, after every interval all the expired values are automatically removed. Default value is 0 and if value is 0 the it will not removes expired values automatically, but don't worry expired items are treated as missing, and deleted when they are fetched.
+- `enableInterval` : enableInterval is a boolean value that is used to enable and disable the interval, the default value is false and if value is explicitly set false then it will not run the interval even if the interval time is set.
+
+Cachejs support TTL, but it is not a TTL cache, and also does not make strong TTL guarantees. When interval is set expired values are removed from cache periodically.
+
+Example:
+```js
+const Cache = require("@opensnip/cachejs");
+
+// Create cache object
+const cache = new Cache({
+  evictionPolicy: "LRU",
+  maxLength: 10,
+  ttl: 100,
+  interval: 1000,
+});
+```
+
+## Set a new data
+
+In cachejs any value (both objects and primitive values) may be used as either a key or a value, duplicate keys not allowed and if duplicate item is inserted it will be replaced by the new item.
+
+```js
+// Add new data in cache
+cache.set("a", 10);
+
+// Add new data in cache
+cache.set("user", { name: "abc" });
+
+// Add duplicate data
+cache.set("a", 20); // Replace the old value
+
+## Set ttl for single data
+
+By default the configuration TTL value is used for every item, but we can set TTL for a single item.
+
+```js
+// Add new data in cache
+cache.set("b", 10, { ttl: 200 }); // Expires after 200 ms
+```
+
+## Get data from cache
+
+By default on cache miss cachejs returns undefined value, but undefined also can be used as a value for item. In this case you can return a custom value on cache miss.
+
+```js
+// Add new data in cache
+cache.set("a", 10);
+
+// Get data
+cache.get("a"); // 10
+```
+
+Customize cache miss value:
+
+```js
+// Add new data in cache
+cache.set("a", undefined);
+
+cache.get("a"); // undefined
+cache.get("b"); // undefined
+
+// Set custom return value
+cache.get("a", function (err, value) {
+  if (err) return null;
+  return value;
+}); // undefined
+
+cache.get("b", function (err, value) {
+  if (err) return null;
+  return value;
+}); // null
+```
+
+## Check data exists in cache
+
+Check weather item exists in the cache or not.
+
+```js
+// Add new data in cache
+cache.set("a", undefined);
+
+// Check data exists or not
+cache.has("a"); // true
+cache.has("b"); // false
+```
+
+## Delete data from cache
+
+Remove data from cache.
+
+```js
+// Delete data
+cache.delete("a");
+```
+
+## Delete all data from cache
+
+Remove all data from the cache.
+
+```js
+// Delete all data
+cache.clear();
+```
+
+## Get all data from cache
+
+Get all data from the cache.
+
+```js
+// Add new data in cache
+cache.set("a", 10);
+
+// Get all data
+cache.forEach(function (data) {
+  console.log(data); // { a: 10 }
+});
+
+// OR
+
+for (let data of cache) {
+  console.log(data); // { a: 10 }
+}
+```
+
+## Get data as array
+
+```js
+// Add new data in cache
+cache.set("a", 10);
+
+// Get all data
+console.log(cache.toArray()); // [ { a: 10 } ]
+```
+
+## License
+
+[MIT License](https://github.com/opensnip/cachejs/blob/main/LICENSE)
+
+[npm-downloads-image]: https://badgen.net/npm/dm/@opensnip/cachejs
+[npm-downloads-url]: https://npmcharts.com/compare/@opensnip/cachejs?minimal=true
+[npm-install-size-image]: https://badgen.net/packagephobia/install/@opensnip/cachejs
+[npm-install-size-url]: https://packagephobia.com/result?p=@opensnip/cachejs
+[npm-url]: https://npmjs.org/package/@opensnip/cachejs
+[npm-version-image]: https://badgen.net/npm/v/@opensnip/cachejs

Diff for: index.cjs

@@ -0,0 +1,2 @@
+const Cache = require("./src/cache.cjs");
+module.exports = Cache;

Diff for: index.d.ts

@@ -0,0 +1,26 @@
+declare type cacheEvictionPolicy = "FIFO" | "LIFO" | "LRU" | "MRU";
+
+declare class Cache {
+  length: number;
+  constructor(options?: {
+    evictionPolicy?: cacheEvictionPolicy;
+    maxLength?: number;
+    ttl?: number;
+    interval?: number;
+    enableInterval?: boolean;
+  });
+  set: (key: any, value: any, options?: { ttl?: number }) => void;
+  startInterval: () => void;
+  clearInterval: () => void;
+  get: (
+    key: any,
+    callback?: (err: Error | undefined, value: any) => any
+  ) => any;
+  delete: (key: any) => void;
+  clear: () => void;
+  has: (key: any) => boolean;
+  forEach: (callback: (element: object, index?: number) => void) => void;
+  toArray: () => any[];
+}
+
+export default Cache;

Diff for: index.mjs

@@ -0,0 +1 @@
+export { default } from "./src/cache.mjs";

Diff for: package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@opensnip/cachejs",
+  "version": "1.0.0",
+  "description": "Fast and lightweight caching library for javascript",
+  "main": "index.mjs",
+  "type": "module",
+  "exports": {
+    "types": "./index.d.ts",
+    "node": {
+      "import": "./index.mjs",
+      "require": "./index.cjs"
+    },
+    "default": "./index.cjs"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "jest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/opensnip/cachejs.git"
+  },
+  "keywords": [
+    "opensnip",
+    "cachejs",
+    "lru cache",
+    "mru cache",
+    "lfu cache",
+    "mfu cache",
+    "fifo cache",
+    "lifo cache",
+    "cache",
+    "nodejs",
+    "library"
+  ],
+  "author": "Rajkumar Dusad",
+  "license": "MIT",
+  "types": "./index.d.ts",
+  "bugs": {
+    "url": "https://github.com/opensnip/cachejs/issues"
+  },
+  "homepage": "https://github.com/opensnip/cachejs#readme",
+  "devDependencies": {
+    "jest": "^29.4.2"
+  },
+  "files": [
+    "src/",
+    "LICENSE",
+    "README.md",
+    "index.cjs",
+    "index.mjs",
+    "index.d.ts"
+  ]
+}

Diff for: src/cache.cjs

@@ -0,0 +1,163 @@
+const FIFO = require("./fifo.cjs");
+const LIFO = require("./lifo.cjs");
+const LRU = require("./lru.cjs");
+const MRU = require("./mru.cjs");
+
+module.exports = class Cache {
+  #cache = null;
+  #config = {
+    evictionPolicy: "LRU",
+    ttl: 0,
+    maxLength: 0,
+    interval: 0,
+    intervalId: null,
+    enableInterval: false,
+  };
+
+  constructor(options = {}) {
+    if (
+      typeof options.evictionPolicy !== "undefined" &&
+      typeof options.evictionPolicy !== "string"
+    ) {
+      throw new TypeError("evictionPolicy should be string");
+    }
+
+    if (
+      (typeof options.maxLength !== "undefined" &&
+        typeof options.maxLength !== "number") ||
+      options.maxLength < 0
+    ) {
+      throw new TypeError("maxLength should be positive integer value");
+    }
+
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    if (
+      typeof options.enableInterval !== "undefined" &&
+      typeof options.enableInterval !== "boolean"
+    ) {
+      throw new TypeError("enableInterval should be boolean");
+    }
+
+    if (
+      (typeof options.interval !== "undefined" &&
+        typeof options.interval !== "number") ||
+      options.interval < 0
+    ) {
+      throw new TypeError("interval should be positive integer value");
+    }
+
+    options.evictionPolicy = options.evictionPolicy || "LRU";
+    options.maxLength =
+      typeof options.maxLength === "number" ? options.maxLength : 1000;
+    options.ttl = typeof options.ttl === "number" ? options.ttl : 0;
+    if (
+      typeof options.interval === "number" &&
+      typeof options.enableInterval !== "boolean"
+    ) {
+      options.enableInterval = true;
+    }
+    options.interval =
+      typeof options.interval === "number" ? options.interval : 1000 * 60;
+    options.enableInterval =
+      typeof options.enableInterval === "boolean"
+        ? options.enableInterval
+        : false;
+
+    this.#config.evictionPolicy = options.evictionPolicy;
+    this.#config.maxLength = options.maxLength;
+    this.#config.ttl = options.ttl;
+    this.#config.interval = options.interval;
+    this.#config.enableInterval =
+      options.interval > 0 ? options.enableInterval : false;
+
+    switch (options.evictionPolicy.toUpperCase()) {
+      case "LRU":
+        this.#cache = new LRU(options);
+        break;
+      case "MRU":
+        this.#cache = new MRU(options);
+        break;
+      case "FIFO":
+        this.#cache = new FIFO(options);
+        break;
+      case "LIFO":
+        this.#cache = new LIFO(options);
+        break;
+      default:
+        throw new TypeError(
+          options.evictionPolicy + " cache eviction policy is not supported"
+        );
+    }
+    // Automatically remove expires cache
+    this.startInterval();
+  }
+
+  get length() {
+    return this.#cache.length;
+  }
+
+  get(key, callback = undefined) {
+    return this.#cache.get(key, callback);
+  }
+
+  set(key, value, options = {}) {
+    return this.#cache.set(key, value, options);
+  }
+
+  delete(key) {
+    return this.#cache.delete(key);
+  }
+
+  clear() {
+    return this.#cache.clear();
+  }
+
+  startInterval() {
+    // Interval already running
+    if (this.#config.intervalId) return;
+    // Interval is disabled
+    if (!this.#config.enableInterval) return;
+
+    this.#config.intervalId = setInterval(
+      function (cache) {
+        if (cache.length == 0) return;
+        cache.forEach(function (data) {
+          // Automatically invalidate expired cache
+        });
+      },
+      this.#config.interval,
+      this.#cache
+    );
+  }
+
+  clearInterval() {
+    if (this.#config.intervalId) {
+      clearInterval(this.#config.intervalId);
+    }
+  }
+
+  has(key) {
+    return this.#cache.has(key);
+  }
+
+  forEach(callback) {
+    return this.#cache.forEach(callback);
+  }
+
+  toArray() {
+    return this.#cache.toArray();
+  }
+
+  // Iterator to iterate over cache with a 'for...of' loop
+  *[Symbol.iterator]() {
+    for (let cache of this.#cache) {
+      yield cache;
+    }
+  }
+};

Diff for: src/cache.mjs

@@ -0,0 +1,163 @@
+import FIFO from "./fifo.mjs";
+import LIFO from "./lifo.mjs";
+import LRU from "./lru.mjs";
+import MRU from "./mru.mjs";
+
+export default class Cache {
+  #cache = null;
+  #config = {
+    evictionPolicy: "LRU",
+    ttl: 0,
+    maxLength: 0,
+    interval: 0,
+    intervalId: null,
+    enableInterval: false,
+  };
+
+  constructor(options = {}) {
+    if (
+      typeof options.evictionPolicy !== "undefined" &&
+      typeof options.evictionPolicy !== "string"
+    ) {
+      throw new TypeError("evictionPolicy should be string");
+    }
+
+    if (
+      (typeof options.maxLength !== "undefined" &&
+        typeof options.maxLength !== "number") ||
+      options.maxLength < 0
+    ) {
+      throw new TypeError("maxLength should be positive integer value");
+    }
+
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    if (
+      typeof options.enableInterval !== "undefined" &&
+      typeof options.enableInterval !== "boolean"
+    ) {
+      throw new TypeError("enableInterval should be boolean");
+    }
+
+    if (
+      (typeof options.interval !== "undefined" &&
+        typeof options.interval !== "number") ||
+      options.interval < 0
+    ) {
+      throw new TypeError("interval should be positive integer value");
+    }
+
+    options.evictionPolicy = options.evictionPolicy || "LRU";
+    options.maxLength =
+      typeof options.maxLength === "number" ? options.maxLength : 1000;
+    options.ttl = typeof options.ttl === "number" ? options.ttl : 0;
+    if (
+      typeof options.interval === "number" &&
+      typeof options.enableInterval !== "boolean"
+    ) {
+      options.enableInterval = true;
+    }
+    options.interval =
+      typeof options.interval === "number" ? options.interval : 1000 * 60;
+    options.enableInterval =
+      typeof options.enableInterval === "boolean"
+        ? options.enableInterval
+        : false;
+
+    this.#config.evictionPolicy = options.evictionPolicy;
+    this.#config.maxLength = options.maxLength;
+    this.#config.ttl = options.ttl;
+    this.#config.interval = options.interval;
+    this.#config.enableInterval =
+      options.interval > 0 ? options.enableInterval : false;
+
+    switch (options.evictionPolicy.toUpperCase()) {
+      case "LRU":
+        this.#cache = new LRU(options);
+        break;
+      case "MRU":
+        this.#cache = new MRU(options);
+        break;
+      case "FIFO":
+        this.#cache = new FIFO(options);
+        break;
+      case "LIFO":
+        this.#cache = new LIFO(options);
+        break;
+      default:
+        throw new TypeError(
+          options.evictionPolicy + " cache eviction policy is not supported"
+        );
+    }
+    // Automatically remove expires cache
+    this.startInterval();
+  }
+
+  get length() {
+    return this.#cache.length;
+  }
+
+  get(key, callback = undefined) {
+    return this.#cache.get(key, callback);
+  }
+
+  set(key, value, options = {}) {
+    return this.#cache.set(key, value, options);
+  }
+
+  delete(key) {
+    return this.#cache.delete(key);
+  }
+
+  clear() {
+    return this.#cache.clear();
+  }
+
+  startInterval() {
+    // Interval already running
+    if (this.#config.intervalId) return;
+    // Interval is disabled
+    if (!this.#config.enableInterval) return;
+
+    this.#config.intervalId = setInterval(
+      function (cache) {
+        if (cache.length == 0) return;
+        cache.forEach(function (data) {
+          // Automatically invalidate expired cache
+        });
+      },
+      this.#config.interval,
+      this.#cache
+    );
+  }
+
+  clearInterval() {
+    if (this.#config.intervalId) {
+      clearInterval(this.#config.intervalId);
+    }
+  }
+
+  has(key) {
+    return this.#cache.has(key);
+  }
+
+  forEach(callback) {
+    return this.#cache.forEach(callback);
+  }
+
+  toArray() {
+    return this.#cache.toArray();
+  }
+
+  // Iterator to iterate over cache with a 'for...of' loop
+  *[Symbol.iterator]() {
+    for (let cache of this.#cache) {
+      yield cache;
+    }
+  }
+}

Diff for: src/fifo.cjs

@@ -0,0 +1,196 @@
+const LinkedList = require("./linkedlist/index.cjs");
+const Node = require("./linkedlist/node.cjs");
+
+module.exports = class FIFO {
+  #linkedList = null;
+  #cache = null;
+  #ttl = 0;
+  #maxLength = 0;
+
+  constructor(options = {}) {
+    if (
+      (typeof options.maxLength !== "undefined" &&
+        typeof options.maxLength !== "number") ||
+      options.maxLength < 0
+    ) {
+      throw new TypeError("maxLength should be positive integer value");
+    }
+
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    if (
+      (typeof options.interval !== "undefined" &&
+        typeof options.interval !== "number") ||
+      options.interval < 0
+    ) {
+      throw new TypeError("interval should be positive integer value");
+    }
+
+    options.maxLength =
+      typeof options.maxLength === "number" ? options.maxLength : 1000;
+    options.ttl = typeof options.ttl === "number" ? options.ttl : 0;
+
+    this.#linkedList = new LinkedList();
+    this.#cache = new Map();
+    this.#ttl = options.ttl;
+    this.#maxLength = options.maxLength;
+  }
+
+  get length() {
+    return this.#cache.size;
+  }
+
+  set(key, value, options = {}) {
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    options.ttl = typeof options.ttl === "number" ? options.ttl : this.#ttl;
+
+    const nodeValue = {
+      key: key,
+      value: value,
+      createdAt: Date.now(),
+      expiresAt: null,
+      ttl: options.ttl,
+      frequency: 0,
+    };
+    if (nodeValue.ttl > 0) {
+      nodeValue.expiresAt = nodeValue.createdAt + nodeValue.ttl;
+    }
+
+    // Insert a new node at head
+    const existingNode = this.#cache.get(key);
+    // Update node data if node is already exists
+    if (existingNode instanceof Node) {
+      existingNode.value = nodeValue;
+    } else {
+      // Remove node if cache is full
+      if (this.length === this.#maxLength) {
+        this.#evict();
+      }
+      // Create new node and make attach it to the head
+      const node = this.#linkedList.insertHead(nodeValue);
+      this.#cache.set(key, node);
+    }
+  }
+
+  get(key, callback = null) {
+    try {
+      if (callback && typeof callback !== "function") {
+        throw new TypeError("callback should be a function");
+      }
+
+      const node = this.#cache.get(key);
+
+      if (node instanceof Node) {
+        // Check node is live or not
+        if (this.#isStale(node)) {
+          this.delete(key);
+          throw new Error(key + " Key not found");
+        }
+
+        if (callback) {
+          return callback(null, node.value.value);
+        } else {
+          return node.value.value;
+        }
+      }
+
+      throw new Error(key + " Key not found");
+    } catch (err) {
+      if (callback) {
+        return callback(err, undefined);
+      } else {
+        return;
+      }
+    }
+  }
+
+  delete(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      this.#linkedList.delete(node);
+      // Delete node
+      this.#cache.delete(key);
+    }
+  }
+
+  #evict() {
+    if (this.#linkedList.tail == null) return;
+    if (this.length !== this.#maxLength) return;
+    this.delete(this.#linkedList.tail.value.key);
+  }
+
+  clear() {
+    // Delete all data from cache
+    this.#linkedList.clear();
+    this.#cache.clear();
+  }
+
+  has(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      // Check node is live or not
+      if (this.#isStale(node)) {
+        this.delete(key);
+      } else {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Iterate over cache using forEach loop
+  forEach(callback) {
+    if (callback && typeof callback !== "function") {
+      throw new TypeError("callback should be a function");
+    }
+
+    let node = this.#linkedList.head;
+    let index = 0;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        callback({ [node.value.key]: node.value.value }, index);
+      }
+      node = next;
+      index++;
+    }
+  }
+
+  toArray() {
+    let values = [];
+    this.forEach(function (data) {
+      values.push(data);
+    });
+    return values;
+  }
+
+  #isStale(node) {
+    if (!node.value.expiresAt) return false;
+    return node.value.expiresAt - Date.now() <= 0;
+  }
+
+  // Iterator to iterate over cache with a 'for...of' loop
+  *[Symbol.iterator]() {
+    let node = this.#linkedList.head;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        yield { [node.value.key]: node.value.value };
+      }
+      node = next;
+    }
+  }
+};

Diff for: src/fifo.mjs

@@ -0,0 +1,196 @@
+import LinkedList from "./linkedlist/index.mjs";
+import Node from "./linkedlist/node.mjs";
+
+export default class FIFO {
+  #linkedList = null;
+  #cache = null;
+  #ttl = 0;
+  #maxLength = 0;
+
+  constructor(options = {}) {
+    if (
+      (typeof options.maxLength !== "undefined" &&
+        typeof options.maxLength !== "number") ||
+      options.maxLength < 0
+    ) {
+      throw new TypeError("maxLength should be positive integer value");
+    }
+
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    if (
+      (typeof options.interval !== "undefined" &&
+        typeof options.interval !== "number") ||
+      options.interval < 0
+    ) {
+      throw new TypeError("interval should be positive integer value");
+    }
+
+    options.maxLength =
+      typeof options.maxLength === "number" ? options.maxLength : 1000;
+    options.ttl = typeof options.ttl === "number" ? options.ttl : 0;
+
+    this.#linkedList = new LinkedList();
+    this.#cache = new Map();
+    this.#ttl = options.ttl;
+    this.#maxLength = options.maxLength;
+  }
+
+  get length() {
+    return this.#cache.size;
+  }
+
+  set(key, value, options = {}) {
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    options.ttl = typeof options.ttl === "number" ? options.ttl : this.#ttl;
+
+    const nodeValue = {
+      key: key,
+      value: value,
+      createdAt: Date.now(),
+      expiresAt: null,
+      ttl: options.ttl,
+      frequency: 0,
+    };
+    if (nodeValue.ttl > 0) {
+      nodeValue.expiresAt = nodeValue.createdAt + nodeValue.ttl;
+    }
+
+    // Insert a new node at head
+    const existingNode = this.#cache.get(key);
+    // Update node data if node is already exists
+    if (existingNode instanceof Node) {
+      existingNode.value = nodeValue;
+    } else {
+      // Remove node if cache is full
+      if (this.length === this.#maxLength) {
+        this.#evict();
+      }
+      // Create new node and make attach it to the head
+      const node = this.#linkedList.insertHead(nodeValue);
+      this.#cache.set(key, node);
+    }
+  }
+
+  get(key, callback = null) {
+    try {
+      if (callback && typeof callback !== "function") {
+        throw new TypeError("callback should be a function");
+      }
+
+      const node = this.#cache.get(key);
+
+      if (node instanceof Node) {
+        // Check node is live or not
+        if (this.#isStale(node)) {
+          this.delete(key);
+          throw new Error(key + " Key not found");
+        }
+
+        if (callback) {
+          return callback(null, node.value.value);
+        } else {
+          return node.value.value;
+        }
+      }
+
+      throw new Error(key + " Key not found");
+    } catch (err) {
+      if (callback) {
+        return callback(err, undefined);
+      } else {
+        return;
+      }
+    }
+  }
+
+  delete(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      this.#linkedList.delete(node);
+      // Delete node
+      this.#cache.delete(key);
+    }
+  }
+
+  #evict() {
+    if (this.#linkedList.tail == null) return;
+    if (this.length !== this.#maxLength) return;
+    this.delete(this.#linkedList.tail.value.key);
+  }
+
+  clear() {
+    // Delete all data from cache
+    this.#linkedList.clear();
+    this.#cache.clear();
+  }
+
+  has(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      // Check node is live or not
+      if (this.#isStale(node)) {
+        this.delete(key);
+      } else {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Iterate over cache using forEach loop
+  forEach(callback) {
+    if (callback && typeof callback !== "function") {
+      throw new TypeError("callback should be a function");
+    }
+
+    let node = this.#linkedList.head;
+    let index = 0;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        callback({ [node.value.key]: node.value.value }, index);
+      }
+      node = next;
+      index++;
+    }
+  }
+
+  toArray() {
+    let values = [];
+    this.forEach(function (data) {
+      values.push(data);
+    });
+    return values;
+  }
+
+  #isStale(node) {
+    if (!node.value.expiresAt) return false;
+    return node.value.expiresAt - Date.now() <= 0;
+  }
+
+  // Iterator to iterate over cache with a 'for...of' loop
+  *[Symbol.iterator]() {
+    let node = this.#linkedList.head;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        yield { [node.value.key]: node.value.value };
+      }
+      node = next;
+    }
+  }
+}

Diff for: src/lifo.cjs

@@ -0,0 +1,196 @@
+const LinkedList = require("./linkedlist/index.cjs");
+const Node = require("./linkedlist/node.cjs");
+
+module.exports = class LIFO {
+  #linkedList = null;
+  #cache = null;
+  #ttl = 0;
+  #maxLength = 0;
+
+  constructor(options = {}) {
+    if (
+      (typeof options.maxLength !== "undefined" &&
+        typeof options.maxLength !== "number") ||
+      options.maxLength < 0
+    ) {
+      throw new TypeError("maxLength should be positive integer value");
+    }
+
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    if (
+      (typeof options.interval !== "undefined" &&
+        typeof options.interval !== "number") ||
+      options.interval < 0
+    ) {
+      throw new TypeError("interval should be positive integer value");
+    }
+
+    options.maxLength =
+      typeof options.maxLength === "number" ? options.maxLength : 1000;
+    options.ttl = typeof options.ttl === "number" ? options.ttl : 0;
+
+    this.#linkedList = new LinkedList();
+    this.#cache = new Map();
+    this.#ttl = options.ttl;
+    this.#maxLength = options.maxLength;
+  }
+
+  get length() {
+    return this.#cache.size;
+  }
+
+  set(key, value, options = {}) {
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    options.ttl = typeof options.ttl === "number" ? options.ttl : this.#ttl;
+
+    const nodeValue = {
+      key: key,
+      value: value,
+      createdAt: Date.now(),
+      expiresAt: null,
+      ttl: options.ttl,
+      frequency: 0,
+    };
+    if (nodeValue.ttl > 0) {
+      nodeValue.expiresAt = nodeValue.createdAt + nodeValue.ttl;
+    }
+
+    // Insert a new node at head
+    const existingNode = this.#cache.get(key);
+    // Update node data if node is already exists
+    if (existingNode instanceof Node) {
+      existingNode.value = nodeValue;
+    } else {
+      // Remove node if cache is full
+      if (this.length === this.#maxLength) {
+        this.#evict();
+      }
+      // Create new node and make attach it to the head
+      const node = this.#linkedList.insertHead(nodeValue);
+      this.#cache.set(key, node);
+    }
+  }
+
+  get(key, callback = null) {
+    try {
+      if (callback && typeof callback !== "function") {
+        throw new TypeError("callback should be a function");
+      }
+
+      const node = this.#cache.get(key);
+
+      if (node instanceof Node) {
+        // Check node is live or not
+        if (this.#isStale(node)) {
+          this.delete(key);
+          throw new Error(key + " Key not found");
+        }
+
+        if (callback) {
+          return callback(null, node.value.value);
+        } else {
+          return node.value.value;
+        }
+      }
+
+      throw new Error(key + " Key not found");
+    } catch (err) {
+      if (callback) {
+        return callback(err, undefined);
+      } else {
+        return;
+      }
+    }
+  }
+
+  delete(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      this.#linkedList.delete(node);
+      // Delete node
+      this.#cache.delete(key);
+    }
+  }
+
+  #evict() {
+    if (this.#linkedList.head == null) return;
+    if (this.length !== this.#maxLength) return;
+    this.delete(this.#linkedList.head.value.key);
+  }
+
+  clear() {
+    // Delete all data from cache
+    this.#linkedList.clear();
+    this.#cache.clear();
+  }
+
+  has(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      // Check node is live or not
+      if (this.#isStale(node)) {
+        this.delete(key);
+      } else {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Iterate over cache using forEach loop
+  forEach(callback) {
+    if (callback && typeof callback !== "function") {
+      throw new TypeError("callback should be a function");
+    }
+
+    let node = this.#linkedList.head;
+    let index = 0;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        callback({ [node.value.key]: node.value.value }, index);
+      }
+      node = next;
+      index++;
+    }
+  }
+
+  toArray() {
+    let values = [];
+    this.forEach(function (data) {
+      values.push(data);
+    });
+    return values;
+  }
+
+  #isStale(node) {
+    if (!node.value.expiresAt) return false;
+    return node.value.expiresAt - Date.now() <= 0;
+  }
+
+  // Iterator to iterate over cache with a 'for...of' loop
+  *[Symbol.iterator]() {
+    let node = this.#linkedList.head;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        yield { [node.value.key]: node.value.value };
+      }
+      node = next;
+    }
+  }
+};

Diff for: src/lifo.mjs

@@ -0,0 +1,196 @@
+import LinkedList from "./linkedlist/index.mjs";
+import Node from "./linkedlist/node.mjs";
+
+export default class LIFO {
+  #linkedList = null;
+  #cache = null;
+  #ttl = 0;
+  #maxLength = 0;
+
+  constructor(options = {}) {
+    if (
+      (typeof options.maxLength !== "undefined" &&
+        typeof options.maxLength !== "number") ||
+      options.maxLength < 0
+    ) {
+      throw new TypeError("maxLength should be positive integer value");
+    }
+
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    if (
+      (typeof options.interval !== "undefined" &&
+        typeof options.interval !== "number") ||
+      options.interval < 0
+    ) {
+      throw new TypeError("interval should be positive integer value");
+    }
+
+    options.maxLength =
+      typeof options.maxLength === "number" ? options.maxLength : 1000;
+    options.ttl = typeof options.ttl === "number" ? options.ttl : 0;
+
+    this.#linkedList = new LinkedList();
+    this.#cache = new Map();
+    this.#ttl = options.ttl;
+    this.#maxLength = options.maxLength;
+  }
+
+  get length() {
+    return this.#cache.size;
+  }
+
+  set(key, value, options = {}) {
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    options.ttl = typeof options.ttl === "number" ? options.ttl : this.#ttl;
+
+    const nodeValue = {
+      key: key,
+      value: value,
+      createdAt: Date.now(),
+      expiresAt: null,
+      ttl: options.ttl,
+      frequency: 0,
+    };
+    if (nodeValue.ttl > 0) {
+      nodeValue.expiresAt = nodeValue.createdAt + nodeValue.ttl;
+    }
+
+    // Insert a new node at head
+    const existingNode = this.#cache.get(key);
+    // Update node data if node is already exists
+    if (existingNode instanceof Node) {
+      existingNode.value = nodeValue;
+    } else {
+      // Remove node if cache is full
+      if (this.length === this.#maxLength) {
+        this.#evict();
+      }
+      // Create new node and make attach it to the head
+      const node = this.#linkedList.insertHead(nodeValue);
+      this.#cache.set(key, node);
+    }
+  }
+
+  get(key, callback = null) {
+    try {
+      if (callback && typeof callback !== "function") {
+        throw new TypeError("callback should be a function");
+      }
+
+      const node = this.#cache.get(key);
+
+      if (node instanceof Node) {
+        // Check node is live or not
+        if (this.#isStale(node)) {
+          this.delete(key);
+          throw new Error(key + " Key not found");
+        }
+
+        if (callback) {
+          return callback(null, node.value.value);
+        } else {
+          return node.value.value;
+        }
+      }
+
+      throw new Error(key + " Key not found");
+    } catch (err) {
+      if (callback) {
+        return callback(err, undefined);
+      } else {
+        return;
+      }
+    }
+  }
+
+  delete(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      this.#linkedList.delete(node);
+      // Delete node
+      this.#cache.delete(key);
+    }
+  }
+
+  #evict() {
+    if (this.#linkedList.head == null) return;
+    if (this.length !== this.#maxLength) return;
+    this.delete(this.#linkedList.head.value.key);
+  }
+
+  clear() {
+    // Delete all data from cache
+    this.#linkedList.clear();
+    this.#cache.clear();
+  }
+
+  has(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      // Check node is live or not
+      if (this.#isStale(node)) {
+        this.delete(key);
+      } else {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Iterate over cache using forEach loop
+  forEach(callback) {
+    if (callback && typeof callback !== "function") {
+      throw new TypeError("callback should be a function");
+    }
+
+    let node = this.#linkedList.head;
+    let index = 0;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        callback({ [node.value.key]: node.value.value }, index);
+      }
+      node = next;
+      index++;
+    }
+  }
+
+  toArray() {
+    let values = [];
+    this.forEach(function (data) {
+      values.push(data);
+    });
+    return values;
+  }
+
+  #isStale(node) {
+    if (!node.value.expiresAt) return false;
+    return node.value.expiresAt - Date.now() <= 0;
+  }
+
+  // Iterator to iterate over cache with a 'for...of' loop
+  *[Symbol.iterator]() {
+    let node = this.#linkedList.head;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        yield { [node.value.key]: node.value.value };
+      }
+      node = next;
+    }
+  }
+}

Diff for: src/linkedlist/index.cjs

@@ -0,0 +1,252 @@
+const Node = require("./node.cjs");
+
+module.exports = class LinkedList {
+  #head = null;
+  #tail = null;
+  #length = 0;
+
+  get head() {
+    return this.#head;
+  }
+
+  get tail() {
+    return this.#tail;
+  }
+
+  get length() {
+    return this.#length;
+  }
+
+  clear() {
+    this.#head = null;
+    this.#tail = null;
+    this.#length = 0;
+  }
+
+  insertHead(value) {
+    const node = new Node(value);
+    if (this.#head === null) {
+      this.#head = this.#tail = node;
+    } else {
+      this.#head.prev = node;
+      node.next = this.#head;
+      this.#head = node;
+    }
+    this.#length++;
+    return node;
+  }
+
+  insertTail(value) {
+    if (this.#tail === null) {
+      return this.insertHead(value);
+    }
+
+    const node = new Node(value);
+    this.#tail.next = node;
+    node.prev = this.#tail;
+    this.#tail = node;
+    this.#length++;
+    return node;
+  }
+
+  insertAfter(node, value) {
+    if (!(node instanceof Node)) {
+      throw new TypeError("node should be a valid Node instance");
+    }
+    const newNode = new Node(value);
+    if (node.next != null) {
+      node.next.prev = newNode;
+      newNode.next = node.next;
+    }
+    newNode.prev = node;
+    node.next = newNode;
+    this.#length++;
+    return node;
+  }
+
+  setHead(node) {
+    if (!(node instanceof Node)) {
+      throw new TypeError("node should be a valid Node instance");
+    }
+
+    if (this.#head === node) return this.#head;
+
+    if (this.#head === null) {
+      return this.insertHead(node.value);
+    }
+
+    this.detach(node);
+    node.prev = null;
+    node.next = this.#head;
+    this.#head.prev = node;
+    this.#head = node;
+    this.#length++;
+    return this.#head;
+  }
+
+  setTail(node) {
+    if (!(node instanceof Node)) {
+      throw new TypeError("node should be a valid Node instance");
+    }
+
+    if (this.#tail === node) return this.#tail;
+
+    if (this.#tail === null) {
+      return this.insertTail(node.value);
+    }
+
+    this.detach(node);
+    this.#tail.next = node;
+    node.prev = this.#tail;
+    node.next = null;
+    this.#tail = node;
+    this.#length++;
+    return this.#tail;
+  }
+
+  swap(leftNode, rightNode) {
+    if (!(leftNode instanceof Node)) {
+      throw new TypeError("leftNode should be a valid Node instance");
+    }
+    if (!(rightNode instanceof Node)) {
+      throw new TypeError("rightNode should be a valid Node instance");
+    }
+
+    if (leftNode === rightNode) return [leftNode, rightNode];
+
+    // Replace left node with right node
+    let tmpRight = new Node(rightNode.value);
+    if (leftNode.prev != null) {
+      leftNode.prev.next = tmpRight;
+    }
+    if (leftNode.next != null) {
+      leftNode.next.prev = tmpRight;
+    }
+    tmpRight.prev = leftNode.prev;
+    tmpRight.next = leftNode.next;
+    if (leftNode == this.#head) this.#head = tmpRight;
+    if (leftNode == this.#tail) this.#tail = tmpRight;
+
+    // Replace right node with left node
+    let tmpLeft = new Node(leftNode.value);
+    if (rightNode.prev != null) {
+      rightNode.prev.next = tmpLeft;
+    }
+    if (rightNode.next != null) {
+      rightNode.next.prev = tmpLeft;
+    }
+    tmpLeft.prev = rightNode.prev;
+    tmpLeft.next = rightNode.next;
+    if (rightNode == this.#head) this.#head = tmpLeft;
+    if (rightNode == this.#tail) this.#tail = tmpLeft;
+
+    delete leftNode.next;
+    delete leftNode.prev;
+    delete leftNode.value;
+    delete rightNode.next;
+    delete rightNode.prev;
+    delete rightNode.value;
+    return [tmpLeft, tmpRight];
+  }
+
+  deleteHead() {
+    if (this.#head == null) return;
+    if (this.#head.next != null) {
+      this.#head.next.prev = null;
+    }
+    delete this.#head.value;
+    this.#head = this.#head.next;
+    this.#length--;
+  }
+
+  deleteTail() {
+    if (this.#tail == null) return;
+    if (this.#tail.prev != null) {
+      this.#tail.prev.next = null;
+    }
+    delete this.#tail.value;
+    this.#tail = this.#tail.prev;
+    this.#length--;
+  }
+
+  delete(node) {
+    if (!(node instanceof Node)) {
+      throw new TypeError("node should be a valid Node instance");
+    }
+    this.detach(node);
+    delete node.prev;
+    delete node.next;
+    delete node.value;
+  }
+
+  detach(node) {
+    if (!(node instanceof Node)) {
+      throw new TypeError("node should be a valid Node instance");
+    }
+
+    if (node.prev != null) {
+      node.prev.next = node.next;
+    }
+    if (node.next != null) {
+      node.next.prev = node.prev;
+    }
+    if (this.#head === node) {
+      this.#head = node.next;
+    }
+    if (this.#tail === node) {
+      this.#tail = node.prev;
+    }
+    node.prev = null;
+    node.next = null;
+    this.#length--;
+  }
+
+  search(value) {
+    let nodes = [];
+    this.forEach(function (node) {
+      if (node.value === value) {
+        nodes.push(node);
+      }
+    });
+    return nodes;
+  }
+
+  find(value) {
+    for (let node of this) {
+      if (node.value === value) {
+        return node;
+      }
+    }
+    return null;
+  }
+
+  forEach(callback) {
+    if (callback && typeof callback != "function") {
+      throw new TypeError("callback should be a function");
+    }
+
+    let node = this.#head;
+    let index = 0;
+    while (node) {
+      callback(node, index);
+      node = node.next;
+      index++;
+    }
+  }
+
+  toArray() {
+    let values = [];
+    this.forEach(function (node) {
+      values.push(node.value);
+    });
+    return values;
+  }
+
+  *[Symbol.iterator]() {
+    let node = this.#head;
+    while (node) {
+      yield node;
+      node = node.next;
+    }
+  }
+};

Diff for: src/linkedlist/index.mjs

@@ -0,0 +1,252 @@
+import Node from "./node.mjs";
+
+export default class LinkedList {
+  #head = null;
+  #tail = null;
+  #length = 0;
+
+  get head() {
+    return this.#head;
+  }
+
+  get tail() {
+    return this.#tail;
+  }
+
+  get length() {
+    return this.#length;
+  }
+
+  clear() {
+    this.#head = null;
+    this.#tail = null;
+    this.#length = 0;
+  }
+
+  insertHead(value) {
+    const node = new Node(value);
+    if (this.#head === null) {
+      this.#head = this.#tail = node;
+    } else {
+      this.#head.prev = node;
+      node.next = this.#head;
+      this.#head = node;
+    }
+    this.#length++;
+    return node;
+  }
+
+  insertTail(value) {
+    if (this.#tail === null) {
+      return this.insertHead(value);
+    }
+
+    const node = new Node(value);
+    this.#tail.next = node;
+    node.prev = this.#tail;
+    this.#tail = node;
+    this.#length++;
+    return node;
+  }
+
+  insertAfter(node, value) {
+    if (!(node instanceof Node)) {
+      throw new TypeError("node should be a valid Node instance");
+    }
+    const newNode = new Node(value);
+    if (node.next != null) {
+      node.next.prev = newNode;
+      newNode.next = node.next;
+    }
+    newNode.prev = node;
+    node.next = newNode;
+    this.#length++;
+    return node;
+  }
+
+  setHead(node) {
+    if (!(node instanceof Node)) {
+      throw new TypeError("node should be a valid Node instance");
+    }
+
+    if (this.#head === node) return this.#head;
+
+    if (this.#head === null) {
+      return this.insertHead(node.value);
+    }
+
+    this.detach(node);
+    node.prev = null;
+    node.next = this.#head;
+    this.#head.prev = node;
+    this.#head = node;
+    this.#length++;
+    return this.#head;
+  }
+
+  setTail(node) {
+    if (!(node instanceof Node)) {
+      throw new TypeError("node should be a valid Node instance");
+    }
+
+    if (this.#tail === node) return this.#tail;
+
+    if (this.#tail === null) {
+      return this.insertTail(node.value);
+    }
+
+    this.detach(node);
+    this.#tail.next = node;
+    node.prev = this.#tail;
+    node.next = null;
+    this.#tail = node;
+    this.#length++;
+    return this.#tail;
+  }
+
+  swap(leftNode, rightNode) {
+    if (!(leftNode instanceof Node)) {
+      throw new TypeError("leftNode should be a valid Node instance");
+    }
+    if (!(rightNode instanceof Node)) {
+      throw new TypeError("rightNode should be a valid Node instance");
+    }
+
+    if (leftNode === rightNode) return [leftNode, rightNode];
+
+    // Replace left node with right node
+    let tmpRight = new Node(rightNode.value);
+    if (leftNode.prev != null) {
+      leftNode.prev.next = tmpRight;
+    }
+    if (leftNode.next != null) {
+      leftNode.next.prev = tmpRight;
+    }
+    tmpRight.prev = leftNode.prev;
+    tmpRight.next = leftNode.next;
+    if (leftNode == this.#head) this.#head = tmpRight;
+    if (leftNode == this.#tail) this.#tail = tmpRight;
+
+    // Replace right node with left node
+    let tmpLeft = new Node(leftNode.value);
+    if (rightNode.prev != null) {
+      rightNode.prev.next = tmpLeft;
+    }
+    if (rightNode.next != null) {
+      rightNode.next.prev = tmpLeft;
+    }
+    tmpLeft.prev = rightNode.prev;
+    tmpLeft.next = rightNode.next;
+    if (rightNode == this.#head) this.#head = tmpLeft;
+    if (rightNode == this.#tail) this.#tail = tmpLeft;
+
+    delete leftNode.next;
+    delete leftNode.prev;
+    delete leftNode.value;
+    delete rightNode.next;
+    delete rightNode.prev;
+    delete rightNode.value;
+    return [tmpLeft, tmpRight];
+  }
+
+  deleteHead() {
+    if (this.#head == null) return;
+    if (this.#head.next != null) {
+      this.#head.next.prev = null;
+    }
+    delete this.#head.value;
+    this.#head = this.#head.next;
+    this.#length--;
+  }
+
+  deleteTail() {
+    if (this.#tail == null) return;
+    if (this.#tail.prev != null) {
+      this.#tail.prev.next = null;
+    }
+    delete this.#tail.value;
+    this.#tail = this.#tail.prev;
+    this.#length--;
+  }
+
+  delete(node) {
+    if (!(node instanceof Node)) {
+      throw new TypeError("node should be a valid Node instance");
+    }
+    this.detach(node);
+    delete node.prev;
+    delete node.next;
+    delete node.value;
+  }
+
+  detach(node) {
+    if (!(node instanceof Node)) {
+      throw new TypeError("node should be a valid Node instance");
+    }
+
+    if (node.prev != null) {
+      node.prev.next = node.next;
+    }
+    if (node.next != null) {
+      node.next.prev = node.prev;
+    }
+    if (this.#head === node) {
+      this.#head = node.next;
+    }
+    if (this.#tail === node) {
+      this.#tail = node.prev;
+    }
+    node.prev = null;
+    node.next = null;
+    this.#length--;
+  }
+
+  search(value) {
+    let nodes = [];
+    this.forEach(function (node) {
+      if (node.value === value) {
+        nodes.push(node);
+      }
+    });
+    return nodes;
+  }
+
+  find(value) {
+    for (let node of this) {
+      if (node.value === value) {
+        return node;
+      }
+    }
+    return null;
+  }
+
+  forEach(callback) {
+    if (callback && typeof callback != "function") {
+      throw new TypeError("callback should be a function");
+    }
+
+    let node = this.#head;
+    let index = 0;
+    while (node) {
+      callback(node, index);
+      node = node.next;
+      index++;
+    }
+  }
+
+  toArray() {
+    let values = [];
+    this.forEach(function (node) {
+      values.push(node.value);
+    });
+    return values;
+  }
+
+  *[Symbol.iterator]() {
+    let node = this.#head;
+    while (node) {
+      yield node;
+      node = node.next;
+    }
+  }
+}

Diff for: src/linkedlist/node.cjs

@@ -0,0 +1,7 @@
+module.exports = class Node {
+  constructor(value) {
+    this.prev = null;
+    this.next = null;
+    this.value = value;
+  }
+};

Diff for: src/linkedlist/node.mjs

@@ -0,0 +1,7 @@
+export default class Node {
+  constructor(value) {
+    this.prev = null;
+    this.next = null;
+    this.value = value;
+  }
+}

Diff for: src/lru.cjs

@@ -0,0 +1,201 @@
+const LinkedList = require("./linkedlist/index.cjs");
+const Node = require("./linkedlist/node.cjs");
+
+module.exports = class LRU {
+  #linkedList = null;
+  #cache = null;
+  #ttl = 0;
+  #maxLength = 0;
+
+  constructor(options = {}) {
+    if (
+      (typeof options.maxLength !== "undefined" &&
+        typeof options.maxLength !== "number") ||
+      options.maxLength < 0
+    ) {
+      throw new TypeError("maxLength should be positive integer value");
+    }
+
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    if (
+      (typeof options.interval !== "undefined" &&
+        typeof options.interval !== "number") ||
+      options.interval < 0
+    ) {
+      throw new TypeError("interval should be positive integer value");
+    }
+
+    options.maxLength =
+      typeof options.maxLength === "number" ? options.maxLength : 1000;
+    options.ttl = typeof options.ttl === "number" ? options.ttl : 0;
+
+    this.#linkedList = new LinkedList();
+    this.#cache = new Map();
+    this.#ttl = options.ttl;
+    this.#maxLength = options.maxLength;
+  }
+
+  get length() {
+    return this.#cache.size;
+  }
+
+  set(key, value, options = {}) {
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    options.ttl = typeof options.ttl === "number" ? options.ttl : this.#ttl;
+
+    const nodeValue = {
+      key: key,
+      value: value,
+      createdAt: Date.now(),
+      expiresAt: null,
+      ttl: options.ttl,
+      frequency: 0,
+    };
+    if (nodeValue.ttl > 0) {
+      nodeValue.expiresAt = nodeValue.createdAt + nodeValue.ttl;
+    }
+
+    // Insert a new node at head
+    const existingNode = this.#cache.get(key);
+    // Update node data if node is already exists
+    if (existingNode instanceof Node) {
+      existingNode.value = nodeValue;
+      // Move current node to the head
+      this.#linkedList.setHead(existingNode);
+    } else {
+      // Remove node if cache is full
+      if (this.length === this.#maxLength) {
+        this.#evict();
+      }
+      // Create new node and make attach it to the head
+      const node = this.#linkedList.insertHead(nodeValue);
+      this.#cache.set(key, node);
+    }
+  }
+
+  get(key, callback = null) {
+    try {
+      if (callback && typeof callback !== "function") {
+        throw new TypeError("callback should be a function");
+      }
+
+      const node = this.#cache.get(key);
+
+      if (node instanceof Node) {
+        // Check node is live or not
+        if (this.#isStale(node)) {
+          this.delete(key);
+          throw new Error(key + " Key not found");
+        }
+
+        // Move current node to the head
+        this.#linkedList.setHead(node);
+
+        if (callback) {
+          return callback(null, node.value.value);
+        } else {
+          return node.value.value;
+        }
+      }
+
+      throw new Error(key + " Key not found");
+    } catch (err) {
+      if (callback) {
+        return callback(err, undefined);
+      } else {
+        return;
+      }
+    }
+  }
+
+  delete(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      this.#linkedList.delete(node);
+      // Delete node
+      this.#cache.delete(key);
+    }
+  }
+
+  #evict() {
+    if (this.#linkedList.tail == null) return;
+    if (this.length !== this.#maxLength) return;
+    this.delete(this.#linkedList.tail.value.key);
+  }
+
+  clear() {
+    // Delete all data from cache
+    this.#linkedList.clear();
+    this.#cache.clear();
+  }
+
+  has(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      // Check node is live or not
+      if (this.#isStale(node)) {
+        this.delete(key);
+      } else {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Iterate over cache using forEach loop
+  forEach(callback) {
+    if (callback && typeof callback !== "function") {
+      throw new TypeError("callback should be a function");
+    }
+
+    let node = this.#linkedList.head;
+    let index = 0;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        callback({ [node.value.key]: node.value.value }, index);
+      }
+      node = next;
+      index++;
+    }
+  }
+
+  toArray() {
+    let values = [];
+    this.forEach(function (data) {
+      values.push(data);
+    });
+    return values;
+  }
+
+  #isStale(node) {
+    if (!node.value.expiresAt) return false;
+    return node.value.expiresAt - Date.now() <= 0;
+  }
+
+  // Iterator to iterate over cache with a 'for...of' loop
+  *[Symbol.iterator]() {
+    let node = this.#linkedList.head;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        yield { [node.value.key]: node.value.value };
+      }
+      node = next;
+    }
+  }
+};

Diff for: src/lru.mjs

@@ -0,0 +1,201 @@
+import LinkedList from "./linkedlist/index.mjs";
+import Node from "./linkedlist/node.mjs";
+
+export default class LRU {
+  #linkedList = null;
+  #cache = null;
+  #ttl = 0;
+  #maxLength = 0;
+
+  constructor(options = {}) {
+    if (
+      (typeof options.maxLength !== "undefined" &&
+        typeof options.maxLength !== "number") ||
+      options.maxLength < 0
+    ) {
+      throw new TypeError("maxLength should be positive integer value");
+    }
+
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    if (
+      (typeof options.interval !== "undefined" &&
+        typeof options.interval !== "number") ||
+      options.interval < 0
+    ) {
+      throw new TypeError("interval should be positive integer value");
+    }
+
+    options.maxLength =
+      typeof options.maxLength === "number" ? options.maxLength : 1000;
+    options.ttl = typeof options.ttl === "number" ? options.ttl : 0;
+
+    this.#linkedList = new LinkedList();
+    this.#cache = new Map();
+    this.#ttl = options.ttl;
+    this.#maxLength = options.maxLength;
+  }
+
+  get length() {
+    return this.#cache.size;
+  }
+
+  set(key, value, options = {}) {
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    options.ttl = typeof options.ttl === "number" ? options.ttl : this.#ttl;
+
+    const nodeValue = {
+      key: key,
+      value: value,
+      createdAt: Date.now(),
+      expiresAt: null,
+      ttl: options.ttl,
+      frequency: 0,
+    };
+    if (nodeValue.ttl > 0) {
+      nodeValue.expiresAt = nodeValue.createdAt + nodeValue.ttl;
+    }
+
+    // Insert a new node at head
+    const existingNode = this.#cache.get(key);
+    // Update node data if node is already exists
+    if (existingNode instanceof Node) {
+      existingNode.value = nodeValue;
+      // Move current node to the head
+      this.#linkedList.setHead(existingNode);
+    } else {
+      // Remove node if cache is full
+      if (this.length === this.#maxLength) {
+        this.#evict();
+      }
+      // Create new node and make attach it to the head
+      const node = this.#linkedList.insertHead(nodeValue);
+      this.#cache.set(key, node);
+    }
+  }
+
+  get(key, callback = null) {
+    try {
+      if (callback && typeof callback !== "function") {
+        throw new TypeError("callback should be a function");
+      }
+
+      const node = this.#cache.get(key);
+
+      if (node instanceof Node) {
+        // Check node is live or not
+        if (this.#isStale(node)) {
+          this.delete(key);
+          throw new Error(key + " Key not found");
+        }
+
+        // Move current node to the head
+        this.#linkedList.setHead(node);
+
+        if (callback) {
+          return callback(null, node.value.value);
+        } else {
+          return node.value.value;
+        }
+      }
+
+      throw new Error(key + " Key not found");
+    } catch (err) {
+      if (callback) {
+        return callback(err, undefined);
+      } else {
+        return;
+      }
+    }
+  }
+
+  delete(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      this.#linkedList.delete(node);
+      // Delete node
+      this.#cache.delete(key);
+    }
+  }
+
+  #evict() {
+    if (this.#linkedList.tail == null) return;
+    if (this.length !== this.#maxLength) return;
+    this.delete(this.#linkedList.tail.value.key);
+  }
+
+  clear() {
+    // Delete all data from cache
+    this.#linkedList.clear();
+    this.#cache.clear();
+  }
+
+  has(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      // Check node is live or not
+      if (this.#isStale(node)) {
+        this.delete(key);
+      } else {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Iterate over cache using forEach loop
+  forEach(callback) {
+    if (callback && typeof callback !== "function") {
+      throw new TypeError("callback should be a function");
+    }
+
+    let node = this.#linkedList.head;
+    let index = 0;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        callback({ [node.value.key]: node.value.value }, index);
+      }
+      node = next;
+      index++;
+    }
+  }
+
+  toArray() {
+    let values = [];
+    this.forEach(function (data) {
+      values.push(data);
+    });
+    return values;
+  }
+
+  #isStale(node) {
+    if (!node.value.expiresAt) return false;
+    return node.value.expiresAt - Date.now() <= 0;
+  }
+
+  // Iterator to iterate over cache with a 'for...of' loop
+  *[Symbol.iterator]() {
+    let node = this.#linkedList.head;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        yield { [node.value.key]: node.value.value };
+      }
+      node = next;
+    }
+  }
+}

Diff for: src/mru.cjs

@@ -0,0 +1,201 @@
+const LinkedList = require("./linkedlist/index.cjs");
+const Node = require("./linkedlist/node.cjs");
+
+module.exports = class MRU {
+  #linkedList = null;
+  #cache = null;
+  #ttl = 0;
+  #maxLength = 0;
+
+  constructor(options = {}) {
+    if (
+      (typeof options.maxLength !== "undefined" &&
+        typeof options.maxLength !== "number") ||
+      options.maxLength < 0
+    ) {
+      throw new TypeError("maxLength should be positive integer value");
+    }
+
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    if (
+      (typeof options.interval !== "undefined" &&
+        typeof options.interval !== "number") ||
+      options.interval < 0
+    ) {
+      throw new TypeError("interval should be positive integer value");
+    }
+
+    options.maxLength =
+      typeof options.maxLength === "number" ? options.maxLength : 1000;
+    options.ttl = typeof options.ttl === "number" ? options.ttl : 0;
+
+    this.#linkedList = new LinkedList();
+    this.#cache = new Map();
+    this.#ttl = options.ttl;
+    this.#maxLength = options.maxLength;
+  }
+
+  get length() {
+    return this.#cache.size;
+  }
+
+  set(key, value, options = {}) {
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    options.ttl = typeof options.ttl === "number" ? options.ttl : this.#ttl;
+
+    const nodeValue = {
+      key: key,
+      value: value,
+      createdAt: Date.now(),
+      expiresAt: null,
+      ttl: options.ttl,
+      frequency: 0,
+    };
+    if (nodeValue.ttl > 0) {
+      nodeValue.expiresAt = nodeValue.createdAt + nodeValue.ttl;
+    }
+
+    // Insert a new node at head
+    const existingNode = this.#cache.get(key);
+    // Update node data if node is already exists
+    if (existingNode instanceof Node) {
+      existingNode.value = nodeValue;
+      // Move current node to the head
+      this.#linkedList.setHead(existingNode);
+    } else {
+      // Remove node if cache is full
+      if (this.length === this.#maxLength) {
+        this.#evict();
+      }
+      // Create new node and make attach it to the head
+      const node = this.#linkedList.insertHead(nodeValue);
+      this.#cache.set(key, node);
+    }
+  }
+
+  get(key, callback = null) {
+    try {
+      if (callback && typeof callback !== "function") {
+        throw new TypeError("callback should be a function");
+      }
+
+      const node = this.#cache.get(key);
+
+      if (node instanceof Node) {
+        // Check node is live or not
+        if (this.#isStale(node)) {
+          this.delete(key);
+          throw new Error(key + " Key not found");
+        }
+
+        // Move current node to the head
+        this.#linkedList.setHead(node);
+
+        if (callback) {
+          return callback(null, node.value.value);
+        } else {
+          return node.value.value;
+        }
+      }
+
+      throw new Error(key + " Key not found");
+    } catch (err) {
+      if (callback) {
+        return callback(err, undefined);
+      } else {
+        return;
+      }
+    }
+  }
+
+  delete(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      this.#linkedList.delete(node);
+      // Delete node
+      this.#cache.delete(key);
+    }
+  }
+
+  #evict() {
+    if (this.#linkedList.head == null) return;
+    if (this.length !== this.#maxLength) return;
+    this.delete(this.#linkedList.head.value.key);
+  }
+
+  clear() {
+    // Delete all data from cache
+    this.#linkedList.clear();
+    this.#cache.clear();
+  }
+
+  has(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      // Check node is live or not
+      if (this.#isStale(node)) {
+        this.delete(key);
+      } else {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Iterate over cache using forEach loop
+  forEach(callback) {
+    if (callback && typeof callback !== "function") {
+      throw new TypeError("callback should be a function");
+    }
+
+    let node = this.#linkedList.head;
+    let index = 0;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        callback({ [node.value.key]: node.value.value }, index);
+      }
+      node = next;
+      index++;
+    }
+  }
+
+  toArray() {
+    let values = [];
+    this.forEach(function (data) {
+      values.push(data);
+    });
+    return values;
+  }
+
+  #isStale(node) {
+    if (!node.value.expiresAt) return false;
+    return node.value.expiresAt - Date.now() <= 0;
+  }
+
+  // Iterator to iterate over cache with a 'for...of' loop
+  *[Symbol.iterator]() {
+    let node = this.#linkedList.head;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        yield { [node.value.key]: node.value.value };
+      }
+      node = next;
+    }
+  }
+};

Diff for: src/mru.mjs

@@ -0,0 +1,201 @@
+import LinkedList from "./linkedlist/index.mjs";
+import Node from "./linkedlist/node.mjs";
+
+export default class MRU {
+  #linkedList = null;
+  #cache = null;
+  #ttl = 0;
+  #maxLength = 0;
+
+  constructor(options = {}) {
+    if (
+      (typeof options.maxLength !== "undefined" &&
+        typeof options.maxLength !== "number") ||
+      options.maxLength < 0
+    ) {
+      throw new TypeError("maxLength should be positive integer value");
+    }
+
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    if (
+      (typeof options.interval !== "undefined" &&
+        typeof options.interval !== "number") ||
+      options.interval < 0
+    ) {
+      throw new TypeError("interval should be positive integer value");
+    }
+
+    options.maxLength =
+      typeof options.maxLength === "number" ? options.maxLength : 1000;
+    options.ttl = typeof options.ttl === "number" ? options.ttl : 0;
+
+    this.#linkedList = new LinkedList();
+    this.#cache = new Map();
+    this.#ttl = options.ttl;
+    this.#maxLength = options.maxLength;
+  }
+
+  get length() {
+    return this.#cache.size;
+  }
+
+  set(key, value, options = {}) {
+    if (
+      (typeof options.ttl !== "undefined" && typeof options.ttl !== "number") ||
+      options.ttl < 0
+    ) {
+      throw new TypeError("ttl should be positive integer value");
+    }
+
+    options.ttl = typeof options.ttl === "number" ? options.ttl : this.#ttl;
+
+    const nodeValue = {
+      key: key,
+      value: value,
+      createdAt: Date.now(),
+      expiresAt: null,
+      ttl: options.ttl,
+      frequency: 0,
+    };
+    if (nodeValue.ttl > 0) {
+      nodeValue.expiresAt = nodeValue.createdAt + nodeValue.ttl;
+    }
+
+    // Insert a new node at head
+    const existingNode = this.#cache.get(key);
+    // Update node data if node is already exists
+    if (existingNode instanceof Node) {
+      existingNode.value = nodeValue;
+      // Move current node to the head
+      this.#linkedList.setHead(existingNode);
+    } else {
+      // Remove node if cache is full
+      if (this.length === this.#maxLength) {
+        this.#evict();
+      }
+      // Create new node and make attach it to the head
+      const node = this.#linkedList.insertHead(nodeValue);
+      this.#cache.set(key, node);
+    }
+  }
+
+  get(key, callback = null) {
+    try {
+      if (callback && typeof callback !== "function") {
+        throw new TypeError("callback should be a function");
+      }
+
+      const node = this.#cache.get(key);
+
+      if (node instanceof Node) {
+        // Check node is live or not
+        if (this.#isStale(node)) {
+          this.delete(key);
+          throw new Error(key + " Key not found");
+        }
+
+        // Move current node to the head
+        this.#linkedList.setHead(node);
+
+        if (callback) {
+          return callback(null, node.value.value);
+        } else {
+          return node.value.value;
+        }
+      }
+
+      throw new Error(key + " Key not found");
+    } catch (err) {
+      if (callback) {
+        return callback(err, undefined);
+      } else {
+        return;
+      }
+    }
+  }
+
+  delete(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      this.#linkedList.delete(node);
+      // Delete node
+      this.#cache.delete(key);
+    }
+  }
+
+  #evict() {
+    if (this.#linkedList.head == null) return;
+    if (this.length !== this.#maxLength) return;
+    this.delete(this.#linkedList.head.value.key);
+  }
+
+  clear() {
+    // Delete all data from cache
+    this.#linkedList.clear();
+    this.#cache.clear();
+  }
+
+  has(key) {
+    const node = this.#cache.get(key);
+
+    if (node instanceof Node) {
+      // Check node is live or not
+      if (this.#isStale(node)) {
+        this.delete(key);
+      } else {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Iterate over cache using forEach loop
+  forEach(callback) {
+    if (callback && typeof callback !== "function") {
+      throw new TypeError("callback should be a function");
+    }
+
+    let node = this.#linkedList.head;
+    let index = 0;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        callback({ [node.value.key]: node.value.value }, index);
+      }
+      node = next;
+      index++;
+    }
+  }
+
+  toArray() {
+    let values = [];
+    this.forEach(function (data) {
+      values.push(data);
+    });
+    return values;
+  }
+
+  #isStale(node) {
+    if (!node.value.expiresAt) return false;
+    return node.value.expiresAt - Date.now() <= 0;
+  }
+
+  // Iterator to iterate over cache with a 'for...of' loop
+  *[Symbol.iterator]() {
+    let node = this.#linkedList.head;
+    while (node) {
+      let next = node.next;
+      if (this.has(node.value.key)) {
+        yield { [node.value.key]: node.value.value };
+      }
+      node = next;
+    }
+  }
+}

Diff for: tests/fifo.test.js

@@ -0,0 +1,133 @@
+const Cache = require("../index.cjs");
+
+describe("FIFO Cache test", () => {
+  let cache = null;
+  beforeEach(() => {
+    cache = new Cache({ maxLength: 4, ttl: 100, evictionPolicy: "FIFO" });
+  });
+
+  test("Set data in cache", () => {
+    cache.set("a", 10);
+    expect(cache.has("a")).toEqual(true);
+  });
+
+  test("Set max data in cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    cache.set("c", 30);
+    cache.set("d", 40);
+    cache.set("e", 50);
+    expect(cache.has("a")).toEqual(false);
+  });
+
+  test("Get data from cache", () => {
+    cache.set("a", 10);
+    expect(cache.get("a")).toEqual(10);
+    cache.set("b", { a: 10, b: 20 });
+    expect(cache.get("b")).toEqual({ a: 10, b: 20 });
+    expect(cache.get("c")).toEqual(undefined);
+  });
+
+  test("Change get return value using callback function", () => {
+    cache.set("a", undefined);
+    expect(
+      cache.get("a", (err, value) => {
+        if (!err) return value;
+        return null;
+      })
+    ).toEqual(undefined);
+    expect(
+      cache.get("b", (err, value) => {
+        if (!err) return value;
+        return null;
+      })
+    ).toEqual(null);
+  });
+
+  test("Check data exists in cache", () => {
+    cache.set("a", 10);
+    expect(cache.has("a")).toEqual(true);
+    expect(cache.has("b")).toEqual(false);
+  });
+
+  test("Delete data from cache", () => {
+    cache.set("a", 10);
+    expect(cache.has("a")).toEqual(true);
+    cache.delete("a");
+    expect(cache.has("a")).toEqual(false);
+  });
+
+  test("Delete all data from cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    expect(cache.has("a")).toEqual(true);
+    cache.clear();
+    expect(cache.has("a")).toEqual(false);
+  });
+
+  test("Evict data from cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    cache.set("c", 30);
+    cache.set("d", 40);
+    cache.set("e", 50);
+    expect(cache.toArray()).toEqual([
+      { e: 50 },
+      { d: 40 },
+      { c: 30 },
+      { b: 20 },
+    ]);
+  });
+
+  test("Evict data from cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    cache.set("c", 30);
+    cache.set("d", 40);
+    cache.get("a");
+    cache.set("e", 50);
+    expect(cache.toArray()).toEqual([
+      { e: 50 },
+      { d: 40 },
+      { c: 30 },
+      { b: 20 },
+    ]);
+  });
+
+  test("Evict data from cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    cache.set("c", 30);
+    cache.set("d", 40);
+    cache.get("d");
+    cache.set("e", 50);
+    expect(cache.toArray()).toEqual([
+      { e: 50 },
+      { d: 40 },
+      { c: 30 },
+      { b: 20 },
+    ]);
+  });
+
+  test("Check ttl for cache", async () => {
+    cache.set("a", 10);
+    cache.set("b", 20, { ttl: 0 });
+    expect(cache.has("a")).toEqual(true);
+    expect(cache.has("b")).toEqual(true);
+    await new Promise((resolve, reject) => {
+      setTimeout(() => resolve(), 200);
+    });
+    expect(cache.has("a")).toEqual(false);
+    expect(cache.has("b")).toEqual(true);
+  });
+
+  test("Get all data as array", async () => {
+    cache.set("a", 10);
+    cache.set("b", 20, { ttl: 0 });
+    expect(cache.toArray()).toEqual([{ b: 20 }, { a: 10 }]);
+    await new Promise((resolve, reject) => {
+      setTimeout(() => resolve(), 200);
+    });
+    expect(cache.toArray()).toEqual([{ b: 20 }]);
+  });
+});

Diff for: tests/lifo.test.js

@@ -0,0 +1,133 @@
+const Cache = require("../index.cjs");
+
+describe("LIFO Cache test", () => {
+  let cache = null;
+  beforeEach(() => {
+    cache = new Cache({ maxLength: 4, ttl: 100, evictionPolicy: "LIFO" });
+  });
+
+  test("Set data in cache", () => {
+    cache.set("a", 10);
+    expect(cache.has("a")).toEqual(true);
+  });
+
+  test("Set max data in cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    cache.set("c", 30);
+    cache.set("d", 40);
+    cache.set("e", 50);
+    expect(cache.has("d")).toEqual(false);
+  });
+
+  test("Get data from cache", () => {
+    cache.set("a", 10);
+    expect(cache.get("a")).toEqual(10);
+    cache.set("b", { a: 10, b: 20 });
+    expect(cache.get("b")).toEqual({ a: 10, b: 20 });
+    expect(cache.get("c")).toEqual(undefined);
+  });
+
+  test("Change get return value using callback function", () => {
+    cache.set("a", undefined);
+    expect(
+      cache.get("a", (err, value) => {
+        if (!err) return value;
+        return null;
+      })
+    ).toEqual(undefined);
+    expect(
+      cache.get("b", (err, value) => {
+        if (!err) return value;
+        return null;
+      })
+    ).toEqual(null);
+  });
+
+  test("Check data exists in cache", () => {
+    cache.set("a", 10);
+    expect(cache.has("a")).toEqual(true);
+    expect(cache.has("b")).toEqual(false);
+  });
+
+  test("Delete data from cache", () => {
+    cache.set("a", 10);
+    expect(cache.has("a")).toEqual(true);
+    cache.delete("a");
+    expect(cache.has("a")).toEqual(false);
+  });
+
+  test("Delete all data from cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    expect(cache.has("a")).toEqual(true);
+    cache.clear();
+    expect(cache.has("a")).toEqual(false);
+  });
+
+  test("Evict data from cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    cache.set("c", 30);
+    cache.set("d", 40);
+    cache.set("e", 50);
+    expect(cache.toArray()).toEqual([
+      { e: 50 },
+      { c: 30 },
+      { b: 20 },
+      { a: 10 },
+    ]);
+  });
+
+  test("Evict data from cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    cache.set("c", 30);
+    cache.set("d", 40);
+    cache.get("a");
+    cache.set("e", 50);
+    expect(cache.toArray()).toEqual([
+      { e: 50 },
+      { c: 30 },
+      { b: 20 },
+      { a: 10 },
+    ]);
+  });
+
+  test("Evict data from cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    cache.set("c", 30);
+    cache.set("d", 40);
+    cache.get("d");
+    cache.set("e", 50);
+    expect(cache.toArray()).toEqual([
+      { e: 50 },
+      { c: 30 },
+      { b: 20 },
+      { a: 10 },
+    ]);
+  });
+
+  test("Check ttl for cache", async () => {
+    cache.set("a", 10);
+    cache.set("b", 20, { ttl: 0 });
+    expect(cache.has("a")).toEqual(true);
+    expect(cache.has("b")).toEqual(true);
+    await new Promise((resolve, reject) => {
+      setTimeout(() => resolve(), 200);
+    });
+    expect(cache.has("a")).toEqual(false);
+    expect(cache.has("b")).toEqual(true);
+  });
+
+  test("Get all data as array", async () => {
+    cache.set("a", 10);
+    cache.set("b", 20, { ttl: 0 });
+    expect(cache.toArray()).toEqual([{ b: 20 }, { a: 10 }]);
+    await new Promise((resolve, reject) => {
+      setTimeout(() => resolve(), 200);
+    });
+    expect(cache.toArray()).toEqual([{ b: 20 }]);
+  });
+});

Diff for: tests/linkedlist.test.js

@@ -0,0 +1,135 @@
+const LinkedList = require("../src/linkedlist/index.cjs");
+
+describe("Linkedlist test", () => {
+  let linkedlist = null;
+  beforeEach(() => {
+    linkedlist = new LinkedList();
+  });
+
+  test("Set data at head in linked list", () => {
+    linkedlist.insertHead(10);
+    linkedlist.insertHead(15);
+    linkedlist.insertHead(20);
+    expect(linkedlist.toArray()).toEqual([20, 15, 10]);
+  });
+
+  test("Set data at the end of linked list", () => {
+    linkedlist.insertTail(10);
+    linkedlist.insertTail(15);
+    linkedlist.insertTail(20);
+    expect(linkedlist.toArray()).toEqual([10, 15, 20]);
+  });
+
+  test("Set data after a node", () => {
+    linkedlist.insertHead(10);
+    linkedlist.insertTail(20);
+    let node = linkedlist.find(10);
+    linkedlist.insertAfter(node, 15);
+    expect(linkedlist.toArray()).toEqual([10, 15, 20]);
+  });
+
+  test("Set head", () => {
+    linkedlist.insertHead(10);
+    linkedlist.insertHead(15);
+    linkedlist.insertHead(20);
+    let node = linkedlist.find(15);
+    linkedlist.setHead(node);
+    expect(linkedlist.toArray()).toEqual([15, 20, 10]);
+  });
+
+  test("Set tail", () => {
+    linkedlist.insertHead(10);
+    linkedlist.insertHead(15);
+    linkedlist.insertHead(20);
+    let node = linkedlist.find(15);
+    linkedlist.setTail(node);
+    expect(linkedlist.toArray()).toEqual([20, 10, 15]);
+  });
+
+  test("Swap nodes", () => {
+    linkedlist.insertTail(10);
+    linkedlist.insertTail(15);
+    linkedlist.insertTail(20);
+    linkedlist.insertTail(25);
+    linkedlist.insertTail(30);
+    let left = linkedlist.find(10);
+    let right = linkedlist.find(25);
+    linkedlist.swap(left, right);
+    expect(linkedlist.toArray()).toEqual([25, 15, 20, 10, 30]);
+  });
+
+  test("Swap neighbor nodes", () => {
+    linkedlist.insertTail(10);
+    linkedlist.insertTail(15);
+    let left = linkedlist.find(10);
+    let right = linkedlist.find(15);
+    linkedlist.swap(left, right);
+    expect(linkedlist.toArray()).toEqual([15, 10]);
+  });
+
+  test("Swap single node", () => {
+    linkedlist.insertTail(10);
+    let left = linkedlist.find(10);
+    linkedlist.swap(left, left);
+    expect(linkedlist.toArray()).toEqual([10]);
+  });
+
+  test("Delete head", () => {
+    linkedlist.insertHead(10);
+    linkedlist.insertHead(15);
+    linkedlist.insertHead(20);
+    linkedlist.deleteHead();
+    expect(linkedlist.toArray()).toEqual([15, 10]);
+  });
+
+  test("Delete tail", () => {
+    linkedlist.insertHead(10);
+    linkedlist.insertHead(15);
+    linkedlist.insertHead(20);
+    linkedlist.deleteTail();
+    expect(linkedlist.toArray()).toEqual([20, 15]);
+  });
+
+  test("Delete node", () => {
+    linkedlist.insertHead(10);
+    linkedlist.insertHead(15);
+    linkedlist.insertHead(20);
+    let node = linkedlist.find(15);
+    linkedlist.delete(node);
+    expect(linkedlist.toArray()).toEqual([20, 10]);
+  });
+
+  test("Detach node", () => {
+    linkedlist.insertHead(10);
+    linkedlist.insertHead(15);
+    linkedlist.insertHead(20);
+    let node = linkedlist.find(15);
+    linkedlist.detach(node);
+    expect(linkedlist.toArray()).toEqual([20, 10]);
+  });
+
+  test("Search nodes by value", () => {
+    linkedlist.insertHead(10);
+    linkedlist.insertHead(15);
+    linkedlist.insertHead(10);
+    linkedlist.insertHead(20);
+    let nodes = linkedlist.search(10);
+    expect(nodes.map((e) => e.value)).toEqual([10, 10]);
+  });
+
+  test("Find a first node by value", () => {
+    linkedlist.insertHead(10);
+    linkedlist.insertHead(15);
+    linkedlist.insertHead(10);
+    linkedlist.insertHead(20);
+    let node = linkedlist.find(10);
+    expect(node.value).toEqual(10);
+  });
+
+  test("Get all values as array", () => {
+    linkedlist.insertHead(10);
+    linkedlist.insertHead(15);
+    linkedlist.insertHead(20);
+    expect(linkedlist.toArray()).toEqual([20, 15, 10]);
+  });
+});

Diff for: tests/lru.test.js

@@ -0,0 +1,133 @@
+const Cache = require("../index.cjs");
+
+describe("LRU Cache test", () => {
+  let cache = null;
+  beforeEach(() => {
+    cache = new Cache({ maxLength: 4, ttl: 100, evictionPolicy: "LRU" });
+  });
+
+  test("Set data in cache", () => {
+    cache.set("a", 10);
+    expect(cache.has("a")).toEqual(true);
+  });
+
+  test("Set max data in cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    cache.set("c", 30);
+    cache.set("d", 40);
+    cache.set("e", 50);
+    expect(cache.has("a")).toEqual(false);
+  });
+
+  test("Get data from cache", () => {
+    cache.set("a", 10);
+    expect(cache.get("a")).toEqual(10);
+    cache.set("b", { a: 10, b: 20 });
+    expect(cache.get("b")).toEqual({ a: 10, b: 20 });
+    expect(cache.get("c")).toEqual(undefined);
+  });
+
+  test("Change get return value using callback function", () => {
+    cache.set("a", undefined);
+    expect(
+      cache.get("a", (err, value) => {
+        if (!err) return value;
+        return null;
+      })
+    ).toEqual(undefined);
+    expect(
+      cache.get("b", (err, value) => {
+        if (!err) return value;
+        return null;
+      })
+    ).toEqual(null);
+  });
+
+  test("Check data exists in cache", () => {
+    cache.set("a", 10);
+    expect(cache.has("a")).toEqual(true);
+    expect(cache.has("b")).toEqual(false);
+  });
+
+  test("Delete data from cache", () => {
+    cache.set("a", 10);
+    expect(cache.has("a")).toEqual(true);
+    cache.delete("a");
+    expect(cache.has("a")).toEqual(false);
+  });
+
+  test("Delete all data from cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    expect(cache.has("a")).toEqual(true);
+    cache.clear();
+    expect(cache.has("a")).toEqual(false);
+  });
+
+  test("Evict data from cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    cache.set("c", 30);
+    cache.set("d", 40);
+    cache.set("e", 50);
+    expect(cache.toArray()).toEqual([
+      { e: 50 },
+      { d: 40 },
+      { c: 30 },
+      { b: 20 },
+    ]);
+  });
+
+  test("Evict data from cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    cache.set("c", 30);
+    cache.set("d", 40);
+    cache.get("a");
+    cache.set("e", 50);
+    expect(cache.toArray()).toEqual([
+      { e: 50 },
+      { a: 10 },
+      { d: 40 },
+      { c: 30 },
+    ]);
+  });
+
+  test("Evict data from cache", () => {
+    cache.set("a", 10);
+    cache.set("b", 20);
+    cache.set("c", 30);
+    cache.set("d", 40);
+    cache.get("d");
+    cache.set("e", 50);
+    expect(cache.toArray()).toEqual([
+      { e: 50 },
+      { d: 40 },
+      { c: 30 },
+      { b: 20 },
+    ]);
+  });
+
+  test("Check ttl for cache", async () => {
+    cache.set("a", 10);
+    cache.set("b", 20, { ttl: 0 });
+    expect(cache.has("a")).toEqual(true);
+    expect(cache.has("b")).toEqual(true);
+    await new Promise((resolve, reject) => {
+      setTimeout(() => resolve(), 200);
+    });
+    expect(cache.has("a")).toEqual(false);
+    expect(cache.has("b")).toEqual(true);
+  });
+
+  test("Get all data as array", async () => {
+    cache.set("a", 10);
+    cache.set("b", 20, { ttl: 0 });
+    expect(cache.toArray()).toEqual([{ b: 20 }, { a: 10 }]);
+    await new Promise((resolve, reject) => {
+      setTimeout(() => resolve(), 200);
+    });
+    expect(cache.toArray()).toEqual([{ b: 20 }]);
+  });
+});