@axi-engine/utils 0.1.9 → 0.2.1

package/dist/index.d.mts

@@ -1,3 +1,8 @@
+/**
+ * Simple scalar type
+ *
+ */
+type ScalarType = string | number | boolean;
 /**
  * Represents a path that can be provided as a single string
  * or an array of segments.
@@ -231,11 +236,18 @@ declare class Emitter<T extends any[]> implements Subscribable<T> {
     clear(): void;
 }
 
+/**
+ * Type guard that checks if a value is a valid ScalarType.
+ * @param value The value to check.
+ * @returns True if the value is a string, number, or boolean.
+ */
+declare function isScalar(value: unknown): value is ScalarType;
 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;
 declare function isBoolean(val: unknown): val is boolean;
 declare function isString(val: unknown): val is string;
+declare function isNull(val: unknown): val is null;
 /**
  * Type guard to check if a value is a string that ends with '%'.
  * @param val The value to check.
@@ -290,4 +302,4 @@ declare function randInt(min: number, max: number): number;
  */
 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 };
+export { type AxiEngineConfig, type Constructor, ConstructorRegistry, Emitter, type PathType, type ScalarType, type Subscribable, areArraysEqual, axiSettings, clampNumber, configure, ensurePathArray, ensurePathString, firstKeyOf, genArray, getPercentOf, getRandomElement, haveSameElements, isBoolean, isNull, isNullOrUndefined, isNumber, isPercentageString, isScalar, isSequentialStart, isString, isUndefined, last, randId, randInt, shuffleArray, throwIf, throwIfEmpty, unique };

package/dist/index.d.ts

@@ -1,12 +1,305 @@
-export type * from './types';
-export * from './arrays';
-export * from './assertion';
-export * from './config';
-export * from './constructor-registry';
-export * from './emitter';
-export * from './guards';
-export * from './math';
-export * from './misc';
-export * from './path';
-export * from './random';
-//# sourceMappingURL=index.d.ts.map
+/**
+ * Simple scalar type
+ *
+ */
+type ScalarType = string | number | boolean;
+/**
+ * Represents a path that can be provided as a single string
+ * or an array of segments.
+ * @example
+ * 'player/stats/health'
+ * ['player', 'stats', 'health']
+ */
+type PathType = string | string[];
+/**
+ * Represents a generic constructor for any class.
+ *
+ * This utility type is essential for implementing higher-order patterns
+ * like mixins, where a function takes a class as an argument and returns
+ * a new, extended class.
+ *
+ * The `...args: any[]` signature allows it to represent constructors
+ * with any number and type of arguments, making it universally applicable.
+ *
+ * @template T - The type of the instance created by the constructor. Defaults to `{}`.
+ *
+ * @example
+ * // Used as a constraint for a base class in a mixin
+ * function Timestamped<TBase extends Constructor>(Base: TBase) {
+ *   return class extends Base {
+ *     timestamp = new Date();
+ *   };
+ * }
+ *
+ * class User {}
+ * const TimestampedUser = Timestamped(User);
+ * const userInstance = new TimestampedUser();
+ * console.log(userInstance.timestamp); // Logs the current date
+ */
+type Constructor<T = {}> = new (...args: any[]) => T;
+/**
+ * Defines the public, read-only contract for an event emitter.
+ * It allows subscribing to an event but not emitting it.
+ * @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;
+};
+
+/**
+ * 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]
+ */
+declare function genArray(length: number): number[];
+/**
+ * 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.
+ */
+declare function shuffleArray<T>(array: T[]): T[];
+/**
+ * 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
+ */
+declare function isSequentialStart<T>(arr1: T[], arr2: T[]): boolean;
+/**
+ * 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
+ */
+declare function haveSameElements<T>(arr1?: T[], arr2?: T[]): boolean;
+/**
+ * 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
+ */
+declare function areArraysEqual<T>(arr1?: T[], arr2?: T[]): boolean;
+/**
+ * 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.
+ */
+declare function last<T>(array: T[]): T | undefined;
+/**
+ * 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.
+ */
+declare function unique<T>(array: T[]): T[];
+/**
+ * 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.
+ */
+declare function getRandomElement<T>(array: T[]): T | undefined;
+
+/**
+ * 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
+ */
+declare function throwIf(conditionForThrow: boolean, exceptionMessage: string): void | never;
+/**
+ * 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]);
+ */
+declare function throwIfEmpty<T>(value: T, exceptionMessage: string): asserts value is NonNullable<T>;
+
+interface AxiEngineConfig {
+    pathSeparator: string;
+}
+declare const axiSettings: AxiEngineConfig;
+/**
+ * set up global configuration for axi-engine.
+ * @param newConfig - configuration object
+ */
+declare function configure(newConfig: Partial<AxiEngineConfig>): void;
+
+/**
+ * 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.
+ */
+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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Type guard that checks if a value is a valid ScalarType.
+ * @param value The value to check.
+ * @returns True if the value is a string, number, or boolean.
+ */
+declare function isScalar(value: unknown): value is ScalarType;
+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;
+declare function isBoolean(val: unknown): val is boolean;
+declare function isString(val: unknown): val is string;
+declare function isNull(val: unknown): val is null;
+/**
+ * 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.
+ */
+declare function isPercentageString(val: unknown): val is string;
+
+/**
+ * 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.
+ */
+declare function clampNumber(val: number, min?: number | null, max?: number | null): number;
+/**
+ * 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
+ */
+declare function getPercentOf(val: number, percents: number): number;
+
+/**
+ * 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;
+
+/**
+ * Ensures that the given path is returned as an array of segments.
+ */
+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;
+
+/**
+ * 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
+ */
+declare function randInt(min: number, max: number): number;
+/**
+ * Generates a unique identifier using uuidv4.
+ * @returns A unique string ID.
+ */
+declare function randId(): string;
+
+export { type AxiEngineConfig, type Constructor, ConstructorRegistry, Emitter, type PathType, type ScalarType, type Subscribable, areArraysEqual, axiSettings, clampNumber, configure, ensurePathArray, ensurePathString, firstKeyOf, genArray, getPercentOf, getRandomElement, haveSameElements, isBoolean, isNull, isNullOrUndefined, isNumber, isPercentageString, isScalar, isSequentialStart, isString, isUndefined, last, randId, randInt, shuffleArray, throwIf, throwIfEmpty, unique };

