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

package/dist/facades/App.d.ts

@@ -1,7 +1,8 @@
 import { AppFacades, AppFacade, AppEvents } from '../types/App';
-import Plugin from '../contracts/Plugin';
+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;
@@ -18,8 +19,8 @@ declare class App implements AppFacade {
 }
 declare const _default: {
     new (...args: any[]): {
-        "__#1@#emitter": import("nanoevents").Emitter<import("../types/Event").EventSourceEvents>;
-        "__#1@#createNanoEvents"(): import("nanoevents").Emitter<import("../types/Event").EventSourceEvents>;
+        "__#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;

package/dist/facades/Auth.d.ts

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

package/dist/facades/Error.d.ts

@@ -1,5 +1,6 @@
-import PropertyBag from '../contracts/PropertyBag';
+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;

package/dist/facades/Log.d.ts

@@ -1,4 +1,5 @@
 import { LogFacade } from '../types/Log';
+
 export default class Log implements LogFacade {
     private _debug;
     constructor(_debug: boolean);

package/dist/facades/Model.d.ts

@@ -3,6 +3,7 @@ import { AppFacade, GlobalModelEvents, ModelFacade as ModelFacadeInterface } fro
 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;
@@ -29,8 +30,8 @@ declare class ModelFacade implements ModelFacadeInterface {
 }
 declare const _default: {
     new (...args: any[]): {
-        "__#1@#emitter": import("nanoevents").Emitter<import("../types/Event").EventSourceEvents>;
-        "__#1@#createNanoEvents"(): import("nanoevents").Emitter<import("../types/Event").EventSourceEvents>;
+        "__#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;

package/dist/facades/Route.d.ts

@@ -1,5 +1,6 @@
 import { RouteDefinition, RouteTuple as RouteTuple, HttpMethod, RouteGenerator, RouteCallConfig } from '../types/Route';
 import { ErrorFacade } from '../types/Error';
+
 declare class Route {
     private routes;
     private error;
@@ -11,18 +12,18 @@ declare class Route {
     url(generator: RouteGenerator): string;
     methods(generator: RouteGenerator): HttpMethod[];
     exists(name: string): boolean;
-    call(generator: RouteGenerator, config?: RouteCallConfig): Promise<import("axios").AxiosResponse<any, any>>;
+    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>;
+            [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>;
+        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;

package/dist/helpers/app.d.ts

@@ -1,4 +1,5 @@
 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 +1,3 @@
-export default function (): import("..").AuthFacade;
+import { AuthFacade } from '../types/Auth';
+
+export default function (): AuthFacade;

package/dist/helpers/collect.d.ts

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

package/dist/helpers/config.d.ts

@@ -1,4 +1,5 @@
 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,3 +1,4 @@
 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,4 +1,5 @@
 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,5 +1,6 @@
 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,4 +1,5 @@
 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,18 +1,19 @@
-import app from './helpers/app';
-import auth from './helpers/auth';
-import collect from './helpers/collect';
-import config from './helpers/config';
-import error from './helpers/error';
-import log from './helpers/log';
-import model from './helpers/model';
-import route from './helpers/route';
+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 Plugin from './contracts/Plugin';
-import PropertyBag from './contracts/PropertyBag';
+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';

package/dist/mixins/BaseModel.d.ts

@@ -1,4 +1,5 @@
 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,12 +1,13 @@
 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;
+        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;

package/dist/mixins/Reducible.d.ts

@@ -1,6 +1,7 @@
 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: {

package/dist/support/collection.d.ts

@@ -1,3 +1,4 @@
 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,2 +1,3 @@
 import { Model } from '../types/Model';
+
 export declare function isModel(value: unknown): value is Model;

package/dist/types/App.d.ts

@@ -7,6 +7,7 @@ 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;

package/dist/types/Auth.d.ts

@@ -1,4 +1,5 @@
 import { Model } from './Model';
+
 export type AuthCredentials = {
     email: string;
     password: string;

package/dist/types/Builder.d.ts

@@ -1,7 +1,9 @@
-import PropertyBag, { PropertyBagEventMap } from '../contracts/PropertyBag';
+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>> & {

package/dist/types/Collection.d.ts

@@ -1,5 +1,6 @@
 import { Event, EventSource } from './Event';
 import { Constructor, TypeOf, JsonValue } from './Support';
+
 export type CollectionEvents<T = unknown> = {
     'change': (e: CollectionChangeEvent<T>) => void;
 };

package/dist/types/Config.d.ts

@@ -1,6 +1,7 @@
-import { PropertyBag } from '..';
+import { PropertyBag } from './PropertyBag';
 import { ModelSchema } from './Model';
 import { RouteDefinition } from './Route';
+
 export type AppConfiguration = {
     app?: {
         env?: string;

package/dist/types/Error.d.ts

@@ -1,5 +1,7 @@
-import PropertyBag, { PropertyBagEventMap } from '../contracts/PropertyBag';
+import { default as PropertyBag } from '../contracts/PropertyBag';
 import { Event, EventSource } from './Event';
+import { PropertyBagEventMap } from './PropertyBag';
+
 export type ErrorEventMap = {
     change: (e: ErrorChangeEvent) => void;
 };

package/dist/types/Event.d.ts

@@ -1,4 +1,5 @@
 import { Unsubscribe } from 'nanoevents';
+
 export type Event<S = any> = {
     source: S;
 };

package/dist/types/Model.d.ts

@@ -3,6 +3,7 @@ import { EventSource, Event } from './Event';
 import { Collection } from './Collection';
 import { RelationInterface, BuilderInterface, Scope, ExtendedOperator } from './Relation';
 import { JsonObject, JsonValue } from './Support';
+
 export type RelationRepository = Record<string, RelationInterface<Model, ModelPaginatedResponse>>;
 export type ModelEvents = {
     'change': (e: ModelChangeEvent) => void;
@@ -131,7 +132,7 @@ export type ModelQuery = JsonObject & {
     page?: number;
     per_page?: number;
     order_by?: string;
-    filters?: JsonObject;
+    where?: JsonObject;
     tab?: string;
     minified?: boolean;
 };

package/dist/types/PropertyBag.d.ts

@@ -0,0 +1,25 @@
+import { Unsubscribe } from 'nanoevents';
+import { Event } from './Event';
+
+export type PropertyBagChangeEvent<T extends object> = Event<PropertyBag<T>> & {
+    path: string;
+    value: unknown;
+    type: 'set' | 'merge' | 'delete';
+};
+export type PropertyBagEventMap<T extends object = any> = {
+    'change': (e: PropertyBagChangeEvent<T>) => void;
+};
+export type PropertyBag<T extends object> = {
+    get(path: string, defaultValue?: unknown): unknown;
+    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;
+    on<K extends keyof PropertyBagEventMap<T>>(event: K, callback: PropertyBagEventMap<T>[K]): Unsubscribe;
+    once<K extends keyof PropertyBagEventMap<T>>(event: K, callback: PropertyBagEventMap<T>[K]): void;
+    emit<K extends keyof PropertyBagEventMap<T>>(event: K, payload: Omit<Parameters<PropertyBagEventMap<T>[K]>[0], 'source'>): void;
+};

package/dist/types/Reducer.d.ts

@@ -1,4 +1,5 @@
 import { Collection } from './Collection';
+
 export type ReducerCallback = (value: any, ...params: any[]) => any;
 export interface Reducer {
     callback: ReducerCallback;

package/dist/types/Relation.d.ts

@@ -1,6 +1,7 @@
 import { BuilderInterface, ExtendedOperator, Scope } from './Builder';
 import { Collection } from './Collection';
 import { Constructor, JsonValue } from './Support';
+
 export type { BuilderInterface, ExtendedOperator, Scope, };
 export type RelationInterface<R, C> = {
     guessInverseRelation(): string;

package/dist/types/Route.d.ts

@@ -1,5 +1,6 @@
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
 import { ReducibleInterface } from './Reducer';
+
 export type RouteReplacer = {
     [key: string]: string | number;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luminix/core",
-  "version": "0.0.1-beta.0",
+  "version": "0.0.1-beta.2",
   "description": "> Projeto em desenvolvimento",
   "main": "dist/core.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,7 @@
     "ts-jest": "^29.1.2",
     "typescript": "^5.3.3",
     "vite": "^5.0.12",
-    "vite-plugin-dts": "^3.7.2"
+    "vite-plugin-dts": "^4.0.0-beta.1"
   },
   "peerDependencies": {
     "axios": "^1.6.4",