@transferwise/neptune-validation 3.0.13 → 3.2.0

package/dist/common/keyMap.d.ts

@@ -0,0 +1,19 @@
+export declare const keyMap: {
+    readonly SPACE: {
+        readonly key: readonly [" ", "Spacebar"];
+        readonly keyCode: 32;
+    };
+    readonly ENTER: {
+        readonly key: "Enter";
+        readonly keyCode: 13;
+    };
+    readonly TAB: {
+        readonly key: "Tab";
+        readonly keyCode: 9;
+    };
+    readonly ESCAPE: {
+        readonly key: "Escape";
+        readonly keyCode: 27;
+    };
+};
+//# sourceMappingURL=keyMap.d.ts.map

package/dist/common/keyMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyMap.d.ts","sourceRoot":"","sources":["../../src/common/keyMap.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;CAKT,CAAC"}

package/dist/event-validators/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './isKey';
+//# sourceMappingURL=index.d.ts.map

package/dist/event-validators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/event-validators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC"}

package/dist/event-validators/isKey.d.ts

@@ -0,0 +1,6 @@
+declare const isKey: ({ keyType, event }: {
+    keyType?: string | undefined;
+    event?: Partial<KeyboardEvent> | null | undefined;
+}) => boolean;
+export default isKey;
+//# sourceMappingURL=isKey.d.ts.map

package/dist/event-validators/isKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isKey.d.ts","sourceRoot":"","sources":["../../src/event-validators/isKey.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,KAAK;;;aAkBV,CAAC;AAEF,eAAe,KAAK,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './type-validators';
+export * from './value-validators';
+export { default as isKey } from './event-validators';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.esm.js

@@ -0,0 +1,59 @@
+const isString = value => typeof value === 'string';
+const isNumber = value => typeof value === 'number' && !Number.isNaN(value);
+const isInteger = value => {
+  return isNumber(value) && Math.floor(value) === value;
+};
+const isBoolean = value => typeof value === 'boolean';
+const isObject = value => typeof value === 'object' && !isNull(value) && value.constructor === Object;
+const isArray = value => Array.isArray(value);
+const isNull = value => value === null;
+const isUndefined = value => typeof value === 'undefined';
+
+/**
+ * Checks empty values for arrays, objects and strings.
+ */
+const isEmpty = value => isString(value) && value.length === 0 || (isObject(value) || isArray(value)) && Object.keys(value).length === 0;
+
+const keyMap = {
+  SPACE: {
+    key: [' ', 'Spacebar'],
+    keyCode: 32
+  },
+  ENTER: {
+    key: 'Enter',
+    keyCode: 13
+  },
+  TAB: {
+    key: 'Tab',
+    keyCode: 9
+  },
+  ESCAPE: {
+    key: 'Escape',
+    keyCode: 27
+  }
+};
+
+const isKey = ({
+  keyType,
+  event
+}) => {
+  if (!keyType || !event) {
+    return false;
+  }
+  const upperCaseKeyType = keyType.toUpperCase();
+  if (!Object.hasOwn(keyMap, upperCaseKeyType)) {
+    return false;
+  }
+  const keyDef = keyMap[upperCaseKeyType];
+  const {
+    key,
+    keyCode
+  } = event;
+  if (key) {
+    return isArray(keyDef.key) ? keyDef.key.includes(key) : key === keyDef.key;
+  }
+  return keyCode === keyDef.keyCode;
+};
+
+export { isArray, isBoolean, isEmpty, isInteger, isKey, isNull, isNumber, isObject, isString, isUndefined };
+//# sourceMappingURL=index.esm.js.map

