@aerogel/core 0.0.0-next.c8f032a868370824898e171969aec1bb6827688e → 0.0.0-next.d824b40e5d06757cd9f47c9f771d916185df4f05

package/src/plugins/index.ts

@@ -1,3 +1,7 @@
+import type { GetClosureArgs } from '@noeldemartin/utils';
+
+import App from '@/services/App';
+
 import type { Plugin } from './Plugin';
 
 export * from './Plugin';
@@ -5,3 +9,18 @@ export * from './Plugin';
 export function definePlugin<T extends Plugin>(plugin: T): T {
     return plugin;
 }
+
+export async function installPlugins(plugins: Plugin[], ...args: GetClosureArgs<Plugin['install']>): Promise<void> {
+    App.setState(
+        'plugins',
+        plugins.reduce((pluginsMap, plugin) => {
+            if (plugin.name) {
+                pluginsMap[plugin.name] = plugin;
+            }
+
+            return pluginsMap;
+        }, {} as Record<string, Plugin>),
+    );
+
+    await Promise.all(plugins.map((plugin) => plugin.install(...args)) ?? []);
+}

package/src/services/App.state.ts

@@ -1,10 +1,18 @@
+import Build from 'virtual:aerogel';
+
 import { defineServiceState } from '@/services/Service';
+import type { Plugin } from '@/plugins/Plugin';
 
 export default defineServiceState({
+    name: 'app',
     initialState: {
-        environment: __AG_ENV,
+        plugins: {} as Record<string, Plugin>,
+        environment: Build.environment,
+        sourceUrl: Build.sourceUrl,
+        isMounted: false,
     },
     computed: {
-        isDevelopment: (state) => state.environment === 'development',
+        development: (state) => state.environment === 'development',
+        testing: (state) => state.environment === 'testing',
     },
 });

package/src/services/App.ts

@@ -1,7 +1,20 @@
 import { facade } from '@noeldemartin/utils';
 
+import Events from '@/services/Events';
+import type { Plugin } from '@/plugins';
+
 import Service from './App.state';
 
-export class AppService extends Service {}
+export class AppService extends Service {
+
+    public plugin<T extends Plugin = Plugin>(name: string): T | null {
+        return (this.plugins[name] as T) ?? null;
+    }
+
+    protected async boot(): Promise<void> {
+        Events.once('application-mounted', () => this.setState({ isMounted: true }));
+    }
+
+}
 
 export default facade(new AppService());

package/src/services/Service.ts

@@ -1,27 +1,42 @@
-import { computed, reactive } from 'vue';
-import { MagicObject, PromisedValue } from '@noeldemartin/utils';
-import type { ComputedRef } from 'vue';
+import { MagicObject, PromisedValue, Storage, isEmpty, objectDeepClone, objectOnly } from '@noeldemartin/utils';
 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 = {};
+export type DefaultServiceState = any; // eslint-disable-line @typescript-eslint/no-explicit-any
 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>;
-}): Constructor<State> & Constructor<ComputedState> & ServiceConstructor {
+    serialize?: (state: Partial<State>) => Partial<State>;
+}): Constructor<State> & Constructor<ComputedState> & Constructor<Service<State, ComputedState, Partial<State>>> {
     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;
         }
@@ -29,47 +44,57 @@ 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> & ServiceConstructor;
+    } as unknown as Constructor<State> &
+        Constructor<ComputedState> &
+        Constructor<Service<State, ComputedState, Partial<State>>>;
 }
 
 export default class Service<
     State extends ServiceState = DefaultServiceState,
