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

package/src/errors/Errors.ts

@@ -1,12 +1,16 @@
-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 { Events } from '@/services';
+import type { AGErrorReportModalProps } from '@/components/modals/AGErrorReportModal';
 import type { ErrorReport, ErrorReportLog, ErrorSource } from './Errors.state';
+import type { ModalComponent } from '@/ui/UI.state';
 
 export class ErrorsService extends Service {
 
@@ -22,14 +26,27 @@ export class ErrorsService extends Service {
     }
 
     public async inspect(error: ErrorSource | ErrorReport[]): Promise<void> {
-        const reports = Array.isArray(error) ? error : [await this.createErrorReport(error)];
+        const reports = Array.isArray(error) ? (error as ErrorReport[]) : [await this.createErrorReport(error)];
 
-        // TODO open errors modal
-        reports;
+        if (reports.length === 0) {
+            UI.alert(translateWithDefault('errors.inspectEmpty', 'Nothing to inspect!'));
+
+            return;
+        }
+
+        UI.openModal<ModalComponent<AGErrorReportModalProps>>(UI.requireComponent(UIComponents.ErrorReportModal), {
+            reports,
+        });
     }
 
     public async report(error: ErrorSource, message?: string): Promise<void> {
-        if (App.isDevelopment || App.isTesting) {
+        await Events.emit('error', { error, message });
+
+        if (App.testing) {
+            throw error;
+        }
+
+        if (App.development) {
             this.logError(error);
         }
 
@@ -37,7 +54,7 @@ export class ErrorsService extends Service {
             throw error;
         }
 
-        if (!App.isMounted) {
+        if (!App.isMounted()) {
             const startupError = await this.createStartupErrorReport(error);
 
             if (startupError) {
@@ -54,8 +71,24 @@ 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<ModalComponent<AGErrorReportModalProps>>(
+                                UI.requireComponent(UIComponents.ErrorReportModal),
+                                { reports: [report] },
+                            ),
+                    },
+                ],
+            },
+        );
 
         this.setState({ logs: [log].concat(this.logs) });
     }
@@ -102,8 +135,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,
         };
     }
@@ -129,4 +176,10 @@ export class ErrorsService extends Service {
 
 }
 
-export default facade(new ErrorsService());
+export default facade(ErrorsService);
+
+declare module '@/services/Events' {
+    export interface EventsPayload {
+        error: { error: ErrorSource; message?: string };
+    }
+}

package/src/errors/index.ts

@@ -1,21 +1,46 @@
+import type { App } from 'vue';
+
 import { bootServices } from '@/services';
 import { definePlugin } from '@/plugins';
 
 import Errors from './Errors';
 import { ErrorReport, ErrorReportLog, ErrorSource } from './Errors.state';
 
+export * from './utils';
 export { Errors, ErrorSource, ErrorReport, ErrorReportLog };
 
 const services = { $errors: Errors };
+const frameworkHandler: ErrorHandler = (error) => {
+    Errors.report(error);
+
+    return true;
+};
+
+function setUpErrorHandler(app: App, baseHandler: ErrorHandler = () => false): void {
+    const errorHandler: ErrorHandler = (error) => baseHandler(error) || frameworkHandler(error);
+
+    app.config.errorHandler = errorHandler;
+    globalThis.onerror = (event, _, __, ___, error) => errorHandler(error ?? event);
+    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) {
+        setUpErrorHandler(app, options.handleError);
+
         await bootServices(app, services);
     },
 });
 
+declare module '@/bootstrap/options' {
+    export interface AerogelOptions {
+        handleError?(error: ErrorSource): boolean;
+    }
+}
+
 declare module '@/services' {
     export interface Services extends ErrorsServices {}
 }

package/src/errors/utils.ts

@@ -0,0 +1,19 @@
+import { JSError, isObject, toString } from '@noeldemartin/utils';
+import { translateWithDefault } from '@/lang/utils';
+import type { ErrorSource } from './Errors.state';
+
+export function 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');
+}

package/src/forms/Form.ts

@@ -1,5 +1,5 @@
-import { MagicObject } from '@noeldemartin/utils';
-import { computed, reactive, readonly, ref } from 'vue';
+import { MagicObject, arrayRemove } from '@noeldemartin/utils';
+import { computed, nextTick, reactive, readonly, ref } from 'vue';
 import type { ObjectValues } from '@noeldemartin/utils';
 import type { ComputedRef, DeepReadonly, Ref, UnwrapNestedRefs } from 'vue';
 