package/dist/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":["../src/type-validators/index.ts","../src/value-validators/index.ts","../src/common/keyMap.ts","../src/event-validators/isKey.ts"],"sourcesContent":[null,null,null,null],"names":["isString","value","isNumber","isNaN","isInteger","Math","floor","isBoolean","isObject","isNull","constructor","Object","isArray","Array","keyMap","event"],"mappings":"AAAA,MAAAA,QAAa,GAAAC,KAAmB,IAAA,OAAAA;MAChCC,QAAa,GAAAD,KAAmB,IAAA,OAAAA,6BACoB,CAAAE,KAAA,CAAAF,KAAA,EAAA;AACpDG,MAAAA,SAAa,GAAAH,KAAoB,IAAA;AAGjC,EAAA,OAAAC,QAAa,CAAAD,KAAA,CAAA,IAASI,IAAW,CAAAC,KAAA,CAAAL,KAAA,CAAO;AAExC,EAAA;AAEA,MAAAM,SAAa,GAAAN,KAAkB,IAAA,OAAAA;AAC/B,MAAAO,QAAa,GAAAP,KAAiB,IAAA,OAAAA,sBAA0C,CAAAQ,MAAA,CAAAR,KAAA,CAAA,IAAAA,KAAA,CAAAS,WAAA,KAAAC,OAAA;AACxE,MAAAC,OAAa,GAAAX,KAAA,IAAsBY,KAAA,CAAAD,OAAA,CAAAX;;;;;ACRhC;AACH;;;ACLA,MAAAa,SAAmB;;;;;;;;;;;;;;;;;;;;;;;cCqBjB,IAAA,CAAAC,KAAA,EAAA;AAEF,IAAA,OAAe,KAAK,CAAA;;;;;;;;;;;;;;;;;;;"}

package/dist/index.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const isString = value => typeof value === 'string';
+const isNumber = value => typeof value === 'number' && !Number.isNaN(value);
+const isInteger = value => {
+  return isNumber(value) && Math.floor(value) === value;
+};
+const isBoolean = value => typeof value === 'boolean';
+const isObject = value => typeof value === 'object' && !isNull(value) && value.constructor === Object;
+const isArray = value => Array.isArray(value);
+const isNull = value => value === null;
+const isUndefined = value => typeof value === 'undefined';
+
+/**
+ * Checks empty values for arrays, objects and strings.
+ */
+const isEmpty = value => isString(value) && value.length === 0 || (isObject(value) || isArray(value)) && Object.keys(value).length === 0;
+
+const keyMap = {
+  SPACE: {
+    key: [' ', 'Spacebar'],
+    keyCode: 32
+  },
+  ENTER: {
+    key: 'Enter',
+    keyCode: 13
+  },
+  TAB: {
+    key: 'Tab',
+    keyCode: 9
+  },
+  ESCAPE: {
+    key: 'Escape',
+    keyCode: 27
+  }
+};
+
+const isKey = ({
+  keyType,
+  event
+}) => {
+  if (!keyType || !event) {
+    return false;
+  }
+  const upperCaseKeyType = keyType.toUpperCase();
+  if (!Object.hasOwn(keyMap, upperCaseKeyType)) {
+    return false;
+  }
+  const keyDef = keyMap[upperCaseKeyType];
+  const {
+    key,
+    keyCode
+  } = event;
+  if (key) {
+    return isArray(keyDef.key) ? keyDef.key.includes(key) : key === keyDef.key;
+  }
+  return keyCode === keyDef.keyCode;
+};
+
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isEmpty = isEmpty;
+exports.isInteger = isInteger;
+exports.isKey = isKey;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isString = isString;
+exports.isUndefined = isUndefined;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/type-validators/index.ts","../src/value-validators/index.ts","../src/common/keyMap.ts","../src/event-validators/isKey.ts"],"sourcesContent":[null,null,null,null],"names":["isString","value","isNumber","isNaN","isInteger","Math","floor","isBoolean","isObject","isNull","constructor","Object","isArray","Array","keyMap","event"],"mappings":";;AAAA,MAAAA,QAAa,GAAAC,KAAmB,IAAA,OAAAA;MAChCC,QAAa,GAAAD,KAAmB,IAAA,OAAAA,6BACoB,CAAAE,KAAA,CAAAF,KAAA,EAAA;AACpDG,MAAAA,SAAa,GAAAH,KAAoB,IAAA;AAGjC,EAAA,OAAAC,QAAa,CAAAD,KAAA,CAAA,IAASI,IAAW,CAAAC,KAAA,CAAAL,KAAA,CAAO;AAExC,EAAA;AAEA,MAAAM,SAAa,GAAAN,KAAkB,IAAA,OAAAA;AAC/B,MAAAO,QAAa,GAAAP,KAAiB,IAAA,OAAAA,sBAA0C,CAAAQ,MAAA,CAAAR,KAAA,CAAA,IAAAA,KAAA,CAAAS,WAAA,KAAAC,OAAA;AACxE,MAAAC,OAAa,GAAAX,KAAA,IAAsBY,KAAA,CAAAD,OAAA,CAAAX;;;;;ACRhC;AACH;;;ACLA,MAAAa,SAAmB;;;;;;;;;;;;;;;;;;;;;;;cCqBjB,IAAA,CAAAC,KAAA,EAAA;AAEF,IAAA,OAAe,KAAK,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/type-validators/index.d.ts

