@terascope/data-mate 2.0.0-dev.5 → 2.0.0-dev.7

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

@@ -1,4 +1,5 @@
-import * as ts from '@terascope/utils';
+import { isNil, isNotNil, getTypeOf, getTime, getUnixTime, isValidDateInstance, toString as utilsToString, toBoolean as utilsToBoolean, trim as utilsTrim, trimEnd as utilsTrimEnd, isBooleanLike as utilsIsBooleanLike, trimStart as utilsTrimStart, toCamelCase as utilsCamelCase, toKebabCase as utilsKebabCase, toPascalCase as utilsPascalCase, toSnakeCase as utilsSnakeCase, toTitleCase as utilsTitleCase, toNumber as utilsToNumber } from '@terascope/core-utils';
+import { parseGeoPoint } from '@terascope/geo-utils';
 import { FieldType } from '@terascope/types';
 import crypto from 'node:crypto';
 import { parsePhoneNumber as _parsePhoneNumber } from 'awesome-phonenumber';
@@ -308,8 +309,8 @@ export const repository = {
  * @returns {*}
  */
 export function setDefault(input, _parentContext, args) {
-    if (ts.isNil(input)) {
-        if (ts.isNil(args.value))
+    if (isNil(input)) {
+        if (isNil(args.value))
             throw new Error('Parameter value cannot be set to undefined or null');
         return args.value;
     }
@@ -330,10 +331,10 @@ export function setDefault(input, _parentContext, args) {
  * @returns {any[] | null} returns the mapped values, return null if input is null/undefined
  */
 export function map(input, parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (!isArray(input))
-        throw new Error(`Input must be an array, received ${ts.getTypeOf(input)}`);
+        throw new Error(`Input must be an array, received ${getTypeOf(input)}`);
     const { fn, options } = args;
     const repoConfig = repository[fn];
     if (!repoConfig)
@@ -366,11 +367,11 @@ export function setField(_input, _parentContext, args) {
  * @returns {String | null} returns null if input is null/undefined
  */
 export function toString(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input))
-        return input.filter(ts.isNotNil).map(ts.toString);
-    return ts.toString(input);
+        return input.filter(isNotNil).map(utilsToString);
+    return utilsToString(input);
 }
 /**
  * Converts values to booleans
@@ -385,11 +386,11 @@ export function toString(input, _parentContext) {
  * @returns {Boolean | null} returns null if input is null/undefined
  */
 export function toBoolean(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input))
-        return input.filter(ts.isNotNil).map(ts.toBoolean);
-    return ts.toBoolean(input);
+        return input.filter(isNotNil).map(utilsToBoolean);
+    return utilsToBoolean(input);
 }
 /**
  * Converts strings to UpperCase
@@ -404,12 +405,12 @@ export function toBoolean(input, _parentContext) {
  * @returns { String | String[] | null } returns null if input is null/undefined
  */
 export function toUpperCase(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input))
-        return input.filter(ts.isNotNil).map((str) => str.toUpperCase());
+        return input.filter(isNotNil).map((str) => str.toUpperCase());
     if (!isString(input))
-        throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
+        throw new Error(`Input must be a string, or an array of string, received ${getTypeOf(input)}`);
     return input.toUpperCase();
 }
 /**
@@ -425,12 +426,12 @@ export function toUpperCase(input, _parentContext) {
  * @returns { String | String[] | null } returns null if input is null/undefined
  */
 export function toLowerCase(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input))
-        return input.filter(ts.isNotNil).map((str) => str.toLowerCase());
+        return input.filter(isNotNil).map((str) => str.toLowerCase());
     if (!isString(input))
-        throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
+        throw new Error(`Input must be a string, or an array of string, received ${getTypeOf(input)}`);
     return input.toLowerCase();
 }
 /**
@@ -453,15 +454,15 @@ export function toLowerCase(input, _parentContext) {
  * @returns { String | String[] | null } returns null if input is null/undefined
  */
 export function trim(input, parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     const char = (args?.char && isString(args.char)) ? args.char : ' ';
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
-            .map((str) => ts.trim(str, char));
+            .filter(isNotNil)
+            .map((str) => utilsTrim(str, char));
     }
