@oscarpalmer/atoms 0.78.0 → 0.80.0

package/src/string/template.ts

@@ -1,6 +1,6 @@
-import type {PlainObject} from '~/models';
-import {getString} from '~/string/index';
-import {getValue} from '~/value/get';
+import type {PlainObject} from '../models';
+import {getString} from '../string/index';
+import {getValue} from '../value/get';
 
 type Options = {
 	/**

package/src/value/clone.ts

@@ -1,5 +1,5 @@
-import {isArrayOrPlainObject} from '~/is';
-import type {ArrayOrPlainObject, GenericCallback, PlainObject} from '~/models';
+import {isArrayOrPlainObject} from '../is';
+import type {ArrayOrPlainObject, PlainObject} from '../models';
 
 /**
  * Clone any kind of value _(deeply, if needed)_
@@ -46,7 +46,7 @@ export function clone(value: unknown) {
 			return cloneRegularExpression(value);
 
 		case isArrayOrPlainObject(value):
-			return cloneObject(value);
+			return cloneObject(value as ArrayOrPlainObject);
 
 		default:
 			return structuredClone(value);

package/src/value/compare.ts

@@ -1,6 +1,6 @@
-import {max} from '~/math';
-import {getNumber} from '~/number';
-import {words, getString, join} from '~/string';
+import {max} from '../math';
+import {getNumber} from '../number';
+import {getString, join, words} from '../string/index';
 
 /**
  * Compare two values _(for sorting purposes)_

package/src/value/diff.ts

@@ -1,7 +1,7 @@
-import {isArrayOrPlainObject} from '~/is';
-import type {ArrayOrPlainObject, Key, PlainObject} from '~/models';
-import {join} from '~/string/index';
-import {equal} from '~/value/equal';
+import {isArrayOrPlainObject} from '../is';
+import type {ArrayOrPlainObject, Key, PlainObject} from '../models';
+import {join} from '../string/index';
+import {equal} from '../value/equal';
 
 export type DiffType = 'full' | 'none' | 'partial';
 

package/src/value/equal.ts

@@ -1,5 +1,5 @@
-import {isPlainObject} from '~/is';
-import type {ArrayOrPlainObject, PlainObject} from '~/models';
+import {isPlainObject} from '../is';
+import type {ArrayOrPlainObject, PlainObject} from '../models';
 
 /**
  * Are two strings equal? _(Case-sensitive by default)_
@@ -54,7 +54,10 @@ export function equal(
 
 		case Array.isArray(first) && Array.isArray(second):
 		case isPlainObject(first) && isPlainObject(second):
-			return equalObject(first, second);
+			return equalObject(
+				first as ArrayOrPlainObject,
+				second as ArrayOrPlainObject,
+			);
 
 		case typeof first === 'string' && ignoreCase === true:
 			return Object.is(first.toLowerCase(), (second as string).toLowerCase());

package/src/value/get.ts

@@ -1,6 +1,6 @@
 import type {ToString} from 'type-fest/source/internal/string';
-import {handleValue} from '~/internal/value/handle';
-import type {ArrayOrPlainObject, Get, Paths} from '~/models';
+import {handleValue} from '../internal/value/handle';
+import type {ArrayOrPlainObject, Get, Paths} from '../models';
 
 /**
  * - Get the value from an object using a known path

package/src/value/index.ts

@@ -1,4 +1,4 @@
-import type {PlainObject} from '~/models';
+import type {PlainObject} from '../models';
 
 /**
  * Create a new object with only the specified keys
@@ -28,3 +28,4 @@ export * from './merge';
 export * from './set';
 export * from './smush';
 export * from './unsmush';
+

package/src/value/merge.ts

@@ -1,5 +1,5 @@
-import {isArrayOrPlainObject} from '~/is';
-import type {ArrayOrPlainObject, PlainObject} from '~/models';
+import {isArrayOrPlainObject} from '../is';
+import type {ArrayOrPlainObject, PlainObject} from '../models';
 
 type MergeOptions = {
 	/**

package/src/value/set.ts

@@ -1,5 +1,5 @@
-import {handleValue} from '~/internal/value/handle';
-import type {ArrayOrPlainObject, Paths, PlainObject} from '~/models';
+import {handleValue} from '../internal/value/handle';
+import type {ArrayOrPlainObject, Paths, PlainObject} from '../models';
 
 /**
  * - Set the value in an object using a known path

package/src/value/smush.ts

@@ -1,8 +1,8 @@
 import type {Get, Paths, Simplify} from 'type-fest';
 import type {ToString} from 'type-fest/source/internal/string';
-import {isArrayOrPlainObject} from '~/is';
-import type {ArrayOrPlainObject, PlainObject} from '~/models';
-import {join} from '~/string/index';
+import {isArrayOrPlainObject} from '../is';
+import type {ArrayOrPlainObject, PlainObject} from '../models';
+import {join} from '../string/index';
 
 type Smushed<Value> = Simplify<{
 	[Key in Paths<Value>]: Get<Value, ToString<Key>>;

package/src/value/unsmush.ts

@@ -1,7 +1,7 @@
 import type {KeysOfUnion, Simplify} from 'type-fest';
-import {isArrayOrPlainObject} from '~/is';
-import type {PlainObject} from '~/models';
-import {setValue} from '~/value/set';
+import {isArrayOrPlainObject} from '../is';
+import type {PlainObject} from '../models';
+import {setValue} from '../value/set';
 
 type Unsmushed<Value extends PlainObject> = Simplify<
 	Omit<

package/types/array/count.d.ts

@@ -1,4 +1,4 @@
-import type { Key, PlainObject } from '~/models';
+import type { Key, PlainObject } from '../models';
 /**
  * Get the number of items _(count)_ that match the given value
  */

package/types/array/exists.d.ts

@@ -1,4 +1,4 @@
-import type { Key, PlainObject } from '~/models';
+import type { Key, PlainObject } from '../models';
 /**
  * Does the value exist in array?
  */

package/types/array/filter.d.ts

@@ -1,4 +1,4 @@
-import type { Key, PlainObject } from '~/models';
+import type { Key, PlainObject } from '../models';
 /**
  * Get a filtered array of items matching `value`
  */

package/types/array/find.d.ts

@@ -1,4 +1,4 @@
-import type { Key, PlainObject } from '~/models';
+import type { Key, PlainObject } from '../models';
 /**
  * Get the first item matching `value` _(or `undefined` if no match is found)_
  */

package/types/array/group-by.d.ts

@@ -1,5 +1,5 @@
 import type { Simplify } from 'type-fest';
-import type { Key, KeyedValue, PlainObject } from '~/models';
+import type { Key, KeyedValue, PlainObject } from '../models';
 /**
  * Create a record from an array of items using a specific key
  */

package/types/array/index-of.d.ts

@@ -1,4 +1,4 @@
-import type { Key, PlainObject } from '~/models';
+import type { Key, PlainObject } from '../models';
 /**
  * Get the index for the first item matching `value` _(or `-1` if no match is found)_
  */

package/types/array/index.d.ts

@@ -1,4 +1,4 @@
-import type { NestedArrayType } from '~/models';
+import type { NestedArrayType } from '../models';
 /**
  * Flatten an array _(using native `flat` and maximum depth)_
  */

package/types/array/insert.d.ts

@@ -1,4 +1,4 @@
-import type { InsertType } from '~/array/models';
+import type { InsertType } from './models';
 /**
  * - Insert values into an array _(at the end)_
  * - _(Uses chunking to avoid stack overflow_)

package/types/array/models.d.ts

@@ -1,4 +1,4 @@
-import type { GenericCallback, Key } from '~/models';
+import type { GenericCallback, Key } from '../models';
 export type Callbacks = {
     bool?: GenericCallback;
     key?: GenericCallback;

package/types/array/sort.d.ts

@@ -1,5 +1,5 @@
-import type { SortKey } from '~/array/models';
-import type { Key, PlainObject } from '~/models';
+import type { Key, PlainObject } from '../models';
+import type { SortKey } from './models';
 /**
  * Sort an array of items _(defaults to ascending)_
  */

package/types/array/to-map.d.ts

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

package/types/array/to-record.d.ts

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

package/types/array/unique.d.ts

@@ -1,4 +1,4 @@
-import type { Key, PlainObject } from '~/models';
+import type { Key, PlainObject } from '../models';
 /**
  * Get an array of unique items
  */

package/types/colour/base.d.cts

@@ -77,6 +77,10 @@ declare class HexColour {
 	 */
 	static toRgb(value: string): RGBColour;
 }
+export type Properties = {
+	hsl: Array<keyof HSLColourValue>;
+	rgb: Array<keyof RGBColourValue>;
+};
 export declare abstract class Colour<Model> {
 	private readonly $colour;
 	protected readonly state: ColourState<Model>;
@@ -84,7 +88,11 @@ export declare abstract class Colour<Model> {
 	 * Get the current value of the colour
 	 */
 	get value(): Model;
-	constructor(type: string, value: Model, defaults: Model, properties: Array<keyof Model>);
+	/**
+	 * Set the current value of the colour
+	 */
+	set value(value: Model);
+	constructor(type: keyof Properties, value: Model);
 	/**
 	 * Convert the colour to a hex-colour
 	 */

package/types/colour/base.d.ts

@@ -1,4 +1,10 @@
-import type { HexColour } from '~/colour/hex';
+import type { HexColour } from './hex';
+import type { HSLColourValue } from './hsl';
+import type { RGBColourValue } from './rgb';
+type Properties = {
+    hsl: Array<keyof HSLColourValue>;
+    rgb: Array<keyof RGBColourValue>;
+};
 export declare abstract class Colour<Model> {
     private readonly $colour;
     protected readonly state: ColourState<Model>;
@@ -6,7 +12,11 @@ export declare abstract class Colour<Model> {
      * Get the current value of the colour
      */
     get value(): Model;
-    constructor(type: string, value: Model, defaults: Model, properties: Array<keyof Model>);
+    /**
+     * Set the current value of the colour
+     */
+    set value(value: Model);
+    constructor(type: keyof Properties, value: Model);
     /**
      * Convert the colour to a hex-colour
      */

package/types/colour/functions.d.cts

@@ -77,6 +77,10 @@ declare class HexColour {
 	 */
 	static toRgb(value: string): RGBColour;
 }
+export type Properties = {
+	hsl: Array<keyof HSLColourValue>;
+	rgb: Array<keyof RGBColourValue>;
+};
 declare abstract class Colour<Model> {
 	private readonly $colour;
 	protected readonly state: ColourState<Model>;
@@ -84,7 +88,11 @@ declare abstract class Colour<Model> {
 	 * Get the current value of the colour
 	 */
 	get value(): Model;
-	constructor(type: string, value: Model, defaults: Model, properties: Array<keyof Model>);
+	/**
+	 * Set the current value of the colour
+	 */
+	set value(value: Model);
+	constructor(type: keyof Properties, value: Model);
 	/**
 	 * Convert the colour to a hex-colour
 	 */

package/types/colour/functions.d.ts

@@ -1,6 +1,6 @@
-import { HexColour } from '~/colour/hex';
-import { HSLColour, type HSLColourValue } from '~/colour/hsl';
-import { RGBColour, type RGBColourValue } from '~/colour/rgb';
+import { HexColour } from './hex';
+import { HSLColour, type HSLColourValue } from './hsl';
+import { RGBColour, type RGBColourValue } from './rgb';
 export declare const anyPattern: RegExp;
 export declare function getNormalisedHex(value: string): string;
 /**

package/types/colour/hex.d.cts

@@ -81,6 +81,10 @@ export declare class HexColour {
  * Get a hex-colour from a string
  */
 export declare function getHexColour(value: string): HexColour;
+export type Properties = {
+	hsl: Array<keyof HSLColourValue>;
+	rgb: Array<keyof RGBColourValue>;
+};
 declare abstract class Colour<Model> {
 	private readonly $colour;
 	protected readonly state: ColourState<Model>;
@@ -88,7 +92,11 @@ declare abstract class Colour<Model> {
 	 * Get the current value of the colour
 	 */
 	get value(): Model;
-	constructor(type: string, value: Model, defaults: Model, properties: Array<keyof Model>);
+	/**
+	 * Set the current value of the colour
+	 */
+	set value(value: Model);
+	constructor(type: keyof Properties, value: Model);
 	/**
 	 * Convert the colour to a hex-colour
 	 */

package/types/colour/hex.d.ts

@@ -1,5 +1,5 @@
-import type { HSLColour } from '~/colour/hsl';
-import type { RGBColour } from '~/colour/rgb';
+import type { HSLColour } from './hsl';
+import type { RGBColour } from './rgb';
 export declare class HexColour {
     private readonly $colour;
     private readonly state;

package/types/colour/hsl.d.cts

@@ -81,6 +81,10 @@ declare class HexColour {
 	 */
 	static toRgb(value: string): RGBColour;
 }
+export type Properties = {
+	hsl: Array<keyof HSLColourValue>;
+	rgb: Array<keyof RGBColourValue>;
+};
 declare abstract class Colour<Model> {
 	private readonly $colour;
 	protected readonly state: ColourState<Model>;
@@ -88,7 +92,11 @@ declare abstract class Colour<Model> {
 	 * Get the current value of the colour
 	 */
 	get value(): Model;
-	constructor(type: string, value: Model, defaults: Model, properties: Array<keyof Model>);
+	/**
+	 * Set the current value of the colour
+	 */
+	set value(value: Model);
+	constructor(type: keyof Properties, value: Model);
 	/**
 	 * Convert the colour to a hex-colour
 	 */

package/types/colour/hsl.d.ts

@@ -1,6 +1,6 @@
-import { Colour } from '~/colour/base';
-import type { HexColour } from '~/colour/hex';
-import type { RGBColour } from '~/colour/rgb';
+import { Colour } from './base';
+import type { HexColour } from './hex';
+import type { RGBColour } from './rgb';
 export type HSLColourValue = {
     hue: number;
     lightness: number;

package/types/colour/index.d.cts

@@ -85,6 +85,10 @@ export declare class HexColour {
  * Get a hex-colour from a string
  */
 export declare function getHexColour(value: string): HexColour;
+export type Properties = {
+	hsl: Array<keyof HSLColourValue>;
+	rgb: Array<keyof RGBColourValue>;
+};
 declare abstract class Colour<Model> {
 	private readonly $colour;
 	protected readonly state: ColourState<Model>;
@@ -92,7 +96,11 @@ declare abstract class Colour<Model> {
 	 * Get the current value of the colour
 	 */
 	get value(): Model;
-	constructor(type: string, value: Model, defaults: Model, properties: Array<keyof Model>);
+	/**
+	 * Set the current value of the colour
+	 */
+	set value(value: Model);
+	constructor(type: keyof Properties, value: Model);
 	/**
 	 * Convert the colour to a hex-colour
 	 */
@@ -161,6 +169,24 @@ export declare class RGBColour extends Colour<RGBColourValue> {
  * Get an RGB-colour from a value-object
  */
 export declare function getRGBColour(value: RGBColourValue): RGBColour;
+/**
+ * Convert a hex-colour to an RGB-colour
+ */
+export declare function hexToRgb(value: string): RGBColour;
+/**
+ * - Convert an HSL-colour to an RGB-colour
+ * - Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L61
+ */
+export declare function hslToRgb(value: HSLColourValue): RGBColour;
+/**
+ * Convert an RGB-colour to a hex-colour
+ */
+export declare function rgbToHex(value: RGBColourValue): HexColour;
+/**
+ * - Convert an RGB-colour to an HSL-colour
+ * - Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L26
+ */
+export declare function rgbToHsl(rgb: RGBColourValue): HSLColour;
 /**
  * Is the value a colour?
  */

package/types/colour/index.d.ts

@@ -1,8 +1,9 @@
-import type { RGBColourValue } from '~/colour/rgb';
+import type { RGBColourValue } from './rgb';
 /**
  * Get a foreground colour _(usually text)_ based on a background colour's luminance
  */
 export declare function getForegroundColour(value: RGBColourValue): string;
+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/types/colour/is.d.cts

@@ -77,6 +77,10 @@ declare class HexColour {
 	 */
 	static toRgb(value: string): RGBColour;
 }
+export type Properties = {
+	hsl: Array<keyof HSLColourValue>;
+	rgb: Array<keyof RGBColourValue>;
+};
 declare abstract class Colour<Model> {
 	private readonly $colour;
 	protected readonly state: ColourState<Model>;
@@ -84,7 +88,11 @@ declare abstract class Colour<Model> {
 	 * Get the current value of the colour
 	 */
 	get value(): Model;
-	constructor(type: string, value: Model, defaults: Model, properties: Array<keyof Model>);
+	/**
+	 * Set the current value of the colour
+	 */
+	set value(value: Model);
+	constructor(type: keyof Properties, value: Model);
 	/**
 	 * Convert the colour to a hex-colour
 	 */
@@ -153,7 +161,7 @@ declare class RGBColour extends Colour<RGBColourValue> {
  * Is the value a colour?
  */
 export declare function isColour(value: unknown): value is HexColour | HSLColour | RGBColour;
-export declare function isColourValue<Expected>(value: unknown, properties: Array<keyof Expected>): value is Expected;
+export declare function isColourValue(value: unknown, properties: string[]): boolean;
 /**
  * Is the value a hex-colour?
  */

package/types/colour/is.d.ts

@@ -1,11 +1,11 @@
-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?
  */
 export declare function isColour(value: unknown): value is HexColour | HSLColour | RGBColour;
-export declare function isColourValue<Expected>(value: unknown, properties: Array<keyof Expected>): value is Expected;
+export declare function isColourValue(value: unknown, properties: string[]): boolean;
 /**
  * Is the value a hex-colour?
  */

package/types/colour/rgb.d.cts

@@ -77,6 +77,10 @@ declare class HexColour {
 	 */
 	static toRgb(value: string): RGBColour;
 }
+export type Properties = {
+	hsl: Array<keyof HSLColourValue>;
+	rgb: Array<keyof RGBColourValue>;
+};
 declare abstract class Colour<Model> {
 	private readonly $colour;
 	protected readonly state: ColourState<Model>;
@@ -84,7 +88,11 @@ declare abstract class Colour<Model> {
 	 * Get the current value of the colour
 	 */
 	get value(): Model;
-	constructor(type: string, value: Model, defaults: Model, properties: Array<keyof Model>);
+	/**
+	 * Set the current value of the colour
+	 */
+	set value(value: Model);
+	constructor(type: keyof Properties, value: Model);
 	/**
 	 * Convert the colour to a hex-colour
 	 */

package/types/colour/rgb.d.ts

@@ -1,6 +1,6 @@
-import { Colour } from '~/colour/base';
-import type { HexColour } from '~/colour/hex';
-import type { HSLColour } from '~/colour/hsl';
+import { Colour } from './base';
+import type { HexColour } from './hex';
+import type { HSLColour } from './hsl';
 export type RGBColourValue = {
     blue: number;
     green: number;

package/types/function.d.ts

@@ -1,4 +1,4 @@
-import type { GenericCallback } from '~/models';
+import type { GenericCallback } from './models';
 type Debounced<Callback extends GenericCallback> = Callback & {
     /**
      * Cancel the debounce

package/types/index.d.cts

@@ -401,6 +401,7 @@ export type StringDigit =
 	| '7'
 	| '8'
 	| '9';
+type NoInfer$1<T> = T extends infer U ? U : never;
 /**
 Returns a boolean for whether the given type is `any`.
 
@@ -429,7 +430,7 @@ const anyA = get(anyObject, 'a');
 @category Type Guard
 @category Utilities
 */
-export type IsAny<T> = 0 extends 1 & T ? true : false;
+export type IsAny<T> = 0 extends 1 & NoInfer$1<T> ? true : false;
 export type Numeric = number | bigint;
 export type Zero = 0 | 0n;
 /**
@@ -1438,8 +1439,14 @@ export type PropertyOf<
 	? undefined
 	: Key extends keyof BaseType
 		? StrictPropertyOf<BaseType, Key, Options>
-		: BaseType extends readonly [] | readonly [unknown, ...unknown[]]
-			? unknown // It's a tuple, but `Key` did not extend `keyof BaseType`. So the index is out of bounds.
+		: BaseType extends readonly unknown[]
+			? Key extends `${number}`
+				? number extends BaseType['length']
+					? Strictify<BaseType[number], Options>
+					: Key extends keyof BaseType
+						? Strictify<BaseType[Key & keyof BaseType], Options>
+						: unknown
+				: unknown
 			: BaseType extends {
 						[n: number]: infer Item;
 						length: number; // Note: This is needed to avoid being too lax with records types using number keys like `{0: string; 1: boolean}`.
@@ -2506,6 +2513,10 @@ export declare class HexColour {
  * Get a hex-colour from a string
  */
 export declare function getHexColour(value: string): HexColour;
+export type Properties = {
+	hsl: Array<keyof HSLColourValue>;
+	rgb: Array<keyof RGBColourValue>;
+};
 declare abstract class Colour<Model> {
 	private readonly $colour;
 	protected readonly state: ColourState<Model>;
@@ -2513,12 +2524,11 @@ declare abstract class Colour<Model> {
 	 * Get the current value of the colour
 	 */
 	get value(): Model;
-	constructor(
-		type: string,
-		value: Model,
-		defaults: Model,
-		properties: Array<keyof Model>,
-	);
+	/**
+	 * Set the current value of the colour
+	 */
+	set value(value: Model);
+	constructor(type: keyof Properties, value: Model);
 	/**
 	 * Convert the colour to a hex-colour
 	 */
@@ -2587,6 +2597,24 @@ export declare class RGBColour extends Colour<RGBColourValue> {
  * Get an RGB-colour from a value-object
  */
 export declare function getRGBColour(value: RGBColourValue): RGBColour;
+/**
+ * Convert a hex-colour to an RGB-colour
+ */
+export declare function hexToRgb(value: string): RGBColour;
+/**
+ * - Convert an HSL-colour to an RGB-colour
+ * - Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L61
+ */
+export declare function hslToRgb(value: HSLColourValue): RGBColour;
+/**
+ * Convert an RGB-colour to a hex-colour
+ */
+export declare function rgbToHex(value: RGBColourValue): HexColour;
+/**
+ * - Convert an RGB-colour to an HSL-colour
+ * - Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L26
+ */
+export declare function rgbToHsl(rgb: RGBColourValue): HSLColour;
 /**
  * Is the value a colour?
  */