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

package/src/Contracts/EventSource.ts

@@ -1,46 +0,0 @@
-import { createNanoEvents, 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()
-    {
-        this.emitter = createNanoEvents<TEvents>();
-    }
-
-    on<E extends keyof TEvents>(event: E, callback: TEvents[E]): Unsubscribe
-    {
-        return this.emitter.on(event, callback);
-    }
-
-    once<E extends keyof TEvents>(event: E, callback: TEvents[E]): void
-    {
-        const off = this.emitter.on(event, ((e: Parameters<TEvents[E]>[0]) => {
-            off();
-            callback(e);
-        }) as any);
-    }
-
-    emit<E extends keyof TEvents>(event: E, ...data: Parameters<TEvents[E]>): void
-    {
-        this.emitter.emit(event, ...data);
-    }
-
-    static foo() {
-
-        return 'bar';
-    }
-}
-
-

package/src/Exceptions/ReducerOverrideException.ts

@@ -1,8 +0,0 @@
-
-export default class ReducerOverrideException extends Error {
-    [Symbol.toStringTag] = 'ReducerOverrideException';
-
-    constructor(name: string, target: unknown) {
-        super(`[Luminix] Cannot create reducer '${name}' on '${target}' as it is a reserved property`);
-    }
-}

package/src/Http/Client.ts

@@ -1,139 +0,0 @@
-
-import { AxiosRequestConfig } from 'axios';
-import * as Obj from '../Obj';
-import Request from './Request';
-
-
-export type RequestOptions = Omit<AxiosRequestConfig, 'url' | 'method'>;
-
-
-export default class Client {
-
-    constructor(
-        protected options: AxiosRequestConfig = {}
-    ) {}
-
-    private parseData(data?: object) {
-        if (Obj.get(this.options, 'headers[Content-Type]', 'application/json') === 'application/x-www-form-urlencoded' && data) {
-            return Obj.toFormData(data || {});
-        }
-
-        return data;
-    }
-
-    baseUrl(baseUrl: string): this {
-        Obj.set(this.options, 'baseURL', baseUrl);
-
-        return this;
-    }
-
-    asForm(): this {
-        Obj.set(this.options, 'headers[Content-Type]', 'application/x-www-form-urlencoded');
-
-        return this;
-    }
-
-    accept(type: string): this {
-        Obj.set(this.options, 'headers[Accept]', type);
-
-        return this;
-    }
-
-    acceptJson(): this {
-        return this.accept('application/json');
-    }
-
-    withHeaders(headers: Record<string, string>): this {
-        Obj.set(this.options, 'headers', Obj.merge(this.options.headers, headers));
-
-        return this;
-    }
-
-    replaceHeaders(headers: Record<string, string>): this {
-        Obj.set(this.options, 'headers', headers);
-
-        return this;
-    }
-
-    withOptions(options: RequestOptions): this {
-        this.options = Obj.merge(this.options, options);
-
-        return this;
-    }
-
-    replaceOptions(options: RequestOptions): this {
-        this.options = options;
-
-        return this;
-    }
-
-    withQueryParameters(params: string | object): this {
-        Obj.set(this.options, 'params', Obj.merge(this.options.params, params));
-
-        return this;
-    }
-
-    replaceQueryParameters(params: string | object): this {
-        Obj.set(this.options, 'params', params);
-
-        return this;
-    }
-
-    withBasicAuth(username: string, password: string): this {
-        Obj.set(this.options, 'headers.Authorization', `Basic ${btoa(`${username}:${password}`)}`);
-
-        return this;
-    }
-
-    withToken(token: string): this {
-        Obj.set(this.options, 'headers.Authorization', `Bearer ${token}`);
-
-        return this;
-    }
-
-    get<TResponse = any>(url: string, query?: string | object) {
-        return new Request<TResponse>({
-            ...this.options,
-            params: query ?? this.options.params,
-            url,
-        });
-    }
-
-    post<TResponse = any, TData = any>(url: string, data?: TData) {
-        return new Request<TResponse, TData>({
-            ...this.options,
-            method: 'post',
-            url,
-            data: this.parseData(data ?? this.options.data),
-        });
-    }
-
-    put<TResponse = any, TData = any>(url: string, data?: TData) {
-        return new Request<TResponse, TData>({
-            ...this.options,
-            method: 'put',
-            url,
-            data: this.parseData(data ?? this.options.data),
-        });
-    }
-
-    patch<TResponse = any, TData = any>(url: string, data?: TData) {
-        return new Request<TResponse, TData>({
-            ...this.options,
-            method: 'patch',
-            url,
-            data: this.parseData(data ?? this.options.data),
-        });
-    }
-
-    delete<TResponse = any>(url: string, query?: string | object) {
-        return new Request<TResponse>({
-            ...this.options,
-            method: 'delete',
-            params: query ?? this.options.params,
-            url,
-        });
-    }
-
-};
-

