@oscarpalmer/atoms 0.125.0 → 0.126.0

package/dist/atoms.full.js

@@ -1819,95 +1819,6 @@ function getEqualOptions(input) {
 }
 const ARRAY_PEEK_PERCENTAGE = 10;
 const ARRAY_THRESHOLD = 100;
-function diff(first, second, options) {
-	const relaxedNullish = typeof options === "object" && options?.relaxedNullish === true;
-	const result = {
-		original: {
-			from: first,
-			to: second
-		},
-		type: "partial",
-		values: {}
-	};
-	const same = relaxedNullish && first == null && second == null || Object.is(first, second);
-	const firstIsArrayOrObject = isArrayOrPlainObject(first);
-	const secondIsArrayOrObject = isArrayOrPlainObject(second);
-	if (same || !(firstIsArrayOrObject || secondIsArrayOrObject)) {
-		result.type = same ? "none" : "full";
-		return result;
-	}
-	if (firstIsArrayOrObject !== secondIsArrayOrObject) {
-		result.type = "full";
-		return result;
-	}
-	const diffs = getDiffs(first, second, relaxedNullish);
-	const { length } = diffs;
-	if (length === 0) result.type = "none";
-	for (let index = 0; index < length; index += 1) {
-		const differences = diffs[index];
-		result.values[differences.key] = {
-			from: differences.from,
-			to: differences.to
-		};
-	}
-	return result;
-}
-function getChanges(changes, first, second, relaxedNullish, prefix) {
-	const checked = /* @__PURE__ */ new Set();
-	for (let outerIndex = 0; outerIndex < 2; outerIndex += 1) {
-		const value = (outerIndex === 0 ? first : second) ?? {};
-		const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
-		const { length } = keys;
-		for (let innerIndex = 0; innerIndex < length; innerIndex += 1) {
-			const key = keys[innerIndex];
-			if (checked.has(key)) continue;
-			checked.add(key);
-			setChanges({
-				changes,
-				key,
-				relaxedNullish,
-				prefix,
-				values: {
-					first,
-					second
-				}
-			});
-		}
-	}
-	return changes;
-}
-function getDiffs(first, second, relaxedNullish, prefix) {
-	const changes = [];
-	if (Array.isArray(first) && Array.isArray(second)) {
-		const maximumLength = Math.max(first.length, second.length);
-		const minimumLength = Math.min(first.length, second.length);
-		for (let index = minimumLength; index < maximumLength; index += 1) {
-			const key = join([prefix, index], ".");
-			changes.push({
-				key,
-				from: index >= first.length ? void 0 : first[index],
-				to: index >= first.length ? second[index] : void 0
-			});
-		}
-	}
-	return getChanges(changes, first, second, relaxedNullish, prefix);
-}
-function setChanges(parameters) {
-	const { changes, key, prefix, relaxedNullish, values } = parameters;
-	const from = values.first?.[key];
-	const to = values.second?.[key];
-	if (equal(from, to, { relaxedNullish })) return;
-	const prefixed = join([prefix, key], ".");
-	const change = {
-		from,
-		to,
-		key: prefixed
-	};
-	const diffs = isArrayOrPlainObject(from) || isArrayOrPlainObject(to) ? getDiffs(from, to, relaxedNullish, prefixed) : [];
-	changes.push(change);
-	const diffsLength = diffs.length;
-	for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) changes.push(diffs[diffIndex]);
-}
 function clone(value) {
 	return cloneValue(value, 0, /* @__PURE__ */ new WeakMap());
 }
@@ -2003,6 +1914,95 @@ function tryStructuredClone(value, depth, references) {
 	}
 }
 const MAX_CLONE_DEPTH = 100;
