@oscarpalmer/atoms 0.78.0 → 0.80.0

package/src/array/sort.ts

@@ -1,7 +1,7 @@
-import type {SortKey, SortKeyWithCallback} from '~/array/models';
-import {isKey} from '~/is';
-import type {Key, PlainObject} from '~/models';
-import {compare} from '~/value/compare';
+import {isKey} from '../is';
+import type {Key, PlainObject} from '../models';
+import {compare} from '../value/compare';
+import type {SortKey, SortKeyWithCallback} from './models';
 
 /**
  * Sort an array of items _(defaults to ascending)_
@@ -57,13 +57,7 @@ export function sort(
 		return array;
 	}
 
-	if (first == null || typeof first === 'boolean') {
-		return first === true
-			? (array as never[]).sort((first, second) => second - first)
-			: array.sort();
-	}
-
-	const direction = second === true ? 'desc' : 'asc';
+	const direction = first === true || second === true ? 'desc' : 'asc';
 
 	const keys = (Array.isArray(first) ? first : [first])
 		.map(key => {
@@ -92,9 +86,11 @@ export function sort(
 	const {length} = keys;
 
 	if (length === 0) {
-		return direction === 'asc'
-			? array.sort()
-			: (array as never[]).sort((first, second) => second - first);
+		return array.sort(
+			(first, second) =>
+				compare(first as never, second as never) *
+				(direction === 'asc' ? 1 : -1),
+		);
 	}
 
 	if (length === 1) {
@@ -109,12 +105,9 @@ export function sort(
 		for (let index = 0; index < length; index += 1) {
 			const {callback, direction} = keys[index];
 
-			const descending = direction === 'desc';
-
-			const compared = compare(
-				callback(descending ? second : first),
-				callback(descending ? first : second),
-			);
+			const compared =
+				compare(callback(first), callback(second)) *
+				(direction === 'asc' ? 1 : -1);
 
 			if (compared !== 0) {
 				return compared;

package/src/array/splice.ts

@@ -1,4 +1,4 @@
-import {insertValues} from '~/array/insert';
+import {insertValues} from './insert';
 
 /**
  * Removes and returns all items from an array starting from a specific index

package/src/array/to-map.ts

@@ -1,5 +1,5 @@
-import {getCallbacks} from '~/internal/array/callbacks';
-import type {Key, PlainObject} from '~/models';
+import {getCallbacks} from '../internal/array/callbacks';
+import type {Key, PlainObject} from '../models';
 
 /**
  * Create a map from an array of items _(using their indices as keys)_

package/src/array/to-record.ts

@@ -1,6 +1,6 @@
 import type {Simplify} from 'type-fest';
-import {groupValues} from '~/array/group-by';
-import type {Key, KeyedValue, PlainObject} from '~/models';
+import {groupValues} from '../array/group-by';
+import type {Key, KeyedValue, PlainObject} from '../models';
 
 /**
  * Create a record from an array of items _(using their indices as keys)_
@@ -11,18 +11,18 @@ export function toRecord<Item>(array: Item[]): Record<number, Item>;
  * Create a record from an array of items using a specific key
  */
 export function toRecord<Item extends PlainObject, ItemKey extends keyof Item>(
-		array: Item[],
-		key: ItemKey,
-	): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
+	array: Item[],
+	key: ItemKey,
+): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
 
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
 export function toRecord<Item extends PlainObject, ItemKey extends keyof Item>(
-		array: Item[],
-		key: ItemKey,
-		arrays: true,
-	): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
+	array: Item[],
+	key: ItemKey,
+	arrays: true,
+): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 
 /**
  * Create a record from an array of items using a specific key
@@ -48,82 +48,82 @@ export function toRecord<
  * Create a record from an array of items using a specific key and value
  */
 export function toRecord<
-		Item extends PlainObject,
-		ItemKey extends keyof Item,
-		ItemValue extends keyof Item,
-	>(
-		array: Item[],
-		key: ItemKey,
-		value: ItemValue,
-	): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
+	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 and value, and grouping them into arrays
  */
 export function toRecord<