package/src/Http/Request.ts

@@ -1,45 +0,0 @@
-import axios, { AxiosRequestConfig, isAxiosError } from "axios";
-import Response from "./Response";
-
-export default class Request<TResponse = any, TData = any> implements Promise<Response<TResponse, TData>> {
-
-    private promise: Promise<Response<TResponse, TData>>;
-    private response?: Response<TResponse, TData>;
-
-    constructor(options: AxiosRequestConfig) {
-        this.promise = new Promise<Response<TResponse, TData>>((resolve, reject) => {
-            axios(options)
-                .then((response) => {
-                    this.response = new Response(response);
-                    resolve(this.response);
-                })
-                .catch((error) => {
-                    if (isAxiosError(error) && error.response) {
-                        this.response = new Response(error.response, error);
-                        resolve(this.response);
-                    } else {
-                        reject(error);
-                    }
-                });
-        });
-    }
-
-    [Symbol.toStringTag]: string = 'Request';
-
-    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> {
-        return this.promise.then(onfulfilled, onrejected);
-    }
-
-    catch<TResult = never>(
-        onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined
-    ): Promise<Response<TResponse, TData> | TResult> {
-        return this.promise.catch(onrejected);
-    }
-
-    finally(onfinally?: (() => void) | null | undefined): Promise<Response<TResponse, TData>> {
-        return this.promise.finally(onfinally);
-    }
-}

package/src/Http/Response.ts

@@ -1,170 +0,0 @@
-
-import { AxiosResponse } from 'axios';
-import * as Obj from '../Obj';
-
-export default class Response<TResponse = any, TData = any> {
-
-    constructor(
-        private response: AxiosResponse<TResponse, TData>,
-        private error?: Error
-    ) {
-
-    }
-
-    body(): string {
-        return typeof this.response.data === 'object'
-            ? JSON.stringify(this.response.data)
-            : String(this.response.data);
-    }
-
-    json(): TResponse;
-    json<K extends keyof TResponse>(key: K): TResponse[K];
-    json(key: string, defaultValue?: any): any;
-    json(key?: string, defaultValue?: any): any {
-
-        if (key) {
-            return Obj.get(this.response.data, key, defaultValue);
-        }
-
-        return this.response.data;
-    }
-    // collect(key?: string): Collection {}
-    status(): number {
-        return Number(this.response.status);
-    }
-
-    successful(): boolean {
-        return this.status() >= 200 && this.status() < 300;
-    }
-
-    redirect(): boolean {
-        return this.status() >= 300 && this.status() < 400;
-    }
-
-    clientError(): boolean {
-        return this.status() >= 400 && this.status() < 500;
-    }
-
-    serverError(): boolean {
-        return this.status() >= 500;
-    }
-
-    failed(): boolean {
-        return this.clientError() || this.serverError();
-    }
-
-    header(header: string): string {
-        return this.response.headers[header];
-    }
-
-    headers(): Record<string, string> {
-        return this.response.headers as Record<string, string>;
-    }
-
-    ok(): boolean {
-        return this.status() === 200;
-    }
-
-    created(): boolean {
-        return this.status() === 201;
-    }
-
-    accepted(): boolean {
-        return this.status() === 202;
-    }
-
-    noContent(): boolean {
-        return this.status() === 204;
-    }
-
-    movedPermanently(): boolean {
-        return this.status() === 301;
-    }
-
-    found(): boolean {
-        return this.status() === 302;
-    }
-
-    badRequest(): boolean {
-        return this.status() === 400;
-    }
-
-    unauthorized(): boolean {
-        return this.status() === 401;
-    }
-
-    paymentRequired(): boolean {
-        return this.status() === 402;
-    }
-
-    forbidden(): boolean {
-        return this.status() === 403;
-    }
-
-    notFound(): boolean {
-        return this.status() === 404;
-    }
-
-    requestTimeout(): boolean {
-        return this.status() === 408;
-    }
-
-    conflict(): boolean {
-        return this.status() === 409;
-    }
-
-    unprocessableEntity(): boolean {
-        return this.status() === 422;
-    }
-
-    tooManyRequests(): boolean {
-        return this.status() === 429;
-    }
-
-    throw(): this {
-        if (this.failed()) {
-            throw this.error || new Error(this.body());
-        }
-
-        return this;
-    }
-
-    throwIf(condition: boolean | ((response: Response) => boolean)): this {
-        if (typeof condition === 'function') {
-            return condition(this) ? this.throw() : this;
-        } 
-        return condition ? this.throw() : this;
-    }
-
-    throwUnless(condition: boolean | ((response: Response) => boolean)): this {
-        if (typeof condition === 'function') {
-            return condition(this) ? this : this.throw();
-        }
-        return condition ? this : this.throw();
-    }
-
-    throwIfStatus(statusCode: number | ((status: number, response: Response) => boolean)): this {
-        if (typeof statusCode === 'function' && statusCode(this.status(), this)) {
-            return this.throw();
-        } 
-        return this.status() === statusCode ? this.throw() : this;
-    }
-
-    throwUnlessStatus(statusCode: number | ((status: number, response: Response) => boolean)): this {
-        if (typeof statusCode === 'function' && !statusCode(this.status(), this)) {
-            return this.throw();
-        }
-        return this.status() === statusCode ? this : this.throw();
-    }
-
-    throwIfClientError(): this {
-        return this.clientError() ? this.throw() : this;
-    }
-
-    throwIfServerError(): this {
-        return this.serverError() ? this.throw() : this;
-    }
-    
-
-};
-

