@xaendar/common 0.0.1

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@xaendar/common",
+  "version": "0.0.1",
+  "type": "module",
+  "author": "Kaitenjo",
+  "license": "MIT",
+  "description": "A library containing common utils and types",
+  "peerDependencies": {
+    "vite": "^8.0.4"
+  }
+}

package/src/models/beautify.type.ts

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

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

@@ -0,0 +1,5 @@
+/**
+ * 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

@@ -0,0 +1,8 @@
+/**
+ * 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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,6 @@
+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

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

package/src/models/function.type.ts

@@ -0,0 +1,86 @@
+/* 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

@@ -0,0 +1,15 @@
+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

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

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,56 @@
+/**
+ * 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

@@ -0,0 +1,11 @@
+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

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

package/tsconfig.json

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

package/vite.config.ts

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