@atlantjs/arch 1.0.0

package/utils/datatypes/generic-types.d.ts

@@ -0,0 +1,7 @@
+declare const emptyObject: {};
+export type Newable<T> = new (...args: any[]) => T;
+export type ObjectType = typeof emptyObject;
+export interface Abstract<T> {
+    prototype: T;
+}
+export {};

package/utils/datatypes/generic-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const emptyObject = {};

package/utils/datatypes/string-utils.d.ts

@@ -0,0 +1,3 @@
+interface String {
+    toKebab(): string;
+}

package/utils/datatypes/string-utils.js

@@ -0,0 +1,4 @@
+"use strict";
+String.prototype.toKebab = function () {
+    return this.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+};

package/utils/ducts/common.d.ts

@@ -0,0 +1,9 @@
+export declare const T: unique symbol;
+export declare const Val: unique symbol;
+export declare const FnVal: unique symbol;
+export declare const EmptyArray: readonly any[];
+export type FalseyValues = false | null | undefined | 0 | 0n | "";
+export declare function isTruthy(val: unknown): boolean;
+export type IterType<T> = T extends {
+    [Symbol.iterator](): infer I;
+} ? I : unknown;

package/utils/ducts/common.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyArray = exports.FnVal = exports.Val = exports.T = void 0;
+exports.isTruthy = isTruthy;
+const guardian_1 = require("../type-guard/guardian");
+exports.T = Symbol("T");
+exports.Val = Symbol("Val");
+exports.FnVal = Symbol("FnVal");
+exports.EmptyArray = Object.freeze([]);
+function isTruthy(val) {
+    return val instanceof Date
+        ? guardian_1.Guardian.isEqual(val.getTime(), val.getTime())
+        : !!val;
+}

package/utils/ducts/optional-type.d.ts

@@ -0,0 +1,25 @@
+import { FalseyValues, IterType, T, Val } from "./common";
+export type Something<T> = OptionalType<T> & {
+    [T]: true;
+};
+export type Nothing = OptionalType<never> & {
+    [T]: false;
+};
+export type Optional<T> = OptionalType<T>;
+type From<T> = Exclude<T, Error | FalseyValues>;
+declare class OptionalType<T> {
+    readonly [T]: boolean;
+    readonly [Val]: T;
+    constructor(val: T, something: boolean);
+    [Symbol.iterator](this: Optional<T>): IterType<T>;
+    isSomething(this: Optional<T>): this is Something<T>;
+    isNothing(this: Optional<T>): this is Nothing;
+    unwrap(this: Optional<T>): T;
+    unwrapUnchecked(this: Optional<T>): T | undefined;
+    unwrapOr(this: Optional<T>, def: T): T;
+    unwrapOrElse(this: Optional<T>, f: () => T): T;
+}
+export declare function Optional<T>(val: T): Optional<From<T>>;
+export declare function Something<T>(val: T): Something<T>;
+export declare const Nothing: Readonly<OptionalType<never>>;
+export {};

package/utils/ducts/optional-type.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Nothing = void 0;
+exports.Optional = Optional;
+exports.Something = Something;
+const common_1 = require("./common");
+class OptionalType {
+    constructor(val, something) {
+        this[common_1.T] = something;
+        this[common_1.Val] = val;
+    }
+    [Symbol.iterator]() {
+        return this[common_1.T]
+            ? this[common_1.Val][Symbol.iterator]()
+            : common_1.EmptyArray[Symbol.iterator]();
+    }
+    isSomething() {
+        return this[common_1.T];
+    }
+    isNothing() {
+        return !this[common_1.T];
+    }
+    unwrap() {
+        if (this[common_1.T]) {
+            return this[common_1.Val];
+        }
+        throw new Error("Failed to unwrap Option (found Nothing)");
+    }
+    unwrapUnchecked() {
+        return this[common_1.Val];
+    }
+    unwrapOr(def) {
+        return this[common_1.T] ? this[common_1.Val] : def;
+    }
+    unwrapOrElse(f) {
+        return this[common_1.T] ? this[common_1.Val] : f();
+    }
+}
+function Optional(val) {
+    return from(val);
+}
+function Something(val) {
+    return new OptionalType(val, true);
+}
+exports.Nothing = Object.freeze(new OptionalType(undefined, false));
+function from(val) {
+    return (0, common_1.isTruthy)(val) && !(val instanceof Error)
+        ? Something(val)
+        : exports.Nothing;
+}

