@luminix/support 0.0.1-beta.0 → 0.0.1-beta.19

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@luminix/support",
-  "version": "0.0.1-beta.0",
+  "version": "0.0.1-beta.19",
   "module": "dist/support.js",
   "types": "types/index.d.ts",
   "type": "module",
   "scripts": {
+    "prebuild": "rm -rf types",
     "build": "tsc && vite build",
     "lint": "eslint . --report-unused-disable-directives --max-warnings 0",
     "lint:fix": "eslint . --report-unused-disable-directives --max-warnings 0 --fix",
@@ -17,17 +18,17 @@
     "@types/lodash-es": "^4.17.12",
     "@typescript-eslint/eslint-plugin": "^8.4.0",
     "@typescript-eslint/parser": "^8.4.0",
-    "axios": "^1.7.7",
     "eslint": "^9.9.1",
     "jest": "^29.7.0",
     "lodash-es": "^4.17.21",
-    "nanoevents": "^9.0.0",
     "ts-jest": "^29.2.5",
     "typescript": "^5.5.4",
     "vite": "^5.4.3",
     "vite-plugin-dts": "^4.1.0"
   },
-  "peerDependencies": {
-    "immer": "^10.1.1"
+  "dependencies": {
+    "axios": "^1.7.7",
+    "immer": "^10.1.1",
+    "nanoevents": "^9.0.0"
   }
 }

package/types/App/Application.d.ts

@@ -0,0 +1,23 @@
+import { default as EventSource } from '../Contracts/EventSource';
+import { ApplicationEvents, ServiceLoader } from './Interfaces';
+import { default as ServiceProvider } from './ServiceProvider';
+export default class Application<TContainers extends Record<string, any> = Record<string, any>> extends EventSource<ApplicationEvents> {
+    protected providers: (typeof ServiceProvider)[];
+    protected _configuration: Record<string, any>;
+    protected singletons: Record<string, any>;
+    protected loaders: Record<string, ServiceLoader>;
+    constructor(providers?: (typeof ServiceProvider)[]);
+    get services(): Record<string, ServiceLoader>;
+    get configuration(): Record<string, any>;
+    loadConfiguration(): void;
+    bind<K extends keyof TContainers>(abstract: K, concrete: () => TContainers[K]): void;
+    singleton<K extends keyof TContainers>(abstract: K, concrete: () => TContainers[K]): void;
+    make<K extends keyof TContainers & string>(abstract: K): TContainers[K];
+    withConfiguration(configuration: Record<string, any>): this;
+    withProviders(providers: (typeof ServiceProvider)[]): this;
+    create(): void;
+    flush(): void;
+    dump(): void;
+    dump($return: true): Object;
+    dump($return: false | string): void;
+}

package/types/App/Interfaces.d.ts

@@ -0,0 +1,35 @@
+import { default as EventSource } from '../Contracts/EventSource';
+export type ApplicationEvents = {
+    init: (providers: ServiceProviderInterface[]) => void;
+    booting: () => void;
+    booted: () => void;
+    flushed: () => void;
+    flushing: () => void;
+    ready: () => void;
+};
+export declare class ApplicationInterface<TContainers extends Record<string, any> = Record<string, any>> extends EventSource<ApplicationEvents> {
+    get services(): Record<string, ServiceLoader>;
+    get configuration(): Record<string, any>;
+    loadConfiguration(): void;
+    bind<K extends keyof TContainers>(abstract: K, concrete: () => TContainers[K]): void;
+    singleton<K extends keyof TContainers>(abstract: K, concrete: () => TContainers[K]): void;
+    make<K extends keyof TContainers & string>(abstract: K): TContainers[K];
+    withConfiguration(configuration: Record<string, any>): this;
+    withProviders(providers: (typeof ServiceProviderInterface)[]): this;
+    create(): void;
+    flush(): void;
+    dump(): void;
+    dump($return: true): Object;
+    dump($return: false | string): void;
+}
+export interface ServiceLoader {
+    loader: () => any;
+    singleton?: boolean;
+}
+declare class ServiceProviderInterface {
+    constructor(app: ApplicationInterface);
+    boot?(): void;
+    register?(): void;
+    flush?(): void;
+}
+export {};

package/types/App/ServiceProvider.d.ts

@@ -0,0 +1,8 @@
+import { ApplicationInterface } from './Interfaces';
+export default class ServiceProvider {
+    protected app: ApplicationInterface;
+    constructor(app: ApplicationInterface);
+    boot?(): void;
+    register?(): void;
+    flush?(): void;
+}

package/types/Arr.d.ts

@@ -0,0 +1,25 @@
+export declare class ArrMacros {
+    [x: string]: (...args: any[]) => any;
+}
+declare class ArrStatic {
+    /**
+     *
+     * Calculates the Cartesian product of the given arrays.
+     *
+     */
+    cartesian<T>(...arrays: T[][]): T[][];
+    /**
+     *
+     * Gets an array of random elements from the given `array`.
+     *
+     */
+    sampleSize(array: any[], n: number): any[];
+    /**
+     *
+     * Returns a shuffled copy of `array`.
+     *
+     */
+    shuffle<T>(array: T[]): T[];
+}
+declare const Arr: ArrStatic & ArrMacros & import('./Mixins/Macroable').MacroableInterface<ArrMacros>;
+export default Arr;

package/types/Collection.d.ts

@@ -0,0 +1,184 @@
+import { default as EventSource, Event } from './Contracts/EventSource';
+import { Constructor, TypeOf } from './Js';
+import { Operator } from './Query';
+export type CollectionChanged<T> = {
+    items: T[];
+};
+export type CollectionEvents<T> = {
+    'change': (e: Event<CollectionChanged<T>, Collection<T>>) => void;
+};
+export type CollectionIteratorCallback<T = unknown, R = void> = (value: T, index: number, collection: Collection<T>) => R;
+export type CollectionPipeCallback<T = unknown, R = unknown> = (collection: Collection<T>) => R;
+export type CollectionSortCallback<T = unknown> = (a: T, b: T) => number;
+export declare function isCollection(instance: unknown): instance is Collection<any>;
+export default class Collection<T> extends EventSource<CollectionEvents<T>> {
+    #private;
+    constructor(items?: Array<T>);
+    get items(): T[];
+    [Symbol.iterator](): IterableIterator<T>;
+    [Symbol.toStringTag]: string;
+    all(): T[];
+    average(): number;
+    average<K extends keyof T>(key: K): number;
+    avg(): number;
+    avg<K extends keyof T>(key: K): number;
+    chunk(size: number): Collection<Collection<T>>;
+    chunkWhile(callback: CollectionIteratorCallback<T, boolean>): Collection<Collection<T>>;
+    collapse(): Collection<unknown>;
+    collect(): Collection<T>;
+    combine(values: Collection<any> | any[]): Record<string, any>;
+    concat(collection: Collection<unknown> | unknown[]): Collection<unknown>;
+    contains(value: T): boolean;
+    contains(key: keyof T, value: T): boolean;
+    contains(callback: CollectionIteratorCallback<T, boolean>): boolean;
+    containsOneItem(): boolean;
+    containsStrict(value: T): boolean;
+    containsStrict(key: keyof T, value: T): boolean;
+    containsStrict(callback: CollectionIteratorCallback<T, boolean>): boolean;
+    count(): number;
+    countBy(callback?: CollectionIteratorCallback<T, string | number>): Record<string | number, number>;
+    crossJoin<V>(...collections: (Collection<V> | V[])[]): Collection<Array<V | T>>;
+    diff(collection: Collection<T> | T[]): Collection<T>;
+    doesntContain(value: T): boolean;
+    doesntContain(key: keyof T, value: T): boolean;
+    doesntContain(callback: CollectionIteratorCallback<T, boolean>): boolean;
+    dump(): void;
+    duplicates(): Collection<T>;
+    duplicates<K extends keyof T>(key: K): Collection<T[K]>;
+    duplicatesStrict(): Collection<T>;
+    duplicatesStrict<K extends keyof T>(key: K): Collection<T[K]>;
+    each(callback: CollectionIteratorCallback<T, void | false>): this;
+    eachSpread(callback: (...args: unknown[]) => void | false): this;
+    ensure(type: TypeOf | Constructor | (TypeOf | Constructor)[]): this;
+    every(callback: CollectionIteratorCallback<T, boolean>): boolean;
+    except(indexes: Array<number>): Collection<T>;
+    filter(callback?: CollectionIteratorCallback<T, boolean>): Collection<T>;
+    first(callback?: CollectionIteratorCallback<T, boolean>): T | null;
+    firstOrFail(callback?: CollectionIteratorCallback<T, boolean>): T;
+    firstWhere<K extends keyof T>(key: K): T | null;
+    firstWhere<K extends keyof T>(key: K, value: T[K]): T | null;
+    firstWhere<K extends keyof T>(key: K, operator: Operator, value: T[K]): T | null;
+    flatMap<R>(callback: CollectionIteratorCallback<T, R | R[]>): Collection<R>;
+    forget(key: number): this;
+    forPage(page: number, perPage: number): Collection<T>;
+    get(key: number): T | null;
+    get<R>(key: number, defaultValue: R): T | R;
+    get<R>(key: number, defaultValue: () => R): T | R;
+    groupBy(key: keyof T): Record<string, T[]>;
+    groupBy(callback: CollectionIteratorCallback<T, string | string[]>): Record<string, T[]>;
+    groupBy(keys: (keyof T | CollectionIteratorCallback<T, string | string[]>)[]): Record<string, unknown>;
+    has(index: number): boolean;
+    hasAny(indexes: number[]): boolean;
+    implode(glue: string): string;
+    implode(key: keyof T, glue: string): string;
+    implode(callback: CollectionIteratorCallback<T, string>, glue: string): string;
+    intersect(values: Collection<T> | T[]): Collection<T>;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    join(glue: string): string;
+    join(glue: string, final: string): string;
+    keyBy(key: keyof T): Record<string, T>;
+    keyBy(callback: CollectionIteratorCallback<T, string>): Record<string, T>;
+    last(callback?: CollectionIteratorCallback<T, boolean> | undefined): T | null;
+    map<R>(callback: CollectionIteratorCallback<T, R>): Collection<R>;
+    mapInto<R extends Constructor<InstanceType<R>>>(constructor: R): Collection<InstanceType<R>>;
+    mapSpread<R>(callback: (...args: unknown[]) => R): Collection<R>;
+    mapToGroups<R>(callback: CollectionIteratorCallback<T, Record<string, R>>): Record<string, R[]>;
+    mapWithKeys<R>(callback: CollectionIteratorCallback<T, Record<string, R>>): Record<string, R>;
+    max(): T | null;
+    max<K extends keyof T>(key: K): T[K] | null;
+    median(): T | null;
+    median<K extends keyof T>(key: K): T[K] | null;
+    merge(values: Collection<T> | T[]): Collection<T>;
+    merge<R>(values: Collection<R> | R[]): Collection<T | R>;
+    min(): T | null;
+    min<K extends keyof T>(key: K): T[K] | null;
+    mode(): T[];
+    mode<K extends keyof T>(key: K): T[K][];
+    nth(n: number, offset?: number): Collection<T>;
+    only(indexes: Array<number>): Collection<T>;
+    pad<R>(size: number, value?: R | null): Collection<T | R | null>;
+    partition(callback: CollectionIteratorCallback<T, boolean>): [Collection<T>, Collection<T>];
+    percentage(callback: CollectionIteratorCallback<T, boolean>, precision?: number): number;
+    pipe<R>(callback: CollectionPipeCallback<T, R>): R;
+    pipeInto<R extends Constructor<InstanceType<R>>>(constructor: R): InstanceType<R>;
+    pipeThrough<R>(pipeline: CollectionPipeCallback<unknown, Collection<unknown> | R>[]): R;
+    pluck<K extends keyof T>(key: K): Collection<T[K]>;
+    pop(): T | null;
+    pop(amount: number): Collection<T>;
+    prepend(value: T): number;
+    pull(index: number): T | null;
+    push(...items: T[]): number;
+    put(index: number, value: T): this;
+    random(): T | null;
+    random(amount: number): Collection<T>;
+    reduce<R>(callback: (carry: R | null, item: T, index: number, collection: this) => R, initialValue?: R | null): R | null;
+    reject(callback: CollectionIteratorCallback<T, boolean>): Collection<T>;
+    replace(data: Record<number, T>): Collection<T>;
+    reverse(): Collection<T>;
+    search(value: T): number | false;
+    search(value: T, strict: boolean): number | false;
+    search(callback: CollectionIteratorCallback<T, boolean>): number | false;
+    select<K extends Array<keyof T>>(keys: K): Collection<Pick<T, K[number]>>;
+    shift(): T | null;
+    shift(count: number): Collection<T>;
+    shuffle(): Collection<T>;
+    skip(amount: number): Collection<T>;
+    skipUntil(callback: CollectionIteratorCallback<T, boolean>): Collection<T>;
+    skipUntil(value: T): Collection<T>;
+    skipWhile(callback: CollectionIteratorCallback<T, boolean>): Collection<T>;
+    skipWhile(value: T): Collection<T>;
+    slice(start?: number, size?: number): Collection<T>;
+    sliding(size: number, step?: number): Collection<Collection<T>>;
+    sole(): T | null;
+    sole<K extends keyof T>(key: K, value: T[K]): T | null;
+    sole(callback: CollectionIteratorCallback<T, boolean>): T | null;
+    some(value: T): boolean;
+    some(key: keyof T, value: T): boolean;
+    some(callback: CollectionIteratorCallback<T, boolean>): boolean;
+    sort(compareFn?: CollectionSortCallback<T>): Collection<T>;
+    sortBy<K extends keyof T>(key: K, order?: 'asc' | 'desc'): Collection<T>;
+    sortBy<K extends keyof T>(columns: [K, 'asc' | 'desc'][]): Collection<T>;
+    sortBy(callback: CollectionIteratorCallback<T, number>): Collection<T>;
+    sortBy(stack: ((a: T, b: T) => number)[]): Collection<T>;
+    sortDesc(): Collection<T>;
+    splice(start: number): Collection<T>;
+    splice(start: number, deleteCount: number): Collection<T>;
+    splice(start: number, deleteCount: number, ...items: T[]): Collection<T>;
+    split(groups: number): Collection<Collection<T>>;
+    splitIn(groups: number): Collection<Collection<T>>;
+    sum(): number;
+    sum<K extends keyof T>(key: K): number;
+    take(amount: number): Collection<T>;
+    takeUntil(value: T): Collection<T>;
+    takeUntil(callback: CollectionIteratorCallback<T, boolean>): Collection<T>;
+    takeWhile(value: T): Collection<T>;
+    takeWhile(callback: CollectionIteratorCallback<T, boolean>): Collection<T>;
+    tap(callback: CollectionPipeCallback<T, void>): this;
+    toArray(): T[];
+    toJson(): string;
+    transform<R>(callback: CollectionIteratorCallback<T, R>): Collection<T | R>;
+    unique(): Collection<T>;
+    unique<K extends keyof T>(key: K): Collection<T>;
+    uniqueStrict(): Collection<T>;
+    uniqueStrict<K extends keyof T>(key: K): Collection<T>;
+    unless(condition: boolean, callback: CollectionPipeCallback<T, void>, otherwise?: CollectionPipeCallback<T, void>): this;
+    unlessEmpty(callback: CollectionPipeCallback<T, void>, otherwise?: CollectionPipeCallback<T, void>): this;
+    unlessNotEmpty(callback: CollectionPipeCallback<T, void>, otherwise?: CollectionPipeCallback<T, void>): this;
+    value<K extends keyof T>(key: K): T[K] | null;
+    when(condition: boolean, callback: CollectionPipeCallback<T, void>, otherwise?: CollectionPipeCallback<T, void>): this;
+    whenEmpty(callback: CollectionPipeCallback<T, void>, otherwise?: CollectionPipeCallback<T, void>): this;
+    whenNotEmpty(callback: CollectionPipeCallback<T, void>, otherwise?: CollectionPipeCallback<T, void>): this;
+    where<K extends keyof T>(key: K, value: T[K]): Collection<T>;
+    where<K extends keyof T>(key: K, operator: Operator, value: T[K]): Collection<T>;
+    whereStrict<K extends keyof T>(key: K, value: T[K]): Collection<T>;
+    whereStrict<K extends keyof T>(key: K, operator: Operator, value: T[K]): Collection<T>;
+    whereBetween<K extends keyof T>(key: K, [min, max]: [T[K], T[K]]): Collection<T>;
+    whereIn<K extends keyof T>(key: K, values: T[K][]): Collection<T>;
+    whereInstanceOf<R extends Constructor<T>>(constructor: R): Collection<T>;
+    whereNotBetween<K extends keyof T>(key: K, [min, max]: [T[K], T[K]]): Collection<T>;
+    whereNotIn<K extends keyof T>(key: K, values: T[K][]): Collection<T>;
+    whereNotNull<K extends keyof T>(key: K): Collection<T>;
+    whereNull<K extends keyof T>(key: K): Collection<T>;
+    zip<R>(items: Collection<R> | R[]): Collection<[T, NonNullable<R> | null]>;
+}

package/types/Contracts/EventSource.d.ts

@@ -0,0 +1,18 @@
+import { Unsubscribe } from 'nanoevents';
+export type Event<TData = any, TSource extends EventSource = any> = TData & {
+    source: TSource;
+};
+export type EventMap = {
+    [key: string]: (event: Event) => void;
+};
+export type EventMapOf<TSource extends EventSource> = TSource extends EventSource<infer T> ? T : never;
+export type EventsOf<TSource extends EventSource> = keyof EventMapOf<TSource>;
+export type EventCallbackOf<TSource extends EventSource, E extends EventsOf<TSource>> = EventMapOf<TSource>[E];
+export default class EventSource<TEvents extends EventMap = EventMap> {
+    private emitter;
+    constructor();
+    on<E extends keyof TEvents>(event: E, callback: TEvents[E]): Unsubscribe;
+    once<E extends keyof TEvents>(event: E, callback: TEvents[E]): void;
+    emit<E extends keyof TEvents>(event: E, ...data: Parameters<TEvents[E]>): void;
+    flushEvents(): void;
+}

package/types/DateTime.d.ts

@@ -0,0 +1,2 @@
+export declare function parse(value: Date | string): Date;
+export declare function toDateTimeLocal(value: Date | string): string;

package/types/Exceptions/NoEmbedException.d.ts

