@luminix/core 0.0.1-beta.2 → 0.0.1-beta.3

package/dist/facades/App.d.ts

@@ -1,31 +0,0 @@
-import { AppFacades, AppFacade, AppEvents } from '../types/App';
-import { default as Plugin } from '../contracts/Plugin';
-import { AppConfiguration } from '../types/Config';
-import { Unsubscribe } from 'nanoevents';
-
-declare class App implements AppFacade {
-    private facades;
-    private booted;
-    private _plugins;
-    make(): AppFacades;
-    make<K extends keyof AppFacades>(key: K): AppFacades[K];
-    has(key: string): boolean;
-    bind<K extends keyof AppFacades>(key: K, facade: AppFacades[K]): void;
-    plugins(): Plugin[];
-    boot(configObject?: AppConfiguration): Promise<AppFacades>;
-    on<E extends keyof AppEvents>(_: E, __: AppEvents[E]): Unsubscribe;
-    once<E extends keyof AppEvents>(_: E, __: AppEvents[E]): void;
-    emit<E extends keyof AppEvents>(_: E, __?: Omit<Parameters<AppEvents[E]>[0], 'source'>): void;
-}
-declare const _default: {
-    new (...args: any[]): {
-        "__#1@#emitter": import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
-        "__#1@#createNanoEvents"(): import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
-        on<E extends keyof AppEvents>(event: E, callback: AppEvents[E]): Unsubscribe;
-        once<E_1 extends keyof AppEvents>(event: E_1, callback: AppEvents[E_1]): void;
-        emit<E_2 extends keyof AppEvents>(event: E_2, data?: Omit<Parameters<AppEvents[E_2]>[0], "source">): void;
-        [Symbol.toStringTag]: string;
-    };
-    name: string;
-} & typeof App;
-export default _default;

package/dist/facades/Auth.d.ts

@@ -1,14 +0,0 @@
-import { AppFacade } from '../types/App';
-import { AuthCredentials, AuthFacade } from '../types/Auth';
-import { Model } from '../types/Model';
-
-export default class Auth implements AuthFacade {
-    private readonly app;
-    private _user;
-    constructor(app: AppFacade);
-    attempt(credentials: AuthCredentials, remember?: boolean, onSubmit?: (e: Event) => void): void;
-    check(): boolean;
-    logout(onSubmit?: (e: Event) => void): void;
-    user(): Model | null;
-    id(): number | string | null;
-}

package/dist/facades/Error.d.ts

@@ -1,15 +0,0 @@
-import { default as PropertyBag } from '../contracts/PropertyBag';
-import { ErrorFacade, ValidationError } from '../types/Error';
-
-export declare const isValidationError: (error: unknown) => error is ValidationError;
-declare class Error implements ErrorFacade {
-    private bags;
-    constructor();
-    bag(name?: string): PropertyBag<Record<string, string>>;
-    add(key: string, value: string, bag?: string): void;
-    set(errors: Record<string, string>, bag?: string): void;
-    all(bag?: string): Record<string, string>;
-    get(key: string, bag?: string): string | null;
-    clear(bag?: string): void;
-}
-export default Error;

package/dist/facades/Log.d.ts

@@ -1,14 +0,0 @@
-import { LogFacade } from '../types/Log';
-
-export default class Log implements LogFacade {
-    private _debug;
-    constructor(_debug: boolean);
-    emergency(...args: any[]): void;
-    alert(...args: any[]): void;
-    critical(...args: any[]): void;
-    error(...args: any[]): void;
-    warning(...args: any[]): void;
-    notice(...args: any[]): void;
-    info(...args: any[]): void;
-    debug(...args: any[]): void;
-}

package/dist/facades/Model.d.ts

