@turndown/library 0.0.19 → 0.0.21

package/dist/helpers/index.js

@@ -0,0 +1,2 @@
+export * from "./object";
+export * from "./string";

package/{src/helpers/object/index.ts → dist/helpers/object/index.d.ts}

@@ -1,13 +1,10 @@
 import { FilterCondition, SortCondition, TurndownObject } from "@/types/base";
-
 export interface Version {
-  major: number;
-  minor: number;
-  patch: number;
+    major: number;
+    minor: number;
+    patch: number;
 }
-
 export type VersionInput = string | Version;
-
 /**
  * Safely parse a JSON string into a value.
  *
@@ -19,14 +16,7 @@ export type VersionInput = string | Version;
  * parseJSON('{"a":1}') // => { a: 1 }
  * parseJSON('not json') // => {}
  */
-export const parseJSON = (jsonString: TurndownObject): TurndownObject => {
-  try {
-    return JSON.parse(jsonString);
-  } catch (error) {
-    return {};
-  }
-};
-
+export declare const parseJSON: (jsonString: TurndownObject) => TurndownObject;
 /**
  * Stringify an object to JSON while skipping circular references.
  *
@@ -39,31 +29,14 @@ export const parseJSON = (jsonString: TurndownObject): TurndownObject => {
  * 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;
-};
-
+export declare const JSONStringify: (obj: TurndownObject) => string;
 /**
  * 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));
-};
-
+export declare const removeUndefined: (obj: TurndownObject) => TurndownObject;
 /**
  * Test whether a location object's `pathname` equals a key.
  *
@@ -73,10 +46,7 @@ export const removeUndefined = (obj: TurndownObject): TurndownObject => {
  * @example
  * validPath({ pathname: "/home" }, "/home") // true
  */
-export const validPath = (location: TurndownObject, key: string): boolean => {
-  return location?.pathname === key;
-};
-
+export declare const validPath: (location: TurndownObject, key: string) => boolean;
 /**
  * Return the first element if the input is an array; otherwise return the value itself.
  *
@@ -87,10 +57,7 @@ export const validPath = (location: TurndownObject, key: string): boolean => {
  * returnObject([1,2,3]) // 1
  * returnObject(5) // 5
  */
-export const returnObject = <T>(input: T | T[]): T => {
-  return Array.isArray(input) ? input[0] : input;
-};
-
+export declare const returnObject: <T>(input: T | T[]) => T;
 /**
  * Filter out items from `array1` whose `id` appears in `array2`.
  *
@@ -99,21 +66,9 @@ export const returnObject = <T>(input: T | T[]): T => {
  * @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 [];
-  }
-};
-
+export declare const filterArrayById: <T extends {
+    id: number | string;
+}>(array1?: T[], array2?: T[]) => T[];
 /**
  * Sort an array of objects by a given property (ascending).
  *
@@ -124,19 +79,7 @@ export const filterArrayById = <T extends { id: number | string }>(
  * @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;
-  });
-};
-
+export declare const sortArrayByProperty: <T extends Record<string, any>>(array: T[], property: keyof T) => T[];
 /**
  * Recursively replace `null` values with empty strings.
  *
@@ -145,23 +88,7 @@ export const sortArrayByProperty = <T extends Record<string, any>>(
  * @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;
-};
-
+export declare const replaceNulls: (obj: TurndownObject) => TurndownObject;
 /**
  * Recursively remove object keys that contain a dot (`.`).
  *
@@ -169,30 +96,7 @@ export const replaceNulls = (obj: TurndownObject): TurndownObject => {
  * @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);
-};
-
+export declare const removeFormProperties: <T extends Record<string, TurndownObject>>(obj: T) => T;
 /**
  * Recursively convert string booleans `"true"`/`"false"` to actual booleans.
  *
@@ -202,36 +106,7 @@ export const removeFormProperties = <T extends Record<string, TurndownObject>>(
  * @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);
-};
-
+export declare const convertStringBooleans: <T extends Record<string, any>>(obj: T) => T;
 /**
  * Convenience helper to clean form-like data:
  * - Removes `undefined` properties
@@ -241,10 +116,7 @@ export const convertStringBooleans = <T extends Record<string, any>>(
  * @param {TurndownObject} obj - Input data.
  * @returns {TurndownObject} Cleaned clone.
  */