@@ -0,0 +1,9 @@
+export declare const isString: (value: unknown) => value is string;
+export declare const isNumber: (value: unknown) => value is number;
+export declare const isInteger: (value: unknown) => value is number;
+export declare const isBoolean: (value: unknown) => value is boolean;
+export declare const isObject: (value: unknown) => value is Record<string, unknown>;
+export declare const isArray: (value: unknown) => value is unknown[];
+export declare const isNull: (value: unknown) => value is null;
+export declare const isUndefined: (value: unknown) => value is undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/type-validators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/type-validators/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,UAAW,OAAO,oBAA+C,CAAC;AACvF,eAAO,MAAM,QAAQ,UAAW,OAAO,oBACY,CAAC;AACpD,eAAO,MAAM,SAAS,UAAW,OAAO,oBAEvC,CAAC;AACF,eAAO,MAAM,SAAS,UAAW,OAAO,qBAAiD,CAAC;AAE1F,eAAO,MAAM,QAAQ,UAAW,OAAO,qCACsC,CAAC;AAC9E,eAAO,MAAM,OAAO,UAAW,OAAO,uBAA6C,CAAC;AACpF,eAAO,MAAM,MAAM,UAAW,OAAO,kBAAkC,CAAC;AACxE,eAAO,MAAM,WAAW,UAAW,OAAO,uBAAqD,CAAC"}

package/dist/value-validators/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Checks empty values for arrays, objects and strings.
+ */
+export declare const isEmpty: (value: unknown) => boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/value-validators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/value-validators/index.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,OAAO,UAAW,OAAO,YAEoC,CAAC"}

package/package.json

@@ -1,13 +1,8 @@
 {
   "name": "@transferwise/neptune-validation",
-  "version": "3.0.13",
+  "version": "3.2.0",
   "description": "Neptune Web validation",
   "license": "Apache-2.0",
-  "main": "./build/umd/polyfill/main.js",
-  "module": "./build/es/polyfill/index.js",
-  "files": [
-    "build"
-  ],
   "keywords": [
     "wise",
     "neptune-web-validation"
@@ -17,19 +12,36 @@
     "fullname": "transferwise/neptune-web",
     "url": "git+https://github.com/transferwise/neptune-web.git"
   },
+  "author": "Wise Payments Ltd.",
+  "sideEffects": [
+    "*.css"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.esm.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/",
+    "src/",
+    "!**/*.tsbuildinfo"
+  ],
   "dependencies": {
-    "@babel/runtime": "^7.18.3",
+    "@babel/runtime": "^7.22.15",
     "core-js": "^3.8.0"
   },
   "devDependencies": {
-    "@rollup/plugin-babel": "^5.2.2",
-    "@rollup/plugin-commonjs": "^11.0.2",
-    "@rollup/plugin-node-resolve": "^7.1.3",
+    "@babel/core": "^7.22.15",
+    "@babel/plugin-transform-runtime": "^7.22.15",
+    "@babel/preset-env": "^7.22.15",
+    "@babel/preset-typescript": "^7.22.15",
+    "@rollup/plugin-babel": "^6.0.3",
+    "@rollup/plugin-node-resolve": "^15.2.1",
+    "@rollup/plugin-typescript": "^11.1.3",
     "@transferwise/eslint-config": "^7.4.0",
+    "@tsconfig/recommended": "^1.0.2",
+    "@types/babel__core": "^7.20.1",
     "@types/jest": "^27.5.2",
     "jest": "^27.0.6",
-    "rollup": "^2.34.0",
-    "rollup-plugin-uglify": "^6.0.4"
+    "rollup": "^3.28.1"
   },
   "publishConfig": {
     "access": "public"
@@ -45,8 +57,7 @@
     "lint:fix:format": "prettier --write --ignore-path ../../../.prettierignore .",
     "lint:fix:js+ts": "pnpm run lint:check:js+ts --fix",
     "build": "npm-run-all build:*",
-    "build:clean": "rm -rf build",
-    "build:umd": "NODE_ENV=umd rollup -c",
-    "build:es": "NODE_ENV=es babel src -d build/es/polyfill --ignore '**/*.spec.js','**/*.story.js'"
+    "build:clean": "rm -rf dist",
+    "build:js": "rollup --config --sourcemap"
   }
 }