@@ -1,42 +0,0 @@
-import { ModelSchema, ModelSchemaAttributes, Model } from '../types/Model';
-import { AppFacade, GlobalModelEvents, ModelFacade as ModelFacadeInterface } from '../types/App';
-import { Unsubscribe } from 'nanoevents';
-import { Reducer, ReducerCallback, Unsubscribe as UnsubscribeReducer } from '../types/Reducer';
-import { Collection } from '../contracts/Collection';
-
-declare class ModelFacade implements ModelFacadeInterface {
-    private readonly _schema;
-    private _models;
-    static name: string;
-    constructor(_schema: ModelSchema);
-    boot(app: AppFacade): void;
-    schema(): ModelSchema;
-    schema(abstract: string): ModelSchemaAttributes;
-    make(): {
-        [abstract: string]: typeof Model;
-    };
-    make(abstract: string): typeof Model;
-    toString(): string;
-    on<K extends keyof GlobalModelEvents>(_: K, __: GlobalModelEvents[K]): Unsubscribe;
-    once<K extends keyof GlobalModelEvents>(_: K, __: GlobalModelEvents[K]): void;
-    emit<K extends keyof GlobalModelEvents>(_: K, __?: Omit<Parameters<GlobalModelEvents[K]>[0], 'source'>): void;
-    reducer(_: string, __: ReducerCallback, ___?: number): UnsubscribeReducer;
-    removeReducer(_: string): void;
-    getReducer(_: string): Collection<Reducer>;
-    hasReducer(_: string): boolean;
-    clearReducer(_: string): void;
-    flushReducers(): void;
-    [reducer: string]: unknown;
-}
-declare const _default: {
-    new (...args: any[]): {
-        "__#1@#emitter": import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
-        "__#1@#createNanoEvents"(): import('nanoevents').Emitter<import('../types/Event').EventSourceEvents>;
-        on<E extends keyof GlobalModelEvents>(event: E, callback: GlobalModelEvents[E]): Unsubscribe;
-        once<E_1 extends keyof GlobalModelEvents>(event: E_1, callback: GlobalModelEvents[E_1]): void;
-        emit<E_2 extends keyof GlobalModelEvents>(event: E_2, data?: Omit<Parameters<GlobalModelEvents[E_2]>[0], "source">): void;
-        [Symbol.toStringTag]: string;
-    };
-    name: string;
-} & typeof ModelFacade;
-export default _default;

package/dist/facades/Route.d.ts

@@ -1,32 +0,0 @@
-import { RouteDefinition, RouteTuple as RouteTuple, HttpMethod, RouteGenerator, RouteCallConfig } from '../types/Route';
-import { ErrorFacade } from '../types/Error';
-
-declare class Route {
-    private routes;
-    private error;
-    private appUrl;
-    constructor(routes: RouteDefinition, error: ErrorFacade, appUrl?: string);
-    private isRouteTuple;
-    private extractGenerator;
-    get(name: string): RouteTuple;
-    url(generator: RouteGenerator): string;
-    methods(generator: RouteGenerator): HttpMethod[];
-    exists(name: string): boolean;
-    call(generator: RouteGenerator, config?: RouteCallConfig): Promise<import('axios').AxiosResponse<any, any>>;
-    toString(): string;
-    [reducer: string]: unknown;
-}
-declare const _default: {
-    new (...args: any[]): {
-        reducers: {
-            [name: string]: import('../types/Collection').Collection<import('../types/Reducer').Reducer>;
-        };
-        reducer(name: string, callback: import('../types/Reducer').ReducerCallback, priority?: number): () => void;
-        removeReducer(name: string, callback: import('../types/Reducer').ReducerCallback): void;
-        getReducer(name: string): import('../types/Collection').Collection<import('../types/Reducer').Reducer>;
-        hasReducer(name: string): boolean;
-        clearReducer(name: string): void;
-        flushReducers(): void;
-    };
-} & typeof Route;
-export default _default;

package/dist/helpers/app.d.ts

@@ -1,5 +0,0 @@
-import { AppExternal, AppFacades } from '../types/App';
-
-declare function app(): AppExternal;
-declare function app<T extends keyof AppFacades>(facade: T): AppFacades[T];
-export default app;

package/dist/helpers/auth.d.ts

@@ -1,3 +0,0 @@
-import { AuthFacade } from '../types/Auth';
-
-export default function (): AuthFacade;

