@daitanjs/manipulation/dist/index.cjs.map

A library to manipulate JSON, strings, and dates.

{
  "version": 3,
  "sources": ["../src/index.js", "../src/dates.js", "../src/json.js", "../src/strings.js"],
  "sourcesContent": ["// manipulation/src/index.js\n/**\n * @file Main entry point for the @daitanjs/manipulation package.\n * @module @daitanjs/manipulation\n *\n * @description\n * This package provides a suite of utilities for common data manipulation tasks,\n * focusing on dates, JSON structures, and strings. It aims to offer robust,\n * well-documented, and easy-to-use functions for everyday development needs.\n *\n * Key Features:\n * - Date conversion (e.g., US to UK format).\n * - JSON cleaning, safe parsing, and validation.\n * - String escaping, truncation, case conversion, and character type checking.\n *\n * All functions are designed with error handling and logging (via `@daitanjs/development`)\n * in mind, throwing specific DaitanJS errors for invalid inputs or operational failures.\n */\n\nimport { getLogger } from '@daitanjs/development';\n\nconst manipulationIndexLogger = getLogger('daitan-manipulation-index');\n\nmanipulationIndexLogger.debug('Exporting DaitanJS Manipulation utilities...');\n\n// --- Date Utilities ---\nexport { convertUSDateToUKDate } from './dates.js';\n// Future date functions (examples, not yet implemented in dates.js):\n// export { formatDate, addDays, dateDifference, isLeapYear, getDayOfWeek } from './dates.js';\n\n// --- JSON Utilities ---\nexport {\n  cleanJSONString,\n  deepCleanJSON,\n  safeParseJSON,\n  validateJSON,\n} from './json.js';\n\n// --- String Utilities ---\nexport {\n  addEscapes,\n  escapeObjectStrings, // Renamed from escapeObject for clarity\n  truncate,\n  toTitleCase,\n  isAlpha,\n  isAlphanumeric,\n  isNumeric,\n  reverseString,\n  // Potential new string utils:\n  // e.g., toKebabCase, toSnakeCase, toCamelCase,\n  // e.g., countOccurrences, removeWhitespace, padString\n} from './strings.js';\n\nmanipulationIndexLogger.info(\n  'DaitanJS Manipulation module exports configured and ready.'\n);\n", "// manipulation/src/dates.js\n/**\n * @file Date manipulation utilities.\n * @module @daitanjs/manipulation/dates\n */\nimport { getLogger } from '@daitanjs/development';\nimport { DaitanInvalidInputError } from '@daitanjs/error';\n\nconst logger = getLogger('daitan-manipulation-dates');\n\n/**\n * Converts a date string from US format (MM/DD/YYYY) to UK/European format (DD/MM/YYYY).\n * Also validates the input date string for correctness.\n *\n * @public\n * @param {string} usDate - The date string in MM/DD/YYYY format.\n * @returns {string} The date string in DD/MM/YYYY format.\n * @throws {DaitanInvalidInputError} If the input date string is not in the expected MM/DD/YYYY format or represents an invalid calendar date.\n *\n * @example\n * convertUSDateToUKDate(\"12/31/2023\"); // \"31/12/2023\"\n * convertUSDateToUKDate(\"02/29/2024\"); // \"29/02/2024\" (valid leap year)\n * convertUSDateToUKDate(\"02/29/2023\"); // throws DaitanInvalidInputError\n */\nexport function convertUSDateToUKDate(usDate) {\n  const callId = `usToUkDate-${Date.now().toString(36)}`;\n  logger.debug(\n    `[${callId}] convertUSDateToUKDate: Attempting to convert date \"${usDate}\".`\n  );\n\n  if (typeof usDate !== 'string' || !usDate.trim()) {\n    const errMsg = 'Input date string cannot be empty.';\n    logger.error(`[${callId}] ${errMsg}`, { input: usDate });\n    throw new DaitanInvalidInputError(errMsg, { inputDate: usDate });\n  }\n\n  const parts = usDate.trim().split('/');\n  if (parts.length !== 3) {\n    const errMsg = `Invalid US date format: \"${usDate}\". Expected MM/DD/YYYY.`;\n    logger.error(`[${callId}] ${errMsg}`);\n    throw new DaitanInvalidInputError(errMsg, { inputDate: usDate });\n  }\n\n  const [monthStr, dayStr, yearStr] = parts;\n\n  if (\n    monthStr.length < 1 ||\n    monthStr.length > 2 ||\n    dayStr.length < 1 ||\n    dayStr.length > 2 ||\n    yearStr.length !== 4\n  ) {\n    const errMsg = `Invalid US date component lengths in \"${usDate}\". Ensure MM (1-2 digits), DD (1-2 digits), YYYY (4 digits).`;\n    logger.error(`[${callId}] ${errMsg}`);\n    throw new DaitanInvalidInputError(errMsg, {\n      inputDate: usDate,\n      parsedParts: { monthStr, dayStr, yearStr },\n    });\n  }\n\n  const monthNum = parseInt(monthStr, 10);\n  const dayNum = parseInt(dayStr, 10);\n  const yearNum = parseInt(yearStr, 10);\n\n  if (isNaN(monthNum) || isNaN(dayNum) || isNaN(yearNum)) {\n    const errMsg = `Invalid numeric components in US date \"${usDate}\". Ensure MM, DD, YYYY are numbers.`;\n    logger.error(`[${callId}] ${errMsg}`);\n    throw new DaitanInvalidInputError(errMsg, {\n      inputDate: usDate,\n      parsedParts: { monthStr, dayStr, yearStr },\n    });\n  }\n\n  if (monthNum < 1 || monthNum > 12 || dayNum < 1 || dayNum > 31) {\n    const errMsg = `Month or day out of valid range in US date \"${usDate}\". Month: ${monthNum}, Day: ${dayNum}.`;\n    logger.error(`[${callId}] ${errMsg}`);\n    throw new DaitanInvalidInputError(errMsg, {\n      inputDate: usDate,\n      month: monthNum,\n      day: dayNum,\n    });\n  }\n\n  // Crucial validation: Test by creating a Date object.\n  // JavaScript's Date constructor is forgiving with out-of-range days/months,\n  // e.g., new Date(2023, 1, 30) becomes March 2nd, 2023.\n  // So, we must check if the constructed date matches the input components.\n  // Note: JavaScript months are 0-indexed (0 = January, 11 = December).\n  const testDate = new Date(yearNum, monthNum - 1, dayNum);\n\n  if (\n    testDate.getFullYear() !== yearNum ||\n    testDate.getMonth() !== monthNum - 1 ||\n    testDate.getDate() !== dayNum\n  ) {\n    const errMsg = `The date \"${usDate}\" is not a valid calendar date (e.g., Feb 30).`;\n    logger.error(`[${callId}] ${errMsg}`);\n    throw new DaitanInvalidInputError(errMsg, { inputDate: usDate });\n  }\n\n  // Pad day and month with leading zero if necessary for DD/MM/YYYY format\n  const ukDay = dayStr.padStart(2, '0');\n  const ukMonth = monthStr.padStart(2, '0');\n  const ukDate = `${ukDay}/${ukMonth}/${yearStr}`;\n\n  logger.info(\n    `[${callId}] Successfully converted \"${usDate}\" (US) to \"${ukDate}\" (UK).`\n  );\n  return ukDate;\n}\n", "// manipulation/src/json.js\n/**\n * @file JSON manipulation utilities.\n * @module @daitanjs/manipulation/json\n */\nimport { getLogger } from '@daitanjs/development';\nimport { DaitanInvalidInputError, DaitanOperationError } from '@daitanjs/error';\n\nconst logger = getLogger('daitan-manipulation-json');\n\n/**\n * Generates detailed error messages for invalid JSON, including context from the string.\n * This helps pinpoint where parsing failed.\n * @private\n * @param {SyntaxError | Error} error - The JSON parsing error object.\n * @param {string} jsonString - The JSON string that caused the error.\n * @returns {string} A detailed error message string.\n */\nfunction generateJSONErrorDetails(error, jsonString) {\n  const positionMatch = error.message.match(/position (\\d+)/i);\n  let enhancedError = `JSON Error: ${error.message}`;\n\n  if (positionMatch && positionMatch[1]) {\n    const position = parseInt(positionMatch[1], 10);\n    if (!isNaN(position)) {\n      const contextChars = 25;\n      const start = Math.max(0, position - contextChars);\n      const end = Math.min(jsonString.length, position + 1 + contextChars);\n      let nearText = jsonString.substring(start, end);\n      nearText = nearText.replace(/\\n/g, '\\\\n').replace(/\\r/g, '\\\\r');\n      const pointerOffset = position - start;\n      const pointerLine = ' '.repeat(pointerOffset) + '^';\n      enhancedError += `\\n  Context: \"${nearText}\"\\n           ${pointerLine}`;\n    }\n  }\n  return enhancedError;\n}\n\n/**\n * Cleans up a string that is supposed to be a JSON string by removing\n * common problematic characters and normalizing whitespace. This is a heuristic\n * approach and works best for common LLM output quirks or copy-paste errors.\n * It does not guarantee valid JSON if the input structure is fundamentally broken.\n *\n * @public\n * @param {string} input - The JSON-like string to be cleaned.\n * @returns {string} Cleaned JSON-like string. Returns the original input if it's not a string or is empty/whitespace only.\n */\nexport function cleanJSONString(input) {\n  if (typeof input !== 'string' || !input.trim()) {\n    if (typeof input === 'string' && input.length > 0 && !input.trim()) {\n      logger.debug(\n        'cleanJSONString: Input string is whitespace only. Returning empty string.'\n      );\n      return '';\n    }\n    logger.debug(\n      'cleanJSONString: Input is not a string or is effectively empty. Returning as is.',\n      { inputType: typeof input }\n    );\n    return input;\n  }\n\n  let cleaned = input;\n  const originalLength = cleaned.length;\n\n  const firstBracket = cleaned.indexOf('{');\n  const firstSquareBracket = cleaned.indexOf('[');\n  let startIndex = -1;\n  if (firstBracket !== -1 && firstSquareBracket !== -1) {\n    startIndex = Math.min(firstBracket, firstSquareBracket);\n  } else {\n    startIndex = Math.max(firstBracket, firstSquareBracket);\n  }\n\n  if (startIndex !== -1) {\n    const lastBracket = cleaned.lastIndexOf('}');\n    const lastSquareBracket = cleaned.lastIndexOf(']');\n    const endIndex = Math.max(lastBracket, lastSquareBracket);\n\n    if (endIndex > startIndex) {\n      cleaned = cleaned.substring(startIndex, endIndex + 1);\n    }\n  }\n\n  cleaned = cleaned.replace(/[\\u200B-\\u200D\\uFEFF]/g, '');\n  cleaned = cleaned.replace(/\\/\\/[^\\n]*\\n?/g, '');\n  cleaned = cleaned.replace(/,\\s*([}\\]])/g, '$1');\n  cleaned = cleaned.trim();\n\n  if (cleaned.length !== originalLength && logger.isLevelEnabled('debug')) {\n    logger.debug(\n      'cleanJSONString: String was modified by cleaning heuristics.',\n      {\n        originalLength,\n        cleanedLength: cleaned.length,\n        originalPreview:\n          input.substring(0, 100) + (input.length > 100 ? '...' : ''),\n        cleanedPreview:\n          cleaned.substring(0, 100) + (cleaned.length > 100 ? '...' : ''),\n      }\n    );\n  }\n  return cleaned;\n}\n\n/**\n * Recursively cleans all string values within a JSON-like object or array\n * using `cleanJSONString`.\n *\n * @public\n * @param {object|Array<any>} data - The object or array whose string values are to be cleaned.\n * @returns {object|Array<any>|string} A new data structure with cleaned string values.\n * @throws {DaitanInvalidInputError} if the input `data` is of an unsupported type.\n */\nexport function deepCleanJSON(data) {\n  if (typeof data === 'string') {\n    return cleanJSONString(data);\n  } else if (Array.isArray(data)) {\n    return data.map((item) => deepCleanJSON(item));\n  } else if (data && typeof data === 'object') {\n    const cleanedObject = {};\n    for (const [key, value] of Object.entries(data)) {\n      cleanedObject[key] = deepCleanJSON(value);\n    }\n    return cleanedObject;\n  } else if (\n    data === null ||\n    typeof data === 'number' ||\n    typeof data === 'boolean' ||\n    data === undefined\n  ) {\n    return data;\n  }\n\n  logger.warn(\n    `deepCleanJSON: Unsupported data type encountered: ${typeof data}. Returning as is.`\n  );\n  return data;\n}\n\n/**\n * Safely parses a JSON string. It can optionally attempt to clean the string\n * using `cleanJSONString` before parsing.\n *\n * @public\n * @param {string} jsonString - The JSON string to parse.\n * @param {object} [options={}] - Options for parsing.\n * @param {boolean} [options.attemptClean=true] - Whether to attempt cleaning the string.\n * @returns {any} The parsed JavaScript object or array.\n * @throws {DaitanInvalidInputError} If `jsonString` is not a string.\n * @throws {DaitanOperationError} If parsing fails.\n */\nexport function safeParseJSON(jsonString, options = {}) {\n  const { attemptClean = true } = options;\n\n  if (typeof jsonString !== 'string') {\n    const errMsg = 'Input to safeParseJSON must be a string.';\n    logger.error(errMsg, { inputType: typeof jsonString });\n    throw new DaitanInvalidInputError(errMsg, { input: jsonString });\n  }\n\n  let stringToParse = attemptClean ? cleanJSONString(jsonString) : jsonString;\n\n  try {\n    return JSON.parse(stringToParse);\n  } catch (error) {\n    const detailedMessage = generateJSONErrorDetails(error, stringToParse);\n    logger.error(\n      `safeParseJSON: Failed to parse JSON string. ${detailedMessage}`\n    );\n    throw new DaitanOperationError(\n      `JSON parsing failed: ${error.message}`,\n      {\n        inputStringPreview:\n          stringToParse.substring(0, 200) +\n          (stringToParse.length > 200 ? '...' : ''),\n        attemptedClean,\n      },\n      error\n    );\n  }\n}\n\n/**\n * Validates if a string is valid JSON.\n * @public\n * @param {string} jsonString - The JSON string to validate.\n * @param {object} [options={}] - Options for validation.\n * @param {boolean} [options.attemptClean=true] - Whether to attempt cleaning before validating.\n * @returns {{ isValid: boolean, parsedJson?: any, error?: string }}\n *          An object indicating validity.\n */\nexport function validateJSON(jsonString, options = {}) {\n  const { attemptClean = true } = options;\n  if (typeof jsonString !== 'string') {\n    return {\n      isValid: false,\n      parsedJson: null,\n      error: 'Input must be a string to validate as JSON.',\n    };\n  }\n  if (!jsonString.trim()) {\n    return {\n      isValid: false,\n      parsedJson: null,\n      error: 'Input JSON string is empty or contains only whitespace.',\n    };\n  }\n\n  const stringToValidate = attemptClean\n    ? cleanJSONString(jsonString)\n    : jsonString;\n\n  try {\n    const parsed = JSON.parse(stringToValidate);\n    return { isValid: true, parsedJson: parsed, error: null };\n  } catch (e) {\n    return {\n      isValid: false,\n      parsedJson: null,\n      error: generateJSONErrorDetails(e, stringToValidate),\n    };\n  }\n}\n", "// manipulation/src/strings.js\n/**\n * @file String manipulation utilities.\n * @module @daitanjs/manipulation/strings\n */\nimport { getLogger } from '@daitanjs/development';\nimport { DaitanInvalidInputError } from '@daitanjs/error';\n\nconst logger = getLogger('daitan-manipulation-strings');\n\n/**\n * Escapes special characters in a string for safe use in contexts like\n * JSON string values or general string literals within generated code.\n *\n * @public\n * @param {string} str - The string to escape.\n * @returns {string} The escaped string.\n * @throws {DaitanInvalidInputError} If input `str` is not a string.\n */\nexport const addEscapes = (str) => {\n  if (typeof str !== 'string') {\n    throw new DaitanInvalidInputError('Input to addEscapes must be a string.');\n  }\n  return str\n    .replace(/\\\\/g, '\\\\\\\\')\n    .replace(/\"/g, '\\\\\"')\n    .replace(/\\n/g, '\\\\n')\n    .replace(/\\r/g, '\\\\r')\n    .replace(/\\t/g, '\\\\t')\n    .replace(/\\f/g, '\\\\f')\n    .replace(/\\b/g, '\\\\b');\n};\n\n/**\n * Recursively escapes special characters in all string values within an object or array.\n * @public\n * @param {any} data - The data structure (object, array, or single string) to process.\n * @returns {any} A new data structure with all string values escaped.\n */\nexport const escapeObjectStrings = (data) => {\n  if (typeof data === 'string') {\n    return addEscapes(data);\n  } else if (Array.isArray(data)) {\n    return data.map((item) => escapeObjectStrings(item));\n  } else if (data && typeof data === 'object') {\n    const escapedObject = {};\n    for (const key in data) {\n      if (Object.prototype.hasOwnProperty.call(data, key)) {\n        escapedObject[key] = escapeObjectStrings(data[key]);\n      }\n    }\n    return escapedObject;\n  }\n  return data;\n};\n\n/**\n * Truncates a string to a specified maximum length, appending an ellipsis if truncated.\n *\n * @public\n * @param {string} str - The string to truncate.\n * @param {number} [maxLength=100] - The maximum length of the string (including ellipsis).\n * @param {string} [ellipsis='...'] - The ellipsis string to append.\n * @returns {string} The truncated string.\n * @throws {DaitanInvalidInputError} If inputs are invalid.\n */\nexport const truncate = (str, maxLength = 100, ellipsis = '...') => {\n  if (typeof str !== 'string') {\n    throw new DaitanInvalidInputError(\n      'Input `str` to truncate must be a string.'\n    );\n  }\n  if (typeof maxLength !== 'number' || isNaN(maxLength) || maxLength <= 0) {\n    throw new DaitanInvalidInputError(\n      'maxLength for truncate must be a positive number.'\n    );\n  }\n  if (typeof ellipsis !== 'string') {\n    throw new DaitanInvalidInputError(\n      'ellipsis for truncate must be a string.'\n    );\n  }\n\n  if (str.length <= maxLength) {\n    return str;\n  }\n  if (maxLength <= ellipsis.length) {\n    return ellipsis.substring(0, maxLength);\n  }\n  return str.substring(0, maxLength - ellipsis.length) + ellipsis;\n};\n\n/**\n * Converts a string to Title Case.\n * @public\n * @param {string} str - The input string.\n * @returns {string} The string in Title Case.\n * @throws {DaitanInvalidInputError} If input `str` is not a string.\n */\nexport const toTitleCase = (str) => {\n  if (typeof str !== 'string') {\n    throw new DaitanInvalidInputError(\n      'Input `str` to toTitleCase must be a string.'\n    );\n  }\n  if (!str.trim()) return '';\n  return str.toLowerCase().replace(/\\b\\w/g, (char) => char.toUpperCase());\n};\n\n/**\n * Checks if a string contains only alphabetic characters.\n * @public\n * @param {string} str - The input string.\n * @returns {boolean} True if the string is purely alphabetic and non-empty.\n * @throws {DaitanInvalidInputError} If input `str` is not a string.\n */\nexport const isAlpha = (str) => {\n  if (typeof str !== 'string') {\n    throw new DaitanInvalidInputError(\n      'Input `str` to isAlpha must be a string.'\n    );\n  }\n  return /^[a-zA-Z]+$/.test(str);\n};\n\n/**\n * Checks if a string contains only alphanumeric characters.\n * @public\n * @param {string} str - The input string.\n * @returns {boolean} True if the string is purely alphanumeric and non-empty.\n * @throws {DaitanInvalidInputError} If input `str` is not a string.\n */\nexport const isAlphanumeric = (str) => {\n  if (typeof str !== 'string') {\n    throw new DaitanInvalidInputError(\n      'Input `str` to isAlphanumeric must be a string.'\n    );\n  }\n  return /^[a-zA-Z0-9]+$/.test(str);\n};\n\n/**\n * Checks if a string contains only numeric characters.\n * @public\n * @param {string} str - The input string.\n * @returns {boolean} True if the string is purely numeric and non-empty.\n * @throws {DaitanInvalidInputError} If input `str` is not a string.\n */\nexport const isNumeric = (str) => {\n  if (typeof str !== 'string') {\n    throw new DaitanInvalidInputError(\n      'Input `str` to isNumeric must be a string.'\n    );\n  }\n  return /^[0-9]+$/.test(str);\n};\n\n/**\n * Reverses a string.\n * @public\n * @param {string} str - The input string.\n * @returns {string} The reversed string.\n * @throws {DaitanInvalidInputError} If input `str` is not a string.\n */\nexport const reverseString = (str) => {\n  if (typeof str !== 'string') {\n    throw new DaitanInvalidInputError(\n      'Input `str` to reverseString must be a string.'\n    );\n  }\n  return str.split('').reverse().join('');\n};\n"],
  "mappings": "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",
  "names": ["import_development", "import_development", "import_error", "logger", "import_development", "import_error", "logger"]
}