package/utils/ducts/return-type.d.ts

@@ -0,0 +1,22 @@
+import { FalseyValues, IterType, T, Val } from "./common";
+export type Success<T> = ReturnType<T, never>;
+export type Failure<E> = ReturnType<never, E>;
+export type Return<T, E> = ReturnType<T, E>;
+type From<T> = Exclude<T, Error | FalseyValues>;
+export declare class ReturnType<T, E> {
+    readonly [T]: boolean;
+    readonly [Val]: T | E;
+    constructor(val: T | E, ok: boolean);
+    [Symbol.iterator](this: Return<T, E>): IterType<T>;
+    isSuccess(this: Return<T, E>): this is Success<T>;
+    isFailure(this: Return<T, E>): this is Failure<E>;
+    flatten<U, F>(this: Return<Return<U, F>, E>): Return<U, E | F>;
+    unwrap(this: Return<T, E>): T;
+    unwrapErr(this: Return<T, E>): E;
+    unwrapOr(this: Return<T, E>, def: T): T;
+    unwrapUnchecked(this: Return<T, E>): T | E;
+}
+export declare function Result<T>(val: T): Return<From<T>, (T extends Error ? T : never) | (Extract<FalseyValues, T> extends never ? never : null)>;
+export declare function Success<T>(val: T): Success<T>;
+export declare function Failure<E>(val: E): Failure<E>;
+export {};

package/utils/ducts/return-type.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturnType = void 0;
+exports.Result = Result;
+exports.Success = Success;
+exports.Failure = Failure;
+const common_1 = require("./common");
+class ReturnType {
+    constructor(val, ok) {
+        this[common_1.Val] = val;
+        this[common_1.T] = ok;
+    }
+    [Symbol.iterator]() {
+        return this[common_1.T]
+            ? this[common_1.Val][Symbol.iterator]()
+            : common_1.EmptyArray[Symbol.iterator]();
+    }
+    isSuccess() {
+        return this[common_1.T];
+    }
+    isFailure() {
+        return !this[common_1.T];
+    }
+    flatten() {
+        return this[common_1.T] ? this[common_1.Val] : this;
+    }
+    unwrap() {
+        if (this[common_1.T]) {
+            return this[common_1.Val];
+        }
+        throw new Error("Failed to unwrap Result (found Err)");
+    }
+    unwrapErr() {
+        if (this[common_1.T]) {
+            throw new Error("Failed to unwrapErr Result (found Ok)");
+        }
+        return this[common_1.Val];
+    }
+    unwrapOr(def) {
+        return this[common_1.T] ? this[common_1.Val] : def;
+    }
+    unwrapUnchecked() {
+        return this[common_1.Val];
+    }
+}
+exports.ReturnType = ReturnType;
+function Result(val) {
+    return from(val);
+}
+function Success(val) {
+    return new ReturnType(val, true);
+}
+function Failure(val) {
+    return new ReturnType(val, false);
+}
+function from(val) {
+    return (0, common_1.isTruthy)(val)
+        ? new ReturnType(val, !(val instanceof Error))
+        : Failure(null);
+}

package/utils/randoms/random-enum-value.d.ts

@@ -0,0 +1,2 @@
+export declare function randomEnumValue<T extends Record<string, unknown>>(anEnum: T): T[keyof T];
+export declare function randomEnumValueExcept<T extends Record<string, unknown>>(anEnum: T, excepts: Array<T[keyof T]>): T[keyof T];

