drimion 0.1.0

package/dist/kernel/utils/number.utils.ts

@@ -0,0 +1,341 @@
+/**
+ * @description
+ * Divides two numbers (`valueA` by `valueB`) with support for validation and normalization.
+ * Handles edge cases such as non-numeric inputs and applies a specified precision to the result.
+ *
+ * @param valueA The dividend (numerator). Can be a number or a value convertible to a number.
+ * @param valueB The divisor (denominator). Can be a number or a value convertible to a number.
+ * @param precision The number of decimal places to apply to the result. Defaults to 5.
+ * @returns The result of the division, normalized and adjusted to the specified precision.
+ * Returns `0` if either value is not a valid number.
+ *
+ * @example
+ * ```typescript
+ * Divide(10, 2); // Returns 5
+ * Divide(10, 3, 3); // Returns 3.333
+ * Divide("10", "2"); // Returns 5 (handles string inputs)
+ * Divide(NaN, 2); // Returns 0
+ * ```
+ */
+export const Divide = (
+	valueA: number,
+	valueB: number,
+	precision = 5,
+): number => {
+	const isValueOneNumber = typeof valueA === "number";
+	const isValueTwoNumber = typeof valueB === "number";
+	const isBothNumber = isValueOneNumber && isValueTwoNumber;
+
+	if (!isBothNumber) {
+		const isNaNValueA = IsNaN(valueA);
+		const isNaNValueB = IsNaN(valueB);
+		const isBothNaN = isNaNValueA && isNaNValueB;
+
+		if (isBothNaN || isNaNValueA || isNaNValueB) return 0;
+		const result = ToPrecision(
+			Float(ToLong(Float(valueA)) / ToLong(Float(valueB))),
+			precision,
+		);
+
+		return EnsureNumber(result);
+	}
+
+	const result = ToPrecision(Float(ToLong(valueA) / ToLong(valueB)), precision);
+	return EnsureNumber(result);
+};
+
+/**
+ * @description
+ * Ensures the input is a valid number. If the input is `NaN` or `Infinity`, it returns `0`.
+ *
+ * @param value The number to validate.
+ * @returns The original number if it is valid, or `0` if the input is `NaN` or `Infinity`.
+ *
+ * @example
+ * ```typescript
+ * EnsureNumber(42); // Returns 42
+ * EnsureNumber(NaN); // Returns 0
+ * EnsureNumber(Infinity); // Returns 0
+ * ```
+ */
+export const EnsureNumber = (value: number): number => {
+	if (Number.isNaN(value) || value === Infinity) return 0;
+	return value;
+};
+
+/**
+ * @description
+ * Normalizes a value into a floating-point number (`float`).
+ *
+ * If the value is a string representation of a number, it parses it into a `float`.
+ * If the value is already a number, it returns the value as is.
+ * If the value is invalid (`NaN` or non-numeric), it returns `0`.
+ *
+ * @param value The input value to normalize. Can be a string or a number.
+ * @returns A floating-point number representation of the input, or `0` if the input is invalid.
+ *
+ * @example
+ * ```typescript
+ * Float("123.45"); // Returns 123.45
+ * Float(678.90); // Returns 678.9
+ * Float("invalid"); // Returns 0
+ * Float(NaN); // Returns 0
+ * ```
+ */
+export const Float = (value: number): number => {
+	if (typeof value === "string" && !IsNaN(value)) return parseFloat(value);
+	if (typeof value === "number") return value;
+	return 0;
+};
+
+/**
+ * @description
+ * Checks if the provided value is `NaN` (Not-a-Number). The function attempts to parse the value into a number
+ * and determines if the result is `NaN`.
+ *
+ * @param value The value to check. Can be a string or a number.
+ * @returns `true` if the value is `NaN`, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * IsNaN("123"); // Returns false (valid number)
+ * IsNaN("abc"); // Returns true (not a number)
+ * IsNaN(NaN); // Returns true
+ * IsNaN(123); // Returns false (valid number)
+ * ```
+ */
+export const IsNaN = (value: string | number): boolean => {
+	return Number.isNaN(parseFloat(String(value)));
+};
+
+/**
+ * @description
+ * Multiplies two numbers (`valueA` and `valueB`) with validation, normalization,
+ * and optional precision adjustment. Handles edge cases where the inputs are not valid numbers.
+ *
+ * @param valueA The first value to multiply. Can be a number or a value convertible to a number.
+ * @param valueB The second value to multiply. Can be a number or a value convertible to a number.
+ * @param precision The number of decimal places to apply to the result. Defaults to 5.
+ * @returns The result of the multiplication, normalized and adjusted to the specified precision.
+ * Returns `0` if either value is not a valid number.
+ *
+ * @example
+ * ```typescript
+ * Multiply(10, 2); // Returns 20
+ * Multiply(10, 2.5, 2); // Returns 25.00
+ * Multiply("10", "3"); // Returns 30 (handles string inputs)
+ * Multiply(NaN, 2); // Returns 0
+ * ```
+ */
+export const Multiply = (
+	valueA: number,
+	valueB: number,
+	precision = 5,
+): number => {
+	const isValueOneNumber = typeof valueA === "number";
+	const isValueTwoNumber = typeof valueB === "number";
+	const isBothNumber = isValueOneNumber && isValueTwoNumber;
+
+	if (!isBothNumber) {
+		const isNaNValueA = IsNaN(valueA);
+		const isNaNValueB = IsNaN(valueB);
+		const isBothNaN = isNaNValueA && isNaNValueB;
+
+		if (isBothNaN || isNaNValueA || isNaNValueB) return 0;
+		const result = ToPrecision(
+			ToDecimal(
+				Float(ToDecimal(ToLong(Float(valueA)) * ToLong(Float(valueB)))),
+			),
+			precision,
+		);
+		return EnsureNumber(result);
+	}
+
+	const result = ToPrecision(
+		ToDecimal(Float(ToDecimal(ToLong(valueA) * ToLong(valueB)))),
+		precision,
+	);
+
+	return EnsureNumber(result);
+};
+
+/**
+ * @description
+ * Subtracts one number (`valueB`) from another (`valueA`) with optional precision adjustment.
+ * Handles edge cases where inputs are not valid numbers by normalizing the values or returning defaults.
+ *
+ * @param valueA The first value (minuend). Can be a number or a value convertible to a number.
+ * @param valueB The second value (subtrahend). Can be a number or a value convertible to a number.
+ * @param precision The number of decimal places to apply to the result. Defaults to 5.
+ * @returns The result of the subtraction, normalized and adjusted to the specified precision.
+ * Returns `0` if both inputs are `NaN`. If one of the inputs is invalid, the valid input is returned
+ * (or negated if the second value is `NaN`).
+ *
+ * @example
+ * ```typescript
+ * Subtract(10, 2); // Returns 8
+ * Subtract(10, "3.5", 2); // Returns 6.50
+ * Subtract(NaN, 5); // Returns -5
+ * Subtract(10, NaN); // Returns 10
+ * Subtract(NaN, NaN); // Returns 0
+ * ```
+ */
+export const Subtract = (
+	valueA: number,
+	valueB: number,
+	precision = 5,
+): number => {
+	const isValueOneNumber = typeof valueA === "number";
+	const isValueTwoNumber = typeof valueB === "number";
+	const isBothNumber = isValueOneNumber && isValueTwoNumber;
+
+	if (!isBothNumber) {
+		const isNaNValueA = IsNaN(valueA);
+		const isNaNValueB = IsNaN(valueB);
+		const isBothNaN = isNaNValueA && isNaNValueB;
+
+		if (isBothNaN) return 0;
+		if (isNaNValueA) return Float(valueB) * -1;
+		if (isNaNValueB) return Float(valueA);
+
+		const result = ToPrecision(
+			Float(ToDecimal(ToLong(Float(valueA)) - ToLong(Float(valueB)))),
+			precision,
+		);
+		return EnsureNumber(result);
+	}
+
+	const result = ToPrecision(
+		Float(ToDecimal(ToLong(valueA) - ToLong(valueB))),
+		precision,
+	);
+	return EnsureNumber(result);
+};
+
+/**
+ * @description
+ * Adds two numbers (`valueA` and `valueB`) with optional precision adjustment.
+ * Handles edge cases where inputs are not valid numbers by normalizing the values or returning defaults.
+ *
+ * @param valueA The first value to add. Can be a number or a value convertible to a number.
+ * @param valueB The second value to add. Can be a number or a value convertible to a number.
+ * @param precision The number of decimal places to apply to the result. Defaults to 5.
+ * @returns The result of the addition, normalized and adjusted to the specified precision.
+ * Returns `0` if both inputs are `NaN`. If one of the inputs is invalid, the valid input is returned.
+ *
+ * @example
+ * ```typescript
+ * Sum(10, 5); // Returns 15
+ * Sum(10, "3.5", 2); // Returns 13.50
+ * Sum(NaN, 5); // Returns 5
+ * Sum(10, NaN); // Returns 10
+ * Sum(NaN, NaN); // Returns 0
+ * ```
+ */
+export const Sum = (valueA: number, valueB: number, precision = 5): number => {
+	const isValueOneNumber = typeof valueA === "number";
+	const isValueTwoNumber = typeof valueB === "number";
+	const isBothNumber = isValueOneNumber && isValueTwoNumber;
+
+	if (!isBothNumber) {
+		const isNaNValueA = IsNaN(valueA);
+		const isNaNValueB = IsNaN(valueB);
+		const isBothNaN = isNaNValueA && isNaNValueB;
+
+		if (isBothNaN) return 0;
+		if (isNaNValueA) return Float(valueB);
+		if (isNaNValueB) return Float(valueA);
+
+		const result = ToPrecision(
+			Float(ToDecimal(ToLong(Float(valueA)) + ToLong(Float(valueB)))),
+			precision,
+		);
+		return EnsureNumber(result);
+	}
+
+	const result = ToPrecision(
+		Float(ToDecimal(ToLong(valueA) + ToLong(valueB))),
+		precision,
+	);
+	return EnsureNumber(result);
+};
+
+/**
+ * @description
+ * Converts a number to its decimal equivalent by dividing it by 100.
+ * This is useful for normalizing values, such as converting percentages to decimals.
+ *
+ * @param value The input value to convert. Must be a number.
+ * @returns The decimal equivalent of the input number.
+ * If the input is not a valid number, it returns the input as is.
+ *
+ * @example
+ * ```typescript
+ * ToDecimal(500); // Returns 5
+ * ToDecimal(25); // Returns 0.25
+ * ToDecimal("100"); // Returns "100" (input not a valid number)
+ * ```
+ */
+export const ToDecimal = (value: number): number => {
+	const isValid = typeof value === "number";
+	if (!isValid) return value;
+	return value / 100;
+};
+
+/**
+ * @description
+ * Converts a number to its "long" equivalent by multiplying it by 100.
+ * This is useful for denormalizing values, such as converting decimals to percentages.
+ *
+ * @param value The input value to convert. Must be a number.
+ * @returns The "long" equivalent of the input number.
+ * If the input is not a valid number, it returns the input as is.
+ *
+ * @example
+ * ```typescript
+ * ToLong(5); // Returns 500
+ * ToLong(0.25); // Returns 25
+ * ToLong("100"); // Returns "100" (input not a valid number)
+ * ```
+ */
+export const ToLong = (value: number): number => {
+	const isValid = typeof value === "number";
+	if (!isValid) return value;
+	return value * 100;
+};
+
+/**
+ * @description
+ * Adjusts a number or numeric string to a specified precision. The function ensures that the
+ * result maintains the desired level of precision, handling both integer and decimal parts appropriately.
+ *
+ * @param value The input value to be adjusted. Can be a number or a numeric string.
+ * @param precision The desired number of decimal places in the result.
+ * @returns A number rounded to the specified precision. If the input is a string, it is parsed and adjusted accordingly.
+ *
+ * @example
+ * ```typescript
+ * ToPrecision(123.456789, 2); // Returns 123.46
+ * ToPrecision("987.654321", 3); // Returns 987.654
+ * ToPrecision(10.5, 1); // Returns 10.5
+ * ```
+ */
+export const ToPrecision = (
+	value: number | string,
+	precision: number,
+): number => {
+	if (typeof value === "string") {
+		return parseFloat(parseFloat(String(value)).toFixed(precision));
+	}
+
+	const int = Math.trunc(value) * 100;
+	const dec = Number(
+		((value * 100 - int) / 100)
+			.toPrecision(precision + 3)
+			.slice(0, precision + 2),
+	);
+
+	return Number(
+		(int / 100 + dec).toPrecision(String(int).length + 1 + precision),
+	);
+};

