@oscarpalmer/atoms 0.213.0 → 0.214.0

package/dist/models/value/value.merge.model.mjs

@@ -0,0 +1,5 @@
+//#region src/models/value/value.merge.model.ts
+const MERGE_SYMBOL_ASSIGN = Symbol("assign");
+const MERGE_SYMBOL_MERGE = Symbol("merge");
+//#endregion
+export { MERGE_SYMBOL_ASSIGN, MERGE_SYMBOL_MERGE };

package/dist/models/value/value.misc.model.d.mts

@@ -0,0 +1,33 @@
+import { NestedKeys, NestedValue, PlainObject, Simplify, ToString, UnionToIntersection } from "../index.mjs";
+//#region src/models/value/value.misc.model.d.ts
+export type ComparisonHandler<Value = any> = (first: Value, second: Value) => number;
+/**
+ * Thanks, type-fest!
+ */
+type KeysOfUnion<ObjectType> = keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
+/**
+ * A shaken object, without any `undefined` values
+ */
+export type Shaken<Value extends PlainObject> = Simplify<{ [Key in keyof Value as undefined extends Value[Key] ? never : Key]: Value[Key]; } & { [Key in keyof Value as undefined extends Value[Key] ? [Value[Key]] extends [undefined] ? never : Key : never]?: Exclude<Value[Key], undefined>; }>;
+/**
+ * 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>>; }>;
+/**
+ * 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}`>>;
+export type UnsmushedKey = {
+  order: number;
+  value: string;
+};
+export declare const COMPARE_NAME: string;
+export declare const VALUE_MISC_EXPRESSION_BRACKET: RegExp;
+export declare const VALUE_MISC_EXPRESSION_DOTS: RegExp;
+export declare const VALUE_MISC_EXPRESSION_NESTED: RegExp;
+export declare const VALUE_MISC_NESTED_MESSAGE_INPUT = "Expected data to be an object";
+export declare const VALUE_MISC_NESTED_MESSAGE_MISSING = "Expected property to exist in object";
+export declare const VALUE_MISC_NESTED_MESSAGE_PATH = "Expected path to be a string";
+export declare const VALUE_MISC_NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
+export declare const SMUSH_MAX_DEPTH = 100;
+//#endregion

package/dist/models/value/value.misc.model.mjs

@@ -0,0 +1,12 @@
+//#region src/models/value/value.misc.model.ts
+const COMPARE_NAME = "compare";
+const VALUE_MISC_EXPRESSION_BRACKET = /\[(\w+)\]/g;
+const VALUE_MISC_EXPRESSION_DOTS = /^\.|\.$/g;
+const VALUE_MISC_EXPRESSION_NESTED = /\.|\[\w+\]/;
+const VALUE_MISC_NESTED_MESSAGE_INPUT = "Expected data to be an object";
+const VALUE_MISC_NESTED_MESSAGE_MISSING = "Expected property to exist in object";
+const VALUE_MISC_NESTED_MESSAGE_PATH = "Expected path to be a string";
+const VALUE_MISC_NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
+const SMUSH_MAX_DEPTH = 100;
+//#endregion
+export { COMPARE_NAME, SMUSH_MAX_DEPTH, VALUE_MISC_EXPRESSION_BRACKET, VALUE_MISC_EXPRESSION_DOTS, VALUE_MISC_EXPRESSION_NESTED, VALUE_MISC_NESTED_MESSAGE_INPUT, VALUE_MISC_NESTED_MESSAGE_MISSING, VALUE_MISC_NESTED_MESSAGE_PATH, VALUE_MISC_NESTED_MESSAGE_UNSAFE };

package/dist/models/value/value.transform.model.d.mts

@@ -0,0 +1,28 @@
+import { PlainObject } from "../index.mjs";
+//#region src/models/value/value.transform.model.d.ts
+export type InternalTransformer<Value extends PlainObject> = {
+  [TRANSFORM_SYMBOL]: TransformHandler<Value>;
+} & Transformer<Value>;
+/**
+ * A callback transform an object's properties
+ */
+export 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
+ */
+export type TransformCallbacks<Value extends PlainObject> = Partial<{ [Key in keyof Value]: (value: Value[Key]) => Value[Key]; }>;
+export type TransformHandler<Value extends PlainObject> = TransformCallback<Value, keyof Value> | TransformCallbacks<Value>;
+/**
+ * A transformer for an object, with predefined callbacks for transforming its properties
+ */
+export type Transformer<Value extends PlainObject> = {
+  /**
+   * Transform an object's properties
+   *
+   * @param value Object to transform
+   * @returns Transformed object
+   */
+  transform(value: Value): Value;
+};
+export declare const TRANSFORM_SYMBOL: unique symbol;
+//#endregion

