@turndown/library 0.0.10 → 0.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turndown/library",
-  "version": "0.0.10",
+  "version": "0.0.16",
   "description": "Shared TypeScript library for the Turndown suite.",
   "keywords": [
     "types",
@@ -16,20 +16,22 @@
     "access": "public"
   },
   "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "source": "./index.ts",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "src",
+    "dist"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "browser": "./dist/index.js",
+      "import": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist",
-    "LICENSE",
-    "README.md"
-  ],
   "scripts": {
     "clean": "rimraf dist",
     "build": "npm run clean && tsc -p .",

package/src/helpers/object/index.ts

@@ -0,0 +1,395 @@
+import { FilterCondition, SortCondition, TurndownObject } from "@/types/base";
+
+export interface Version {
+  major: number;
+  minor: number;
+  patch: number;
+}
+
+export type VersionInput = string | Version;
+
+/**
+ * Safely parse a JSON string into a value.
+ *
+ * Returns `{}` if parsing fails instead of throwing.
+ *
+ * @param {TurndownObject} jsonString - The JSON string to parse.
+ * @returns {TurndownObject} Parsed value or `{}` on failure.
+ * @example
+ * parseJSON('{"a":1}') // => { a: 1 }
+ * parseJSON('not json') // => {}
+ */
+export const parseJSON = (jsonString: TurndownObject): TurndownObject => {
+  try {
+    return JSON.parse(jsonString);
+  } catch (error) {
+    return {};
+  }
+};
+
+/**
+ * Stringify an object to JSON while skipping circular references.
+ *
+ * Uses an internal cache to omit repeated object references that would
+ * normally cause `JSON.stringify` to throw.
+ *
+ * @param {TurndownObject} obj - Value to stringify.
+ * @returns {string} JSON string with circulars omitted.
+ * @example
+ * const a:any = {}; a.self = a;
+ * JSONStringify(a) // => "{}"
+ */
+export const JSONStringify = (obj: TurndownObject): string => {
+  let cache: TurndownObject = [];
+  let str = JSON.stringify(obj, function (_key, value) {
+    if (typeof value === "object" && value !== null) {
+      if (cache.indexOf(value) !== -1) {
+        return;
+      }
+      cache.push(value);
+    }
+    return value;
+  });
+  cache = null;
+  return str;
+};
+
+/**
+ * Deep-remove `undefined` properties by serializing & parsing.
+ *
+ * @param {TurndownObject} obj - Input object.
+ * @returns {TurndownObject} Cleaned clone with `undefined` removed.
+ */
+export const removeUndefined = (obj: TurndownObject): TurndownObject => {
+  return JSON.parse(JSONStringify(obj));
+};
+
+/**
+ * Test whether a location object's `pathname` equals a key.
+ *
+ * @param {TurndownObject} location - Object expected to have a `pathname`.
+ * @param {string} key - Path to compare.
+ * @returns {boolean}
+ * @example
+ * validPath({ pathname: "/home" }, "/home") // true
+ */
+export const validPath = (location: TurndownObject, key: string): boolean => {
+  return location?.pathname === key;
+};
+
+/**
+ * Return the first element if the input is an array; otherwise return the value itself.
+ *
+ * @typeParam T - Element type.
+ * @param {T | T[]} input - A single value or an array.
+ * @returns {T} First element or the input value.
+ * @example
+ * returnObject([1,2,3]) // 1
+ * returnObject(5) // 5
+ */
+export const returnObject = <T>(input: T | T[]): T => {
+  return Array.isArray(input) ? input[0] : input;
+};
+
+/**
+ * Filter out items from `array1` whose `id` appears in `array2`.
+ *
+ * @typeParam T - Object type with an `id` field.
+ * @param {T[]} [array1] - Source array.
+ * @param {T[]} [array2] - Items whose `id`s should be excluded.
+ * @returns {T[]} Filtered array (or `[]` on errors/invalid input).
+ */
+export const filterArrayById = <T extends { id: number | string }>(
+  array1?: T[],
+  array2?: T[]
+): T[] => {
+  try {
+    if (!array1 || !array2) return [];
+
+    const idsToExclude = new Set(array2.map((item) => item.id));
+    return array1.filter((item) => !idsToExclude.has(item.id));
+  } catch (error) {
+    console.error("An error occurred:", error);
+    return [];
+  }
+};
+
+/**
+ * Sort an array of objects by a given property (ascending).
+ *
+ * Mutates the original array (uses `Array.prototype.sort`).
+ *
+ * @typeParam T - Object type.
+ * @param {T[]} array - Array to sort.
+ * @param {keyof T} property - Property name to sort by.
+ * @returns {T[]} The same array instance, sorted (or empty array if input invalid).
+ */
+export const sortArrayByProperty = <T extends Record<string, any>>(
+  array: T[],
+  property: keyof T
+): T[] => {
+  if (!array || array.length === 0) return [];
+
+  return array.sort((a, b) => {
+    if (a[property] < b[property]) return -1;
+    if (a[property] > b[property]) return 1;
+    return 0;
+  });
+};
+
+/**
+ * Recursively replace `null` values with empty strings.
+ *
+ * Works on primitives, arrays, and plain objects.
+ *
+ * @param {TurndownObject} obj - Input value.
+ * @returns {TurndownObject} Value with all `null` replaced by `""`.
+ */
+export const replaceNulls = (obj: TurndownObject): TurndownObject => {
+  if (obj === null) {
+    return "";
+  } else if (Array.isArray(obj)) {
+    return obj.map(replaceNulls);
+  } else if (typeof obj === "object" && obj !== null) {
+    const newObj: any = {};
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        newObj[key] = replaceNulls(obj[key]);
+      }
+    }
+    return newObj;
+  }
+  return obj;
+};
+
+/**
+ * Recursively remove object keys that contain a dot (`.`).
+ *
+ * @typeParam T - Object type.
+ * @param {T} obj - Input object.
+ * @returns {T} New object with dotted keys removed at all levels.
+ */
+export const removeFormProperties = <T extends Record<string, TurndownObject>>(
+  obj: T
+): T => {
+  const recursiveRemove = (input: TurndownObject): TurndownObject => {
+    if (Array.isArray(input)) {
+      return input.map((item) => recursiveRemove(item));
+    } else if (typeof input === "object" && input !== null) {
+      const newObj: Record<string, TurndownObject> = { ...input };
+
+      Object.keys(newObj).forEach((key) => {
+        if (key.includes(".")) {
+          delete newObj[key];
+        } else {
+          newObj[key] = recursiveRemove(newObj[key]);
+        }
+      });
+      return newObj;
+    }
+    return input;
+  };
+
+  return recursiveRemove(obj);
+};
+
+/**
+ * Recursively convert string booleans `"true"`/`"false"` to actual booleans.
+ *
+ * Leaves all other values unchanged.
+ *
+ * @typeParam T - Object type.
+ * @param {T} obj - Input object or array.
+ * @returns {T} New value with boolean-like strings converted.
+ */
+export const convertStringBooleans = <T extends Record<string, any>>(
+  obj: T
+): T => {
+  const recursiveConvert = (input: any): any => {
+    if (Array.isArray(input)) {
+      return input.map((item) => recursiveConvert(item));
+    } else if (typeof input === "object" && input !== null) {
+      const newObj: Record<string, any> = { ...input };
+
+      Object.keys(newObj).forEach((key) => {
+        const value = newObj[key];
+
+        if (value === "true") {
+          newObj[key] = true;
+        } else if (value === "false") {
+          newObj[key] = false;
+        } else if (typeof value === "object" && value !== null) {
+          newObj[key] = recursiveConvert(value);
+        }
+      });
+
+      return newObj;
+    }
+
+    return input;
+  };
+
+  return recursiveConvert(obj);
+};
+
+/**
+ * Convenience helper to clean form-like data:
+ * - Removes `undefined` properties
+ * - Converts string booleans to booleans
+ * - Removes keys containing a dot ('.')
+ *
+ * @param {TurndownObject} obj - Input data.
+ * @returns {TurndownObject} Cleaned clone.
+ */
+export const cleanFormData = (obj: TurndownObject) => {
+  return removeFormProperties(convertStringBooleans(removeUndefined(obj)));
+};
+
+/**
+ * Return a default pagination object, allowing optional sort and filters.
+ *
+ * @param {SortCondition[]} [sort] - Optional sort conditions.
+ * @param {FilterCondition[]} [filters] - Optional filter conditions.
+ * @returns {{ page: number; size: number; sort: SortCondition[]; filters: FilterCondition[] }}
+ * @example
+ * resetPagination() // => { page:1, size:25, sort:[], filters:[] }
+ */
+export const resetPagination = (
+  sort?: SortCondition[],
+  filters?: FilterCondition[]
+) => {
+  return {
+    page: 1,
+    size: 25,
+    sort: sort || [],
+    filters: filters || [],
+  };
+};
+
+/**
+ * Format a string of digits into a U.S. phone number.
+ *
+ * Strips non-numeric characters and formats as `(XXX) XXX-XXXX`.
+ * If fewer than 10 digits are provided, returns the input unchanged.
+ *
+ * @param {string | number} value - Phone number digits (string or number).
+ * @returns {string} Formatted phone number, or original input if invalid length.
+ * @example
+ * formatPhoneNumber("1234567890") // "(123) 456-7890"
+ * formatPhoneNumber(9876543210)   // "(987) 654-3210"
+ * formatPhoneNumber("555")        // "555"
+ */
+export const formatPhoneNumber = (value: string | number): string => {
+  const digits = value.toString().replace(/\D/g, "");
+  if (digits.length !== 10) return value.toString();
+
+  const area = digits.slice(0, 3);
+  const prefix = digits.slice(3, 6);
+  const line = digits.slice(6);
+
+  return `(${area}) ${prefix}-${line}`;
+};
+
+/**
+ * Format a number with thousands separators (commas).
+ *
+ * @param {number} value - Number to format.
+ * @returns {string} String with commas.
+ * @example
+ * formatNumber(1234567) // "1,234,567"
+ */
+export const formatNumber = (value: number): string => {
+  return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+};
+
+/**
+ * Parse a number string (note: current implementation adds commas as well).
+ *
+ * @remarks
+ * This function uses the same regex as `formatNumber`, so it **does not remove**
+ * commas; it inserts them. If you intended to *strip* separators, consider:
+ * `value.toString().replace(/,/g, "")`.
+ *
+ * @param {number} value - Number to "parse".
+ * @returns {string} Currently returns a comma-formatted string.
+ */
+export const parseNumber = (value: number): string => {
+  return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, "");
+};
+
+/**
+ * Delete a property from an object if it exists (no-op if it doesn't).
+ *
+ * @param {TurndownObject} obj - Target object (mutated).
+ * @param {string} propertyName - Property to delete.
+ * @returns {void}
+ */
+export const deletePropertyIfExists = (
+  obj: TurndownObject,
+  propertyName: string
+) => {
+  if (Object.prototype.hasOwnProperty.call(obj, propertyName)) {
+    delete obj[propertyName];
+  }
+};
+
+/**
+ * Split an array into chunks of a given size.
+ *
+ * @typeParam T - Element type.
+ * @param {T[]} array - Source array.
+ * @param {number} chunkSize - Size of each chunk (no validation performed).
+ * @returns {T[][]} Array of chunks (last one may be smaller).
+ * @example
+ * chunkArray([1,2,3,4,5], 2) // [[1,2],[3,4],[5]]
+ */
+export const chunkArray = <T>(array: T[], chunkSize: number): T[][] => {
+  const result: T[][] = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+};
+
+/**
+ * Return a shallow clone of `obj` without the listed properties.
+ *
+ * @param {TurndownObject} obj - Source object.
+ * @param {TurndownObject} propsToOmit - Iterable of property names (expects array-like).
+ * @returns {TurndownObject} New object without omitted props.
+ * @example
+ * omitProperties({a:1,b:2}, ["b"]) // { a:1 }
+ */
+export const omitProperties = (
+  obj: TurndownObject,
+  propsToOmit: TurndownObject
+) => {
+  const newObj = { ...obj };
+  propsToOmit.forEach((prop: TurndownObject) => {
+    delete newObj[prop];
+  });
+
+  return newObj;
+};
+
+/**
+ * Safe `hasOwnProperty` check.
+ *
+ * @param {Record<string, any>} obj - Object to test.
+ * @param {string} key - Property name.
+ * @returns {boolean}
+ */
+export const hasProperty = (obj: Record<string, any>, key: string): boolean => {
+  if (!obj) return false;
+  return Object.prototype.hasOwnProperty.call(obj, key);
+};
+
+/**
+ * Determine if an object has at least one own enumerable property.
+ *
+ * @param {object} obj - Object to test.
+ * @returns {boolean} `true` if there is at least one key.
+ */
+export const hasProperties = (obj: object): boolean => {
+  return Object.keys(obj || {}).length > 0;
+};

