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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luminix/support",
-  "version": "0.0.1-beta.0",
+  "version": "0.0.1-beta.1",
   "module": "dist/support.js",
   "types": "types/index.d.ts",
   "type": "module",

package/types/App/ServiceContainer.d.ts

@@ -0,0 +1,6 @@
+export default class ServiceContainer<TServices extends Map<string, any> = Map<string, any>> {
+    private services;
+    bind<K extends keyof TServices>(abstract: K, concrete: () => TServices[K]): void;
+    singleton<K extends keyof TServices>(abstract: K, concrete: TServices[K]): void;
+    get(serviceName: string): any;
+}

package/types/Arr.d.ts

@@ -0,0 +1,18 @@
+/**
+ *
+ * Calculates the Cartesian product of the given arrays.
+ *
+ */
+export declare function cartesian<T>(...arrays: T[][]): T[][];
+/**
+ *
+ * Gets an array of random elements from the given `array`.
+ *
+ */
+export declare function sampleSize(array: any[], n: number): any[];
+/**
+ *
+ * Returns a shuffled copy of `array`.
+ *
+ */
+export declare function shuffle<T>(array: T[]): T[];

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,15 @@
+import { Unsubscribe } from 'nanoevents';
+export type Event<TData = any, TSource extends EventSource = EventSource> = TData & {
+    source: TSource;
+};
+export type EventMap = {
+    [key: string]: (event: Event) => void;
+};
+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;
+    static foo(): string;
+}

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/Http/Client.d.ts

@@ -0,0 +1,25 @@
+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;
+    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,40 @@
+import { AxiosResponse } from 'axios';
+export default class Response<TResponse = any, TData = any> {
+    private response;
+    private error?;
+    constructor(response: AxiosResponse<TResponse, TData>, error?: Error | undefined);
+    body(): string;
+    json(): TResponse;
+    json<K extends keyof TResponse>(key: K): TResponse[K];
+    json(key: string, defaultValue?: any): any;
+    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/index.d.ts

@@ -0,0 +1,25 @@
+import { default as Client, RequestOptions } from './Client';
+import { default as Response } from './Response';
+import { default as Request } from './Request';
+declare class HttpStatic {
+    get Client(): typeof Client;
+    get Response(): typeof Response;
+    get Request(): typeof Request;
+    getClient(): Client;
+    baseUrl(baseUrl: string): Client;
+    asForm(): Client;
+    accept(type: string): Client;
+    acceptJson(): Client;
+    withHeaders(headers: Record<string, string>): Client;
+    withOptions(options: RequestOptions): Client;
+    withQueryParameters(params: string | object): Client;
+    withBasicAuth(username: string, password: string): Client;
+    withToken(token: string): Client;
+    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>;
+}
+declare const Http: HttpStatic & import('../Mixins/Macroable').MacroMethodMap & import('../Mixins/Macroable').MacroableInterface<import('../Mixins/Macroable').MacroMethodMap>;
+export default Http;

package/types/Http.d.ts

@@ -0,0 +1,30 @@
+import { AxiosResponse } from 'axios';
+declare class Response<T = any, D = any> {
+    _response: AxiosResponse<T, D>;
+    constructor(_response: AxiosResponse<T, D>);
+    body(): string;
+    json(): D;
+    status(): number;
+    successful(): 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;
+    serverError(): boolean;
+}
+export declare function get(url: string, query?: string | object): Promise<Response>;
+export {};

package/{src/Js.ts → types/Js.d.ts}

@@ -1,5 +1,2 @@
-
-
 export type Constructor<T = {}> = new (...args: any[]) => T;
-
 export type TypeOf = 'string' | 'number' | 'boolean' | 'object' | 'undefined' | 'function' | 'symbol' | 'bigint';

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/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,14 @@
+export type JsonProperty = null | boolean | number | string;
+export declare function fromQuery(searchParams: URLSearchParams): Record<string, any>;
+export declare function fromFormData(formData: FormData): Record<string, any>;
+export declare function get(object: any, path: string, defaultValue?: any): any;
+export declare function has(object: any, path: string): boolean;
+export declare function isEmpty(object: any): boolean;
+export declare function isEqual(object: any, other: any): boolean;
+export declare function merge(object: any, ...sources: any[]): any;
+export declare function omit(object: any, ...paths: string[]): any;
+export declare function pick(object: any, ...paths: string[]): any;
+export declare function set(object: any, path: string, value: any): void;
+export declare function toQuery(object: any): URLSearchParams;
+export declare function toFormData(object: any): FormData;
+export declare function unset(object: any, path: string): void;

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): object;
+export declare function merge(...parts: (string | URLSearchParams)[]): URLSearchParams;