package/src/Http/index.ts

@@ -1,90 +0,0 @@
-import Client, { RequestOptions } from "./Client";
-import Response from "./Response";
-import Request from "./Request";
-import Macroable from "../Mixins/Macroable";
-
-class HttpStatic {
-
-    get Client() {
-        return Client;
-    }
-
-    get Response() {
-        return Response;
-    }
-
-    get Request() {
-        return Request;
-    }
-
-    getClient(): Client {
-        return new Client();
-    }
-
-    baseUrl(baseUrl: string): Client {
-        return this.getClient().baseUrl(baseUrl);
-    }
-
-    asForm(): Client {
-        return this.getClient().asForm();
-    }
-
-    accept(type: string): Client {
-        return this.getClient().accept(type);
-    }
-
-    acceptJson(): Client {
-        return this.getClient().acceptJson();
-    }
-
-    withHeaders(headers: Record<string, string>): Client {
-        return this.getClient().withHeaders(headers);
-    }
-
-    withOptions(options: RequestOptions): Client {
-        return this.getClient().withOptions(options);
-    }
-
-
-    withQueryParameters(params: string | object): Client {
-        return this.getClient().withQueryParameters(params);
-    }
-
-    withBasicAuth(username: string, password: string): Client {
-        return this.getClient().withBasicAuth(username, password);
-    }
-
-    withToken(token: string): Client {
-        return this.getClient().withToken(token);
-    }
-
-    get<TResponse = any>(url: string, query?: string | object) {
-        return this.getClient().get<TResponse>(url, query);
-    }
-
-
-    post<TResponse = any, TData = any>(url: string, data?: TData) {
-        return this.getClient().post<TResponse, TData>(url, data);
-    }
-
-
-    put<TResponse = any, TData = any>(url: string, data?: TData) {
-        return this.getClient().put<TResponse, TData>(url, data);
-    }
-
-
-    patch<TResponse = any, TData = any>(url: string, data?: TData) {
-        return this.getClient().patch<TResponse, TData>(url, data);
-    }
-
-
-    delete<TResponse = any>(url: string, query?: string | object) {
-        return this.getClient().delete<TResponse>(url, query);
-    }
-
-}
-
-const Http = new (Macroable(HttpStatic))();
-
-export default Http;
-