+function diff(first, second, options) {
+	const relaxedNullish = typeof options === "object" && options?.relaxedNullish === true;
+	const result = {
+		original: {
+			from: first,
+			to: second
+		},
+		type: "partial",
+		values: {}
+	};
+	const same = relaxedNullish && first == null && second == null || Object.is(first, second);
+	const firstIsArrayOrObject = isArrayOrPlainObject(first);
+	const secondIsArrayOrObject = isArrayOrPlainObject(second);
+	if (same || !(firstIsArrayOrObject || secondIsArrayOrObject)) {
+		result.type = same ? "none" : "full";
+		return result;
+	}
+	if (firstIsArrayOrObject !== secondIsArrayOrObject) {
+		result.type = "full";
+		return result;
+	}
+	const diffs = getDiffs(first, second, relaxedNullish);
+	const { length } = diffs;
+	if (length === 0) result.type = "none";
+	for (let index = 0; index < length; index += 1) {
+		const differences = diffs[index];
+		result.values[differences.key] = {
+			from: differences.from,
+			to: differences.to
+		};
+	}
+	return result;
+}
+function getChanges(changes, first, second, relaxedNullish, prefix) {
+	const checked = /* @__PURE__ */ new Set();
+	for (let outerIndex = 0; outerIndex < 2; outerIndex += 1) {
+		const value = (outerIndex === 0 ? first : second) ?? {};
+		const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
+		const { length } = keys;
+		for (let innerIndex = 0; innerIndex < length; innerIndex += 1) {
+			const key = keys[innerIndex];
+			if (checked.has(key)) continue;
+			checked.add(key);
+			setChanges({
+				changes,
+				key,
+				relaxedNullish,
+				prefix,
+				values: {
+					first,
+					second
+				}
+			});
+		}
+	}
+	return changes;
+}
+function getDiffs(first, second, relaxedNullish, prefix) {
+	const changes = [];
+	if (Array.isArray(first) && Array.isArray(second)) {
+		const maximumLength = Math.max(first.length, second.length);
+		const minimumLength = Math.min(first.length, second.length);
+		for (let index = minimumLength; index < maximumLength; index += 1) {
+			const key = join([prefix, index], ".");
+			changes.push({
+				key,
+				from: index >= first.length ? void 0 : first[index],
+				to: index >= first.length ? second[index] : void 0
+			});
+		}
+	}
+	return getChanges(changes, first, second, relaxedNullish, prefix);
+}
+function setChanges(parameters) {
+	const { changes, key, prefix, relaxedNullish, values } = parameters;
+	const from = values.first?.[key];
+	const to = values.second?.[key];
+	if (equal(from, to, { relaxedNullish })) return;
+	const prefixed = join([prefix, key], ".");
+	const change = {
+		from,
+		to,
+		key: prefixed
+	};
+	const diffs = isArrayOrPlainObject(from) || isArrayOrPlainObject(to) ? getDiffs(from, to, relaxedNullish, prefixed) : [];
+	changes.push(change);
+	const diffsLength = diffs.length;
+	for (let diffIndex = 0; diffIndex < diffsLength; diffIndex += 1) changes.push(diffs[diffIndex]);
+}
 function getMergeOptions(options) {
 	const actual = {
 		replaceableObjects: void 0,

package/dist/index.js

@@ -46,8 +46,8 @@ import { getValue } from "./internal/value/get.js";
 import { template } from "./string/template.js";
 import "./string/index.js";
 import { equal } from "./internal/value/equal.js";
-import { diff } from "./value/diff.js";
 import { clone } from "./value/clone.js";
+import { diff } from "./value/diff.js";
 import { merge } from "./value/merge.js";
 import { partial } from "./value/partial.js";
 import { smush } from "./value/smush.js";

package/dist/value/index.js

@@ -2,8 +2,8 @@ import { compare } from "../internal/value/compare.js";
 import { setValue } from "../internal/value/set.js";
 import { getValue } from "../internal/value/get.js";
 import { equal } from "../internal/value/equal.js";
-import { diff } from "./diff.js";
 import { clone } from "./clone.js";
+import { diff } from "./diff.js";
 import { merge } from "./merge.js";
 import { partial } from "./partial.js";
 import { smush } from "./smush.js";

package/package.json

@@ -101,5 +101,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.125.0"
+	"version": "0.126.0"
 }

package/src/beacon.ts

@@ -99,6 +99,9 @@ class Beacon<Value> {
 	}
 }
 
