limited-cache 1.1.1 → 2.1.0

package/dist/types.d.ts

@@ -1,60 +1,58 @@
-export declare type DefaultItemType = any;
-export interface LimitedCacheOptionsFull {
-    /** Items will be removed to keep the cache within the maxCacheSize limit */
-    maxCacheSize: number;
-    /** Items will be removed and never returned if they were set more than maxCacheTime milliseconds ago */
-    maxCacheTime: number;
-    /** (dev only) A warning will be emitted if an item rotates out of the cache before this many milliseconds have passed, to indicate the size is too small */
-    warnIfItemPurgedBeforeTime: number;
-    /** (private) Internal cleanup of old keys will be performed after this many operations */
-    opLimit: number;
-    /** (private) Internal optimization to adjust how much searching will be done to find expired items, to avoid being O(n) */
-    scanLimit: number;
-}
-export declare type LimitedCacheOptions = Partial<LimitedCacheOptionsFull> | null;
-export declare type LimitedCacheOptionsReadonly = Readonly<LimitedCacheOptionsFull>;
-export interface LimitedCacheInstance<ItemType = DefaultItemType> {
-    /** Return the requested item, if it has not expired */
-    get: (cacheKey: string) => ItemType | undefined;
-    /** Return all non-expired items */
-    getAll: () => Record<string, ItemType>;
-    /** Indicate whether or not the requested item is present and has not expired */
-    has: (cacheKey: string) => boolean;
-    /** Add the item to the cache, or update its timestamp if it already exists */
-    set: (cacheKey: string, item: ItemType) => ItemType;
-    /** Remove the requested item from the cache, if necessary */
-    remove: (cacheKey: string) => true;
-    /** Remove all items and all timestamps from the cache */
-    reset: () => LimitedCacheMeta<ItemType>;
-    /** Return a serializable representation of the cache internals, suitable for long-term storage */
-    getCacheMeta: () => LimitedCacheMeta<ItemType>;
-    /** Return the cache's current values for all options */
-    getOptions: () => LimitedCacheOptionsFull;
-    /** Update one or more of the cache's options */
-    setOptions: (newOptions: LimitedCacheOptions) => LimitedCacheOptionsReadonly;
-    /** Reduces cache size by cleaning up old keys and expired items */
-    doMaintenance: () => LimitedCacheMeta<ItemType>;
-}
-export interface LimitedCacheObjectInstance<ItemType = DefaultItemType> {
-    [key: string]: ItemType;
-}
-/**
- *  A serializable representation of the cache internals, suitable for long-term storage
- */
-export interface LimitedCacheMeta<ItemType = DefaultItemType> {
-    /** Schema version: old versions will be upgraded if possible, or a warning will be emitted if not */
-    limitedCacheMetaVersion: number;
-    /** Options to control cache size, time, and behavior */
-    options: LimitedCacheOptionsReadonly;
-    /** The values in the cache, stored by key. Will include old keys not yet garbage collected */
-    cache: Record<string, ItemType | undefined>;
-    /** List of keys that have been set, in chronological order. Used to find cache items most likely to be expired */
-    keyList: Array<string>;
-    /** The [setTime, expirationTime] for each key that has been set. Removed on unset. */
-    keyInfo: Record<string, [
-        number,
-        number
-    ] | undefined>;
-    /** Number of operations remaining until internal cleanup of old keys is performed. Based on options.opLimit */
-    opsLeft: number;
-}
+export type DefaultItemType = any;
+export interface LimitedCacheOptionsFull {
+    /** Items will be removed to keep the cache within the maxCacheSize limit */
+    maxCacheSize: number;
+    /** Items will be removed and never returned if they were set more than maxCacheTime milliseconds ago */
+    maxCacheTime: number;
+    /** (dev only) A warning will be emitted if an item rotates out of the cache before this many milliseconds have passed, to indicate the size is too small */
+    warnIfItemPurgedBeforeTime: number;
+    /** (private) Internal cleanup of old keys will be performed after this many operations */
+    opLimit: number;
+    /** (private) Internal optimization to adjust how much searching will be done to find expired items, to avoid being O(n) */
+    scanLimit: number;
+}
+export type LimitedCacheOptions = Partial<LimitedCacheOptionsFull> | null;
+export type LimitedCacheOptionsReadonly = Readonly<LimitedCacheOptionsFull>;
+export interface LimitedCacheInstance<ItemType = DefaultItemType> {
+    /** Return the requested item, if it has not expired */
+    get: (cacheKey: string) => ItemType | undefined;
+    /** Return all non-expired items */
+    getAll: () => Record<string, ItemType>;
+    /** Indicate whether or not the requested item is present and has not expired */
+    has: (cacheKey: string) => boolean;
+    /** Add the item to the cache, or update its timestamp if it already exists */
+    set: (cacheKey: string, item: ItemType) => ItemType;
+    /** Remove the requested item from the cache, if necessary */
+    remove: (cacheKey: string) => true;
+    /** Remove all items and all timestamps from the cache */
+    reset: () => LimitedCacheMeta<ItemType>;
+    /** Return a serializable representation of the cache internals, suitable for long-term storage */
+    getCacheMeta: () => LimitedCacheMeta<ItemType>;
+    /** Return the cache's current values for all options */
+    getOptions: () => LimitedCacheOptionsFull;
+    /** Update one or more of the cache's options */
+    setOptions: (newOptions: LimitedCacheOptions) => LimitedCacheOptionsReadonly;
+    /** Reduces cache size by cleaning up old keys and expired items */
+    doMaintenance: () => LimitedCacheMeta<ItemType>;
+}
+export interface LimitedCacheObjectInstance<ItemType = DefaultItemType> {
+    [key: string]: ItemType;
+}
+/**
+ *  A serializable representation of the cache internals, suitable for long-term storage
+ */
+export interface LimitedCacheMeta<ItemType = DefaultItemType> {
+    /** Schema version: old versions will be upgraded if possible, or a warning will be emitted if not */
+    limitedCacheMetaVersion: number;
+    /** Options to control cache size, time, and behavior */
+    options: LimitedCacheOptionsReadonly;
+    /** The values in the cache, stored by key. Will include old keys not yet garbage collected */
+    cache: Record<string, ItemType | undefined>;
+    /** List of keys that have been set, in chronological order. Used to find cache items most likely to be expired */
+    keyList: Array<string>;
+    /** The [setTime, expirationTime] for each key that has been set. Removed on unset. */
+    keyInfo: Record<string, [number, number] | undefined>;
+    /** Number of operations remaining until internal cleanup of old keys is performed. Based on options.opLimit */
+    opsLeft: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC;AAElC,MAAM,WAAW,uBAAuB;IACtC,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAC;IACrB,wGAAwG;IACxG,YAAY,EAAE,MAAM,CAAC;IAErB,4JAA4J;IAC5J,0BAA0B,EAAE,MAAM,CAAC;IACnC,0FAA0F;IAC1F,OAAO,EAAE,MAAM,CAAC;IAChB,2HAA2H;IAC3H,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,uBAAuB,CAAC,GAAG,IAAI,CAAC;AAC1E,MAAM,MAAM,2BAA2B,GAAG,QAAQ,CAAC,uBAAuB,CAAC,CAAC;AAE5E,MAAM,WAAW,oBAAoB,CAAC,QAAQ,GAAG,eAAe;IAC9D,uDAAuD;IACvD,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,QAAQ,GAAG,SAAS,CAAC;IAChD,mCAAmC;IACnC,MAAM,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACvC,gFAAgF;IAChF,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;IACnC,8EAA8E;IAC9E,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,KAAK,QAAQ,CAAC;IACpD,6DAA6D;IAC7D,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,yDAAyD;IACzD,KAAK,EAAE,MAAM,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IACxC,kGAAkG;IAClG,YAAY,EAAE,MAAM,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAC/C,wDAAwD;IACxD,UAAU,EAAE,MAAM,uBAAuB,CAAC;IAC1C,gDAAgD;IAChD,UAAU,EAAE,CAAC,UAAU,EAAE,mBAAmB,KAAK,2BAA2B,CAAC;IAC7E,mEAAmE;IACnE,aAAa,EAAE,MAAM,gBAAgB,CAAC,QAAQ,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,0BAA0B,CAAC,QAAQ,GAAG,eAAe;IACpE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,QAAQ,GAAG,eAAe;IAC1D,qGAAqG;IACrG,uBAAuB,EAAE,MAAM,CAAC;IAChC,wDAAwD;IACxD,OAAO,EAAE,2BAA2B,CAAC;IACrC,8FAA8F;IAC9F,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,GAAG,SAAS,CAAC,CAAC;IAC5C,kHAAkH;IAClH,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACvB,sFAAsF;IACtF,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC,CAAC;IACtD,+GAA+G;IAC/G,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "limited-cache",
-  "version": "1.1.1",
+  "version": "2.1.0",
   "description": "A minimal JS cache: like using an object, except it won't grow forever",
   "keywords": [
     "limited cache",
@@ -14,99 +14,112 @@
     "autoexpire"
   ],
   "license": "MIT",
-  "homepage": "https://github.com/spautz/limited-cache#readme",
+  "homepage": "https://github.com/spautz/limited-cache/packages/limited-cache#readme",
   "bugs": "https://github.com/spautz/limited-cache/issues",
   "repository": {
     "type": "git",
-    "url": "https://github.com/spautz/limited-cache.git"
+    "url": "git+https://github.com/spautz/limited-cache.git",
+    "directory": "packages/limited-cache"
   },
   "author": {
     "name": "Steven Pautz",
-    "url": "http://stevenpautz.com/"
+    "url": "https://github.com/spautz/"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "tag": "next"
   },
   "files": [
     "dist/",
+    "docs/",
     "legacy-types/",
     "src/",
     "LICENSE",
     "*.md"
   ],
-  "source": "src/index.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.esm.js",
-  "jsnext:main": "dist/index.esm.js",
-  "types": "dist/index.d.ts",
-  "sideEffects": false,
-  "engines": {
-    "node": ">=10",
-    "yarn": "1.*"
-  },
-  "scripts": {
-    "____ LIFECYCLE HOOKS _______________________________________________": "",
-    "prepare": "yon run build && husky install",
-    "prerelease": "yon run build:clean",
-    "prepublishOnly": "yarn run dev:readonly && yarn run build",
-    "____ INTEGRATION ___________________________________________________": "",
-    "clean": "yon run build:clean && yon run test:clean && rimraf ./node_modules/.cache/",
-    "dev": "yon run format && yon run types && yon run lint",
-    "dev:readonly": "yon run format:verify && yon run types && yon run lint",
-    "all": "yon run clean && yon run dev && yon run test:coverage && yon run build",
-    "all:readonly": "yon run dev:readonly && yon run test:coverage",
-    "____ INDIVIDUAL COMMANDS ___________________________________________": "",
-    "build": "yon run build:clean && yon run build:main && yon run build:verify && yon run build:types",
-    "build:clean": "rimraf ./dist ./legacy-types",
-    "build:main": "tsdx build",
-    "build:types": "yon run build:types:3.x && yon run build:types:4.x",
-    "build:types:3.x": "downlevel-dts ./dist ./legacy-types/ts3.x/dist --to=3.0",
-    "build:types:4.x": "downlevel-dts ./dist ./dist --to=4.0",
-    "build:verify": "node ./scripts/verify-build.js",
-    "build:watch": "tsdx watch",
-    "format": "prettier --write \"**/*.*\"",
-    "format:verify": "prettier --list-different \"**/*.*\"",
-    "lint": "tsdx lint . --max-warnings 0",
-    "lint-staged": "lint-staged",
-    "release:changelog": "standard-version --skip.commit --skip.tag --release-as ",
-    "release:tag": "standard-version --commit-all --sign --skip.changelog --release-as ",
-    "test": "yon run test:coverage",
-    "test:clean": "rimraf ./coverage",
-    "test:coverage": "yon run test:clean && tsdx test --coverage",
-    "test:nowatch": "yon run test:clean && tsdx test",
-    "test:watch": "yon run test:clean && tsdx test --watch",
-    "test:watchcoverage": "yon run test:clean && tsdx test --watchAll --coverage",
-    "types": "tsc --noEmit --p tsconfig.json"
+  "source": "./src/index.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
   },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "jsnext:main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
   "dependencies": {},
   "devDependencies": {
-    "@types/jest": "26.0.23",
-    "@types/node": "15.12.4",
-    "downlevel-dts": "0.7.0",
-    "husky": "6.0.0",
-    "lint-staged": "10.5.4",
-    "rimraf": "3.0.2",
-    "standard-version": "9.3.0",
-    "tsdx": "0.14.1",
-    "typescript": "4.2.4",
-    "yarn-or-npm": "3.0.1"
-  },
-  "resolutions": {
-    "**/@typescript-eslint/eslint-plugin": "^4.28.0",
-    "**/@typescript-eslint/parser": "^4.28.0"
+    "@types/node": "18.16.3"
   },
-  "lint-staged": {
-    "**/*.{css,html,js,jsx,json,less,md,scss,ts,tsx}": [
-      "prettier --write"
-    ]
-  },
-  "standard-version": {
-    "scripts": {
-      "postchangelog": "yon run format"
+  "peerDependencies": {},
+  "size-limit": [
+    {
+      "path": "dist/index.js",
+      "import": "{}",
+      "limit": "20 B"
+    },
+    {
+      "path": "dist/index.js",
+      "limit": "2 kB"
     }
-  },
+  ],
   "typesVersions": {
-    "<4": {
+    "<4.0": {
       "*": [
-        "legacy-types/ts3.x/*"
+        "legacy-types/ts3.5/index.d.ts"
+      ]
+    },
+    "<4.5": {
+      "*": [
+        "legacy-types/ts4.0/index.d.ts"
+      ]
+    },
+    "<4.7": {
+      "*": [
+        "legacy-types/ts4.5/index.d.ts"
+      ]
+    },
+    "*": {
+      "*": [
+        "dist/index.d.ts"
       ]
     }
+  },
+  "scripts": {
+    "____ HOOKS _________________________________________________________": "",
+    "____ INTEGRATION ___________________________________________________": "",
+    "clean": "pnpm run build:clean && pnpm run test:clean && rimraf --glob ./node_modules/.cache *.log",
+    "all": "pnpm run format                 && pnpm run typecheck && pnpm run lint:fix && pnpm run test:coverage && pnpm run build",
+    "all:readonly": "pnpm run format:verify && pnpm run typecheck && pnpm run lint     && pnpm run test:quick",
+    "all:quick": "pnpm run format           && pnpm run typecheck && pnpm run lint:fix",
+    "all:ci": "pnpm run format:verify       && pnpm run typecheck && pnpm run lint     && pnpm run test:ci && pnpm run build",
+    "____ INDIVIDUAL COMMANDS ___________________________________________": "",
+    "build": "pnpm run build:main && pnpm run sizecheck && pnpm run build:legacytypes",
+    "build:clean": "rimraf ./dist ./legacy-types",
+    "build:main": "pnpm run build:clean && tsup src/index.ts --format cjs && tsc -p ./tsconfig.build.json",
+    "build:legacytypes": "pnpm run build:legacytypes:3.5 && pnpm run build:legacytypes:4.0 && pnpm run build:legacytypes:4.5",
+    "build:legacytypes:3.5": "downlevel-dts ./dist ./legacy-types/ts3.5 --to=3.5",
+    "build:legacytypes:4.0": "downlevel-dts ./dist ./legacy-types/ts4.0 --to=4.0",
+    "build:legacytypes:4.5": "downlevel-dts ./dist ./legacy-types/ts4.5 --to=4.5",
+    "build:watch": "pnpm run build:clean && tsup src/index.ts --format esm,cjs --dts --watch",
+    "format": "prettier --write .",
+    "format:verify": "prettier --list-different .",
+    "lint": "eslint . --max-warnings 0",
+    "lint:fix": "eslint . --max-warnings 0 --fix",
+    "sizecheck": "size-limit",
+    "test": "pnpm run test:coverage",
+    "test:clean": "rimraf ./coverage",
+    "test:ci": "pnpm run test:clean            && vitest run --coverage",
+    "test:coverage": "pnpm run test:clean      && vitest run --coverage",
+    "test:quick": "pnpm run test:clean         && vitest run --coverage=false",
+    "test:watch": "pnpm run test:clean         && vitest watch --coverage=false",
+    "test:watchcoverage": "pnpm run test:clean && vitest watch --coverage",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit"
   }
-}
+}

package/src/__tests__/LimitedCache.test.ts

@@ -0,0 +1,186 @@
+import { describe, beforeEach, expect, it } from 'vitest';
+import { defaultOptions } from '../core/defaultOptions';
+import { LimitedCache } from '../core/LimitedCache';
+import { LimitedCacheInstance } from '../types';
+
+describe('LimitedCache', () => {
+  it('initializes without options', () => {
+    const myCache: LimitedCacheInstance = LimitedCache();
+
+    expect(myCache).toBeTruthy();
+  });
+
+  it('initializes with options', () => {
+    const myCache: LimitedCacheInstance = LimitedCache({
+      maxCacheSize: 123,
+      maxCacheTime: 456,
+      warnIfItemPurgedBeforeTime: 999,
+      opLimit: 10,
+      scanLimit: 100,
+    });
+
+    expect(myCache).toBeTruthy();
+  });
+
+  describe('works as a standard cache', () => {
+    let myCache: LimitedCacheInstance<number | undefined>;
+    beforeEach(() => {
+      myCache = LimitedCache<number | undefined>();
+    });
+
+    it('has: when missing', () => {
+      const result = myCache.has('asdf');
+      expect(result).toEqual(false);
+    });
+
+    it('has: when present', () => {
+      myCache.set('abc', 123);
+
+      const result = myCache.has('abc');
+      expect(result).toEqual(true);
+    });
+
+    it('get: when missing', () => {
+      const result = myCache.get('asdf');
+      expect(result).toBeUndefined();
+    });
+
+    it('get: when present', () => {
+      myCache.set('abc', 123);
+
+      const result = myCache.get('abc');
+      expect(result).toEqual(123);
+    });
+
+    it('getAll: when empty', () => {
+      const result = myCache.getAll();
+      expect(result).toEqual({});
+    });
+
+    it('getAll: when present', () => {
+      myCache.set('abc', 123);
+
+      const result = myCache.getAll();
+      expect(result).toEqual({ abc: 123 });
+    });
+
+    it('set: when new', () => {
+      const result = myCache.set('abc', 123);
+      expect(result).toEqual(123);
+    });
+
+    it('set: when already present', () => {
+      myCache.set('abc', 123);
+
+      const result = myCache.set('abc', 456);
+      expect(result).toEqual(456);
+    });
+
+    it('remove and return value', () => {
+      myCache.set('abc', 123);
+
+      const result = myCache.remove('abc');
+      expect(result).toEqual(true);
+    });
+
+    it('remove, then check', () => {
+      myCache.set('abc', 123);
+      myCache.remove('abc');
+
+      const result = myCache.has('abc');
+      expect(result).toEqual(false);
+    });
+
+    it('remove, then get', () => {
+      myCache.set('abc', 123);
+      myCache.remove('abc');
+
+      const result = myCache.get('abc');
+      expect(result).toEqual(undefined);
+    });
+
+    it('remove undefined values', () => {
+      myCache.set('abc', 123);
+      myCache.remove('abc');
+
+      const result = myCache.get('abc');
+      expect(result).toEqual(undefined);
+
+      myCache.set('abc', undefined);
+      myCache.remove('abc');
+
+      const result2 = myCache.get('abc');
+      expect(result2).toEqual(undefined);
+    });
+  });
+
+  describe('provides functions for managing options and meta', () => {
+    let myCache: LimitedCacheInstance<unknown>;
+    beforeEach(() => {
+      myCache = LimitedCache<unknown>();
+    });
+
+    it('getCacheMeta', () => {
+      const result = myCache.getCacheMeta();
+
+      expect(result).toEqual({
+        limitedCacheMetaVersion: 2,
+        options: defaultOptions,
+        cache: {},
+        keyList: [],
+        keyInfo: {},
+        opsLeft: 200,
+      });
+    });
+
+    it('getOptions', () => {
+      const result = myCache.getOptions();
+
+      expect(result).toEqual(defaultOptions);
+    });
+
+    it('setOptions and return value', () => {
+      const result = myCache.setOptions({
+        maxCacheSize: 123,
+        maxCacheTime: 456,
+        warnIfItemPurgedBeforeTime: 999,
+        opLimit: 10,
+        scanLimit: 100,
+      });
+
+      expect(result).toEqual({
+        ...defaultOptions,
+        maxCacheSize: 123,
+        maxCacheTime: 456,
+        warnIfItemPurgedBeforeTime: 999,
+        opLimit: 10,
+        scanLimit: 100,
+      });
+    });
+
+    it('setOptions as mutation', () => {
+      myCache.setOptions({
+        maxCacheSize: 123,
+        maxCacheTime: 456,
+        warnIfItemPurgedBeforeTime: 999,
+        opLimit: 10,
+        scanLimit: 100,
+      });
+
+      const result = myCache.getOptions();
+      expect(result).toEqual({
+        ...defaultOptions,
+        maxCacheSize: 123,
+        maxCacheTime: 456,
+        warnIfItemPurgedBeforeTime: 999,
+        opLimit: 10,
+        scanLimit: 100,
+      });
+    });
+
+    it('doMaintenance', () => {
+      // should not throw
+      myCache.doMaintenance();
+    });
+  });
+});

package/src/__tests__/LimitedCacheObject.test.ts

@@ -0,0 +1,150 @@
+import { describe, beforeEach, expect, it } from 'vitest';
+import { defaultOptions } from '../core/defaultOptions';
+import { LimitedCacheObject, getCacheMetaFromObject } from '../core/LimitedCacheObject';
+import { LimitedCacheObjectInstance } from '../types';
+
+describe('LimitedCacheObject', () => {
+  it('initializes without options', () => {
+    const myCache: LimitedCacheObjectInstance = LimitedCacheObject();
+
+    expect(myCache).toBeTruthy();
+  });
+
+  it('initializes with options', () => {
+    const myCache: LimitedCacheObjectInstance = LimitedCacheObject({
+      maxCacheSize: 123,
+      maxCacheTime: 456,
+      warnIfItemPurgedBeforeTime: 999,
+      opLimit: 10,
+      scanLimit: 100,
+    });
+
+    expect(myCache).toBeTruthy();
+  });
+
+  describe('look like a standard object', () => {
+    let myCache: LimitedCacheObjectInstance<number>;
+    beforeEach(() => {
+      myCache = LimitedCacheObject<number>();
+    });
+
+    it('has: when missing, via prototype hasOwnProperty', () => {
+      const result = Object.prototype.hasOwnProperty.call(myCache, 'asdf');
+      expect(result).toEqual(false);
+    });
+
+    it('has: when missing, via local hasOwnProperty', () => {
+      // eslint-disable-next-line no-prototype-builtins
+      const result = myCache.hasOwnProperty('asdf');
+      expect(result).toEqual(false);
+    });
+
+    it('has: when missing, via "in"', () => {
+      const result = 'asdf' in myCache;
+      expect(result).toEqual(false);
+    });
+
+    it('has: when present, via prototype hasOwnProperty', () => {
+      myCache.abc = 123;
+
+      const result = Object.prototype.hasOwnProperty.call(myCache, 'abc');
+      expect(result).toEqual(true);
+    });
+
+    it('has: when present, via local hasOwnProperty', () => {
+      myCache.abc = 123;
+
+      // eslint-disable-next-line no-prototype-builtins
+      const result = myCache.hasOwnProperty('abc');
+      expect(result).toEqual(true);
+    });
+
+    it('has: when present, via "in"', () => {
+      myCache.abc = 123;
+
+      const result = 'abc' in myCache;
+      expect(result).toEqual(true);
+    });
+
+    it('get: when missing', () => {
+      const result = myCache.asdf;
+      expect(result).toBeUndefined();
+    });
+
+    it('get: when present', () => {
+      myCache.abc = 123;
+
+      const result = myCache.abc;
+      expect(result).toEqual(123);
+    });
+
+    it('set: when new', () => {
+      const result = (myCache.abc = 123);
+      expect(result).toEqual(123);
+    });
+
+    it('set: when already present', () => {
+      myCache.abc = 123;
+
+      const result = (myCache.abc = 456);
+      expect(result).toEqual(456);
+    });
+
+    it('delete and return value', () => {
+      myCache.abc = 123;
+
+      const result = delete myCache.abc;
+      expect(result).toEqual(true);
+    });
+
+    it('delete, then check', () => {
+      myCache.abc = 123;
+      delete myCache.abc;
+
+      const result = Object.prototype.hasOwnProperty.call(myCache, 'abc');
+      expect(result).toEqual(false);
+    });
+
+    it('delete, then get', () => {
+      myCache.abc = 123;
+      delete myCache.abc;
+
+      const result = myCache.abc;
+      expect(result).toEqual(undefined);
+    });
+
+    it('keys: when empty', () => {
+      const result = Object.keys(myCache);
+      expect(result).toEqual([]);
+    });
+
+    it('keys: when populated', () => {
+      myCache.abc = 123;
+
+      const result = Object.keys(myCache);
+      expect(result).toEqual(['abc']);
+    });
+
+    it('keys: when all are removed', () => {
+      myCache.abc = 123;
+      delete myCache.abc;
+
+      const result = Object.keys(myCache);
+      expect(result).toEqual([]);
+    });
+  });
+
+  it('offers a way to get the cacheMeta', () => {
+    const myCache = LimitedCacheObject<number>();
+    const result = getCacheMetaFromObject(myCache);
+
+    expect(result).toEqual({
+      limitedCacheMetaVersion: 2,
+      options: defaultOptions,
+      cache: {},
+      keyList: [],
+      keyInfo: {},
+      opsLeft: 200,
+    });
+  });
+});