package/src/common/keyMap.ts

@@ -0,0 +1,6 @@
+export const keyMap = {
+  SPACE: { key: [' ', 'Spacebar'], keyCode: 32 },
+  ENTER: { key: 'Enter', keyCode: 13 },
+  TAB: { key: 'Tab', keyCode: 9 },
+  ESCAPE: { key: 'Escape', keyCode: 27 },
+} as const;

package/src/event-validators/index.ts

@@ -0,0 +1 @@
+export { default } from './isKey';

package/src/event-validators/isKey.spec.ts

@@ -0,0 +1,58 @@
+/* eslint-disable no-console */
+import { keyMap } from '../common/keyMap';
+
+import isKey from '.';
+
+const { TAB, ESCAPE } = keyMap;
+
+describe('isKey', () => {
+  it('returns true if eventKey is equal to key', () => {
+    const event = { key: 'Tab', keyCode: TAB.keyCode };
+    expect(isKey({ keyType: TAB.key, event })).toBe(true);
+  });
+
+  it('returns true if eventKey is equal to empty key', () => {
+    const event = { key: ' ' };
+    expect(isKey({ keyType: 'Space', event })).toBe(true);
+  });
+
+  it('returns true if eventKey is equal to Spacebar', () => {
+    const event = { key: 'Spacebar' };
+    expect(isKey({ keyType: 'Space', event })).toBe(true);
+  });
+
+  it('returns true if eventKey is equal to Tab', () => {
+    const event = { key: 'Tab' };
+    expect(isKey({ keyType: TAB.key, event })).toBe(true);
+  });
+
+  it('returns true if eventKeyCode is equal to key', () => {
+    const event = { keyCode: TAB.keyCode };
+    expect(isKey({ keyType: TAB.key, event })).toBe(true);
+  });
+
+  it('returns false if key is  not defined', () => {
+    const event = { keyCode: TAB.keyCode };
+    expect(isKey({ event })).toBe(false);
+  });
+
+  it('returns false if event is  not defined', () => {
+    const event = null;
+    expect(isKey({ event })).toBe(false);
+  });
+
+  it('returns false if eventKey or eventKeyCode are not defined', () => {
+    const event = {};
+    expect(isKey({ keyType: TAB.key, event })).toBe(false);
+  });
+
+  it('returns false if eventKey is equal to key', () => {
+    const event = { key: 'Escape', keyCode: ESCAPE.keyCode };
+    expect(isKey({ keyType: TAB.key, event })).toBe(false);
+  });
+
+  it('returns false if eventKeyCode is equal to key', () => {
+    const event = { keyCode: ESCAPE.keyCode };
+    expect(isKey({ keyType: TAB.key, event })).toBe(false);
+  });
+});

package/src/event-validators/isKey.ts

@@ -0,0 +1,24 @@
+import { keyMap } from '../common/keyMap';
+import { isArray } from '../type-validators';
+
+const isKey = ({ keyType, event }: { keyType?: string; event?: Partial<KeyboardEvent> | null }) => {
+  if (!keyType || !event) {
+    return false;
+  }
+
+  const upperCaseKeyType = keyType.toUpperCase();
+  if (!Object.hasOwn(keyMap, upperCaseKeyType)) {
+    return false;
+  }
+  const keyDef = keyMap[upperCaseKeyType as keyof typeof keyMap];
+
+  const { key, keyCode } = event;
+
+  if (key) {
+    return isArray(keyDef.key) ? keyDef.key.includes(key) : key === keyDef.key;
+  }
+
+  return keyCode === keyDef.keyCode;
+};
+
+export default isKey;

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './type-validators';
+export * from './value-validators';
+export { default as isKey } from './event-validators';

package/src/type-validators/index.spec.ts