package/dist/helpers/collect.d.ts

@@ -1 +0,0 @@
-export default function collect<T = unknown>(items: T[]): import('../types/Collection').Collection<T>;

package/dist/helpers/config.d.ts

@@ -1,5 +0,0 @@
-import { ConfigFacade } from '../types/Config';
-
-declare function config(): ConfigFacade;
-declare function config(path: string, defaultValue?: unknown): unknown;
-export default config;

package/dist/helpers/error.d.ts

@@ -1,4 +0,0 @@
-import { ErrorFacade } from '../types/Error';
-
-export default function error(): ErrorFacade;
-export default function error(key: string, bag?: string): string | null;

package/dist/helpers/log.d.ts

@@ -1,5 +0,0 @@
-import { LogFacade } from '../types/Log';
-
-declare function log(): LogFacade;
-declare function log(...data: any[]): void;
-export default log;

package/dist/helpers/model.d.ts

@@ -1,6 +0,0 @@
-import { Model } from '../types/Model';
-import { ModelFacade } from '../types/App';
-
-declare function model(): ModelFacade;
-declare function model(abstract: string): typeof Model;
-export default model;

package/dist/helpers/route.d.ts

@@ -1,5 +0,0 @@
-import { RouteFacade, RouteReplacer } from '../types/Route';
-
-declare function route(): RouteFacade;
-declare function route(name: string, parameters?: RouteReplacer): string;
-export default route;

package/dist/index.d.ts

@@ -1,24 +0,0 @@
-import { default as app } from './helpers/app';
-import { default as auth } from './helpers/auth';
-import { default as collect } from './helpers/collect';
-import { default as config } from './helpers/config';
-import { default as error } from './helpers/error';
-import { default as log } from './helpers/log';
-import { default as model } from './helpers/model';
-import { default as route } from './helpers/route';
-import { isValidationError } from './facades/Error';
-import { default as Plugin } from './contracts/Plugin';
-import { default as PropertyBag } from './contracts/PropertyBag';
-import { isModel } from './support/model';
-import { isCollection } from './support/collection';
-import { Reducible } from './mixins/Reducible';
-import { HasEvents } from './mixins/HasEvents';
-
-export { app, auth, collect, config, error, log, model, route, isCollection, isValidationError, isModel, Plugin, PropertyBag, Reducible, HasEvents, };
-export type { AppFacade } from './types/App';
-export type { AuthFacade } from './types/Auth';
-export type { LogFacade } from './types/Log';
-export type { ReducibleInterface } from './types/Reducer';
-export type { RouteFacade } from './types/Route';
-export type { Model, BaseModel } from './types/Model';
-export type { EventSource } from './types/Event';

package/dist/mixins/BaseModel.d.ts

@@ -1,5 +0,0 @@
-import { BaseModel, Model as ModelInterface } from '../types/Model';
-import { AppFacades } from '../types/App';
-
-export declare function BaseModelFactory(facades: AppFacades, abstract: string): typeof BaseModel;
-export declare function ModelFactory(facades: AppFacades, abstract: string, CustomModel: typeof BaseModel): typeof ModelInterface;

package/dist/mixins/HasEvents.d.ts

@@ -1,16 +0,0 @@
-import { Emitter } from 'nanoevents';
-import { EventSourceEvents, EventSource } from '../types/Event';
-import { Constructor } from '../types/Support';
-
-export declare function isEventSource<T>(value: T): value is T & EventSource<any>;
-export declare function HasEvents<T extends EventSourceEvents, U extends Constructor>(Base: U): {
-    new (...args: any[]): {
-        "__#1@#emitter": Emitter<EventSourceEvents>;
-        "__#1@#createNanoEvents"(): Emitter<EventSourceEvents>;
-        on<E extends keyof T>(event: E, callback: T[E]): import('nanoevents').Unsubscribe;
-        once<E_1 extends keyof T>(event: E_1, callback: T[E_1]): void;
-        emit<E_2 extends keyof T>(event: E_2, data?: Omit<Parameters<T[E_2]>[0], "source">): void;
-        [Symbol.toStringTag]: string;
-    };
-    name: string;
-} & U;

