@doist/todoist-ai 4.15.1 → 4.16.1

package/dist/utils/duration-parser.js

@@ -1,96 +0,0 @@
-/**
- * Duration parser utility for converting human-readable duration strings
- * to minutes using a restricted, language-neutral syntax.
- *
- * Supported formats:
- * - "2h" (hours only)
- * - "90m" (minutes only)
- * - "2h30m" (hours + minutes)
- * - "1.5h" (decimal hours)
- * - Supports optional spaces: "2h 30m"
- */
-export class DurationParseError extends Error {
-    constructor(input, reason) {
-        super(`Invalid duration format "${input}": ${reason}`);
-        this.name = 'DurationParseError';
-    }
-}
-/**
- * Parses duration string in restricted syntax to minutes.
- * Max duration: 1440 minutes (24 hours)
- *
- * @param durationStr - Duration string like "2h30m", "45m", "1.5h"
- * @returns Parsed duration in minutes
- * @throws DurationParseError for invalid formats
- */
-export function parseDuration(durationStr) {
-    if (!durationStr || typeof durationStr !== 'string') {
-        throw new DurationParseError(durationStr, 'Duration must be a non-empty string');
-    }
-    // Remove all spaces and convert to lowercase
-    const normalized = durationStr.trim().toLowerCase().replace(/\s+/g, '');
-    // Check for empty string after trimming
-    if (!normalized) {
-        throw new DurationParseError(durationStr, 'Duration must be a non-empty string');
-    }
-    // Validate format with strict ordering: hours must come before minutes
-    // This regex ensures: optional hours followed by optional minutes, no duplicates
-    const match = normalized.match(/^(?:(\d+(?:\.\d+)?)h)?(?:(\d+(?:\.\d+)?)m)?$/);
-    if (!match || (!match[1] && !match[2])) {
-        throw new DurationParseError(durationStr, 'Use format like "2h", "30m", "2h30m", or "1.5h"');
-    }
-    let totalMinutes = 0;
-    const [, hoursStr, minutesStr] = match;
-    // Parse hours if present
-    if (hoursStr) {
-        const hours = Number.parseFloat(hoursStr);
-        if (Number.isNaN(hours) || hours < 0) {
-            throw new DurationParseError(durationStr, 'Hours must be a positive number');
-        }
-        totalMinutes += hours * 60;
-    }
-    // Parse minutes if present
-    if (minutesStr) {
-        const minutes = Number.parseFloat(minutesStr);
-        if (Number.isNaN(minutes) || minutes < 0) {
-            throw new DurationParseError(durationStr, 'Minutes must be a positive number');
-        }
-        // Don't allow decimal minutes
-        if (minutes % 1 !== 0) {
-            throw new DurationParseError(durationStr, 'Minutes must be a whole number (use decimal hours instead)');
-        }
-        totalMinutes += minutes;
-    }
-    // The regex already ensures at least one unit is present
-    // Round to nearest minute (handles decimal hours)
-    totalMinutes = Math.round(totalMinutes);
-    // Validate minimum duration
-    if (totalMinutes === 0) {
-        throw new DurationParseError(durationStr, 'Duration must be greater than 0 minutes');
-    }
-    // Validate maximum duration (24 hours = 1440 minutes)
-    if (totalMinutes > 1440) {
-        throw new DurationParseError(durationStr, 'Duration cannot exceed 24 hours (1440 minutes)');
-    }
-    return { minutes: totalMinutes };
-}
-/**
- * Formats minutes back to a human-readable duration string.
- * Used when returning task data to LLMs.
- *
- * @param minutes - Duration in minutes
- * @returns Formatted duration string like "2h30m" or "45m"
- */
-export function formatDuration(minutes) {
-    if (minutes <= 0)
-        return '0m';
-    const hours = Math.floor(minutes / 60);
-    const remainingMinutes = minutes % 60;
-    if (hours === 0) {
-        return `${remainingMinutes}m`;
-    }
-    if (remainingMinutes === 0) {
-        return `${hours}h`;
-    }
-    return `${hours}h${remainingMinutes}m`;
-}

