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

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@luminix/support",
-  "version": "0.0.1-beta.1",
+  "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

@@ -1,18 +1,25 @@
-/**
- *
- * 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[];
+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/Contracts/EventSource.d.ts

@@ -1,15 +1,18 @@
 import { Unsubscribe } from 'nanoevents';
-export type Event<TData = any, TSource extends EventSource = EventSource> = TData & {
+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;
-    static foo(): string;
+    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/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

@@ -15,6 +15,8 @@ export default class Client {
     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>;

package/types/Http/Response.d.ts

@@ -1,12 +1,14 @@
 import { AxiosResponse } from 'axios';
 export default class Response<TResponse = any, TData = any> {
-    private response;
-    private error?;
-    constructor(response: AxiosResponse<TResponse, TData>, error?: Error | undefined);
+    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;

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

@@ -1,2 +1,6 @@
-export type Constructor<T = {}> = new (...args: any[]) => T;
+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/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/Obj.d.ts

@@ -1,14 +1,20 @@
-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;
+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

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

package/types/Str.d.ts

@@ -3,8 +3,16 @@ 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 upperFirst(string: string): string;
+export declare function ucfirst(string: string): string;
+export declare function upper(string: string): string;

package/types/index.d.ts

@@ -1,10 +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 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 { 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 { Arr, Collection, EventSource, Http, Reducible, Macroable, Obj, Query, 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;

package/vite.config.js

@@ -12,11 +12,6 @@ export default defineConfig({
             entry: resolve(__dirname, 'src/index.ts'),
             formats: ['es'],
         },
-        rollupOptions: {
-            external: [
-                'immer',
-            ]
-        }
     },
     
 });

package/types/App/ServiceContainer.d.ts

@@ -1,6 +0,0 @@
-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/Http/index.d.ts

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

@@ -1,30 +0,0 @@
-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/types/Services/ApplicationService.d.ts

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