@ariestools/sdk 7.0.6 → 7.0.8

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

@@ -1,8 +0,0 @@
-// src/delay.ts
-import { setTimeoutEx } from "../../timer/neutral/index.mjs";
-var delay = (ms) => {
-  return new Promise((resolve) => setTimeoutEx(() => resolve(), ms));
-};
-export {
-  delay
-};

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

@@ -1,7 +0,0 @@
-/**
- * Truncates a string to show the first and last `length` characters separated by an ellipsis.
- * @param value - The string to ellipsize
- * @param length - Number of characters to keep at each end (default 2)
- * @returns The ellipsized string
- */
-export declare const ellipsize: (value: string, length?: number) => string;

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

@@ -1,9 +0,0 @@
-// src/index.ts
-var ellipsize = (value, length = 2) => {
-  const part1 = value.slice(0, length);
-  const part2 = value.slice(value.length - length);
-  return `${part1}...${part2}`;
-};
-export {
-  ellipsize
-};

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

@@ -1,87 +0,0 @@
-/**
- * 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];

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

@@ -1 +0,0 @@
-export * from './Enum.ts';

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

@@ -1,7 +0,0 @@
-// src/Enum.ts
-var Enum = (obj) => {
-  return obj;
-};
-export {
-  Enum
-};

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

@@ -1 +0,0 @@
-export type { Enum, EnumKey, EnumValue, } from './Enum.ts';

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

@@ -1,11 +0,0 @@
-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 {};

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

@@ -1,14 +0,0 @@
-/**
- * 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>;

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

@@ -1,2 +0,0 @@
-export * from './assert.ts';
-export * from './handleError.ts';

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

@@ -1,31 +0,0 @@
-// 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
-};

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

@@ -1 +0,0 @@
-export type { AssertConfig } from './assert.ts';

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

@@ -1,73 +0,0 @@
-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;
-}

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

@@ -1,131 +0,0 @@
-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;
-}

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

@@ -1 +0,0 @@
-export * from './Events.ts';

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

@@ -1,3 +0,0 @@
-export * from './BaseEmitter.ts';
-export * from './Events/index.ts';
-export * from './model/index.ts';