@oscarpalmer/atoms 0.5.2 → 0.7.0

package/dist/css/flex.css

@@ -45,104 +45,104 @@
   gap: 0;
 }
 
-.ac-c {
+.flex-ac-c {
   align-content: center;
 }
-.ac-fe {
+.flex-ac-fe {
   align-content: flex-end;
 }
-.ac-fs {
+.flex-ac-fs {
   align-content: flex-start;
 }
-.ac-s {
+.flex-ac-s {
   align-content: stretch;
 }
 
-.ai-c {
+.flex-ai-c {
   align-items: center;
 }
-.ai-fe {
+.flex-ai-fe {
   align-items: flex-end;
 }
-.ai-fs {
+.flex-ai-fs {
   align-items: flex-start;
 }
-.ai-s {
+.flex-ai-s {
   align-items: stretch;
 }
 
-.as-c {
+.flex-as-c {
   align-self: center;
 }
-.as-fe {
+.flex-as-fe {
   align-self: flex-end;
 }
-.as-fs {
+.flex-as-fs {
   align-self: flex-start;
 }
-.as-s {
+.flex-as-s {
   align-self: stretch;
 }
 
-.ac-sa {
+.flex-ac-sa {
   align-content: space-around;
 }
 
-.ac-sb {
+.flex-ac-sb {
   align-content: space-between;
 }
 
-.ac-se {
+.flex-ac-se {
   align-content: space-evenly;
 }
 
-.jc-c {
+.flex-jc-c {
   justify-content: center;
 }
-.jc-fe {
+.flex-jc-fe {
   justify-content: flex-end;
 }
-.jc-fs {
+.flex-jc-fs {
   justify-content: flex-start;
 }
-.jc-s {
+.flex-jc-s {
   justify-content: stretch;
 }
 
-.ji-c {
+.flex-ji-c {
   justify-items: center;
 }
-.ji-fe {
+.flex-ji-fe {
   justify-items: flex-end;
 }
-.ji-fs {
+.flex-ji-fs {
   justify-items: flex-start;
 }
-.ji-s {
+.flex-ji-s {
   justify-items: stretch;
 }
 
-.js-c {
+.flex-js-c {
   justify-self: center;
 }
-.js-fe {
+.flex-js-fe {
   justify-self: flex-end;
 }
-.js-fs {
+.flex-js-fs {
   justify-self: flex-start;
 }
-.js-s {
+.flex-js-s {
   justify-self: stretch;
 }
 
-.jc-sa {
+.flex-jc-sa {
   justify-content: space-around;
 }
 
-.jc-sb {
+.flex-jc-sb {
   justify-content: space-between;
 }
 
-.jc-se {
+.flex-jc-se {
   justify-content: space-evenly;
 }

package/dist/js/atoms.js

@@ -1,36 +1,190 @@
-// src/js/value.ts
-function getValue(data, key) {
-  if (typeof data !== "object" || data === null || isNullableOrWhitespace(key)) {
+// src/js/element.ts
+function findParentElement(origin, selector) {
+  if (origin == null || selector == null) {
     return;
   }
-  const parts = getString(key).split(".");
-  const length = parts.length;
-  let index = 0;
-  let value = data;
-  while (typeof value === "object" && value !== null && index < length) {
-    value = value[parts[index++]];
+  function matches(element) {
+    return typeof selector === "string" ? element.matches?.(selector) ?? false : typeof selector === "function" ? selector(element) : false;
+  }
+  if (matches(origin)) {
+    return origin;
+  }
+  let parent = origin.parentElement;
+  while (parent != null && !matches(parent)) {
+    if (parent === document.body) {
+      return;
+    }
+    parent = parent.parentElement;
+  }
+  return parent ?? undefined;
+}
+function getElementUnderPointer(all) {
+  const elements = Array.from(document.querySelectorAll(":hover")).filter((element) => {
+    const style = window.getComputedStyle(element);
+    return element.tagName !== "HEAD" && (typeof all === "boolean" && all ? true : style.pointerEvents !== "none" && style.visibility !== "hidden");
+  });
+  return elements[elements.length - 1];
+}
+// src/js/event.ts
+function getPosition(event) {
+  let x;
+  let y;
+  if (event instanceof MouseEvent) {
+    x = event.clientX;
+    y = event.clientY;
+  } else if (event instanceof TouchEvent) {
+    x = event.touches[0]?.clientX;
+    y = event.touches[0]?.clientY;
+  }
+  return typeof x === "number" && typeof y === "number" ? { x, y } : undefined;
+}
+var supportsTouch = (() => {
+  let value = false;
+  try {
+    if ("matchMedia" in window) {
+      const media = matchMedia("(pointer: coarse)");
+      if (typeof media?.matches === "boolean") {
+        value = media.matches;
+      }
+    }
+    if (!value) {
+      value = "ontouchstart" in window || navigator.maxTouchPoints > 0 || (navigator.msMaxTouchPoints ?? 0) > 0;
+    }
+  } catch {
+    value = false;
   }
   return value;
+})();
+// src/js/number.ts
+function clampNumber(value, min, max) {
+  return Math.min(Math.max(getNumber(value), getNumber(min)), getNumber(max));
 }
-function isNullable(value) {
-  return value === undefined || value === null;
+function getNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "symbol") {
+    return NaN;
+  }
+  let parsed = value?.valueOf?.() ?? value;
+  if (typeof parsed === "object") {
+    parsed = parsed?.toString() ?? parsed;
+  }
+  if (typeof parsed !== "string") {
+    return parsed == null ? NaN : typeof parsed === "number" ? parsed : +parsed;
+  }
+  if (zeroPattern.test(parsed)) {
+    return 0;
+  }
+  const trimmed = parsed.trim();
+  if (trimmed.length === 0) {
+    return NaN;
+  }
+  const isBinary = binaryPattern.test(trimmed);
+  if (isBinary || octalPattern.test(trimmed)) {
+    return parseInt(trimmed.slice(2), isBinary ? 2 : 8);
+  }
+  return +(hexadecimalPattern.test(trimmed) ? trimmed : trimmed.replace(separatorPattern, ""));
 }
-
+var binaryPattern = /^0b[01]+$/i;
+var hexadecimalPattern = /^0x[0-9a-f]+$/i;
+var octalPattern = /^0o[0-7]+$/i;
+var separatorPattern = /_/g;
+var zeroPattern = /^\s*0+\s*$/;
 // src/js/string.ts
 function createUuid() {
   return uuidTemplate.replace(/[018]/g, (substring) => (substring ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> substring / 4).toString(16));
 }
-function getString(value2) {
-  return typeof value2 === "string" ? value2 : String(value2);
+function getString(value) {
+  return typeof value === "string" ? value : typeof value?.toString === "function" ? value.toString() : String(value);
 }
-function isNullableOrWhitespace(value2) {
-  return isNullable(value2) || getString(value2).trim().length === 0;
+function isNullableOrWhitespace(value) {
+  return value == null || getString(value).trim().length === 0;
 }
 var uuidTemplate = "10000000-1000-4000-8000-100000000000";
+// src/js/value.ts
+var _getValue = function(data, key) {
+  if (typeof data !== "object" || data === null || badProperties.has(key)) {
+    return;
+  }
+  if (data instanceof Map) {
+    return data.get(key);
+  }
+  return data[key];
+};
+var _setValue = function(data, key, value) {
+  if (typeof data !== "object" || data === null || badProperties.has(key)) {
+    return;
+  }
+  if (data instanceof Map) {
+    data.set(key, value);
+  } else {
+    data[key] = value;
+  }
+};
+function getValue(data, key) {
+  if (typeof data !== "object" || data === null || isNullableOrWhitespace(key)) {
+    return;
+  }
+  const parts = getString(key).split(".").reverse();
+  let position = parts.length;
+  let value = data;
+  while (position--) {
+    value = _getValue(value, parts[position]);
+    if (value == null) {
+      break;
+    }
+  }
+  return value;
+}
+function isArrayOrObject(value) {
+  return constructors.has(value?.constructor?.name);
+}
+function isNullable(value) {
+  return value == null;
+}
+function isObject(value) {
+  return value?.constructor?.name === objectConstructor;
+}
+function setValue(data, key, value) {
+  if (typeof data !== "object" || data === null || isNullableOrWhitespace(key)) {
+    return data;
+  }
+  const parts = getString(key).split(".").reverse();
+  let position = parts.length;
+  let target = data;
+  while (position--) {
+    const key2 = parts[position];
+    if (position === 0) {
+      _setValue(target, key2, value);
+      break;
+    }
+    let next = _getValue(target, key2);
+    if (typeof next !== "object" || next === null) {
+      next = numberExpression.test(parts[position - 1]) ? [] : {};
+      target[key2] = next;
+    }
+    target = next;
+  }
+  return data;
+}
+var badProperties = new Set(["__proto__", "constructor", "prototype"]);
+var objectConstructor = "Object";
+var constructors = new Set(["Array", objectConstructor]);
+var numberExpression = /^\d+$/;
 export {
+  supportsTouch,
+  setValue,
+  isObject,
   isNullableOrWhitespace,
   isNullable,
+  isArrayOrObject,
   getValue,
   getString,
-  createUuid
+  getPosition,
+  getNumber,
+  getElementUnderPointer,
+  findParentElement,
+  createUuid,
+  clampNumber
 };

package/package.json

@@ -5,13 +5,11 @@
 	},
 	"description": "Sweet little atomic goodies…",
 	"devDependencies": {
-		"@rollup/plugin-typescript": "^11.1",
+		"@biomejs/biome": "^1.5",
+		"@happy-dom/global-registrator": "^13.3",
 		"bun": "^1.0",
-		"prettier": "^3.1",
-		"rollup": "^4.5",
-		"sass": "^1.69",
-		"typescript": "^5.3",
-		"xo": "^0.56"
+		"sass": "^1.70",
+		"typescript": "^5.3"
 	},
 	"exports": {
 		".": {
@@ -20,48 +18,26 @@
 		},
 		"./package.json": "./package.json"
 	},
-	"files": [
-		"dist",
-		"src",
-		"types"
-	],
+	"files": ["dist", "src", "types"],
 	"keywords": [],
 	"license": "MIT",
 	"main": "./dist/js/atoms.js",
 	"module": "./dist/js/atoms.js",
 	"name": "@oscarpalmer/atoms",
-	"prettier": {
-		"arrowParens": "avoid",
-		"bracketSpacing": false,
-		"singleQuote": true,
-		"switchIndent": true,
-		"trailingComma": "all",
-		"useTabs": true
-	},
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/oscarpalmer/atoms.git"
 	},
 	"scripts": {
-		"build": "npm run build:css && npm run build:js && npm run types",
-		"build:css": "npx sass ./src/css:./dist/css --no-source-map",
-		"build:js": "npx bun build ./src/js/index.ts --outfile ./dist/js/atoms.js",
-		"test": "npx bun test --coverage",
-		"types": "npx tsc ./src/js/index.ts --declaration --declarationDir ./types --emitDeclarationOnly",
-		"watch:css": "npx sass ./src/css:./dist/css --no-source-map --watch",
-		"watch:js": "npx bun build ./src/js/index.ts --outfile ./dist/js/atoms.js --watch"
+		"build": "bun run build:css && bun run build:js && bun run types",
+		"build:css": "bunx sass ./src/css:./dist/css --no-source-map",
+		"build:js": "bunx bun build ./src/js/index.ts --outfile ./dist/js/atoms.js",
+		"test": "bun test --preload ./test/_preload.ts --coverage",
+		"types": "bunx tsc -p ./tsconfig.json",
+		"watch:css": "bunx sass ./src/css:./dist/css --no-source-map --watch",
+		"watch:js": "bun build ./src/js/index.ts --outfile ./dist/js/atoms.js --watch"
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.5.2",
-	"xo": {
-		"envs": [
-			"browser"
-		],
-		"prettier": true,
-		"rules": {
-			"import/extensions": "off",
-			"import/no-cycle": "off"
-		}
-	}
-}
+	"version": "0.7.0"
+}

package/src/css/flex.scss

@@ -61,7 +61,7 @@ $types: (a: 'align', j: 'justify');
 
 @each $typeKey, $typeValue in $types {
 	@each $alignmentOriginKey, $alignmentOriginValue in $alignmentOrigins {
-		.#{$typeKey}#{$alignmentOriginKey} {
+		.flex-#{$typeKey}#{$alignmentOriginKey} {
 			@each $alignmentValueKey, $alignmentValueValue in $alignmentValues {
 				&-#{$alignmentValueKey} {
 					#{$typeValue}-#{$alignmentOriginValue}: #{$alignmentValueValue}
@@ -71,7 +71,7 @@ $types: (a: 'align', j: 'justify');
 	}
 
 	@each $justificationValueKey, $justificationValueValue in $justificationValues {
-		.#{$typeKey}c-#{$justificationValueKey} {
+		.flex-#{$typeKey}c-#{$justificationValueKey} {
 			#{$typeValue}-content: #{$justificationValueValue}
 		}
 	}

package/src/js/element.ts

@@ -0,0 +1,58 @@
+/**
+ * - Find the parent element that matches the selector
+ * - Matches may be found by a query string or a callback
+ */
+export function findParentElement(
+	origin: Element,
+	selector: string | ((element: Element) => boolean),
+): Element | undefined {
+	if (origin == null || selector == null) {
+		return undefined;
+	}
+
+	function matches(element: Element): boolean {
+		return typeof selector === 'string'
+			? element.matches?.(selector) ?? false
+			: typeof selector === 'function'
+			  ? selector(element)
+			  : false;
+	}
+
+	if (matches(origin)) {
+		return origin;
+	}
+
+	let parent: Element | null = origin.parentElement;
+
+	while (parent != null && !matches(parent)) {
+		if (parent === document.body) {
+			return undefined;
+		}
+
+		parent = parent.parentElement;
+	}
+
+	return parent ?? undefined;
+}
+
+/**
+ * - Get the most specific element under the pointer
+ * - Ignores elements with `pointer-events: none` and `visibility: hidden`
+ * - If `all` is `true`, all elements under the pointer are returned
+ */
+export function getElementUnderPointer(all?: boolean): Element | undefined {
+	const elements = Array.from(document.querySelectorAll(':hover')).filter(
+		element => {
+			const style = window.getComputedStyle(element);
+
+			return (
+				element.tagName !== 'HEAD' &&
+				(typeof all === 'boolean' && all
+					? true
+					: style.pointerEvents !== 'none' && style.visibility !== 'hidden')
+			);
+		},
+	);
+
+	return elements[elements.length - 1];
+}

package/src/js/event.ts

@@ -0,0 +1,57 @@
+type NavigatorWithMsMaxTouchPoints = Navigator & {
+	msMaxTouchPoints: number;
+};
+
+type Position = {
+	x: number;
+	y: number;
+};
+
+/**
+ * Does the browser support touch events?
+ */
+export const supportsTouch = (() => {
+	let value = false;
+
+	try {
+		if ('matchMedia' in window) {
+			const media = matchMedia('(pointer: coarse)');
+
+			if (typeof media?.matches === 'boolean') {
+				value = media.matches;
+			}
+		}
+
+		if (!value) {
+			value =
+				'ontouchstart' in window ||
+				navigator.maxTouchPoints > 0 ||
+				((navigator as NavigatorWithMsMaxTouchPoints).msMaxTouchPoints ?? 0) >
+					0;
+		}
+	} catch {
+		value = false;
+	}
+
+	return value;
+})();
+
+/**
+ * Get the X- and Y-coordinates from a pointer event
+ */
+export function getPosition(
+	event: MouseEvent | TouchEvent,
+): Position | undefined {
+	let x: number | undefined;
+	let y: number | undefined;
+
+	if (event instanceof MouseEvent) {
+		x = event.clientX;
+		y = event.clientY;
+	} else if (event instanceof TouchEvent) {
+		x = event.touches[0]?.clientX;
+		y = event.touches[0]?.clientY;
+	}
+
+	return typeof x === 'number' && typeof y === 'number' ? {x, y} : undefined;
+}

package/src/js/index.ts

@@ -1,2 +1,5 @@
+export * from './element';
+export * from './event';
+export * from './number';
 export * from './string';
 export * from './value';

package/src/js/number.ts

@@ -0,0 +1,56 @@
+const binaryPattern = /^0b[01]+$/i;
+const hexadecimalPattern = /^0x[0-9a-f]+$/i;
+const octalPattern = /^0o[0-7]+$/i;
+const separatorPattern = /_/g;
+const zeroPattern = /^\s*0+\s*$/;
+
+/**
+ * Clamps a number between a minimum and maximum value
+ */
+export function clampNumber(value: number, min: number, max: number): number {
+	return Math.min(Math.max(getNumber(value), getNumber(min)), getNumber(max));
+}
+
+/**
+ * - Gets the number value from an unknown value
+ * - Returns `NaN` if the value is `undefined`, `null`, or cannot be parsed
+ */
+export function getNumber(value: unknown): number {
+	if (typeof value === 'number') {
+		return value;
+	}
+
+	if (typeof value === 'symbol') {
+		return NaN;
+	}
+
+	let parsed = value?.valueOf?.() ?? value;
+
+	if (typeof parsed === 'object') {
+		parsed = parsed?.toString() ?? parsed;
+	}
+
+	if (typeof parsed !== 'string') {
+		return parsed == null ? NaN : typeof parsed === 'number' ? parsed : +parsed;
+	}
+
+	if (zeroPattern.test(parsed)) {
+		return 0;
+	}
+
+	const trimmed = parsed.trim();
+
+	if (trimmed.length === 0) {
+		return NaN;
+	}
+
+	const isBinary = binaryPattern.test(trimmed);
+
+	if (isBinary || octalPattern.test(trimmed)) {
+		return parseInt(trimmed.slice(2), isBinary ? 2 : 8);
+	}
+
+	return +(hexadecimalPattern.test(trimmed)
+		? trimmed
+		: trimmed.replace(separatorPattern, ''));
+}

package/src/js/string.ts

@@ -1,5 +1,3 @@
-import {isNullable} from './value';
-
 const uuidTemplate = '10000000-1000-4000-8000-100000000000';
 
 /**
@@ -18,7 +16,11 @@ export function createUuid(): string {
  * Get the string value from any value
  */
 export function getString(value: unknown): string {
-	return typeof value === 'string' ? value : String(value);
+	return typeof value === 'string'
+		? value
+		: typeof value?.toString === 'function'
+		  ? value.toString()
+		  : String(value);
 }
 
 /**
@@ -27,5 +29,5 @@ export function getString(value: unknown): string {
 export function isNullableOrWhitespace(
 	value: unknown,
 ): value is undefined | null | '' {
-	return isNullable(value) || getString(value).trim().length === 0;
+	return value == null || getString(value).trim().length === 0;
 }

package/src/js/value.ts

@@ -1,10 +1,51 @@
 import {getString, isNullableOrWhitespace} from './string';
 
+export type ArrayOrObject = unknown[] | GenericObject;
+export type GenericObject = Record<string, unknown>;
+export type Key = number | string;
+export type ValueObject = ArrayOrObject | Map<unknown, unknown> | Set<unknown>;
+
+const badProperties = new Set(['__proto__', 'constructor', 'prototype']);
+const objectConstructor = 'Object';
+const constructors = new Set(['Array', objectConstructor]);
+const numberExpression = /^\d+$/;
+
+/**
+ * Internal function to get a value from an object
+ */
+function _getValue(data: ValueObject, key: string): unknown {
+	if (typeof data !== 'object' || data === null || badProperties.has(key)) {
+		return undefined;
+	}
+
+	if (data instanceof Map) {
+		return data.get(key as never);
+	}
+
+	return data[key as never];
+}
+
+/**
+ * Internal function to set a value in an object
+ */
+function _setValue(data: ValueObject, key: string, value: unknown): void {
+	if (typeof data !== 'object' || data === null || badProperties.has(key)) {
+		return;
+	}
+
+	if (data instanceof Map) {
+		data.set(key as never, value);
+	} else {
+		data[key as never] = value as never;
+	}
+}
+
 /**
- * - Get the value from an object using a path
- * - You can retrieve a nested value by using a dot notation path
+ * - Get the value from an object using a key path
+ * - You can retrieve a nested value by using dot notation, e.g., `foo.bar.baz`
+ * - Returns `undefined` if the value is not found
  */
-export function getValue(data: unknown, key: unknown): unknown {
+export function getValue(data: ValueObject, key: Key): unknown {
 	if (
 		typeof data !== 'object' ||
 		data === null ||
@@ -13,22 +54,86 @@ export function getValue(data: unknown, key: unknown): unknown {
 		return undefined;
 	}
 
-	const parts = getString(key).split('.');
-	const length = parts.length;
+	const parts = getString(key).split('.').reverse();
 
-	let index = 0;
+	let position = parts.length;
 	let value = data;
 
-	while (typeof value === 'object' && value !== null && index < length) {
-		value = value[parts[index++]];
+	while (position--) {
+		value = _getValue(value, parts[position]) as ValueObject;
+
+		if (value == null) {
+			break;
+		}
 	}
 
 	return value;
 }
 
+/**
+ * Is the value an array or a generic object?
+ */
+export function isArrayOrObject(value: unknown): value is ArrayOrObject {
+	return constructors.has((value as ArrayOrObject)?.constructor?.name);
+}
+
 /**
  * Is the value undefined or null?
  */
 export function isNullable(value: unknown): value is undefined | null {
-	return value === undefined || value === null;
+	return value == null;
+}
+
+/**
+ * Is the value a generic object?
+ */
+export function isObject(value: unknown): value is GenericObject {
+	return (value as GenericObject)?.constructor?.name === objectConstructor;
+}
+
+/**
+ * - Set the value in an object using a key path
+ * - You can set a nested value by using dot notation, e.g., `foo.bar.baz`
+ * - If a part of the path does not exist, it will be created, either as an array or a generic object, depending on the key
+ * - Returns the original object
+ */
+export function setValue<Model extends ValueObject>(
+	data: Model,
+	key: Key,
+	value: unknown,
+): Model {
+	if (
+		typeof data !== 'object' ||
+		data === null ||
+		isNullableOrWhitespace(key)
+	) {
+		return data;
+	}
+
+	const parts = getString(key).split('.').reverse();
+
+	let position = parts.length;
+	let target: ValueObject = data;
+
+	while (position--) {
+		const key = parts[position] as never;
+
+		if (position === 0) {
+			_setValue(target, key, value);
+
+			break;
+		}
+
+		let next = _getValue(target, key);
+
+		if (typeof next !== 'object' || next === null) {
+			next = numberExpression.test(parts[position - 1]) ? [] : {};
+
+			target[key] = next as never;
+		}
+
+		target = next as ValueObject;
+	}
+
+	return data;
 }

package/types/element.d.ts

@@ -0,0 +1,11 @@
+/**
+ * - Find the parent element that matches the selector
+ * - Matches may be found by a query string or a callback
+ */
+export declare function findParentElement(origin: Element, selector: string | ((element: Element) => boolean)): Element | undefined;
+/**
+ * - Get the most specific element under the pointer
+ * - Ignores elements with `pointer-events: none` and `visibility: hidden`
+ * - If `all` is `true`, all elements under the pointer are returned
+ */
+export declare function getElementUnderPointer(all?: boolean): Element | undefined;

package/types/event.d.ts

@@ -0,0 +1,13 @@
+type Position = {
+    x: number;
+    y: number;
+};
+/**
+ * Does the browser support touch events?
+ */
+export declare const supportsTouch: boolean;
+/**
+ * Get the X- and Y-coordinates from a pointer event
+ */
+export declare function getPosition(event: MouseEvent | TouchEvent): Position | undefined;
+export {};

package/types/index.d.ts

@@ -1,2 +1,5 @@
+export * from './element';
+export * from './event';
+export * from './number';
 export * from './string';
 export * from './value';

package/types/number.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Clamps a number between a minimum and maximum value
+ */
+export declare function clampNumber(value: number, min: number, max: number): number;
+/**
+ * - Gets the number value from an unknown value
+ * - Returns `NaN` if the value is `undefined`, `null`, or cannot be parsed
+ */
+export declare function getNumber(value: unknown): number;

package/types/value.d.ts

@@ -1,9 +1,29 @@
+export type ArrayOrObject = unknown[] | GenericObject;
+export type GenericObject = Record<string, unknown>;
+export type Key = number | string;
+export type ValueObject = ArrayOrObject | Map<unknown, unknown> | Set<unknown>;
 /**
- * - Get the value from an object using a path
- * - You can retrieve a nested value by using a dot notation path
+ * - Get the value from an object using a key path
+ * - You can retrieve a nested value by using dot notation, e.g., `foo.bar.baz`
+ * - Returns `undefined` if the value is not found
  */
-export declare function getValue(data: unknown, key: unknown): unknown;
+export declare function getValue(data: ValueObject, key: Key): unknown;
+/**
+ * Is the value an array or a generic object?
+ */
+export declare function isArrayOrObject(value: unknown): value is ArrayOrObject;
 /**
  * Is the value undefined or null?
  */
 export declare function isNullable(value: unknown): value is undefined | null;
+/**
+ * Is the value a generic object?
+ */
+export declare function isObject(value: unknown): value is GenericObject;
+/**
+ * - Set the value in an object using a key path
+ * - You can set a nested value by using dot notation, e.g., `foo.bar.baz`
+ * - If a part of the path does not exist, it will be created, either as an array or a generic object, depending on the key
+ * - Returns the original object
+ */
+export declare function setValue<Model extends ValueObject>(data: Model, key: Key, value: unknown): Model;