package/dist/mixins/Reducible.d.ts

@@ -1,17 +0,0 @@
-import { ReducerCallback, Reducer } from '../types/Reducer';
-import { Constructor } from '../types/Support';
-import { Collection } from '../types/Collection';
-
-export declare function Reducible<T extends Constructor>(Base: T): {
-    new (...args: any[]): {
-        reducers: {
-            [name: string]: Collection<Reducer>;
-        };
-        reducer(name: string, callback: ReducerCallback, priority?: number): () => void;
-        removeReducer(name: string, callback: ReducerCallback): void;
-        getReducer(name: string): Collection<Reducer>;
-        hasReducer(name: string): boolean;
-        clearReducer(name: string): void;
-        flushReducers(): void;
-    };
-} & T;

package/dist/support/collection.d.ts

@@ -1,4 +0,0 @@
-import { Collection } from '../types/Collection';
-
-export declare function cartesian<T>(...arrays: T[][]): T[][];
-export declare function isCollection(instance: unknown): instance is Collection;

package/dist/support/model.d.ts

@@ -1,3 +0,0 @@
-import { Model } from '../types/Model';
-
-export declare function isModel(value: unknown): value is Model;

package/dist/support/reader.d.ts

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

package/dist/support/searchParams.d.ts

@@ -1 +0,0 @@
-export declare const createMergedSearchParams: (...urls: string[]) => URLSearchParams;

package/dist/types/App.d.ts

@@ -1,72 +0,0 @@
-import { AppConfiguration, ConfigFacade } from './Config';
-import { PluginInterface } from './Plugin';
-import { LogFacade } from './Log';
-import { AuthFacade } from './Auth';
-import { BaseModel, Model, ModelSchema, ModelSchemaAttributes } from './Model';
-import { RouteFacade } from './Route';
-import { EventSource, Event } from './Event';
-import { ErrorFacade } from './Error';
-import { ReducibleInterface } from './Reducer';
-
-type Plugin = PluginInterface<AppFacade, AppFacades>;
-export type GlobalModelEvents = {
-    'save': (e: ModelGlobalEvent) => void;
-    'delete': (e: ModelGlobalEvent) => void;
-    'restore': (e: ModelGlobalEvent) => void;
-    'create': (e: ModelGlobalEvent) => void;
-    'update': (e: ModelGlobalEvent) => void;
-    'fetch': (e: ModelGlobalEvent) => void;
-    'error': (e: ModelGlobalErrorEvent) => void;
-};
-export type ModelGlobalEvent = Event<ModelFacade> & {
-    class: string;
-    model: BaseModel;
-    force?: boolean;
-};
-export type ModelGlobalErrorEvent = ModelGlobalEvent & {
-    error: unknown;
-    operation: 'save' | 'delete' | 'restore' | 'forceDelete';
-};
-export type ModelFacade = EventSource<GlobalModelEvents> & ReducibleInterface & {
-    schema(): ModelSchema;
-    schema(abstract: string): ModelSchemaAttributes;
-    make(): Record<string, typeof Model>;
-    make(abstract: string): typeof Model;
-    boot(app: AppFacade): void;
-};
-export type AppEvents = {
-    'init': (e: InitEvent) => void;
-    'booted': (e: Event<AppFacade>) => void;
-    'booting': (e: Event<AppFacade>) => void;
-};
-export type InitEvent = Event<AppFacade> & {
-    register(plugin: Plugin): void;
-};
-export type AppExternal = {
-    boot: (config?: AppConfiguration) => Promise<AppFacades>;
-    make(): AppFacades;
-    make<T extends keyof AppFacades>(key: T): AppFacades[T];
-    plugins: () => Plugin[];
-    on: EventSource<AppEvents>['once'];
-};
-export type AppFacade = AppExternal & {
-    has(key: string): boolean;
-    bind<T extends keyof AppFacades>(key: T, facade: AppFacades[T]): void;
-    emit: EventSource<AppEvents>['emit'];
-    once: EventSource<AppEvents>['once'];
-    on: EventSource<AppEvents>['on'];
-};
-export type AppFacades = {
-    auth: AuthFacade;
-    config: ConfigFacade;
-    error: ErrorFacade;
-    log: LogFacade;
-    model: ModelFacade;
-    route: RouteFacade;
-    [key: string]: any;
-};
-export type BootOptions = {
-    config?: AppConfiguration;
-    skipBootRequest?: boolean;
-};
-export {};

