@xaendar/common 0.0.4 → 0.1.0

package/package.json

@@ -1,8 +1,17 @@
-{
-  "name": "@xaendar/common",
-  "version": "0.0.4",
-  "type": "module",
-  "author": "Kaitenjo",
-  "license": "MIT",
-  "description": "A library containing common utils and types"
-}
+{
+  "name": "@xaendar/common",
+  "version": "0.1.0",
+  "description": "A library containing common utils and types",
+  "type": "module",
+  "main": "./xaendar-common.es.js",
+  "module": "./xaendar-common.es.js",
+  "types": "./xaendar-common.es.d.ts",
+  "exports": {
+    ".": {
+      "import": "./xaendar-common.es.js",
+      "types": "./xaendar-common.es.d.ts"
+    }
+  },
+  "peerDependencies": {},
+  "dependencies": {}
+}

package/xaendar-common.es.d.ts

@@ -0,0 +1,165 @@
+/**
+ * A type representing an abstract constructor function for a given type T.
+ * This type can be used to define abstract classes.
+ */
+export declare type AbstractConstructor<T extends Object = Object> = abstract new (...args: any[]) => T;
+
+/**
+ * An abstract constructor function type that can accept any number of arguments
+ * and return an instance of the specified type.
+ */
+export declare type AbstractConstructorFunction<T extends object = object, Statics extends Record<string, unknown> | undefined = undefined> = (abstract new (...args: any[]) => T) & (Statics extends undefined ? object : Statics);
+
+export declare type AccessorDecorator<Class extends Object, Field = unknown, ReturnTypeField = Field> = (value: ClassAccessorDecoratorValue<Field>, context: ClassAccessorDecoratorContext<Class, ReturnTypeField>) => {
+    get?: () => ReturnTypeField;
+    set?: (value: ReturnTypeField) => void;
+    init?: (initialValue: Field) => ReturnTypeField;
+} | void;
+
+/**
+ * A function type that can accept any number of arguments and return a promise of any type.
+ */
+export declare type AsyncFunction<Arguments extends any[] = any[], ReturnType = void> = Arguments extends Array<any> ? (...args: Arguments) => Promise<ReturnType> : () => Promise<ReturnType>;
+
+/**
+ * An async function type that accepts arguments but always resolves to void.
+ * Typically used for async callbacks or side-effect functions.
+ * @template Arguments - The types of the function arguments
+ * @example
+ * type OnUserChangeAsync = AsyncVoidFunction<[user: User]>;
+ * const handleUserChangeAsync: OnUserChangeAsync = async (user) => await api.logChange(user);
+ */
+export declare type AsyncVoidFunction<Arguments extends any[] = any[]> = (...args: Arguments) => Promise<void>;
+
+export declare type Beautify<T extends Object> = {
+    [K in keyof T]: T[K];
+} & {};
+
+export declare type ClassAccessorDecoratorValue<Field = unknown> = {
+    get?: () => Field;
+    set: (value: Field) => void;
+};
+
+declare type ClassDecorator_2<T extends Object, Statics extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}> = (klass: Constructor<T, Statics>, context: ClassDecoratorContext) => void;
+export { ClassDecorator_2 as ClassDecorator }
+
+/**
+ * A type representing a constructor function for a given type T.
+ * This type can be used to define classes or factory functions
+ */
+export declare type Constructor<T extends Object = Object, Statics extends Record<string, unknown> = {}> = (new (...args: any[]) => T) & Statics;
+
+/**
+ * A constructor function type that can accept any number of arguments and return an instance of any type.
+ */
+export declare type ConstructorFunction<T extends object = object, Statics extends Record<string, unknown> | undefined = undefined> = (new (...args: any[]) => T) & (Statics extends undefined ? object : Statics);
+
+export declare type ContainsChar<String extends string, Contains extends string> = String extends `${infer First}${infer Rest}` ? First extends Contains ? true : ContainsChar<Rest, Contains> : false;
+
+export declare type Dictionary<Key extends string | number, Value> = {
+    [K in Key]?: Value;
+};
+
+export declare type FieldDecorator<Class extends Object, Field, ReturnType = Field> = (field: undefined, context: ClassFieldDecoratorContext<Class, Field>) => ((value: Field) => ReturnType);
+
+/**
+ * A function type that can accept any number of arguments and return any type.
+ */
+declare type Function_2<Arguments extends any[] = any[], ReturnType = void> = Arguments extends Array<any> ? (...args: Arguments) => ReturnType : () => ReturnType;
+export { Function_2 as Function }
+
+declare type MethodDecorator_2<T extends Object, Method extends Function_2> = (value: Method, context: ClassMethodDecoratorContext<T, Method>) => Method | void;
+export { MethodDecorator_2 as MethodDecorator }
+
+export declare type Mutable<T extends Object> = {
+    -readonly [P in keyof T]: T[P];
+};
+
+/**
+ * An async function type that accepts no arguments and returns a promise of the specified type.
+ * @template ReturnType - The type that the promise resolves to (defaults to void)
+ * @example
+ * type FetchUser = AsyncFunctionNoArgs<User>;
+ * const fetchUser: FetchUser = async () => await api.getUser();
+ */
+export declare type NoArgsAsyncFunction<ReturnType = void> = () => Promise<ReturnType>;
+
+/**
+ * An async function type that accepts arguments but always resolves to void.
+ */
+export declare type NoArgsAsyncVoidFunction = () => Promise<void>;
+
+/**
+ * A function type that accepts no arguments and returns a value of the specified type.
+ * Also known as a 'thunk' in functional programming.
+ * @template ReturnType - The return type of the function (defaults to void)
+ * @example
+ * type GetUser = FunctionNoArgs<User>;
+ * const getUser: GetUser = () => ({ id: 1, name: 'John' });
+ */
+export declare type NoArgsFunction<ReturnType = void> = () => ReturnType;
+
+/**
+ * A function type that accepts arguments but always returns void.
+ */
+export declare type NoArgsVoidFunction = () => void;
+
+export declare type PositiveInteger<Value extends number> = ContainsChar<`${Value}`, '-'> extends true ? never : ContainsChar<`${Value}`, '.'> extends true ? never : Value;
+
+export declare type RequireOne<T extends Object, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+
+/**
+ * A generic LIFO (Last In, First Out) stack data structure.
+ *
+ * @template T - The type of elements held in the stack. Defaults to `unknown`.
+ */
+export declare class Stack<T = unknown> {
+    /**
+     * Internal array holding the stack elements, ordered from bottom to top.
+     */
+    private _elements;
+    [index: number]: T;
+    constructor();
+    /**
+     * The number of elements currently in the stack.
+     */
+    get length(): number;
+    /**
+     * A shallow copy of the elements in the stack, ordered from bottom to top.
+     */
+    get values(): T[];
+    /**
+     * Removes and returns the top element of the stack.
+     *
+     * @returns The top element, or `undefined` if the stack is empty.
+     */
+    pop(): T | undefined;
+    /**
+     * Pushes an element onto the top of the stack.
+     *
+     * @param element - The element to push.
+     * @returns The new length of the stack.
+     */
+    push(element: T): number;
+}
+
+export declare type TupleOfLength<Length extends number, TupleType = number, Acc extends TupleType[] = []> = PositiveInteger<Length> extends never ? never : Acc['length'] extends Length ? Acc : TupleOfLength<Length, TupleType, [...Acc, TupleType]>;
+
+/**
+ * A function type that accepts arguments but always returns void.
+ * Typically used for callbacks, event handlers, or side-effect functions.
+ * @template Arguments - The types of the function arguments
+ * @example
+ * type OnUserChange = VoidFunction<[user: User]>;
+ * const handleUserChange: OnUserChange = (user) => console.log(user);
+ */
+declare type VoidFunction_2<Arguments extends any[] = any[]> = (...args: Arguments) => void;
+export { VoidFunction_2 as VoidFunction }
+
+export { }