package/utils/randoms/random-enum-value.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomEnumValue = randomEnumValue;
+exports.randomEnumValueExcept = randomEnumValueExcept;
+function randomEnumValue(anEnum) {
+    const keys = Object.keys(anEnum).filter((x) => Number.isNaN(Number(x)));
+    const randomKeyIndex = Math.floor(Math.random() * keys.length);
+    const randomKey = keys[randomKeyIndex];
+    return anEnum[randomKey];
+}
+function randomEnumValueExcept(anEnum, excepts) {
+    const exceptKeys = excepts.map((value) => Object.keys(anEnum).find((key) => anEnum[key] === value));
+    const validKeys = Object.keys(anEnum).filter((key) => Number.isNaN(Number(key)) && !exceptKeys.includes(key));
+    if (validKeys.length === 0) {
+        throw new Error("No valid enum keys available after excluding 'excepts'.");
+    }
+    const randomKeyIndex = Math.floor(Math.random() * validKeys.length);
+    const randomKey = validKeys[randomKeyIndex];
+    return anEnum[randomKey];
+}

package/utils/randoms/random-number.d.ts

@@ -0,0 +1,6 @@
+interface RandomValue {
+    min: number;
+    max: number;
+}
+export declare function randomNumber(value: RandomValue): number;
+export {};

package/utils/randoms/random-number.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomNumber = randomNumber;
+function randomNumber(value) {
+    return Math.floor(Math.random() * (value.max - value.min + 1)) + value.min;
+}

package/utils/type-guard/guardian-exception.d.ts

@@ -0,0 +1,2 @@
+export declare class GuardianException extends Error {
+}

package/utils/type-guard/guardian-exception.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuardianException = void 0;
+class GuardianException extends Error {
+}
+exports.GuardianException = GuardianException;

package/utils/type-guard/guardian.d.ts

@@ -0,0 +1,29 @@
+import { PrimitiveType } from "./guardian.type";
+export declare class Guardian {
+    static and(...args: boolean[]): boolean;
+    static or(...args: boolean[]): boolean;
+    static greaterThan(value: number, reference: number): boolean;
+    static lessThan(value: number, reference: number): boolean;
+    static isEmpty<T>(value: unknown): value is null | undefined | T[];
+    static isNotEmpty(value: unknown): boolean;
+    static isUndefined(value: unknown): value is undefined;
+    static isNotUndefined(value: unknown): value is boolean;
+    static isNull(value: unknown): value is null;
+    static isNotNull(value: unknown): value is boolean;
+    static isEqual(valueA: unknown, valueB: unknown): boolean;
+    static isAnyOf(reference: unknown, anyValues: unknown[]): boolean;
+    static isDifferent(valueA: unknown, valueB: unknown): boolean;
+    static isTruthy(value: boolean): boolean;
+    static isFalsy(value: boolean | undefined): boolean;
+    static ternaryCondition<TTrue, TFalse>(condition: boolean, returnIfTrue: TTrue, returnIfFalse: TFalse): TTrue | TFalse;
+    static isBetween(value: number | string, min: number, max: number): boolean;
+    static isLengthEqual(value: unknown, length: number): boolean;
+    static isNullOrUndefined(value: unknown): value is null | undefined;
+    static isNotNullOrUndefined(value: unknown): value is boolean;
+    static isNumber(value: unknown): value is number;
+    static isString(value: unknown): value is string;
+    static isArray(value: unknown): value is unknown[];
+    static isObject(value: unknown): value is object;
+    static isTypeOf<T>(value: unknown, type: PrimitiveType): value is T;
+    static isNotTypeOf<T>(value: unknown, type: PrimitiveType): value is T;
+}

