@ariestools/sdk 7.0.3

package/dist/_pkg/enum/neutral/Enum.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Transforms a given record object into a readonly "enum-like" structure while preserving
+ * the literal types of its values. This allows you to use the returned object both at runtime
+ * (for lookups) and at compile time (for strongly typed values).
+ *
+ * To maintain literal types (i.e., prevent them from being widened to `string`, `number`, etc.),
+ * ensure you annotate your object with `as const` before passing it to `Enum`.
+ *
+ * @template T - A record type with string keys and any kind of values.
+ * @param obj - A readonly record object annotated with `as const`.
+ * @returns A readonly version of the provided record, preserving exact literal value types.
+ *
+ * @example
+ * ```typescript
+ * // Defining a record with literal types using as const:
+ * const DnsRecordType = Enum({
+ *   A: 1,
+ *   AAAA: 28,
+ *   CAA: 257,
+ *   CNAME: 5,
+ *   DNAME: 39,
+ *   MX: 15,
+ *   NS: 2,
+ *   PTR: 12,
+ *   SOA: 6,
+ *   SPF: 99,
+ *   SRV: 33,
+ *   TXT: 16,
+ * } as const);
+ *
+ * // DnsRecordType is now a readonly object:
+ * // {
+ * //   readonly A: 1;
+ * //   readonly AAAA: 28;
+ * //   readonly CAA: 257;
+ * //   readonly CNAME: 5;
+ * //   readonly DNAME: 39;
+ * //   readonly MX: 15;
+ * //   readonly NS: 2;
+ * //   readonly PTR: 12;
+ * //   readonly SOA: 6;
+ * //   readonly SPF: 99;
+ * //   readonly SRV: 33;
+ * //   readonly TXT: 16;
+ * // }
+ * ```
+ */
+export declare const Enum: <const T extends Record<string | number | symbol, unknown>>(obj: Readonly<T>) => Enum<T>;
+/**
+ * A utility type that, given a `Record<string, unknown>`, returns a readonly version
+ * of that record. This results in a type where all properties of `T` are readonly.
+ *
+ * @template T - The record type to make readonly.
+ *
+ * @example
+ * ```typescript
+ * // Given a record:
+ * export const DnsRecordType = Enum({
+ *   A: 1,
+ *   AAAA: 28,
+ *   CAA: 257,
+ *   CNAME: 5,
+ *   DNAME: 39,
+ *   MX: 15,
+ *   NS: 2,
+ *   PTR: 12,
+ *   SOA: 6,
+ *   SPF: 99,
+ *   SRV: 33,
+ *   TXT: 16,
+ * })
+ *
+ * // Now the type inference will preserve the literal types:
+ * export type DnsRecordType = Enum<typeof DnsRecordType>
+ * ```
+ */
+export type Enum<T extends Readonly<Record<string | number | symbol, unknown>>> = {
+    readonly [K in keyof T]: T[K];
+};
+/**
+ * A utility type that, given an `Enum` object, returns the union of its keys.
+ */
+export type EnumKey<T extends Record<string | number | symbol, unknown>, K = Enum<T>> = keyof K;
+/**
+ * A utility type that, given an `Enum` object, returns the union of its values.
+ */
+export type EnumValue<T extends Record<string | number | symbol, unknown>, K = Enum<T>> = K[keyof K];
+//# sourceMappingURL=Enum.d.ts.map

package/dist/_pkg/enum/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Enum.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/enum/neutral/index.mjs