-    ComputedState extends ServiceState = {}
+    ComputedState extends ServiceState = {},
+    ServiceStorage extends Partial<State> = Partial<State>
 > extends MagicObject {
 
-    protected _namespace: string;
+    public static persist: string[] = [];
+
+    protected _name: string;
     private _booted: PromisedValue<void>;
-    private _state: State;
-    private _computedState: Record<keyof ComputedState, ComputedRef>;
+    private _computedStateKeys: Set<keyof State>;
+    private _store?: Store | false;
 
     constructor() {
         super();
 
-        this._namespace = new.target.name;
-        this._booted = new PromisedValue();
-        this._state = reactive(this.getInitialState());
-        this._computedState = Object.entries(this.getComputedStateDefinition()).reduce(
-            (computedState, [name, method]) => {
-                computedState[name as keyof ComputedState] = computed(() => method(this._state));
+        const getters = this.getComputedStateDefinition();
 
-                return computedState;
-            },
-            {} as Record<keyof ComputedState, ComputedRef>,
-        );
+        this._name = this.getName() ?? 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,
+            });
     }
 
     public get booted(): PromisedValue<void> {
         return this._booted;
     }
 
-    public launch(namespace?: string): Promise<void> {
-        const handleError = (error: unknown) => this._booted.reject(new ServiceBootError(this._namespace, error));
-
-        this._namespace = namespace ?? this._namespace;
+    public launch(): Promise<void> {
+        const handleError = (error: unknown) => this._booted.reject(new ServiceBootError(this._name, error));
 
         try {
-            this.boot()
+            this.frameworkBoot()
+                .then(() => this.boot())
                 .then(() => this._booted.resolve())
                 .catch(handleError);
         } catch (error) {
@@ -79,15 +104,48 @@ 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);
     }
 
@@ -95,26 +153,29 @@ export default class Service<
         this.setState({ [property]: value } as Partial<State>);
     }
 
-    protected hasState<P extends keyof State>(property: P): boolean {
-        return property in this._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);
 
-    protected hasComputedState<P extends keyof State>(property: P): boolean {
-        return property in this._computedState;
-    }
+        if (isEmpty(persisted)) {
+            return;
+        }
 
-    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;
+        const storage = Storage.require<ServiceStorage>(this._name);
+
+        Storage.set(this._name, {
+            ...storage,
+            ...this.serializePersistedState(objectDeepClone(persisted) as Partial<State>),
+        });
     }
 
-    protected getComputedState<P extends keyof ComputedState>(property: P): ComputedState[P] {
-        return this._computedState[property]?.value;
+    protected usesStore(): boolean {
+        return false;
     }
 
-    protected setState(state: Partial<State>): void {
-        Object.assign(this._state, state);
+    protected getName(): string | null {
+        return null;
     }
 
     protected getInitialState(): State {
@@ -125,8 +186,34 @@ export default class Service<
         return {} as ComputedStateDefinition<State, ComputedState>;
     }
 
+    protected serializePersistedState(state: Partial<State>): Partial<State> {
+        return state;
+    }
+
+    protected async frameworkBoot(): Promise<void> {
+        this.restorePersistedState();
+    }
+
     protected async boot(): Promise<void> {
-        //
+        // Override.
+    }
+
+    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,6 +5,7 @@ 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,20 +25,36 @@ 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 ([name, service]) => {
-            // eslint-disable-next-line no-console
-            await service.launch(name.slice(1)).catch((error) => console.error(error));
+            await service
+                .launch()
+                .catch((error) => app.config.errorHandler?.(error, null, `Failed launching ${name}.`));
         }),
     );
 
     Object.assign(app.config.globalProperties, services);