package/dist/kernel/utils/object.utils.ts

@@ -0,0 +1,61 @@
+/**
+ * @description
+ * Recursively freezes an object to make it immutable. This prevents any modifications to the object or its nested properties.
+ *
+ * @typeParam T - The type of the object being frozen.
+ * @param obj The object to be deeply frozen. If the input is not an object, it is returned as is.
+ * @returns The same object, but deeply frozen to prevent further modifications.
+ *
+ * @example
+ * ```typescript
+ * const mutableObject = { a: 1, b: { c: 2 } };
+ * const frozenObject = DeepFreeze(mutableObject);
+ *
+ * frozenObject.a = 2; // This will throw a TypeError in strict mode.
+ * frozenObject.b.c = 3; // This will also throw a TypeError.
+ * ```
+ */
+export const DeepFreeze = <T extends object>(obj: T): T => {
+	if (!obj || typeof obj !== "object") return obj;
+
+	Object.keys(obj).forEach((prop) => {
+		const key = prop as keyof typeof obj;
+		if (typeof obj[key] === "object" && !Object.isFrozen(obj[key]))
+			DeepFreeze(obj[key] as T);
+	});
+
+	return Object.freeze(obj) as T;
+};
+
+/**
+ * @description
+ * Stringifies values with stable object key ordering so deeply equal objects
+ * produce the same representation regardless of insertion order.
+ */
+export const StableStringify = (value: unknown): string => {
+	const seen = new WeakSet<object>();
+
+	const normalize = (target: unknown): unknown => {
+		if (target === null || typeof target !== "object") {
+			if (typeof target === "bigint") return target.toString();
+			if (typeof target === "symbol") return target.description;
+			if (typeof target === "function") return target.toString();
+			return target;
+		}
+
+		if (target instanceof Date) return target.toISOString();
+
+		if (seen.has(target)) return "[Circular]";
+		seen.add(target);
+
+		if (Array.isArray(target)) return target.map((item) => normalize(item));
+
+		const result: Record<string, unknown> = {};
+		for (const key of Object.keys(target).sort()) {
+			result[key] = normalize((target as Record<string, unknown>)[key]);
+		}
+		return result;
+	};
+
+	return JSON.stringify(normalize(value));
+};