package/dist/models/value/value.transform.model.mjs

@@ -0,0 +1,4 @@
+//#region src/models/value/value.transform.model.ts
+const TRANSFORM_SYMBOL = Symbol("transform");
+//#endregion
+export { TRANSFORM_SYMBOL };

package/dist/plan/generate.d.mts

@@ -1,4 +1,5 @@
+import { AsyncPlanState, PlanState } from "../models/plan.model.mjs";
 //#region src/plan/generate.d.ts
-export declare function asyncGenerate(callback: (...parameters: unknown[]) => AsyncGenerator, parameters: unknown[], unwrap: boolean): Promise<unknown>;
-export declare function generate(callback: (...parameters: unknown[]) => Generator, parameters: unknown[], unwrap: boolean): unknown;
+export declare function asyncGenerate(input: AsyncPlanState | ((...parameters: unknown[]) => AsyncGenerator), parameters: unknown[], unwrap: boolean): Promise<unknown>;
+export declare function generate(input: PlanState | ((...parameters: unknown[]) => Generator), parameters: unknown[], unwrap: boolean): unknown;
 //#endregion

package/dist/plan/generate.mjs

@@ -1,14 +1,16 @@
 import { isError, isOk } from "../internal/result/misc.mjs";
 //#region src/plan/generate.ts
