@oscarpalmer/atoms 0.192.0 → 0.193.1

package/src/array/get.ts

@@ -1,131 +0,0 @@
-import {isNonPlainObject} from '../internal/is';
-import type {NumericalKeys, PlainObject} from '../models';
-
-// #region Functions
-
-/**
- * Get an array from an object, where only values with numerical keys will be included
- *
- * @param value Object to convert to an array
- * @returns Array holding the values of the object's numerical keys
- *
- * @example
- * ```typescript
- * getArray({0: 'a', 1: 'b', 2: 'c', d: 'd'}, true); // => ['a', 'b', 'c']
- * getArray({a: 'a', b: 'b', c: 'c', d: 'd'}, true); // => []
- * ```
- */
-export function getArray<Value extends PlainObject>(
-	value: Value,
-	indiced: true,
-): Value[NumericalKeys<Value>][];
-
-/**
- * Get an array from a map
- *
- * @param value Map to convert to an array
- * @returns Array holding the entries of the map
- *
- * @example
- * ```typescript
- * getArray(
- *   new Map([['a', 1], ['b', 2], ['c', 3]]),
- * ); // => [['a', 1], ['b', 2], ['c', 3]]
- * ```
- */
-export function getArray<Key, Value>(map: Map<Key, Value>): [Key, Value][];
-
-/**
- * Get an array from an object
- *
- * @param value Object to convert to an array
- * @returns Array holding the values of the object
- *
- * @example
- * ```typescript
- * getArray({0: 'a', 1: 'b', 2: 'c', d: 'd'}); // => ['a', 'b', 'c', 'd']
- * getArray({a: 'a', b: 'b', c: 'c', d: 'd'}); // => ['a', 'b', 'c', 'd']
- * ```
- */
-export function getArray<Value extends PlainObject>(
-	value: Value,
-): [keyof Value, Value[keyof Value]][];
-
-/**
- * Get an array from a set
- *
- * @param value Set to convert to an array
- * @returns Array holding the values of the set
- *
- * @example
- * ```typescript
- * getArray(new Set([123, 456, 789])); // => [123, 456, 789]
- * ```
- */
-export function getArray<Value>(set: Set<Value>): Value[];
-
-/**
- * Get an array from a value
- *
- * @param value Original array
- * @returns Original array
- *
- * @example
- * ```typescript
- * getArray([123]); // => [123]
- * ```
- */
-export function getArray<Item>(value: Item[]): Item[];
-
-/**
- * Get an array from an unknown value
- *
- * @param value Value to convert to an array
- * @returns Array of value
- *
- * @example
- * ```typescript
- * getArray(123); // => [123]
- * ```
- */
-export function getArray<Value>(value: Value): Value[];
-
-export function getArray(value: unknown, indiced?: unknown): unknown[] {
-	if (Array.isArray(value)) {
-		return value;
-	}
-
-	if (value instanceof Map) {
-		return [...value.entries()];
-	}
-
-	if (value instanceof Set) {
-		return [...value.values()];
-	}
-
-	if (isNonPlainObject(value)) {
-		return [value];
-	}
-
-	if (indiced !== true) {
-		return Object.entries(value);
-	}
-
-	const keys = Object.keys(value);
-	const {length} = keys;
-
-	const array: unknown[] = [];
-
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		const asNumber = Number.parseInt(key, 10);
-
-		if (!Number.isNaN(asNumber)) {
-			array[asNumber] = (value as Record<string, unknown>)[key];
-		}
-	}
-
-	return array;
-}
-
-// #endregion

package/src/array/group-by.ts