-export const cleanFormData = (obj: TurndownObject) => {
-  return removeFormProperties(convertStringBooleans(removeUndefined(obj)));
-};
-
+export declare const cleanFormData: (obj: TurndownObject) => any;
 /**
  * Return a default pagination object, allowing optional sort and filters.
  *
@@ -254,18 +126,12 @@ export const cleanFormData = (obj: TurndownObject) => {
  * @example
  * resetPagination() // => { page:1, size:25, sort:[], filters:[] }
  */
-export const resetPagination = (
-  sort?: SortCondition[],
-  filters?: FilterCondition[]
-) => {
-  return {
-    page: 1,
-    size: 25,
-    sort: sort || [],
-    filters: filters || [],
-  };
+export declare const resetPagination: (sort?: SortCondition[], filters?: FilterCondition[]) => {
+    page: number;
+    size: number;
+    sort: SortCondition[];
+    filters: FilterCondition[];
 };
-
 /**
  * Format a string of digits into a U.S. phone number.
  *
@@ -279,17 +145,7 @@ export const resetPagination = (
  * 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}`;
-};
-
+export declare const formatPhoneNumber: (value: string | number) => string;
 /**
  * Format a number with thousands separators (commas).
  *
@@ -298,10 +154,7 @@ export const formatPhoneNumber = (value: string | number): string => {
  * @example
  * formatNumber(1234567) // "1,234,567"
  */
-export const formatNumber = (value: number): string => {
-  return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-};
-
+export declare const formatNumber: (value: number) => string;
 /**
  * Parse a number string (note: current implementation adds commas as well).
  *
@@ -313,10 +166,7 @@ export const formatNumber = (value: number): string => {
  * @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, "");
-};
-
+export declare const parseNumber: (value: number) => string;
 /**
  * Delete a property from an object if it exists (no-op if it doesn't).
  *
@@ -324,15 +174,7 @@ export const parseNumber = (value: number): string => {
  * @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];
-  }
-};
-
+export declare const deletePropertyIfExists: (obj: TurndownObject, propertyName: string) => void;
 /**
  * Split an array into chunks of a given size.
  *
@@ -343,14 +185,7 @@ export const deletePropertyIfExists = (
  * @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;
-};
-
+export declare const chunkArray: <T>(array: T[], chunkSize: number) => T[][];
 /**
  * Return a shallow clone of `obj` without the listed properties.
  *
@@ -360,18 +195,7 @@ export const chunkArray = <T>(array: T[], chunkSize: number): T[][] => {
  * @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;
-};
-
+export declare const omitProperties: (obj: TurndownObject, propsToOmit: TurndownObject) => any;
 /**
  * Safe `hasOwnProperty` check.
  *
@@ -379,17 +203,11 @@ export const omitProperties = (
  * @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);
-};
-
+export declare const hasProperty: (obj: Record<string, any>, key: string) => boolean;
 /**
  * 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;
-};
+export declare const hasProperties: (obj: object) => boolean;

package/dist/helpers/object/index.js

@@ -0,0 +1,350 @@
+/**
+ * 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) => {
+    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) => {
+    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;
+};
+/**
+ * Deep-remove `undefined` properties by serializing & parsing.
+ *
+ * @param {TurndownObject} obj - Input object.
+ * @returns {TurndownObject} Cleaned clone with `undefined` removed.
+ */
+export const removeUndefined = (obj) => {
+    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, key) => {
+    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 = (input) => {
+    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 = (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 [];
+    }
+};
+/**
+ * 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 = (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;
+    });
+};
+/**
+ * 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) => {
+    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;
+};
+/**
+ * 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 = (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);
+};
+/**
+ * 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 = (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);
+};
+/**
+ * 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) => {
+    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, filters) => {
+    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) => {
+    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) => {
+    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) => {
+    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, propertyName) => {
+    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 = (array, chunkSize) => {
+    const result = [];
+    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, propsToOmit) => {
+    const newObj = { ...obj };
+    propsToOmit.forEach((prop) => {
+        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, key) => {
+    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) => {
+    return Object.keys(obj || {}).length > 0;
+};

package/dist/helpers/string/index.d.ts

@@ -0,0 +1,104 @@
+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 declare const normalCase: (str?: TurndownObject) => string;
+/**
+ * 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 declare const sentenceCase: (str?: TurndownObject) => string;
+/**
+ * Uppercase the entire string.
+ *
+ * @param {TurndownObject} [str] Input value (falsy returns an empty string)
+ * @returns {string}
+ * @example
+ * upperCase("Hello world") // "HELLO WORLD"
+ */
+export declare const upperCase: (str?: TurndownObject) => string;
+/**
+ * Lowercase the entire string.
+ *
+ * @param {TurndownObject} [str] Input value (falsy returns an empty string)
+ * @returns {string}
+ * @example
+ * lowerCase("Hello WORLD") // "hello world"
+ */
+export declare const lowerCase: (str?: TurndownObject) => string;
+/**
+ * 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 declare const camelCase: (str?: TurndownObject) => string;
+/**
+ * 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 declare const pascalCase: (str?: TurndownObject) => string;
+/**
+ * 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 declare const kebabCase: (str?: TurndownObject) => string;
+/**
+ * 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 declare const snakeCase: (str?: TurndownObject) => string;
+/**
+ * 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 declare const snakeCaseToSpaces: (str?: TurndownObject) => string;
+/**
+ * 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 declare const kebabToSpaces: (str?: TurndownObject) => string;

package/{src/helpers/string/index.ts → dist/helpers/string/index.js}

@@ -1,5 +1,3 @@
-import { TurndownObject } from "@/types/base";
-
 /**
  * Convert a string to "Normal Case":
  * - Inserts spaces between camel/pascal case boundaries
@@ -11,20 +9,16 @@ import { TurndownObject } from "@/types/base";
  * 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(" ");
+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(" ");
 };
-
 /**
  * Capitalize only the first character; lowercases the rest.
  * Trims leading/trailing spaces before processing.
@@ -34,13 +28,12 @@ export const normalCase = (str?: TurndownObject): 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();
+export const sentenceCase = (str) => {
+    if (!str)
+        return "";
+    const s = str.trim();
+    return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
 };
-
 /**
  * Uppercase the entire string.
  *
@@ -49,10 +42,9 @@ export const sentenceCase = (str?: TurndownObject): string => {
  * @example
  * upperCase("Hello world") // "HELLO WORLD"
  */
-export const upperCase = (str?: TurndownObject): string => {
-  return str ? str.toUpperCase() : "";
+export const upperCase = (str) => {
+    return str ? str.toUpperCase() : "";
 };
-
 /**
  * Lowercase the entire string.
  *
@@ -61,10 +53,9 @@ export const upperCase = (str?: TurndownObject): string => {
  * @example
  * lowerCase("Hello WORLD") // "hello world"
  */
-export const lowerCase = (str?: TurndownObject): string => {
-  return str ? str.toLowerCase() : "";
+export const lowerCase = (str) => {
+    return str ? str.toLowerCase() : "";
 };
-
 /**
  * Convert to camelCase.
  * Splits on spaces, underscores, and hyphens; lowercases the first word,
@@ -76,19 +67,17 @@ export const lowerCase = (str?: TurndownObject): string => {
  * 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
+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("");
+        : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join("");
 };
-
 /**
  * Convert to PascalCase.
  * Splits on spaces, underscores, and hyphens; TitleCases all words and joins them.
@@ -99,15 +88,15 @@ export const camelCase = (str?: TurndownObject): string => {
  * 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("");
+export const pascalCase = (str) => {
+    if (!str)
+        return "";
+    return str
+        .toLowerCase()
+        .split(/[\s_-]+/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join("");
 };
-
 /**
  * Convert to kebab-case.
  * Inserts hyphens between camelCase boundaries, then replaces spaces/underscores with hyphens.
@@ -118,14 +107,14 @@ export const pascalCase = (str?: TurndownObject): string => {
  * 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();
+export const kebabCase = (str) => {
+    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.
@@ -136,14 +125,14 @@ export const kebabCase = (str?: TurndownObject): string => {
  * 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();
+export const snakeCase = (str) => {
+    if (!str)
+        return "";
+    return str
+        .replace(/([a-z])([A-Z])/g, "$1_$2")
+        .replace(/[\s-]+/g, "_")
+        .toLowerCase();
 };
-
 /**
  * Convert snake_case to space-delimited words.
  *
@@ -152,11 +141,11 @@ export const snakeCase = (str?: TurndownObject): string => {
  * @example
  * snakeCaseToSpaces("hello_world_again") // "hello world again"
  */
-export const snakeCaseToSpaces = (str?: TurndownObject): string => {
-  if (!str) return "";
-  return str.split("_").join(" ");
+export const snakeCaseToSpaces = (str) => {
+    if (!str)
+        return "";
+    return str.split("_").join(" ");
 };
-
 /**
  * Convert kebab-case to space-delimited words.
  *
@@ -165,7 +154,8 @@ export const snakeCaseToSpaces = (str?: TurndownObject): string => {
  * @example
  * kebabToSpaces("hello-world-again") // "hello world again"
  */
-export const kebabToSpaces = (str?: TurndownObject): string => {
-  if (!str) return "";
-  return str.split("-").join(" ");
+export const kebabToSpaces = (str) => {
+    if (!str)
+        return "";
+    return str.split("-").join(" ");
 };

package/dist/index.js

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

package/dist/types/base/index.d.ts

@@ -0,0 +1,18 @@
+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 declare const STATUS: {
+    readonly ACTIVE: "ACTIVE";
+    readonly INACTIVE: "INACTIVE";
+};
+export type Status = ObjectValues<typeof STATUS>;
+export * from "./paging.types";

package/dist/types/base/index.js

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

package/dist/types/base/paging.types.d.ts

@@ -0,0 +1,30 @@
+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/dist/types/base/paging.types.js

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

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export * from "./user";
+export * from "./base";

package/dist/types/user/index.d.ts

@@ -0,0 +1,37 @@
+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 declare const ACCOUNT_TYPE: {
+    readonly TURNDOWN_ADMIN: "TURNDOWN_ADMIN";
+    readonly OWNER: "OWNER";
+    readonly ACCOUNT_ADMIN: "ACCOUNT_ADMIN";
+    readonly MAINTAINER: "MAINTAINER";
+    readonly CLEANER: "CLEANER";
+};
+export type AccountType = ObjectValues<typeof ACCOUNT_TYPE>;
+export declare const LANGUAGE: {
+    readonly ENGLISH: "ENGLISH";
+    readonly FRENCH: "FRENCH";
+    readonly SPANISH: "SPANISH";
+    readonly GERMAN: "GERMAN";
+};
+export type Language = ObjectValues<typeof LANGUAGE>;

package/dist/types/user/index.js

@@ -0,0 +1,13 @@
+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",
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turndown/library",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "Shared TypeScript library for the Turndown suite.",
   "keywords": [
     "types",
@@ -16,21 +16,20 @@
     "access": "public"
   },
   "type": "module",
-  "main": "dist/index.ts",
-  "module": "dist/index.ts",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "src",
-    "dist"
-  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "browser": "./dist/index.ts",
-      "import": "./dist/index.ts"
+      "import": "./dist/index.ts",
+      "default": "./dist/index.ts"
     },
     "./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/types/base/index.ts

@@ -1,26 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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>;