package/dist/utils/duration-parser.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=duration-parser.test.d.ts.map

package/dist/utils/duration-parser.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"duration-parser.test.d.ts","sourceRoot":"","sources":["../../src/utils/duration-parser.test.ts"],"names":[],"mappings":""}

package/dist/utils/duration-parser.test.js

@@ -1,147 +0,0 @@
-import { DurationParseError, formatDuration, parseDuration } from './duration-parser.js';
-describe('parseDuration', () => {
-    describe('valid formats', () => {
-        it('should parse hours only', () => {
-            expect(parseDuration('2h')).toEqual({ minutes: 120 });
-            expect(parseDuration('1h')).toEqual({ minutes: 60 });
-            expect(parseDuration('24h')).toEqual({ minutes: 1440 });
-        });
-        it('should parse minutes only', () => {
-            expect(parseDuration('90m')).toEqual({ minutes: 90 });
-            expect(parseDuration('45m')).toEqual({ minutes: 45 });
-            expect(parseDuration('1m')).toEqual({ minutes: 1 });
-            expect(parseDuration('1440m')).toEqual({ minutes: 1440 });
-        });
-        it('should parse hours and minutes combined', () => {
-            expect(parseDuration('2h30m')).toEqual({ minutes: 150 });
-            expect(parseDuration('1h45m')).toEqual({ minutes: 105 });
-            expect(parseDuration('0h30m')).toEqual({ minutes: 30 });
-            expect(parseDuration('23h59m')).toEqual({ minutes: 1439 });
-        });
-        it('should parse decimal hours', () => {
-            expect(parseDuration('1.5h')).toEqual({ minutes: 90 });
-            expect(parseDuration('2.25h')).toEqual({ minutes: 135 });
-            expect(parseDuration('0.5h')).toEqual({ minutes: 30 });
-            expect(parseDuration('0.75h')).toEqual({ minutes: 45 });
-        });
-        it('should handle spaces in input', () => {
-            expect(parseDuration('2h 30m')).toEqual({ minutes: 150 });
-            expect(parseDuration(' 1h45m ')).toEqual({ minutes: 105 });
-            expect(parseDuration('  2h  ')).toEqual({ minutes: 120 });
-            expect(parseDuration(' 90m ')).toEqual({ minutes: 90 });
-        });
-        it('should handle case insensitive input', () => {
-            expect(parseDuration('2H')).toEqual({ minutes: 120 });
-            expect(parseDuration('90M')).toEqual({ minutes: 90 });
-            expect(parseDuration('2H30M')).toEqual({ minutes: 150 });
-            expect(parseDuration('1.5H')).toEqual({ minutes: 90 });
-        });
-        it('should round decimal minutes from decimal hours', () => {
-            expect(parseDuration('1.33h')).toEqual({ minutes: 80 }); // 1.33 * 60 = 79.8 -> 80
-            expect(parseDuration('1.67h')).toEqual({ minutes: 100 }); // 1.67 * 60 = 100.2 -> 100
-        });
-    });
-    describe('invalid formats', () => {
-        it('should throw error for empty or null input', () => {
-            expect(() => parseDuration('')).toThrow(DurationParseError);
-            expect(() => parseDuration('   ')).toThrow('Duration must be a non-empty string');
-            // biome-ignore lint/suspicious/noExplicitAny: Testing error cases with invalid types
-            expect(() => parseDuration(null)).toThrow('Duration must be a non-empty string');
-            // biome-ignore lint/suspicious/noExplicitAny: Testing error cases with invalid types
-            expect(() => parseDuration(undefined)).toThrow('Duration must be a non-empty string');
-        });
-        it('should throw error for invalid format', () => {
-            expect(() => parseDuration('2')).toThrow('Use format like "2h", "30m", "2h30m", or "1.5h"');
-            expect(() => parseDuration('2hours')).toThrow('Use format like');
-            expect(() => parseDuration('2h30')).toThrow('Use format like');
-            expect(() => parseDuration('h30m')).toThrow('Use format like');
-            expect(() => parseDuration('2x30m')).toThrow('Use format like');
-            expect(() => parseDuration('2h30s')).toThrow('Use format like');
-        });
-        it('should throw error for decimal minutes', () => {
-            expect(() => parseDuration('90.5m')).toThrow('Minutes must be a whole number');
-            expect(() => parseDuration('1h30.5m')).toThrow('Minutes must be a whole number');
-        });
-        it('should throw error for negative values', () => {
-            expect(() => parseDuration('-2h')).toThrow('Use format like');
-            expect(() => parseDuration('-30m')).toThrow('Use format like');
-            expect(() => parseDuration('2h-30m')).toThrow('Use format like');
-        });
-        it('should throw error for zero duration', () => {
-            expect(() => parseDuration('0h')).toThrow('Duration must be greater than 0 minutes');
-            expect(() => parseDuration('0m')).toThrow('Duration must be greater than 0 minutes');
-            expect(() => parseDuration('0h0m')).toThrow('Duration must be greater than 0 minutes');
-        });
-        it('should throw error for duration exceeding 24 hours', () => {
-            expect(() => parseDuration('25h')).toThrow('Duration cannot exceed 24 hours (1440 minutes)');
-            expect(() => parseDuration('1441m')).toThrow('Duration cannot exceed 24 hours (1440 minutes)');
-            expect(() => parseDuration('24h1m')).toThrow('Duration cannot exceed 24 hours (1440 minutes)');
-            expect(() => parseDuration('24.1h')).toThrow('Duration cannot exceed 24 hours (1440 minutes)');
-        });
-        it('should throw error for malformed numbers', () => {
-            expect(() => parseDuration('2.h')).toThrow('Use format like');
-            expect(() => parseDuration('2h.m')).toThrow('Use format like');
-            expect(() => parseDuration('2..5h')).toThrow('Use format like');
-        });
-        it('should throw error for duplicate units', () => {
-            expect(() => parseDuration('2h3h')).toThrow('Use format like');
-            expect(() => parseDuration('30m45m')).toThrow('Use format like');
-        });
-        it('should throw error for wrong order (minutes before hours)', () => {
-            expect(() => parseDuration('30m2h')).toThrow('Use format like');
-            expect(() => parseDuration('45m1h')).toThrow('Use format like');
-        });
-        it('should throw error for invalid mixed formats with correct order', () => {
-            expect(() => parseDuration('2h30m15h')).toThrow('Use format like');
-            expect(() => parseDuration('1h2h30m')).toThrow('Use format like');
-        });
-    });
-    describe('edge cases', () => {
-        it('should handle maximum allowed duration', () => {
-            expect(parseDuration('24h')).toEqual({ minutes: 1440 });
-            expect(parseDuration('1440m')).toEqual({ minutes: 1440 });
-            expect(parseDuration('23h60m')).toEqual({ minutes: 1440 });
-        });
-        it('should handle minimum allowed duration', () => {
-            expect(parseDuration('1m')).toEqual({ minutes: 1 });
-            expect(parseDuration('0.017h')).toEqual({ minutes: 1 }); // 0.017 * 60 = 1.02 -> 1
-        });
-    });
-});
-describe('formatDuration', () => {
-    it('should format minutes only', () => {
-        expect(formatDuration(45)).toBe('45m');
-        expect(formatDuration(1)).toBe('1m');
-        expect(formatDuration(59)).toBe('59m');
-    });
-    it('should format hours only', () => {
-        expect(formatDuration(60)).toBe('1h');
-        expect(formatDuration(120)).toBe('2h');
-        expect(formatDuration(1440)).toBe('24h');
-    });
-    it('should format hours and minutes combined', () => {
-        expect(formatDuration(90)).toBe('1h30m');
-        expect(formatDuration(150)).toBe('2h30m');
-        expect(formatDuration(105)).toBe('1h45m');
-        expect(formatDuration(1439)).toBe('23h59m');
-    });
-    it('should handle edge cases', () => {
-        expect(formatDuration(0)).toBe('0m');
-        expect(formatDuration(-5)).toBe('0m');
-    });
-});
-describe('round trip parsing and formatting', () => {
-    const testCases = [
-        { input: '2h', expectedMinutes: 120, expectedFormat: '2h' },
-        { input: '45m', expectedMinutes: 45, expectedFormat: '45m' },
-        { input: '2h30m', expectedMinutes: 150, expectedFormat: '2h30m' },
-        { input: '1.5h', expectedMinutes: 90, expectedFormat: '1h30m' },
-    ];
-    for (const { input, expectedMinutes, expectedFormat } of testCases) {
-        it(`should parse "${input}" and format back consistently`, () => {
-            const parsed = parseDuration(input);
-            expect(parsed.minutes).toBe(expectedMinutes);
-            expect(formatDuration(parsed.minutes)).toBe(expectedFormat);
-        });
-    }
-});