package/utils/type-guard/guardian.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Guardian = void 0;
+const guardian_exception_1 = require("./guardian-exception");
+class Guardian {
+    static and(...args) {
+        return args.every((func) => func);
+    }
+    static or(...args) {
+        return args.some((func) => func);
+    }
+    static greaterThan(value, reference) {
+        return value > reference;
+    }
+    static lessThan(value, reference) {
+        return value < reference;
+    }
+    static isEmpty(value) {
+        if (Guardian.isNullOrUndefined(value)) {
+            return true;
+        }
+        if (Guardian.isString(value) || Guardian.isArray(value)) {
+            return value.length === 0;
+        }
+        if (Guardian.isObject(value)) {
+            return Object.keys(value).length === 0;
+        }
+        return false;
+    }
+    static isNotEmpty(value) {
+        if (Guardian.isNullOrUndefined(value)) {
+            return false;
+        }
+        if ((Guardian.isString(value) || Guardian.isArray(value)) &&
+            value.length === 0) {
+            return false;
+        }
+        if (Guardian.isObject(value) && Object.keys(value).length === 0) {
+            return false;
+        }
+        return true;
+    }
+    static isUndefined(value) {
+        return value === undefined;
+    }
+    static isNotUndefined(value) {
+        return value !== undefined;
+    }
+    static isNull(value) {
+        return value === null;
+    }
+    static isNotNull(value) {
+        return value !== null;
+    }
+    static isEqual(valueA, valueB) {
+        return valueA === valueB;
+    }
+    static isAnyOf(reference, anyValues) {
+        for (const value of anyValues) {
+            if (Guardian.isEqual(reference, value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static isDifferent(valueA, valueB) {
+        return valueA !== valueB;
+    }
+    static isTruthy(value) {
+        return value;
+    }
+    static isFalsy(value) {
+        return value === false;
+    }
+    static ternaryCondition(condition, returnIfTrue, returnIfFalse) {
+        return condition ? returnIfTrue : returnIfFalse;
+    }
+    static isBetween(value, min, max) {
+        if (min > max)
+            throw new guardian_exception_1.GuardianException(`Max ${max} should be greater than min ${min}.`);
+        if (Guardian.isEmpty(value)) {
+            throw new guardian_exception_1.GuardianException("Cannot check length of a value. Provided value is empty");
+        }
+        const valueLength = Guardian.isNumber(value) ? value : Number(value);
+        return valueLength >= min && valueLength <= max;
+    }
+    static isLengthEqual(value, length) {
+        if (Guardian.isEmpty(value)) {
+            throw new guardian_exception_1.GuardianException("Cannot check length of a value. Provided value is empty");
+        }
+        let valueLength;
+        if (Guardian.isNumber(value)) {
+            valueLength = length;
+        }
+        else if (Guardian.isString(value) || Guardian.isArray(value)) {
+            valueLength = value.length;
+        }
+        else {
+            throw new guardian_exception_1.GuardianException("Unsupported value type");
+        }
+        return valueLength === length;
+    }
+    static isNullOrUndefined(value) {
+        if (value === null || value === undefined)
+            return true;
+        return false;
+    }
+    static isNotNullOrUndefined(value) {
+        if (value === undefined || value === null)
+            return false;
+        return true;
+    }
+    static isNumber(value) {
+        return typeof value === "number";
+    }
+    static isString(value) {
+        return typeof value === "string";
+    }
+    static isArray(value) {
+        return Array.isArray(value);
+    }
+    static isObject(value) {
+        return typeof value === "object";
+    }
+    static isTypeOf(value, type) {
+        return Guardian.isEqual(typeof value, type);
+    }
+    static isNotTypeOf(value, type) {
+        return Guardian.isDifferent(typeof value, type);
+    }
+}
+exports.Guardian = Guardian;

package/utils/type-guard/guardian.type.d.ts

@@ -0,0 +1 @@
+export type PrimitiveType = "string" | "number" | "boolean" | "object" | "undefined" | "function" | "symbol" | "bigint";

package/utils/type-guard/guardian.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });