@oscarpalmer/atoms 0.192.0 → 0.193.1

package/src/value/smush.ts

@@ -1,89 +0,0 @@
-import {isArrayOrPlainObject} from '../internal/is';
-import {join} from '../internal/string';
-import type {
-	ArrayOrPlainObject,
-	NestedKeys,
-	NestedValue,
-	PlainObject,
-	Simplify,
-	ToString,
-} from '../models';
-
-// #region Types
-
-/**
- * A smushed object, with all nested objects flattened into a single level, using dot notation keys
- */
-export type Smushed<Value extends PlainObject> = Simplify<{
-	[NestedKey in NestedKeys<Value>]: NestedValue<Value, ToString<NestedKey>>;
-}>;
-
-// #endregion
-
-// #region Functions
-
-function flattenObject(
-	value: ArrayOrPlainObject,
-	depth: number,
-	smushed: WeakMap<WeakKey, PlainObject>,
-	prefix?: string,
-): PlainObject {
-	if (depth >= MAX_DEPTH) {
-		return {};
-	}
-
-	if (smushed.has(value)) {
-		return smushed.get(value) as never;
-	}
-
-	const keys = Object.keys(value);
-	const {length} = keys;
-	const flattened = {} as Record<string, unknown>;
-
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		const val = value[key as never];
-
-		if (isArrayOrPlainObject(val)) {
-			const prefixedKey = join([prefix, key], '.');
-
-			flattened[prefixedKey] = Array.isArray(val) ? val.slice() : {...val};
-
-			const nested = flattenObject(val, depth + 1, smushed, prefixedKey);
-			const nestedKeys = Object.keys(nested);
-			const nestedLength = nestedKeys.length;
-
-			for (let nestedIndex = 0; nestedIndex < nestedLength; nestedIndex += 1) {
-				const nestedKey = nestedKeys[nestedIndex];
-
-				flattened[nestedKey] = nested[nestedKey];
-			}
-		} else {
-			flattened[join([prefix, key], '.')] = val;
-		}
-	}
-
-	smushed.set(value, flattened);
-
-	return flattened as never;
-}
-
-/**
- * Smush an object into a flat object that uses dot notation keys
- *
- * @param value Object to smush
- * @returns Smushed object with dot notation keys
- */
-export function smush<Value extends PlainObject>(value: Value): Smushed<Value> {
-	return typeof value === 'object' && value !== null
-		? (flattenObject(value, 0, new WeakMap()) as never)
-		: ({} as never);
-}
-
-// #endregion
-
-// #region Variables
-
-const MAX_DEPTH = 100;
-
-// #endregion

package/src/value/transform.ts