package/dist/utils/labels.js

@@ -1,18 +0,0 @@
-import { z } from 'zod';
-const LABELS_OPERATORS = ['and', 'or'];
-export const LabelsSchema = {
-    labels: z.string().array().optional().describe('The labels to filter the tasks by'),
-    labelsOperator: z
-        .enum(LABELS_OPERATORS)
-        .optional()
-        .describe('The operator to use when filtering by labels. This will dictate whether a task has all labels, or some of them. Default is "or".'),
-};
-export function generateLabelsFilter(labels = [], labelsOperator = 'or') {
-    if (labels.length === 0)
-        return '';
-    const operator = labelsOperator === 'and' ? ' & ' : ' | ';
-    // Add @ prefix to labels for Todoist API query
-    const prefixedLabels = labels.map((label) => (label.startsWith('@') ? label : `@${label}`));
-    const labelStr = prefixedLabels.join(` ${operator} `);
-    return `(${labelStr})`;
-}

package/dist/utils/priorities.js

@@ -1,20 +0,0 @@
-import { z } from 'zod';
-const PRIORITY_VALUES = ['p1', 'p2', 'p3', 'p4'];
-export const PrioritySchema = z.enum(PRIORITY_VALUES, {
-    description: 'Task priority: p1 (highest), p2 (high), p3 (medium), p4 (lowest/default)',
-});
-export function convertPriorityToNumber(priority) {
-    // Todoist API uses inverse mapping: p1=4 (highest), p2=3, p3=2, p4=1 (lowest)
-    const priorityMap = { p1: 4, p2: 3, p3: 2, p4: 1 };
-    return priorityMap[priority];
-}
-export function convertNumberToPriority(priority) {
-    // Convert Todoist API numbers back to our enum
-    const numberMap = { 4: 'p1', 3: 'p2', 2: 'p3', 1: 'p4' };
-    return numberMap[priority];
-}
-export function formatPriorityForDisplay(priority) {
-    // Convert Todoist API numbers to display format (P1, P2, P3, P4)
-    const displayMap = { 4: 'P1', 3: 'P2', 2: 'P3', 1: 'P4' };
-    return displayMap[priority] || '';
-}

