@aerogel/core 0.0.0-next.59bf5f7cc06e728d0cf6c00de28f1da48d7d6b8e → 0.0.0-next.926bde19326fe7b6b24b277666936862b64d8295

package/src/services/Service.ts

@@ -1,42 +1,27 @@
-import { MagicObject, PromisedValue, Storage, isEmpty, objectDeepClone, objectOnly } from '@noeldemartin/utils';
+import { computed, reactive } from 'vue';
+import { MagicObject, PromisedValue } from '@noeldemartin/utils';
+import type { ComputedRef } from 'vue';
 import type { Constructor } from '@noeldemartin/utils';
-import type { Store } from 'pinia';
 
 import ServiceBootError from '@/errors/ServiceBootError';
-import { defineServiceStore } from '@/services/store';
 
 export type ServiceState = Record<string, any>; // eslint-disable-line @typescript-eslint/no-explicit-any
-export type DefaultServiceState = any; // eslint-disable-line @typescript-eslint/no-explicit-any
+export type DefaultServiceState = {};
 export type ServiceConstructor<T extends Service = Service> = Constructor<T> & typeof Service;
 
 export type ComputedStateDefinition<TState extends ServiceState, TComputedState extends ServiceState> = {
     [K in keyof TComputedState]: (state: TState) => TComputedState[K];
-} & ThisType<{
-    readonly [K in keyof TComputedState]: TComputedState[K];
-}>;
+};
 
 export function defineServiceState<
     State extends ServiceState = ServiceState,
     ComputedState extends ServiceState = {}
 >(options: {
-    name: string;
     initialState: State;
-    persist?: (keyof State)[];
     computed?: ComputedStateDefinition<State, ComputedState>;
-    serialize?: (state: Partial<State>) => Partial<State>;
-}): Constructor<State> & Constructor<ComputedState> & Constructor<Service<State, ComputedState, Partial<State>>> {
+}): Constructor<State> & Constructor<ComputedState> & ServiceConstructor {
     return class extends Service<State, ComputedState> {
 
-        public static persist = (options.persist as string[]) ?? [];
-
-        protected usesStore(): boolean {
-            return true;
-        }
-
-        protected getName(): string | null {
-            return options.name ?? null;
-        }
-
         protected getInitialState(): State {
             return options.initialState;
         }
@@ -44,53 +29,44 @@ export function defineServiceState<
         protected getComputedStateDefinition(): ComputedStateDefinition<State, ComputedState> {
             return options.computed ?? ({} as ComputedStateDefinition<State, ComputedState>);
         }
-
-        protected serializePersistedState(state: Partial<State>): Partial<State> {
-            return options.serialize?.(state) ?? state;
-        }
     
-    } as unknown as Constructor<State> &
-        Constructor<ComputedState> &
-        Constructor<Service<State, ComputedState, Partial<State>>>;
+    } as unknown as Constructor<State> & Constructor<ComputedState> & ServiceConstructor;
 }
 
 export default class Service<
     State extends ServiceState = DefaultServiceState,
