@oscarpalmer/atoms 0.222.0 → 0.223.0

package/dist/internal/subscription.mjs

@@ -1,24 +1,21 @@
-import { isKey, isPlainObject } from "./is.mjs";
-import { SUBSCRIPTION_DISALLOWED_KEY, SUBSCRIPTION_INVALID_KEY, SUBSCRIPTION_INVALID_VALUE, SUBSCRIPTION_NAME, SUBSCRIPTION_PROPERTY, SUBSCRIPTION_STORE, SUBSCRIPTION_SYMBOL } from "../models/subscription.model.mjs";
+import { SUBSCRIPTION_DISALLOWED_KEY, SUBSCRIPTION_INVALID_KEY, SUBSCRIPTION_INVALID_VALUE, SUBSCRIPTION_NAME, SUBSCRIPTION_STORE, SUBSCRIPTION_SYMBOL } from "../models/subscription.model.mjs";
 import { createAborter } from "./aborter.mjs";
+import { isKey, isPlainObject } from "./is.mjs";
 // src/internal/subscription.ts
-function Subscription(state, property, parameters) {
+function Subscription(state, parameters) {
 	this[SUBSCRIPTION_SYMBOL] = state;
-	this[property.key] = property.value;
 	state.aborter = createAborter(parameters.signal, () => this.unsubscribe(subscriptions, this, state));
 	addSubscription(this);
 }
-Subscription.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_NAME;
 Subscription.prototype.unsubscribe = removeSubscription;
 Object.defineProperty(Subscription.prototype, "active", {
 	enumerable: true,
 	get: getSubscriptionActive
 });
 function Subscriptions(parameters) {
-	const { keys, property } = createSubscriptionsParameters(parameters);
-	this[SUBSCRIPTION_SYMBOL] = createSubscriptionsState(property, keys);
+	const { keys } = createSubscriptionsParameters(parameters);
+	this[SUBSCRIPTION_SYMBOL] = createSubscriptionsState(keys);
 }
-Subscriptions.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_STORE;
 Subscriptions.prototype.clear = clearSubscriptions;
 Subscriptions.prototype.create = createSubscription;
 Object.defineProperties(Subscriptions.prototype, {
@@ -74,7 +71,8 @@ function createSubscription(params) {
 	const state = {
 		parameters,
 		subscriptions,
-		active: true
+		active: true,
+		name: SUBSCRIPTION_NAME
 	};
 	const existing = getExistingSubscription(subscriptions, state);
 	if (existing != null) return [existing, true];
@@ -82,7 +80,7 @@ function createSubscription(params) {
 		if (subscriptions.keys === false) throw new Error(SUBSCRIPTION_DISALLOWED_KEY);
 		else if (subscriptions.keys !== true && !subscriptions.keys.has(parameters.key)) throw new Error(SUBSCRIPTION_INVALID_KEY);
 	}
-	return [new Subscription(state, subscriptions.property, parameters), false];
+	return [new Subscription(state, parameters), false];
 }
 function getExistingSubscription(subscriptions, state) {
 	const { values } = subscriptions;
@@ -114,26 +112,16 @@ function createSubscriptionsParameters(input) {
 	let keys;
 	if (values.keys instanceof Set) keys = values.keys;
 	else keys = typeof values.keys === "boolean" ? values.keys : false;
-	return {
-		keys,
-		property: createSubscriptionsProperty(values.property)
-	};
-}
-function createSubscriptionsProperty(input) {
-	const values = isPlainObject(input) ? input : {};
-	return {
-		key: typeof values.key === "string" ? values.key : SUBSCRIPTION_PROPERTY,
-		value: values.value ?? "subscription"
-	};
+	return { keys };
 }
-function createSubscriptionsState(property, keys) {
+function createSubscriptionsState(keys) {
 	return {
 		keys,
-		property,
 		items: {
 			any: /* @__PURE__ */ new Set(),
 			keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
 		},
+		name: SUBSCRIPTION_STORE,
 		values: {
 			from: {
 				any: /* @__PURE__ */ new Map(),
@@ -153,10 +141,10 @@ function createSubscriptionsState(property, keys) {
 * @returns `true` if the value is a subscription, otherwise `false`
 */
 function isSubscription(value) {
-	return isSubscriptionInstance(value, SUBSCRIPTION_NAME);
+	return isSubscriptionInstance(SUBSCRIPTION_NAME, value);
 }
-function isSubscriptionInstance(value, name) {
-	return typeof value === "object" && value !== null && "$subscription" in value && value["$subscription"] === name;
+function isSubscriptionInstance(type, value) {
+	return typeof value === "object" && value !== null && SUBSCRIPTION_SYMBOL in value && value[SUBSCRIPTION_SYMBOL].name === type;
 }
 /**
 * Is the value a subscriptions store?
@@ -165,7 +153,7 @@ function isSubscriptionInstance(value, name) {
 * @returns `true` if the value is a subscriptions store, otherwise `false`
 */
 function isSubscriptions(value) {
-	return isSubscriptionInstance(value, SUBSCRIPTION_STORE);
+	return isSubscriptionInstance(SUBSCRIPTION_STORE, value);
 }
 function removeFromStore(items, values, subscription, value, key) {
 	items.delete(subscription);

package/dist/internal/value/compare.mjs

@@ -1,5 +1,5 @@
-import { max } from "../math/aggregate.mjs";
 import { COMPARE_NAME } from "../../models/value/value.misc.model.mjs";
+import { max } from "../math/aggregate.mjs";
 import { getString, words } from "../string/misc.mjs";
 import { createCompareHandler } from "./handlers.mjs";
 // src/internal/value/compare.ts

package/dist/internal/value/equal.d.mts

@@ -1,6 +1,6 @@
 import { Constructor } from "../../models/index.mjs";
-import { CompareHandler } from "../../models/value/value.handler.model.mjs";
 import { EqualOptions, Equalizer, EqualizerOptions } from "../../models/value/value.equal.model.mjs";
+import { CompareHandler } from "../../models/value/value.handler.model.mjs";
 declare function Equalizer(this: any, options: EqualizerOptions): void;
 /**
  * Deregister a equality comparison handler for a specific class

package/dist/internal/value/equal.mjs

@@ -1,8 +1,8 @@
+import { EQUAL_ERROR_PROPERTIES, EQUAL_EXPRESSION_PROPERTIES, EQUAL_SYMBOL } from "../../models/value/value.equal.model.mjs";
 import { isNonPlainObject, isPlainObject, isPrimitive, isTypedArray } from "../is.mjs";
-import { round } from "../math/misc.mjs";
 import { min } from "../math/aggregate.mjs";
+import { round } from "../math/misc.mjs";
 import { createCompareHandler } from "./handlers.mjs";
-import { EQUAL_ERROR_PROPERTIES, EQUAL_EXPRESSION_PROPERTIES, EQUAL_SYMBOL } from "../../models/value/value.equal.model.mjs";
 // src/internal/value/equal.ts
 function Equalizer(options) {
 	this[EQUAL_SYMBOL] = options;

package/dist/internal/value/set.mjs

@@ -1,6 +1,6 @@
+import { EXPRESSION_INTEGER } from "../../models/misc.model.mjs";
 import { unwrap } from "../result/misc.mjs";
 import { getPaths, handleValue } from "./misc.mjs";
-import { EXPRESSION_INTEGER } from "../../models/misc.model.mjs";
 // src/internal/value/set.ts
 function setValue(data, path, value, ignoreCase) {
 	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return data;

package/dist/is.mjs

@@ -1,5 +1,5 @@
-import { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonInstanceOf, isNonKey, isNonNumber, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNumber, isPlainObject, isPrimitive, isTemplateStringsArray, isTypedArray } from "./internal/is.mjs";
 import { getArray } from "./internal/array/get.mjs";
+import { isArrayOrPlainObject, isConstructor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonInstanceOf, isNonKey, isNonNumber, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNumber, isPlainObject, isPrimitive, isTemplateStringsArray, isTypedArray } from "./internal/is.mjs";
 import { getString } from "./internal/string/misc.mjs";
 import { EXPRESSION_WHITESPACE_ONLY } from "./models/misc.model.mjs";
 // src/is.ts

package/dist/logger.mjs

@@ -1,9 +1,10 @@
 import { noop } from "./internal/function/misc.mjs";
 import { getString } from "./internal/string/misc.mjs";
-import { LOGGER_NAME, LOGGER_NAME_TIMED, LOGGER_PROPERTY, LOGGER_SYMBOL } from "./models/logger.model.mjs";
+import { LOGGER_NAME, LOGGER_NAME_TIMED, LOGGER_SYMBOL } from "./models/logger.model.mjs";
 // src/logger.ts
-function Lumberjack() {}
-Lumberjack.prototype[LOGGER_PROPERTY] = LOGGER_NAME;
+function Lumberjack() {
+	this[LOGGER_SYMBOL] = { name: LOGGER_NAME };
+}
 Lumberjack.prototype.time = getTimeLogger;
 Object.defineProperties(Lumberjack.prototype, {
 	debug: { get: getLoggerCallback.bind("debug") },
@@ -23,6 +24,7 @@ Object.defineProperties(Lumberjack.prototype, {
 function TimeLogger(label) {
 	this[LOGGER_SYMBOL] = {
 		label,
+		name: LOGGER_NAME_TIMED,
 		started: enabled,
 		stopped: false
 	};
@@ -31,7 +33,6 @@ function TimeLogger(label) {
 	};
 	if (this[LOGGER_SYMBOL].started) console.time(label);
 }
-TimeLogger.prototype[LOGGER_PROPERTY] = LOGGER_NAME_TIMED;
 Object.defineProperties(TimeLogger.prototype, {
 	active: {
 		enumerable: true,
@@ -74,7 +75,7 @@ function isLogger(value) {
 	return isLoggerInstance(LOGGER_NAME, value);
 }
 function isLoggerInstance(name, value) {
-	return typeof value === "object" && value !== null && "$logger" in value && value["$logger"] === name;
+	return typeof value === "object" && value !== null && LOGGER_SYMBOL in value && value[LOGGER_SYMBOL].name === name;
 }
 /**
 * Is the value a _TimeLogger_?

package/dist/math.mjs

@@ -1,7 +1,7 @@
 import { isNumber } from "./internal/is.mjs";
+import { aggregate, getAggregateCallback, getAggregated, max, min } from "./internal/math/aggregate.mjs";
 import { floor, round, roundNumber } from "./internal/math/misc.mjs";
 import { AGGREGATION_AVERAGE } from "./models/math.model.mjs";
-import { aggregate, getAggregateCallback, getAggregated, max, min } from "./internal/math/aggregate.mjs";
 // src/math.ts
 function average(array, key) {
 	const aggregated = aggregate(AGGREGATION_AVERAGE, array, key);

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

@@ -5,6 +5,16 @@ export type ArrayCompareSetsType = "difference" | "intersection" | "union";
  */
 export type ArrayComparison = "end" | "inside" | "invalid" | "outside" | "same" | "start";
 export type ArrayExtractType = "drop" | "take";
+export type ArrayFindParameters = {
+  bare?: boolean;
+  indiced?: boolean;
+  input: unknown[];
+  limit?: number;
+  reverse?: boolean;
+};
+export type ArrayFindResult = {
+  values: unknown[];
+};
 export type ArrayFlattened<Value> = Value extends ReadonlyArray<infer Inner> ? Inner : Value;
 export type ArrayGetCallbacks = {
   bool?: GenericCallback;
@@ -29,4 +39,5 @@ export declare const ARRAY_SETS_COMPARE_DIFFERENCE: ArrayCompareSetsType;
 export declare const ARRAY_SETS_COMPARE_INTERSECTION: ArrayCompareSetsType;
 export declare const ARRAY_SETS_COMPARE_UNION: ArrayCompareSetsType;
 export declare const ARRAY_SLICE_DROP: ArrayExtractType;
-export declare const ARRAY_SLICE_TAKE: ArrayExtractType;
+export declare const ARRAY_SLICE_TAKE: ArrayExtractType;
+export declare const ARRAY_UNIQUE_THRESHOLD = 100;

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

@@ -8,4 +8,5 @@ const ARRAY_SETS_COMPARE_INTERSECTION = "intersection";
 const ARRAY_SETS_COMPARE_UNION = "union";
 const ARRAY_SLICE_DROP = "drop";
 const ARRAY_SLICE_TAKE = "take";
-export { ARRAY_CHUNK_MAX_SIZE, ARRAY_INSERT_TYPE_INSERT, ARRAY_INSERT_TYPE_PUSH, ARRAY_INSERT_TYPE_SPLICE, ARRAY_SETS_COMPARE_DIFFERENCE, ARRAY_SETS_COMPARE_INTERSECTION, ARRAY_SETS_COMPARE_UNION, ARRAY_SLICE_DROP, ARRAY_SLICE_TAKE };
+const ARRAY_UNIQUE_THRESHOLD = 100;
+export { ARRAY_CHUNK_MAX_SIZE, ARRAY_INSERT_TYPE_INSERT, ARRAY_INSERT_TYPE_PUSH, ARRAY_INSERT_TYPE_SPLICE, ARRAY_SETS_COMPARE_DIFFERENCE, ARRAY_SETS_COMPARE_INTERSECTION, ARRAY_SETS_COMPARE_UNION, ARRAY_SLICE_DROP, ARRAY_SLICE_TAKE, ARRAY_UNIQUE_THRESHOLD };

package/dist/models/beacon.model.d.mts

@@ -1,4 +1,4 @@
-import { Subscription, SubscriptionProperty, Subscriptions } from "./subscription.model.mjs";
+import { Subscription, Subscriptions } from "./subscription.model.mjs";
 /**
  * A beacon is a lighthouse, holding an observable value that can be subscribed to and emitted from
  */
@@ -54,6 +54,7 @@ export type BeaconState<Value> = {
   observable?: Observable<Value>;
   options: Required<BeaconOptions<Value>>;
   subscriptions?: Subscriptions<Observer<unknown>>;
+  name: typeof BEACON_NAME;
   value: Value;
 };
 export type InternalBeacon = {
@@ -91,6 +92,7 @@ export type Observable<Value> = {
 export type ObservableState<Value> = {
   active: boolean;
   beacon: BeaconState<Value>;
+  name: typeof BEACON_OBSERVABLE;
 };
 export type Observer<Value> = {
   /**
@@ -108,10 +110,8 @@ export type Observer<Value> = {
 };
 export declare const BEACON_MESSAGE_RETRIEVE = "Cannot retrieve observable from a closed beacon";
 export declare const BEACON_MESSAGE_SUBSCRIBE = "Cannot subscribe to a closed observable";
-export declare const BEACON_PROPERTY = "$beacon";
 export declare const BEACON_NAME = "beacon";
 export declare const BEACON_OBSERVABLE = "observable";
 export declare const BEACON_SYMBOL: unique symbol;
 export declare const BEACON_TYPE_ERROR = "error";
-export declare const BEACON_TYPE_NEXT = "next";
-export declare const beaconSubscription: SubscriptionProperty;
+export declare const BEACON_TYPE_NEXT = "next";

package/dist/models/beacon.model.mjs

@@ -1,15 +1,9 @@
-import { SUBSCRIPTION_NAME } from "./subscription.model.mjs";
 // src/models/beacon.model.ts
 const BEACON_MESSAGE_RETRIEVE = "Cannot retrieve observable from a closed beacon";
 const BEACON_MESSAGE_SUBSCRIBE = "Cannot subscribe to a closed observable";
-const BEACON_PROPERTY = "$beacon";
 const BEACON_NAME = "beacon";
 const BEACON_OBSERVABLE = "observable";
-const BEACON_SYMBOL = Symbol(BEACON_PROPERTY);
+const BEACON_SYMBOL = Symbol("beacon");
 const BEACON_TYPE_ERROR = "error";
 const BEACON_TYPE_NEXT = "next";
-const beaconSubscription = {
-	key: BEACON_PROPERTY,
-	value: SUBSCRIPTION_NAME
-};
-export { BEACON_MESSAGE_RETRIEVE, BEACON_MESSAGE_SUBSCRIBE, BEACON_NAME, BEACON_OBSERVABLE, BEACON_PROPERTY, BEACON_SYMBOL, BEACON_TYPE_ERROR, BEACON_TYPE_NEXT, beaconSubscription };
+export { BEACON_MESSAGE_RETRIEVE, BEACON_MESSAGE_SUBSCRIBE, BEACON_NAME, BEACON_OBSERVABLE, BEACON_SYMBOL, BEACON_TYPE_ERROR, BEACON_TYPE_NEXT };

package/dist/models/color.model.d.mts

@@ -1,6 +1,6 @@
-import { Subscription } from "./subscription.model.mjs";
-import { Herald, HeraldEvents } from "./herald.model.mjs";
 import { COLOR_SYMBOL } from "../color/constants.mjs";
+import { Herald, HeraldEvents } from "./herald.model.mjs";
+import { Subscription } from "./subscription.model.mjs";
 export type Alpha = {
   hex: string;
   value: number;

package/dist/models/function/limiter.model.d.mts

@@ -50,6 +50,7 @@ export type Limiter<Callback extends GenericCallback> = {
 export type LimiterState<Callback = GenericCallback> = {
   callback: Callback;
   interval: number;
+  name: string;
   parameters: unknown[];
   start?: number;
   throttle: boolean;
@@ -60,7 +61,6 @@ export type LimiterType = "debounce" | "throttle" | "wait";
 export declare const LIMITER_DEBOUNCE: LimiterType;
 export declare const LIMITER_NAME_ASYNC = "asyncLimiter";
 export declare const LIMITER_NAME_SYNC = "limiter";
-export declare const LIMITER_PROPERTY = "$limiter";
 export declare const LIMITER_OFFSET = 5;
 export declare const LIMITER_SYMBOL: unique symbol;
 export declare const LIMITER_THROTTLE: LimiterType;

package/dist/models/function/limiter.model.mjs

@@ -2,7 +2,6 @@
 const LIMITER_DEBOUNCE = "debounce";
 const LIMITER_NAME_ASYNC = "asyncLimiter";
 const LIMITER_NAME_SYNC = "limiter";
-const LIMITER_PROPERTY = "$limiter";
 const LIMITER_OFFSET = 5;
 const LIMITER_SYMBOL = Symbol("limiter");
 const LIMITER_THROTTLE = "throttle";
@@ -11,4 +10,4 @@ const LIMITER_WAIT = "wait";
 const clearTimer = typeof cancelAnimationFrame === "function" ? cancelAnimationFrame : clearTimeout;
 // istanbul ignore next
 const startTimer = typeof requestAnimationFrame === "function" ? requestAnimationFrame : setTimeout;
-export { LIMITER_DEBOUNCE, LIMITER_NAME_ASYNC, LIMITER_NAME_SYNC, LIMITER_OFFSET, LIMITER_PROPERTY, LIMITER_SYMBOL, LIMITER_THROTTLE, LIMITER_WAIT, clearTimer, startTimer };
+export { LIMITER_DEBOUNCE, LIMITER_NAME_ASYNC, LIMITER_NAME_SYNC, LIMITER_OFFSET, LIMITER_SYMBOL, LIMITER_THROTTLE, LIMITER_WAIT, clearTimer, startTimer };

package/dist/models/function/memoize.model.d.mts

@@ -1,5 +1,5 @@
-import { GenericCallback } from "../index.mjs";
 import { SizedMap } from "../../internal/sized/map.mjs";
+import { GenericCallback } from "../index.mjs";
 export type InternalMemoized = {
   [MEMOIZED_SYMBOL]: MemoizedState;
 } & Memoized<GenericCallback>;

package/dist/models/function/once.model.d.mts

@@ -68,7 +68,6 @@ export type OnceState<Value, Callback = GenericCallback> = {
 };
 export declare const ONCE_NAME_ASYNC = "asyncOnce";
 export declare const ONCE_NAME_SYNC = "once";
-export declare const ONCE_PROPERTY = "$once";
 export declare const ONCE_MESSAGE_CLEARED = "Once has been cleared";
 export declare const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
 export declare const ONCE_SYMBOL: unique symbol;

package/dist/models/function/once.model.mjs

@@ -1,8 +1,7 @@
 // src/models/function/once.model.ts
 const ONCE_NAME_ASYNC = "asyncOnce";
 const ONCE_NAME_SYNC = "once";
-const ONCE_PROPERTY = "$once";
 const ONCE_MESSAGE_CLEARED = "Once has been cleared";
 const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
-const ONCE_SYMBOL = Symbol(ONCE_PROPERTY);
-export { ONCE_MESSAGE_CLEARED, ONCE_MESSAGE_EXPECTATION, ONCE_NAME_ASYNC, ONCE_NAME_SYNC, ONCE_PROPERTY, ONCE_SYMBOL };
+const ONCE_SYMBOL = Symbol("once");
+export { ONCE_MESSAGE_CLEARED, ONCE_MESSAGE_EXPECTATION, ONCE_NAME_ASYNC, ONCE_NAME_SYNC, ONCE_SYMBOL };

package/dist/models/function/work.model.d.mts

@@ -1,6 +1,6 @@
 import { GenericCallback } from "../index.mjs";
-import { Asserter } from "./assert.model.mjs";
 import { UnwrapValue } from "../result.model.mjs";
+import { Asserter } from "./assert.model.mjs";
 /**
  * An asynchronous _Flow_, a function that pipes a value through a series of functions
  */

package/dist/models/herald.model.d.mts

@@ -1,5 +1,5 @@
 import { GenericCallback } from "./index.mjs";
-import { Subscription, SubscriptionProperty, Subscriptions } from "./subscription.model.mjs";
+import { Subscription, Subscriptions } from "./subscription.model.mjs";
 export type Herald<Events extends Record<string, GenericCallback>> = {
   readonly events: HeraldEvents<Events>;
   /**
@@ -34,7 +34,6 @@ export type HeraldEvents<Events extends Record<string, GenericCallback>> = { [Ke
 export type HeraldOnCreate<Events extends Record<string, GenericCallback>> = <Event extends keyof Events>(event: Event, callback: Events[Event], subscription: Subscription) => void;
 export type HeraldOptions<Events extends Record<string, GenericCallback>> = {
   names: Array<keyof Events>;
-  property?: SubscriptionProperty;
   onCreate?: HeraldOnCreate<Events>;
 };
 export type HeraldState = {
@@ -45,14 +44,18 @@ export type HeraldState = {
 export type InternalHerald = {
   [HERALD_SYMBOL]: {
     events: HeraldEvents<Record<string, GenericCallback>>;
+    name: typeof HERALD_NAME_HERALD;
     state: HeraldState;
   };
 } & Herald<Record<string, GenericCallback>>;
+export type InternalHeraldEvents = {
+  [HERALD_SYMBOL]: {
+    name: typeof HERALD_NAME_EVENTS;
+  };
+} & HeraldEvents<Record<string, GenericCallback>>;
 export declare const HERALD_MESSAGE_ARRAY = "Herald requires an array of event names.";
 export declare const HERALD_MESSAGE_ONCREATE = "Herald requires a valid onCreate callback for subscription creation";
 export declare const HERALD_MESSAGE_PROPERTY = "Herald requires valid property information for subscription identification";
 export declare const HERALD_NAME_EVENTS = "events";
 export declare const HERALD_NAME_HERALD = "herald";
-export declare const HERALD_PROPERTY = "$herald";
-export declare const HERALD_SYMBOL: unique symbol;
-export declare const heraldSubscription: SubscriptionProperty;
+export declare const HERALD_SYMBOL: unique symbol;

package/dist/models/herald.model.mjs

@@ -1,14 +1,8 @@
-import { SUBSCRIPTION_NAME } from "./subscription.model.mjs";
 // src/models/herald.model.ts
 const HERALD_MESSAGE_ARRAY = "Herald requires an array of event names.";
 const HERALD_MESSAGE_ONCREATE = `Herald requires a valid onCreate callback for subscription creation`;
 const HERALD_MESSAGE_PROPERTY = `Herald requires valid property information for subscription identification`;
 const HERALD_NAME_EVENTS = "events";
 const HERALD_NAME_HERALD = "herald";
-const HERALD_PROPERTY = "$herald";
-const HERALD_SYMBOL = Symbol(HERALD_PROPERTY);
-const heraldSubscription = {
-	key: HERALD_PROPERTY,
-	value: SUBSCRIPTION_NAME
-};
-export { HERALD_MESSAGE_ARRAY, HERALD_MESSAGE_ONCREATE, HERALD_MESSAGE_PROPERTY, HERALD_NAME_EVENTS, HERALD_NAME_HERALD, HERALD_PROPERTY, HERALD_SYMBOL, heraldSubscription };
+const HERALD_SYMBOL = Symbol("herald");
+export { HERALD_MESSAGE_ARRAY, HERALD_MESSAGE_ONCREATE, HERALD_MESSAGE_PROPERTY, HERALD_NAME_EVENTS, HERALD_NAME_HERALD, HERALD_SYMBOL };

package/dist/models/logger.model.d.mts

@@ -77,5 +77,4 @@ export type TimeLoggerState = {
 };
 export declare const LOGGER_NAME = "Logger";
 export declare const LOGGER_NAME_TIMED = "TimedLogger";
-export declare const LOGGER_PROPERTY = "$logger";
 export declare const LOGGER_SYMBOL: unique symbol;

package/dist/models/logger.model.mjs

@@ -1,6 +1,5 @@
 // src/models/logger.model.ts
 const LOGGER_NAME = "Logger";
 const LOGGER_NAME_TIMED = "TimedLogger";
-const LOGGER_PROPERTY = "$logger";
-const LOGGER_SYMBOL = Symbol(LOGGER_PROPERTY);
-export { LOGGER_NAME, LOGGER_NAME_TIMED, LOGGER_PROPERTY, LOGGER_SYMBOL };
+const LOGGER_SYMBOL = Symbol("logger");
+export { LOGGER_NAME, LOGGER_NAME_TIMED, LOGGER_SYMBOL };

package/dist/models/plan.model.d.mts

@@ -10,6 +10,10 @@ export type AsyncFailure<Value> = {
    */
   [Symbol.asyncIterator]: () => AsyncGenerator<Err<Value>, never>;
 };
+export type AsyncImmediateState = {
+  generator: () => AsyncGenerator;
+  type: typeof PLAN_FAILURE_ASYNC | typeof PLAN_SUCCESS_ASYNC;
+};
 /**
  * An asynchronous plan of execution that can yield intermediate results and eventually return a result
  */
@@ -27,23 +31,19 @@ export type AsyncPlan<Yielded, Returned, Parameters extends unknown[]> = {
    *
    * @returns Attempted result
    */
-  attempt: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>> : (signal?: AbortSignal) => Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+  attempt: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>> : (signal?: AbortSignal) => Promise<Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>>;
   /**
    * Run the plan to completion
    *
-   * @throws {PlanError<Yielded, Returned>}
+   * @throws {PlannedError<Yielded, Returned>}
    * @returns Result
    */
-  run: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<PlanReturned<Returned>> : (signal?: AbortSignal) => Promise<PlanReturned<Returned>>;
+  run: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<PlannedReturned<Returned>> : (signal?: AbortSignal) => Promise<PlannedReturned<Returned>>;
 };
 /**
  * An immediately succeeding or failing asynchronous plan
  */
-export type AsyncPlanned<Value, Error> = AsyncSuccess<Value> | AsyncFailure<Error>;
-export type AsyncPlannedState = {
-  generator: () => AsyncGenerator;
-  type: typeof PLAN_FAILURE_ASYNC | typeof PLAN_SUCCESS_ASYNC;
-};
+export type AsyncImmediate<Value, Error> = AsyncSuccess<Value> | AsyncFailure<Error>;
 export type AsyncPlanState = {
   generator(...parameters: unknown[]): AsyncGenerator;
   type: typeof PLAN_TYPE_ASYNC;
@@ -101,10 +101,19 @@ export type GenericPlanItem = {
 };
 export type GenericPlanItemState = {
   generator: () => AsyncGenerator | Generator;
-  type: PlanType | PlannedType | StepType;
+  type: PlanType | ImmediateType | StepType;
 };
+/**
+ * An immediately succeeding or failing plan
+ */
+export type Immediate<Value, Error> = Success<Value> | Failure<Error>;
+export type ImmediateState = {
+  generator: () => Generator;
+  type: typeof PLAN_FAILURE_SYNC | typeof PLAN_SUCCESS_SYNC;
+};
+export type ImmediateType = "asyncFailure" | "asyncSuccess" | "failure" | "success";
 export type InternalAsyncFailure = {
-  [PLAN_SYMBOL]: AsyncPlannedState;
+  [PLAN_SYMBOL]: AsyncImmediateState;
 } & AsyncFailure<never>;
 export type InternalAsyncPlan = {
   [PLAN_SYMBOL]: AsyncPlanState;
@@ -113,16 +122,16 @@ export type InternalAsyncStep = {
   [PLAN_SYMBOL]: AsyncStepState;
 } & AsyncStep<never>;
 export type InternalAsyncSuccess = {
-  [PLAN_SYMBOL]: AsyncPlannedState;
+  [PLAN_SYMBOL]: AsyncImmediateState;
 } & AsyncSuccess<never>;
 export type InternalFailure = {
-  [PLAN_SYMBOL]: PlannedState;
+  [PLAN_SYMBOL]: ImmediateState;
 } & Failure<never>;
 export type InternalPlan = {
   [PLAN_SYMBOL]: PlanState;
 } & Plan<never, never, unknown[]>;
 export type InternalSuccess = {
-  [PLAN_SYMBOL]: PlannedState;
+  [PLAN_SYMBOL]: ImmediateState;
 } & Success<never>;
 export type InternalStep = {
   [PLAN_SYMBOL]: StepState;
@@ -153,42 +162,33 @@ export type Plan<Yielded, Returned, Parameters extends unknown[]> = {
    *
    * @returns Attempted result
    */
-  attempt(...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
+  attempt(...parameters: Parameters): Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>;
   /**
    * Run the plan to completion
    *
-   * @throws {PlanError<Yielded, Returned>}
+   * @throws {PlannedError<Yielded, Returned>}
    * @returns Result
    */
-  run(...parameters: Parameters): PlanReturned<Returned>;
+  run(...parameters: Parameters): PlannedReturned<Returned>;
+};
+export type PlanState = {
+  generator(...parameters: unknown[]): Generator;
+  type: typeof PLAN_TYPE_SYNC;
 };
-/**
- * An OK result of a plan execution
- */
-export type PlanOk<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned extends Ok<infer Value> ? Value : Returned;
-type PlanErrors<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
 /**
  * An error result of a plan execution
  */
-export type PlanError<Yielded, Returned> = [PlanErrors<Yielded, Returned>] extends [never] ? Error : PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
+export type PlannedError<Yielded, Returned> = [PlannedErrors<Yielded, Returned>] extends [never] ? Error : PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
+type PlannedErrors<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
 type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer E> ? E : Original extends Failure<infer E> ? E : never;
 /**
- * The returned result of a plan execution _(excluding errors, which are thrown)_
+ * An OK result of a plan execution
  */
-export type PlanReturned<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned;
+export type PlannedOk<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned extends Ok<infer Value> ? Value : Returned;
 /**
- * An immediately succeeding or failing plan
+ * The returned result of a plan execution _(excluding errors, which are thrown)_
  */
-export type Planned<Value, Error> = Success<Value> | Failure<Error>;
-export type PlannedState = {
-  generator: () => Generator;
-  type: typeof PLAN_FAILURE_SYNC | typeof PLAN_SUCCESS_SYNC;
-};
-export type PlannedType = "asyncFailure" | "asyncSuccess" | "failure" | "success";
-export type PlanState = {
-  generator(...parameters: unknown[]): Generator;
-  type: typeof PLAN_TYPE_SYNC;
-};
+export type PlannedReturned<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned;
 /**
  * A single step within a plan of execution
  */

package/dist/models/promise.model.d.mts

@@ -64,12 +64,6 @@ export type PromiseParameters = {
  * - `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]>; };
 /**
  * Options for handling multiple _Promises_
@@ -101,11 +95,17 @@ export type RejectedPromise = {
    */
   reason: unknown;
 };
+/**
+ * An error thrown when a promise times out
+ */
+export declare class TimedError extends Error {
+  constructor();
+}
 export declare const PROMISE_ABORT_EVENT = "abort";
 export declare const PROMISE_ABORT_OPTIONS: {
   once: boolean;
 };
-export declare const PROMISE_ERROR_NAME = "PromiseTimeoutError";
+export declare const PROMISE_ERROR_NAME = "TimedError";
 export declare const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
 export declare const PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE = "promises expected an array or object holding promise-functions or promises";
 export declare const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";

package/dist/models/promise.model.mjs

@@ -25,7 +25,7 @@ var CancelablePromise = class extends Promise {
 /**
 * An error thrown when a promise times out
 */
-var PromiseTimeoutError = class extends Error {
+var TimedError = class extends Error {
 	constructor() {
 		super(PROMISE_MESSAGE_TIMEOUT);
 		this.name = PROMISE_ERROR_NAME;
@@ -33,7 +33,7 @@ var PromiseTimeoutError = class extends Error {
 };
 const PROMISE_ABORT_EVENT = "abort";
 const PROMISE_ABORT_OPTIONS = { once: true };
-const PROMISE_ERROR_NAME = "PromiseTimeoutError";
+const PROMISE_ERROR_NAME = "TimedError";
 const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
 const PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE = "promises expected an array or object holding promise-functions or promises";
 const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
@@ -43,4 +43,4 @@ const PROMISE_STRATEGY_ALL = /* @__PURE__ */ new Set(["complete", "first"]);
 const PROMISE_STRATEGY_DEFAULT = "complete";
 const PROMISE_TYPE_FULFILLED = "fulfilled";
 const PROMISE_TYPE_REJECTED = "rejected";
-export { CancelablePromise, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError };
+export { CancelablePromise, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, TimedError };

package/dist/models/queue.model.d.mts

@@ -241,7 +241,6 @@ export declare const QUEUE_MESSAGE_MAXIMUM = "Queue has reached its maximum size
 export declare const QUEUE_MESSAGE_REMOVE = "Item removed from queue";
 export declare const QUEUE_NAME_KEYED = "keyedQueue";
 export declare const QUEUE_NAME_QUEUE = "queue";
-export declare const QUEUE_PROPERTY = "$queue";
 export declare const QUEUE_STATUS_ACTIVE: QueueStatusKey;
 export declare const QUEUE_STATUS_EMPTY: QueueStatusKey;
 export declare const QUEUE_STATUS_FULL: QueueStatusKey;