@@ -0,0 +1,140 @@
+import {
+  isString,
+  isNumber,
+  isInteger,
+  isBoolean,
+  isArray,
+  isObject,
+  isNull,
+  isUndefined,
+} from '.';
+
+describe('given a library for validating data types', () => {
+  describe('when validating a string', () => {
+    it('should return true when the value is a string', () => {
+      expect(isString('a')).toBe(true);
+      expect(isString('')).toBe(true);
+    });
+    it('should return false when the value is not string', () => {
+      expect(isString(1)).toBe(false);
+      expect(isString(true)).toBe(false);
+      expect(isString([])).toBe(false);
+      expect(isString({})).toBe(false);
+      expect(isString(undefined)).toBe(false);
+      expect(isString(null)).toBe(false);
+      expect(isString(NaN)).toBe(false);
+    });
+  });
+
+  describe('when validating a number', () => {
+    it('should return true when the value is a number', () => {
+      expect(isNumber(1)).toBe(true);
+      expect(isNumber(0)).toBe(true);
+      expect(isNumber(1.23)).toBe(true);
+      expect(isNumber(-1)).toBe(true);
+    });
+    it('should return false when the value is not number', () => {
+      expect(isNumber('a')).toBe(false);
+      expect(isNumber(true)).toBe(false);
+      expect(isNumber([])).toBe(false);
+      expect(isNumber({})).toBe(false);
+      expect(isNumber(undefined)).toBe(false);
+      expect(isNumber(null)).toBe(false);
+      expect(isNumber(NaN)).toBe(false);
+    });
+  });
+
+  describe('when validating an integer', () => {
+    it('should return true when the value is a integer', () => {
+      expect(isInteger(1)).toBe(true);
+      expect(isInteger(0)).toBe(true);
+      expect(isInteger(-1)).toBe(true);
+    });
+    it('should return false when the value is not an integer', () => {
+      expect(isInteger(1.23)).toBe(false);
+      expect(isInteger('a')).toBe(false);
+      expect(isInteger(true)).toBe(false);
+      expect(isInteger([])).toBe(false);
+      expect(isInteger({})).toBe(false);
+      expect(isInteger(undefined)).toBe(false);
+      expect(isInteger(null)).toBe(false);
+      expect(isInteger(NaN)).toBe(false);
+    });
+  });
+
+  describe('when validating a boolean', () => {
+    it('should return true when the value is a boolean', () => {
+      expect(isBoolean(true)).toBe(true);
+      expect(isBoolean(false)).toBe(true);
+    });
+    it('should return false when the value is not a boolean', () => {
+      expect(isBoolean(1)).toBe(false);
+      expect(isBoolean('a')).toBe(false);
+      expect(isBoolean([])).toBe(false);
+      expect(isBoolean({})).toBe(false);
+      expect(isBoolean(undefined)).toBe(false);
+      expect(isBoolean(null)).toBe(false);
+      expect(isBoolean(NaN)).toBe(false);
+    });
+  });
+
+  describe('when validating an array', () => {
+    it('should return true when the value is an array', () => {
+      expect(isArray([1])).toBe(true);
+      expect(isArray([])).toBe(true);
+    });
+    it('should return false when the value is not an array', () => {
+      expect(isArray(1)).toBe(false);
+      expect(isArray('a')).toBe(false);
+      expect(isArray(true)).toBe(false);
+      expect(isArray({})).toBe(false);
+      expect(isArray(undefined)).toBe(false);
+      expect(isArray(null)).toBe(false);
+      expect(isArray(NaN)).toBe(false);
+    });
+  });
+
+  describe('when validating an object', () => {
+    it('should return true when the value is an object', () => {
+      expect(isObject({ a: 1 })).toBe(true);
+      expect(isObject({})).toBe(true);
+    });
+    it('should return false when the value is not an object', () => {
+      expect(isObject(1)).toBe(false);
+      expect(isObject('a')).toBe(false);
+      expect(isObject(true)).toBe(false);
+      expect(isObject([])).toBe(false);
+      expect(isObject(undefined)).toBe(false);
+      expect(isObject(null)).toBe(false);
+      expect(isObject(NaN)).toBe(false);
+    });
+  });
+
+  describe('when validating a null', () => {
+    it('should return true when the value is null', () => {
+      expect(isNull(null)).toBe(true);
+    });
+    it('should return false when the value is not null', () => {
+      expect(isNull(0)).toBe(false);
+      expect(isNull(false)).toBe(false);
+      expect(isNull([])).toBe(false);
+      expect(isNull({})).toBe(false);
+      expect(isNull(undefined)).toBe(false);
+      expect(isNull(NaN)).toBe(false);
+    });
+  });
+
+  describe('when validating an undefined', () => {
+    it('should return true when the value is undefined', () => {
+      expect(isUndefined(undefined)).toBe(true);
+    });
+    it('should return false when the value is not undefined', () => {
+      expect(isUndefined(0)).toBe(false);
+      expect(isUndefined(false)).toBe(false);
+      expect(isUndefined([])).toBe(false);
+      expect(isUndefined({})).toBe(false);
+      expect(isUndefined(null)).toBe(false);
+      expect(isUndefined(NaN)).toBe(false);
+    });
+  });
+});