-    return ts.trim(input, char);
+    return utilsTrim(input, char);
 }
 /**
  * Will trim the beginning of the input
@@ -479,18 +480,18 @@ export function trim(input, parentContext, args) {
  * @returns { String | String[] | null } returns null if input is null/undefined
  */
 export function trimStart(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (args?.char && !isString(args.char))
-        throw new Error(`Parameter char must be a string, received ${ts.getTypeOf(input)}`);
+        throw new Error(`Parameter char must be a string, received ${getTypeOf(input)}`);
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
-            .map((str) => ts.trimStart(str, args?.char));
+            .filter(isNotNil)
+            .map((str) => utilsTrimStart(str, args?.char));
     }
     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?.char);
+        throw new Error(`Input must be a string, or an array of string, received ${getTypeOf(input)}`);
+    return utilsTrimStart(input, args?.char);
 }
 /**
  * Will trim the end of the input
@@ -507,18 +508,18 @@ export function trimStart(input, _parentContext, args) {
  * @returns { String | String[] | null } returns null if input is null/undefined
  */
 export function trimEnd(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (args?.char && !isString(args.char))
-        throw new Error(`Parameter char must be a string, received ${ts.getTypeOf(input)}`);
+        throw new Error(`Parameter char must be a string, received ${getTypeOf(input)}`);
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
-            .map((str) => ts.trimEnd(str, args?.char));
+            .filter(isNotNil)
+            .map((str) => utilsTrimEnd(str, args?.char));
     }
     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?.char);
+        throw new Error(`Input must be a string, or an array of string, received ${getTypeOf(input)}`);
+    return utilsTrimEnd(input, args?.char);
 }
 /**
  * Will truncate the input to the length of the size given
@@ -535,21 +536,21 @@ export function trimEnd(input, _parentContext, args) {
  */
 export function truncate(input, _parentContext, args) {
     const { size } = args;
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
-    if (!size || !ts.isNumber(size) || size <= 0)
+    if (!size || !isNumber(size) || size <= 0)
         throw new Error('Invalid size paramter for truncate');
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((str) => str.slice(0, size));
     }
     if (!isString(input))