package/dist/index.js

@@ -1,12 +1,296 @@
-//
-export * from './arrays';
-export * from './assertion';
-export * from './config';
-export * from './constructor-registry';
-export * from './emitter';
-export * from './guards';
-export * from './math';
-export * from './misc';
-export * from './path';
-export * from './random';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConstructorRegistry: () => ConstructorRegistry,
+  Emitter: () => Emitter,
+  areArraysEqual: () => areArraysEqual,
+  axiSettings: () => axiSettings,
+  clampNumber: () => clampNumber,
+  configure: () => configure,
+  ensurePathArray: () => ensurePathArray,
+  ensurePathString: () => ensurePathString,
+  firstKeyOf: () => firstKeyOf,
+  genArray: () => genArray,
+  getPercentOf: () => getPercentOf,
+  getRandomElement: () => getRandomElement,
+  haveSameElements: () => haveSameElements,
+  isBoolean: () => isBoolean,
+  isNull: () => isNull,
+  isNullOrUndefined: () => isNullOrUndefined,
+  isNumber: () => isNumber,
+  isPercentageString: () => isPercentageString,
+  isScalar: () => isScalar,
+  isSequentialStart: () => isSequentialStart,
+  isString: () => isString,
+  isUndefined: () => isUndefined,
+  last: () => last,
+  randId: () => randId,
+  randInt: () => randInt,
+  shuffleArray: () => shuffleArray,
+  throwIf: () => throwIf,
+  throwIfEmpty: () => throwIfEmpty,
+  unique: () => unique
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/arrays.ts
+function genArray(length) {
+  return Array.from({ length }, (_v, i) => i);
+}
+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;
+}
+function isSequentialStart(arr1, arr2) {
+  if (arr1.length > arr2.length) {
+    return false;
+  }
+  return arr1.every((element, index) => element === arr2[index]);
+}
+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]);
+}
+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]);
+}
+function last(array) {
+  return array[array.length - 1];
+}
+function unique(array) {
+  return [...new Set(array)];
+}
+function getRandomElement(array) {
+  if (array.length === 0) {
+    return void 0;
+  }
+  const index = Math.floor(Math.random() * array.length);
+  return array[index];
+}
+
+// src/guards.ts
+function isScalar(value) {
+  const type = typeof value;
+  return type === "string" || type === "number" || type === "boolean";
+}
+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";
+}
+function isNull(val) {
+  return val === null;
+}
+function isPercentageString(val) {
+  return typeof val === "string" && val.endsWith("%");
+}
+
+// src/assertion.ts
+function throwIf(conditionForThrow, exceptionMessage) {
+  if (conditionForThrow) {
+    throw new Error(exceptionMessage);
+  }
+}
+function throwIfEmpty(value, exceptionMessage) {
+  const isArrayAndEmpty = Array.isArray(value) && value.length === 0;
+  if (isNullOrUndefined(value) || isArrayAndEmpty) {
+    throw new Error(exceptionMessage);
+  }
+}
+
+// src/config.ts
+var defaultConfig = {
+  pathSeparator: "/"
+};
+var axiSettings = { ...defaultConfig };
+function configure(newConfig) {
+  Object.assign(axiSettings, newConfig);
+}
+
+// src/constructor-registry.ts
+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();
+  }
+};
+
+// src/emitter.ts
+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();
+  }
+};
+
+// src/math.ts
+function clampNumber(val, min, max) {
+  if (!isNullOrUndefined(min)) val = Math.max(val, min);
+  if (!isNullOrUndefined(max)) val = Math.min(val, max);
+  return val;
+}
+function getPercentOf(val, percents) {
+  return percents / 100 * val;
+}
+
+// src/misc.ts
+function firstKeyOf(obj) {
+  return Object.keys(obj)[0];
+}
+
+// src/path.ts
+function ensurePathArray(path, separator = axiSettings.pathSeparator) {
+  return Array.isArray(path) ? [...path] : path.split(separator);
+}
+function ensurePathString(path, separator = axiSettings.pathSeparator) {
+  return !Array.isArray(path) ? path : path.join(separator);
+}
+
+// src/random.ts
+var import_uuid = require("uuid");
+function randInt(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min) + min);
+}
+function randId() {
+  return (0, import_uuid.v4)();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConstructorRegistry,
+  Emitter,
+  areArraysEqual,
+  axiSettings,
+  clampNumber,
+  configure,
+  ensurePathArray,
+  ensurePathString,
+  firstKeyOf,
+  genArray,
+  getPercentOf,
+  getRandomElement,
+  haveSameElements,
+  isBoolean,
+  isNull,
+  isNullOrUndefined,
+  isNumber,
+  isPercentageString,
+  isScalar,
+  isSequentialStart,
+  isString,
+  isUndefined,
+  last,
+  randId,
+  randInt,
+  shuffleArray,
+  throwIf,
+  throwIfEmpty,
+  unique
+});

package/dist/index.mjs

@@ -45,6 +45,10 @@ function getRandomElement(array) {
 }
 
 // src/guards.ts
+function isScalar(value) {
+  const type = typeof value;
+  return type === "string" || type === "number" || type === "boolean";
+}
 function isNullOrUndefined(val) {
   return val === void 0 || val === null;
 }
@@ -60,6 +64,9 @@ function isBoolean(val) {
 function isString(val) {
   return typeof val === "string";
 }
+function isNull(val) {
+  return val === null;
+}
 function isPercentageString(val) {
   return typeof val === "string" && val.endsWith("%");
 }
@@ -216,9 +223,11 @@ export {
   getRandomElement,
   haveSameElements,
   isBoolean,
+  isNull,
   isNullOrUndefined,
   isNumber,
   isPercentageString,
+  isScalar,
   isSequentialStart,
   isString,
   isUndefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axi-engine/utils",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "description": "Core utility library for Axi Engine, providing common functions for arrays, math, type guards, and more.",
   "license": "MIT",
   "repository": {