@@ -7,6 +7,8 @@ export const FormFieldTypes = {
     String: 'string',
     Number: 'number',
     Boolean: 'boolean',
+    Object: 'object',
+    Date: 'date',
 } as const;
 
 export interface FormFieldDefinition<TType extends FormFieldType = FormFieldType, TRules extends string = string> {
@@ -17,6 +19,7 @@ export interface FormFieldDefinition<TType extends FormFieldType = FormFieldType
 
 export type FormFieldDefinitions = Record<string, FormFieldDefinition>;
 export type FormFieldType = ObjectValues<typeof FormFieldTypes>;
+export type FormFieldValue = GetFormFieldValue<FormFieldType>;
 
 export type FormData<T> = {
     -readonly [k in keyof T]: T[k] extends FormFieldDefinition<infer TType, infer TRules>
@@ -36,17 +39,26 @@ export type GetFormFieldValue<TType> = TType extends typeof FormFieldTypes.Strin
     ? number
     : TType extends typeof FormFieldTypes.Boolean
     ? boolean
+    : TType extends typeof FormFieldTypes.Object
+    ? object
+    : TType extends typeof FormFieldTypes.Date
+    ? Date
     : never;
 
+const validForms: WeakMap<Form, ComputedRef<boolean>> = new WeakMap();
+
+export type SubmitFormListener = () => unknown;
+export type FocusFormListener = (input: string) => unknown;
+
 export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinitions> extends MagicObject {
 
     public errors: DeepReadonly<UnwrapNestedRefs<FormErrors<Fields>>>;
 
     private _fields: Fields;
     private _data: FormData<Fields>;
-    private _valid: ComputedRef<boolean>;
     private _submitted: Ref<boolean>;
     private _errors: FormErrors<Fields>;
+    private _listeners: { focus?: FocusFormListener[]; submit?: SubmitFormListener[] } = {};
 
     constructor(fields: Fields) {
         super();
@@ -55,13 +67,17 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
         this._submitted = ref(false);
         this._data = this.getInitialData(fields);
         this._errors = this.getInitialErrors(fields);
-        this._valid = computed(() => !Object.values(this._errors).some((error) => error !== null));
+
+        validForms.set(
+            this,
+            computed(() => !Object.values(this._errors).some((error) => error !== null)),
+        );
 
         this.errors = readonly(this._errors);
     }
 
     public get valid(): boolean {
-        return this._valid.value;
+        return !!validForms.get(this)?.value;
     }
 
     public get submitted(): boolean {
@@ -80,6 +96,10 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
         return this._data[field] as unknown as GetFormFieldValue<Fields[T]['type']>;
     }
 
+    public data(): FormData<Fields> {
+        return { ...this._data };
+    }
+
     public validate(): boolean {
         const errors = Object.entries(this._fields).reduce((formErrors, [name, definition]) => {
             formErrors[name] = this.getFieldErrors(name, definition);
@@ -92,17 +112,45 @@ 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 {
         this._submitted.value = true;
 
-        return this.validate();
+        const valid = this.validate();
+
+        valid && this._listeners['submit']?.forEach((listener) => listener());
+
+        return valid;
+    }
+
+    public on(event: 'focus', listener: FocusFormListener): () => void;
+    public on(event: 'submit', listener: SubmitFormListener): () => void;
+    public on(event: 'focus' | 'submit', listener: FocusFormListener | SubmitFormListener): () => void {
+        this._listeners[event] ??= [];
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this._listeners[event]?.push(listener as any);
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return () => this.off(event as any, listener);
+    }
+
+    public off(event: 'focus', listener: FocusFormListener): void;
+    public off(event: 'submit', listener: SubmitFormListener): void;
+    public off(event: 'focus' | 'submit', listener: FocusFormListener | SubmitFormListener): void {
+        arrayRemove(this._listeners[event] ?? [], listener);
+    }
+
+    public async focus(input: string): Promise<void> {
+        await nextTick();
+
+        this._listeners['focus']?.forEach((listener) => listener(input));
     }
 
     protected __get(property: string): unknown {

package/src/forms/index.ts

@@ -1,3 +1,4 @@
 export * from './Form';
 export * from './composition';
 export * from './utils';
+export { default as Form } from './Form';

package/src/forms/utils.ts

@@ -8,6 +8,13 @@ export function booleanInput(defaultValue?: boolean): FormFieldDefinition<typeof
     };
 }
 
+export function dateInput(defaultValue?: Date): FormFieldDefinition<typeof FormFieldTypes.Date> {
+    return {
+        default: defaultValue,
+        type: FormFieldTypes.Date,
+    };
+}
+
 export function requiredBooleanInput(
     defaultValue?: boolean,
 ): FormFieldDefinition<typeof FormFieldTypes.Boolean, 'required'> {
@@ -18,6 +25,14 @@ export function requiredBooleanInput(
     };
 }
 
+export function requiredDateInput(defaultValue?: Date): FormFieldDefinition<typeof FormFieldTypes.Date> {
+    return {
+        default: defaultValue,
+        type: FormFieldTypes.Date,
+        rules: 'required',
+    };
+}
+
 export function requiredNumberInput(
     defaultValue?: number,
 ): FormFieldDefinition<typeof FormFieldTypes.Number, 'required'> {

package/src/jobs/Job.ts

@@ -0,0 +1,5 @@
+export default abstract class Job {
+
+    public abstract run(): Promise<void>;
+
+}

package/src/jobs/index.ts

@@ -0,0 +1,7 @@
+import Job from './Job';
+
+export { Job };
+
+export async function dispatch(job: Job): Promise<void> {
+    await job.run();
+}

package/src/lang/Lang.ts

@@ -1,10 +1,11 @@
-import { facade, toString } from '@noeldemartin/utils';
+import { facade } from '@noeldemartin/utils';
 
 import App from '@/services/App';
 import Service from '@/services/Service';
 
 export interface LangProvider {
-    translate(key: string, parameters?: Record<string, unknown>): string;
+    translate(key: string, parameters?: Record<string, unknown> | number): string;
+    translateWithDefault(key: string, defaultMessage: string, parameters?: Record<string, unknown> | number): string;
 }
 
 export class LangService extends Service {
@@ -17,10 +18,16 @@ 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;
             },
+            translateWithDefault: (_, defaultMessage) => {
+                // eslint-disable-next-line no-console
+                App.development && console.warn('Lang provider is missing');
+
+                return defaultMessage;
+            },
         };
     }
 
@@ -28,33 +35,18 @@ export class LangService extends Service {
         this.provider = provider;
     }
 
-    public translate(key: string, parameters?: Record<string, unknown>): string {
+    public translate(key: string, parameters?: Record<string, unknown> | number): string {
         return this.provider.translate(key, parameters) ?? key;
     }
 
-    public translateWithDefault(key: string, defaultMessage: string): string;
-    public translateWithDefault(key: string, parameters: Record<string, unknown>, defaultMessage: string): string;
     public translateWithDefault(
         key: string,
-        defaultMessageOrParameters?: string | Record<string, unknown>,
-        defaultMessage?: string,
+        defaultMessage: string,
+        parameters: Record<string, unknown> | number = {},
     ): string {
-        defaultMessage ??= defaultMessageOrParameters as string;
-
-        const parameters = typeof defaultMessageOrParameters === 'string' ? {} : defaultMessageOrParameters ?? {};
-        const message = this.provider.translate(key, parameters) ?? key;
-
-        if (message === key) {
-            return Object.entries(parameters).reduce(
-                (renderedMessage, [name, value]) =>
-                    renderedMessage.replace(new RegExp(`\\{\\s*${name}\\s*\\}`, 'g'), toString(value)),
-                defaultMessage,
-            );
-        }
-
-        return message;
+        return this.provider.translateWithDefault(key, defaultMessage, parameters);
     }
 
 }
 
-export default facade(new LangService());
+export default facade(LangService);

package/src/main.histoire.ts

@@ -0,0 +1 @@
+import './assets/histoire.css';

package/src/main.ts

@@ -1,11 +1,12 @@
-import './globals';
-
 export * from './bootstrap';
 export * from './components';
+export * from './directives';
 export * from './errors';
 export * from './forms';
+export * from './jobs';
 export * from './lang';
 export * from './plugins';
 export * from './services';
+export * from './testing';
 export * from './ui';
 export * from './utils';

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,31 @@
+import Aerogel from 'virtual:aerogel';
+
 import { defineServiceState } from '@/services/Service';
+import type { Plugin } from '@/plugins/Plugin';
 
 export default defineServiceState({
     name: 'app',
     initialState: {
-        environment: __AG_ENV,
-        isMounted: false,
+        plugins: {} as Record<string, Plugin>,
+        environment: Aerogel.environment,
+        version: Aerogel.version,
+        sourceUrl: Aerogel.sourceUrl,
     },
     computed: {
-        isDevelopment: (state) => state.environment === 'development',
-        isTesting: (state) => state.environment === 'testing',
+        development: (state) => state.environment === 'development',
+        testing: (state) => state.environment === 'test' || state.environment === 'testing',
+        versionName(state): string {
+            if (this.development) {
+                return 'dev.' + Aerogel.sourceHash.toString().substring(0, 7);
+            }
+
+            return `v${state.version}`;
+        },
+        versionUrl(state): string {
+            return (
+                state.sourceUrl +
+                (this.development ? `/tree/${Aerogel.sourceHash}` : `/releases/tag/${this.versionName}`)
+            );
+        },
     },
 });

package/src/services/App.ts

@@ -1,17 +1,50 @@
-import { facade } from '@noeldemartin/utils';
+import Aerogel from 'virtual:aerogel';
+
+import { PromisedValue, facade, forever, updateLocationQueryParameters } 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 readonly name = Aerogel.name;
+    public readonly ready = new PromisedValue<void>();
+    public readonly mounted = new PromisedValue<void>();
+
+    public isReady(): boolean {
+        return this.ready.isResolved();
+    }
+
+    public isMounted(): boolean {
+        return this.mounted.isResolved();
+    }
+
+    public async whenReady<T>(callback: () => T): Promise<T> {
+        const result = await this.ready.then(callback);
+
+        return result;
+    }
+
+    public async reload(queryParameters?: Record<string, string | undefined>): Promise<void> {
+        queryParameters && updateLocationQueryParameters(queryParameters);
+
+        location.reload();
+
+        // Stall until the reload happens
+        await forever();
+    }
+
+    public plugin<T extends Plugin = Plugin>(name: string): T | null {
+        return (this.plugins[name] as T) ?? null;
+    }
 
-        Events.once('application-mounted', () => this.setState({ isMounted: true }));
+    protected async boot(): Promise<void> {
+        Events.once('application-ready', () => this.ready.resolve());
+        Events.once('application-mounted', () => this.mounted.resolve());
     }
 
 }
 
-export default facade(new AppService());
+export default facade(AppService);

package/src/services/Cache.ts

@@ -0,0 +1,43 @@
+import { PromisedValue, facade, tap } from '@noeldemartin/utils';
+
+import Service from '@/services/Service';
+
+export class CacheService extends Service {
+
+    private cache?: PromisedValue<Cache> = undefined;
+
+    public async get(url: string): Promise<Response | null> {
+        const cache = await this.open();
+        const response = await cache.match(url);
+
+        return response ?? null;
+    }
+
+    public async store(url: string, response: Response): Promise<void> {
+        const cache = await this.open();
+
+        await cache.put(url, response);
+    }
+
+    public async replace(url: string, response: Response): Promise<void> {
+        const cache = await this.open();
+        const keys = await cache.keys(url);
+
+        if (keys.length === 0) {
+            return;
+        }
+
+        await cache.put(url, response);
+    }
+
+    protected async open(): Promise<Cache> {
+        return (this.cache =
+            this.cache ??
+            tap(new PromisedValue<Cache>(), (cache) => {
+                caches.open('app').then((instance) => cache.resolve(instance));
+            }));
+    }
+
+}
+
+export default facade(CacheService);

package/src/services/Events.test.ts

@@ -0,0 +1,39 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import Events, { EventListenerPriorities } from './Events';
+
+describe('Events', () => {
+
+    beforeEach(() => void Events.reset());
+
+    it('registers listeners', async () => {
+        // Arrange
+        let counter = 0;
+
+        Events.on('trigger', () => counter++);
+
+        // Act
+        await Events.emit('trigger');
+        await Events.emit('trigger');
+        await Events.emit('trigger');
+
+        // Assert
+        expect(counter).toEqual(3);
+    });
+
+    it('triggers listeners by priority', async () => {
+        // Arrange
+        const storage: string[] = [];
+
+        Events.on('trigger', () => storage.push('second'));
+        Events.on('trigger', { priority: EventListenerPriorities.Low }, () => storage.push('third'));
+        Events.on('trigger', { priority: EventListenerPriorities.High }, () => storage.push('first'));
+
+        // Act
+        await Events.emit('trigger');
+
+        // Assert
+        expect(storage).toEqual(['first', 'second', 'third']);
+    });
+
+});