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

package/src/errors/Errors.ts

@@ -1,11 +1,12 @@
-import { JSError, facade, isObject } from '@noeldemartin/utils';
+import { JSError, facade, isObject, objectWithoutEmpty, toString } from '@noeldemartin/utils';
 
 import App from '@/services/App';
 import ServiceBootError from '@/errors/ServiceBootError';
-import UI from '@/ui/UI';
-import { translate } from '@/lang/utils';
+import UI, { UIComponents } from '@/ui/UI';
+import { translateWithDefault } from '@/lang/utils';
 
 import Service from './Errors.state';
+import { Colors } from '@/components/constants';
 import type { ErrorReport, ErrorReportLog, ErrorSource } from './Errors.state';
 
 export class ErrorsService extends Service {
@@ -24,12 +25,17 @@ export class ErrorsService extends Service {
     public async inspect(error: ErrorSource | ErrorReport[]): Promise<void> {
         const reports = Array.isArray(error) ? error : [await this.createErrorReport(error)];
 
-        // TODO open errors modal
-        reports;
+        if (reports.length === 0) {
+            UI.alert(translateWithDefault('errors.inspectEmpty', 'Nothing to inspect!'));
+
+            return;
+        }
+
+        UI.openModal(UI.requireComponent(UIComponents.ErrorReportModal), { reports });
     }
 
     public async report(error: ErrorSource, message?: string): Promise<void> {
-        if (App.isDevelopment || App.isTesting) {
+        if (App.development || App.testing) {
             this.logError(error);
         }
 
@@ -54,8 +60,23 @@ export class ErrorsService extends Service {
             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)');
+        UI.showSnackbar(
+            message ??
+                translateWithDefault('errors.notice', 'Something went wrong, but it\'s not your fault. Try again!'),
+            {
+                color: Colors.Danger,
+                actions: [
+                    {
+                        text: translateWithDefault('errors.viewDetails', 'View details'),
+                        dismiss: true,
+                        handler: () =>
+                            UI.openModal(UI.requireComponent(UIComponents.ErrorReportModal), {
+                                reports: [report],
+                            }),
+                    },
+                ],
+            },
+        );
 
         this.setState({ logs: [log].concat(this.logs) });
     }
@@ -84,6 +105,22 @@ export class ErrorsService extends Service {
         });
     }
 
+    public getErrorMessage(error: ErrorSource): string {
+        if (typeof error === 'string') {
+            return error;
+        }
+
+        if (error instanceof Error || error instanceof JSError) {
+            return error.message;
+        }
+
+        if (isObject(error)) {
+            return toString(error['message'] ?? error['description'] ?? 'Unknown error object');
+        }
+
+        return translateWithDefault('errors.unknown', 'Unknown Error');
+    }
+
     private logError(error: unknown): void {
         // eslint-disable-next-line no-console
         console.error(error);
@@ -102,8 +139,22 @@ export class ErrorsService extends Service {
             return this.createErrorReportFromError(error);
         }
 
+        if (isObject(error)) {
+            return objectWithoutEmpty({
+                title: toString(
+                    error['name'] ?? error['title'] ?? translateWithDefault('errors.unknown', 'Unknown Error'),
+                ),
+                description: toString(
+                    error['message'] ??
+                        error['description'] ??
+                        translateWithDefault('errors.unknownDescription', 'Unknown error object'),
+                ),
+                error,
+            });
+        }
+
         return {
-            title: translate('errors.unknown'),
+            title: translateWithDefault('errors.unknown', 'Unknown Error'),
             error,
         };
     }

package/src/errors/index.ts

@@ -1,3 +1,5 @@
+import { tap } from '@noeldemartin/utils';
+
 import { bootServices } from '@/services';
 import { definePlugin } from '@/plugins';
 
@@ -7,15 +9,51 @@ import { ErrorReport, ErrorReportLog, ErrorSource } from './Errors.state';
 export { Errors, ErrorSource, ErrorReport, ErrorReportLog };
 
 const services = { $errors: Errors };
+const frameworkHandler: ErrorHandler = (error) => {
+    if (!Errors.instance) {
+        // eslint-disable-next-line no-console
+        console.warn('Errors service hasn\'t been initialized properly!');
+
+        // eslint-disable-next-line no-console
+        console.error(error);
+
+        return true;
+    }
 
+    Errors.report(error);
+
+    return true;
+};
+
+function setUpErrorHandler(baseHandler: ErrorHandler = () => false): ErrorHandler {
+    return tap(
+        (error) => baseHandler(error) || frameworkHandler(error),
+        (errorHandler) => {
+            globalThis.onerror = (message, _, __, ___, error) => errorHandler(error ?? message);
+            globalThis.onunhandledrejection = (event) => errorHandler(event.reason);
+        },
+    );
+}
+
+export type ErrorHandler = (error: ErrorSource) => boolean;
 export type ErrorsServices = typeof services;
 
 export default definePlugin({
-    async install(app) {
+    async install(app, options) {
+        const errorHandler = setUpErrorHandler(options.handleError);
+
+        app.config.errorHandler = errorHandler;
+
         await bootServices(app, services);
     },
 });
 
+declare module '@/bootstrap/options' {
+    interface AerogelOptions {
+        handleError?(error: ErrorSource): boolean;
+    }
+}
+
 declare module '@/services' {
     export interface Services extends ErrorsServices {}
 }

package/src/forms/Form.ts

@@ -92,11 +92,11 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
         return this.valid;
     }
 
-    public reset(): void {
+    public reset(options: { keepData?: boolean; keepErrors?: boolean } = {}): void {
         this._submitted.value = false;
 
-        this.resetData();
-        this.resetErrors();
+        options.keepData || this.resetData();
+        options.keepErrors || this.resetErrors();
     }
 
     public submit(): boolean {

package/src/lang/Lang.ts

@@ -17,7 +17,7 @@ export class LangService extends Service {
         this.provider = {
             translate: (key) => {
                 // eslint-disable-next-line no-console
-                App.isDevelopment && console.warn('Lang provider is missing');
+                App.development && console.warn('Lang provider is missing');
 
                 return key;
             },

package/src/main.ts

@@ -1,5 +1,3 @@
-import './globals';
-
 export * from './bootstrap';
 export * from './components';
 export * from './errors';

package/src/plugins/Plugin.ts

@@ -3,5 +3,6 @@ import type { App } from 'vue';
 import type { AerogelOptions } from '@/bootstrap/options';
 
 export interface Plugin {
+    name?: string;
     install(app: App, options: AerogelOptions): void | Promise<void>;
 }

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,13 +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',
-        isTesting: (state) => state.environment === 'testing',
+        development: (state) => state.environment === 'development',
+        testing: (state) => state.environment === 'testing',
     },
 });

package/src/services/App.ts

@@ -1,14 +1,17 @@
 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 {
 
-    protected async boot(): Promise<void> {
-        await super.boot();
+    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 }));
     }
 