package/xaendar-common.es.js

@@ -0,0 +1,25 @@
+//#region ../packages/common/src/models/stack/stack.model.ts
+var e = class {
+	_elements = [];
+	constructor() {
+		return new Proxy(this, { get(e, t) {
+			if (typeof t == "string") return isNaN(Number(t)) ? e[t] : e._elements[Number(t)];
+		} });
+	}
+	get length() {
+		return this._elements.length;
+	}
+	get values() {
+		return [...this._elements];
+	}
+	pop() {
+		return this._elements.pop();
+	}
+	push(e) {
+		return this._elements.push(e);
+	}
+};
+//#endregion
+export { e as Stack };
+
+//# sourceMappingURL=xaendar-common.es.js.map

package/xaendar-common.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xaendar-common.es.js","names":[],"sources":["../../../packages/common/src/models/stack/stack.model.ts"],"sourcesContent":["/**\r\n * A generic LIFO (Last In, First Out) stack data structure.\r\n *\r\n * @template T - The type of elements held in the stack. Defaults to `unknown`.\r\n */\r\nexport class Stack<T = unknown> {\r\n  /**\r\n   * Internal array holding the stack elements, ordered from bottom to top.\r\n   */\r\n  private _elements = new Array<T>;\r\n\r\n  [index: number]: T;\r\n\r\n  constructor() {\r\n    return new Proxy(this, {\r\n      get(target, prop) {\r\n        if (typeof prop === 'string') {\r\n          return isNaN(Number(prop)) ? (target as unknown as { [prop]: unknown })[prop] : target._elements[Number(prop)];\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * The number of elements currently in the stack.\r\n   */\r\n  public get length(): number {\r\n    return this._elements.length;\r\n  }\r\n\r\n  /**\r\n   * A shallow copy of the elements in the stack, ordered from bottom to top.\r\n   */\r\n  public get values(): T[] {\r\n    return [...this._elements];\r\n  }\r\n\r\n  /**\r\n   * Removes and returns the top element of the stack.\r\n   *\r\n   * @returns The top element, or `undefined` if the stack is empty.\r\n   */\r\n  public pop(): T | undefined {\r\n    return this._elements.pop();\r\n  }\r\n\r\n  /**\r\n   * Pushes an element onto the top of the stack.\r\n   *\r\n   * @param element - The element to push.\r\n   * @returns The new length of the stack.\r\n   */\r\n  public push(element: T): number {\r\n    return this._elements.push(element);\r\n  }\r\n}"],"mappings":";AAKA,IAAa,IAAb,MAAgC;CAI9B,YAAoB,EAAY;CAIhC,cAAc;AACZ,SAAO,IAAI,MAAM,MAAM,EACrB,IAAI,GAAQ,GAAM;AAChB,OAAI,OAAO,KAAS,SAClB,QAAO,MAAM,OAAO,EAAK,CAAC,GAAI,EAA0C,KAAQ,EAAO,UAAU,OAAO,EAAK;KAGlH,CAAC;;CAMJ,IAAW,SAAiB;AAC1B,SAAO,KAAK,UAAU;;CAMxB,IAAW,SAAc;AACvB,SAAO,CAAC,GAAG,KAAK,UAAU;;CAQ5B,MAA4B;AAC1B,SAAO,KAAK,UAAU,KAAK;;CAS7B,KAAY,GAAoB;AAC9B,SAAO,KAAK,UAAU,KAAK,EAAQ"}

package/src/models/beautify.type.ts

@@ -1,3 +0,0 @@
-export type Beautify<T extends Object> = {
-  [K in keyof T]: T[K] 
-} & {}

package/src/models/constructors/abstact-constructor.type.ts

@@ -1,5 +0,0 @@
-/**
- * A type representing an abstract constructor function for a given type T.
- * This type can be used to define abstract classes.
- */
-export type AbstractConstructor<T extends Object = Object> = abstract new (...args: any[]) => T;

package/src/models/constructors/constructor.type.ts

@@ -1,8 +0,0 @@
-/**
- * A type representing a constructor function for a given type T.
- * This type can be used to define classes or factory functions
- */
-export type Constructor<
-  T extends Object = Object, 
-  Statics extends Record<string, unknown> = {}
-> = (new (...args: any[]) => T) & Statics;

package/src/models/contains-char.ts

@@ -1,9 +0,0 @@
-export type ContainsChar<
-  String extends string,
-  Contains extends string
-> =
-  String extends `${infer First}${infer Rest}`
-    ? First extends Contains
-      ? true
-      : ContainsChar<Rest, Contains>
-    : false;

package/src/models/decorators/accessor-decorator.type.ts

@@ -1,17 +0,0 @@
-export type AccessorDecorator<
-  Class extends Object, 
-  Field = unknown,
-  ReturnTypeField = Field
-> = (
-  value: ClassAccessorDecoratorValue<Field>,
-  context: ClassAccessorDecoratorContext<Class, ReturnTypeField>
-) => {
-  get?: () => ReturnTypeField;
-  set?: (value: ReturnTypeField) => void;
-  init?: (initialValue: Field) => ReturnTypeField;
-} | void;
-
-export type ClassAccessorDecoratorValue<Field = unknown> = {
-  get?: () => Field;
-  set: (value: Field) => void;
-};

package/src/models/decorators/class-decorator.type.ts

@@ -1,6 +0,0 @@
-import { Constructor } from '../constructors/constructor.type';
-
-export type ClassDecorator<
-  T extends Object, 
-  Statics extends { [key: string]: any } = { [key: string]: any }
-> = (klass: Constructor<T, Statics>, context: ClassDecoratorContext) => void

package/src/models/decorators/field-decorator.type.ts

@@ -1,5 +0,0 @@
-export type FieldDecorator<
-  Class extends Object, 
-  Field,
-  ReturnType = Field
-> = (field: undefined, context: ClassFieldDecoratorContext<Class, Field>) => ((value: Field) => ReturnType);

package/src/models/decorators/method-decorator.type.ts

@@ -1,6 +0,0 @@
-import { Function } from '../function.type';
-
-export type MethodDecorator<
- T extends Object,
-  Method extends Function
-> = (value: Method, context: ClassMethodDecoratorContext<T, Method>) => Method | void;

package/src/models/dictionary.type.ts

@@ -1,3 +0,0 @@
-export type Dictionary<Key extends string | number, Value> = {
-  [K in Key]?: Value
-}

package/src/models/function.type.ts

@@ -1,86 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * A function type that can accept any number of arguments and return any type.
- */
-export type Function<
-  Arguments extends any[] = any[],
-  ReturnType = void
-> = Arguments extends Array<any>
-  ? (...args: Arguments) => ReturnType
-  : () => ReturnType;
-
-/**
- * A function type that can accept any number of arguments and return a promise of any type.
- */
-export type AsyncFunction<
-  Arguments extends any[] = any[],
-  ReturnType = void
-> = Arguments extends Array<any>
-  ? (...args: Arguments) => Promise<ReturnType>
-  : () => Promise<ReturnType>;
-
-/**
- * A function type that accepts no arguments and returns a value of the specified type.
- * Also known as a 'thunk' in functional programming.
- * @template ReturnType - The return type of the function (defaults to void)
- * @example
- * type GetUser = FunctionNoArgs<User>;
- * const getUser: GetUser = () => ({ id: 1, name: 'John' });
- */
-export type NoArgsFunction <ReturnType = void> = () => ReturnType;
-
-/**
- * An async function type that accepts no arguments and returns a promise of the specified type.
- * @template ReturnType - The type that the promise resolves to (defaults to void)
- * @example
- * type FetchUser = AsyncFunctionNoArgs<User>;
- * const fetchUser: FetchUser = async () => await api.getUser();
- */
-export type NoArgsAsyncFunction <ReturnType = void> = () => Promise<ReturnType>;
-
-/**
- * A function type that accepts arguments but always returns void.
- */
-export type NoArgsVoidFunction = () => void;
-
-/**
- * An async function type that accepts arguments but always resolves to void.
- */
-export type NoArgsAsyncVoidFunction = () => Promise<void>;
-
-/**
- * A function type that accepts arguments but always returns void.
- * Typically used for callbacks, event handlers, or side-effect functions.
- * @template Arguments - The types of the function arguments
- * @example
- * type OnUserChange = VoidFunction<[user: User]>;
- * const handleUserChange: OnUserChange = (user) => console.log(user);
- */
-export type VoidFunction<Arguments extends any[] = any[]> = (...args: Arguments) => void;
-
-/**
- * An async function type that accepts arguments but always resolves to void.
- * Typically used for async callbacks or side-effect functions.
- * @template Arguments - The types of the function arguments
- * @example
- * type OnUserChangeAsync = AsyncVoidFunction<[user: User]>;
- * const handleUserChangeAsync: OnUserChangeAsync = async (user) => await api.logChange(user);
- */
-export type AsyncVoidFunction<Arguments extends any[] = any[]> = (...args: Arguments) => Promise<void>;
-
-/**
- * A constructor function type that can accept any number of arguments and return an instance of any type.
- */
-export type ConstructorFunction<
-  T extends object = object,
-  Statics extends Record<string, unknown> | undefined = undefined
-> = (new (...args: any[]) => T) & (Statics extends undefined ? object : Statics);
-
-/**
- * An abstract constructor function type that can accept any number of arguments
- * and return an instance of the specified type.
- */
-export type AbstractConstructorFunction<
-  T extends object = object,
-  Statics extends Record<string, unknown> | undefined = undefined
-> = (abstract new (...args: any[]) => T) & (Statics extends undefined ? object : Statics);

package/src/models/index.ts

@@ -1,15 +0,0 @@
-export * from './beautify.type';
-export * from './constructors/abstact-constructor.type';
-export * from './constructors/constructor.type';
-export * from './contains-char';
-export * from './decorators/accessor-decorator.type';
-export * from './decorators/class-decorator.type';
-export * from './decorators/field-decorator.type';
-export * from './decorators/method-decorator.type';
-export * from './dictionary.type';
-export * from './function.type';
-export * from './mutable.type';
-export * from './positive-integer.type';
-export * from './require-one.type';
-export * from './stack/stack.model';
-export * from './tuple-of-length.type';

package/src/models/mutable.type.ts

@@ -1,3 +0,0 @@
-export type Mutable<T extends Object> = {
-  -readonly [P in keyof T]: T[P];
-};

package/src/models/positive-integer.type.ts

@@ -1,8 +0,0 @@
-import { ContainsChar } from './contains-char';
-
-export type PositiveInteger<Value extends number> =
-  ContainsChar<`${Value}`, '-'> extends true
-    ? never
-    : ContainsChar<`${Value}`, '.'> extends true
-      ? never
-        : Value;

package/src/models/require-one.type.ts

@@ -1,6 +0,0 @@
-export type RequireOne<T extends Object, Keys extends keyof T = keyof T> =
-  Pick<T, Exclude<keyof T, Keys>> &
-  {
-    [K in Keys]-?: Required<Pick<T, K>> &
-      Partial<Pick<T, Exclude<Keys, K>>>
-  }[Keys];

package/src/models/stack/stack.model.ts

@@ -1,56 +0,0 @@
-/**
- * A generic LIFO (Last In, First Out) stack data structure.
- *
- * @template T - The type of elements held in the stack. Defaults to `unknown`.
- */
-export class Stack<T = unknown> {
-  /**
-   * Internal array holding the stack elements, ordered from bottom to top.
-   */
-  private _elements = new Array<T>;
-
-  [index: number]: T;
-
-  constructor() {
-    return new Proxy(this, {
-      get(target, prop) {
-        if (typeof prop === 'string') {
-          return isNaN(Number(prop)) ? (target as unknown as { [prop]: unknown })[prop] : target._elements[Number(prop)];
-        }
-      }
-    });
-  }
-
-  /**
-   * The number of elements currently in the stack.
-   */
-  public get length(): number {
-    return this._elements.length;
-  }
-
-  /**
-   * A shallow copy of the elements in the stack, ordered from bottom to top.
-   */
-  public get values(): T[] {
-    return [...this._elements];
-  }
-
-  /**
-   * Removes and returns the top element of the stack.
-   *
-   * @returns The top element, or `undefined` if the stack is empty.
-   */
-  public pop(): T | undefined {
-    return this._elements.pop();
-  }
-
-  /**
-   * Pushes an element onto the top of the stack.
-   *
-   * @param element - The element to push.
-   * @returns The new length of the stack.
-   */
-  public push(element: T): number {
-    return this._elements.push(element);
-  }
-}

package/src/models/tuple-of-length.type.ts

@@ -1,11 +0,0 @@
-import { PositiveInteger } from './positive-integer.type';
-
-export type TupleOfLength<
-  Length extends number,
-  TupleType = number,
-  Acc extends TupleType[] = []
-> = PositiveInteger<Length> extends never
-      ? never
-      : Acc['length'] extends Length
-        ? Acc
-        : TupleOfLength<Length, TupleType, [...Acc, TupleType]>

package/src/public-api.ts

@@ -1 +0,0 @@
-export * from './models';

package/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-}

package/vite.config.ts

@@ -1,4 +0,0 @@
-import { defineConfig } from 'vite';
-import getViteConfig from '../../vite-config';
-
-export default defineConfig(getViteConfig('@xaendar/common', __dirname));