@oscarpalmer/atoms 0.141.2 → 0.143.0

package/src/result.ts

@@ -1,4 +1,5 @@
 import {isPlainObject} from './internal/is';
+import {attemptPromise} from './promise';
 
 // #region Types
 
@@ -158,16 +159,16 @@ export function ok<Value>(value: Value): Ok<Value> {
  * @param error Error value
  * @returns Callback result
  */
-export function result<Value, E>(callback: () => Value, error: E): ExtendedErr<E> | Ok<Value>;
+export function attempt<Value, E>(callback: () => Value, error: E): ExtendedErr<E> | Ok<Value>;
 
 /**
  * Executes a callback, catching any errors, and returns a result
  * @param callback Callback to execute
  * @returns Callback result
  */
-export function result<Value>(callback: () => Value): Result<Value, Error>;
+export function attempt<Value>(callback: () => Value): Result<Value, Error>;
 
-export function result<Value, E>(
+export function attempt<Value, E>(
 	callback: () => Value,
 	err?: E,
 ): ExtendedErr<E> | Result<Value, E> {
@@ -180,7 +181,19 @@ export function result<Value, E>(
 	}
 }
 
-result.async = asyncResult;
+attempt.async = asyncAttempt;
+attempt.promise = attemptPromise;
+
+/**
+ * Executes a promise, catching any errors, and returns a result
+ * @param promise Promise to execute
+ * @param error Error value
+ * @returns Callback result
+ */
+async function asyncAttempt<Value, E>(
+	promise: Promise<Value>,
+	error: E,
+): Promise<ExtendedErr<E> | Ok<Awaited<Value>>>;
 
 /**
  * Executes a callback asynchronously, catching any errors, and returns a result
@@ -188,26 +201,33 @@ result.async = asyncResult;
  * @param error Error value
  * @returns Callback result
  */
-async function asyncResult<Value, E>(
+async function asyncAttempt<Value, E>(
 	callback: () => Promise<Value>,
 	error: E,
 ): Promise<ExtendedErr<E> | Ok<Value>>;
 
+/**
+ * Executes a promise, catching any errors, and returns a result
+ * @param promise Promise to execute
+ * @returns Callback result
+ */
+async function asyncAttempt<Value>(promise: Promise<Value>): Promise<Awaited<Value>>;
+
 /**
  * Executes a callback asynchronously, catching any errors, and returns a result
  * @param callback Callback to execute
  * @returns Callback result
  */
-async function asyncResult<Value>(callback: () => Promise<Value>): Promise<Result<Value>>;
+async function asyncAttempt<Value>(callback: () => Promise<Value>): Promise<Result<Value>>;
 
-async function asyncResult<Value, E>(
-	callback: () => Promise<Value>,
+async function asyncAttempt<Value, E>(
+	value: Promise<Value> | (() => Promise<Value>),
 	err?: E,
-): Promise<Result<Value, E>> {
+): Promise<unknown> {
 	try {
-		const value = await callback();
+		const result = await (typeof value === 'function' ? value() : value);
 
-		return ok(value);
+		return ok(result);
 	} catch (thrown) {
 		return getError((err ?? thrown) as E, err == null ? undefined : (thrown as Error));
 	}

package/src/sized/map.ts

@@ -5,7 +5,7 @@ import {getSizedMaximum} from '../internal/sized';
 /**
  * A Map with a maximum size
  *
- * Behaviour is similar to a _LRU_-cache, where the least recently used entries are removed
+ * Behavior is similar to a _LRU_-cache, where the least recently used entries are removed
  */
 export class SizedMap<Key = unknown, Value = unknown> extends Map<Key, Value> {
 	/**

package/src/sized/set.ts

@@ -4,7 +4,7 @@ import {getSizedMaximum} from '../internal/sized';
 
 /**
  * - A Set with a maximum size
- * - Behaviour is similar to a _LRU_-cache, where the oldest values are removed
+ * - Behavior is similar to a _LRU_-cache, where the oldest values are removed
  */
 export class SizedSet<Value = unknown> extends Set<Value> {
 	/**
@@ -84,7 +84,7 @@ export class SizedSet<Value = unknown> extends Set<Value> {
 	 * Get a value from the SizedSet, if it exists _(and move it to the end)_
 	 * @param value Value to get from the SizedSet
 	 * @param update Update the value's position in the SizedSet? _(defaults to `false`)_
-	 * @returns The value if it exists, otherwise `undefined`
+	 * @returns Found value if it exists, otherwise `undefined`
 	 */
 	get(value: Value, update?: boolean): Value | undefined {
 		if (this.has(value)) {

package/src/value/get-set.ts

@@ -1,2 +1,2 @@
 export {getValue} from '../internal/value/get';
-export {setValue} from '../internal/value/set';
+export {setValue} from '../internal/value/set';

package/src/value/merge.ts

@@ -101,7 +101,7 @@ function initializeMerger(options?: Partial<MergeOptions>): Merger {
 
 	return <Model extends ArrayOrPlainObject>(values: NestedPartial<Model>[]): Model =>
 		handleMerge(values, actual) as Model;
-};
+}
 
 function mergeObjects(
 	values: ArrayOrPlainObject[],

package/src/value/misc.ts

@@ -1,3 +1,4 @@
-export {partial} from './partial';
+export {omit} from './omit';
+export {pick} from './pick';
 export {smush, type Smushed} from './smush';
 export {unsmush, type Unsmushed} from './unsmush';

package/src/value/omit.ts

@@ -0,0 +1,19 @@
+import {partial} from '../internal/value/partial';
+import type {PlainObject} from '../models';
+
+// #region Functions
+
+/**
+ * Create a new object without the specified keys
+ * @param value Original object
+ * @param keys Keys to omit
+ * @returns Partial object without the specified keys
+ */
+export function omit<Value extends PlainObject, Key extends keyof Value>(
+	value: Value,
+	keys: Key[],
+): Omit<Value, Key> {
+	return partial(value, keys, true);
+}
+
+// #endregion

package/src/value/pick.ts

@@ -0,0 +1,19 @@
+import {partial} from '../internal/value/partial';
+import type {PlainObject} from '../models';
+
+// #region Functions
+
+/**
+ * Create a new object with only the specified keys
+ * @param value Original object
+ * @param keys Keys to use
+ * @returns Partial object with only the specified keys
+ */
+export function pick<Value extends PlainObject, Key extends keyof Value>(
+	value: Value,
+	keys: Key[],
+): Pick<Value, Key> {
+	return partial(value, keys, false);
+}
+
+// #endregion

package/types/color/misc/is.d.ts

@@ -2,39 +2,39 @@ import type { Color } from '../index';
 import type { HSLAColor, HSLColor, RGBAColor, RGBColor } from '../models';
 /**
  * Is the value a Color?
- * @param value The value to check
+ * @param value Value to check
  * @returns `true` if the value is a Color, otherwise `false`
  */
 export declare function isColor(value: unknown): value is Color;
 /**
  * Is the value a hex color?
- * @param value The value to check
+ * @param value Value to check
  * @param alpha Allow alpha channel? _(defaults to `true`)_
  * @returns `true` if the value is a hex color, otherwise `false`
  */
 export declare function isHexColor(value: unknown, alpha?: boolean): value is string;
 /**
  * Is the value an HSLA color?
- * @param value The value to check
+ * @param value Value to check
  * @returns `true` if the value is an HSLA color, otherwise `false`
  */
 export declare function isHslaColor(value: unknown): value is HSLAColor;
 /**
  * Is the value an HSL color?
- * @param value The value to check
+ * @param value Value to check
  * @returns `true` if the value is an HSL color, otherwise `false`
  */
 export declare function isHslColor(value: unknown): value is HSLColor;
 export declare function isHslLike(value: unknown): value is Record<keyof HSLColor, unknown>;
 /**
  * Is the value an RGBA color?
- * @param value The value to check
+ * @param value Value to check
  * @returns `true` if the value is an RGBA color, otherwise `false`
  */
 export declare function isRgbaColor(value: unknown): value is RGBAColor;
 /**
  * Is the value an RGB color?
- * @param value The value to check
+ * @param value Value to check
  * @returns `true` if the value is an RGB color, otherwise `false`
  */
 export declare function isRgbColor(value: unknown): value is RGBColor;

package/types/function/debounce.d.ts

@@ -1,4 +1,4 @@
-import type { CancellableCallback, GenericCallback } from '../models';
+import type { CancelableCallback, GenericCallback } from '../models';
 /**
  * Debounce a function, ensuring it is only called after `time` milliseconds have passed
  *
@@ -7,4 +7,4 @@ import type { CancellableCallback, GenericCallback } from '../models';
  * @param time Time in milliseconds to wait before calling the callback _(defaults to match frame rate)_
  * @returns Debounced callback with a `cancel` method
  */
-export declare function debounce<Callback extends GenericCallback>(callback: Callback, time?: number): CancellableCallback<Callback>;
+export declare function debounce<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;

package/types/function/memoize.d.ts

@@ -27,7 +27,7 @@ declare class Memoized<Callback extends GenericCallback> {
     /**
      * Get a result from the cache
      * @param key Key to get
-     * @returns The cached result or `undefined` if it does not exist
+     * @returns Cached result or `undefined` if it does not exist
      */
     get(key: unknown): ReturnType<Callback> | undefined;
     /**

package/types/function/throttle.d.ts

@@ -1,8 +1,8 @@
-import type { CancellableCallback, GenericCallback } from '../models';
+import type { CancelableCallback, GenericCallback } from '../models';
 /**
  * Throttle a function, ensuring it is only called once every `time` milliseconds
  * @param callback Callback to throttle
  * @param time Time in milliseconds to wait before calling the callback again _(defaults to match frame rate)_
  * @returns Throttled callback with a `cancel` method
  */
-export declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): CancellableCallback<Callback>;
+export declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;

package/types/index.d.ts

@@ -33,7 +33,8 @@ export * from './string/template';
 export * from './value/clone';
 export * from './value/diff';
 export * from './value/merge';
-export * from './value/partial';
+export * from './value/omit';
+export * from './value/pick';
 export * from './value/smush';
 export * from './value/unsmush';
 export * from './beacon';

package/types/internal/function/limiter.d.ts

@@ -1,3 +1,3 @@
-import type { CancellableCallback } from '../../models';
+import type { CancelableCallback } from '../../models';
 import type { GenericCallback } from '../../models';
-export declare function getLimiter<Callback extends GenericCallback>(callback: Callback, throttler: boolean, time?: number): CancellableCallback<Callback>;
+export declare function getLimiter<Callback extends GenericCallback>(callback: Callback, throttler: boolean, time?: number): CancelableCallback<Callback>;

package/types/internal/math/aggregate.d.ts

@@ -5,6 +5,7 @@ type Aggregation = {
 };
 export type AggregationType = 'average' | 'max' | 'min' | 'sum';
 export declare function aggregate(type: AggregationType, array: unknown[], key: unknown): Aggregation;
+export declare function getAggregateCallback(key: unknown): Function | undefined;
 /**
  * Get the maximum value from a list of items
  * @param items List of items

package/types/internal/number.d.ts

@@ -18,6 +18,6 @@ export declare function clamp(value: number, minimum: number, maximum: number, l
 /**
  * Get the number value from an unknown value _(based on Lodash)_
  * @param value Original value
- * @returns The value as a number, or `NaN` if the value is unable to be parsed
+ * @returns Original value as a number, or `NaN` if the value is unable to be parsed
  */
 export declare function getNumber(value: unknown): number;

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

@@ -0,0 +1,2 @@
+export declare function partial<Value extends object, Key extends keyof Value>(value: unknown, keys: Key[], omit: true): Omit<Value, Key>;
+export declare function partial<Value extends object, Key extends keyof Value>(value: unknown, keys: Key[], omit: false): Pick<Value, Key>;

package/types/is.d.ts

@@ -1,10 +1,16 @@
 import type { Primitive } from './models';
 /**
  * Is the value empty, or only containing `null` or `undefined` values?
- * @param value Object to check
- * @returns `true` if the object is considered empty, otherwise `false`
+ * @param value Value to check
+ * @returns `true` if the value is considered empty, otherwise `false`
  */
 export declare function isEmpty(value: unknown): boolean;
+/**
+ * Is the value not `undefined` or `null`?
+ * @param value Value to check
+ * @returns `true` if the value is not `undefined` or `null`, otherwise `false`
+ */
+export declare function isNonNullable(value: unknown): value is Exclude<unknown, undefined | null>;
 /**
  * Is the value `undefined` or `null`?
  * @param value Value to check

package/types/math.d.ts

@@ -41,6 +41,26 @@ export declare function count<Item extends PlainObject>(array: Item[], key: keyo
  * @return Number of items, or `NaN` if no count can be calculated
  */
 export declare function count(values: unknown[]): number;
+/**
+ * Get the median value from a list of items
+ * @param array List of items
+ * @param callback Callback to get an item's value
+ * @returns Median value, or `NaN` if no median can be calculated
+ */
+export declare function median<Item>(array: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
+/**
+ * Get the median value from a list of items
+ * @param array List of items
+ * @param key Key to use for value
+ * @returns Median value, or `NaN` if no median can be calculated
+ */
+export declare function median<Item extends PlainObject>(array: Item[], key: keyof NumericalValues<Item>): number;
+/**
+ * Get the median value from a list of numbers
+ * @param array List of numbers
+ * @returns Median value, or `NaN` if no median can be calculated
+ */
+export declare function median(array: number[]): number;
 /**
  * Get the minimum value from a list of items
  * @param items List of items

package/types/models.d.ts

@@ -9,9 +9,9 @@ export type ArrayOrPlainObject = unknown[] | Record<PropertyKey, unknown>;
  */
 export type BuiltIns = void | Date | Primitive | RegExp;
 /**
- * An extend callback that can be cancelled
+ * An extend callback that can be canceled
  */
-export type CancellableCallback<Callback extends GenericCallback> = Callback & {
+export type CancelableCallback<Callback extends GenericCallback> = Callback & {
     /**
      * Cancel the callback
      */

package/types/promise.d.ts

@@ -1,3 +1,13 @@
+import type { RequiredKeys } from './models';
+export declare class CancelablePromise<Value = void> extends Promise<Value> {
+    #private;
+    constructor(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void);
+    /**
+     * Cancel the promise, rejecting it with an optional reason
+     * @param reason Optional reason for canceling the promise
+     */
+    cancel(reason?: unknown): void;
+}
 type FulfilledPromiseResult<Value> = {
     status: typeof TYPE_FULFILLED;
     value: Value;
@@ -12,6 +22,10 @@ type PromiseOptions = {
      */
     time?: number;
 };
+/**
+ * Promise handling strategy
+ */
+export type PromiseStrategy = 'complete' | 'first';
 export declare class PromiseTimeoutError extends Error {
     constructor();
 }
@@ -19,27 +33,33 @@ type Promises<Items extends unknown[]> = {
     [K in keyof Items]: Promise<Items[K]>;
 };
 type PromisesOptions = {
-    eager?: boolean;
     signal?: AbortSignal;
+    strategy?: PromiseStrategy;
 };
 type PromisesResult<Items extends unknown[]> = {
-    [K in keyof Items]: PromisesResultItem<Items[K]>;
+    [K in keyof Items]: Items[K] extends Promise<infer Value> ? PromisesResultItem<Value> : never;
 };
 type PromisesResultItem<Value> = FulfilledPromiseResult<Value> | RejectedPromiseResult;
 type RejectedPromiseResult = {
     status: typeof TYPE_REJECTED;
     reason: unknown;
 };
+/**
+ * Create a cancelable promise
+ * @param executor Executor function for the promise
+ * @returns Cancelable promise
+ */
+export declare function cancelable<Value>(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void): CancelablePromise<Value>;
 /**
  * Create a delayed promise that resolves after a certain amount of time, or rejects if aborted
  * @param options Options for the delay
- * @returns A delayed promise
+ * @returns Delayed promise
  */
 export declare function delay(options?: PromiseOptions): Promise<void>;
 /**
  * Create a delayed promise that resolves after a certain amount of time
  * @param time How long to wait for _(in milliseconds; defaults to `0`)_
- * @returns A delayed promise
+ * @returns Delayed promise
  */
 export declare function delay(time?: number): Promise<void>;
 /**
@@ -55,19 +75,23 @@ export declare function isFulfilled<Value>(value: unknown): value is FulfilledPr
  */
 export declare function isRejected(value: unknown): value is RejectedPromiseResult;
 /**
- * ---
+ * Handle a list of promises, returning their results in an ordered array.
+ *
+ * Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results
  * @param items List of promises
  * @param options Options for handling the promises
  * @return List of results
  */
-export declare function promises<Items extends unknown[], Options extends PromisesOptions>(items: Promises<Items>, options?: Options): Promise<Options['eager'] extends true ? Items : PromisesResult<Items>>;
+export declare function promises<Items extends unknown[], Options extends PromisesOptions>(items: Promises<Items>, options?: Options): Promise<Options['strategy'] extends 'first' ? Items : PromisesResult<Items>>;
 /**
- * Handle a list of promises, returning their results in an ordered array. If any promise in the list is rejected, the whole function will reject
+ * Handle a list of promises, returning their results in an ordered array.
+ *
+ * If any promise in the list is rejected, the whole function will reject
  * @param items List of promises
- * @param eager Reject immediately if any promise is rejected
+ * @param strategy Strategy for handling the promises; rejects on the first error encountered
  * @return List of results
  */
-export declare function promises<Items extends unknown[]>(items: Promises<Items>, eager: true): Promise<Items>;
+export declare function promises<Items extends unknown[]>(items: Promises<Items>, strategy: 'first'): Promise<Items>;
 /**
  * Handle a list of promises, returning their results in an ordered array of rejected and resolved results
  * @param items List of promises
@@ -75,8 +99,41 @@ export declare function promises<Items extends unknown[]>(items: Promises<Items>
  * @return List of results
  */
 export declare function promises<Items extends unknown[]>(items: Promises<Items>, signal?: AbortSignal): Promise<PromisesResult<Items>>;
-export declare function timed(promise: Promise<unknown>, options: PromiseOptions): Promise<unknown>;
-export declare function timed(promise: Promise<unknown>, time: number): Promise<unknown>;
+/**
+ * Create a promise that should be settled within a certain amount of time
+ * @param promise Promise to settle
+ * @param options Timed options
+ * @returns Timed promise
+ */
+export declare function timed<Value>(promise: Promise<Value>, options: RequiredKeys<PromiseOptions, 'time'>): Promise<Value>;
+/**
+ * Create a promise that should be settled within a certain amount of time
+ * @param promise Promise to settle
+ * @param time How long to wait for _(in milliseconds; defaults to `0`)_
+ * @returns Timed promise
+ */
+export declare function timed<Value>(promise: Promise<Value>, time: number): Promise<Value>;
+/**
+ * Wrap a promise with safety handlers, with optional abort capabilities and timeout
+ * @param promise Promise to wrap
+ * @param options Options for the promise
+ * @returns Wrapped promise
+ */
+export declare function attemptPromise<Value>(promise: Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
+/**
+ * Wrap a promise-returning callback with safety handlers, with optional abort capabilities and timeout
+ * @param callback Callback to wrap
+ * @param options Options for the promise
+ * @returns Promise-wrapped callback
+ */
+export declare function attemptPromise<Value>(callback: () => Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
+/**
+ * Wrap a callback with a promise and safety handlers, with optional abort capabilities and timeout
+ * @param callback Callback to wrap
+ * @param options Options for the promise
+ * @returns Promise-wrapped callback
+ */
+export declare function attemptPromise<Value>(callback: () => Value, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
 declare const TYPE_FULFILLED = "fulfilled";
 declare const TYPE_REJECTED = "rejected";
 export {};

package/types/random.d.ts

@@ -35,9 +35,9 @@ export declare function getRandomItem<Value>(array: Value[]): Value | undefined;
  */
 export declare function getRandomItems<Value>(array: Value[], amount: number): Value[];
 /**
- * Get an shuffled array
+ * Get a shuffled array
  * @param array Array to get random items from
- * @returns A shuffled version of the original array
+ * @returns Shuffled version of the original array
  */
 export declare function getRandomItems<Value>(array: Value[]): Value[];
 export { getRandomFloat, getRandomInteger } from './internal/random';

package/types/result.d.ts

@@ -1,3 +1,4 @@
+import { attemptPromise } from './promise';
 /**
  * An error result
  */
@@ -83,29 +84,43 @@ export declare function ok<Value>(value: Value): Ok<Value>;
  * @param error Error value
  * @returns Callback result
  */
-export declare function result<Value, E>(callback: () => Value, error: E): ExtendedErr<E> | Ok<Value>;
+export declare function attempt<Value, E>(callback: () => Value, error: E): ExtendedErr<E> | Ok<Value>;
 /**
  * Executes a callback, catching any errors, and returns a result
  * @param callback Callback to execute
  * @returns Callback result
  */
-export declare function result<Value>(callback: () => Value): Result<Value, Error>;
-export declare namespace result {
-    var async: typeof asyncResult;
+export declare function attempt<Value>(callback: () => Value): Result<Value, Error>;
+export declare namespace attempt {
+    var async: typeof asyncAttempt;
+    var promise: typeof attemptPromise;
 }
+/**
+ * Executes a promise, catching any errors, and returns a result
+ * @param promise Promise to execute
+ * @param error Error value
+ * @returns Callback result
+ */
+declare function asyncAttempt<Value, E>(promise: Promise<Value>, error: E): Promise<ExtendedErr<E> | Ok<Awaited<Value>>>;
 /**
  * Executes a callback asynchronously, catching any errors, and returns a result
  * @param callback Callback to execute
  * @param error Error value
  * @returns Callback result
  */
-declare function asyncResult<Value, E>(callback: () => Promise<Value>, error: E): Promise<ExtendedErr<E> | Ok<Value>>;
+declare function asyncAttempt<Value, E>(callback: () => Promise<Value>, error: E): Promise<ExtendedErr<E> | Ok<Value>>;
+/**
+ * Executes a promise, catching any errors, and returns a result
+ * @param promise Promise to execute
+ * @returns Callback result
+ */
+declare function asyncAttempt<Value>(promise: Promise<Value>): Promise<Awaited<Value>>;
 /**
  * Executes a callback asynchronously, catching any errors, and returns a result
  * @param callback Callback to execute
  * @returns Callback result
  */
-declare function asyncResult<Value>(callback: () => Promise<Value>): Promise<Result<Value>>;
+declare function asyncAttempt<Value>(callback: () => Promise<Value>): Promise<Result<Value>>;
 /**
  * Gets the value of an ok result _(or a default value)_
  * @param value Result to unwrap

package/types/sized/map.d.ts

@@ -1,7 +1,7 @@
 /**
  * A Map with a maximum size
  *
- * Behaviour is similar to a _LRU_-cache, where the least recently used entries are removed
+ * Behavior is similar to a _LRU_-cache, where the least recently used entries are removed
  */
 export declare class SizedMap<Key = unknown, Value = unknown> extends Map<Key, Value> {
     #private;

package/types/sized/set.d.ts

@@ -1,6 +1,6 @@
 /**
  * - A Set with a maximum size
- * - Behaviour is similar to a _LRU_-cache, where the oldest values are removed
+ * - Behavior is similar to a _LRU_-cache, where the oldest values are removed
  */
 export declare class SizedSet<Value = unknown> extends Set<Value> {
     #private;
@@ -36,7 +36,7 @@ export declare class SizedSet<Value = unknown> extends Set<Value> {
      * Get a value from the SizedSet, if it exists _(and move it to the end)_
      * @param value Value to get from the SizedSet
      * @param update Update the value's position in the SizedSet? _(defaults to `false`)_
-     * @returns The value if it exists, otherwise `undefined`
+     * @returns Found value if it exists, otherwise `undefined`
      */
     get(value: Value, update?: boolean): Value | undefined;
 }

package/types/value/misc.d.ts

@@ -1,3 +1,4 @@
-export { partial } from './partial';
+export { omit } from './omit';
+export { pick } from './pick';
 export { smush, type Smushed } from './smush';
 export { unsmush, type Unsmushed } from './unsmush';

package/types/value/omit.d.ts

@@ -0,0 +1,8 @@
+import type { PlainObject } from '../models';
+/**
+ * Create a new object without the specified keys
+ * @param value Original object
+ * @param keys Keys to omit
+ * @returns Partial object without the specified keys
+ */
+export declare function omit<Value extends PlainObject, Key extends keyof Value>(value: Value, keys: Key[]): Omit<Value, Key>;

package/types/value/{partial.d.ts → pick.d.ts}

@@ -5,4 +5,4 @@ import type { PlainObject } from '../models';
  * @param keys Keys to use
  * @returns Partial object with only the specified keys
  */
-export declare function partial<Value extends PlainObject, Key extends keyof Value>(value: Value, keys: Key[]): Pick<Value, Key>;
+export declare function pick<Value extends PlainObject, Key extends keyof Value>(value: Value, keys: Key[]): Pick<Value, Key>;

package/dist/value/partial.js

@@ -1,17 +0,0 @@
-/**
-* Create a new object with only the specified keys
-* @param value Original object
-* @param keys Keys to use
-* @returns Partial object with only the specified keys
-*/
-function partial(value, keys) {
-	if (typeof value !== "object" || value === null || Object.keys(value).length === 0 || !Array.isArray(keys) || keys.length === 0) return {};
-	const { length } = keys;
-	const partials = {};
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		if (key in value) partials[key] = value[key];
-	}
-	return partials;
-}
-export { partial };