-async function asyncGenerate(callback, parameters, unwrap) {
-	const generator = callback(...parameters);
+async function asyncGenerate(input, parameters, unwrap) {
+	let generator;
+	if (typeof input === "function") generator = input(...parameters);
+	else generator = input.generator(...parameters);
 	let success = true;
 	let lastValue;
 	try {
 		while (true) {
 			const next = await generator.next(lastValue);
-			const { done } = next;
-			let { value } = next;
+			const done = next.done === true;
+			const { value } = next;
 			if (value instanceof Error) throw value;
 			if (isError(value)) throw value.error;
 			lastValue = value;
@@ -18,13 +20,15 @@ async function asyncGenerate(callback, parameters, unwrap) {
 		lastValue = error;
 		success = false;
 	} finally {
-		await generator?.return(lastValue);
+		await generator.return(lastValue);
 	}
 	if (success) return unwrap && isOk(lastValue) ? lastValue.value : lastValue;
 	throw lastValue;
 }
-function generate(callback, parameters, unwrap) {
-	const generator = callback(...parameters);
+function generate(input, parameters, unwrap) {
+	let generator;
+	if (typeof input === "function") generator = input(...parameters);
+	else generator = input.generator(...parameters);
 	let success = true;
 	let lastValue;
 	try {

package/dist/plan/index.d.mts

@@ -1,4 +1,4 @@
-import { AsyncPlan, Plan } from "../internal/models/plan.model.mjs";
+import { AsyncPlan, Plan } from "../models/plan.model.mjs";
 import { asyncAttemptRun, attemptRun } from "./result.mjs";
 import { asyncRun, run } from "./run.mjs";
 //#region src/plan/index.d.ts

package/dist/plan/index.mjs

@@ -1,4 +1,4 @@
-import { PLAN_MESSAGE_PLAN_INPUT, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../internal/models/plan.model.mjs";
+import { PLAN_MESSAGE_PLAN_INPUT, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../models/plan.model.mjs";
 import { isAsyncGenerator, isGenerator } from "./is.mjs";
 import { asyncAttemptRun, attemptRun, attemptRunAsyncPlan, attemptRunPlan } from "./result.mjs";
 import { asyncRun, run, runAsyncPlan, runPlan } from "./run.mjs";

package/dist/plan/is.d.mts

@@ -1,4 +1,4 @@
-import { AsyncPlan, Plan } from "../internal/models/plan.model.mjs";
+import { AsyncPlan, Plan } from "../models/plan.model.mjs";
 //#region src/plan/is.d.ts
 /**
  * Is the value an asynchronous generator function?

package/dist/plan/is.mjs

@@ -1,4 +1,4 @@
-import { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../internal/models/plan.model.mjs";
+import { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../models/plan.model.mjs";
 //#region src/plan/is.ts
 /**
 * Is the value an asynchronous generator function?

package/dist/plan/misc.d.mts

@@ -1,4 +1,4 @@
-import { Ok } from "../internal/models/result.model.mjs";
+import { Ok } from "../models/result.model.mjs";
 //#region src/plan/misc.d.ts
 /**
  * Create an immediately failing plan

package/dist/plan/models.d.mts

@@ -1,2 +1,2 @@
-import { AsyncPlan, Plan } from "../internal/models/plan.model.mjs";
+import { AsyncPlan, Plan } from "../models/plan.model.mjs";
 export type { AsyncPlan, Plan };

package/dist/plan/result.d.mts

@@ -1,5 +1,5 @@
-import { Result } from "../internal/models/result.model.mjs";
-import { AsyncPlan, InternalAsyncPlan, InternalPlan, Plan, PlanError, PlanOk } from "../internal/models/plan.model.mjs";
+import { Result } from "../models/result.model.mjs";
+import { AsyncPlan, InternalAsyncPlan, InternalPlan, Plan, PlanError, PlanOk } from "../models/plan.model.mjs";
 //#region src/plan/result.d.ts
 /**
  * Attempt to run the generator to completion

package/dist/plan/result.mjs

@@ -1,5 +1,5 @@
 import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
-import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../internal/models/plan.model.mjs";
+import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../models/plan.model.mjs";
 import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "./is.mjs";
 import { asyncGenerate, generate } from "./generate.mjs";
 //#region src/plan/result.ts
@@ -14,10 +14,10 @@ function attemptRun(input, ...parameters) {
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function attemptRunAsyncPlan(...parameters) {
-	return asyncAttempt(() => asyncGenerate(this[PLAN_SYMBOL].generator, parameters, true));
+	return asyncAttempt(() => asyncGenerate(this[PLAN_SYMBOL], parameters, true));
 }
 function attemptRunPlan(...parameters) {
-	return attempt(() => generate(this[PLAN_SYMBOL].generator, parameters, true));
+	return attempt(() => generate(this[PLAN_SYMBOL], parameters, true));
 }
 attemptRun.async = asyncAttemptRun;
 //#endregion

package/dist/plan/run.d.mts

@@ -1,4 +1,4 @@
-import { AsyncPlan, InternalAsyncPlan, InternalPlan, Plan, PlanReturned } from "../internal/models/plan.model.mjs";
+import { AsyncPlan, InternalAsyncPlan, InternalPlan, Plan, PlanReturned } from "../models/plan.model.mjs";
 import { asyncAttemptRun, attemptRun } from "./result.mjs";
 //#region src/plan/run.d.ts
 /**

package/dist/plan/run.mjs

@@ -1,4 +1,4 @@
-import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../internal/models/plan.model.mjs";
+import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../models/plan.model.mjs";
 import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "./is.mjs";
 import { asyncGenerate, generate } from "./generate.mjs";
 import { asyncAttemptRun, attemptRun } from "./result.mjs";
@@ -14,10 +14,10 @@ function run(input, ...parameters) {
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function runAsyncPlan(...parameters) {
-	return asyncGenerate(this[PLAN_SYMBOL].generator, parameters, false);
+	return asyncGenerate(this[PLAN_SYMBOL], parameters, false);
 }
 function runPlan(...parameters) {
-	return generate(this[PLAN_SYMBOL].generator, parameters, false);
+	return generate(this[PLAN_SYMBOL], parameters, false);
 }
 asyncRun.attempt = asyncAttemptRun;
 run.async = asyncRun;

package/dist/promise/delay.d.mts

@@ -1,4 +1,4 @@
-import { PromiseOptions } from "./models.mjs";
+import { PromiseOptions } from "../models/promise.model.mjs";
 //#region src/promise/delay.d.ts
 /**
  * Create a delayed promise that resolves after a certain amount of time, or rejects if aborted

package/dist/promise/delay.mjs

@@ -1,5 +1,6 @@
 import { createAborter } from "../internal/aborter.mjs";
-import { LIMITER_WAIT, getLimiter } from "../internal/function/limit.mjs";
+import { LIMITER_WAIT } from "../models/function/limiter.model.mjs";
+import { getLimiter } from "../internal/function/limit.mjs";
 import { createPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
 //#region src/promise/delay.ts

package/dist/promise/helpers.d.mts

@@ -1,5 +1,5 @@
-import { RequiredKeys } from "../models.mjs";
-import { FulfilledPromise, PromiseOptions, PromiseStrategy, PromisesOptions, PromisesValue, RejectedPromise } from "./models.mjs";
+import { RequiredKeys } from "../models/index.mjs";
+import { FulfilledPromise, PromiseOptions, PromiseStrategy, PromisesOptions, PromisesValue, RejectedPromise } from "../models/promise.model.mjs";
 //#region src/promise/helpers.d.ts
 export declare function createPromiseOptions(input: unknown): RequiredKeys<PromiseOptions, "time">;
 export declare function createPromisesOptions(input: unknown): RequiredKeys<PromisesOptions, "strategy">;

package/dist/promise/helpers.mjs

@@ -1,7 +1,7 @@
 import { isPlainObject } from "../internal/is.mjs";
 import { error, ok } from "../internal/result/misc.mjs";
 import { getNumberOrDefault } from "../internal/defaults.mjs";
-import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
+import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "../models/promise.model.mjs";
 //#region src/promise/helpers.ts
 function createPromiseOptions(input) {
 	if (typeof input === "number") return { time: getNumberOrDefault(input, 0) };
@@ -48,7 +48,10 @@ function getStrategyOrDefault(value) {
 * @returns `true` if the value is a fulfilled _Promise_ result, otherwise `false`
 */
 function isFulfilled(value) {
-	return isType(value, PROMISE_TYPE_FULFILLED);
+	return isPromiseResult(value, PROMISE_TYPE_FULFILLED);
+}
+function isPromiseResult(value, type) {
+	return isPlainObject(value) && "status" in value && value.status === type;
 }
 /**
 * Is the value a rejected _Promise_ result?
@@ -57,10 +60,7 @@ function isFulfilled(value) {
 * @returns `true` if the value is a rejected _Promise_ result, otherwise `false`
 */
 function isRejected(value) {
-	return isType(value, PROMISE_TYPE_REJECTED);
-}
-function isType(value, type) {
-	return isPlainObject(value) && "status" in value && value.status === type;
+	return isPromiseResult(value, PROMISE_TYPE_REJECTED);
 }
 //#endregion
 export { createPromiseOptions, createPromisesOptions, getResultsFromPromises, getStrategyOrDefault, isFulfilled, isRejected };

package/dist/promise/index.d.mts

@@ -1,5 +1,5 @@
-import { PlainObject } from "../models.mjs";
-import { PromiseOptions, PromiseStrategy, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValues } from "./models.mjs";
+import { PlainObject } from "../models/index.mjs";
+import { PromiseOptions, PromiseStrategy, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValues } from "../models/promise.model.mjs";
 //#region src/promise/index.d.ts
 /**
  * Wrap a _Promise_ with safety handlers

package/dist/promise/index.mjs

@@ -1,7 +1,7 @@
 import { isArrayOrPlainObject } from "../internal/is.mjs";
 import { createAborter } from "../internal/aborter.mjs";
 import { asyncAttempt } from "../internal/result/attempt.mjs";
-import { PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
+import { PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "../models/promise.model.mjs";
 import { createPromiseOptions, createPromisesOptions, getResultsFromPromises } from "./helpers.mjs";
 import { handleResult, settlePromise } from "./misc.mjs";
 import { getTimedPromise } from "./timed.mjs";

package/dist/promise/misc.d.mts

@@ -1,6 +1,6 @@
-import { Result } from "../internal/models/result.model.mjs";
-import { Aborter } from "../internal/aborter.mjs";
-import { CancelablePromise, PromiseParameters } from "./models.mjs";
+import { Aborter } from "../models/aborter.model.mjs";
+import { Result } from "../models/result.model.mjs";
+import { CancelablePromise, PromiseParameters } from "../models/promise.model.mjs";
 import { toPromise } from "../result/misc.mjs";
 import { isFulfilled, isRejected } from "./helpers.mjs";
 //#region src/promise/misc.d.ts

package/dist/promise/misc.mjs

@@ -1,7 +1,6 @@
 import { error, ok } from "../internal/result/misc.mjs";
 import { toPromise } from "../result/misc.mjs";
-import { PROMISE_MESSAGE_EXPECTATION_RESULT } from "./constants.mjs";
-import { CancelablePromise } from "./models.mjs";
+import { CancelablePromise, PROMISE_MESSAGE_EXPECTATION_RESULT } from "../models/promise.model.mjs";
 import { isFulfilled, isRejected } from "./helpers.mjs";
 //#region src/promise/misc.ts
 /**
@@ -17,7 +16,8 @@ function handleResult(status, parameters) {
 	const { aborter, complete, data, handlers, index, key, value } = parameters;
 	if (aborter?.signal.aborted ?? false) return;
 	if (!complete && status === "rejected") {
-		settlePromise(handlers.reject, value, aborter);
+		aborter?.cancel();
+		handlers.reject(value);
 		return;
 	}
 	data.result[key] = !complete ? value : status === "fulfilled" ? {
@@ -27,7 +27,10 @@ function handleResult(status, parameters) {
 		status,
 		reason: value
 	};
-	if (index === data.last) settlePromise(handlers.resolve, data.result, aborter);
+	if (index === data.last) {
+		aborter?.cancel();
+		handlers.resolve(data.result);
+	}
 }
 function settlePromise(settler, value, aborter) {
 	aborter?.cancel();

package/dist/promise/models.d.mts

@@ -1,106 +1,2 @@
-import { ArrayOrPlainObject, GenericCallback, Key } from "../models.mjs";
-import { Result } from "../internal/models/result.model.mjs";
-import { Aborter } from "../internal/aborter.mjs";
-import { PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
-//#region src/promise/models.d.ts
-/**
- * A _Promise_ that can be canceled
- */
-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;
-}
-/**
- * A _Promise_ that was fulfilled
- */
-export type FulfilledPromise<Value> = {
-  /**
-   * Status of the _Promise_
-   */
-  status: typeof PROMISE_TYPE_FULFILLED;
-  /**
-   * Value of the _Promise_
-   */
-  value: Awaited<Value>;
-};
-export type PromiseData = {
-  last: number;
-  result: ArrayOrPlainObject;
-};
-export type PromiseHandlers = {
-  resolve(value: unknown[]): void;
-  reject(reason: unknown): void;
-};
-/**
- * Options for a _Promise_-handling function
- */
-export type PromiseOptions = {
-  /**
-   * AbortSignal for aborting the _Promise_; when aborted, the _Promise_ will reject with the reason of the signal
-   */
-  signal?: AbortSignal;
-  /**
-   * How long to wait for _(in milliseconds; defaults to `0`)_
-   */
-  time?: number;
-};
-export type PromiseParameters = {
-  aborter?: Aborter;
-  complete: boolean;
-  data: PromiseData;
-  handlers: PromiseHandlers;
-  index: number;
-  key: Key;
-  value?: unknown;
-};
-/**
- * _Promise_ handling strategy
- *
- * - `complete`: wait for all _Promises_ to settle, then return the results, as an array of fulfilled and/or rejected results
- * - `first`: rejects on the first rejected _Promise_, and returns an array of values
- */
-export type PromiseStrategy = "complete" | "first";
-/**
- * An error thrown when a promise times out
- */
-export declare class PromiseTimeoutError extends Error {
-  constructor();
-}
-export type PromisesItems<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Promise<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Promise<Value> : Promise<Items[ItemsKey]>; } extends (infer Result) ? Result : never;
-/**
- * Options for handling multiple _Promises_
- */
-export type PromisesOptions = {
-  /**
-   * AbortSignal for aborting the _Promises_; when aborted, the _Promises_ will reject with the reason of the signal
-   */
-  signal?: AbortSignal;
-  /**
-   * Strategy for handling the _Promises_; defaults to `complete`
-   */
-  strategy?: PromiseStrategy;
-};
-export type PromisesResult<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never; };
-export type PromisesUnwrapped<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never; } extends (infer Result) ? Result : never;
-export type PromisesValue<Value> = (FulfilledPromise<Value> | RejectedPromise);
-export type PromisesValues<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never; } extends (infer Result) ? Result : never;
-/**
- * A _Promise_ that was rejected
- */
-export type RejectedPromise = {
-  /**
-   * Status of the _Promise_
-   */
-  status: typeof PROMISE_TYPE_REJECTED;
-  /**
-   * Reason for the rejection
-   */
-  reason: unknown;
-};
-//#endregion
+import { CancelablePromise, FulfilledPromise, PromiseOptions, PromiseStrategy, PromiseTimeoutError, PromisesOptions, RejectedPromise } from "../models/promise.model.mjs";
+export { CancelablePromise, type FulfilledPromise, type PromiseOptions, type PromiseStrategy, PromiseTimeoutError, type PromisesOptions, type RejectedPromise };

package/dist/promise/models.mjs

@@ -1,36 +1,2 @@
-import { PROMISE_ERROR_NAME, PROMISE_MESSAGE_TIMEOUT } from "./constants.mjs";
-//#region src/promise/models.ts
-/**
-* A _Promise_ that can be canceled
-*/
-var CancelablePromise = class extends Promise {
-	#rejector;
-	constructor(executor) {
-		let rejector;
-		super((resolve, reject) => {
-			rejector = reject;
-			executor(resolve, reject);
-		});
-		this.#rejector = rejector;
-	}
-	/**
-	* Cancel the _Promise_, rejecting it with an optional reason
-	*
-	* @param reason Optional reason for canceling the _Promise_
-	*/
-	cancel(reason) {
-		this.#rejector?.(reason);
-		this.#rejector = void 0;
-	}
-};
-/**
-* An error thrown when a promise times out
-*/
-var PromiseTimeoutError = class extends Error {
-	constructor() {
-		super(PROMISE_MESSAGE_TIMEOUT);
-		this.name = PROMISE_ERROR_NAME;
-	}
-};
-//#endregion
+import { CancelablePromise, PromiseTimeoutError } from "../models/promise.model.mjs";
 export { CancelablePromise, PromiseTimeoutError };

package/dist/promise/timed.d.mts

@@ -1,5 +1,5 @@
-import { RequiredKeys } from "../models.mjs";
-import { PromiseOptions } from "./models.mjs";
+import { RequiredKeys } from "../models/index.mjs";
+import { PromiseOptions } from "../models/promise.model.mjs";
 //#region src/promise/timed.d.ts
 export declare function getTimedPromise<Value>(promise: Promise<Value>, time: number, signal?: AbortSignal): Promise<Value>;
 /**

package/dist/promise/timed.mjs

@@ -1,7 +1,7 @@
 import { createAborter } from "../internal/aborter.mjs";
-import { LIMITER_WAIT, getLimiter } from "../internal/function/limit.mjs";
-import { PROMISE_MESSAGE_EXPECTATION_TIMED } from "./constants.mjs";
-import { PromiseTimeoutError } from "./models.mjs";
+import { LIMITER_WAIT } from "../models/function/limiter.model.mjs";
+import { getLimiter } from "../internal/function/limit.mjs";
+import { PROMISE_MESSAGE_EXPECTATION_TIMED, PromiseTimeoutError } from "../models/promise.model.mjs";
 import { createPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
 //#region src/promise/timed.ts

package/dist/query.d.mts

@@ -1,4 +1,4 @@
-import { PlainObject } from "./models.mjs";
+import { PlainObject } from "./models/index.mjs";
 //#region src/query.d.ts
 /**
  * Convert a query string to a plain _(nested)_ object

package/dist/query.mjs

@@ -2,6 +2,7 @@ import { isPlainObject } from "./internal/is.mjs";
 import { getString, ignoreKey, join, tryDecode, tryEncode } from "./internal/string/misc.mjs";
 import { getNumber } from "./internal/number.mjs";
 import { setValue } from "./internal/value/set.mjs";
+import { QUERY_EXPRESSION_ARRAY_SUFFIX, QUERY_EXPRESSION_BOOLEAN, QUERY_TRUE, QUERY_TYPES } from "./models/query.model.mjs";
 //#region src/query.ts
 /**
 * Convert a query string to a plain _(nested)_ object
@@ -11,7 +12,7 @@ import { setValue } from "./internal/value/set.mjs";
 */
 function fromQuery(query) {
 	if (typeof query !== "string" || query.trim().length === 0) return {};
-	const parts = query.split(QUERY_AMPERSAND).map((part) => part.split(QUERY_EQUAL).map(tryDecode)).sort(([first], [second]) => first.localeCompare(second));
+	const parts = query.split("&").map((part) => part.split("=").map(tryDecode)).sort(([first], [second]) => first.localeCompare(second));
 	const { length } = parts;
 	const parameters = {};
 	let position = 0;
@@ -41,9 +42,9 @@ function getParts(value, fromArray, prefix) {
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
 		const val = value[key];
-		const fullKey = join([prefix, fromArray ? void 0 : key], QUERY_DOT);
+		const fullKey = join([prefix, fromArray ? void 0 : key], ".");
 		const encodedKey = getString(tryEncode(fullKey));
-		const prefixedKey = fromArray ? join([encodedKey, index], QUERY_DOT) : encodedKey;
+		const prefixedKey = fromArray ? join([encodedKey, index], ".") : encodedKey;
 		if (Array.isArray(val)) parts.push(...getParts(val, true, fullKey));
 		else if (isPlainObject(val)) parts.push(...getParts(val, false, fullKey));
 		else if (isDecodable(val)) parts.push(`${prefixedKey}=${getString(tryEncode(val))}`);
@@ -70,18 +71,7 @@ function isDecodable(value) {
 * @returns Query string representation of the object
 */
 function toQuery(parameters) {
-	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), QUERY_AMPERSAND) : "";
+	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), "&") : "";
 }
-const QUERY_AMPERSAND = "&";
-const QUERY_DOT = ".";
-const QUERY_EQUAL = "=";
-const QUERY_EXPRESSION_ARRAY_SUFFIX = /\[\]$/;
-const QUERY_EXPRESSION_BOOLEAN = /^(false|true)$/;
-const QUERY_TRUE = "true";
-const QUERY_TYPES = /* @__PURE__ */ new Set([
-	"boolean",
-	"number",
-	"string"
-]);
 //#endregion
 export { fromQuery, toQuery };