package/dist/utils/response-builders.js

@@ -1,210 +0,0 @@
-import { DisplayLimits } from './constants.js';
-import { formatPriorityForDisplay } from './priorities.js';
-import { ToolNames } from './tool-names.js';
-/**
- * Helper function to get date string in YYYY-MM-DD format
- */
-export function getDateString(date = new Date()) {
-    const parts = date.toISOString().split('T');
-    return parts[0] ?? '';
-}
-const { FIND_TASKS_BY_DATE, ADD_TASKS, UPDATE_TASKS, COMPLETE_TASKS, GET_OVERVIEW } = ToolNames;
-/**
- * Creates concise, actionable summaries for task operations instead of raw JSON
- */
-export function summarizeTaskOperation(action, tasks, options = {}) {
-    const { nextSteps, context, showDetails = false } = options;
-    const count = tasks.length;
-    const bits = [];
-    // Main action summary
-    const taskOrTasks = count === 1 ? 'task' : 'tasks';
-    const actionSummary = `${action} ${count} ${taskOrTasks}${context ? ` ${context}` : ''}.`;
-    bits.push(actionSummary);
-    // Task details preview (if requested or small batch)
-    const smallBatchLimit = 5;
-    if (showDetails || count <= smallBatchLimit) {
-        const previews = previewTasks(tasks, smallBatchLimit);
-        if (previews.length > 0) {
-            const moreInfo = count > smallBatchLimit ? `, +${count - smallBatchLimit} more` : '';
-            bits.push(`Tasks:\n${previews}${moreInfo}.`);
-        }
-    }
-    // Next steps guidance
-    if (nextSteps?.length) {
-        bits.push(formatNextSteps(nextSteps));
-    }
-    return bits.join('\n');
-}
-/**
- * Creates batch operation summaries with success/failure breakdown
- */
-export function summarizeBatch(params) {
-    const { action, success, total, successItems, failures, nextSteps } = params;
-    const bits = [];
-    // Main result summary
-    const successBit = `${action}: ${success}/${total} successful.`;
-    bits.push(successBit);
-    // Success items (if provided and reasonable count)
-    if (successItems?.length && successItems.length <= 5) {
-        bits.push(`Completed:\n${successItems.map((item) => `    ${item}`).join('\n')}.`);
-    }
-    // Failure details (if any)
-    if (failures?.length) {
-        const failureCount = failures.length;
-        const failureBit = `Failed (${failureCount}):\n${failures
-            .slice(0, DisplayLimits.MAX_FAILURES_SHOWN)
-            .map((f) => `    ${f.item} (Error: ${f.error}${f.code ? ` [${f.code}]` : ''})`)
-            .join('\n')}${failureCount > DisplayLimits.MAX_FAILURES_SHOWN ? `, +${failureCount - DisplayLimits.MAX_FAILURES_SHOWN} more` : ''}.`;
-        bits.push(failureBit);
-    }
-    // Next steps
-    if (nextSteps?.length) {
-        bits.push(formatNextSteps(nextSteps));
-    }
-    return bits.join('\n');
-}
-/**
- * Formats a single task-like object into a readable preview line
- */
-function formatTaskPreview(task) {
-    const content = task.content || task.title || 'Untitled';
-    const due = task.dueDate ? ` • due ${task.dueDate}` : '';
-    const priority = task.priority ? ` • ${formatPriorityForDisplay(task.priority)}` : '';
-    const project = task.projectName ? ` • ${task.projectName}` : '';
-    const id = task.id ? ` • id=${task.id}` : '';
-    return `    ${content}${due}${priority}${project}${id}`;
-}
-/**
- * Formats a single project-like object into a readable preview line
- */
-export function formatProjectPreview(project) {
-    const isInbox = project.inboxProject ? ' • Inbox' : '';
-    const isFavorite = project.isFavorite ? ' • ⭐' : '';
-    const isShared = project.isShared ? ' • Shared' : '';
-    const viewStyle = project.viewStyle && project.viewStyle !== 'list' ? ` • ${project.viewStyle}` : '';
-    const id = ` • id=${project.id}`;
-    return `    ${project.name}${isInbox}${isFavorite}${isShared}${viewStyle}${id}`;
-}
-/**
- * Creates preview lines for task lists
- */
-export function previewTasks(tasks, limit = 5) {
-    const previewTasks = tasks.slice(0, limit);
-    const lines = previewTasks.map(formatTaskPreview).join('\n');
-    // If we're showing fewer tasks than the total, add an indicator
-    if (tasks.length > limit) {
-        const remaining = tasks.length - limit;
-        return `${lines}\n    ... and ${remaining} more task${remaining === 1 ? '' : 's'}`;
-    }
-    return lines;
-}
-/**
- * Creates list summaries with counts, filters, and guidance
- */
-export function summarizeList({ subject, count, limit, nextCursor, filterHints, previewLines, zeroReasonHints, nextSteps, }) {
-    const bits = [];
-    // Header with count and pagination info
-    const header = `${subject}: ${count}${typeof limit === 'number' ? ` (limit ${limit})` : ''}${nextCursor ? ', more available' : ''}.`;
-    bits.push(header);
-    // Filter information
-    if (filterHints?.length) {
-        bits.push(`Filter: ${filterHints.join('; ')}.`);
-    }
-    // Preview of items
-    if (previewLines?.length) {
-        bits.push(`Preview:\n${previewLines}`);
-    }
-    // Help for empty results
-    if (!count && zeroReasonHints?.length) {
-        bits.push(`No results. ${zeroReasonHints.join('; ')}.`);
-    }
-    // Next steps guidance
-    if (nextSteps?.length || nextCursor) {
-        bits.push(formatNextSteps(nextSteps || [], nextCursor));
-    }
-    return bits.join('\n');
-}
-/**
- * Formats next steps array into a consistent "Next:" section
- * If nextCursor is provided, adds cursor instruction to the steps
- */
-export function formatNextSteps(nextSteps, nextCursor) {
-    const allSteps = [...nextSteps];
-    if (nextCursor) {
-        allSteps.push(`Pass cursor '${nextCursor}' to fetch more results.`);
-    }
-    return `Next:\n${allSteps.map((step) => `- ${step}`).join('\n')}`;
-}
-/**
- * Helper to generate contextual next steps based on task operations
- */
-export function generateTaskNextSteps(operation, tasks, context) {
-    const nextSteps = [];
-    const count = context?.count ?? tasks.length;
-    switch (operation.toLowerCase()) {
-        case 'added':
-            // Context-aware suggestions for newly added tasks
-            if (context?.hasToday) {
-                nextSteps.push(`Use ${FIND_TASKS_BY_DATE}('today') to review today's updated schedule`);
-            }
-            else if (context?.hasOverdue) {
-                nextSteps.push(`Use ${FIND_TASKS_BY_DATE}('today') to prioritize past-due items`);
-            }
-            else if (context?.projectName) {
-                nextSteps.push(`Use ${GET_OVERVIEW} with projectId to see ${context.projectName} structure`);
-            }
-            else {
-                nextSteps.push(`Use ${GET_OVERVIEW} to see your updated project organization`);
-            }
-            // Time-based suggestions
-            if (context?.timeOfDay === 'morning') {
-                nextSteps.push(`Use ${FIND_TASKS_BY_DATE}('today') to plan your day`);
-            }
-            break;
-        case 'updated':
-        case 'organized':
-            if (context?.hasToday) {
-                nextSteps.push(`Use ${FIND_TASKS_BY_DATE}('today') to see your prioritized schedule`);
-            }
-            else if (context?.hasHighPriority) {
-                nextSteps.push(`Use ${FIND_TASKS_BY_DATE} with filter to focus on high-priority items`);
-            }
-            else {
-                nextSteps.push(`Use ${GET_OVERVIEW} to see your updated project structure`);
-            }
-            break;
-        case 'completed':
-            if (context?.timeOfDay === 'evening') {
-                nextSteps.push(`Use ${FIND_TASKS_BY_DATE}('tomorrow') to plan upcoming work`);
-            }
-            else if (context?.hasOverdue) {
-                nextSteps.push(`Use ${FIND_TASKS_BY_DATE}('today') to tackle remaining past-due items`);
-            }
-            else {
-                nextSteps.push(`Use ${FIND_TASKS_BY_DATE}('today') to see remaining work`);
-            }
-            break;
-        case 'listed':
-            if (context?.isEmptyResult) {
-                nextSteps.push(`Use ${ADD_TASKS} to add tasks for this timeframe`);
-                nextSteps.push(`Use ${GET_OVERVIEW} with projectId to see tasks in other projects`);
-            }
-            else if (count > 0) {
-                // Tailor suggestions based on result size
-                if (count > DisplayLimits.BATCH_OPERATION_THRESHOLD) {
-                    nextSteps.push(`Use ${UPDATE_TASKS} to batch-update priorities or dates`);
-                    nextSteps.push('Consider breaking large tasks into subtasks');
-                }
-                else {
-                    nextSteps.push(`Use ${UPDATE_TASKS} to modify priorities or due dates`);
-                }
-                nextSteps.push(`Use ${COMPLETE_TASKS} to mark finished tasks`);
-                // Time-sensitive suggestions
-                if (context?.hasOverdue) {
-                    nextSteps.push('Focus on overdue items first to get back on track');
-                }
-            }
-            break;
-    }
-    return nextSteps;
-}

