@oscarpalmer/atoms 0.5.2 → 0.6.0

package/dist/js/atoms.js

@@ -1,35 +1,110 @@
+// 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(value) {
+  return typeof value === "string" ? value : String(value);
+}
+function isNullableOrWhitespace(value) {
+  return value === undefined || 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);
+  }
+  if (data instanceof Set) {
+    return Array.from(data)[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 if (data instanceof Set) {
+    _setValueInSet(data, key, value);
+  } else {
+    data[key] = value;
+  }
+};
+var _setValueInSet = function(data, key, value) {
+  const index = numberExpression.test(key) ? Number.parseInt(key, 10) : -1;
+  if (index === -1 || index >= data.size) {
+    data.add(value);
+    return;
+  }
+  const array = Array.from(data);
+  array.splice(index, 1, value);
+  data.clear();
+  const { length } = array;
+  let position = Number(length);
+  while (position--) {
+    data.add(array[length - position - 1]);
+  }
+};
 function getValue(data, key) {
   if (typeof data !== "object" || data === null || isNullableOrWhitespace(key)) {
     return;
   }
-  const parts = getString(key).split(".");
-  const length = parts.length;
-  let index = 0;
+  const parts = getString(key).split(".").reverse();
+  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]);
+    if (value === undefined) {
+      break;
+    }
   }
   return value;
 }
+function isArrayOrObject(value) {
+  return constructors.has(value?.constructor?.name);
+}
 function isNullable(value) {
   return value === undefined || value === null;
 }
-
-// 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 isObject(value) {
+  return value?.constructor?.name === objectConstructor;
 }
-function isNullableOrWhitespace(value2) {
-  return isNullable(value2) || getString(value2).trim().length === 0;
+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 uuidTemplate = "10000000-1000-4000-8000-100000000000";
+var badProperties = new Set(["__proto__", "constructor", "prototype"]);
+var objectConstructor = "Object";
+var constructors = new Set(["Array", objectConstructor]);
+var numberExpression = /^\d+$/;
 export {
+  setValue,
+  isObject,
   isNullableOrWhitespace,
   isNullable,
+  isArrayOrObject,
   getValue,
   getString,
   createUuid

package/package.json

@@ -5,13 +5,10 @@
 	},
 	"description": "Sweet little atomic goodies…",
 	"devDependencies": {
-		"@rollup/plugin-typescript": "^11.1",
+		"@biomejs/biome": "^1.4",
 		"bun": "^1.0",
-		"prettier": "^3.1",
-		"rollup": "^4.5",
 		"sass": "^1.69",
-		"typescript": "^5.3",
-		"xo": "^0.56"
+		"typescript": "^5.3"
 	},
 	"exports": {
 		".": {
@@ -30,38 +27,20 @@
 	"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 --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.6.0"
 }

package/src/js/string.ts

@@ -1,5 +1,3 @@
-import {isNullable} from './value';
-
 const uuidTemplate = '10000000-1000-4000-8000-100000000000';
 
 /**
@@ -27,5 +25,9 @@ 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 === undefined ||
+		value === null ||
+		getString(value).trim().length === 0
+	);
 }

package/src/js/value.ts

@@ -1,10 +1,86 @@
 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);
+	}
+
+	if (data instanceof Set) {
+		return Array.from(data)[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 if (data instanceof Set) {
+		_setValueInSet(data, key, value);
+	} else {
+		data[key as never] = value as never;
+	}
+}
+
+/**
+ * - Internal function to set a value in a `Set`
+ * - If key is not a valid index or if it is greater than or equal to the length of the set, we simply append it to the set
+ * - If the index is less than the size of the set, we convert the set to an array, splice the value into the array, and then convert the array back to a set
+ */
+function _setValueInSet(data: Set<unknown>, key: string, value: unknown): void {
+	const index = numberExpression.test(key) ? Number.parseInt(key, 10) : -1;
+
+	if (index === -1 || index >= data.size) {
+		data.add(value);
+
+		return;
+	}
+
+	const array = Array.from(data);
+
+	array.splice(index, 1, value);
+
+	data.clear();
+
+	const {length} = array;
+
+	let position = Number(length);
+
+	while (position--) {
+		data.add(array[length - position - 1]);
+	}
+}
+
 /**
- * - 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 +89,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 === undefined) {
+			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;
 }
+
+/**
+ * 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/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;