Overview

typepurify is a lightning-fast, zero-schema data cleaner designed to deeply strip null, undefined, and optionally empty strings/arrays/objects from your data maps while keeping your TypeScript types perfectly aligned.

Instead of writing complex Zod or Joi schemas just to clean a payload, typepurify automatically re-infers your types at compile-time and safely handles nested records and array structures.

⚡ Why typepurify? (vs. Zod / Lodash)

When developers receive messy data from an API, they usually reach for tools that have major drawbacks:

typepurify solves data cleaning perfectly. It dynamically recalculates your TypeScript interfaces at compile-time, physically removing null and undefined from the output types without writing a single schema.

🧠 How it Works

Understanding how typepurify processes your data is simple. It uses a recursive engine to traverse your nested payloads and instantly strips out unwanted, empty, or undefined values based on your configuration.

Installation

npm install typepurify
# or
yarn add typepurify
# or
pnpm add typepurify

Usage

import { clean } from 'typepurify';

const messyPayload = {
  id: 101,
  profile: {
    title: null,
    geo: 'IN',
  },
  tags: ['React', null, 'TypeScript'],
  emptyString: '',
  emptyArray: [],
};

// Standard clean (removes null and undefined natively)
const cleanPayload = clean(messyPayload);
/* Result: 
{ 
  id: 101, 
  profile: { geo: "IN" }, 
  tags: ["React", "TypeScript"], 
  emptyString: "", 
  emptyArray: [] 
} 
*/
// Note: Types are automatically inferred! `title` is instantly removed from the `profile` type at compile time.

// Aggressive clean with Options
const ultraCleanPayload = clean(messyPayload, {
  stripEmptyStrings: true,
  stripEmptyArrays: true,
});
/* Result: 
{ 
  id: 101, 
  profile: { geo: "IN" }, 
  tags: ["React", "TypeScript"] 
} 
*/

API

clean<T>(obj: T, options?: CleanOptions): DeepRequired<T>

Recursively deep-cleans null/undefined values from objects and arrays, dynamically re-inferring compile-time types without generating heavy schemas.

cleanInPlace<T>(obj: T, options?: CleanOptions): DeepRequired<T>

Operates exactly like clean(), but mutates the original payload directly instead of allocating new objects in memory. This offers maximum performance and zero memory overhead for massive data payloads.

Options:

• stripEmptyStrings (boolean): Removes empty strings "".
• stripEmptyArrays (boolean): Removes arrays with zero length [].
• stripEmptyObjects (boolean): Removes objects with no keys {}.
• trimStrings (boolean): Trims whitespace from strings before processing.
• stripWhen (function): Custom predicate function to strip any specific value (e.g., (val) => val === 'N/A').

Contributing

Contributions, issues, and feature requests are welcome! See our Contributing Guidelines for more details.

👨💻 About the Author

Vallarasu Kanthasamy
Full-Stack & Systems Engineer

I build lightweight, high-performance developer utilities and media automation engines. My engineering focus centers on zero-dependency architecture, defensive data structures, and advanced TypeScript type systems that normalize boundaries in enterprise applications.

🌐 Digital Ecosystem & Platforms

Developer Tools & Extensions

• Auto Console Log (VS Code) – Lightning-fast debugging for JS/TS.
• Opacity Adjuster (Chrome Extension)
• Tech Stack Checker (Chrome Extension)
• Universal Spreadsheet Markdown Editor
• Media Bucket Sync for Amazon S3 (WordPress)

Open Source & Resources

• Awesome Developer Resources – A curated list of high-value tools for developers.
• My Developer Resources & Blog

Connect With Me

• Portfolio: vallarasuk.com
• GitHub: github.vallarasuk.com
• LinkedIn: linkedin.vallarasuk.com
• Community: Join my WhatsApp Developer Squad

🛡️ License

MIT © Vallarasu Kanthasamy