package/src/type-validators/index.ts

@@ -0,0 +1,13 @@
+export const isString = (value: unknown): value is string => typeof value === 'string';
+export const isNumber = (value: unknown): value is number =>
+  typeof value === 'number' && !Number.isNaN(value);
+export const isInteger = (value: unknown): value is number => {
+  return isNumber(value) && Math.floor(value) === value;
+};
+export const isBoolean = (value: unknown): value is boolean => typeof value === 'boolean';
+
+export const isObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && !isNull(value) && value.constructor === Object;
+export const isArray = (value: unknown): value is unknown[] => Array.isArray(value);
+export const isNull = (value: unknown): value is null => value === null;
+export const isUndefined = (value: unknown): value is undefined => typeof value === 'undefined';

package/src/value-validators/index.spec.ts

@@ -0,0 +1,23 @@
+import { isEmpty } from '.';
+
+describe('given a library for validating values', () => {
+  describe('when checking for empty values', () => {
+    it('should return true for empty strings', () => {
+      expect(isEmpty('')).toBe(true);
+      expect(isEmpty('a')).toBe(false);
+    });
+    it('should return true for empty array', () => {
+      expect(isEmpty([])).toBe(true);
+      expect(isEmpty(['a'])).toBe(false);
+    });
+    it('should return true for empty object', () => {
+      expect(isEmpty({})).toBe(true);
+      expect(isEmpty({ a: 'a' })).toBe(false);
+    });
+    it('should return false when the value is not a string, array, or object', () => {
+      expect(isEmpty(1)).toBe(false);
+      expect(isEmpty(null)).toBe(false);
+      expect(isEmpty(undefined)).toBe(false);
+    });
+  });
+});

package/src/value-validators/index.ts

@@ -0,0 +1,8 @@
+import { isString, isObject, isArray } from '../type-validators';
+
+/**
+ * Checks empty values for arrays, objects and strings.
+ */
+export const isEmpty = (value: unknown) =>
+  (isString(value) && value.length === 0) ||
+  ((isObject(value) || isArray(value)) && Object.keys(value).length === 0);

package/build/es/polyfill/common/keyMap.js

@@ -1 +0,0 @@
-export var keyMap={SPACE:{key:[" ","Spacebar"],keyCode:32},ENTER:{key:"Enter",keyCode:13},TAB:{key:"Tab",keyCode:9},ESCAPE:{key:"Escape",keyCode:27}};

package/build/es/polyfill/event-validators/index.js

@@ -1 +0,0 @@
-export{default}from"./isKey";

package/build/es/polyfill/event-validators/isKey.js

@@ -1 +0,0 @@
-import"core-js/modules/es.array.includes.js";import"core-js/modules/es.string.includes.js";import{keyMap}from"../common/keyMap";import{isArray}from"../type-validators";var isKey=function(a){var b=a.keyType,c=a.event;if(!b||!c)return!1;var d=b.toUpperCase(),e=keyMap[d];if(!e)return!1;var f=c.key,g=c.keyCode;return f?isArray(e.key)?e.key.includes(f):f===e.key:g===e.keyCode};export default isKey;

package/build/es/polyfill/index.js

@@ -1 +0,0 @@
-export*from"./type-validators";export*from"./value-validators";export{default as isKey}from"./event-validators";