package/src/helpers/string/index.ts

@@ -0,0 +1,171 @@
+import { TurndownObject } from "@/types/base";
+
+/**
+ * Convert a string to "Normal Case":
+ * - Inserts spaces between camel/pascal case boundaries
+ * - Capitalizes the first letter of each word, lowercases the rest
+ *
+ * @param {TurndownObject} [str] Input value (falsy returns an empty string)
+ * @returns {string}
+ * @example
+ * normalCase("helloWorld") // "Hello World"
+ * normalCase("XMLHttpRequest") // "Xml Http Request"
+ */
+export const normalCase = (str?: TurndownObject): string => {
+  if (!str) return "";
+
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1 $2")
+    .replace(/([A-Z])([A-Z][a-z])/g, "$1 $2")
+    .split(/\s+/)
+    .map(
+      (word: string) =>
+        word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+    )
+    .join(" ");
+};
+
+/**
+ * Capitalize only the first character; lowercases the rest.
+ * Trims leading/trailing spaces before processing.
+ *
+ * @param {TurndownObject} [str] Input value (falsy returns an empty string)
+ * @returns {string}
+ * @example
+ * sentenceCase("hELLO WORLD") // "Hello world"
+ */
+export const sentenceCase = (str?: TurndownObject): string => {
+  if (!str) return "";
+
+  const s = str.trim();
+  return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
+};
+
+/**
+ * Uppercase the entire string.
+ *
+ * @param {TurndownObject} [str] Input value (falsy returns an empty string)
+ * @returns {string}
+ * @example
+ * upperCase("Hello world") // "HELLO WORLD"
+ */
+export const upperCase = (str?: TurndownObject): string => {
+  return str ? str.toUpperCase() : "";
+};
+
+/**
+ * Lowercase the entire string.
+ *
+ * @param {TurndownObject} [str] Input value (falsy returns an empty string)
+ * @returns {string}
+ * @example
+ * lowerCase("Hello WORLD") // "hello world"
+ */
+export const lowerCase = (str?: TurndownObject): string => {
+  return str ? str.toLowerCase() : "";
+};
+
+/**
+ * Convert to camelCase.
+ * Splits on spaces, underscores, and hyphens; lowercases the first word,
+ * TitleCases the rest, then joins with no separators.
+ *
+ * @param {TurndownObject} [str] Input value (falsy returns an empty string)
+ * @returns {string}
+ * @example
+ * camelCase("Hello world") // "helloWorld"
+ * camelCase("hello_world-again") // "helloWorldAgain"
+ */
+export const camelCase = (str?: TurndownObject): string => {
+  if (!str) return "";
+  return str
+    .toLowerCase()
+    .split(/[\s_-]+/)
+    .map((word: string, i: number) =>
+      i === 0
+        ? word
+        : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+    )
+    .join("");
+};
+
+/**
+ * Convert to PascalCase.
+ * Splits on spaces, underscores, and hyphens; TitleCases all words and joins them.
+ *
+ * @param {TurndownObject} [str] Input value (falsy returns an empty string)
+ * @returns {string}
+ * @example
+ * pascalCase("hello world") // "HelloWorld"
+ * pascalCase("hello_world-again") // "HelloWorldAgain"
+ */
+export const pascalCase = (str?: TurndownObject): string => {
+  if (!str) return "";
+  return str
+    .toLowerCase()
+    .split(/[\s_-]+/)
+    .map((word: string) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join("");
+};
+
+/**
+ * Convert to kebab-case.
+ * Inserts hyphens between camelCase boundaries, then replaces spaces/underscores with hyphens.
+ *
+ * @param {TurndownObject} [str] Input value (falsy returns an empty string)
+ * @returns {string}
+ * @example
+ * kebabCase("HelloWorld Again") // "hello-world-again"
+ * kebabCase("hello_world") // "hello-world"
+ */
+export const kebabCase = (str?: TurndownObject): string => {
+  if (!str) return "";
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1-$2")
+    .replace(/[\s_]+/g, "-")
+    .toLowerCase();
+};
+
+/**
+ * Convert to snake_case.
+ * Inserts underscores between camelCase boundaries, then replaces spaces/hyphens with underscores.
+ *
+ * @param {TurndownObject} [str] Input value (falsy returns an empty string)
+ * @returns {string}
+ * @example
+ * snakeCase("HelloWorld Again") // "hello_world_again"
+ * snakeCase("hello-world") // "hello_world"
+ */
+export const snakeCase = (str?: TurndownObject): string => {
+  if (!str) return "";
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1_$2")
+    .replace(/[\s-]+/g, "_")
+    .toLowerCase();
+};
+
+/**
+ * Convert snake_case to space-delimited words.
+ *
+ * @param {TurndownObject} [str] Input value (falsy returns an empty string)
+ * @returns {string}
+ * @example
+ * snakeCaseToSpaces("hello_world_again") // "hello world again"
+ */
+export const snakeCaseToSpaces = (str?: TurndownObject): string => {
+  if (!str) return "";
+  return str.split("_").join(" ");
+};
+
+/**
+ * Convert kebab-case to space-delimited words.
+ *
+ * @param {TurndownObject} [str] Input value (falsy returns an empty string)
+ * @returns {string}
+ * @example
+ * kebabToSpaces("hello-world-again") // "hello world again"
+ */
+export const kebabToSpaces = (str?: TurndownObject): string => {
+  if (!str) return "";
+  return str.split("-").join(" ");
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./helpers";
+export * from "./types";

package/src/types/base/index.ts

@@ -0,0 +1,26 @@
+export type GenericTurndownObject = Record<string, any> | any | undefined;
+export type TurndownObject<T = GenericTurndownObject> =
+  | Record<string, T>
+  | T
+  | undefined;
+
+export type ObjectValues<T> = T[keyof T];
+export type ObjectKeys<T> = [keyof T];
+
+export interface MetaData {
+  company_id: string;
+  deleted: boolean;
+  updated_by: string;
+  created_by: string;
+  created_at: Date;
+  updated_at: Date;
+}
+
+export const STATUS = {
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE",
+} as const;
+
+export type Status = ObjectValues<typeof STATUS>;
+
+export * from "./paging.types";

package/src/types/base/paging.types.ts

@@ -0,0 +1,35 @@
+export interface PagingResult {
+  hasNextPage: boolean;
+  totalPages: number;
+  totalRecords: number;
+}
+export interface DataWithPagingResult<T> {
+  data: T;
+  pagination: PagingResult;
+}
+export interface SortCondition {
+  name: string;
+  direction: "ASC" | "DESC";
+}
+export interface FilterCondition {
+  name: string;
+  condition: "=" | ">" | "<" | "!=" | "LIKE" | "IN" | ">=" | "<=";
+  valueString?: string;
+  valueNumber?: number;
+  valueBoolean?: boolean;
+  useAnd?: boolean;
+}
+export interface PaginationRequest {
+  page: number;
+  size: number;
+  sort?: SortCondition[];
+  filters?: FilterCondition[];
+}
+export declare const createPagingObject: (
+  page: number,
+  size: number,
+  sort?: SortCondition[],
+  filters?: FilterCondition[]
+) => {
+  pagination: any;
+};

package/src/types/user/index.ts

@@ -0,0 +1,42 @@
+import { MetaData, ObjectValues, Status } from "@/types";
+
+export interface User extends Omit<MetaData, "created_by" | "updated_by"> {
+  id: string;
+  firstName: string;
+  lastName: string;
+  mi: string;
+  username: string;
+  email: string;
+  password: string;
+  loginAttempts: number;
+  locked: boolean;
+  passwordLastReset: Date;
+  passwordResetRequired: boolean;
+  type: AccountType;
+  status: Status;
+  companyId: number;
+  phoneNumber: string;
+  phoneFormat: string;
+  language: Language;
+  biometrics: string;
+  lastLogin: Date;
+}
+
+export const ACCOUNT_TYPE = {
+  TURNDOWN_ADMIN: "TURNDOWN_ADMIN",
+  OWNER: "OWNER",
+  ACCOUNT_ADMIN: "ACCOUNT_ADMIN",
+  MAINTAINER: "MAINTAINER",
+  CLEANER: "CLEANER",
+} as const;
+
+export type AccountType = ObjectValues<typeof ACCOUNT_TYPE>;
+
+export const LANGUAGE = {
+  ENGLISH: "ENGLISH",
+  FRENCH: "FRENCH",
+  SPANISH: "SPANISH",
+  GERMAN: "GERMAN",
+} as const;
+
+export type Language = ObjectValues<typeof LANGUAGE>;

package/dist/helpers/object/index.js

@@ -1,171 +0,0 @@
-export const parseJSON = (jsonString) => {
-    try {
-        return JSON.parse(jsonString);
-    }
-    catch (error) {
-        return {};
-    }
-};
-export const JSONStringify = (obj) => {
-    let cache = [];
-    let str = JSON.stringify(obj, function (_key, value) {
-        if (typeof value === "object" && value !== null) {
-            if (cache.indexOf(value) !== -1) {
-                return;
-            }
-            cache.push(value);
-        }
-        return value;
-    });
-    cache = null;
-    return str;
-};
-export const removeUndefined = (obj) => {
-    return JSON.parse(JSONStringify(obj));
-};
-export const validPath = (location, key) => {
-    return location?.pathname === key;
-};
-export const returnObject = (input) => {
-    return Array.isArray(input) ? input[0] : input;
-};
-export const filterArrayById = (array1, array2) => {
-    try {
-        if (!array1 || !array2)
-            return [];
-        const idsToExclude = new Set(array2.map((item) => item.id));
-        return array1.filter((item) => !idsToExclude.has(item.id));
-    }
-    catch (error) {
-        console.error("An error occurred:", error);
-        return [];
-    }
-};
-export const sortArrayByProperty = (array, property) => {
-    if (!array || array.length === 0)
-        return [];
-    return array.sort((a, b) => {
-        if (a[property] < b[property])
-            return -1;
-        if (a[property] > b[property])
-            return 1;
-        return 0;
-    });
-};
-export const replaceNulls = (obj) => {
-    if (obj === null) {
-        return "";
-    }
-    else if (Array.isArray(obj)) {
-        return obj.map(replaceNulls);
-    }
-    else if (typeof obj === "object" && obj !== null) {
-        const newObj = {};
-        for (const key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                newObj[key] = replaceNulls(obj[key]);
-            }
-        }
-        return newObj;
-    }
-    return obj;
-};
-export const removeFormProperties = (obj) => {
-    const recursiveRemove = (input) => {
-        if (Array.isArray(input)) {
-            return input.map((item) => recursiveRemove(item));
-        }
-        else if (typeof input === "object" && input !== null) {
-            const newObj = { ...input };
-            Object.keys(newObj).forEach((key) => {
-                if (key.includes(".")) {
-                    delete newObj[key];
-                }
-                else {
-                    newObj[key] = recursiveRemove(newObj[key]);
-                }
-            });
-            return newObj;
-        }
-        return input;
-    };
-    return recursiveRemove(obj);
-};
-export const convertStringBooleans = (obj) => {
-    const recursiveConvert = (input) => {
-        if (Array.isArray(input)) {
-            return input.map((item) => recursiveConvert(item));
-        }
-        else if (typeof input === "object" && input !== null) {
-            const newObj = { ...input };
-            Object.keys(newObj).forEach((key) => {
-                const value = newObj[key];
-                if (value === "true") {
-                    newObj[key] = true;
-                }
-                else if (value === "false") {
-                    newObj[key] = false;
-                }
-                else if (typeof value === "object" && value !== null) {
-                    newObj[key] = recursiveConvert(value);
-                }
-            });
-            return newObj;
-        }
-        return input;
-    };
-    return recursiveConvert(obj);
-};
-export const cleanFormData = (obj) => {
-    return removeFormProperties(convertStringBooleans(removeUndefined(obj)));
-};
-export const resetPagination = (sort, filters) => {
-    return {
-        page: 1,
-        size: 25,
-        sort: sort || [],
-        filters: filters || [],
-    };
-};
-export const formatPhoneNumber = (value) => {
-    const digits = value.toString().replace(/\D/g, "");
-    if (digits.length !== 10)
-        return value.toString();
-    const area = digits.slice(0, 3);
-    const prefix = digits.slice(3, 6);
-    const line = digits.slice(6);
-    return `(${area}) ${prefix}-${line}`;
-};
-export const formatNumber = (value) => {
-    return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-};
-export const parseNumber = (value) => {
-    return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, "");
-};
-export const deletePropertyIfExists = (obj, propertyName) => {
-    if (Object.prototype.hasOwnProperty.call(obj, propertyName)) {
-        delete obj[propertyName];
-    }
-};
-export const chunkArray = (array, chunkSize) => {
-    const result = [];
-    for (let i = 0; i < array.length; i += chunkSize) {
-        result.push(array.slice(i, i + chunkSize));
-    }
-    return result;
-};
-export const omitProperties = (obj, propsToOmit) => {
-    const newObj = { ...obj };
-    propsToOmit.forEach((prop) => {
-        delete newObj[prop];
-    });
-    return newObj;
-};
-export const hasProperty = (obj, key) => {
-    if (!obj)
-        return false;
-    return Object.prototype.hasOwnProperty.call(obj, key);
-};
-export const hasProperties = (obj) => {
-    return Object.keys(obj || {}).length > 0;
-};

