Array Utilities

function unique(arr)

import { unique } from '@semantic-ui/utils';

const arr = [1, 2, 2, 3, 4, 4, 5];
console.log(unique(arr)); // [1, 2, 3, 4, 5]

function filterEmpty(arr)

import { filterEmpty } from '@semantic-ui/utils';

const arr = [1, undefined, 2, null, 3, '', 4];
console.log(filterEmpty(arr)); // [1, 2, null, 3, '', 4]

function last(array, number = 1)

import { last } from '@semantic-ui/utils';

const arr = [1, 2, 3, 4, 5];
console.log(last(arr)); // 5
console.log(last(arr, 2)); // [4, 5]

function first(array, number = 1)

import { first } from '@semantic-ui/utils';

const arr = [1, 2, 3, 4, 5];
console.log(first(arr)); // 1
console.log(first(arr, 2)); // [1, 2]

function firstMatch(array, callback)

import { firstMatch } from '@semantic-ui/utils';

const arr = [1, 2, 3, 4, 5];
const result = firstMatch(arr, (value) => value > 3);
console.log(result); // 4

function findIndex(array, callback)

import { findIndex } from '@semantic-ui/utils';

const arr = [1, 2, 3, 4, 5];
const index = findIndex(arr, (value) => value > 3);
console.log(index); // 3

function remove(array, callbackOrValue)

import { remove } from '@semantic-ui/utils';

const arr = [1, 2, 3, 4, 5];
remove(arr, 3);
console.log(arr); // [1, 2, 4, 5]

remove(arr, (value) => value > 4);
console.log(arr); // [1, 2, 4]

function inArray(value, array = [])

import { inArray } from '@semantic-ui/utils';

const arr = [1, 2, 3, 4, 5];
console.log(inArray(3, arr)); // true
console.log(inArray(6, arr)); // false

function range(start, stop, step = 1)

import { range } from '@semantic-ui/utils';

console.log(range(5)); // [0, 1, 2, 3, 4]
console.log(range(1, 5)); // [1, 2, 3, 4]
console.log(range(0, 10, 2)); // [0, 2, 4, 6, 8]

function moveItem(array = [], callbackOrValue, index)

import { moveItem } from '@semantic-ui/utils';

const arr = [1, 2, 3, 4];
console.log(moveItem(arr, 3, 0)); // [3, 1, 2, 4]
console.log(moveItem(arr, 2, 'last')); // [1, 3, 4, 2]
console.log(moveItem(arr, x => x === 4, 'first')); // [4, 1, 2, 3]
console.log(moveItem(arr, 2, 1)); // [1, 2, 3, 4]

function moveToFront(array = [], callbackOrValue)

import { moveToFront } from '@semantic-ui/utils';

const arr = [1, 2, 3, 4];
console.log(moveToFront(arr, 3)); // [3, 1, 2, 4]

function moveToBack(array = [], callbackOrValue)

import { moveToBack } from '@semantic-ui/utils';

const arr = [1, 2, 3, 4];
console.log(moveToBack(arr, 2)); // [1, 3, 4, 2]

function sum(values)

import { sum } from '@semantic-ui/utils';

const numbers = [1, 2, 3, 4, 5];
console.log(sum(numbers)); // 15

function where(array, properties)

import { where } from '@semantic-ui/utils';

const people = [
  { name: 'John', age: 30 },
  { name: 'Jane', age: 25 },
  { name: 'Bob', age: 30 }
];
const result = where(people, { age: 30 });
console.log(result); // [{ name: 'John', age: 30 }, { name: 'Bob', age: 30 }]

function flatten(arr)

import { flatten } from '@semantic-ui/utils';

const nestedArray = [1, [2, [3, 4]], 5];
console.log(flatten(nestedArray)); // [1, 2, 3, 4, 5]

function some(collection, predicate)

import { some } from '@semantic-ui/utils';

const numbers = [1, 2, 3, 4, 5];
const result = some(numbers, (num) => num > 3);
console.log(result); // true

function sortBy(arr, key, comparator)

import { sortBy } from '@semantic-ui/utils';

const people = [
  { name: 'John', age: 30 },
  { name: 'Jane', age: 25 },
  { name: 'Bob', age: 35 }
];
console.log(sortBy(people, 'age'));
// [{ name: 'Jane', age: 25 }, { name: 'John', age: 30 }, { name: 'Bob', age: 35 }]

// With custom comparator (descending)
console.log(sortBy(people, 'age', (a, b) => b - a));
// [{ name: 'Bob', age: 35 }, { name: 'John', age: 30 }, { name: 'Jane', age: 25 }]

import { sortBy } from '@semantic-ui/utils';

const employees = [
  { name: 'John', age: 30, department: 'IT' },
  { name: 'Jane', age: 25, department: 'HR' },
  { name: 'Bob', age: 30, department: 'IT' },
  { name: 'Alice', age: 25, department: 'IT' }
];

// Sort by age first, then by name
console.log(sortBy(employees, ['age', 'name']));
// [
//   { name: 'Alice', age: 25, department: 'IT' },
//   { name: 'Jane', age: 25, department: 'HR' },
//   { name: 'Bob', age: 30, department: 'IT' },
//   { name: 'John', age: 30, department: 'IT' }
// ]

// Sort with custom comparator for multi-key
console.log(sortBy(employees, ['age', 'name'], (a, b, objA, objB, keyIndex) => {
  // Reverse sort for age (first key), normal sort for name (second key)
  return keyIndex === 0 ? b - a : String(a).localeCompare(String(b));
}));

function groupBy(array, property)

import { groupBy } from '@semantic-ui/utils';

const people = [
  { name: 'John', age: 30 },
  { name: 'Jane', age: 25 },
  { name: 'Bob', age: 30 }
];
const grouped = groupBy(people, 'age');
console.log(grouped);
// {
//   '25': [{ name: 'Jane', age: 25 }],
//   '30': [{ name: 'John', age: 30 }, { name: 'Bob', age: 30 }]
// }

function intersection(...arrays)

import { intersection } from '@semantic-ui/utils';

const arr1 = [1, 2, 3, 4];
const arr2 = [3, 4, 5, 6];
const arr3 = [3, 4, 6, 7];
console.log(intersection(arr1, arr2, arr3)); // [3, 4]

function difference(...arrays)

import { difference } from '@semantic-ui/utils';

const arr1 = [1, 2, 3, 4];
const arr2 = [3, 4, 5, 6];
const arr3 = [3, 4, 6, 7];
console.log(difference(arr1, arr2, arr3)); // [1, 2]

function uniqueItems(...arrays)

import { uniqueItems } from '@semantic-ui/utils';

const arr1 = [1, 2, 3];
const arr2 = [2, 3, 4];
const arr3 = [3, 4, 5];
console.log(uniqueItems(arr1, arr2, arr3)); // [1, 5]