-		Item extends PlainObject,
-		ItemKey extends keyof Item,
-		ItemValue extends keyof Item,
-	>(
-		array: Item[],
-		key: ItemKey,
-		value: ItemValue,
-		arrays: true,
-	): Simplify<Record<KeyedValue<Item, ItemKey>, Array<Item[ItemValue]>>>;
+	Item extends PlainObject,
+	ItemKey extends keyof Item,
+	ItemValue extends keyof Item,
+>(
+	array: Item[],
+	key: ItemKey,
+	value: ItemValue,
+	arrays: true,
+): Simplify<Record<KeyedValue<Item, ItemKey>, Array<Item[ItemValue]>>>;
 
 /**
  * Create a record from an array of items using a specific key and value
  */
 export function toRecord<
-		Item extends PlainObject,
-		ItemKey extends keyof Item,
-		ItemValue extends (item: Item, index: number, array: Item[]) => unknown,
-	>(
-		array: Item[],
-		key: ItemKey,
-		value: ItemValue,
-	): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>>;
+	Item extends PlainObject,
+	ItemKey extends keyof Item,
+	ItemValue extends (item: Item, index: number, array: Item[]) => unknown,
+>(
+	array: Item[],
+	key: ItemKey,
+	value: ItemValue,
+): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>>;
 
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
 export function toRecord<
-		Item extends PlainObject,
-		ItemKey extends keyof Item,
-		ItemValue extends (item: Item, index: number, array: Item[]) => unknown,
-	>(
-		array: Item[],
-		key: ItemKey,
-		value: ItemValue,
-		arrays: true,
-	): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>>;
+	Item extends PlainObject,
+	ItemKey extends keyof Item,
+	ItemValue extends (item: Item, index: number, array: Item[]) => unknown,
+>(
+	array: Item[],
+	key: ItemKey,
+	value: ItemValue,
+	arrays: true,
+): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>>;
 
 /**
  * Create a record from an array of items using a specific key and value
  */
 export function toRecord<
-		Item extends PlainObject,
-		ItemKey extends (item: Item, index: number, array: Item[]) => Key,
-		ItemValue extends keyof Item,
-	>(
-		array: Item[],
-		key: ItemKey,
-		value: ItemValue,
-	): Record<ReturnType<ItemKey>, Item[ItemValue]>;
+	Item extends PlainObject,
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+	ItemValue extends keyof Item,
+>(
+	array: Item[],
+	key: ItemKey,
+	value: ItemValue,
+): Record<ReturnType<ItemKey>, Item[ItemValue]>;
 
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
 export function toRecord<
-		Item extends PlainObject,
-		ItemKey extends (item: Item, index: number, array: Item[]) => Key,
-		ItemValue extends keyof Item,
-	>(
-		array: Item[],
-		key: ItemKey,
-		value: ItemValue,
-		arrays: true,
-	): Record<ReturnType<ItemKey>, Array<Item[ItemValue]>>;
+	Item extends PlainObject,
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+	ItemValue extends keyof Item,
+>(
+	array: Item[],
+	key: ItemKey,
+	value: ItemValue,
+	arrays: true,
+): Record<ReturnType<ItemKey>, Array<Item[ItemValue]>>;
 
 /**
  * Create a record from an array of items using a specific key and value

package/src/array/unique.ts

@@ -1,5 +1,5 @@
-import {findValues} from '~/internal/array/find';
-import type {Key, PlainObject} from '~/models';
+import {findValues} from '../internal/array/find';
+import type {Key, PlainObject} from '../models';
 
 /**
  * Get an array of unique items
@@ -20,9 +20,9 @@ export function unique<Item extends PlainObject, ItemKey extends keyof Item>(
  * - Use `key` to find a comparison value for an item
  */
 export function unique<
-		Item,
-		ItemKey extends (item: Item, index: number, array: Item[]) => Key,
-	>(array: Item[], key: ItemKey): Item[];
+	Item,
+	ItemKey extends (item: Item, index: number, array: Item[]) => Key,
+>(array: Item[], key: ItemKey): Item[];
 
 export function unique(array: unknown[], key?: unknown): unknown[] {
 	return findValues('unique', array, [key, undefined]);

package/src/colour/base.ts

@@ -1,8 +1,44 @@
-import type {HexColour} from '~/colour/hex';
-import {isColourValue} from '~/colour/is';
+import type {HexColour} from './hex';
+import type {HSLColourValue} from './hsl';
+import {isColourValue} from './is';
+import type {RGBColourValue} from './rgb';
+
+type Defaults = {
+	hsl: HSLColourValue;
+	rgb: RGBColourValue;
+};
+
+type Properties = {
+	hsl: Array<keyof HSLColourValue>;
+	rgb: Array<keyof RGBColourValue>;
+};
+
+const defaults: Defaults = {
+	hsl: {
+		hue: 0,
+		lightness: 0,
+		saturation: 0,
+	},
+	rgb: {
+		blue: 0,
+		green: 0,
+		red: 0,
+	},
+};
+
+const properties: Properties = {
+	hsl: ['hue', 'lightness', 'saturation'],
+	rgb: ['blue', 'green', 'red'],
+};
+
+function getValue<Model>(value: Model, type: keyof Properties): Model {
+	return (
+		isColourValue(value, properties[type]) ? {...value} : {...defaults[type]}
+	) as Model;
+}
 
 export abstract class Colour<Model> {
-	private declare readonly $colour: string;
+	private declare readonly $colour: keyof Properties;
 	protected declare readonly state: ColourState<Model>;
 
 	/**
@@ -12,18 +48,18 @@ export abstract class Colour<Model> {
 		return {...this.state.value};
 	}
 
-	constructor(
-		type: string,
-		value: Model,
-		defaults: Model,
-		properties: Array<keyof Model>,
-	) {
+	/**
+	 * Set the current value of the colour
+	 */
+	set value(value: Model) {
+		this.state.value = getValue(value, this.$colour);
+	}
+
+	constructor(type: keyof Properties, value: Model) {
 		this.$colour = type;
 
 		this.state = {
-			value: isColourValue<Model>(value, properties)
-				? {...value}
-				: {...defaults},
+			value: getValue(value, type),
 		};
 	}
 

package/src/colour/functions.ts

@@ -1,7 +1,7 @@
-import {HexColour} from '~/colour/hex';
-import {HSLColour, type HSLColourValue} from '~/colour/hsl';
-import {RGBColour, type RGBColourValue} from '~/colour/rgb';
-import {clamp} from '~/number';
+import {clamp} from '../number';
+import {HexColour} from './hex';
+import {HSLColour, type HSLColourValue} from './hsl';
+import {RGBColour, type RGBColourValue} from './rgb';
 
 export const anyPattern = /^#*([a-f0-9]{3}){1,2}$/i;
 const groupedPattern = /^#*([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})$/i;

package/src/colour/hex.ts

@@ -1,6 +1,6 @@
-import {anyPattern, getNormalisedHex, hexToRgb} from '~/colour/functions';
-import type {HSLColour} from '~/colour/hsl';
-import type {RGBColour} from '~/colour/rgb';
+import {anyPattern, getNormalisedHex, hexToRgb} from './functions';
+import type {HSLColour} from './hsl';
+import type {RGBColour} from './rgb';
 
 type State = {
 	value: string;

package/src/colour/hsl.ts

@@ -1,8 +1,8 @@
-import {Colour} from '~/colour/base';
-import {hslToRgb} from '~/colour/functions';
-import type {HexColour} from '~/colour/hex';
-import type {RGBColour} from '~/colour/rgb';
-import {clamp} from '~/number';
+import {clamp} from '../number';
+import {Colour} from './base';
+import {hslToRgb} from './functions';
+import type {HexColour} from './hex';
+import type {RGBColour} from './rgb';
 
 export type HSLColourValue = {
 	hue: number;
@@ -54,7 +54,7 @@ export class HSLColour extends Colour<HSLColourValue> {
 	}
 
 	constructor(value: HSLColourValue) {
-		super('hsl', value, defaults, properties);
+		super('hsl', value);
 	}
 
 	/**
@@ -86,18 +86,6 @@ export class HSLColour extends Colour<HSLColourValue> {
 	}
 }
 
-const defaults: HSLColourValue = {
-	hue: 0,
-	lightness: 0,
-	saturation: 0,
-};
-
-const properties: Array<keyof HSLColourValue> = [
-	'hue',
-	'lightness',
-	'saturation',
-];
-
 /**
  * Get an HSL-colour from a value-object
  */

package/src/colour/index.ts

@@ -1,4 +1,4 @@
-import type {RGBColourValue} from '~/colour/rgb';
+import type {RGBColourValue} from './rgb';
 
 /**
  * Get a foreground colour _(usually text)_ based on a background colour's luminance
@@ -21,6 +21,7 @@ export function getForegroundColour(value: RGBColourValue): string {
 	return luminance > 0.625 ? 'black' : 'white';
 }
 
+export {hexToRgb, hslToRgb, rgbToHex, rgbToHsl} from './functions';
 export {getHexColour, HexColour} from './hex';
 export {getHSLColour, HSLColour, type HSLColourValue} from './hsl';
 export {isColour, isHexColour, isHSLColour, isRGBColour} from './is';

package/src/colour/is.ts

@@ -1,6 +1,6 @@
-import type {HexColour} from '~/colour/hex';
-import type {HSLColour} from '~/colour/hsl';
-import type {RGBColour} from '~/colour/rgb';
+import type {HexColour} from './hex';
+import type {HSLColour} from './hsl';
+import type {RGBColour} from './rgb';
 
 /**
  * Is the value a colour?
@@ -11,10 +11,7 @@ export function isColour(
 	return isInstance(/^(hex|hsl|rgb)$/, value);
 }
 
-export function isColourValue<Expected>(
-	value: unknown,
-	properties: Array<keyof Expected>,
-): value is Expected {
+export function isColourValue(value: unknown, properties: string[]): boolean {
 	return (
 		typeof value === 'object' &&
 		value !== null &&

package/src/colour/rgb.ts

@@ -1,8 +1,8 @@
-import {Colour} from '~/colour/base';
-import {rgbToHex, rgbToHsl} from '~/colour/functions';
-import type {HexColour} from '~/colour/hex';
-import type {HSLColour} from '~/colour/hsl';
-import {clamp} from '~/number';
+import {clamp} from '../number';
+import {Colour} from './base';
+import {rgbToHex, rgbToHsl} from './functions';
+import type {HexColour} from './hex';
+import type {HSLColour} from './hsl';
 
 export type RGBColourValue = {
 	blue: number;
@@ -54,7 +54,7 @@ export class RGBColour extends Colour<RGBColourValue> {
 	}
 
 	constructor(value: RGBColourValue) {
-		super('rgb', value, defaults, properties);
+		super('rgb', value);
 	}
 
 	/**
@@ -93,14 +93,6 @@ export class RGBColour extends Colour<RGBColourValue> {
 	}
 }
 
-const defaults: RGBColourValue = {
-	blue: 0,
-	green: 0,
-	red: 0,
-};
-
-const properties: Array<keyof RGBColourValue> = ['blue', 'green', 'red'];
-
 /**
  * Get an RGB-colour from a value-object
  */

package/src/emitter.ts

@@ -1,4 +1,4 @@
-import {noop} from '~/function';
+import {noop} from './function';
 
 class Emitter<Value> {
 	private declare readonly state: EmitterState<Value>;

package/src/function.ts

@@ -1,5 +1,5 @@
-import type {GenericCallback} from '~/models';
-import {clamp} from '~/number';
+import type {GenericCallback} from './models';
+import {clamp} from './number';
 
 type Debounced<Callback extends GenericCallback> = Callback & {
 	/**

package/src/index.ts

@@ -1,16 +1,16 @@
-export * from '~/array/index';
-export * from '~/colour/index';
-export * from '~/emitter';
-export * from '~/function';
-export * from '~/is';
-export * from '~/logger';
-export * from '~/math';
-export * from '~/models';
-export * from '~/number';
-export * from '~/query';
-export * from '~/queue';
-export * from '~/random';
-export * from '~/sized';
-export * from '~/string/index';
-export * from '~/touch';
-export * from '~/value/index';
+export * from './array/index';
+export * from './colour/index';
+export * from './emitter';
+export * from './function';
+export * from './is';
+export * from './logger';
+export * from './math';
+export * from './models';
+export * from './number';
+export * from './query';
+export * from './queue';
+export * from './random';
+export * from './sized';
+export * from './string/index';
+export * from './touch';
+export * from './value/index';

package/src/internal/array/callbacks.ts

@@ -1,5 +1,5 @@
-import type {Callbacks} from '~/array/models';
-import type {GenericCallback, PlainObject} from '~/models';
+import type {Callbacks} from '../../array/models';
+import type {GenericCallback, PlainObject} from '../../models';
 
 function getCallback(value: unknown): GenericCallback | undefined {
 	switch (typeof value) {

package/src/internal/array/find.ts

@@ -1,5 +1,5 @@
-import type {FindType} from '~/array/models';
-import {getCallbacks} from '~/internal/array/callbacks';
+import type {FindType} from '../../array/models';
+import {getCallbacks} from './callbacks';
 
 type Parameters = {
 	bool?: unknown;
@@ -18,7 +18,7 @@ export function findValue(
 
 	if (callbacks?.bool == null && callbacks?.key == null) {
 		return type === 'index'
-			? array.findIndex(item => item === value)
+			? array.indexOf(value)
 			: array.find(item => item === value);
 	}
 
@@ -64,25 +64,24 @@ export function findValues(
 		return array.filter(item => item === value);
 	}
 
+	const keys = new Set();
 	const result: unknown[] = [];
-	const values: unknown[] = callbacks?.key != null ? [] : result;
 
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
-		const keyed = callbacks?.key?.(item, index, array) ?? item;
+		const key = callbacks?.key?.(item, index, array) ?? item;
 
 		if (
-			(type === 'all' && keyed === value) ||
-			(type === 'unique' && values.indexOf(keyed) === -1)
+			(type === 'all' && key === value) ||
+			(type === 'unique' && !keys.has(key))
 		) {
-			if (values !== result) {
-				values.push(keyed);
-			}
-
+			keys.add(key);
 			result.push(item);
 		}
 	}
 
+	keys.clear();
+
 	return result;
 }
 

package/src/internal/value/handle.ts

@@ -1,4 +1,4 @@
-import type {ArrayOrPlainObject, PlainObject} from '~/models';
+import type {ArrayOrPlainObject, PlainObject} from '../../models';
 
 function findKey(
 	needle: string,

package/src/is.ts

@@ -1,5 +1,5 @@
-import type {ArrayOrPlainObject, Key, PlainObject, Primitive} from '~/models';
-import {getString} from '~/string';
+import type {ArrayOrPlainObject, Key, PlainObject, Primitive} from './models';
+import {getString} from './string/index';
 
 /**
  * Is the value an array or a record?

package/src/logger.ts

@@ -1,4 +1,4 @@
-import {noop} from '~/function';
+import {noop} from './function';
 
 declare global {
 	var _atomic_logging: boolean;

package/src/query.ts

@@ -1,7 +1,7 @@
-import {isPlainObject} from '~/is';
-import type {ArrayOrPlainObject, PlainObject} from '~/models';
-import {join} from '~/string';
-import {setValue} from '~/value';
+import {isPlainObject} from './is';
+import type {ArrayOrPlainObject, PlainObject} from './models';
+import {join} from './string/index';
+import {setValue} from './value/set';
 
 /**
  * Convert a query string to a plain _(nested)_ object

package/src/random.ts

@@ -1,4 +1,4 @@
-import {shuffle} from '~/array/shuffle';
+import {shuffle} from './array/shuffle';
 
 /**
  * Get a random boolean

package/src/sized.ts

@@ -1,4 +1,4 @@
-import {clamp} from '~/number';
+import {clamp} from './number';
 
 /**
  * A Map with a maximum size

package/src/string/case.ts

@@ -1,4 +1,4 @@
-import {words} from '~/string/index';
+import {words} from './index';
 
 /**
  * Convert a string to camel case _(thisIsCamelCase)_

package/src/string/index.ts

@@ -1,4 +1,4 @@
-import {compact} from '~/array';
+import {compact} from '../array/compact';
 
 /**
  * Create a new UUID
@@ -91,3 +91,4 @@ export function words(value: string): string[] {
 
 export * from './case';
 export * from './template';
+