package/src/services/Service.ts

@@ -93,7 +93,8 @@ export default class Service<
         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) {
@@ -189,10 +190,14 @@ export default class Service<
         return state;
     }
 
-    protected async boot(): Promise<void> {
+    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;

package/src/services/index.ts

@@ -24,13 +24,16 @@ 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]) => {
-            // eslint-disable-next-line no-console
-            await service.launch().catch((error) => console.error(error));
+        Object.entries(services).map(async ([name, service]) => {
+            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({

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,7 +17,16 @@ export interface ModalComponent<
     Result = unknown
 > {}
 
+export interface Snackbar {
+    id: string;
+    component: Component;
+    properties: Record<string, unknown>;
+}
+
 export default defineServiceState({
     name: 'ui',
-    initialState: { modals: [] as Modal[] },
+    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,16 +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 {
@@ -66,6 +79,25 @@ export class UIService extends Service {
         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;
     }
@@ -105,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);
@@ -124,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,7 +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 };
@@ -20,7 +22,9 @@ export default definePlugin({
         const defaultComponents = {
             [UIComponents.AlertModal]: AGAlertModal,
             [UIComponents.ConfirmModal]: AGConfirmModal,
+            [UIComponents.ErrorReportModal]: AGErrorReportModal,
             [UIComponents.LoadingModal]: AGLoadingModal,
+            [UIComponents.Snackbar]: AGSnackbar,
         };
 
         Object.entries({

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';
-}