-        throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
+        throw new Error(`Input must be a string, or an array of string, received ${getTypeOf(input)}`);
     return input.slice(0, size);
 }
 function parsePhoneNumber(str) {
-    let testNumber = ts.toString(str).trim();
+    let testNumber = utilsToString(str).trim();
     if (testNumber.charAt(0) === '0')
         testNumber = testNumber.slice(1);
     // needs to start with a +
@@ -575,20 +576,20 @@ function parsePhoneNumber(str) {
  * returns null if input is null/undefined
  */
 export function toISDN(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input))
-        return input.filter(ts.isNotNil).map(parsePhoneNumber);
+        return input.filter(isNotNil).map(parsePhoneNumber);
     return parsePhoneNumber(input);
 }
 function convertToNumber(input, args) {
     let result = input;
-    if (args?.booleanLike === true && ts.isBooleanLike(input)) {
-        result = ts.toNumber(toBoolean(result));
+    if (args?.booleanLike === true && utilsIsBooleanLike(input)) {
+        result = utilsToNumber(toBoolean(result));
     }
-    result = ts.toNumber(result);
+    result = utilsToNumber(result);
     if (Number.isNaN(result))
-        throw new Error(`Could not convert input of type ${ts.getTypeOf(input)} to a number`);
+        throw new Error(`Could not convert input of type ${getTypeOf(input)} to a number`);
     return result;
 }
 /**
@@ -609,11 +610,11 @@ function convertToNumber(input, args) {
  * @returns { number | null } returns null if input is null/undefined
  */
 export function toNumber(input, _parentContext, args) {
-    if (ts.isNil(input) && args?.booleanLike !== true)
+    if (isNil(input) && args?.booleanLike !== true)
         return null;
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((data) => convertToNumber(data, args));
     }
     return convertToNumber(input, args);
@@ -636,11 +637,11 @@ export function toNumber(input, _parentContext, args) {
  * @returns { string | null } returns null if input is null/undefined
  */
 export function decodeBase64(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((data) => Buffer.from(data, 'base64').toString('utf8'));
     }
     return Buffer.from(input, 'base64').toString('utf8');
@@ -660,11 +661,11 @@ export function decodeBase64(input, _parentContext) {
  * @returns { string | null } returns null if input is null/undefined
  */
 export function encodeBase64(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((data) => Buffer.from(data).toString('base64'));
     }
     return Buffer.from(input).toString('base64');
@@ -685,12 +686,12 @@ export function encodeBase64(input, _parentContext) {
  * @returns { string | null } returns null if input is null/undefined
  */
 export function decodeURL(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input))
-        return input.filter(ts.isNotNil).map(decodeURIComponent);
+        return input.filter(isNotNil).map(decodeURIComponent);
     if (!isString(input))
-        throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
+        throw new Error(`Input must be a string, or an array of string, received ${getTypeOf(input)}`);
     return decodeURIComponent(input);
 }
 /**
@@ -709,12 +710,12 @@ export function decodeURL(input, _parentContext) {
  * @returns { string | null } returns null if input is null/undefined
  */
 export function encodeURL(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input))
-        return input.filter(ts.isNotNil).map(encodeURIComponent);
+        return input.filter(isNotNil).map(encodeURIComponent);
     if (!isString(input))
-        throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
+        throw new Error(`Input must be a string, or an array of string, received ${getTypeOf(input)}`);
     return encodeURIComponent(input);
 }
 /**
@@ -733,11 +734,11 @@ export function encodeURL(input, _parentContext) {
  * @returns { string | null } returns null if input is null/undefined
  */
 export function decodeHex(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((data) => Buffer.from(data, 'hex').toString('utf8'));
     }
     return Buffer.from(input, 'hex').toString('utf8');