-    ComputedState extends ServiceState = {},
-    ServiceStorage extends Partial<State> = Partial<State>
+    ComputedState extends ServiceState = {}
 > extends MagicObject {
 
-    public static persist: string[] = [];
-
-    protected _name: string;
+    protected _namespace: string;
     private _booted: PromisedValue<void>;
-    private _computedStateKeys: Set<keyof State>;
-    private _store?: Store | false;
+    private _state: State;
+    private _computedState: Record<keyof ComputedState, ComputedRef>;
 
     constructor() {
         super();
 
-        const getters = this.getComputedStateDefinition();
-
-        this._name = this.getName() ?? new.target.name;
+        this._namespace = new.target.name;
         this._booted = new PromisedValue();
-        this._computedStateKeys = new Set(Object.keys(getters));
-        this._store =
-            this.usesStore() &&
-            defineServiceStore(this._name, {
-                state: () => this.getInitialState(),
-
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                getters: getters as any,
-            });
+        this._state = reactive(this.getInitialState());
+        this._computedState = Object.entries(this.getComputedStateDefinition()).reduce(
+            (computedState, [name, method]) => {
+                computedState[name as keyof ComputedState] = computed(() => method(this._state));
+
+                return computedState;
+            },
+            {} as Record<keyof ComputedState, ComputedRef>,
+        );
     }
 
     public get booted(): PromisedValue<void> {
         return this._booted;
     }
 
-    public launch(): Promise<void> {
-        const handleError = (error: unknown) => this._booted.reject(new ServiceBootError(this._name, error));
+    public launch(namespace?: string): Promise<void> {
+        const handleError = (error: unknown) => this._booted.reject(new ServiceBootError(this._namespace, error));
+
+        this._namespace = namespace ?? this._namespace;
 
         try {
             this.boot()
@@ -103,48 +79,15 @@ export default class Service<
         return this._booted;
     }
 
-    public hasState<P extends keyof State>(property: P): boolean {
-        if (!this._store) {
-            return false;
-        }
-
-        return property in this._store.$state || this._computedStateKeys.has(property);
-    }
-
-    public getState(): State;
-    public getState<P extends keyof State>(property: P): State[P];
-    public getState<P extends keyof State>(property?: P): State | State[P] {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const store = this._store as any;
-
-        if (property) {
-            return store ? store[property] : undefined;
-        }
-
-        return store ? store : {};
-    }
-
-    public setState<P extends keyof State>(property: P, value: State[P]): void;
-    public setState(state: Partial<State>): void;
-    public setState<P extends keyof State>(stateOrProperty: P | Partial<State>, value?: State[P]): void {
-        if (!this._store) {
-            return;
-        }
-
-        const state = (
-            typeof stateOrProperty === 'string' ? { [stateOrProperty]: value } : stateOrProperty
-        ) as Partial<State>;
-
-        Object.assign(this._store.$state, state);
-
-        this.onStateUpdated(state);
-    }
-
     protected __get(property: string): unknown {
         if (this.hasState(property)) {
             return this.getState(property);
         }
 
+        if (this.hasComputedState(property)) {
+            return this.getComputedState(property);
+        }
+
         return super.__get(property);
     }
 
@@ -152,29 +95,26 @@ export default class Service<
         this.setState({ [property]: value } as Partial<State>);
     }
 
-    protected onStateUpdated(state: Partial<State>): void {
-        // TODO fix this.static()
-        const persist = (this.constructor as unknown as { persist: string[] }).persist;
-        const persisted = objectOnly(state, persist);
-
-        if (isEmpty(persisted)) {
-            return;
-        }
+    protected hasState<P extends keyof State>(property: P): boolean {
+        return property in this._state;
+    }
 
-        const storage = Storage.require<ServiceStorage>(this._name);
+    protected hasComputedState<P extends keyof State>(property: P): boolean {
+        return property in this._computedState;
+    }
 
-        Storage.set(this._name, {
-            ...storage,
-            ...this.serializePersistedState(objectDeepClone(persisted) as Partial<State>),
-        });
+    protected getState(): State;
+    protected getState<P extends keyof State>(property: P): State[P];
+    protected getState<P extends keyof State>(property?: P): State | State[P] {
+        return property ? this._state[property] : this._state;
     }
 
-    protected usesStore(): boolean {
-        return false;
+    protected getComputedState<P extends keyof ComputedState>(property: P): ComputedState[P] {
+        return this._computedState[property]?.value;
     }
 
-    protected getName(): string | null {
-        return null;
+    protected setState(state: Partial<State>): void {
+        Object.assign(this._state, state);
     }
 
     protected getInitialState(): State {
@@ -185,30 +125,8 @@ export default class Service<
         return {} as ComputedStateDefinition<State, ComputedState>;
     }
 
-    protected serializePersistedState(state: Partial<State>): Partial<State> {
-        return state;
-    }
-
     protected async boot(): Promise<void> {
-        this.restorePersistedState();
-    }
-
-    protected restorePersistedState(): void {
-        // TODO fix this.static()
-        const persist = (this.constructor as unknown as { persist: string[] }).persist;
-
-        if (!this.usesStore() || isEmpty(persist)) {
-            return;
-        }
-
-        if (Storage.has(this._name)) {
-            const persisted = Storage.require<ServiceStorage>(this._name);
-            this.setState(persisted);
-
-            return;
-        }
-
-        Storage.set(this._name, objectOnly(this.getState(), persist));
+        //
     }
 
 }

package/src/services/index.ts

@@ -5,7 +5,6 @@ import { definePlugin } from '@/plugins';
 import App from './App';
 import Events from './Events';
 import Service from './Service';
-import { getPiniaStore } from './store';
 
 export * from './App';
 export * from './Events';
@@ -24,9 +23,9 @@ export interface Services extends DefaultServices {}
 
 export async function bootServices(app: VueApp, services: Record<string, Service>): Promise<void> {
     await Promise.all(
-        Object.entries(services).map(async ([_, service]) => {
+        Object.entries(services).map(async ([name, service]) => {
             // eslint-disable-next-line no-console
-            await service.launch().catch((error) => console.error(error));
+            await service.launch(name.slice(1)).catch((error) => console.error(error));
         }),
     );
 
@@ -34,24 +33,11 @@ export async function bootServices(app: VueApp, services: Record<string, Service
 }
 
 export default definePlugin({
-    async install(app, options) {
-        const services = {
-            ...defaultServices,
-            ...options.services,
-        };
-
-        app.use(getPiniaStore());
-
-        await bootServices(app, services);
+    async install(app) {
+        await bootServices(app, defaultServices);
     },
 });
 
-declare module '@/bootstrap/options' {
-    interface AerogelOptions {
-        services?: Record<string, Service>;
-    }
-}
-
 declare module '@vue/runtime-core' {
     interface ComponentCustomProperties extends Services {}
 }

package/src/ui/UI.state.ts

@@ -18,6 +18,5 @@ export interface ModalComponent<
 > {}
 
 export default defineServiceState({
-    name: 'ui',
     initialState: { modals: [] as Modal[] },
 });

package/src/ui/UI.ts

@@ -21,7 +21,6 @@ type ModalResult<TComponent> = TComponent extends ModalComponent<Record<string,
 export const UIComponents = {
     AlertModal: 'alert-modal',
     ConfirmModal: 'confirm-modal',
-    LoadingModal: 'loading-modal',
 } as const;
 
 export type UIComponent = ObjectValues<typeof UIComponents>;
@@ -52,20 +51,6 @@ export class UIService extends Service {
         return result ?? false;
     }
 
-    public async loading<T>(operation: Promise<T>): Promise<T>;
-    public async loading<T>(message: string, operation: Promise<T>): Promise<T>;
-    public async loading<T>(messageOrOperation: string | Promise<T>, operation?: Promise<T>): Promise<T> {
-        operation = typeof messageOrOperation === 'string' ? (operation as Promise<T>) : messageOrOperation;
-
-        const message = typeof messageOrOperation === 'string' ? messageOrOperation : undefined;
-        const modal = await this.openModal(this.requireComponent(UIComponents.LoadingModal), { message });
-        const result = await operation;
-
-        await this.closeModal(modal.id);
-
-        return result;
-    }
-
     public registerComponent(name: UIComponent, component: Component): void {
         this.components[name] = component;
     }

package/src/ui/index.ts

@@ -6,7 +6,6 @@ import { definePlugin } from '@/plugins';
 import UI, { UIComponents } from './UI';
 import AGAlertModal from '../components/modals/AGAlertModal.vue';
 import AGConfirmModal from '../components/modals/AGConfirmModal.vue';
-import AGLoadingModal from '../components/modals/AGLoadingModal.vue';
 import type { UIComponent } from './UI';
 
 export { UI, UIComponents, UIComponent };
@@ -20,7 +19,6 @@ export default definePlugin({
         const defaultComponents = {
             [UIComponents.AlertModal]: AGAlertModal,
             [UIComponents.ConfirmModal]: AGConfirmModal,
-            [UIComponents.LoadingModal]: AGLoadingModal,
         };
 
         Object.entries({

package/src/utils/index.ts

@@ -1,4 +1,3 @@
 export * from './composition/events';
-export * from './composition/forms';
 export * from './composition/hooks';
 export * from './vue';

package/src/components/forms/AGCheckbox.vue

@@ -1,35 +0,0 @@
-<template>
-    <AGHeadlessInput ref="$input" :name="name" class="flex">
-        <AGHeadlessInputInput
-            v-bind="$attrs"
-            type="checkbox"
-            :class="{
-                'text-indigo-600 focus:ring-indigo-600': !$input?.errors,
-                'border-red-200 text-red-600 focus:ring-red-600': $input?.errors,
-            }"
-        />
-
-        <div class="ml-2">
-            <AGHeadlessInputLabel v-if="$slots.default">
-                <slot />
-            </AGHeadlessInputLabel>
-            <AGHeadlessInputError class="text-sm text-red-600" />
-        </div>
-    </AGHeadlessInput>
-</template>
-
-<script setup lang="ts">
-import { componentRef, stringProp } from '@/utils/vue';
-
-import type { IAGHeadlessInput } from '@/components/headless/forms/AGHeadlessInput';
-
-import AGHeadlessInput from '../headless/forms/AGHeadlessInput.vue';
-import AGHeadlessInputError from '../headless/forms/AGHeadlessInputError.vue';
-import AGHeadlessInputInput from '../headless/forms/AGHeadlessInputInput.vue';
-import AGHeadlessInputLabel from '../headless/forms/AGHeadlessInputLabel.vue';
-
-defineProps({ name: stringProp() });
-defineOptions({ inheritAttrs: false });
-
-const $input = componentRef<IAGHeadlessInput>();
-</script>

package/src/components/modals/AGLoadingModal.vue

@@ -1,19 +0,0 @@
-<template>
-    <AGModal :cancellable="false">
-        <AGMarkdown :text="renderedMessage" />
-    </AGModal>
-</template>
-
-<script setup lang="ts">
-import { computed } from 'vue';
-
-import { stringProp } from '@/utils/vue';
-import { translateWithDefault } from '@/lang/utils';
-
-import AGModal from './AGModal.vue';
-
-import AGMarkdown from '../basic/AGMarkdown.vue';
-
-const props = defineProps({ message: stringProp() });
-const renderedMessage = computed(() => props.message ?? translateWithDefault('ui.loading', 'Loading...'));
-</script>

package/src/errors/Errors.state.ts

@@ -1,31 +0,0 @@
-import type { JSError } from '@noeldemartin/utils';
-
-import { defineServiceState } from '@/services';
-
-export type ErrorSource = string | Error | JSError | unknown;
-
-export interface ErrorReport {
-    title: string;
-    description?: string;
-    details?: string;
-    error?: Error | JSError | unknown;
-}
-
-export interface ErrorReportLog {
-    report: ErrorReport;
-    seen: boolean;
-    date: Date;
-}
-
-export default defineServiceState({
-    name: 'errors',
-    initialState: {
-        logs: [] as ErrorReportLog[],
-        startupErrors: [] as ErrorReport[],
-    },
-    computed: {
-        hasErrors: ({ logs }) => logs.length > 0,
-        hasNewErrors: ({ logs }) => logs.some((error) => !error.seen),
-        hasStartupErrors: ({ startupErrors }) => startupErrors.length > 0,
-    },
-});

package/src/errors/Errors.ts

@@ -1,132 +0,0 @@
-import { JSError, facade, isObject } from '@noeldemartin/utils';
-
-import App from '@/services/App';
-import ServiceBootError from '@/errors/ServiceBootError';
-import UI from '@/ui/UI';
-import { translate } from '@/lang/utils';
-
-import Service from './Errors.state';
-import type { ErrorReport, ErrorReportLog, ErrorSource } from './Errors.state';
-
-export class ErrorsService extends Service {
-
-    public forceReporting: boolean = false;
-    private enabled: boolean = true;
-
-    public enable(): void {
-        this.enabled = true;
-    }
-
-    public disable(): void {
-        this.enabled = false;
-    }
-
-    public async inspect(error: ErrorSource | ErrorReport[]): Promise<void> {
-        const reports = Array.isArray(error) ? error : [await this.createErrorReport(error)];
-
-        // TODO open errors modal
-        reports;
-    }
-
-    public async report(error: ErrorSource, message?: string): Promise<void> {
-        if (App.isDevelopment || App.isTesting) {
-            this.logError(error);
-        }
-
-        if (!this.enabled) {
-            throw error;
-        }
-
-        if (!App.isMounted) {
-            const startupError = await this.createStartupErrorReport(error);
-
-            if (startupError) {
-                this.setState({ startupErrors: this.startupErrors.concat(startupError) });
-            }
-
-            return;
-        }
-
-        const report = await this.createErrorReport(error);
-        const log: ErrorReportLog = {
-            report,
-            seen: false,
-            date: new Date(),
-        };
-
-        // TODO open error snackbar
-        UI.alert(message ?? 'Something went wrong, but it\'s not your fault! (look at the console for details)');
-
-        this.setState({ logs: [log].concat(this.logs) });
-    }
-
-    public see(report: ErrorReport): void {
-        this.setState({
-            logs: this.logs.map((log) => {
-                if (log.report !== report) {
-                    return log;
-                }
-
-                return {
-                    ...log,
-                    seen: true,
-                };
-            }),
-        });
-    }
-
-    public seeAll(): void {
-        this.setState({
-            logs: this.logs.map((log) => ({
-                ...log,
-                seen: true,
-            })),
-        });
-    }
-
-    private logError(error: unknown): void {
-        // eslint-disable-next-line no-console
-        console.error(error);
-
-        if (isObject(error) && error.cause) {
-            this.logError(error.cause);
-        }
-    }
-
-    private async createErrorReport(error: ErrorSource): Promise<ErrorReport> {
-        if (typeof error === 'string') {
-            return { title: error };
-        }
-
-        if (error instanceof Error || error instanceof JSError) {
-            return this.createErrorReportFromError(error);
-        }
-
-        return {
-            title: translate('errors.unknown'),
-            error,
-        };
-    }
-
-    private async createStartupErrorReport(error: ErrorSource): Promise<ErrorReport | null> {
-        if (error instanceof ServiceBootError) {
-            // Ignore second-order boot errors in order to have a cleaner startup crash screen.
-            return error.cause instanceof ServiceBootError ? null : this.createErrorReport(error.cause);
-        }
-
-        return this.createErrorReport(error);
-    }
-
-    private createErrorReportFromError(error: Error | JSError, defaults: Partial<ErrorReport> = {}): ErrorReport {
-        return {
-            title: error.name,
-            description: error.message,
-            details: error.stack,
-            error,
-            ...defaults,
-        };
-    }
-
-}
-
-export default facade(new ErrorsService());

package/src/errors/index.ts

@@ -1,21 +0,0 @@
-import { bootServices } from '@/services';
-import { definePlugin } from '@/plugins';
-
-import Errors from './Errors';
-import { ErrorReport, ErrorReportLog, ErrorSource } from './Errors.state';
-
-export { Errors, ErrorSource, ErrorReport, ErrorReportLog };
-
-const services = { $errors: Errors };
-
-export type ErrorsServices = typeof services;
-
-export default definePlugin({
-    async install(app) {
-        await bootServices(app, services);
-    },
-});
-
-declare module '@/services' {
-    interface Services extends ErrorsServices {}
-}

package/src/lang/utils.ts

@@ -1,4 +0,0 @@
-import Lang from './Lang';
-
-export const translate = Lang.translate.bind(Lang);
-export const translateWithDefault = Lang.translateWithDefault.bind(Lang);

package/src/services/store.ts

@@ -1,27 +0,0 @@
-import { createPinia, defineStore, setActivePinia } from 'pinia';
-import type { DefineStoreOptions, Pinia, StateTree, Store, _GettersTree } from 'pinia';
-
-let _store: Pinia | null = null;
-
-function initializePiniaStore(): Pinia {
-    if (!_store) {
-        _store = createPinia();
-
-        setActivePinia(_store);
-    }
-
-    return _store;
-}
-
-export function getPiniaStore(): Pinia {
-    return _store ?? initializePiniaStore();
-}
-
-export function defineServiceStore<Id extends string, S extends StateTree = {}, G extends _GettersTree<S> = {}, A = {}>(
-    name: Id,
-    options: Omit<DefineStoreOptions<Id, S, G, A>, 'id'>,
-): Store<Id, S, G, A> {
-    initializePiniaStore();
-
-    return defineStore(name, options)();
-}

package/src/utils/composition/forms.ts

@@ -1,11 +0,0 @@
-import { objectWithout } from '@noeldemartin/utils';
-import { computed, useAttrs } from 'vue';
-import type { ComputedRef } from 'vue';
-
-export function useInputAttrs(): [ComputedRef<{}>, ComputedRef<unknown>] {
-    const attrs = useAttrs();
-    const className = computed(() => attrs.class);
-    const inputAttrs = computed(() => objectWithout(attrs, 'class'));
-
-    return [inputAttrs, className];
-}