@mrxsys/mrx-core 2.4.0 → 2.5.1

package/dist/modules/singletonManager/singletonManager.d.ts

@@ -0,0 +1,75 @@
+/**
+* SingletonManager is a static class that manages the singletons in the application.
+* When a class is registered, the SingletonManager creates a new instance of the class when it is requested.
+*
+* @example
+* ```ts
+* class ExampleSingleton {
+*    private static _count = 0;
+*    private readonly _id: number;
+*
+*    public constructor() {
+*       ExampleSingleton._count += 1;
+*      this._id = ExampleSingleton._count;
+*      console.log(`ExampleSingleton created with ID: ${this._id}`);
+*    }
+*
+*    public sayHello(): void {
+*      console.log(`Hello from instance ${this._id}!`);
+*    }
+* }
+*
+* SingletonManager.register('ExampleSingleton', ExampleSingleton);
+*
+* SingletonManager.get<ExampleSingleton>('ExampleSingleton').sayHello(); // Output: ExampleSingleton created with ID: 1 /n Hello from instance 1!
+* SingletonManager.get<ExampleSingleton>('ExampleSingleton').sayHello(); // Output: Hello from instance 1!
+* ```
+*/
+export declare class SingletonManager {
+    /**
+    * _registry is a private static property that holds the class instances that are registered
+    * in the SingletonManager. The key is the name of the class and the value is the instance of the class.
+    */
+    private static readonly _registry;
+    /**
+    * Registers a class constructor in the SingletonManager.
+    *
+    * @template TClass - The type of the class.
+    * @template TArgs - The tuple type of the constructor arguments.
+    *
+    * @param name - The name of the class.
+    * @param constructor - The constructor of the class.
+    * @param args - The arguments to pass to the constructor of the class.
+    *
+    * @throws ({@link BaseError}) - If the class constructor is already registered, it throws an error.
+    */
+    static register<TClass extends object, TArgs extends unknown[]>(name: string, constructor: new (...args: TArgs) => TClass, ...args: TArgs): void;
+    /**
+    * Unregisters a class from the SingletonManager.
+    *
+    * @param name - The name of the class to unregister.
+    *
+    * @throws ({@link BaseError}) If the class constructor is not registered, it throws an error.
+    */
+    static unregister(name: string): void;
+    /**
+    * Gets the singleton instance of the class. If the class is not registered, it throws an error.
+    *
+    * @template TClass - The type of the class.
+    *
+    * @param name - The name of the class to get the singleton instance.
+    *
+    * @throws ({@link BaseError}) If the class is not registered, it throws an error.
+    *
+    * @returns The singleton instance of the class.
+    */
+    static get<TClass>(name: string): TClass;
+    /**
+    * Checks if the class is registered in the SingletonManager.
+    *
+    * @param name - The name of the class to check if it is registered.
+    *
+    * @returns True if the class is registered, otherwise false.
+    */
+    static has(name: string): boolean;
+}

package/dist/modules/typedEventEmitter/index.d.ts

@@ -0,0 +1 @@
+export { TypedEventEmitter } from './typedEventEmitter';

package/dist/modules/typedEventEmitter/index.js

@@ -0,0 +1,7 @@
+// @bun
+import {
+  TypedEventEmitter
+} from "../../chunk-yvyahr2h.js";
+export {
+  TypedEventEmitter
+};

package/dist/{typedEventEmitter → modules/typedEventEmitter}/typedEventEmitter.d.ts

@@ -10,12 +10,14 @@ export declare class TypedEventEmitter<TEvents extends EventMap> extends EventEm
      * Emits an event with the specified payload.
      *
      * @template KEvent - The type of event to emit.
+     *
      * @param event - The event name to emit.
      * @param payload - The data to send with the event.
+     *
      * @returns Whether the event had listeners.
      *
      * @example
-     * ```typescript
+     * ```ts
      * class MyEmitter extends TypedEventEmitter<{ foo: [string] }> {}
      * const emitter = new MyEmitter();
      * emitter.emit('foo', 'hello');
@@ -26,12 +28,14 @@ export declare class TypedEventEmitter<TEvents extends EventMap> extends EventEm
      * Registers an event listener for the specified event.
      *
      * @template KEvent - The type of event to listen for.
+     *
      * @param event - The event name to listen for.
      * @param listener - The callback function that handles the event.
+     *
      * @returns This instance for chaining.
      *
      * @example