@@ -0,0 +1,8 @@
+// src/Enum.ts
+var Enum = (obj) => {
+  return obj;
+};
+export {
+  Enum
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/enum/neutral/model.d.ts

@@ -0,0 +1,2 @@
+export type { Enum, EnumKey, EnumValue, } from './Enum.ts';
+//# sourceMappingURL=model.d.ts.map

package/dist/_pkg/enum/neutral/model.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=model.mjs.map

package/dist/_pkg/error/neutral/assert.d.ts

@@ -0,0 +1,12 @@
+type AssertCallback = (value: unknown, message: string) => string | boolean;
+/** Configuration for assertion behavior: a static message string, a boolean toggle, or a callback. */
+export type AssertConfig = string | AssertCallback | boolean;
+/**
+ * Throws an Error based on the assert configuration when a value fails validation.
+ * @param value - The value being validated
+ * @param assert - Assertion config controlling the error message
+ * @param defaultMessage - Fallback message if no custom message is provided
+ */
+export declare const assertError: (value: unknown, assert: AssertConfig | undefined, defaultMessage: string) => undefined;
+export {};
+//# sourceMappingURL=assert.d.ts.map

package/dist/_pkg/error/neutral/handleError.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Invokes the handler if the value is an Error, otherwise re-throws it.
+ * @param error - The caught value to inspect
+ * @param handler - Callback invoked with the Error if it is one
+ * @returns The handler's return value
+ */
+export declare const handleError: <T>(error: any, handler: (error: Error) => T) => T;
+/**
+ * Async version of handleError. Invokes the async handler if the value is an Error, otherwise re-throws it.
+ * @param error - The caught value to inspect
+ * @param handler - Async callback invoked with the Error if it is one
+ * @returns The handler's resolved return value
+ */
+export declare const handleErrorAsync: <T>(error: any, handler: (error: Error) => Promise<T>) => Promise<T>;
+//# sourceMappingURL=handleError.d.ts.map

package/dist/_pkg/error/neutral/index.d.ts

@@ -0,0 +1,3 @@
+export * from './assert.ts';
+export * from './handleError.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/error/neutral/index.mjs

@@ -0,0 +1,32 @@
+// src/assert.ts
+import { isString, isUndefined } from "../../typeof/neutral/index.mjs";
+var assertError = (value, assert, defaultMessage) => {
+  if (!isUndefined(assert)) {
+    const assertString = typeof assert === "string" ? assert : typeof assert === "boolean" ? defaultMessage : assert(value, defaultMessage);
+    if (isString(assertString) || assertString) {
+      throw new Error(assertString === true ? defaultMessage : assertString);
+    }
+  }
+  return void 0;
+};
+
+// src/handleError.ts
+import { isError } from "../../typeof/neutral/index.mjs";
+var handleError = (error, handler) => {
+  if (isError(error)) {
+    return handler(error);
+  }
+  throw error;
+};
+var handleErrorAsync = async (error, handler) => {
+  if (isError(error)) {
+    return await handler(error);
+  }
+  throw error;
+};
+export {
+  assertError,
+  handleError,
+  handleErrorAsync
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/error/neutral/model.d.ts

@@ -0,0 +1,2 @@
+export type { AssertConfig } from './assert.ts';
+//# sourceMappingURL=model.d.ts.map

package/dist/_pkg/error/neutral/model.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=model.mjs.map

package/dist/_pkg/events/neutral/BaseEmitter.d.ts

@@ -0,0 +1,74 @@
+import type { BaseParams } from '../../base/neutral/index.ts';
+import { Base } from '../../base/neutral/index.ts';
+import type { EmptyObject } from '../../object/neutral/index.ts';
+import type { EventAnyListener, EventData, EventEmitter, EventListener } from './model/index.ts';
+/** Fields specific to BaseEmitter configuration parameters. */
+export interface BaseEmitterParamsFields {
+}
+/** Parameters type for configuring a BaseEmitter instance. */
+export type BaseEmitterParams<T extends EmptyObject = EmptyObject> = BaseParams<T & BaseEmitterParamsFields>;
+/**
+ * Base class that combines the Base utility class with typed event emission capabilities.
+ * Delegates all event operations to an internal Events instance.
+ */
+export declare class BaseEmitter<TParams extends BaseParams = BaseParams, TEventData extends EventData = EventData> extends Base<TParams> implements EventEmitter<TEventData> {
+    eventData: TEventData;
+    private events;
+    constructor(params: BaseParams<TParams>);
+    /**
+     * Removes all listeners for the specified event name(s).
+     * @param eventNames - One or more event names to clear listeners for.
+     * @returns This instance for chaining.
+     */
+    clearListeners(eventNames: keyof TEventData | (keyof TEventData)[]): this;
+    /**
+     * Emits an event, invoking all registered listeners concurrently.
+     * @param eventName - The event to emit.
+     * @param eventArgs - The data to pass to listeners.
+     */
+    emit<TEventName extends keyof TEventData = keyof TEventData, TEventArgs extends TEventData[TEventName] = TEventData[TEventName]>(eventName: TEventName, eventArgs: TEventArgs): Promise<void>;
+    /**
+     * Emits an event, invoking all registered listeners sequentially in order.
+     * @param eventName - The event to emit.
+     * @param eventArgs - The data to pass to listeners.
+     */
+    emitSerial<TEventName extends keyof TEventData = keyof TEventData, TEventArgs extends TEventData[TEventName] = TEventData[TEventName]>(eventName: TEventName, eventArgs: TEventArgs): Promise<void>;
+    /**
+     * Returns the total number of listeners registered for the specified event name(s).
+     * @param eventNames - One or more event names to count listeners for.
+     * @returns The total listener count.
+     */
+    listenerCount(eventNames: keyof TEventData | (keyof TEventData)[]): number;
+    /**
+     * Removes a specific listener from the specified event name(s).
+     * @param eventNames - One or more event names to unsubscribe from.
+     * @param listener - The listener to remove.
+     */
+    off<TEventName extends keyof TEventData>(eventNames: TEventName | TEventName[], listener: EventListener<TEventData[TEventName]>): void;
+    /**
+     * Removes a wildcard listener that was receiving all events.
+     * @param listener - The wildcard listener to remove.
+     */
+    offAny(listener: EventAnyListener): void;
+    /**
+     * Subscribes a listener to the specified event name(s).
+     * @param eventNames - One or more event names to listen for.
+     * @param listener - The callback to invoke when the event fires.
+     * @returns An unsubscribe function.
+     */
+    on<TEventName extends keyof TEventData>(eventNames: TEventName | TEventName[], listener: EventListener<TEventData[TEventName]>): () => void;
+    /**
+     * Subscribes a wildcard listener that receives all events.
+     * @param listener - The callback to invoke for any event.
+     * @returns An unsubscribe function.
+     */
+    onAny(listener: EventAnyListener): () => void;
+    /**
+     * Subscribes a listener that will be invoked only once for the specified event, then automatically removed.
+     * @param eventName - The event to listen for.
+     * @param listener - The callback to invoke once.
+     * @returns An unsubscribe function.
+     */
+    once<TEventName extends keyof TEventData>(eventName: TEventName, listener: EventListener<TEventData[TEventName]>): () => void;
+}
+//# sourceMappingURL=BaseEmitter.d.ts.map

package/dist/_pkg/events/neutral/Events/Events.d.ts

@@ -0,0 +1,132 @@
+import type { BaseParams } from '../../../base/neutral/index.ts';
+import { Base } from '../../../base/neutral/index.ts';
+import type { EventAnyListener, EventArgs, EventData, EventEmitter, EventListener, EventName } from '../model/index.ts';
+/**
+Emittery can collect and log debug information.
+
+To enable this feature set the `DEBUG` environment variable to `emittery` or `*`. Additionally, you can set the static `isDebugEnabled` variable to true
+on the Emittery class, or `myEmitter.debug.enabled` on an instance of it for debugging a single instance.
+
+See API for more information on how debugging works.
+*/
+export type DebugLogger = (type: string, debugName: string, eventName?: EventName, eventData?: EventArgs) => void;
+/** Information about a registered event listener, including an optional filter for selective invocation. */
+export interface EventListenerInfo<TEventArgs extends EventArgs = EventArgs> {
+    filter?: TEventArgs;
+    listener: EventListener<TEventArgs>;
+}
+/**
+Configure debug options of an instance.
+*/
+export interface DebugOptions {
+    enabled?: boolean;
+    logger?: DebugLogger;
+    readonly name: string;
+}
+/** Data shape for internal meta events that fire when listeners are added or removed. */
+export interface MetaEventData<TEventData extends EventData> {
+    listenerAdded: {
+        eventName?: keyof TEventData;
+        listener: EventListener<TEventData[keyof TEventData]> | EventAnyListener<TEventData[keyof TEventData]>;
+    };
+    listenerRemoved: {
+        eventName?: keyof TEventData;
+        listener: EventListener<TEventData[keyof TEventData]> | EventAnyListener<TEventData[keyof TEventData]>;
+    };
+}
+/** Parameters for constructing an Events instance, with optional debug configuration. */
+export type EventsParams = BaseParams<{
+    readonly debug?: DebugOptions;
+}>;
+/**
+ * Core typed event emitter implementation supporting named events, wildcard listeners,
+ * serial and concurrent emission, listener filtering, and debug logging.
+ */
+export declare class Events<TEventData extends EventData = EventData> extends Base<EventsParams> implements EventEmitter<TEventData> {
+    protected static anyMap: WeakMap<object, Set<EventAnyListener>>;
+    protected static eventsMap: WeakMap<object, Map<PropertyKey, Set<EventListenerInfo<unknown>>>>;
+    private static isGlobalDebugEnabled;
+    eventData: TEventData;
+    private _canEmitMetaEvents;
+    constructor(params?: EventsParams);
+    /** Whether debug mode is enabled globally or via the DEBUG environment variable. */
+    static get isDebugEnabled(): boolean;
+    static set isDebugEnabled(newValue: boolean);
+    /** The debug configuration for this instance, if provided. */
+    get debug(): DebugOptions | undefined;
+    /**
+     * Removes all listeners for the specified event name(s).
+     * @param eventNames - One or more event names to clear listeners for.
+     */
+    clearListeners(eventNames: keyof TEventData | (keyof TEventData)[]): void;
+    /**
+     * Emits an event, invoking all registered listeners concurrently.
+     * @param eventName - The event to emit.
+     * @param eventArgs - The data to pass to listeners.
+     */
+    emit<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]): Promise<void>;
+    /**
+     * Emits an internal meta event (listenerAdded or listenerRemoved).
+     * @param eventName - The meta event name.
+     * @param eventArgs - The meta event data containing listener and event information.
+     * @returns True if the meta event was emitted successfully.
+     */
+    emitMetaEvent<TEventName extends keyof MetaEventData<TEventData>>(eventName: TEventName, eventArgs: MetaEventData<TEventData>[TEventName]): Promise<true | undefined>;
+    /**
+     * Emits an event, invoking all registered listeners sequentially in order.
+     * @param eventName - The event to emit.
+     * @param eventArgs - The data to pass to listeners.
+     */
+    emitSerial<TEventName extends keyof TEventData>(eventName: TEventName, eventArgs: TEventData[TEventName]): Promise<void>;
+    /**
+     * Returns the total number of listeners registered for the specified event name(s).
+     * @param eventNames - One or more event names to count listeners for.
+     * @returns The total listener count.
+     */
+    listenerCount(eventNames?: keyof TEventData | (keyof TEventData)[]): number;
+    /**
+     * Logs debug information if debug mode is enabled.
+     * @param type - The type of operation being logged.
+     * @param eventName - The event name, if applicable.
+     * @param eventArgs - The event data, if applicable.
+     */
+    logIfDebugEnabled<TEventName extends EventName>(type: string, eventName?: TEventName, eventArgs?: EventArgs): void;
+    /**
+     * Removes a specific listener from the specified event name(s).
+     * @param eventNames - One or more event names to unsubscribe from.
+     * @param listener - The listener to remove.
+     */
+    off<TEventName extends keyof TEventData, TEventListener = EventListener<TEventData[TEventName]>>(eventNames: TEventName | TEventName[], listener: TEventListener): void;
+    /**
+     * Removes a wildcard listener that was receiving all events.
+     * @param listener - The wildcard listener to remove.
+     */
+    offAny(listener: EventAnyListener): void;
+    /**
+     * Subscribes a listener to the specified event name(s).
+     * @param eventNames - One or more event names to listen for.
+     * @param listener - The callback to invoke when the event fires.
+     * @param filter - Optional filter to selectively invoke the listener based on event data.
+     * @returns An unsubscribe function.
+     */
+    on<TEventName extends keyof TEventData = keyof TEventData>(eventNames: TEventName | TEventName[], listener: EventListener<TEventData[TEventName]>, filter?: TEventData[TEventName]): () => void;
+    /**
+     * Subscribes a wildcard listener that receives all events.
+     * @param listener - The callback to invoke for any event.
+     * @returns An unsubscribe function.
+     */
+    onAny(listener: EventAnyListener): () => void;
+    /**
+     * Subscribes a listener that will be invoked only once for the specified event, then automatically removed.
+     * @param eventName - The event to listen for.
+     * @param listener - The callback to invoke once.
+     * @returns An unsubscribe function.
+     */
+    once<TEventName extends keyof TEventData>(eventName: TEventName, listener: EventListener<TEventData[TEventName]>): () => void;
+    private emitInternal;
+    private emitMetaEventInternal;
+    private getListeners;
+    private safeCallAnyListener;
+    private safeCallListener;
+}
+//# sourceMappingURL=Events.d.ts.map

package/dist/_pkg/events/neutral/Events/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Events.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/events/neutral/index.d.ts

@@ -0,0 +1,4 @@
+export * from './BaseEmitter.ts';
+export * from './Events/index.ts';
+export * from './model/index.ts';
+//# sourceMappingURL=index.d.ts.map