package/dist/utils/sanitize-data.js

@@ -1,37 +0,0 @@
-/**
- * Removes all null fields, empty objects, and empty arrays from an object recursively.
- * This ensures that data sent to agents doesn't include unnecessary empty values.
- *
- * @param obj - The object to sanitize
- * @returns A new object with all null fields, empty objects, and empty arrays removed
- */
-export function removeNullFields(obj) {
-    if (obj === null || obj === undefined) {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        return obj.map((item) => removeNullFields(item));
-    }
-    if (typeof obj === 'object') {
-        const sanitized = {};
-        for (const [key, value] of Object.entries(obj)) {
-            if (value !== null) {
-                const cleanedValue = removeNullFields(value);
-                // Skip empty arrays
-                if (Array.isArray(cleanedValue) && cleanedValue.length === 0) {
-                    continue;
-                }
-                // Skip empty objects
-                if (cleanedValue !== null &&
-                    typeof cleanedValue === 'object' &&
-                    !Array.isArray(cleanedValue) &&
-                    Object.keys(cleanedValue).length === 0) {
-                    continue;
-                }
-                sanitized[key] = cleanedValue;
-            }
-        }
-        return sanitized;
-    }
-    return obj;
-}

package/dist/utils/sanitize-data.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=sanitize-data.test.d.ts.map