@@ -0,0 +1,4 @@
+export default class NoEmbedException extends Error {
+    [Symbol.toStringTag]: string;
+    constructor();
+}

package/types/Exceptions/ReducerOverrideException.d.ts

@@ -0,0 +1,4 @@
+export default class ReducerOverrideException extends Error {
+    [Symbol.toStringTag]: string;
+    constructor(name: string, target: unknown);
+}

package/types/Func.d.ts

@@ -0,0 +1,3 @@
+import { DebouncedFunc, DebounceSettings, ThrottleSettings } from 'lodash-es';
+export declare function throttle<T extends (...args: any) => any>(func: T, wait?: number, options?: ThrottleSettings): DebouncedFunc<T>;
+export declare function debounce<T extends (...args: any) => any>(func: T, wait?: number, options?: DebounceSettings): DebouncedFunc<T>;

package/types/Http/Client.d.ts

@@ -0,0 +1,27 @@
+import { AxiosRequestConfig } from 'axios';
+import { default as Request } from './Request';
+export type RequestOptions = Omit<AxiosRequestConfig, 'url' | 'method'>;
+export default class Client {
+    protected options: AxiosRequestConfig;
+    constructor(options?: AxiosRequestConfig);
+    private parseData;
+    baseUrl(baseUrl: string): this;
+    asForm(): this;
+    accept(type: string): this;
+    acceptJson(): this;
+    withHeaders(headers: Record<string, string>): this;
+    replaceHeaders(headers: Record<string, string>): this;
+    withOptions(options: RequestOptions): this;
+    replaceOptions(options: RequestOptions): this;
+    withQueryParameters(params: string | object): this;
+    replaceQueryParameters(params: string | object): this;
+    withData(data: object): this;
+    replaceData(data: object): this;
+    withBasicAuth(username: string, password: string): this;
+    withToken(token: string): this;
+    get<TResponse = any>(url: string, query?: string | object): Request<TResponse, any>;
+    post<TResponse = any, TData = any>(url: string, data?: TData): Request<TResponse, TData>;
+    put<TResponse = any, TData = any>(url: string, data?: TData): Request<TResponse, TData>;
+    patch<TResponse = any, TData = any>(url: string, data?: TData): Request<TResponse, TData>;
+    delete<TResponse = any>(url: string, query?: string | object): Request<TResponse, any>;
+}