package/dist/kernel/utils/string.utils.ts

@@ -0,0 +1,128 @@
+/**
+ * @description
+ * Removes characters from a string based on a condition defined by the provided `IsChar` function.
+ *
+ * @param target The input string from which characters will be removed.
+ * @param IsChar A callback function that determines whether a character should be removed.
+ * It receives a character as input and returns `true` if the character should be removed, or `false` otherwise.
+
+ * @returns A new string with the characters removed based on the `IsChar` condition.
+ * If the input `target` is not a string, it returns the input as is.
+ *
+ * @example
+ * ```typescript
+ * const isVowel = (char: string) => 'aeiou'.includes(char.toLowerCase());
+ * const result = RemoveChars("Hello, World!", isVowel);
+ * console.log(result); // "Hll, Wrld!"
+ *
+ * const isDigit = (char: string) => /\d/.test(char);
+ * const result = RemoveChars("123abc456", isDigit);
+ * console.log(result); // "abc"
+ * ```
+ */
+export const RemoveChars = (
+	target: string,
+	IsChar: (char: string) => boolean,
+): string => {
+	if (typeof target !== "string") return target;
+
+	const chars = target.split("");
+	const str = chars.reduce((prev, current) => {
+		const isSpecialChar = IsChar(current);
+		if (isSpecialChar) return prev;
+		return prev + current;
+	}, "");
+
+	return str;
+};
+
+/**
+ * @description
+ * Replaces all occurrences of a specified character in a string with a given value.
+ * The replacement is performed globally (all occurrences).
+ *
+ * @param target The string in which the replacements will be made.
+ * @param char The character or substring to replace. A global regular expression will be created based on this.
+ * @param value The value to replace the `char` with. Can be a string or a number.
+ * @returns A new string with all occurrences of `char` replaced by `value`.
+ * If the inputs are not valid (e.g., `target` or `char` are not strings), the original `target` is returned unchanged.
+ *
+ * @example
+ * ```typescript
+ * // Example 1: Replace a character
+ * const result = Replace("hello world", "o", "a");
+ * console.log(result); // "hella warld"
+ *
+ * // Example 2: Replace a substring
+ * const result = Replace("2024-12-15", "-", "/");
+ * console.log(result); // "2024/12/15"
+ *
+ * // Example 3: Replace with a number
+ * const result = Replace("Price: $$", "$", 100);
+ * console.log(result); // "Price: 100100"
+ * ```
+ */
+export const ReplaceChars = (
+	target: string,
+	char: string,
+	value: string | number,
+): string => {
+	const pattern = RegExp(char, "g");
+	const isValidTarget = typeof target === "string";
+	const isValidChar = typeof char === "string";
+	const isValidValue = typeof value === "string" || typeof value === "number";
+
+	const isValid = isValidChar && isValidTarget && isValidValue;
+	if (!isValid) return target;
+
+	return target.replace(pattern, `${value}`);
+};
+
+/**
+ * @description Removes all spaces from a given string. It utilizes the `RemoveChars` utility function,
+ * passing a condition to identify spaces as the characters to remove.
+ *
+ * @param target The input string from which spaces will be removed.
+ * @returns A new string with all spaces removed. If the input is not a valid string, it will return the input as is.
+ *
+ * @example
+ * ```typescript
+ * const result = RemoveSpaces("Hello, World!");
+ * console.log(result); // "Hello,World!"
+ *
+ * const anotherResult = RemoveSpaces("   Open  AI ");
+ * console.log(anotherResult); // "OpenAI"
+ * ```
+ */
+export const RemoveSpaces = (target: string): string => {
+	return RemoveChars(target, (char: string) => char === " ");
+};
+
+/**
+ * @description
+ * Converts a JavaScript value into a specialized flatted string. This method serializes
+ * complex objects, including circular references, into a flat structure.
+ *
+ * @param value The JavaScript value to be stringified.
+ * @returns A flatted string representation of the value.
+ *
+ * @example
+ * ```typescript
+ * const obj = { a: 1 };
+ * obj.self = obj;
+ * const result = Stringify(obj);
+ * console.log(result); // Outputs a flatted string representing the object with circular references.
+ * ```
+ */
+export const Stringify = (value: unknown): string => {
+	const seen = new WeakSet();
+	return (
+		JSON.stringify(value, (_, val) => {
+			if (typeof val === "object" && val !== null) {
+				if (seen.has(val)) return "[Circular]";
+				seen.add(val);
+			}
+			return val;
+		}) ?? "undefined"
+	);
+};