package/src/Mixins/Macroable.ts

@@ -1,81 +0,0 @@
-
-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>; /* & {
-        [key: string]: (...args: any[]) => any;
-    };*/
-};
-
-export default function Macroable<TMacros extends MacroMethodMap, TBase extends Constructor>(
-    Base: TBase
-): MacroableOf<TBase, TMacros>
-{
-    return class MacroableBase extends Base {
-
-        _macros: TMacros = {} as TMacros;
-
-        constructor(...args: any[]) {
-            super(...args);
-
-            return new Proxy(this, {
-                get(target, prop, receiver) {
-                    if (Reflect.has(target, prop)) {
-                        return Reflect.get(target, prop, receiver);
-                    }
-
-                    if (typeof prop === 'string' && target.hasMacro(prop)) {
-                        return target._macros[prop].bind(target);
-                    }
-
-                    return Reflect.get(target, prop, receiver);
-                },
-            });
-        }
-
-        macro<K extends keyof TMacros>(name: K, macro: TMacros[K]): void {
-            if (typeof macro !== 'function') {
-                throw new TypeError('Macro must be a function');
-            }
-
-            this._macros[name] = macro;
-        }
-
-        hasMacro(name: string): boolean {
-            return name in this._macros && typeof this._macros[name] === 'function';
-        }
-
-        flushMacros(): void {
-            this._macros = {} as TMacros;
-        }
-
-    } as any;
-}

package/src/Mixins/Reducible.ts

@@ -1,126 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-types */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { isDraftable, produce } from 'immer';
-
-import { Constructor } from '../Js';
-
-import Collection from '../Collection';
-import ReducerOverrideException from '../Exceptions/ReducerOverrideException';
-
-
-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>; /* & {
-        [key: string]: (value: any, ...args: any[]) => any;
-    };*/
-};
-
-export default function Reducible<TReducers extends ReducerMethodMap, TBase extends Constructor>(Base: TBase): ReducibleOf<TBase, TReducers> {
-    return class extends Base {
-        _reducers: ReducerRepository = {};
-
-        constructor(...args: any[]) {
-            super(...args);
-            return new Proxy(this, {
-                get(target, prop, receiver) {
-                    if (typeof prop === 'symbol' || prop in target) {
-                        return Reflect.get(target, prop, receiver);
-                    }
-                    return (value: unknown, ...args: unknown[]) => {
-                        const { [prop]: reducers = new Collection<Reducer>() } = target._reducers;
-
-                        if (isDraftable(value)) {
-                            return produce(value, (draft: unknown) => {
-                                return reducers
-                                    .sortBy('priority')
-                                    .reduce((prevValue, item) => item.callback(prevValue, ...args), draft);
-                            });
-                        }
-    
-                        return reducers
-                            .sortBy('priority')
-                            .reduce((prevValue, item) => item.callback(prevValue, ...args), value);
-                    };
-                },
-
-            });
-        }
-  
-        reducer(name: string, callback: ReducerCallback, priority: number = 10) {
-            if (name in this) {
-                throw new ReducerOverrideException(name, this);
-            }
-            if (!this._reducers[name]) {
-                this._reducers[name] = new Collection<Reducer>();
-            }
-
-            this._reducers[name].push({ callback, priority });
-
-            return () => this.removeReducer(name, callback);
-        }
-
-        removeReducer(name: string, callback: ReducerCallback) {
-            const index = this._reducers[name].search((reducer) => reducer.callback === callback);
-            if (index === false) {
-                return;
-            }
-            this._reducers[name].pull(index);
-        }
-
-        getReducer(name: string): Collection<Reducer> {
-            if (!this._reducers[name]) {
-                this._reducers[name] = new Collection<Reducer>();
-            }
-            return this._reducers[name];
-        }
-
-        hasReducer(name: string): boolean {
-            return !!this._reducers[name] && this._reducers[name].count() > 0;
-        }
-
-        clearReducer(name: string) {
-            this._reducers[name].splice(0, this._reducers[name].count());
-        }
-
-        flushReducers() {
-            Object.values(this._reducers).forEach((collection) => collection.splice(0, collection.count()));
-        }
-    } as any;
-}