package/{src/Services/ApplicationService.ts → types/Services/ApplicationService.d.ts}

@@ -1,7 +1,2 @@
-
-
 export default class ApplicationService {
-    
 }
-
-

package/types/Str.d.ts

@@ -0,0 +1,10 @@
+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 kebab(string: string): string;
+export declare function studly(string: string): string;
+export declare function snake(string: string): string;
+export declare function trim(string: string, chars?: string): string;
+export declare function upperFirst(string: string): string;

package/types/index.d.ts

@@ -0,0 +1,10 @@
+import { default as Collection } from './Collection';
+import { default as EventSource } from './Contracts/EventSource';
+import { default as Http } from './Http';
+import { default as Reducible } from './Mixins/Reducible';
+import { default as Macroable } from './Mixins/Macroable';
+import * as Arr from './Arr';
+import * as Obj from './Obj';
+import * as Query from './Query';
+import * as Str from './Str';
+export { Arr, Collection, EventSource, Http, Reducible, Macroable, Obj, Query, Str, };

package/src/App/ServiceContainer.ts

@@ -1,32 +0,0 @@
-
-
-
-
-
-export default class ServiceContainer<TServices extends Map<string, any> = Map<string, any>> {
-
-    private services: TServices = new Map() as TServices;
-
-    bind<K extends keyof TServices>(abstract: K, concrete: () => TServices[K]): void {
-        if (typeof abstract !== 'string') {
-            throw new TypeError('Service name must be a string.');
-        }
-        this.services.set(abstract, concrete);
-    }
-
-    singleton<K extends keyof TServices>(abstract: K, concrete: TServices[K]): void {
-        if (typeof abstract !== 'string') {
-            throw new TypeError('Service name must be a string.');
-        }
-        this.services.set(abstract, concrete);
-    }
-
-    get(serviceName: string): any {
-        const service = this.services.get(serviceName);
-        if (!service) {
-            throw new Error(`Service '${serviceName}' is not bound in the container.`);
-        }
-        return service;
-    }
-}
-

package/src/App/index.ts

@@ -1,27 +0,0 @@
-
-// export type AppServices = {
-
-// };
-
-// class App {
-
-
-//     private constructor() {
-//     }
-
-//     private static _instance?: App;
-
-//     static getInstance() {
-//         if (!this._instance) {
-//             this._instance = new App();
-//         }
-
-//         return this._instance;
-//     }
-
-
-// }
-
-
-
-

package/src/Arr.ts

@@ -1,33 +0,0 @@
-import * as _ from 'lodash-es';
-
-/**
- * 
- * Calculates the Cartesian product of the given arrays.
- * 
- */
-export function cartesian<T>(...arrays: T[][]): T[][] {
-    return arrays.reduce((a, b) => a.flatMap((d) => b.map((e) => [d, e].flat())) as T[]) as T[][];
-}
-
-
-/**
- * 
- * Gets an array of random elements from the given `array`.
- * 
- */
-export function sampleSize(array: any[], n: number): any[] {
-    return _.sampleSize(array, n);
-}
-
-
-/**
- * 
- * Returns a shuffled copy of `array`.
- *
- */
-export function shuffle<T>(array: T[]): T[] {
-    return _.shuffle(array);
-}
-
-
-