How to fix Rest parameter cannot have initializer in TypeScript

// WRONG - rest parameter with initializer
function logMessages(...messages: string[] = []) {
  messages.forEach(msg => console.log(msg));
}

// CORRECT - remove the initializer
function logMessages(...messages: string[]) {
  messages.forEach(msg => console.log(msg));
}

// Now the function works correctly
logMessages("Hello", "World");  // Logs: Hello, World
logMessages();                   // Logs nothing (messages is empty array [])

// WRONG - trying to give rest parameter a default
function processItems(...items: any[] = []) {
  // Process items
}

// CORRECT - use a regular parameter with default before rest parameter
function processItems(firstItem: any = null, ...remainingItems: any[]) {
  const allItems = firstItem !== null ? [firstItem, ...remainingItems] : remainingItems;
  // Process allItems
}

// Alternative: Handle empty case inside function
function processItems(...items: any[]) {
  if (items.length === 0) {
    // Handle empty case
    return;
  }
  // Process items
}

// This is ALSO invalid in JavaScript!
function invalid(...args = []) {
  console.log(args);
}
// JavaScript error: "Rest parameter may not have a default initializer"

// Valid JavaScript/TypeScript:
function valid(...args) {
  console.log(args);
}

// Test in Node.js to confirm:
node -e "function test(...args=[]) { console.log(args) }"
// Throws: SyntaxError: Rest parameter may not have a default initializer

// Scenario: You want at least one item with a default
// WRONG approach:
function addItems(...items: string[] = ["default"]) {
  // This doesn't make sense - what if user provides items?
}

// CORRECT approach 1: Separate required parameter
function addItems(firstItem: string = "default", ...additionalItems: string[]) {
  const allItems = [firstItem, ...additionalItems];
  // Process allItems
}

// CORRECT approach 2: Overload the function
function addItems(item: string): void;
function addItems(...items: string[]): void;
function addItems(...items: string[]) {
  if (items.length === 0) {
    items = ["default"]; // Set default inside function
  }
  // Process items
}

// CORRECT approach 3: Use optional parameters
function addItems(item1?: string, item2?: string, item3?: string) {
  const items = [item1, item2, item3].filter(Boolean) as string[];
  if (items.length === 0) {
    items.push("default");
  }
  // Process items
}

{
  "compilerOptions": {
    // These settings help catch syntax errors early
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,

    // Don't use these if you want to catch syntax errors:
    // "skipLibCheck": true,  // Still checks your code
    // "noEmitOnError": false // Would emit despite errors

    // Good practice for development
    "noUnusedLocals": true,
    "noUnusedParameters": true
  }
}

npx tsc --noEmit --listFiles
# or for specific file
npx tsc --noEmit your-file.ts

// Pattern 1: Function that accepts array or rest parameters
function processItems(items: string[]): void;
function processItems(...items: string[]): void;
function processItems(...args: [string[]] | string[]) {
  const items = Array.isArray(args[0]) ? args[0] : args;
  if (items.length === 0) {
    // Handle empty case
    console.log("No items provided");
    return;
  }
  // Process items
}

// Pattern 2: Builder pattern with defaults
class ItemProcessor {
  private items: string[] = [];

  addItems(...items: string[]): this {
    this.items.push(...items);
    return this;
  }

  process() {
    if (this.items.length === 0) {
      this.items = ["default"];
    }
    // Process this.items
  }
}

// Pattern 3: Configuration object with rest parameters
interface ProcessOptions {
  requiredItem?: string;
  additionalItems?: string[];
}

function processWithOptions(options: ProcessOptions) {
  const items = [
    ...(options.requiredItem ? [options.requiredItem] : []),
    ...(options.additionalItems || [])
  ];
  if (items.length === 0) {
    items.push("default");
  }
  // Process items
}