+/**
+ * Options for Beacon
+ */
 type BeaconOptions<Value> = {
 	/**
 	 * Method for comparing values for equality
@@ -321,4 +324,4 @@ const DESTROYED_BEACON = 'Cannot retrieve observable from a destroyed beacon';
 
 const DESTROYED_OBSERVABLE = 'Cannot subscribe to a destroyed observable';
 
-export type {Beacon, Observable, Observer, Subscription};
+export type {Beacon, BeaconOptions, Observable, Observer, Subscription};

package/src/function.ts

@@ -108,6 +108,9 @@ class Memoized<Callback extends GenericCallback> {
 	}
 }
 
+/**
+ * Options for memoized functions
+ */
 type MemoizedOptions<Callback extends GenericCallback> = {
 	/**
 	 * Callback for getting a cache key for the provided parameters
@@ -228,7 +231,7 @@ export function throttle<Callback extends GenericCallback>(
 	return getLimiter(callback, true, time);
 }
 
-export type {CancellableCallback, GenericCallback, Memoized};
+export type {CancellableCallback, GenericCallback, Memoized, MemoizedOptions};
 export {noop} from './internal/function';
 
 //

package/src/internal/value/equal.ts

@@ -2,7 +2,10 @@ import type {ArrayOrPlainObject, PlainObject, TypedArray} from '../../models';
 import {chunk} from '../array/chunk';
 import {isPlainObject, isTypedArray} from '../is';
 
-type EqualOptions = {
+/**
+ * Options for value equality comparison
+ */
+export type EqualOptions = {
 	/**
 	 * When `true`, strings are compared case-insensitively
 	 */

package/src/string/index.ts

@@ -2,4 +2,4 @@ export {getString, join, words} from '../internal/string';
 export type {PlainObject} from '../models';
 export {camelCase, capitalize, kebabCase, pascalCase, snakeCase, titleCase} from './case';
 export {createUuid, getUuid, parse, truncate} from './misc';
-export {template} from './template';
+export {template, type TemplateOptions} from './template';

package/src/string/template.ts

@@ -3,7 +3,10 @@ import {getValue} from '../internal/value/get';
 import {isPlainObject} from '../is';
 import type {PlainObject} from '../models';
 
-type TemplateOptions = {
+/**
+ * Options for templating strings
+ */
+export type TemplateOptions = {
 	/**
 	 * Ignore case when searching for variables?
 	 */

package/src/value/diff.ts

@@ -2,7 +2,10 @@ import {isArrayOrPlainObject} from '../internal/is';
 import {join} from '../internal/string';
 import {equal} from '../internal/value/equal';
 
-type DiffOptions = {
+/**
+ * Options for value comparison
+ */
+export type DiffOptions = {
 	/**
 	 * Should `null` and `undefined` be considered equal and ignored in results?
 	 */
@@ -29,7 +32,7 @@ export type DiffResult<First, Second = First> = {
 	values: Record<string, DiffValue>;
 };
 
-export type DiffType = 'full' | 'none' | 'partial';
+type DiffType = 'full' | 'none' | 'partial';
 
 /**
  * The difference between two values

package/src/value/index.ts

@@ -1,11 +1,11 @@
 export {compare} from '../internal/value/compare';
-export {diff} from './diff';
-export {equal} from '../internal/value/equal';
+export {equal, type EqualOptions} from '../internal/value/equal';
 export {getValue} from '../internal/value/get';
 export {setValue} from '../internal/value/set';
 export type {ArrayOrPlainObject, NestedPartial, PlainObject} from '../models';
 export {clone} from './clone';
-export {merge} from './merge';
+export {diff, type DiffOptions, type DiffResult, type DiffValue} from './diff';
+export {merge, type MergeOptions} from './merge';
 export {partial} from './partial';
 export {smush} from './smush';
 export {unsmush} from './unsmush';

package/src/value/merge.ts

@@ -5,7 +5,7 @@ import type {ArrayOrPlainObject, NestedPartial, PlainObject} from '../models';
 /**
  * Options for merging values
  */
-type MergeOptions = {
+export type MergeOptions = {
 	/**
 	 * Key _(or key epxressions)_ for values that should be replaced
 	 * ```ts

package/types/beacon.d.ts

@@ -34,6 +34,9 @@ declare class Beacon<Value> {
      */
     finish(): void;
 }
+/**
+ * Options for Beacon
+ */
 type BeaconOptions<Value> = {
     /**
      * Method for comparing values for equality
@@ -108,4 +111,4 @@ declare class Subscription<Value> {
  * @returns Beacon instance
  */
 export declare function beacon<Value>(value: Value, options?: BeaconOptions<Value>): Beacon<Value>;
-export type { Beacon, Observable, Observer, Subscription };
+export type { Beacon, BeaconOptions, Observable, Observer, Subscription };

package/types/function.d.ts

@@ -49,6 +49,9 @@ declare class Memoized<Callback extends GenericCallback> {
      */
     run(...parameters: Parameters<Callback>): ReturnType<Callback>;
 }
+/**
+ * Options for memoized functions
+ */
 type MemoizedOptions<Callback extends GenericCallback> = {
     /**
      * Callback for getting a cache key for the provided parameters
@@ -86,5 +89,5 @@ export declare function memoize<Callback extends GenericCallback>(callback: Call
  * @returns Throttled callback with a `cancel` method
  */
 export declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): CancellableCallback<Callback>;
-export type { CancellableCallback, GenericCallback, Memoized };
+export type { CancellableCallback, GenericCallback, Memoized, MemoizedOptions };
 export { noop } from './internal/function';

package/types/internal/value/equal.d.ts

@@ -1,4 +1,7 @@
-type EqualOptions = {
+/**
+ * Options for value equality comparison
+ */
+export type EqualOptions = {
     /**
      * When `true`, strings are compared case-insensitively
      */

package/types/string/index.d.ts

@@ -2,4 +2,4 @@ export { getString, join, words } from '../internal/string';
 export type { PlainObject } from '../models';
 export { camelCase, capitalize, kebabCase, pascalCase, snakeCase, titleCase } from './case';
 export { createUuid, getUuid, parse, truncate } from './misc';
-export { template } from './template';
+export { template, type TemplateOptions } from './template';

package/types/string/template.d.ts

@@ -1,5 +1,8 @@
 import type { PlainObject } from '../models';
-type TemplateOptions = {
+/**
+ * Options for templating strings
+ */
+export type TemplateOptions = {
     /**
      * Ignore case when searching for variables?
      */

package/types/value/diff.d.ts

@@ -1,4 +1,7 @@
-type DiffOptions = {
+/**
+ * Options for value comparison
+ */
+export type DiffOptions = {
     /**
      * Should `null` and `undefined` be considered equal and ignored in results?
      */
@@ -23,7 +26,7 @@ export type DiffResult<First, Second = First> = {
      */
     values: Record<string, DiffValue>;
 };
-export type DiffType = 'full' | 'none' | 'partial';
+type DiffType = 'full' | 'none' | 'partial';
 /**
  * The difference between two values
  */

package/types/value/index.d.ts

@@ -1,11 +1,11 @@
 export { compare } from '../internal/value/compare';
-export { diff } from './diff';
-export { equal } from '../internal/value/equal';
+export { equal, type EqualOptions } from '../internal/value/equal';
 export { getValue } from '../internal/value/get';
 export { setValue } from '../internal/value/set';
 export type { ArrayOrPlainObject, NestedPartial, PlainObject } from '../models';
 export { clone } from './clone';
-export { merge } from './merge';
+export { diff, type DiffOptions, type DiffResult, type DiffValue } from './diff';
+export { merge, type MergeOptions } from './merge';
 export { partial } from './partial';
 export { smush } from './smush';
 export { unsmush } from './unsmush';

package/types/value/merge.d.ts

@@ -2,7 +2,7 @@ import type { ArrayOrPlainObject, NestedPartial } from '../models';
 /**
  * Options for merging values
  */
-type MergeOptions = {
+export type MergeOptions = {
     /**
      * Key _(or key epxressions)_ for values that should be replaced
      * ```ts