package/dist/kernel/utils/type.utils.ts

@@ -0,0 +1,33 @@
+import validator from "../libs/validator";
+
+/**
+ * @description
+ * Get the actual type instead of using the built-in `typeof` keyword for clearer type output.
+ *
+ * @param props The argument to check the type against.
+
+ * @returns A string representing the actual type of the props.
+ *
+ * @example
+ * ```typescript
+ * const type = InvalidPropsType(null)
+ * console.log(type) // "Null" instead of "object"
+ * ```
+ */
+export const InvalidPropsType = (props: unknown): string => {
+	if (validator.isAggregate(props)) return "Aggregate";
+	if (validator.isArray(props)) return "Array";
+	if (validator.isBoolean(props)) return "boolean";
+	if (validator.isDate(props)) return "Date";
+	if (validator.isEntity(props)) return "Entity";
+	if (validator.isFunction(props)) return "Function";
+	if (validator.isID(props)) return "ID";
+	if (validator.isNull(props)) return "Null";
+	if (validator.isNumber(props)) return "Number";
+	if (validator.isObject(props)) return "Object";
+	if (validator.isString(props)) return "String";
+	if (validator.isSymbol(props)) return "Symbol";
+	if (validator.isUndefined(props)) return "Undefined";
+	if (validator.isValueObject(props)) return "Value Object";
+	return typeof props;
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "drimion",
+  "version": "0.1.0",
+  "description": "Headless DDD primitives CLI for TypeScript — own your domain",
+  "keywords": [
+    "ddd",
+    "domain-driven-design",
+    "cli",
+    "codegen",
+    "typescript",
+    "scaffold",
+    "architecture"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bramadl/drimion.git"
+  },
+  "type": "module",
+  "private": false,
+  "bin": {
+    "drimion": "dist/cli/index.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "release:patch": "./scripts/release.sh patch",
+    "release:minor": "./scripts/release.sh minor",
+    "release:major": "./scripts/release.sh major",
+    "build": "tsup && node scripts/copy.mjs",
+    "dev": "tsup --watch",
+    "test": "bun test",
+    "lint": "biome check src/",
+    "format": "biome format src/ --write"
+  },
+  "engines": {
+    "node": ">=18 || >=20"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.4.14",
+    "@types/bun": "latest",
+    "@types/fs-extra": "^11.0.4",
+    "tsup": "^8.5.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.4.2",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "fs-extra": "^11.3.4",
+    "handlebars": "^4.7.9",
+    "ora": "^9.4.0"
+  }
+}