codeoptimize

Pattern Optimization Toolkit for JavaScript

Clean conditions for complex codebases. Not replacing if-else — optimizing repetitive patterns.

npm install codeoptimize

🎯 What is codeoptimize?

codeoptimize is a lightweight utility library with 5 focused patterns that help you write cleaner, more maintainable code.

✅ 5 Core Patterns (No Overlap)

| Pattern | Purpose | Use When | Example | |---------|---------|----------|---------| | router() | Message/Event routing | 5+ branches on same value | router(map).route(key) | | guard() | Deep nesting flattener | 3+ nested if levels | guard(x).ok().then(fn) | | match() | State/Case matching | Fixed values (strings, enums) | match(x).case(1, A) | | validate() | Form/API validation | Multi-field validation | validate(d).email() | | toggle() | Repeated toggle patterns | Same pattern 3+ times | toggle(state, set, {on, off}) |

❌ What codeoptimize is NOT

• ❌ Not an if-else replacement - We optimize patterns, not replace JavaScript
• ❌ Not a logic obfuscator - Simple conditions stay as if/else
• ❌ Not magic - Pure JavaScript, no eval, no dynamic code

✅ What codeoptimize IS

• ✅ Pattern optimizer - Repetitive code becomes DRY
• ✅ Readability booster - Complex nesting becomes flat chains
• ✅ Production ready - 50+ tests, TypeScript, zero deps

📦 API Overview

| Pattern | Function | Use Case | Example | |---------|----------|----------|---------| | Router | router() | Message/Event routing (5+ branches) | router(map).route(key) | | Guard | guard() | Deep nesting (3+ levels) | guard(x).ok().then(fn) | | Match | match() | State machine / Fixed values | match(x).case(1, A).else(B) | | Validate | validate() | Form/API validation | validate(d).email().check() | | Toggle | toggle() | Repeated toggle patterns | toggle(state, set, {on, off}) |

🔧 Utilities (Optional)

Helper functions for complex conditions:

import { all, any, not, one, none } from 'codeoptimize';

all([a, b, c])      // All must be true
any([a, b, c])      // Any can be true
not(a)              // Negate
one([a, b, c])      // Exactly one true
none([a, b, c])     // None are true

Use with plain JavaScript:

// Keep it simple - no when() needed
if (all([isLoggedIn, hasPermission, notExpired])) {
  grantAccess();
} else {
  denyAccess();
}

📚 Complete Documentation

1️⃣ router() - Object-based Message Routing

Replaces: Long if-else chains for message/event handling

Use when: 5+ branches based on same value (msg.type, action, event)

import { router } from 'codeoptimize';

// BEFORE - 70 lines of if-else
ws.onmessage = (event) => {
  const msg = JSON.parse(event.data);
  
  if (msg.type === 'phone_connected') {
    setConnected(true);
    setPhoneInfo(msg.info);
    addLog(`📱 ${msg.info?.model}`, 'success');
  }
  if (msg.type === 'phone_disconnected') {
    setConnected(false);
    addLog('Disconnected', 'error');
  }
  if (msg.type === 'log') {
    setKeylogs(prev => [msg, ...prev]);
  }
  // ... 4 more if blocks
};

// AFTER - 15 lines with router
const messageRouter = router({
  phone_connected: (msg) => {
    setConnected(true);
    setPhoneInfo(msg.info);
    addLog(`📱 ${msg.info?.model}`, 'success');
  },
  phone_disconnected: () => {
    setConnected(false);
    addLog('Disconnected', 'error');
  },
  log: (msg) => setKeylogs(prev => [msg, ...prev]),
  root_result: handleRootResult,
  audio_chunk: playAudioChunk,
  file_list: handleFileList,
  file_data: handleFileData
});

ws.onmessage = (event) => {
  const msg = JSON.parse(event.data);
  messageRouter.route(msg.type, msg, (type) => {
    console.warn(`Unknown message type: ${type}`);
  });
};

API:

router(handlers)           // Create router
  .route(key, data, fb)    // Route to handler
  .default(fn)             // Set global fallback
  .has(key)                // Check if handler exists
  .keys()                  // Get all registered keys

2️⃣ guard() - Guard Clauses for Nested Conditions

Replaces: Deep nested if statements (3+ levels)

Use when: Multiple null/undefined checks or early returns needed

import { guard } from 'codeoptimize';

// BEFORE - Deep nesting (hard to read)
if (user) {
  if (user.active) {
    if (user.verified) {
      if (user.role === 'admin') {
        runAdmin();
      }
    }
  }
}

// AFTER - Clean guard chain
guard(user)
  .exists()
  .prop('active')
  .prop('verified')
  .prop('role')
  .is('admin')
  .then(() => runAdmin());

// OR with early return pattern
guard(user)
  .exists()
  .prop('permissions')
  .notEmpty()
  .then(permissions => {
    // Safe to use permissions here
    processPermissions(permissions);
  })
  .else(() => {
    showGuestView();
  });

API:

guard(value)
  .exists()           // Check not null/undefined
  .ok()               // Check truthy
  .notEmpty()         // Check not empty (array/string/object)
  .isFunction()       // Check is function
  .isArray()          // Check is array
  .isObject()         // Check is object
  .prop(name)         // Access property safely
  .check(fn)          // Custom validation
  .then(fn)           // Execute if valid
  .else(fn)           // Execute if invalid
  .or(defaultValue)   // Get value or default
  .isValid()          // Check if valid
  .value()            // Get underlying value

3️⃣ toggle() - Toggle Helper

Replaces: Identical toggle functions repeated multiple times

Use when: Same toggle pattern repeated 3+ times

import { toggle } from 'codeoptimize';

// BEFORE - 5 identical functions (40 lines)
const toggleCamera = () => {
  const newState = !isCameraOn;
  setCameraOn(newState);
  if (newState) {
    sendJSON({ type: 'start_camera' });
    addLog('Started', 'success');
  } else {
    sendJSON({ type: 'stop_camera' });
    addLog('Stopped', 'info');
  }
};

const toggleAudio = () => {
  const newState = !isAudioOn;
  setAudioOn(newState);
  if (newState) {
    sendJSON({ type: 'start_audio' });
    addLog('Started', 'success');
  } else {
    sendJSON({ type: 'stop_audio' });
    addLog('Stopped', 'info');
  }
};

// ... 3 more identical functions

// AFTER - Reusable helper (15 lines)
const toggleCamera = () => toggle(isCameraOn, setCameraOn, {
  on: () => {
    sendJSON({ type: 'start_camera' });
    addLog('📷 Camera Started', 'success');
  },
  off: () => {
    sendJSON({ type: 'stop_camera' });
    addLog('Camera Stopped', 'info');
  }
});

const toggleAudio = () => toggle(isAudioOn, setAudioOn, {
  on: () => {
    sendJSON({ type: 'start_audio' });
    addLog('🎤 Audio Started', 'success');
  },
  off: () => {
    sendJSON({ type: 'stop_audio' });
    addLog('Audio Stopped', 'info');
  }
});

API:

toggle(state, setState, {
  on,              // Execute when turning on
  off,             // Execute when turning off
  before,          // Execute before state change
  after            // Execute after state change
})

4️⃣ match() - Pattern Matching

Replaces: Switch statements, if-else chains for fixed values

Use when: 4+ branches based on same value (status, state, type)

import { match } from 'codeoptimize';

// BEFORE - Switch statement
function render() {
  switch (status) {
    case 'loading':
      return <LoadingSpinner />;
    case 'success':
      return <DataView data={data} />;
    case 'error':
      return <ErrorMessage error={error} />;
    case 'empty':
      return <EmptyState />;
    default:
      return <div>Unknown state</div>;
  }
}

// AFTER - Match expression
const render = () =>
  match(status)
    .case('loading', <LoadingSpinner />)
    .case('success', <DataView data={data} />)
    .case('error', <ErrorMessage error={error} />)
    .case('empty', <EmptyState />)
    .else(<div>Unknown state</div>);

// With functions (lazy evaluation)
match(httpStatus)
  .case(200, () => handleSuccess())
  .case(404, () => handleNotFound())
  .case(500, () => handleServerError())
  .cases([401, 403], () => handleAuthError())  // Multiple values
  .else(() => handleUnknown());

API:

match(value)
  .case(matchValue, result)     // Match single value
  .cases([values], result)      // Match multiple values (OR)
  .when(predicate, result)      // Match with function
  .else(result)                 // Default case
  .value()                      // Get result
  .isMatched()                  // Check if matched
  .run()                        // Execute and get result

5️⃣ validate() - Validation Chain

Replaces: Manual validation if-else chains

Use when: Multiple field validations needed

import { validate } from 'codeoptimize';

// BEFORE - Manual validation (20 lines)
function validateUser(data) {
  const errors = [];
  if (!data.email) {
    errors.push('Email is required');
  } else if (!/\S+@\S+\.\S+/.test(data.email)) {
    errors.push('Invalid email format');
  }
  if (!data.password) {
    errors.push('Password is required');
  } else if (data.password.length < 8) {
    errors.push('Password must be at least 8 characters');
  }
  if (!data.age || data.age < 18) {
    errors.push('Must be 18 or older');
  }
  return errors.length === 0 ? { valid: true } : { valid: false, errors };
}

// AFTER - Validation chain (8 lines)
const validateUser = (data) =>
  validate(data)
    .required('email', 'password', 'age')
    .email('email')
    .minLength('password', 8)
    .min('age', 18)
    .check();

// Usage
const result = validateUser(formData);
if (result.valid) {
  submit(result.data);
} else {
  showErrors(result.errors);
}

API:

validate(data)
  .required(...fields)          // Required fields
  .email(field)                 // Email format
  .minLength(field, min)        // Minimum length
  .maxLength(field, max)        // Maximum length
  .min(field, value)            // Minimum number
  .max(field, value)            // Maximum number
  .pattern(field, regex)        // Regex pattern
  .custom(field, fn)            // Custom validation
  .equals(field, value)         // Must equal value
  .oneOfRequired(...fields)     // At least one required
  .check()                      // Get validation result

Validation Result:

{
  valid: boolean,
  errors: [{ field, message }],
  errorCount: number,
  data: Object | null,
  fieldCount: number
}

🎯 Real-World Examples

Example 1: WebSocket Message Handler

import { router } from 'codeoptimize';

const wsRouter = router({
  connect: handleConnect,
  disconnect: handleDisconnect,
  message: handleMessage,
  error: handleError,
  ping: () => sendPong()
});

ws.onmessage = (e) => {
  wsRouter.route(JSON.parse(e.data).type);
};

Example 2: React Component State

import { match } from 'codeoptimize';

function UserProfile({ state }) {
  return match(state.status)
    .case('loading', <Spinner />)
    .case('error', <Error msg={state.error} />)
    .case('success', <Profile data={state.data} />)
    .else(<Empty />);
}

Example 3: Form Validation

import { validate } from 'codeoptimize';

const handleSubmit = (formData) => {
  const validation = validate(formData)
    .required('email', 'password', 'name')
    .email('email')
    .minLength('password', 8)
    .minLength('name', 2)
    .pattern('phone', /^\d{10}$/, 'Invalid phone number')
    .check();

  if (validation.valid) {
    submit(validation.data);
  } else {
    setErrors(validation.errors);
  }
};

Example 4: Permission System

import { cond, guard } from 'codeoptimize';

const checkAccess = (user, resource) =>
  guard(user)
    .exists()
    .prop('permissions')
    .notEmpty()
    .then(permissions =>
      cond(resource.type)
        .is('document', () => hasDocAccess(permissions, resource))
        .is('admin', () => permissions.includes('admin'))
        .is('settings', () => permissions.includes('settings'))
        .else(false)
    )
    .or(false);

Example 5: Toggle Features

import { toggle } from 'codeoptimize';

// Multiple toggles with same pattern
const toggleDarkMode = () => toggle(isDark, setDarkMode, {
  on: () => document.body.classList.add('dark'),
  off: () => document.body.classList.remove('dark')
});

const toggleNotifications = () => toggle(isNotif, setNotif, {
  on: () => enableNotifications(),
  off: () => disableNotifications()
});

📊 When to Use What

| Scenario | Lines | Pattern | Benefit | |----------|-------|---------|---------| | 5+ if-else branches | 50+ | router(), cond(), match() | 70% reduction | | 3+ nested if levels | 15+ | guard() | 60% reduction | | Repeated toggles (3+) | 30+ | toggle() | 50% reduction | | Form validation | 20+ | validate() | 60% reduction | | State machine | 15+ | match() | 40% reduction | | Complex boolean | 5+ | when() + all() | 30% reduction | | Simple 1-2 conditions | 1-5 | Keep if/else | No change |

🔐 Security & Performance

Is this safe for production?

✅ YES - 100% safe

• Pure JavaScript (no eval, no dynamic code)
• Works in Node.js, browser, serverless
• Zero dependencies
• TypeScript definitions included

Performance impact?

| Pattern | Speed | Overhead | |---------|-------|----------| | if/else | Fastest | Baseline | | router() | Almost same | Negligible | | guard() | Slightly slower | <1ms per chain | | match() | Almost same | Negligible | | validate() | Fast | <5ms for 10 fields |

Overhead is negligible unless you're doing 10 lakh operations/sec.

🚫 Anti-Patterns (Don't Do This)

// ❌ Over-engineering simple condition
cond(age >= 18).then(() => allow()).else(() => deny());

// ✅ Keep it simple
if (age >= 18) allow(); else deny();

// ❌ Replacing clear ternary
cond(isActive).then('active').else('inactive');

// ✅ Ternary is better here
const status = isActive ? 'active' : 'inactive';

// ❌ Unnecessary abstraction
when(loading && !error && hasData).then(show);

// ✅ Plain JS is clearer
if (loading && !error && hasData) show();

📦 Bundle Size

| Export | Minified | Gzipped | |--------|----------|---------| | Full | 8.2 KB | 2.8 KB | | router only | 1.2 KB | 0.5 KB | | guard only | 2.1 KB | 0.8 KB | | toggle only | 0.8 KB | 0.4 KB | | match only | 1.5 KB | 0.6 KB | | validate only | 2.8 KB | 1.0 KB | | cond only | 2.0 KB | 0.7 KB | | when only | 1.0 KB | 0.5 KB |

Tree-shaking enabled - Import only what you need:

// Full import
import { router, guard, toggle } from 'codeoptimize';

// Or import individually (better for bundle size)
import router from 'codeoptimize/router';
import guard from 'codeoptimize/guard';
import toggle from 'codeoptimize/toggle';

📝 License

MIT © [Your Name]

🤝 Contributing

Contributions welcome! Please read CONTRIBUTING.md first.

# Fork the repo
git clone https://github.com/yourusername/codeoptimize.git

# Install dependencies
npm install

# Run tests
npm test

# Run linter
npm run lint

📞 Support

• Issues: GitHub Issues
• Email: [email protected]
• Twitter: @yourusername

🙏 Acknowledgments

Inspired by:

• Rust's match expression
• Kotlin's when expression
• Swift's switch statement
• Functional programming patterns

Made with ❤️ for cleaner code