package/build/es/polyfill/type-validators/index.js

@@ -1 +0,0 @@
-import"core-js/modules/es.number.is-nan.js";import"core-js/modules/es.number.constructor.js";var isString=function(a){return"string"==typeof a},isNumber=function(a){return"number"==typeof a&&!Number.isNaN(a)},isInteger=function(a){return isNumber(a)&&Math.floor(a)===a},isBoolean=function(a){return"boolean"==typeof a},isObject=function(a){return!isNull(a)&&!isUndefined(a)&&a.constructor===Object},isArray=function(a){return Array.isArray(a)},isNull=function(a){return null===a},isUndefined=function(a){return"undefined"==typeof a};export{isString,isNumber,isInteger,isBoolean,isObject,isArray,isNull,isUndefined};

package/build/es/polyfill/type-validators/spec.js

@@ -1 +0,0 @@
-import{isString,isNumber,isInteger,isBoolean,isArray,isObject,isNull,isUndefined}from".";describe("Given a library for validating data types",function(){describe("when validating a string",function(){it("should return true when the value is a string",function(){expect(isString("a")).toBe(!0),expect(isString("")).toBe(!0)}),it("should return false when the value is not string",function(){expect(isString(1)).toBe(!1),expect(isString(!0)).toBe(!1),expect(isString([])).toBe(!1),expect(isString({})).toBe(!1),expect(isString(void 0)).toBe(!1),expect(isString(null)).toBe(!1),expect(isString(NaN)).toBe(!1)})}),describe("when validating a number",function(){it("should return true when the value is a number",function(){expect(isNumber(1)).toBe(!0),expect(isNumber(0)).toBe(!0),expect(isNumber(1.23)).toBe(!0),expect(isNumber(-1)).toBe(!0)}),it("should return false when the value is not number",function(){expect(isNumber("a")).toBe(!1),expect(isNumber(!0)).toBe(!1),expect(isNumber([])).toBe(!1),expect(isNumber({})).toBe(!1),expect(isNumber(void 0)).toBe(!1),expect(isNumber(null)).toBe(!1),expect(isNumber(NaN)).toBe(!1)})}),describe("when validating an integer",function(){it("should return true when the value is a integer",function(){expect(isInteger(1)).toBe(!0),expect(isInteger(0)).toBe(!0),expect(isInteger(-1)).toBe(!0)}),it("should return false when the value is not an integer",function(){expect(isInteger(1.23)).toBe(!1),expect(isInteger("a")).toBe(!1),expect(isInteger(!0)).toBe(!1),expect(isInteger([])).toBe(!1),expect(isInteger({})).toBe(!1),expect(isInteger(void 0)).toBe(!1),expect(isInteger(null)).toBe(!1),expect(isInteger(NaN)).toBe(!1)})}),describe("when validating a boolean",function(){it("should return true when the value is a boolean",function(){expect(isBoolean(!0)).toBe(!0),expect(isBoolean(!1)).toBe(!0)}),it("should return false when the value is not a boolean",function(){expect(isBoolean(1)).toBe(!1),expect(isBoolean("a")).toBe(!1),expect(isBoolean([])).toBe(!1),expect(isBoolean({})).toBe(!1),expect(isBoolean(void 0)).toBe(!1),expect(isBoolean(null)).toBe(!1),expect(isBoolean(NaN)).toBe(!1)})}),describe("when validating an array",function(){it("should return true when the value is an array",function(){expect(isArray([1])).toBe(!0),expect(isArray([])).toBe(!0)}),it("should return false when the value is not an array",function(){expect(isArray(1)).toBe(!1),expect(isArray("a")).toBe(!1),expect(isArray(!0)).toBe(!1),expect(isArray({})).toBe(!1),expect(isArray(void 0)).toBe(!1),expect(isArray(null)).toBe(!1),expect(isArray(NaN)).toBe(!1)})}),describe("when validating an object",function(){it("should return true when the value is an object",function(){expect(isObject({a:1})).toBe(!0),expect(isObject({})).toBe(!0)}),it("should return false when the value is not an object",function(){expect(isObject(1)).toBe(!1),expect(isObject("a")).toBe(!1),expect(isObject(!0)).toBe(!1),expect(isObject([])).toBe(!1),expect(isObject(void 0)).toBe(!1),expect(isObject(null)).toBe(!1),expect(isObject(NaN)).toBe(!1)})}),describe("when validating a null",function(){it("should return true when the value is null",function(){expect(isNull(null)).toBe(!0)}),it("should return false when the value is not null",function(){expect(isNull(0)).toBe(!1),expect(isNull(!1)).toBe(!1),expect(isNull([])).toBe(!1),expect(isNull({})).toBe(!1),expect(isNull(void 0)).toBe(!1),expect(isNull(NaN)).toBe(!1)})}),describe("when validating an undefined",function(){it("should return true when the value is undefined",function(){expect(isUndefined(void 0)).toBe(!0)}),it("should return false when the value is not undefined",function(){expect(isUndefined(0)).toBe(!1),expect(isUndefined(!1)).toBe(!1),expect(isUndefined([])).toBe(!1),expect(isUndefined({})).toBe(!1),expect(isUndefined(null)).toBe(!1),expect(isUndefined(NaN)).toBe(!1)})})});

