@axi-engine/utils 0.1.7 → 0.1.8

package/README.md

@@ -32,11 +32,8 @@ const isSame = haveSameElements(['a', 'b'], ['b', 'a']); // Returns true
 
 ## API Reference
 
-Will be available when code and repository will be fully published 
+[**Browse the API Documentation here**](https://github.com/axijs/engine/tree/main/packages/utils/docs/api)
 
-<!-- 
-[**Full API Documentation**](https://github.com/.../blob/main/packages/utils/docs/api/README.md)
--->
 
 
 

package/dist/index.cjs

@@ -0,0 +1,380 @@
+let uuid = require("uuid");
+
+//#region src/arrays.ts
+/**
+* Generates an array of numbers from 0 to length-1.
+* @param length The desired length of the array.
+* @returns An array of sequential numbers.
+* @example genArray(3); // returns [0, 1, 2]
+*/
+function genArray(length) {
+	return Array.from({ length }, (_v, i) => i);
+}
+/**
+* Creates a new array with its elements shuffled in a random order.
+* This function does not mutate the original array.
+* @template T The type of elements in the array.
+* @param array The array to shuffle.
+* @returns A new, shuffled array.
+*/
+function shuffleArray(array) {
+	const result = [...array];
+	for (let i = result.length - 1; i > 0; i--) {
+		const j = Math.floor(Math.random() * (i + 1));
+		[result[i], result[j]] = [result[j], result[i]];
+	}
+	return result;
+}
+/**
+* Checks if the first array is a sequential starting subset of the second array.
+* @param arr1 The potential subset array.
+* @param arr2 The array to check against.
+* @returns `true` if arr1 is a sequential start of arr2, otherwise `false`.
+* @example
+* isSequentialStart([1, 2], [1, 2, 3]); // true
+* isSequentialStart([1, 3], [1, 2, 3]); // false
+*/
+function isSequentialStart(arr1, arr2) {
+	if (arr1.length > arr2.length) return false;
+	return arr1.every((element, index) => element === arr2[index]);
+}
+/**
+* Checks if two arrays contain the same elements, ignoring order.
+* Works for arrays of primitives like strings or numbers.
+* @template T The type of elements in the array.
+* @param arr1 The first array.
+* @param arr2 The second array.
+* @returns `true` if both arrays contain the same elements, otherwise `false`.
+* @example
+* haveSameElements(['a', 'b'], ['b', 'a']); // true
+* haveSameElements([1, 2, 3], [3, 1, 2]); // true
+* haveSameElements(['a', 'b'], ['a', 'c']); // false
+*/
+function haveSameElements(arr1, arr2) {
+	if (!arr1 && !arr2) return true;
+	if (!arr1 || !arr2) return false;
+	if (arr1.length !== arr2.length) return false;
+	const sortedArr1 = [...arr1].sort();
+	const sortedArr2 = [...arr2].sort();
+	return sortedArr1.every((value, index) => value === sortedArr2[index]);
+}
+/**
+* Checks if two arrays are strictly equal (same elements in the same order).
+* @template T The type of elements in the array.
+* @param arr1 The first array.
+* @param arr2 The second array.
+* @returns `true` if the arrays are strictly equal, otherwise `false`.
+* @example
+* areArraysEqual(['a', 'b'], ['a', 'b']); // true
+* areArraysEqual(['a', 'b'], ['b', 'a']); // false
+* areArraysEqual([1, 2], [1, 2, 3]);    // false
+*/
+function areArraysEqual(arr1, arr2) {
+	if (!arr1 && !arr2) return true;
+	if (!arr1 || !arr2) return false;
+	if (arr1.length !== arr2.length) return false;
+	return arr1.every((value, index) => value === arr2[index]);
+}
+/**
+* Gets the last element of an array.
+* @template T The type of elements in the array.
+* @param array The array to query.
+* @returns The last element of the array, or `undefined` if the array is empty.
+*/
+function last(array) {
+	return array[array.length - 1];
+}
+/**
+* Creates a duplicate-free version of an array.
+* @template T The type of elements in the array.
+* @param array The array to process.
+* @returns A new array with only unique elements.
+*/
+function unique(array) {
+	return [...new Set(array)];
+}
+/**
+* Gets a random element from an array.
+* @template T The type of elements in the array.
+* @param array The array to choose from.
+* @returns A random element from the array, or `undefined` if the array is empty.
+*/
+function getRandomElement(array) {
+	if (array.length === 0) return;
+	return array[Math.floor(Math.random() * array.length)];
+}
+
+//#endregion
+//#region src/guards.ts
+function isNullOrUndefined(val) {
+	return val === void 0 || val === null;
+}
+function isUndefined(val) {
+	return typeof val === "undefined";
+}
+function isNumber(val) {
+	return typeof val === "number";
+}
+function isBoolean(val) {
+	return typeof val === "boolean";
+}
+function isString(val) {
+	return typeof val === "string";
+}
+/**
+* Type guard to check if a value is a string that ends with '%'.
+* @param val The value to check.
+* @returns `true` if the value is a percentage string.
+*/
+function isPercentageString(val) {
+	return typeof val === "string" && val.endsWith("%");
+}
+
+//#endregion
+//#region src/assertion.ts
+/**
+* Throws an error if the condition is true.
+* @param conditionForThrow - If true, an error will be thrown.
+* @param exceptionMessage - The message for the error.
+* @throws {Error} if the value is true
+*/
+function throwIf(conditionForThrow, exceptionMessage) {
+	if (conditionForThrow) throw new Error(exceptionMessage);
+}
+/**
+* Throws an error if the value is null, undefined, or an empty array.
+*
+* @template T The type of the value being checked.
+* @param value The value to check.
+* @param exceptionMessage The message for the error.
+* @throws {Error} if the value is null, undefined, or an empty array.
+*
+* @example
+* // Example with a potentially undefined variable
+* const user: { name: string } | undefined = findUser();
+* throwIfEmpty(user, 'User not found');
+* // From here, TypeScript knows `user` is not undefined.
+* console.log(user.name);
+*
+* @example
+* // Example with an array
+* const items: string[] = getItems();
+* throwIfEmpty(items, 'Items array cannot be empty');
+* // From here, you can safely access items[0] without checking for an empty array again.
+* console.log('First item:', items[0]);
+*/
+function throwIfEmpty(value, exceptionMessage) {
+	const isArrayAndEmpty = Array.isArray(value) && value.length === 0;
+	if (isNullOrUndefined(value) || isArrayAndEmpty) throw new Error(exceptionMessage);
+}
+
+//#endregion
+//#region src/config.ts
+const defaultConfig = { pathSeparator: "/" };
+const axiSettings = { ...defaultConfig };
+/**
+* set up global configuration for axi-engine.
+* @param newConfig - configuration object
+*/
+function configure(newConfig) {
+	Object.assign(axiSettings, newConfig);
+}
+
+//#endregion
+//#region src/constructor-registry.ts
+/**
+* A generic registry for mapping string identifiers to class constructors.
+*
+* This utility is fundamental for building extensible systems like dependency injection containers,
+* factories, and serialization engines where types need to be dynamically resolved.
+*
+* @template T - A base type that all registered constructors must produce an instance of.
+*/
+var ConstructorRegistry = class {
+	items = /* @__PURE__ */ new Map();
+	/**
+	* Registers a constructor with a unique string identifier.
+	*
+	* @param typeId - The unique identifier for the constructor (e.g., a static `typeName` property from a class).
+	* @param ctor - The class constructor to register.
+	* @returns The registry instance for chainable calls.
+	* @throws If a constructor with the same `typeId` is already registered.
+	*/
+	register(typeId, ctor) {
+		throwIf(this.items.has(typeId), `A constructor with typeId '${typeId}' is already registered.`);
+		this.items.set(typeId, ctor);
+		return this;
+	}
+	/**
+	* Retrieves a constructor by its identifier.
+	*
+	* @param typeId - The identifier of the constructor to retrieve.
+	* @returns The found class constructor.
+	* @throws If no constructor is found for the given `typeId`.
+	*/
+	get(typeId) {
+		const Ctor = this.items.get(typeId);
+		throwIfEmpty(Ctor, `No constructor found for typeId '${typeId}'`);
+		return Ctor;
+	}
+	/**
+	* Checks if a constructor for a given identifier is registered.
+	* @param typeId - The identifier to check.
+	* @returns `true` if a constructor is registered, otherwise `false`.
+	*/
+	has(typeId) {
+		return this.items.has(typeId);
+	}
+	/**
+	* Clears all registered constructors from the registry.
+	*/
+	clear() {
+		this.items.clear();
+	}
+};
+
+//#endregion
+//#region src/emitter.ts
+/**
+* A minimal, type-safe event emitter for a single event.
+* It does not manage state, it only manages subscribers and event dispatching.
+* @template T A tuple representing the types of the event arguments.
+*/
+var Emitter = class {
+	listeners = /* @__PURE__ */ new Set();
+	/**
+	* Returns the number of listeners.
+	*/
+	get listenerCount() {
+		return this.listeners.size;
+	}
+	/**
+	* Subscribes a listener to this event.
+	* @returns A function to unsubscribe the listener.
+	*/
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	/**
+	* Manually unsubscribe by listener
+	* @returns returns true if an listener has been removed, or false if the listener does not exist.
+	*/
+	unsubscribe(listener) {
+		return this.listeners.delete(listener);
+	}
+	/**
+	* Dispatches the event to all subscribed listeners.
+	*/
+	emit(...args) {
+		this.listeners.forEach((listener) => listener(...args));
+	}
+	/**
+	* Clears all listeners.
+	*/
+	clear() {
+		this.listeners.clear();
+	}
+};
+
+//#endregion
+//#region src/math.ts
+/**
+* Clamps a number between an optional minimum and maximum value.
+* @param val The number to clamp.
+* @param min The minimum value. If null or undefined, it's ignored.
+* @param max The maximum value. If null or undefined, it's ignored.
+* @returns The clamped number.
+*/
+function clampNumber(val, min, max) {
+	if (!isNullOrUndefined(min)) val = Math.max(val, min);
+	if (!isNullOrUndefined(max)) val = Math.min(val, max);
+	return val;
+}
+/**
+* Calculates a percentage of a given value.
+* @param val The base value.
+* @param percents The percentage to get.
+* @returns The calculated percentage of the value.
+* @example getPercentOf(200, 10); // returns 20
+*/
+function getPercentOf(val, percents) {
+	return percents / 100 * val;
+}
+
+//#endregion
+//#region src/misc.ts
+/**
+* Returns the first key of an object.
+* @param obj The object from which to get the key.
+* @returns The first key of the object as a string.
+*/
+function firstKeyOf(obj) {
+	return Object.keys(obj)[0];
+}
+
+//#endregion
+//#region src/path.ts
+/**
+* Ensures that the given path is returned as an array of segments.
+*/
+function ensurePathArray(path, separator = axiSettings.pathSeparator) {
+	return Array.isArray(path) ? [...path] : path.split(separator);
+}
+/**
+* Ensures that the given path is returned as a single string.
+*/
+function ensurePathString(path, separator = axiSettings.pathSeparator) {
+	return !Array.isArray(path) ? path : path.join(separator);
+}
+
+//#endregion
+//#region src/random.ts
+/**
+* Returns a random integer between min (inclusive) and max (exclusive).
+* @param min The minimum integer (inclusive).
+* @param max The maximum integer (exclusive).
+* @returns A random integer.
+* @example randInt(1, 5); // returns 1, 2, 3, or 4
+*/
+function randInt(min, max) {
+	min = Math.ceil(min);
+	max = Math.floor(max);
+	return Math.floor(Math.random() * (max - min) + min);
+}
+/**
+* Generates a unique identifier using uuidv4.
+* @returns A unique string ID.
+*/
+function randId() {
+	return (0, uuid.v4)();
+}
+
+//#endregion
+exports.ConstructorRegistry = ConstructorRegistry;
+exports.Emitter = Emitter;
+exports.areArraysEqual = areArraysEqual;
+exports.axiSettings = axiSettings;
+exports.clampNumber = clampNumber;
+exports.configure = configure;
+exports.ensurePathArray = ensurePathArray;
+exports.ensurePathString = ensurePathString;
+exports.firstKeyOf = firstKeyOf;
+exports.genArray = genArray;
+exports.getPercentOf = getPercentOf;
+exports.getRandomElement = getRandomElement;
+exports.haveSameElements = haveSameElements;
+exports.isBoolean = isBoolean;
+exports.isNullOrUndefined = isNullOrUndefined;
+exports.isNumber = isNumber;
+exports.isPercentageString = isPercentageString;
+exports.isSequentialStart = isSequentialStart;
+exports.isString = isString;
+exports.isUndefined = isUndefined;
+exports.last = last;
+exports.randId = randId;
+exports.randInt = randInt;
+exports.shuffleArray = shuffleArray;
+exports.throwIf = throwIf;
+exports.throwIfEmpty = throwIfEmpty;
+exports.unique = unique;

package/dist/{index.d.ts → index.d.cts}

@@ -1,3 +1,4 @@
+//#region src/types.d.ts
 /**
  * Represents a path that can be provided as a single string
  * or an array of segments.
@@ -38,16 +39,17 @@ type Constructor<T = {}> = new (...args: any[]) => T;
  * @template T A tuple representing the types of the event arguments.
  */
 type Subscribable<T extends any[]> = {
-    readonly listenerCount: number;
-    /**
-     * Subscribes a listener to this event.
-     * @returns A function to unsubscribe the listener.
-     */
-    subscribe(listener: (...args: T) => void): () => void;
-    unsubscribe(listener: (...args: T) => void): boolean;
-    clear(): void;
+  readonly listenerCount: number;
+  /**
+       * Subscribes a listener to this event.
+       * @returns A function to unsubscribe the listener.
+       */
+  subscribe(listener: (...args: T) => void): () => void;
+  unsubscribe(listener: (...args: T) => void): boolean;
+  clear(): void;
 };
-
+//#endregion
+//#region src/arrays.d.ts
 /**
  * Generates an array of numbers from 0 to length-1.
  * @param length The desired length of the array.
@@ -119,7 +121,8 @@ declare function unique<T>(array: T[]): T[];
  * @returns A random element from the array, or `undefined` if the array is empty.
  */
 declare function getRandomElement<T>(array: T[]): T | undefined;
-
+//#endregion
+//#region src/assertion.d.ts
 /**
  * Throws an error if the condition is true.
  * @param conditionForThrow - If true, an error will be thrown.
@@ -150,9 +153,10 @@ declare function throwIf(conditionForThrow: boolean, exceptionMessage: string):
  * console.log('First item:', items[0]);
  */
 declare function throwIfEmpty<T>(value: T, exceptionMessage: string): asserts value is NonNullable<T>;
-
+//#endregion
+//#region src/config.d.ts
 interface AxiEngineConfig {
-    pathSeparator: string;
+  pathSeparator: string;
 }
 declare const axiSettings: AxiEngineConfig;
 /**
@@ -160,7 +164,8 @@ declare const axiSettings: AxiEngineConfig;
  * @param newConfig - configuration object
  */
 declare function configure(newConfig: Partial<AxiEngineConfig>): void;
-
+//#endregion
+//#region src/constructor-registry.d.ts
 /**
  * A generic registry for mapping string identifiers to class constructors.
  *
@@ -170,67 +175,69 @@ declare function configure(newConfig: Partial<AxiEngineConfig>): void;
  * @template T - A base type that all registered constructors must produce an instance of.
  */
 declare class ConstructorRegistry<T> {
-    private readonly items;
-    /**
-     * Registers a constructor with a unique string identifier.
-     *
-     * @param typeId - The unique identifier for the constructor (e.g., a static `typeName` property from a class).
-     * @param ctor - The class constructor to register.
-     * @returns The registry instance for chainable calls.
-     * @throws If a constructor with the same `typeId` is already registered.
-     */
-    register(typeId: string, ctor: Constructor<T>): this;
-    /**
-     * Retrieves a constructor by its identifier.
-     *
-     * @param typeId - The identifier of the constructor to retrieve.
-     * @returns The found class constructor.
-     * @throws If no constructor is found for the given `typeId`.
-     */
-    get(typeId: string): Constructor<T>;
-    /**
-     * Checks if a constructor for a given identifier is registered.
-     * @param typeId - The identifier to check.
-     * @returns `true` if a constructor is registered, otherwise `false`.
-     */
-    has(typeId: string): boolean;
-    /**
-     * Clears all registered constructors from the registry.
-     */
-    clear(): void;
+  private readonly items;
+  /**
+       * Registers a constructor with a unique string identifier.
+       *
+       * @param typeId - The unique identifier for the constructor (e.g., a static `typeName` property from a class).
+       * @param ctor - The class constructor to register.
+       * @returns The registry instance for chainable calls.
+       * @throws If a constructor with the same `typeId` is already registered.
+       */
+  register(typeId: string, ctor: Constructor<T>): this;
+  /**
+       * Retrieves a constructor by its identifier.
+       *
+       * @param typeId - The identifier of the constructor to retrieve.
+       * @returns The found class constructor.
+       * @throws If no constructor is found for the given `typeId`.
+       */
+  get(typeId: string): Constructor<T>;
+  /**
+       * Checks if a constructor for a given identifier is registered.
+       * @param typeId - The identifier to check.
+       * @returns `true` if a constructor is registered, otherwise `false`.
+       */
+  has(typeId: string): boolean;
+  /**
+       * Clears all registered constructors from the registry.
+       */
+  clear(): void;
 }
-
+//#endregion
+//#region src/emitter.d.ts
 /**
  * A minimal, type-safe event emitter for a single event.
  * It does not manage state, it only manages subscribers and event dispatching.
  * @template T A tuple representing the types of the event arguments.
  */
 declare class Emitter<T extends any[]> implements Subscribable<T> {
-    private listeners;
-    /**
-     * Returns the number of listeners.
-     */
-    get listenerCount(): number;
-    /**
-     * Subscribes a listener to this event.
-     * @returns A function to unsubscribe the listener.
-     */
-    subscribe(listener: (...args: T) => void): () => void;
-    /**
-     * Manually unsubscribe by listener
-     * @returns returns true if an listener has been removed, or false if the listener does not exist.
-     */
-    unsubscribe(listener: (...args: T) => void): boolean;
-    /**
-     * Dispatches the event to all subscribed listeners.
-     */
-    emit(...args: T): void;
-    /**
-     * Clears all listeners.
-     */
-    clear(): void;
+  private listeners;
+  /**
+       * Returns the number of listeners.
+       */
+  get listenerCount(): number;
+  /**
+       * Subscribes a listener to this event.
+       * @returns A function to unsubscribe the listener.
+       */
+  subscribe(listener: (...args: T) => void): () => void;
+  /**
+       * Manually unsubscribe by listener
+       * @returns returns true if an listener has been removed, or false if the listener does not exist.
+       */
+  unsubscribe(listener: (...args: T) => void): boolean;
+  /**
+       * Dispatches the event to all subscribed listeners.
+       */
+  emit(...args: T): void;
+  /**
+       * Clears all listeners.
+       */
+  clear(): void;
 }
-
+//#endregion
+//#region src/guards.d.ts
 declare function isNullOrUndefined(val: unknown): val is null | undefined;
 declare function isUndefined(val: unknown): val is undefined;
 declare function isNumber(val: unknown): val is number;
@@ -242,7 +249,8 @@ declare function isString(val: unknown): val is string;
  * @returns `true` if the value is a percentage string.
  */
 declare function isPercentageString(val: unknown): val is string;
-
+//#endregion
+//#region src/math.d.ts
 /**
  * Clamps a number between an optional minimum and maximum value.
  * @param val The number to clamp.
@@ -259,14 +267,16 @@ declare function clampNumber(val: number, min?: number | null, max?: number | nu
  * @example getPercentOf(200, 10); // returns 20
  */
 declare function getPercentOf(val: number, percents: number): number;
-
+//#endregion
+//#region src/misc.d.ts
 /**
  * Returns the first key of an object.
  * @param obj The object from which to get the key.
  * @returns The first key of the object as a string.
  */
 declare function firstKeyOf(obj: any): string;
-
+//#endregion
+//#region src/path.d.ts
 /**
  * Ensures that the given path is returned as an array of segments.
  */
@@ -275,7 +285,8 @@ declare function ensurePathArray(path: PathType, separator?: string): string[];
  * Ensures that the given path is returned as a single string.
  */
 declare function ensurePathString(path: PathType, separator?: string): string;
-
+//#endregion
+//#region src/random.d.ts
 /**
  * Returns a random integer between min (inclusive) and max (exclusive).
  * @param min The minimum integer (inclusive).
@@ -289,5 +300,6 @@ declare function randInt(min: number, max: number): number;
  * @returns A unique string ID.
  */
 declare function randId(): string;
-
-export { type AxiEngineConfig, type Constructor, ConstructorRegistry, Emitter, type PathType, type Subscribable, areArraysEqual, axiSettings, clampNumber, configure, ensurePathArray, ensurePathString, firstKeyOf, genArray, getPercentOf, getRandomElement, haveSameElements, isBoolean, isNullOrUndefined, isNumber, isPercentageString, isSequentialStart, isString, isUndefined, last, randId, randInt, shuffleArray, throwIf, throwIfEmpty, unique };
+//#endregion
+export { AxiEngineConfig, Constructor, ConstructorRegistry, Emitter, PathType, Subscribable, areArraysEqual, axiSettings, clampNumber, configure, ensurePathArray, ensurePathString, firstKeyOf, genArray, getPercentOf, getRandomElement, haveSameElements, isBoolean, isNullOrUndefined, isNumber, isPercentageString, isSequentialStart, isString, isUndefined, last, randId, randInt, shuffleArray, throwIf, throwIfEmpty, unique };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/arrays.ts","../src/assertion.ts","../src/config.ts","../src/constructor-registry.ts","../src/emitter.ts","../src/guards.ts","../src/math.ts","../src/misc.ts","../src/path.ts","../src/random.ts"],"mappings":"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"}