@@ -1,369 +0,0 @@
-import {groupValues} from '../internal/array/group';
-import type {Key, KeyedValue, PlainObject, Simplify} from '../models';
-
-// #region Functions
-
-/**
- * Create a record from an array of items using a specific key and value
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to group
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   item => item,
- * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
- * ```
- */
-export function groupBy<
-	Item,
-	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
-	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
->(
-	array: Item[],
-	key: KeyCallback,
-	value: ValueCallback,
-): Simplify<Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>>>;
-
-/**
- * Create a record from an array of items using a specific key and value
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to group
- * @param key Callback to get an item's grouping key
- * @param value Key to use for value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   'id'
- * ); // => {10: 3, 20: 2}
- * ```
- */
-export function groupBy<
-	Item extends PlainObject,
-	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
-	ItemValue extends keyof Item,
->(
-	array: Item[],
-	key: KeyCallback,
-	value: ItemValue,
-): Record<ReturnType<KeyCallback>, Item[ItemValue]>;
-
-/**
- * Create a record from an array of items using a specific key and value
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @param value Callback to get an item's value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   item => item,
- * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
- * ```
- */
-export function groupBy<
-	Item extends PlainObject,
-	ItemKey extends keyof Item,
-	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
->(
-	array: Item[],
-	key: ItemKey,
-	value: ValueCallback,
-): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ValueCallback>>>;
-
-/**
- * Create a record from an array of items using a specific key and value
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id'
- * ); // => {10: 3, 20: 2}
- * ```
- */
-export function groupBy<
-	Item extends PlainObject,
-	ItemKey extends keyof Item,
-	ItemValue extends keyof Item,
->(
-	array: Item[],
-	key: ItemKey,
-	value: ItemValue,
-): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
-
-/**
- * Create a record from an array of items using a specific key
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to group
- * @param callback Callback to get an item's grouping key
- * @returns Record of keyed items
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
- * ```
- */
-export function groupBy<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(
-	array: Item[],
-	callback: Callback,
-): Record<ReturnType<Callback>, Item>;
-
-/**
- * Create a record from an array of items using a specific key
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @returns Record of keyed items
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
- * ```
- */
-export function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(
-	array: Item[],
-	key: ItemKey,
-): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
-
-/**
- * Create a record from an array of items _(using indices as keys)_
- *
- * @param array Array to group
- * @returns Record of indiced items
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- * ); // => {0: {id: 1, value: 10}, 1: {id: 2, value: 20}, 2: {id: 3, value: 10}}
- * ```
- */
-export function groupBy<Item>(array: Item[]): Record<number, Item>;
-
-export function groupBy(array: unknown[], first?: unknown, second?: unknown): unknown {
-	return groupValues(array, first, second, false);
-}
-
-groupBy.arrays = groupArraysBy;
-
-/**
- * Create a record from an array of items using a specific key and value, grouping values into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   item => item,
- * ); // => {
- *    //   10: [{id: 1, value: 10}, {id: 3, value: 10}],
- *    //   20: [{id: 2, value: 20}],
- *    // }
- * ```
- */
-export function groupArraysBy<
-	Item,
-	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
-	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
->(
-	array: Item[],
-	key: KeyCallback,
-	value: ValueCallback,
-): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
-
-/**
- * Create a record from an array of items using a specific key and value, grouping values into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param key Callback to get an item's grouping key
- * @param value Key to use for value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   'id',
- * ); // => {
- *    //   10: [1, 3],
- *    //   20: [2],
- *    // }
- * ```
- */
-export function groupArraysBy<
-	Item extends PlainObject,
-	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
-	ItemValue extends keyof Item,
->(
-	array: Item[],
-	key: KeyCallback,
-	value: ItemValue,
-): Record<ReturnType<KeyCallback>, Item[ItemValue][]>;
-
-/**
- * Create a record from an array of items using a specific key and value, grouping values into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @param value Callback to get an item's value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   item => item,
- * ); // => {
- *    //   10: [{id: 1, value: 10}, {id: 3, value: 10}],
- *    //   20: [{id: 2, value: 20}],
- *    // }
- * ```
- */
-export function groupArraysBy<
-	Item extends PlainObject,
-	ItemKey extends keyof Item,
-	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
->(
-	array: Item[],
-	key: ItemKey,
-	value: ValueCallback,
-): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ValueCallback>[]>>;
-
-/**
- * Create a record from an array of items using a specific key and value, grouping values into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id',
- * ); // => {
- *    //   10: [1, 3],
- *    //   20: [2],
- *    // }
- * ```
- */
-export function groupArraysBy<
-	Item extends PlainObject,
-	ItemKey extends keyof Item,
-	ItemValue extends keyof Item,
->(
-	array: Item[],
-	key: ItemKey,
-	value: ItemValue,
-): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue][]>>;
-
-/**
- * Create a record from an array of items using a specific key, grouping items into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param callback Callback to get an item's grouping key
- * @returns Record of keyed items
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- * ); // => {
- *    //   10: [{id: 1, value: 10}, {id: 3, value: 10}],
- *    //   20: [{id: 2, value: 20}],
- *    // }
- * ```
- */
-export function groupArraysBy<
-	Item,
-	Callback extends (item: Item, index: number, array: Item[]) => Key,
->(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
-
-/**
- * Create a record from an array of items using a specific key, grouping items into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @returns Record of keyed items
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => {
- *    //   10: [{id: 1, value: 10}, {id: 3, value: 10}],
- *    //   20: [{id: 2, value: 20}],
- *    // }
- * ```
- */
-export function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item>(
-	array: Item[],
-	key: ItemKey,
-): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
-
-export function groupArraysBy(array: unknown[], first?: unknown, second?: unknown): unknown {
-	return groupValues(array, first, second, true);
-}
-
-// #endregion

package/src/array/index.ts

@@ -1,26 +0,0 @@
-export * from '../internal/array/chunk';
-export * from '../internal/array/compact';
-export * from '../internal/array/index-of';
-export * from '../internal/array/shuffle';
-
-export * from './difference';
-export * from './exists';
-export * from './find';
-export * from './flatten';
-export * from './from';
-export * from './get';
-export * from './insert';
-export * from './intersection';
-export * from './partition';
-export * from './match';
-export * from './push';
-export * from './reverse';
-export * from './select';
-export * from './single';
-export * from './slice';
-export * from './splice';
-export * from './to-set';
-export * from './toggle';
-export * from './union';
-export * from './unique';
-export * from './update';

package/src/array/insert.ts

@@ -1,52 +0,0 @@
-import {INSERT_TYPE_INSERT, insertValues} from '../internal/array/insert';
-
-// #region Functions
-
-/**
- * Insert items into an array at a specified index
- *
- * _(Uses chunking to avoid call stack size being exceeded)_
- *
- * @param array Original array
- * @param index Index to insert at
- * @param items Inserted items
- * @returns Updated array
- *
- * @example
- * ```typescript
- * insert([1, 2, 3], 1, [4, 5]); // => [1, 4, 5, 2, 3]
- * ```
- */
-export function insert<Item>(array: Item[], index: number, items: Item[]): Item[];
-
-/**
- * Insert items into an array _(at the end)_
- *
- * _(Uses chunking to avoid call stack size being exceeded)_
- *
- * @param array Original array
- * @param items Inserted items
- * @returns Updated array
- *
- * @example
- * ```typescript
- * insert([1, 2, 3], [4, 5]); // => [1, 2, 3, 4, 5]
- * ```
- */
-export function insert<Item>(array: Item[], items: Item[]): Item[];
-
-export function insert(
-	array: unknown[],
-	indexOrItems: number | unknown[],
-	items?: unknown[],
-): unknown[] {
-	return insertValues(
-		INSERT_TYPE_INSERT,
-		array,
-		items == null ? indexOrItems : items,
-		typeof indexOrItems === 'number' ? indexOrItems : array?.length,
-		0,
-	) as unknown[];
-}
-
-// #endregion

package/src/array/intersection.ts

@@ -1,72 +0,0 @@
-import {COMPARE_SETS_INTERSECTION, compareSets} from '../internal/array/sets';
-
-// #region Functions
-
-/**
- * Get the common values between two arrays
- *
- * @param first First array
- * @param second Second array
- * @param callback Callback to get an item's value for comparison
- * @returns Common values from both arrays
- *
- * @example
- * ```typescript
- * intersection(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   [{id: 2}, {id: 3}, {id: 4}],
- *   item => item.id,
- * ); // => [{id: 2}, {id: 3}]
- * ```
- */
-export function intersection<First, Second>(
-	first: First[],
-	second: Second[],
-	callback: (item: First | Second) => unknown,
-): First[];
-
-/**
- * Get the common values between two arrays
- *
- * @param first First array
- * @param second Second array
- * @param key Key to get an item's value for comparison
- * @returns Common values from both arrays
- *
- * @example
- * ```typescript
- * intersection(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   [{id: 2}, {id: 3}, {id: 4}],
- *   'id',
- * ); // => [{id: 2}, {id: 3}]
- * ```
- */
-export function intersection<
-	First extends Record<string, unknown>,
-	Second extends Record<string, unknown>,
-	SharedKey extends keyof First & keyof Second,
->(first: First[], second: Second[], key: SharedKey): First[];
-
-/**
- * Get the common values between two arrays
- *
- * @param first First array
- * @param second Second array
- * @returns Common values from both arrays
- *
- * @example
- * ```typescript
- * intersection(
- *   [1, 2, 3],
- *   [2, 3, 4],
- * ); // => [2, 3]
- * ```
- */
-export function intersection<First, Second>(first: First[], second: Second[]): First[];
-
-export function intersection(first: unknown[], second: unknown[], key?: unknown): unknown[] {
-	return compareSets(COMPARE_SETS_INTERSECTION, first, second, key);
-}
-
-// #endregion