package/dist/helpers/string/index.js

@@ -1,68 +0,0 @@
-export const normalCase = (str) => {
-    if (!str)
-        return "";
-    return str
-        .replace(/([a-z])([A-Z])/g, "$1 $2")
-        .replace(/([A-Z])([A-Z][a-z])/g, "$1 $2")
-        .split(/\s+/)
-        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-        .join(" ");
-};
-export const sentenceCase = (str) => {
-    if (!str)
-        return "";
-    const s = str.trim();
-    return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
-};
-export const upperCase = (str) => {
-    return str ? str.toUpperCase() : "";
-};
-export const lowerCase = (str) => {
-    return str ? str.toLowerCase() : "";
-};
-export const camelCase = (str) => {
-    if (!str)
-        return "";
-    return str
-        .toLowerCase()
-        .split(/[\s_-]+/)
-        .map((word, i) => i === 0
-        ? word
-        : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-        .join("");
-};
-export const pascalCase = (str) => {
-    if (!str)
-        return "";
-    return str
-        .toLowerCase()
-        .split(/[\s_-]+/)
-        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-        .join("");
-};
-export const kebabCase = (str) => {
-    if (!str)
-        return "";
-    return str
-        .replace(/([a-z])([A-Z])/g, "$1-$2")
-        .replace(/[\s_]+/g, "-")
-        .toLowerCase();
-};
-export const snakeCase = (str) => {
-    if (!str)
-        return "";
-    return str
-        .replace(/([a-z])([A-Z])/g, "$1_$2")
-        .replace(/[\s-]+/g, "_")
-        .toLowerCase();
-};
-export const snakeCaseToSpaces = (str) => {
-    if (!str)
-        return "";
-    return str.split("_").join(" ");
-};
-export const kebabToSpaces = (str) => {
-    if (!str)
-        return "";
-    return str.split("-").join(" ");
-};

package/dist/index.js

@@ -1,5 +0,0 @@
-export * from "./helpers";
-export * from "./types";
-export const test = () => {
-    console.log("working");
-};

package/dist/types/base/index.js

@@ -1,5 +0,0 @@
-export const STATUS = {
-    ACTIVE: "ACTIVE",
-    INACTIVE: "INACTIVE",
-};
-export * from "./paging.types";

package/dist/types/base/paging.types.js

@@ -1 +0,0 @@
-export {};

package/dist/types/user/index.js

@@ -1,13 +0,0 @@
-export const ACCOUNT_TYPE = {
-    TURNDOWN_ADMIN: "TURNDOWN_ADMIN",
-    OWNER: "OWNER",
-    ACCOUNT_ADMIN: "ACCOUNT_ADMIN",
-    MAINTAINER: "MAINTAINER",
-    CLEANER: "CLEANER",
-};
-export const LANGUAGE = {
-    ENGLISH: "ENGLISH",
-    FRENCH: "FRENCH",
-    SPANISH: "SPANISH",
-    GERMAN: "GERMAN",
-};