package/types/Http/Request.d.ts

@@ -0,0 +1,11 @@
+import { AxiosRequestConfig } from 'axios';
+import { default as Response } from './Response';
+export default class Request<TResponse = any, TData = any> implements Promise<Response<TResponse, TData>> {
+    private promise;
+    private response?;
+    constructor(options: AxiosRequestConfig);
+    [Symbol.toStringTag]: string;
+    then<TResult1 = Response<TResponse, TData>, TResult2 = never>(onfulfilled?: ((value: Response<TResponse, TData>) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<Response<TResponse, TData> | TResult>;
+    finally(onfinally?: (() => void) | null | undefined): Promise<Response<TResponse, TData>>;
+}

package/types/Http/Response.d.ts

@@ -0,0 +1,42 @@
+import { AxiosResponse } from 'axios';
+export default class Response<TResponse = any, TData = any> {
+    protected _response: AxiosResponse<TResponse, TData>;
+    protected _error?: Error | undefined;
+    constructor(_response: AxiosResponse<TResponse, TData>, _error?: Error | undefined);
+    error(): Error | undefined;
+    body(): string;
+    json(): TResponse;
+    json<K extends keyof TResponse>(key: K): TResponse[K];
+    json(key: string, defaultValue?: any): any;
+    has(key: string): boolean;
+    status(): number;
+    successful(): boolean;
+    redirect(): boolean;
+    clientError(): boolean;
+    serverError(): boolean;
+    failed(): boolean;
+    header(header: string): string;
+    headers(): Record<string, string>;
+    ok(): boolean;
+    created(): boolean;
+    accepted(): boolean;
+    noContent(): boolean;
+    movedPermanently(): boolean;
+    found(): boolean;
+    badRequest(): boolean;
+    unauthorized(): boolean;
+    paymentRequired(): boolean;
+    forbidden(): boolean;
+    notFound(): boolean;
+    requestTimeout(): boolean;
+    conflict(): boolean;
+    unprocessableEntity(): boolean;
+    tooManyRequests(): boolean;
+    throw(): this;
+    throwIf(condition: boolean | ((response: Response) => boolean)): this;
+    throwUnless(condition: boolean | ((response: Response) => boolean)): this;
+    throwIfStatus(statusCode: number | ((status: number, response: Response) => boolean)): this;
+    throwUnlessStatus(statusCode: number | ((status: number, response: Response) => boolean)): this;
+    throwIfClientError(): this;
+    throwIfServerError(): this;
+}

package/types/Http/Utils/isValidationError.d.ts

@@ -0,0 +1,8 @@
+import { default as Response } from '../Response';
+export type ValidationError = {
+    message: string;
+    errors: {
+        [key: string]: string[];
+    };
+};
+export default function isValidationError(response: unknown): response is Response<ValidationError>;

package/types/Js.d.ts

@@ -0,0 +1,6 @@
+export type Constructor<TInstance = {}, TArgs extends Array<any> = any[]> = new (...args: TArgs) => TInstance;
+export type TypeOf = 'string' | 'number' | 'boolean' | 'object' | 'undefined' | 'function' | 'symbol' | 'bigint';
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type JsonValue = string | number | boolean | null | JsonObject | Array<string | number | boolean | null | JsonObject>;

package/types/Mixins/Macroable.d.ts

@@ -0,0 +1,29 @@
+import { Constructor } from '../Js';
+export type MacroMethodMap = Record<string, (...args: any[]) => any>;
+export type MacroableInterface<TMacros extends MacroMethodMap> = {
+    /**
+     *
+     * Register a custom macro
+     *
+     * @param name
+     * @param macro
+     */
+    macro<K extends keyof TMacros>(name: K, macro: TMacros[K]): void;
+    /**
+     *
+     * Checks if a macro is registered
+     *
+     * @param name
+     */
+    hasMacro(name: string): boolean;
+    /**
+     *
+     * Flushes the existing macros.
+     *
+     */
+    flushMacros(): void;
+};
+export type MacroableOf<TBase extends Constructor, TMacros extends MacroMethodMap> = Omit<TBase, 'new'> & {
+    new (...args: ConstructorParameters<TBase>): InstanceType<TBase> & TMacros & MacroableInterface<TMacros>;
+};
+export default function Macroable<TMacros extends MacroMethodMap, TBase extends Constructor>(Base: TBase): MacroableOf<TBase, TMacros>;

package/types/Mixins/MakeFacade.d.ts

@@ -0,0 +1,7 @@
+import { default as Application } from '../App/Application';
+import { Constructor } from '../Js';
+export type HasFacadeAccessor = {
+    getFacadeAccessor(): string | object;
+};
+export type FacadeOf<TService extends object, TBase extends HasFacadeAccessor> = TBase & TService;
+export default function MakeFacade<TService extends object, TBase extends HasFacadeAccessor>(Base: Constructor<HasFacadeAccessor, []>, app?: Application): FacadeOf<TService, TBase>;

package/types/Mixins/Reducible.d.ts

@@ -0,0 +1,29 @@
+import { Constructor } from '../Js';
+import { default as Collection } from '../Collection';
+export type ReducerRepository = {
+    [reducer: string]: Collection<Reducer<any, any[]>>;
+};
+export type ReducerCallback<TValue = any, TParams extends any[] = any[]> = (value: TValue, ...params: TParams) => TValue;
+export interface Reducer<TValue = any, TParams extends any[] = any[]> {
+    callback: ReducerCallback<TValue, TParams>;
+    priority: number;
+}
+export type Unsubscribe = () => void;
+export type ReducerMethodMap = Record<string, (value: any, ...params: any[]) => any>;
+type First<T extends any[]> = T extends [infer A, ...any] ? A : unknown;
+type Tail<T extends any[]> = T extends [any, ...infer R] ? R : unknown[];
+export type ReducerCallbackFor<TReducers extends ReducerMethodMap, K extends keyof TReducers> = ReducerCallback<First<Parameters<TReducers[K]>>, Tail<Parameters<TReducers[K]>>>;
+export type ReducerFor<TReducers extends ReducerMethodMap, K extends keyof TReducers> = Reducer<First<Parameters<TReducers[K]>>, Tail<Parameters<TReducers[K]>>>;
+export type ReducibleInterface<TReducers extends ReducerMethodMap> = {
+    reducer<K extends keyof TReducers>(name: K, callback: ReducerCallbackFor<TReducers, K>, priority?: number): Unsubscribe;
+    removeReducer<K extends keyof TReducers>(name: K, callback: ReducerCallbackFor<TReducers, K>): void;
+    getReducer<K extends keyof TReducers>(name: K): Collection<ReducerFor<TReducers, K>>;
+    hasReducer(name: string): boolean;
+    clearReducer(name: string): void;
+    flushReducers(): void;
+};
+export type ReducibleOf<TBase extends Constructor, TReducers extends ReducerMethodMap> = Omit<TBase, 'new'> & {
+    new (...args: ConstructorParameters<TBase>): InstanceType<TBase> & TReducers & ReducibleInterface<TReducers>;
+};
+export default function Reducible<TReducers extends ReducerMethodMap, TBase extends Constructor>(Base: TBase): ReducibleOf<TBase, TReducers>;
+export {};

package/types/Obj.d.ts

@@ -0,0 +1,20 @@
+export declare class ObjMacros {
+    [x: string]: (...args: any[]) => any;
+}
+export declare class ObjStatic {
+    fromQuery(searchParams: URLSearchParams): Record<string, any>;
+    fromFormData(formData: FormData): Record<string, any>;
+    get(object: any, path: string, defaultValue?: any): any;
+    has(object: any, path: string): boolean;
+    isEmpty(object: any): boolean;
+    isEqual(object: any, other: any): boolean;
+    merge(object: any, ...sources: any[]): any;
+    omit(object: any, ...paths: string[]): any;
+    pick(object: any, ...paths: string[]): any;
+    set(object: any, path: string, value: any): void;
+    toQuery(object: any): URLSearchParams;
+    toFormData(object: any): FormData;
+    unset(object: any, path: string): void;
+}
+declare const Obj: ObjStatic & ObjMacros & import('./Mixins/Macroable').MacroableInterface<ObjMacros>;
+export default Obj;

package/types/PropertyBag.d.ts

@@ -0,0 +1,24 @@
+import { default as EventSource, Event } from './Contracts/EventSource';
+export type PropertyBagChangeEvent = {
+    path: string;
+    value: unknown;
+    type: 'set' | 'merge' | 'delete';
+};
+export type PropertyBagEventMap<T extends object = any> = {
+    'change': (e: Event<PropertyBagChangeEvent, PropertyBag<T>>) => void;
+};
+declare class PropertyBag<T extends object> extends EventSource<PropertyBagEventMap<T>> {
+    private bag;
+    private locked;
+    constructor(bag: T);
+    get(path: string, defaultValue?: unknown): any;
+    set(path: string, value: unknown): void;
+    merge(path: string, value: unknown): void;
+    has(path: string): boolean;
+    delete(path: string): void;
+    lock(path: string): void;
+    clone(): PropertyBag<T>;
+    all(): T;
+    isEmpty(): boolean;
+}
+export default PropertyBag;

package/types/Query.d.ts

@@ -0,0 +1,4 @@
+export type Operator = '=' | '!=' | '>' | '>=' | '<' | '<=';
+export declare function fromObject(object: object): URLSearchParams;
+export declare function toObject(searchParams: URLSearchParams): Record<string, any>;
+export declare function merge(...parts: (string | URLSearchParams)[]): URLSearchParams;

package/types/Str.d.ts

@@ -0,0 +1,18 @@
+export declare function after(string: string, search: string): string;
+export declare function afterLast(string: string, search: string): string;
+export declare function before(string: string, search: string): string;
+export declare function beforeLast(string: string, search: string): string;
+export declare function camel(string: string): string;
+export declare function lcfirst(string: string): string;
+export declare function lower(string: string): string;
+export declare function kebab(string: string): string;
+export declare function padBoth(string: string, length: number, chars?: string): string;
+export declare function padLeft(string: string, length: number, chars?: string): string;
+export declare function padRight(string: string, length: number, chars?: string): string;
+export declare function readable(string: string): string;
+export declare function studly(string: string): string;
+export declare function snake(string: string): string;
+export declare function title(string: string): string;
+export declare function trim(string: string, chars?: string): string;
+export declare function ucfirst(string: string): string;
+export declare function upper(string: string): string;

package/types/index.d.ts

@@ -0,0 +1,33 @@
+import { default as axios } from 'axios';
+import { default as Application } from './App/Application';
+import { default as Client } from './Http/Client';
+import { default as Collection } from './Collection';
+import { default as EventSource } from './Contracts/EventSource';
+import { default as Macroable } from './Mixins/Macroable';
+import { default as MakeFacade } from './Mixins/MakeFacade';
+import { default as PropertyBag } from './PropertyBag';
+import { default as reader } from './reader';
+import { default as Reducible } from './Mixins/Reducible';
+import { default as Request } from './Http/Request';
+import { default as Response } from './Http/Response';
+import { default as ServiceProvider } from './App/ServiceProvider';
+import { default as isValidationError } from './Http/Utils/isValidationError';
+import { default as Arr } from './Arr';
+import { default as Obj } from './Obj';
+import * as immer from 'immer';
+import * as DateTime from './DateTime';
+import * as Func from './Func';
+import * as Query from './Query';
+import * as Str from './Str';
+export { Application, Arr, Client, Collection, DateTime, EventSource, Func, isValidationError, Macroable, MakeFacade, Obj, PropertyBag, reader, Reducible, Request, Response, ServiceProvider, Query, Str, axios, immer, };
+export type { ArrMacros } from './Arr';
+export type { ObjMacros } from './Obj';
+export type { ApplicationInterface, ApplicationEvents } from './App/Interfaces';
+export type { Event, EventMap, EventMapOf, EventsOf, EventCallbackOf } from './Contracts/EventSource';
+export type { RequestOptions } from './Http/Client';
+export type { MacroableOf, MacroableInterface } from './Mixins/Macroable';
+export type { HasFacadeAccessor, FacadeOf } from './Mixins/MakeFacade';
+export type { ReducibleInterface, ReducibleOf, ReducerCallback } from './Mixins/Reducible';
+export type { CollectionIteratorCallback } from './Collection';
+export type { Constructor, TypeOf, JsonObject, JsonValue } from './Js';
+export type { PropertyBagEventMap } from './PropertyBag';

package/types/reader.d.ts

@@ -0,0 +1,2 @@
+declare const reader: (name: string, type?: "data" | "error") => any;
+export default reader;