@terascope/data-mate 0.57.0 → 1.0.0

package/dist/src/transforms/field-transform.js

@@ -1,326 +1,297 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toTitleCase = exports.toSnakeCase = exports.toPascalCase = exports.toKebabCase = exports.toCamelCase = exports.parseDate = exports.formatDate = exports.toISO8601 = exports.toUnixTime = exports.splitString = exports.replaceLiteral = exports.replaceRegex = exports.extract = exports.toGeoPoint = exports.toJSON = exports.parseJSON = exports.encodeSHA1 = exports.encodeSHA = exports.encodeMD5 = exports.encodeHex = exports.decodeHex = exports.encodeURL = exports.decodeURL = exports.encodeBase64 = exports.decodeBase64 = exports.toNumber = exports.toISDN = exports.truncate = exports.trimEnd = exports.trimStart = exports.trim = exports.toLowerCase = exports.toUpperCase = exports.toBoolean = exports.toString = exports.setField = exports.map = exports.setDefault = exports.repository = void 0;
-const ts = __importStar(require("@terascope/utils"));
-const types_1 = require("@terascope/types");
-const crypto_1 = __importDefault(require("crypto"));
-const awesome_phonenumber_1 = __importDefault(require("awesome-phonenumber"));
-const date_fns_1 = require("date-fns");
-const field_validator_1 = require("../validations/field-validator");
-const interfaces_1 = require("../interfaces");
-exports.repository = {
+import * as ts from '@terascope/utils';
+import { FieldType } from '@terascope/types';
+import crypto from 'node:crypto';
+import PhoneValidator from 'awesome-phonenumber';
+import { format as dateFormat, parse } from 'date-fns';
+import { isString, isValidDate, isNumber, isArray, isNumberTuple } from '../validations/field-validator.js';
+import { InputType } from '../interfaces.js';
+export const repository = {
     toString: {
         fn: toString,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     toBoolean: {
         fn: toBoolean,
         config: {},
-        output_type: types_1.FieldType.Boolean,
-        primary_input_type: interfaces_1.InputType.Any
+        output_type: FieldType.Boolean,
+        primary_input_type: InputType.Any
     },
     toUpperCase: {
         fn: toUpperCase,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     toLowerCase: {
         fn: toLowerCase,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     trim: {
         fn: trim,
         config: {
-            char: { type: types_1.FieldType.String }
+            char: { type: FieldType.String }
         },
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     truncate: {
         fn: truncate,
         config: {
-            size: { type: types_1.FieldType.Number }
+            size: { type: FieldType.Number }
         },
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     toISDN: {
         fn: toISDN,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     toNumber: {
         fn: toNumber,
         config: {
-            booleanLike: { type: types_1.FieldType.Boolean }
+            booleanLike: { type: FieldType.Boolean }
         },
-        output_type: types_1.FieldType.Number,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.Number,
+        primary_input_type: InputType.String
     },
     decodeBase64: {
         fn: decodeBase64,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     encodeBase64: {
         fn: encodeBase64,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     decodeURL: {
         fn: decodeURL,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     encodeURL: {
         fn: encodeURL,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     decodeHex: {
         fn: decodeHex,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     encodeHex: {
         fn: encodeHex,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     encodeMD5: {
         fn: encodeMD5,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     encodeSHA: {
         fn: encodeSHA,
         config: {
-            hash: { type: types_1.FieldType.String },
-            digest: { type: types_1.FieldType.String }
+            hash: { type: FieldType.String },
+            digest: { type: FieldType.String }
         },
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     encodeSHA1: {
         fn: encodeSHA1,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     parseJSON: {
         fn: parseJSON,
         config: {},
-        output_type: types_1.FieldType.Any,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.Any,
+        primary_input_type: InputType.String
     },
     toJSON: {
         fn: toJSON,
         config: {
-            pretty: { type: types_1.FieldType.Boolean }
+            pretty: { type: FieldType.Boolean }
         },
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.Any
+        output_type: FieldType.String,
+        primary_input_type: InputType.Any
     },
     toGeoPoint: {
         fn: toGeoPoint,
         config: {},
-        output_type: types_1.FieldType.GeoPoint,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.GeoPoint,
+        primary_input_type: InputType.String
     },
     // this will be overridden
     extract: {
         fn: extract,
         config: {
-            regex: { type: types_1.FieldType.String },
-            isMultiValue: { type: types_1.FieldType.Boolean },
-            jexlExp: { type: types_1.FieldType.String },
-            start: { type: types_1.FieldType.String },
-            end: { type: types_1.FieldType.String }
+            regex: { type: FieldType.String },
+            isMultiValue: { type: FieldType.Boolean },
+            jexlExp: { type: FieldType.String },
+            start: { type: FieldType.String },
+            end: { type: FieldType.String }
         },
-        output_type: types_1.FieldType.Any,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.Any,
+        primary_input_type: InputType.String
     },
     replaceRegex: {
         fn: replaceRegex,
         config: {
-            regex: { type: types_1.FieldType.String },
-            replace: { type: types_1.FieldType.String },
-            global: { type: types_1.FieldType.String },
-            ignore_case: { type: types_1.FieldType.Boolean }
+            regex: { type: FieldType.String },
+            replace: { type: FieldType.String },
+            global: { type: FieldType.String },
+            ignore_case: { type: FieldType.Boolean }
         },
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     replaceLiteral: {
         fn: replaceLiteral,
         config: {
             search: {
-                type: types_1.FieldType.String
+                type: FieldType.String
             },
             replace: {
-                type: types_1.FieldType.String
+                type: FieldType.String
             }
         },
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     toUnixTime: {
         fn: toUnixTime,
         config: {},
-        output_type: types_1.FieldType.Number,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.Number,
+        primary_input_type: InputType.String
     },
     toISO8601: {
         fn: toISO8601,
         config: {
             resolution: {
-                type: types_1.FieldType.String,
+                type: FieldType.String,
                 description: 'may be set to seconds | milliseconds'
             }
         },
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     formatDate: {
         fn: formatDate,
         config: {
-            format: { type: types_1.FieldType.String },
-            resolution: { type: types_1.FieldType.String, description: 'may be set to seconds | milliseconds' },
+            format: { type: FieldType.String },
+            resolution: { type: FieldType.String, description: 'may be set to seconds | milliseconds' },
         },
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     parseDate: {
         fn: parseDate,
         config: {
-            format: { type: types_1.FieldType.String },
+            format: { type: FieldType.String },
         },
-        output_type: types_1.FieldType.Date,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.Date,
+        primary_input_type: InputType.String
     },
     trimStart: {
         fn: trimStart,
         config: {
-            char: { type: types_1.FieldType.String }
+            char: { type: FieldType.String }
         },
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     trimEnd: {
         fn: trimEnd,
         config: {
-            char: { type: types_1.FieldType.String }
+            char: { type: FieldType.String }
         },
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     toCamelCase: {
         fn: toCamelCase,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     toKebabCase: {
         fn: toKebabCase,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     toPascalCase: {
         fn: toPascalCase,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     toSnakeCase: {
         fn: toSnakeCase,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     toTitleCase: {
         fn: toTitleCase,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     },
     setField: {
         fn: setField,
         config: {
             value: {
-                type: types_1.FieldType.Any
+                type: FieldType.Any
             }
         },
-        output_type: types_1.FieldType.Any,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.Any,
+        primary_input_type: InputType.String
     },
     setDefault: {
         fn: setDefault,
         config: {
             value: {
-                type: types_1.FieldType.Any
+                type: FieldType.Any
             }
         },
-        output_type: types_1.FieldType.Any,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.Any,
+        primary_input_type: InputType.String
     },
     map: {
         fn: map,
         config: {
             fn: {
-                type: types_1.FieldType.String
+                type: FieldType.String
             },
             options: {
-                type: types_1.FieldType.Object
+                type: FieldType.Object
             }
         },
-        output_type: types_1.FieldType.Any,
-        primary_input_type: interfaces_1.InputType.Array
+        output_type: FieldType.Any,
+        primary_input_type: InputType.Array
     },
     splitString: {
         fn: splitString,
         config: {},
-        output_type: types_1.FieldType.String,
-        primary_input_type: interfaces_1.InputType.String
+        output_type: FieldType.String,
+        primary_input_type: InputType.String
     }
 };
 /**
@@ -336,7 +307,7 @@ exports.repository = {
  * @param {{ value: any }} args value is what will be given when input is null/undefined
  * @returns {*}
  */
-function setDefault(input, _parentContext, args) {
+export function setDefault(input, _parentContext, args) {
     if (ts.isNil(input)) {
         if (ts.isNil(args.value))
             throw new Error('Parameter value cannot be set to undefined or null');
@@ -344,7 +315,6 @@ function setDefault(input, _parentContext, args) {
     }
     return input;
 }
-exports.setDefault = setDefault;
 /**
  * This function is used to map an array of values with any FieldTransform method
  *
@@ -359,18 +329,17 @@ exports.setDefault = setDefault;
  * options is an object with any additional parameters needed
  * @returns {any[] | null} returns the mapped values, return null if input is null/undefined
  */
-function map(input, parentContext, args) {
+export function map(input, parentContext, args) {
     if (ts.isNil(input))
         return null;
-    if (!(0, field_validator_1.isArray)(input))
+    if (!isArray(input))
         throw new Error(`Input must be an array, received ${ts.getTypeOf(input)}`);
     const { fn, options } = args;
-    const repoConfig = exports.repository[fn];
+    const repoConfig = repository[fn];
     if (!repoConfig)
         throw new Error(`No function ${fn} was found in the field transform repository`);
     return input.map((data) => repoConfig.fn(data, parentContext, options));
 }
-exports.map = map;
 // TODO: this is currently a hack for directives, this will evolve, do not use it for other purposes
 /**
  * This function is not meant to be used programmatically
@@ -380,11 +349,10 @@ exports.map = map;
  * @param {{ value: any }} args value will be used to set field
  * @returns
  */
-function setField(_input, _parentContext, args) {
+export function setField(_input, _parentContext, args) {
     const { value } = args;
     return value;
 }
-exports.setField = setField;
 /**
  * Converts values to strings
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -397,14 +365,13 @@ exports.setField = setField;
  * @param {*} input
  * @returns {String | null} returns null if input is null/undefined
  */
-function toString(input, _parentContext) {
+export function toString(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input))
+    if (isArray(input))
         return input.filter(ts.isNotNil).map(ts.toString);
     return ts.toString(input);
 }
-exports.toString = toString;
 /**
  * Converts values to booleans
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -417,14 +384,13 @@ exports.toString = toString;
  * @param {*} input
  * @returns {Boolean | null} returns null if input is null/undefined
  */
-function toBoolean(input, _parentContext) {
+export function toBoolean(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input))
+    if (isArray(input))
         return input.filter(ts.isNotNil).map(ts.toBoolean);
     return ts.toBoolean(input);
 }
-exports.toBoolean = toBoolean;
 /**
  * Converts strings to UpperCase
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -437,16 +403,15 @@ exports.toBoolean = toBoolean;
  * @param {StringInput} input string or string[]
  * @returns { String | String[] | null } returns null if input is null/undefined
  */
-function toUpperCase(input, _parentContext) {
+export function toUpperCase(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input))
+    if (isArray(input))
         return input.filter(ts.isNotNil).map((str) => str.toUpperCase());
-    if (!(0, field_validator_1.isString)(input))
+    if (!isString(input))
         throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
     return input.toUpperCase();
 }
-exports.toUpperCase = toUpperCase;
 /**
  * Converts strings to lowercase
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -459,16 +424,15 @@ exports.toUpperCase = toUpperCase;
  * @param {StringInput} input string | string[]
  * @returns { String | String[] | null } returns null if input is null/undefined
  */
-function toLowerCase(input, _parentContext) {
+export function toLowerCase(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input))
+    if (isArray(input))
         return input.filter(ts.isNotNil).map((str) => str.toLowerCase());
-    if (!(0, field_validator_1.isString)(input))
+    if (!isString(input))
         throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
     return input.toLowerCase();
 }
-exports.toLowerCase = toLowerCase;
 /**
  * Will trim the input
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -488,18 +452,17 @@ exports.toLowerCase = toLowerCase;
  * @param {{ char: string }} [args] a single char or word that will be cut out
  * @returns { String | String[] | null } returns null if input is null/undefined
  */
-function trim(input, parentContext, args) {
+export function trim(input, parentContext, args) {
     if (ts.isNil(input))
         return null;
-    const char = ((args === null || args === void 0 ? void 0 : args.char) && (0, field_validator_1.isString)(args.char)) ? args.char : ' ';
-    if ((0, field_validator_1.isArray)(input)) {
+    const char = (args?.char && isString(args.char)) ? args.char : ' ';
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
             .map((str) => ts.trim(str, char));
     }
     return ts.trim(input, char);
 }
-exports.trim = trim;
 /**
  * Will trim the beginning of the input
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -515,21 +478,20 @@ exports.trim = trim;
  * @param {{ char: string }} [args]
  * @returns { String | String[] | null } returns null if input is null/undefined
  */
-function trimStart(input, _parentContext, args) {
+export function trimStart(input, _parentContext, args) {
     if (ts.isNil(input))
         return null;
-    if ((args === null || args === void 0 ? void 0 : args.char) && !(0, field_validator_1.isString)(args.char))
+    if (args?.char && !isString(args.char))
         throw new Error(`Parameter char must be a string, received ${ts.getTypeOf(input)}`);
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
-            .map((str) => ts.trimStart(str, args === null || args === void 0 ? void 0 : args.char));
+            .map((str) => ts.trimStart(str, args?.char));
     }
-    if (!(0, field_validator_1.isString)(input))
+    if (!isString(input))
         throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
-    return ts.trimStart(input, args === null || args === void 0 ? void 0 : args.char);
+    return ts.trimStart(input, args?.char);
 }
-exports.trimStart = trimStart;
 /**
  * Will trim the end of the input
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -544,21 +506,20 @@ exports.trimStart = trimStart;
  * @param {{ char: string }} [args]
  * @returns { String | String[] | null } returns null if input is null/undefined
  */
-function trimEnd(input, _parentContext, args) {
+export function trimEnd(input, _parentContext, args) {
     if (ts.isNil(input))
         return null;
-    if ((args === null || args === void 0 ? void 0 : args.char) && !(0, field_validator_1.isString)(args.char))
+    if (args?.char && !isString(args.char))
         throw new Error(`Parameter char must be a string, received ${ts.getTypeOf(input)}`);
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
-            .map((str) => ts.trimEnd(str, args === null || args === void 0 ? void 0 : args.char));
+            .map((str) => ts.trimEnd(str, args?.char));
     }
-    if (!(0, field_validator_1.isString)(input))
+    if (!isString(input))
         throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
-    return ts.trimEnd(input, args === null || args === void 0 ? void 0 : args.char);
+    return ts.trimEnd(input, args?.char);
 }
-exports.trimEnd = trimEnd;
 /**
  * Will truncate the input to the length of the size given
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -572,22 +533,21 @@ exports.trimEnd = trimEnd;
  * @param {{ size: number }} args
  * @returns { String | String[] | null } returns null if input is null/undefined
  */
-function truncate(input, _parentContext, args) {
+export function truncate(input, _parentContext, args) {
     const { size } = args;
     if (ts.isNil(input))
         return null;
     if (!size || !ts.isNumber(size) || size <= 0)
         throw new Error('Invalid size paramter for truncate');
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
             .map((str) => str.slice(0, size));
     }
-    if (!(0, field_validator_1.isString)(input))
+    if (!isString(input))
         throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
     return input.slice(0, size);
 }
-exports.truncate = truncate;
 function parsePhoneNumber(str) {
     let testNumber = ts.toString(str).trim();
     if (testNumber.charAt(0) === '0')
@@ -595,7 +555,7 @@ function parsePhoneNumber(str) {
     // needs to start with a +
     if (testNumber.charAt(0) !== '+')
         testNumber = `+${testNumber}`;
-    const fullNumber = new awesome_phonenumber_1.default(testNumber).getNumber();
+    const fullNumber = new PhoneValidator(testNumber).getNumber();
     if (fullNumber)
         return String(fullNumber).slice(1);
     throw Error('Could not determine the incoming phone number');
@@ -614,17 +574,16 @@ function parsePhoneNumber(str) {
  * @returns { String | String[] | null }  a fully validated phone number,
  * returns null if input is null/undefined
  */
-function toISDN(input, _parentContext) {
+export function toISDN(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input))
+    if (isArray(input))
         return input.filter(ts.isNotNil).map(parsePhoneNumber);
     return parsePhoneNumber(input);
 }
-exports.toISDN = toISDN;
 function convertToNumber(input, args) {
     let result = input;
-    if ((args === null || args === void 0 ? void 0 : args.booleanLike) === true && ts.isBooleanLike(input)) {
+    if (args?.booleanLike === true && ts.isBooleanLike(input)) {
         result = ts.toNumber(toBoolean(result));
     }
     result = ts.toNumber(result);
@@ -649,17 +608,16 @@ function convertToNumber(input, args) {
  * @param {{ booleanLike?: boolean }} [args]
  * @returns { number | null } returns null if input is null/undefined
  */
-function toNumber(input, _parentContext, args) {
-    if (ts.isNil(input) && (args === null || args === void 0 ? void 0 : args.booleanLike) !== true)
+export function toNumber(input, _parentContext, args) {
+    if (ts.isNil(input) && args?.booleanLike !== true)
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
             .map((data) => convertToNumber(data, args));
     }
     return convertToNumber(input, args);
 }
-exports.toNumber = toNumber;
 /**
  * decodes a base64 encoded value
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -677,17 +635,16 @@ exports.toNumber = toNumber;
  * @param {*} input
  * @returns { string | null } returns null if input is null/undefined
  */
-function decodeBase64(input, _parentContext) {
+export function decodeBase64(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
             .map((data) => Buffer.from(data, 'base64').toString('utf8'));
     }
     return Buffer.from(input, 'base64').toString('utf8');
 }
-exports.decodeBase64 = decodeBase64;
 /**
  * converts a value into a base64 encoded value
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -702,17 +659,16 @@ exports.decodeBase64 = decodeBase64;
  * @param {*} input
  * @returns { string | null } returns null if input is null/undefined
  */
-function encodeBase64(input, _parentContext) {
+export function encodeBase64(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
             .map((data) => Buffer.from(data).toString('base64'));
     }
     return Buffer.from(input).toString('base64');
 }
-exports.encodeBase64 = encodeBase64;
 /**
  * decodes a URL encoded value
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -728,16 +684,15 @@ exports.encodeBase64 = encodeBase64;
  * @param {StringInput} input
  * @returns { string | null } returns null if input is null/undefined
  */
-function decodeURL(input, _parentContext) {
+export function decodeURL(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input))
+    if (isArray(input))
         return input.filter(ts.isNotNil).map(decodeURIComponent);
-    if (!(0, field_validator_1.isString)(input))
+    if (!isString(input))
         throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
     return decodeURIComponent(input);
 }
-exports.decodeURL = decodeURL;
 /**
  * URL encodes a value
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -753,16 +708,15 @@ exports.decodeURL = decodeURL;
  * @param {StringInput} input
  * @returns { string | null } returns null if input is null/undefined
  */
-function encodeURL(input, _parentContext) {
+export function encodeURL(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input))
+    if (isArray(input))
         return input.filter(ts.isNotNil).map(encodeURIComponent);
-    if (!(0, field_validator_1.isString)(input))
+    if (!isString(input))
         throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
     return encodeURIComponent(input);
 }
-exports.encodeURL = encodeURL;
 /**
  * decodes the hex encoded input
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -778,17 +732,16 @@ exports.encodeURL = encodeURL;
  * @param {*} input
  * @returns { string | null } returns null if input is null/undefined
  */
-function decodeHex(input, _parentContext) {
+export function decodeHex(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
             .map((data) => Buffer.from(data, 'hex').toString('utf8'));
     }
     return Buffer.from(input, 'hex').toString('utf8');
 }
-exports.decodeHex = decodeHex;
 /**
  * hex encodes the input
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -803,17 +756,16 @@ exports.decodeHex = decodeHex;
  * @param {*} input
  * @returns { string | null } returns null if input is null/undefined
  */
-function encodeHex(input, _parentContext) {
+export function encodeHex(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
             .map((data) => Buffer.from(data).toString('hex'));
     }
     return Buffer.from(input).toString('hex');
 }
-exports.encodeHex = encodeHex;
 /**
  * MD5 encodes the input
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -826,17 +778,16 @@ exports.encodeHex = encodeHex;
  * @param {*} input
  * @returns { string | null } returns null if input is null/undefined
  */
-function encodeMD5(input, _parentContext) {
+export function encodeMD5(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
-            .map((data) => crypto_1.default.createHash('md5').update(data).digest('hex'));
+            .map((data) => crypto.createHash('md5').update(data).digest('hex'));
     }
-    return crypto_1.default.createHash('md5').update(input).digest('hex');
+    return crypto.createHash('md5').update(input).digest('hex');
 }
-exports.encodeMD5 = encodeMD5;
 /**
 * SHA encodes the input to the hash specified
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -854,20 +805,19 @@ exports.encodeMD5 = encodeMD5;
  *  possible hash values
  * @returns { string | null } returns null if input is null/undefined
  */
-function encodeSHA(input, _parentContext, { hash = 'sha256', digest = 'hex' } = {}) {
+export function encodeSHA(input, _parentContext, { hash = 'sha256', digest = 'hex' } = {}) {
     if (ts.isNil(input))
         return null;
     if (!['ascii', 'utf8', 'utf16le', 'ucs2', 'base64', 'latin1', 'hex', 'binary'].includes(digest)) {
         throw new Error('Parameter digest is misconfigured');
     }
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
-            .map((data) => crypto_1.default.createHash(hash).update(data).digest(digest));
+            .map((data) => crypto.createHash(hash).update(data).digest(digest));
     }
-    return crypto_1.default.createHash(hash).update(input).digest(digest);
+    return crypto.createHash(hash).update(input).digest(digest);
 }
-exports.encodeSHA = encodeSHA;
 /**
  * converts the value to a SHA1 encoded value
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -882,17 +832,16 @@ exports.encodeSHA = encodeSHA;
  * @param {*} input
  * @returns { string | null } returns null if input is null/undefined
  */
-function encodeSHA1(input, _parentContext) {
+export function encodeSHA1(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
-            .map((data) => crypto_1.default.createHash('sha1').update(data).digest('hex'));
+            .map((data) => crypto.createHash('sha1').update(data).digest('hex'));
     }
-    return crypto_1.default.createHash('sha1').update(input).digest('hex');
+    return crypto.createHash('sha1').update(input).digest('hex');
 }
-exports.encodeSHA1 = encodeSHA1;
 /**
  * Parses the json input
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -909,17 +858,16 @@ exports.encodeSHA1 = encodeSHA1;
  * @param {*} input
  * @returns { any | null } returns null if input is null/undefined
  */
-function parseJSON(input, _parentContext) {
+export function parseJSON(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
             .map((data) => JSON.parse(data));
     }
     return JSON.parse(input);
 }
-exports.parseJSON = parseJSON;
 /**
  * Converts input to JSON
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -935,10 +883,10 @@ exports.parseJSON = parseJSON;
  * @param {*} [{ pretty = false }={}] setting pretty to true will format the json output
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
-function toJSON(input, _parentContext, { pretty = false } = {}) {
+export function toJSON(input, _parentContext, { pretty = false } = {}) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
             .map((data) => {
@@ -951,7 +899,6 @@ function toJSON(input, _parentContext, { pretty = false } = {}) {
         return JSON.stringify(input, null, 2);
     return JSON.stringify(input);
 }
-exports.toJSON = toJSON;
 /**
  * Converts the value into a geo-point
  * if given an array it will convert everything in the array excluding null/undefined values
@@ -970,18 +917,17 @@ exports.toJSON = toJSON;
  * @returns {{ lat: number, lon: number } | { lat: number, lon: number }[] | null }
  * returns null if input is null/undefined
  */
-function toGeoPoint(input, _parentContext) {
+export function toGeoPoint(input, _parentContext) {
     if (ts.isNil(input))
         return null;
     // a tuple of numbers is a form of geo-point, do not map it
-    if ((0, field_validator_1.isArray)(input) && !(0, field_validator_1.isNumberTuple)(input)) {
+    if (isArray(input) && !isNumberTuple(input)) {
         return input
             .filter(ts.isNotNil)
             .map((data) => ts.parseGeoPoint(data, true));
     }
     return ts.parseGeoPoint(input, true);
 }
-exports.toGeoPoint = toGeoPoint;
 /**
  * Can extract values from a string input. You may either specify a regex, a jexl expression, or
  * specify the start and end from which the extraction will take all values between
@@ -1019,8 +965,7 @@ exports.toGeoPoint = toGeoPoint;
  * results; // ['hello', 'world'];
  */
 // this will be overritten by extract in jexl folder
-function extract(_input, _parentContext, _args) { }
-exports.extract = extract;
+export function extract(_input, _parentContext, _args) { }
 /**
  * This function replaces chars in a string based off the regex value provided
  *
@@ -1046,7 +991,7 @@ exports.extract = extract;
  * }
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
-function replaceRegex(input, _parentContext, { regex, replace, ignoreCase, global }) {
+export function replaceRegex(input, _parentContext, { regex, replace, ignoreCase, global }) {
     if (ts.isNil(input))
         return null;
     let options = '';
@@ -1054,20 +999,19 @@ function replaceRegex(input, _parentContext, { regex, replace, ignoreCase, globa
         options += 'i';
     if (global)
         options += 'g';
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input.filter(ts.isNotNil).map((data) => {
-            if (!(0, field_validator_1.isString)(data))
+            if (!isString(data))
                 throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
             const re = new RegExp(regex, options);
             return data.replace(re, replace);
         });
     }
-    if (!(0, field_validator_1.isString)(input))
+    if (!isString(input))
         throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
     const re = new RegExp(regex, options);
     return input.replace(re, replace);
 }
-exports.replaceRegex = replaceRegex;
 /**
  * This function replaces the searched value with the replace value
  *
@@ -1086,17 +1030,17 @@ exports.replaceRegex = replaceRegex;
  * search is the word that is to be changed to the value specified with the paramter replace
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
-function replaceLiteral(input, _parentContext, { search, replace }) {
+export function replaceLiteral(input, _parentContext, { search, replace }) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input.filter(ts.isNotNil).map((data) => {
-            if (!(0, field_validator_1.isString)(data))
+            if (!isString(data))
                 throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(data)}`);
             return data.replace(search, replace);
         });
     }
-    if (!(0, field_validator_1.isString)(input))
+    if (!isString(input))
         throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
     try {
         return input.replace(search, replace);
@@ -1105,7 +1049,6 @@ function replaceLiteral(input, _parentContext, { search, replace }) {
         throw new Error(`Could not replace ${search} with ${replace}`);
     }
 }
-exports.replaceLiteral = replaceLiteral;
 /**
  * Converts a string to an array of characters split by the delimiter provided
  *
@@ -1121,11 +1064,11 @@ exports.replaceLiteral = replaceLiteral;
  * @param {{ delimiter: string }} [args] delimter defaults to an empty string
  * @returns {(string[] | null)}
  */
-function splitString(input, _parentContext, args) {
+export function splitString(input, _parentContext, args) {
     if (ts.isNil(input))
         return null;
     const delimiter = args ? args.delimiter : '';
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input.filter(ts.isNotNil).map((data) => {
             if (!ts.isString(data)) {
                 throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(data)}`);
@@ -1138,7 +1081,6 @@ function splitString(input, _parentContext, args) {
     }
     throw new Error(`Input must be a string or an array, got ${ts.getTypeOf(input)}`);
 }
-exports.splitString = splitString;
 function _makeUnitTime(input, { ms = false } = {}) {
     let time;
     if (ms) {
@@ -1167,25 +1109,24 @@ function _makeUnitTime(input, { ms = false } = {}) {
  * @param {*} [{ ms = false }={}] set ms to true if you want time in milliseconds
  * @returns { number | number[] | null} returns null if input is null/undefined
  */
-function toUnixTime(input, _parentContext, { ms = false } = {}) {
+export function toUnixTime(input, _parentContext, { ms = false } = {}) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input.filter(ts.isNotNil).map((data) => {
-            if (!(0, field_validator_1.isValidDate)(data)) {
+            if (!isValidDate(data)) {
                 throw new Error(`Not a valid date, cannot transform ${data} to unix time`);
             }
             return _makeUnitTime(data, { ms });
         });
     }
-    if (!(0, field_validator_1.isValidDate)(input))
+    if (!isValidDate(input))
         throw new Error(`Not a valid date, cannot transform ${input} to unix time`);
     return _makeUnitTime(input, { ms });
 }
-exports.toUnixTime = toUnixTime;
 function _makeIso(input, args) {
     let value = input;
-    if ((0, field_validator_1.isNumber)(input) && args && args.resolution)
+    if (isNumber(input) && args && args.resolution)
         value *= 1000;
     return new Date(value).toISOString();
 }
@@ -1207,38 +1148,37 @@ function _makeIso(input, args) {
  * if input is a number, you may specify the resolution of that number, defaults to seconds
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
-function toISO8601(input, _parentContext, args) {
+export function toISO8601(input, _parentContext, args) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
             .map((data) => {
-            if (!(0, field_validator_1.isValidDate)(data)) {
+            if (!isValidDate(data)) {
                 throw new Error(`Input is not valid date, received ${data}`);
             }
             return _makeIso(data, args);
         });
     }
-    if (!(0, field_validator_1.isValidDate)(input)) {
+    if (!isValidDate(input)) {
         throw new Error(`Input is not valid date, received ${input}`);
     }
     return _makeIso(input, args);
 }
-exports.toISO8601 = toISO8601;
 function _formatDate(input, args) {
-    if (!(0, field_validator_1.isValidDate)(input)) {
+    if (!isValidDate(input)) {
         throw new Error('Input is not valid date');
     }
     let value = input;
     const { format, resolution } = args;
-    if (!(0, field_validator_1.isString)(format))
+    if (!isString(format))
         throw new Error(`Invalid parameter format, must be a string, received ${ts.getTypeOf(input)}`);
-    if ((0, field_validator_1.isString)(value))
+    if (isString(value))
         value = new Date(value);
-    if ((0, field_validator_1.isNumber)(value) && resolution === 'seconds')
+    if (isNumber(value) && resolution === 'seconds')
         value *= 1000;
-    return (0, date_fns_1.format)(value, format);
+    return dateFormat(value, format);
 }
 /**
  * Function that will format a number or date string to a given date format provided
@@ -1265,25 +1205,24 @@ function _formatDate(input, args) {
  * format is the shape that the date will be, resolution is only needed when input is a number
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
-function formatDate(input, _parentContext, args) {
+export function formatDate(input, _parentContext, args) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
             .map((data) => _formatDate(data, args));
     }
     return _formatDate(input, args);
 }
-exports.formatDate = formatDate;
 function _parseDate(input, args) {
     if (ts.isNil(input))
         return null;
     const { format } = args;
-    if (!(0, field_validator_1.isString)(format)) {
+    if (!isString(format)) {
         throw new Error(`Invalid parameter format, must be a string, received ${ts.getTypeOf(input)}`);
     }
-    const parsed = (0, date_fns_1.parse)(input, format, new Date());
+    const parsed = parse(input, format, new Date());
     if (!ts.isValidDateInstance(parsed)) {
         throw new Error('Cannot parse date');
     }
@@ -1313,17 +1252,16 @@ function _parseDate(input, args) {
  * @param { format: string } args
  * @returns { Date | Date[] | null } returns null if input is null/undefined
  */
-function parseDate(input, _parentContext, args) {
+export function parseDate(input, _parentContext, args) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input)) {
+    if (isArray(input)) {
         return input
             .filter(ts.isNotNil)
             .map((data) => _parseDate(data, args));
     }
     return _parseDate(input, args);
 }
-exports.parseDate = parseDate;
 /**
  * Will convert a string, or an array of strings to camel case;
  *
@@ -1338,14 +1276,13 @@ exports.parseDate = parseDate;
  * @param {string | string[]} input
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
-function toCamelCase(input, _parentContext) {
+export function toCamelCase(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input))
+    if (isArray(input))
         return input.filter(ts.isNotNil).map(ts.toCamelCase);
     return ts.toCamelCase(input);
 }
-exports.toCamelCase = toCamelCase;
 /**
  * Will convert a string, or an array of strings to kebab case
  * @example
@@ -1361,14 +1298,13 @@ exports.toCamelCase = toCamelCase;
  * @param {string | string[]} input
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
-function toKebabCase(input, _parentContext) {
+export function toKebabCase(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input))
+    if (isArray(input))
         return input.filter(ts.isNotNil).map(ts.toKebabCase);
     return ts.toKebabCase(input);
 }
-exports.toKebabCase = toKebabCase;
 /**
  * Converts a string, or an array of strings to pascal case
  *
@@ -1383,14 +1319,13 @@ exports.toKebabCase = toKebabCase;
  * @param {string | string[]} input
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
-function toPascalCase(input, _parentContext) {
+export function toPascalCase(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input))
+    if (isArray(input))
         return input.filter(ts.isNotNil).map(ts.toPascalCase);
     return ts.toPascalCase(input);
 }
-exports.toPascalCase = toPascalCase;
 /**
  * Converts a string, or an array of strings to snake case
  * @example
@@ -1404,14 +1339,13 @@ exports.toPascalCase = toPascalCase;
  * @param {string | string[]} input
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
-function toSnakeCase(input, _parentContext) {
+export function toSnakeCase(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input))
+    if (isArray(input))
         return input.filter(ts.isNotNil).map(ts.toSnakeCase);
     return ts.toSnakeCase(input);
 }
-exports.toSnakeCase = toSnakeCase;
 /**
  * Converts a string, or an array of strings to title case
  * @example
@@ -1422,12 +1356,11 @@ exports.toSnakeCase = toSnakeCase;
  * @param {string | string[]} input
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
-function toTitleCase(input, _parentContext) {
+export function toTitleCase(input, _parentContext) {
     if (ts.isNil(input))
         return null;
-    if ((0, field_validator_1.isArray)(input))
+    if (isArray(input))
         return input.filter(ts.isNotNil).map(ts.toTitleCase);
     return ts.toTitleCase(input);
 }
-exports.toTitleCase = toTitleCase;
 //# sourceMappingURL=field-transform.js.map