package/dist/utils/sanitize-data.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sanitize-data.test.d.ts","sourceRoot":"","sources":["../../src/utils/sanitize-data.test.ts"],"names":[],"mappings":""}

package/dist/utils/sanitize-data.test.js

@@ -1,93 +0,0 @@
-import { removeNullFields } from './sanitize-data.js';
-describe('removeNullFields', () => {
-    it('should remove null fields from objects including nested objects', () => {
-        const input = {
-            name: 'John',
-            age: null,
-            email: 'john@example.com',
-            phone: null,
-            address: {
-                street: '123 Main St',
-                city: null,
-                country: 'USA',
-            },
-        };
-        const result = removeNullFields(input);
-        expect(result).toEqual({
-            name: 'John',
-            email: 'john@example.com',
-            address: {
-                street: '123 Main St',
-                country: 'USA',
-            },
-        });
-    });
-    it('should handle arrays with null values', () => {
-        const input = {
-            items: [
-                { id: 1, value: 'test' },
-                { id: 2, value: null },
-                { id: 3, value: 'another' },
-            ],
-        };
-        const result = removeNullFields(input);
-        expect(result).toEqual({
-            items: [{ id: 1, value: 'test' }, { id: 2 }, { id: 3, value: 'another' }],
-        });
-    });
-    it('should handle null objects', () => {
-        const result = removeNullFields(null);
-        expect(result).toBeNull();
-    });
-    it('should remove empty objects and empty arrays', () => {
-        const input = {
-            something: 'hello',
-            another: {},
-            yetAnother: [],
-        };
-        const result = removeNullFields(input);
-        expect(result).toEqual({
-            something: 'hello',
-        });
-    });
-    it('should remove empty objects and empty arrays in nested structures', () => {
-        const input = {
-            name: 'Test',
-            metadata: {},
-            tags: [],
-            nested: {
-                data: 'value',
-                emptyObj: {},
-                emptyArr: [],
-                deepNested: {
-                    anotherEmpty: {},
-                },
-            },
-            items: [
-                { id: 1, data: 'test', empty: {} },
-                { id: 2, list: [] },
-            ],
-        };
-        const result = removeNullFields(input);
-        expect(result).toEqual({
-            name: 'Test',
-            nested: {
-                data: 'value',
-            },
-            items: [{ id: 1, data: 'test' }, { id: 2 }],
-        });
-    });
-    it('should keep arrays with values and objects with properties', () => {
-        const input = {
-            emptyArray: [],
-            arrayWithValues: [1, 2, 3],
-            emptyObject: {},
-            objectWithProps: { key: 'value' },
-        };
-        const result = removeNullFields(input);
-        expect(result).toEqual({
-            arrayWithValues: [1, 2, 3],
-            objectWithProps: { key: 'value' },
-        });
-    });
-});