Description

The tuple utility function is a TypeScript helper designed to return a tuple while correctly inferring its type. It is useful when you want TypeScript to deduce a tuple type without the need for explicit type annotations, type casting, or the const assertion. This function works with empty tuples, as well as tuples containing elements of varying types, ensuring enhanced type safety and clarity.

Code Byte

export const tuple = <T extends unknown[]>(args: [...T]): T => args;

Comment Snippet

/**
 * @description TypeScript utility function to return a tuple and correctly infers the tuple type.
 * This fn is useful when you want TS to infer a tuple type without needing to explicitly set the type,
 * use type casting, or apply the `const` assertion.
 *
 * @example
 * // Infers as [number, number]
 * const numbers = tuple([1, 2]);
 *
 * @example
 * // Infers as [number, string, boolean]
 * const mixed = tuple([1, "hello", true]);
 *
 * @example
 * // Infers as []
 * const empty = tuple([]);
 *
 * @category Utility
 */

Tests

import { tuple } from './typescript.utils';

describe('TypeScript Utils', () => {
  describe('tuple()', () => {
    it('should return a tuple', () => {
      const result = tuple([1, 2]);
      expect(result).toEqual([1, 2]);
    });

    it('should return a tuple with multiple elements of different types', () => {
      const result = tuple([1, true, 'a']);
      expect(result).toEqual([1, true, 'a']);
    });

    it('should return an empty tuple', () => {
      const result = tuple([]);
      expect(result).toEqual([]);
    });
  });
});