+
+    App.development && Object.assign(window, services);
 }
 
 export default definePlugin({
-    async install(app) {
-        await bootServices(app, defaultServices);
+    async install(app, options) {
+        const services = {
+            ...defaultServices,
+            ...options.services,
+        };
+
+        app.use(getPiniaStore());
+
+        await bootServices(app, services);
     },
 });
 
+declare module '@/bootstrap/options' {
+    interface AerogelOptions {
+        services?: Record<string, Service>;
+    }
+}
+
 declare module '@vue/runtime-core' {
     interface ComponentCustomProperties extends Services {}
 }

package/src/services/store.ts

@@ -0,0 +1,27 @@
+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/types/virtual.d.ts

@@ -0,0 +1,11 @@
+declare module 'virtual:aerogel' {
+    interface AerogelBuild {
+        environment: 'production' | 'development' | 'testing';
+        basePath?: string;
+        sourceUrl?: string;
+    }
+
+    const build: AerogelBuild;
+
+    export default build;
+}

package/src/ui/UI.state.ts

@@ -17,6 +17,16 @@ export interface ModalComponent<
     Result = unknown
 > {}
 
+export interface Snackbar {
+    id: string;
+    component: Component;
+    properties: Record<string, unknown>;
+}
+
 export default defineServiceState({
-    initialState: { modals: [] as Modal[] },
+    name: 'ui',
+    initialState: {
+        modals: [] as Modal[],
+        snackbars: [] as Snackbar[],
+    },
 });

package/src/ui/UI.ts

@@ -4,9 +4,10 @@ import type { Component } from 'vue';
 import type { ObjectValues } from '@noeldemartin/utils';
 
 import Events from '@/services/Events';
+import type { SnackbarAction, SnackbarColor } from '@/components/headless/snackbars';
 
 import Service from './UI.state';
-import type { Modal, ModalComponent } from './UI.state';
+import type { Modal, ModalComponent, Snackbar } from './UI.state';
 
 interface ModalCallbacks<T = unknown> {
     willClose(result: T | undefined): void;
@@ -21,15 +22,28 @@ type ModalResult<TComponent> = TComponent extends ModalComponent<Record<string,
 export const UIComponents = {
     AlertModal: 'alert-modal',
     ConfirmModal: 'confirm-modal',
+    ErrorReportModal: 'error-report-modal',
+    LoadingModal: 'loading-modal',
+    Snackbar: 'snackbar',
 } as const;
 
 export type UIComponent = ObjectValues<typeof UIComponents>;
 
+export interface ShowSnackbarOptions {
+    component?: Component;
+    color?: SnackbarColor;
+    actions?: SnackbarAction[];
+}
+
 export class UIService extends Service {
 
     private modalCallbacks: Record<string, Partial<ModalCallbacks>> = {};
     private components: Partial<Record<UIComponent, Component>> = {};
 
+    public requireComponent(name: UIComponent): Component {
+        return this.components[name] ?? fail(`UI Component '${name}' is not defined!`);
+    }
+
     public alert(message: string): void;
     public alert(title: string, message: string): void;
     public alert(messageOrTitle: string, message?: string): void {
@@ -51,6 +65,39 @@ 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 showSnackbar(message: string, options: ShowSnackbarOptions = {}): void {
+        const snackbar: Snackbar = {
+            id: uuid(),
+            properties: { message, ...options },
+            component: options.component ?? markRaw(this.requireComponent(UIComponents.Snackbar)),
+        };
+
+        this.setState('snackbars', this.snackbars.concat(snackbar));
+
+        setTimeout(() => this.hideSnackbar(snackbar.id), 5000);
+    }
+
+    public hideSnackbar(id: string): void {
+        this.setState(
+            'snackbars',
+            this.snackbars.filter((snackbar) => snackbar.id !== id),
+        );
+    }
+
     public registerComponent(name: UIComponent, component: Component): void {
         this.components[name] = component;
     }
@@ -90,15 +137,9 @@ export class UIService extends Service {
     }
 
     protected async boot(): Promise<void> {
-        await super.boot();
-
         this.watchModalEvents();
     }
 
-    private requireComponent(name: UIComponent): Component {
-        return this.components[name] ?? fail(`UI Component '${name}' is not defined!`);
-    }
-
     private watchModalEvents(): void {
         Events.on('modal-will-close', ({ modal, result }) => {
             this.modalCallbacks[modal.id]?.willClose?.(result);
@@ -109,7 +150,10 @@ export class UIService extends Service {
         });
 
         Events.on('modal-closed', async ({ modal, result }) => {
-            this.setState({ modals: this.modals.filter((m) => m.id !== modal.id) });
+            this.setState(
+                'modals',
+                this.modals.filter((m) => m.id !== modal.id),
+            );
 
             this.modalCallbacks[modal.id]?.closed?.(result);
 

package/src/ui/index.ts

@@ -6,6 +6,9 @@ import { definePlugin } from '@/plugins';
 import UI, { UIComponents } from './UI';
 import AGAlertModal from '../components/modals/AGAlertModal.vue';
 import AGConfirmModal from '../components/modals/AGConfirmModal.vue';
+import AGErrorReportModal from '../components/modals/AGErrorReportModal.vue';
+import AGLoadingModal from '../components/modals/AGLoadingModal.vue';
+import AGSnackbar from '../components/snackbars/AGSnackbar.vue';
 import type { UIComponent } from './UI';
 
 export { UI, UIComponents, UIComponent };
@@ -19,6 +22,9 @@ export default definePlugin({
         const defaultComponents = {
             [UIComponents.AlertModal]: AGAlertModal,
             [UIComponents.ConfirmModal]: AGConfirmModal,
+            [UIComponents.ErrorReportModal]: AGErrorReportModal,
+            [UIComponents.LoadingModal]: AGLoadingModal,
+            [UIComponents.Snackbar]: AGSnackbar,
         };
 
         Object.entries({
@@ -37,5 +43,5 @@ declare module '@/bootstrap/options' {
 }
 
 declare module '@/services' {
-    interface Services extends UIServices {}
+    export interface Services extends UIServices {}
 }

package/src/utils/composition/forms.ts

@@ -0,0 +1,11 @@
+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];
+}

package/src/utils/index.ts

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

package/src/utils/markdown.ts

@@ -1,8 +1,17 @@
+import { tap } from '@noeldemartin/utils';
 import DOMPurify from 'dompurify';
-import { marked } from 'marked';
+import { Renderer, marked } from 'marked';
+
+function makeRenderer(): Renderer {
+    return tap(new Renderer(), (renderer) => {
+        renderer.link = function(href, title, text) {
+            return Renderer.prototype.link.apply(this, [href, title, text]).replace('<a', '<a target="_blank"');
+        };
+    });
+}
 
 export function renderMarkdown(markdown: string): string {
-    return safeHtml(marked(markdown, { mangle: false, headerIds: false }));
+    return safeHtml(marked(markdown, { mangle: false, headerIds: false, renderer: makeRenderer() }));
 }
 
 export function safeHtml(html: string): string {

package/src/utils/vue.ts

@@ -10,6 +10,8 @@ type BaseProp<T> = {
 type RequiredProp<T> = BaseProp<T> & { required: true };
 type OptionalProp<T> = BaseProp<T> & { default: T | (() => T) | null };
 
+export type ComponentProps = Record<string, unknown>;
+
 export function arrayProp<T>(defaultValue?: () => T[]): OptionalProp<T[]> {
     return {
         type: Array as PropType<T[]>,

package/tsconfig.json

@@ -1,6 +1,7 @@
 {
     "extends": "../../tsconfig.json",
     "compilerOptions": {
+        "types": ["unplugin-icons/types/vue3"],
         "baseUrl": ".",
         "paths": {
             "@/*": ["./src/*"]

package/vite.config.ts

@@ -1,10 +1,11 @@
 import Aerogel from '@aerogel/vite';
+import Icons from 'unplugin-icons/vite';
 import { defineConfig } from 'vitest/config';
 import { resolve } from 'path';
 
 export default defineConfig({
     test: { clearMocks: true },
-    plugins: [Aerogel()],
+    plugins: [Aerogel(), Icons()],
     resolve: {
         alias: {
             '@': resolve(__dirname, './src'),

package/src/globals.ts

@@ -1,6 +0,0 @@
-export {};
-
-declare global {
-    export const __AG_BASE_PATH: string | undefined;
-    export const __AG_ENV: 'production' | 'development' | 'testing';
-}