package/build/es/polyfill/value-validators/index.js

@@ -1,5 +0,0 @@
-import"core-js/modules/es.object.keys.js";import{isString,isObject,isArray}from"../type-validators";/**
- * Checks empty values for arrays,objects and strings.
- *
- * @param {object | Array | string} value
- */var isEmpty=function(a){return isString(a)&&0===a.length||(isObject(a)||isArray(a))&&0===Object.keys(a).length};export{isEmpty};

package/build/es/polyfill/value-validators/spec.js

@@ -1 +0,0 @@
-import{isEmpty}from".";describe("Given a library for validating values",function(){describe("when checking for empty values",function(){it("should return true for empty strings",function(){expect(isEmpty("")).toBe(!0),expect(isEmpty("a")).toBe(!1)}),it("should return true for empty array",function(){expect(isEmpty([])).toBe(!0),expect(isEmpty(["a"])).toBe(!1)}),it("should return true for empty object",function(){expect(isEmpty({})).toBe(!0),expect(isEmpty({a:"a"})).toBe(!1)}),it("should return false when the value is not a string, array, or object",function(){expect(isEmpty(1)).toBe(!1),expect(isEmpty(null)).toBe(!1),expect(isEmpty(void 0)).toBe(!1)})})});

package/build/umd/polyfill/main.js

@@ -1 +0,0 @@
-!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("core-js/modules/es.number.is-nan.js"),require("core-js/modules/es.number.constructor.js"),require("core-js/modules/es.object.keys.js"),require("core-js/modules/es.array.includes.js"),require("core-js/modules/es.string.includes.js")):"function"==typeof define&&define.amd?define(["exports","core-js/modules/es.number.is-nan.js","core-js/modules/es.number.constructor.js","core-js/modules/es.object.keys.js","core-js/modules/es.array.includes.js","core-js/modules/es.string.includes.js"],r):r((e="undefined"!=typeof globalThis?globalThis:e||self)["@transferwise/neptune-validation"]={})}(this,function(e){"use strict";function r(e){return"string"==typeof e}function s(e){return"number"==typeof e&&!Number.isNaN(e)}function n(e){return!t(e)&&!u(e)&&e.constructor===Object}function o(e){return Array.isArray(e)}var t=function(e){return null===e},u=function(e){return void 0===e},i={SPACE:{key:[" ","Spacebar"],keyCode:32},ENTER:{key:"Enter",keyCode:13},TAB:{key:"Tab",keyCode:9},ESCAPE:{key:"Escape",keyCode:27}};e.isArray=o,e.isBoolean=function(e){return"boolean"==typeof e},e.isEmpty=function(e){return r(e)&&0===e.length||(n(e)||o(e))&&0===Object.keys(e).length},e.isInteger=function(e){return s(e)&&Math.floor(e)===e},e.isKey=function(e){var r=e.keyType,s=e.event;if(!r||!s)return!1;e=r.toUpperCase(),r=i[e];if(!r)return!1;e=s.key,s=s.keyCode;return e?o(r.key)?r.key.includes(e):e===r.key:s===r.keyCode},e.isNull=t,e.isNumber=s,e.isObject=n,e.isString=r,e.isUndefined=u,Object.defineProperty(e,"__esModule",{value:!0})});