package/dist/types/Auth.d.ts

@@ -1,13 +0,0 @@
-import { Model } from './Model';
-
-export type AuthCredentials = {
-    email: string;
-    password: string;
-};
-export type AuthFacade = {
-    attempt(credentials: AuthCredentials, remember: boolean, onSubmit?: (e: Event) => void): void;
-    check(): boolean;
-    logout(onSubmit?: (e: Event) => void): void;
-    user(): Model | null;
-    id(): number | string | null;
-};

package/dist/types/Builder.d.ts

@@ -1,47 +0,0 @@
-import { default as PropertyBag } from '../contracts/PropertyBag';
-import { Event, EventSource } from './Event';
-import { JsonObject, JsonValue } from './Support';
-import { Operator, Collection } from './Collection';
-import { PropertyBagEventMap } from './PropertyBag';
-
-export type Scope<R, C> = (builder: BuilderInterface<R, C>) => BuilderInterface<R, C> | void;
-export type ExtendedOperator = Operator | 'like' | 'notLike' | 'between' | 'notBetween' | 'isNull' | 'isNotNull';
-export type BuilderInterface<R, C> = EventSource<BuilderEventMap<R, C>> & {
-    lock(path: string): void;
-    where(scope: Scope<R, C>): BuilderInterface<R, C>;
-    where(key: string, value: JsonValue): BuilderInterface<R, C>;
-    where(key: string, operator: ExtendedOperator, value: JsonValue): BuilderInterface<R, C>;
-    where(key: string | Scope<R, C>, operatorOrValue?: ExtendedOperator | JsonValue, value?: JsonValue): BuilderInterface<R, C>;
-    whereNull(key: string): BuilderInterface<R, C>;
-    whereNotNull(key: string): BuilderInterface<R, C>;
-    whereBetween(key: string, value: [JsonValue, JsonValue]): BuilderInterface<R, C>;
-    whereNotBetween(key: string, value: [JsonValue, JsonValue]): BuilderInterface<R, C>;
-    orderBy(column: string, direction?: 'asc' | 'desc'): BuilderInterface<R, C>;
-    searchBy(term: string): BuilderInterface<R, C>;
-    minified(): BuilderInterface<R, C>;
-    limit(value: number): BuilderInterface<R, C>;
-    get(page?: number, replaceLinksWith?: string): Promise<C>;
-    all(): Promise<Collection<R>>;
-    first(): Promise<R | null>;
-    find(id: string | number): Promise<R | null>;
-    unset(key: string): BuilderInterface<R, C>;
-};
-export type BuilderEventMap<R, C> = PropertyBagEventMap & {
-    'change': (e: BuilderChangeEvent<R, C>) => void;
-    'submit': (e: BuilderSubmitEvent<R, C>) => void;
-    'success': (e: BuilderSuccessEvent<R, C>) => void;
-    'error': (e: BuilderErrorEvent<R, C>) => void;
-};
-export type BuilderChangeEvent<R, C> = Event<BuilderInterface<R, C>> & {
-    data: PropertyBag<JsonObject>;
-};
-export type BuilderSubmitEvent<R, C> = Event<BuilderInterface<R, C>> & {
-    data: PropertyBag<JsonObject>;
-};
-export type BuilderSuccessEvent<R, C> = Event<BuilderInterface<R, C>> & {
-    response: C;
-    items: Collection<R> | R | null;
-};
-export type BuilderErrorEvent<R, C> = Event<BuilderInterface<R, C>> & {
-    error: unknown;
-};