@@ -757,11 +758,11 @@ export function decodeHex(input, _parentContext) {
  * @returns { string | null } returns null if input is null/undefined
  */
 export function encodeHex(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((data) => Buffer.from(data).toString('hex'));
     }
     return Buffer.from(input).toString('hex');
@@ -779,11 +780,11 @@ export function encodeHex(input, _parentContext) {
  * @returns { string | null } returns null if input is null/undefined
  */
 export function encodeMD5(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((data) => crypto.createHash('md5').update(data)
             .digest('hex'));
     }
@@ -808,14 +809,14 @@ export function encodeMD5(input, _parentContext) {
  * @returns { string | null } returns null if input is null/undefined
  */
 export function encodeSHA(input, _parentContext, { hash = 'sha256', digest = 'hex' } = {}) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (!['ascii', 'utf8', 'utf16le', 'ucs2', 'base64', 'latin1', 'hex', 'binary'].includes(digest)) {
         throw new Error('Parameter digest is misconfigured');
     }
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((data) => crypto.createHash(hash).update(data)
             .digest(digest));
     }
@@ -837,11 +838,11 @@ export function encodeSHA(input, _parentContext, { hash = 'sha256', digest = 'he
  * @returns { string | null } returns null if input is null/undefined
  */
 export function encodeSHA1(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((data) => crypto.createHash('sha1').update(data)
             .digest('hex'));
     }
@@ -865,11 +866,11 @@ export function encodeSHA1(input, _parentContext) {
  * @returns { any | null } returns null if input is null/undefined
  */
 export function parseJSON(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((data) => JSON.parse(data));
     }
     return JSON.parse(input);
@@ -890,11 +891,11 @@ export function parseJSON(input, _parentContext) {
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
 export function toJSON(input, _parentContext, { pretty = false } = {}) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((data) => {
             if (pretty)
                 return JSON.stringify(data, null, 2);
@@ -924,15 +925,15 @@ export function toJSON(input, _parentContext, { pretty = false } = {}) {
  * returns null if input is null/undefined
  */
 export function toGeoPoint(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     // a tuple of numbers is a form of geo-point, do not map it
     if (isArray(input) && !isNumberTuple(input)) {
         return input
-            .filter(ts.isNotNil)
-            .map((data) => ts.parseGeoPoint(data, true));
+            .filter(isNotNil)
+            .map((data) => parseGeoPoint(data, true));
     }
-    return ts.parseGeoPoint(input, true);
+    return parseGeoPoint(input, true);
 }
 /**
  * Can extract values from a string input. You may either specify a regex, a jexl expression, or
@@ -998,7 +999,7 @@ export function extract(_input, _parentContext, _args) { }
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
 export function replaceRegex(input, _parentContext, { regex, replace, ignoreCase, global }) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     let options = '';
     if (ignoreCase)
@@ -1006,15 +1007,15 @@ export function replaceRegex(input, _parentContext, { regex, replace, ignoreCase
     if (global)
         options += 'g';
     if (isArray(input)) {
-        return input.filter(ts.isNotNil).map((data) => {
+        return input.filter(isNotNil).map((data) => {
             if (!isString(data))
-                throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
+                throw new Error(`Input must be a string, or an array of string, received ${getTypeOf(input)}`);
             const re = new RegExp(regex, options);
             return data.replace(re, replace);
         });
     }
     if (!isString(input))
-        throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
+        throw new Error(`Input must be a string, or an array of string, received ${getTypeOf(input)}`);
     const re = new RegExp(regex, options);
     return input.replace(re, replace);
 }
@@ -1037,17 +1038,17 @@ export function replaceRegex(input, _parentContext, { regex, replace, ignoreCase
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
 export function replaceLiteral(input, _parentContext, { search, replace }) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input)) {
-        return input.filter(ts.isNotNil).map((data) => {
+        return input.filter(isNotNil).map((data) => {
             if (!isString(data))
-                throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(data)}`);
+                throw new Error(`Input must be a string, or an array of string, received ${getTypeOf(data)}`);
             return data.replace(search, replace);
         });
     }
     if (!isString(input))
-        throw new Error(`Input must be a string, or an array of string, received ${ts.getTypeOf(input)}`);
+        throw new Error(`Input must be a string, or an array of string, received ${getTypeOf(input)}`);
     try {
         return input.replace(search, replace);
     }
@@ -1071,29 +1072,29 @@ export function replaceLiteral(input, _parentContext, { search, replace }) {
  * @returns {(string[] | null)}
  */
 export function splitString(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     const delimiter = args ? args.delimiter : '';
     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)}`);
+        return input.filter(isNotNil).map((data) => {
+            if (!isString(data)) {
+                throw new Error(`Input must be a string, or an array of string, received ${getTypeOf(data)}`);
             }
             return data.split(delimiter);
         });
     }
-    if (ts.isString(input)) {
+    if (isString(input)) {
         return input.split(delimiter);
     }
-    throw new Error(`Input must be a string or an array, got ${ts.getTypeOf(input)}`);
+    throw new Error(`Input must be a string or an array, got ${getTypeOf(input)}`);
 }
 function _makeUnitTime(input, { ms = false } = {}) {
     let time;
     if (ms) {
-        time = ts.getTime(input);
+        time = getTime(input);
     }
     else {
-        time = ts.getUnixTime(input);
+        time = getUnixTime(input);
     }
     return time;
 }
@@ -1116,10 +1117,10 @@ function _makeUnitTime(input, { ms = false } = {}) {
  * @returns { number | number[] | null} returns null if input is null/undefined
  */
 export function toUnixTime(input, _parentContext, { ms = false } = {}) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input)) {
-        return input.filter(ts.isNotNil).map((data) => {
+        return input.filter(isNotNil).map((data) => {
             if (!isValidDate(data)) {
                 throw new Error(`Not a valid date, cannot transform ${data} to unix time`);
             }
@@ -1155,11 +1156,11 @@ function _makeIso(input, args) {
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
 export function toISO8601(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((data) => {
             if (!isValidDate(data)) {
                 throw new Error(`Input is not valid date, received ${data}`);
@@ -1179,7 +1180,7 @@ function _formatDate(input, args) {
     let value = input;
     const { format, resolution } = args;
     if (!isString(format))
-        throw new Error(`Invalid parameter format, must be a string, received ${ts.getTypeOf(input)}`);
+        throw new Error(`Invalid parameter format, must be a string, received ${getTypeOf(input)}`);
     if (isString(value))
         value = new Date(value);
     if (isNumber(value) && resolution === 'seconds')
@@ -1212,25 +1213,25 @@ function _formatDate(input, args) {
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
 export function formatDate(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((data) => _formatDate(data, args));
     }
     return _formatDate(input, args);
 }
 function _parseDate(input, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     const { format } = args;
     if (!isString(format)) {
-        throw new Error(`Invalid parameter format, must be a string, received ${ts.getTypeOf(input)}`);
+        throw new Error(`Invalid parameter format, must be a string, received ${getTypeOf(input)}`);
     }
     const inputStr = String(input);
     const parsed = parse(inputStr, format, new Date());
-    if (!ts.isValidDateInstance(parsed)) {
+    if (!isValidDateInstance(parsed)) {
         throw new Error('Cannot parse date');
     }
     return parsed;
@@ -1260,11 +1261,11 @@ function _parseDate(input, args) {
  * @returns { Date | Date[] | null } returns null if input is null/undefined
  */
 export function parseDate(input, _parentContext, args) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input)) {
         return input
-            .filter(ts.isNotNil)
+            .filter(isNotNil)
             .map((data) => _parseDate(data, args));
     }
     return _parseDate(input, args);
@@ -1284,11 +1285,11 @@ export function parseDate(input, _parentContext, args) {
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
 export function toCamelCase(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input))
-        return input.filter(ts.isNotNil).map(ts.toCamelCase);
-    return ts.toCamelCase(input);
+        return input.filter(isNotNil).map(utilsCamelCase);
+    return utilsCamelCase(input);
 }
 /**
  * Will convert a string, or an array of strings to kebab case
@@ -1306,11 +1307,11 @@ export function toCamelCase(input, _parentContext) {
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
 export function toKebabCase(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input))
-        return input.filter(ts.isNotNil).map(ts.toKebabCase);
-    return ts.toKebabCase(input);
+        return input.filter(isNotNil).map(utilsKebabCase);
+    return utilsKebabCase(input);
 }
 /**
  * Converts a string, or an array of strings to pascal case
@@ -1327,11 +1328,11 @@ export function toKebabCase(input, _parentContext) {
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
 export function toPascalCase(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input))
-        return input.filter(ts.isNotNil).map(ts.toPascalCase);
-    return ts.toPascalCase(input);
+        return input.filter(isNotNil).map(utilsPascalCase);
+    return utilsPascalCase(input);
 }
 /**
  * Converts a string, or an array of strings to snake case
@@ -1347,11 +1348,11 @@ export function toPascalCase(input, _parentContext) {
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
 export function toSnakeCase(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input))
-        return input.filter(ts.isNotNil).map(ts.toSnakeCase);
-    return ts.toSnakeCase(input);
+        return input.filter(isNotNil).map(utilsSnakeCase);
+    return utilsSnakeCase(input);
 }
 /**
  * Converts a string, or an array of strings to title case
@@ -1364,10 +1365,10 @@ export function toSnakeCase(input, _parentContext) {
  * @returns { string | string[] | null } returns null if input is null/undefined
  */
 export function toTitleCase(input, _parentContext) {
-    if (ts.isNil(input))
+    if (isNil(input))
         return null;
     if (isArray(input))
-        return input.filter(ts.isNotNil).map(ts.toTitleCase);
-    return ts.toTitleCase(input);
+        return input.filter(isNotNil).map(utilsTitleCase);
+    return utilsTitleCase(input);
 }
 //# sourceMappingURL=field-transform.js.map