-     * ```typescript
+     * ```ts
      * class MyEmitter extends TypedEventEmitter<{ foo: [string] }> {}
      * const emitter = new MyEmitter();
      * emitter.on('foo', payload => {
@@ -44,12 +48,14 @@ export declare class TypedEventEmitter<TEvents extends EventMap> extends EventEm
      * Registers a one-time event listener for the specified event.
      *
      * @template KEvent - The type of event to listen for.
+     *
      * @param event - The event name to listen for.
      * @param listener - The callback function that handles the event.
+     *
      * @returns This instance for chaining.
      *
      * @example
-     * ```typescript
+     * ```ts
      * class MyEmitter extends TypedEventEmitter<{ bar: [number] }> {}
      * const emitter = new MyEmitter();
      * emitter.once('bar', payload => {
@@ -62,12 +68,14 @@ export declare class TypedEventEmitter<TEvents extends EventMap> extends EventEm
      * Registers an event listener for the specified event (alias for on).
      *
      * @template KEvent - The type of event to listen for.
+     *
      * @param event - The event name to listen for.
      * @param listener - The callback function that handles the event.
+     *
      * @returns This instance for chaining.
      *
      * @example
-     * ```typescript
+     * ```ts
      * class MyEmitter extends TypedEventEmitter<{ baz: [boolean] }> {}
      * const emitter = new MyEmitter();
      * emitter.addListener('baz', payload => {
@@ -80,12 +88,14 @@ export declare class TypedEventEmitter<TEvents extends EventMap> extends EventEm
      * Removes an event listener for the specified event.
      *
      * @template KEvent - The type of event.
+     *
      * @param event - The event name.
      * @param listener - The callback function to remove.
+     *
      * @returns This instance for chaining.
      *
      * @example
-     * ```typescript
+     * ```ts
      * class MyEmitter extends TypedEventEmitter<{ foo: string }> {}
      * const emitter = new MyEmitter();
      * const handler = (payload: string) => {};
@@ -98,12 +108,14 @@ export declare class TypedEventEmitter<TEvents extends EventMap> extends EventEm
      * Removes an event listener for the specified event (alias for removeListener).
      *
      * @template KEvent - The type of event.
+     *
      * @param event - The event name.
      * @param listener - The callback function to remove.
+     *
      * @returns This instance for chaining.
      *
      * @example
-     * ```typescript
+     * ```ts
      * class MyEmitter extends TypedEventEmitter<{ foo: [string] }> {}
      * const emitter = new MyEmitter();
      * const handler = (payload: string) => {};
@@ -116,11 +128,13 @@ export declare class TypedEventEmitter<TEvents extends EventMap> extends EventEm
      * Returns the number of listeners for the specified event.
      *
      * @template KEvent - The type of event.
+     *
      * @param event - The event name.
+     *
      * @returns The number of listeners.
      *
      * @example
-     * ```typescript
+     * ```ts
      * class MyEmitter extends TypedEventEmitter<{ foo: [string] }> {}
      * const emitter = new MyEmitter();
      * emitter.on('foo', () => {});
@@ -132,11 +146,13 @@ export declare class TypedEventEmitter<TEvents extends EventMap> extends EventEm
      * Returns a copy of the array of listeners for the specified event.
      *
      * @template KEvent - The type of event.
+     *
      * @param event - The event name.
+     *
      * @returns An array of listener functions.
      *
      * @example
-     * ```typescript
+     * ```ts
      * class MyEmitter extends TypedEventEmitter<{ foo: [string] }> {}
      * const emitter = new MyEmitter();
      * emitter.on('foo', () => {});
@@ -148,11 +164,13 @@ export declare class TypedEventEmitter<TEvents extends EventMap> extends EventEm
      * Returns a copy of the array of raw listeners for the specified event.
      *
      * @template KEvent - The type of event.
+     *
      * @param event - The event name.
+     *
      * @returns An array of raw listener functions.
      *
      * @example
-     * ```typescript
+     * ```ts
      * class MyEmitter extends TypedEventEmitter<{ foo: [string] }> {}
      * const emitter = new MyEmitter();
      * emitter.on('foo', () => {});
@@ -164,12 +182,14 @@ export declare class TypedEventEmitter<TEvents extends EventMap> extends EventEm
      * Adds a listener to the beginning of the listeners array for the specified event.
      *
      * @template KEvent - The type of event.
+     *
      * @param event - The event name.
      * @param listener - The callback function to add.
+     *
      * @returns This instance for chaining.
      *
      * @example
-     * ```typescript
+     * ```ts
      * class MyEmitter extends TypedEventEmitter<{ foo: [string] }> {}
      * const emitter = new MyEmitter();
      * emitter.prependListener('foo', payload => {
@@ -182,12 +202,14 @@ export declare class TypedEventEmitter<TEvents extends EventMap> extends EventEm
      * Adds a one-time listener to the beginning of the listeners array for the specified event.
      *
      * @template KEvent - The type of event.
+     *
      * @param event - The event name.
      * @param listener - The callback function to add.
+     *
      * @returns This instance for chaining.
      *
      * @example
-     * ```typescript
+     * ```ts
      * class MyEmitter extends TypedEventEmitter<{ foo: [string] }> {}
      * const emitter = new MyEmitter();
      * emitter.prependOnceListener('foo', payload => {

package/dist/modules/typedEventEmitter/types/index.d.ts

@@ -0,0 +1 @@
+export type { EventMap } from './eventMap';

package/dist/modules/typedEventEmitter/types/index.js

@@ -0,0 +1 @@
+// @bun

package/dist/utils/enums/utilsErrorKeys.d.ts

@@ -0,0 +1,3 @@
+export declare const UTILS_ERROR_KEYS: {
+    readonly INVALID_ENVIRONMENT: "utils.error.invalid_environment";
+};

package/dist/utils/env.d.ts

@@ -5,6 +5,6 @@ import type { TSchema } from '@sinclair/typebox';
  * @param schema - The schema to validate the environment variables against.
  * @param env - The environment variables to validate. Defaults to `process.env`.
  *
- * @throws ({@link CoreError}): If the environment variables are invalid based on the schema. ({@link utilErrorKeys.invalidEnvironment})
+ * @throws ({@link BaseError}) - If the environment variables are invalid based on the schema.
  */
 export declare const validateEnv: (schema: TSchema, env?: Record<string, unknown>) => void;

package/dist/utils/index.d.ts

@@ -1,3 +1,3 @@
-export * from './env';
-export * from './isIsoDateString';
-export * from './stream';
+export { validateEnv } from './env';
+export { isDateString } from './isDateString';
+export { makeStreamAsyncIterable } from './stream';

package/dist/utils/index.js

@@ -1,2 +1,33 @@
 // @bun
-import{b as t}from"../chunk-89mnpfvy.js";import"../chunk-91srr77d.js";import"../chunk-df9xr1f5.js";import{oa as m,pa as p}from"../chunk-9hj714bv.js";import"../chunk-z00b1r18.js";import"../chunk-4w7nd4nw.js";export{t as validateEnv,p as makeStreamAsyncIterable,m as isIsoDateString};
+import {
+  isDateString,
+  makeStreamAsyncIterable
+} from "../chunk-5qtpggzv.js";
+import {
+  BaseError
+} from "../chunk-vknq69e0.js";
+
+// source/utils/env.ts
+import { Value } from "@sinclair/typebox/value";
+
+// source/utils/enums/utilsErrorKeys.ts
+var UTILS_ERROR_KEYS = {
+  INVALID_ENVIRONMENT: "utils.error.invalid_environment"
+};
+
+// source/utils/env.ts
+var validateEnv = (schema, env = process.env) => {
+  try {
+    Value.Assert(schema, Value.Parse(schema, env));
+  } catch (error) {
+    throw new BaseError({
+      message: UTILS_ERROR_KEYS.INVALID_ENVIRONMENT,
+      cause: error
+    });
+  }
+};
+export {
+  validateEnv,
+  makeStreamAsyncIterable,
+  isDateString
+};

package/dist/utils/isDateString.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Checks if a value is a valid date string.
+ *
+ * @param v - The value to check.
+ *
+ * @returns True if the value is a valid date string, false otherwise.
+ *
+ * @example
+ * ```typescript
+ * isDateString('2023-10-01T12:00:00Z'); // true
+ * isDateString('invalid-date'); // false
+ * isDateString(12345); // false
+ * isDateString(new Date().toISOString()); // true
+ * ```
+ */
+export declare const isDateString: (v: unknown) => v is string;

package/dist/utils/stream.d.ts

@@ -6,6 +6,17 @@ import type { Stream } from 'stream';
  * @template KStream - The type of the stream.
  * @param stream - The stream to make async iterable.
  *
- * @returns The stream as an async iterable. ({@link KStream} extends {@link Stream} & {@link AsyncIterable})
+ * @returns The stream as an async iterable.
+ *
+ * @example
+ * ```typescript
+ * import { Readable } from 'stream';
+ *
+ * const readableStream = Readable.from(['data1', 'data2', 'data3']);
+ * const asyncIterableStream = makeStreamAsyncIterable(readableStream);
+ *
+ * for await (const data of asyncIterableStream)
+ *     console.log(data); // Outputs: data1, data2, data3
+ * ```
  */
 export declare const makeStreamAsyncIterable: <TModel, KStream extends Stream = Stream>(stream: KStream) => KStream & AsyncIterable<TModel>;

package/dist/utils/types/index.d.ts

@@ -1 +1 @@
-export type * from './streamWithAsyncIterable';
+export type { StreamWithAsyncIterable } from './streamWithAsyncIterable';

package/dist/utils/types/streamWithAsyncIterable.d.ts

@@ -7,20 +7,27 @@ import type { PassThrough } from 'stream';
  * @template TModel - The type of the object to retrieve.
  *
  * @example
- * ```typescript
+ *  Define a model
+ * ```ts
  * interface User {
  *     id: string;
  *     name: string;
  * }
- *
+ * ```
+ * @example
+ * Use the stream with async iterable
+ * ```ts
  * const users: StreamWithAsyncIterable<User> = ...;
  *
- * // Method 1
  * for await (const user of users)
  *    console.log(user);
+ *```
+ * @example
+ * Use the stream with event listeners
+ * ```ts
+ * const users: StreamWithAsyncIterable<User> = ...;
  *
- * // Method 2
  * users.on('data', (user: User) => console.log(user));
  * ```
  */
-export type StreamWithAsyncIterable<TModel> = PassThrough & AsyncIterable<TModel extends (infer Model)[] ? Model : never>;
+export type StreamWithAsyncIterable<TModel> = AsyncIterable<TModel> & PassThrough;