isSet

Determines whether a value is a Set object with enhanced type safety. Provides reliable Set detection using instanceof check with generic type support for type-safe Set validation and processing. Works with any Set instance regardless of the stored value types.

Signature

const isSet: <T extends Set<any>>(value: unknown) => value is T

Parameters

Name	Type	Description
value	-	Value to test for Set type

Returns

Type-safe boolean indicating whether the value is a Set

Examples

Basic Set detection

import { isSet } from '@winglet/common-utils';

// True cases - Set instances
console.log(isSet(new Set())); // true
console.log(isSet(new Set([1, 2, 3]))); // true
console.log(isSet(new Set(['a', 'b', 'c']))); // true

const numberSet = new Set<number>();
numberSet.add(42);
console.log(isSet(numberSet)); // true

// False cases - not Set instances
console.log(isSet([])); // false (array)
console.log(isSet({})); // false (plain object)
console.log(isSet(new Map())); // false (Map, not Set)
console.log(isSet(new WeakSet())); // false (WeakSet, not Set)
console.log(isSet({ size: 0, has: () => false })); // false (set-like object)
console.log(isSet('set')); // false (string)
console.log(isSet(null)); // false
console.log(isSet(undefined)); // false

Type-safe Set processing

function processSetData(data: unknown) {
  if (isSet(data)) {
    // TypeScript knows data is Set
    console.log(`Set with ${data.size} unique values`);

    // Safe to use Set methods
    const values = Array.from(data.values());
    const hasSpecificValue = data.has('target');

    return {
      size: data.size,
      values,
      isEmpty: data.size === 0,
      hasTarget: hasSpecificValue
    };
  }

  throw new Error('Expected Set instance');
}

// Usage
const tagSet = new Set(['javascript', 'typescript', 'react']);
const result = processSetData(tagSet);
console.log('Processed set:', result);

Unique value validation

interface CollectionManager {
  uniqueItems: unknown;
}

function validateUniqueCollection(manager: CollectionManager) {
  if (!isSet(manager.uniqueItems)) {
    throw new Error('Unique items must be stored in a Set');
  }

  return {
    isValid: true,
    count: manager.uniqueItems.size,
    isEmpty: manager.uniqueItems.size === 0,

    add(item: any) {
      manager.uniqueItems.add(item);
      return this;
    },

    remove(item: any) {
      manager.uniqueItems.delete(item);
      return this;
    },

    contains(item: any) {
      return manager.uniqueItems.has(item);
    }
  };
}

Data structure conversion

function convertToArray(setOrArray: unknown): any[] {
  if (isSet(setOrArray)) {
    // Convert Set to Array maintaining uniqueness
    return Array.from(setOrArray);
  }

  if (Array.isArray(setOrArray)) {
    return [...setOrArray];
  }

  throw new Error('Expected Set or Array');
}

function ensureUniqueValues(arrayOrSet: unknown): Set<any> {
  if (isSet(arrayOrSet)) {
    return new Set(arrayOrSet); // Create copy
  }

  if (Array.isArray(arrayOrSet)) {
    return new Set(arrayOrSet); // Remove duplicates
  }

  throw new Error('Expected Set or Array');
}

// Usage
const numbers = [1, 2, 2, 3, 3, 4];
const uniqueNumbers = ensureUniqueValues(numbers);
console.log(convertToArray(uniqueNumbers)); // [1, 2, 3, 4]

Playground

import { isSet } from '@winglet/common-utils';

// True cases - Set instances
console.log(isSet(new Set())); // true
console.log(isSet(new Set([1, 2, 3]))); // true
console.log(isSet(new Set(['a', 'b', 'c']))); // true

const numberSet = new Set<number>();
numberSet.add(42);
console.log(isSet(numberSet)); // true

// False cases - not Set instances
console.log(isSet([])); // false (array)
console.log(isSet({})); // false (plain object)
console.log(isSet(new Map())); // false (Map, not Set)
console.log(isSet(new WeakSet())); // false (WeakSet, not Set)
console.log(isSet({ size: 0, has: () => false })); // false (set-like object)
console.log(isSet('set')); // false (string)
console.log(isSet(null)); // false
console.log(isSet(undefined)); // false

Notes

Key Features:

• Maintains insertion order (like Map)
• Automatic duplicate removal
• Direct size property
• Efficient add/delete/has operations
• Iterable interface support

Use Cases:

• Unique value collections
• Permission/role systems
• Tag management
• Data deduplication
• Graph algorithms (visited nodes)
• Cache key management

Related Types:

• Use isWeakSet() for WeakSet detection
• Use isMap() for Map detection
• Use isArray() for array detection
• Use typeof obj === 'object' for basic object checking

Performance: Direct instanceof check provides optimal performance.

Cross-frame Compatibility: Works correctly across different execution contexts.