@@ -1,153 +0,0 @@
-import {isNonPlainObject} from '../internal/is';
-import type {GenericCallback, PlainObject} from '../models';
-
-// #region Types
-
-/**
- * A callback transform an object's properties
- */
-type TransformCallback<Value extends PlainObject, Key extends keyof Value> = (
-	key: Key,
-	value: Value[Key],
-) => Value[Key];
-
-/**
- * A collection of keyed callbacks to transform an object's properties
- */
-type TransformCallbacks<Value extends PlainObject> = Partial<{
-	[Key in keyof Value]: (value: Value[Key]) => Value[Key];
-}>;
-
-/**
- * A transformer function for an object, with predefined callbacks for transforming its properties
- */
-export type Transformer<Value extends PlainObject> = {
-	(value: Value): Value;
-};
-
-// #endregion
-
-// #region Functions
-
-function getTransformer<Value extends PlainObject, Key extends keyof Value>(
-	input: unknown,
-): TransformCallback<Value, Key> | TransformCallbacks<Value> | undefined {
-	if (typeof input === 'function') {
-		return input as GenericCallback;
-	}
-
-	if (isNonPlainObject(input)) {
-		return;
-	}
-
-	const keys = Object.keys(input) as Key[];
-	const {length} = keys;
-
-	const transformer: Partial<TransformCallbacks<Value>> = {};
-
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		const value = input[key];
-
-		if (typeof value === 'function') {
-			transformer[key] = value;
-		}
-	}
-
-	if (Object.keys(transformer).length > 0) {
-		return transformer;
-	}
-}
-
-/**
- * Initialize a transformer for an object with a transformer function
- *
- * _Available as `initializeTransformer` and `transform.initialize`_
- *
- * @param transform Transformer function
- * @returns Transformer
- */
-export function initializeTransformer<Value extends PlainObject>(
-	transform: TransformCallback<Value, keyof Value>,
-): Transformer<Value>;
-
-/**
- * Initialize a transformer for an object with transformer functions
- *
- * _Available as `initializeTransformer` and `transform.initialize`_
- *
- * @param transformers Keyed transformer functions
- * @returns Transformer
- */
-export function initializeTransformer<Value extends PlainObject>(
-	transformers: TransformCallbacks<Value>,
-): Transformer<Value>;
-
-export function initializeTransformer<Value extends PlainObject>(
-	transform: unknown,
-): Transformer<Value> {
-	const transformer = getTransformer<Value, keyof Value>(transform);
-
-	return value => transformValue(value, transformer);
-}
-
-/**
- * Transform and objects properties using a transformer function
- *
- * @param value Object to transform
- * @param transform Transformer function
- * @returns Transformed object
- */
-export function transform<Value extends PlainObject, Key extends keyof Value>(
-	value: Value,
-	transform: TransformCallback<Value, Key>,
-): Value;
-
-/**
- * Transform and objects properties using a transformer object
- *
- * @param value Object to transform
- * @param transformers Keyed transformer functions
- * @returns Transformed object
- */
-export function transform<Value extends PlainObject>(
-	value: Value,
-	transformers: TransformCallbacks<Value>,
-): Value;
-
-export function transform<Value extends PlainObject>(value: Value, transform: unknown): Value {
-	return transformValue(value, getTransformer(transform));
-}
-
-transform.initialize = initializeTransformer;
-
-function transformValue<Value extends PlainObject, Key extends keyof Value>(
-	value: Value,
-	transformer?: TransformCallback<Value, Key> | TransformCallbacks<Value>,
-): Value {
-	if (isNonPlainObject(value)) {
-		return {} as Value;
-	}
-
-	if (transformer == null) {
-		return value;
-	}
-
-	const keys = Object.keys(value) as Key[];
-	const {length} = keys;
-
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		const val = value[key];
-
-		if (typeof transformer === 'function') {
-			value[key] = transformer(key, val) as Value[Key];
-		} else {
-			value[key] = (transformer[key]?.(val) ?? val) as Value[Key];
-		}
-	}
-
-	return value;
-}
-
-// #endregion

package/src/value/unsmush.ts

@@ -1,84 +0,0 @@
-import {isArrayOrPlainObject} from '../internal/is';
-import {setValue} from '../internal/value/set';
-import type {PlainObject, Simplify, UnionToIntersection} from '../models';
-
-// #region Types
-
-/**
- * Thanks, type-fest!
- */
-type KeysOfUnion<ObjectType> = keyof UnionToIntersection<
-	ObjectType extends unknown ? Record<keyof ObjectType, never> : never
->;
-
-type OrderedKey = {
-	order: number;
-	value: string;
-};
-
-/**
- * An unsmushed object, with all dot notation keys turned into nested keys
- */
-export type Unsmushed<Value extends PlainObject> = Simplify<
-	Omit<
-		{
-			[UnionKey in KeysOfUnion<Value>]: Value[UnionKey];
-		},
-		`${string}.${string}`
-	>
->;
-
-// #endregion
-
-// #region Functions
-
-function getKeys(value: PlainObject): OrderedKey[] {
-	const keys = Object.keys(value);
-	const {length} = keys;
-
-	const orderedKeys: OrderedKey[] = [];
-
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-
-		orderedKeys.push({
-			order: key.split('.').length,
-			value: key,
-		});
-	}
-
-	return orderedKeys.sort((first, second) => first.order - second.order);
-}
-
-/**
- * Unsmush a smushed object _(turning dot notation keys into nested keys)_
- *
- * @param value Object to unsmush
- * @returns Unsmushed object with nested keys
- */
-export function unsmush<Value extends PlainObject>(value: Value): Unsmushed<Value> {
-	if (typeof value !== 'object' || value === null) {
-		return {} as never;
-	}
-
-	const keys = getKeys(value);
-	const {length} = keys;
-	const unsmushed: PlainObject = {};
-
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index].value;
-		const val = value[key];
-
-		let next = val;
-
-		if (isArrayOrPlainObject(val)) {
-			next = Array.isArray(val) ? val.slice() : {...val};
-		}
-
-		setValue(unsmushed, key, next);
-	}
-
-	return unsmushed as never;
-}
-
-// #endregion