@aerogel/core 0.0.0-next.7f6ed5a1f91688a86bf5ede2adc465e4fd6cfdea → 0.0.0-next.b85327579d32f21c6a9fa21142f0165cdd320d7e

package/src/components/headless/modals/AGHeadlessModalPanel.vue

@@ -1,7 +1,11 @@
 <template>
     <DialogPanel>
         <slot />
-        <AGModalContext v-if="childModal" :child-index="modal.childIndex + 1" :modal="childModal" />
+
+        <template v-if="childModal">
+            <div class="pointer-events-none fixed inset-0 z-50 bg-black/30" />
+            <AGModalContext :child-index="modal.childIndex + 1" :modal="childModal" />
+        </template>
     </DialogPanel>
 </template>
 
@@ -15,6 +19,10 @@ import type { IAGModalContext } from '@/components/modals/AGModalContext';
 
 import AGModalContext from '../../modals/AGModalContext.vue';
 
-const modal = injectReactiveOrFail<IAGModalContext>('modal');
+const modal = injectReactiveOrFail<IAGModalContext>(
+    'modal',
+    'could not obtain modal reference from <AGHeadlessModalPanel>, ' +
+        'did you render this component manually? Show it using $ui.openModal() instead',
+);
 const childModal = computed(() => UI.modals[modal.childIndex] ?? null);
 </script>

package/src/components/index.ts

@@ -1,6 +1,7 @@
 import AGAppLayout from './AGAppLayout.vue';
+import AGAppOverlays from './AGAppOverlays.vue';
 
-export { AGAppLayout };
+export { AGAppLayout, AGAppOverlays };
 
 export * from './basic';
 export * from './forms';

package/src/components/modals/AGAlertModal.vue

@@ -1,15 +1,26 @@
 <template>
     <AGModal>
+        <AGMarkdown
+            v-if="title"
+            :text="title"
+            as="h2"
+            class="font-semibold"
+            raw
+            inline
+        />
         <AGMarkdown :text="message" />
     </AGModal>
 </template>
 
 <script setup lang="ts">
-import { requiredStringProp } from '@/utils/vue';
+import { requiredStringProp, stringProp } from '@/utils/vue';
 
 import AGModal from './AGModal.vue';
 
 import AGMarkdown from '../basic/AGMarkdown.vue';
 
-defineProps({ message: requiredStringProp() });
+defineProps({
+    title: stringProp(),
+    message: requiredStringProp(),
+});
 </script>

package/src/components/modals/AGConfirmModal.vue

@@ -0,0 +1,30 @@
+<template>
+    <AGModal v-slot="{ close }: IAGModalDefaultSlotProps" :cancellable="false">
+        <AGMarkdown v-if="title" :text="title" as="h1" />
+        <AGMarkdown :text="message" />
+
+        <div class="mt-2 flex flex-row-reverse gap-2">
+            <AGButton @click="close(true)">
+                {{ $td('ui.ok', 'OK') }}
+            </AGButton>
+            <AGButton secondary @click="close()">
+                {{ $td('ui.cancel', 'Cancel') }}
+            </AGButton>
+        </div>
+    </AGModal>
+</template>
+
+<script setup lang="ts">
+import { requiredStringProp, stringProp } from '@/utils/vue';
+
+import AGModal from './AGModal.vue';
+import type { IAGModalDefaultSlotProps } from './AGModal';
+
+import AGButton from '../forms/AGButton.vue';
+import AGMarkdown from '../basic/AGMarkdown.vue';
+
+defineProps({
+    title: stringProp(),
+    message: requiredStringProp(),
+});
+</script>

package/src/components/modals/AGLoadingModal.vue

@@ -0,0 +1,19 @@
+<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/components/modals/AGModal.ts

@@ -4,3 +4,7 @@ export interface IAGModal {
     cancellable: Ref<boolean>;
     close(): Promise<void>;
 }
+
+export interface IAGModalDefaultSlotProps {
+    close(result?: unknown): Promise<void>;
+}

package/src/components/modals/AGModal.vue

@@ -1,5 +1,10 @@
 <template>
-    <AGHeadlessModal v-slot="{ close }: IAGHeadlessModalDefaultSlotProps" class="relative z-50">
+    <AGHeadlessModal
+        ref="$headlessModal"
+        v-slot="{ close }: IAGHeadlessModalDefaultSlotProps"
+        :cancellable="cancellable"
+        class="relative z-50"
+    >
         <div class="fixed inset-0 flex items-center justify-center">
             <AGHeadlessModalPanel class="flex max-h-full max-w-full flex-col overflow-hidden bg-white">
                 <div class="flex max-h-full flex-col overflow-auto p-4">
@@ -11,8 +16,21 @@
 </template>
 
 <script setup lang="ts">
-import type { IAGHeadlessModalDefaultSlotProps } from '@/components/headless/modals/AGHeadlessModal';
+import { computed, ref } from 'vue';
+
+import { booleanProp } from '@/utils';
+import type { IAGHeadlessModal, IAGHeadlessModalDefaultSlotProps } from '@/components/headless/modals/AGHeadlessModal';
+
+import type { IAGModal } from './AGModal';
 
 import AGHeadlessModal from '../headless/modals/AGHeadlessModal.vue';
 import AGHeadlessModalPanel from '../headless/modals/AGHeadlessModalPanel.vue';
+
+const $headlessModal = ref<IAGHeadlessModal>();
+
+defineProps({ cancellable: booleanProp(true) });
+defineExpose<IAGModal>({
+    close: async () => $headlessModal.value?.close(),
+    cancellable: computed(() => !!$headlessModal.value?.cancellable),
+});
 </script>

package/src/components/modals/index.ts

@@ -1,5 +1,8 @@
+import AGAlertModal from './AGAlertModal.vue';
+import AGConfirmModal from './AGConfirmModal.vue';
+import AGLoadingModal from './AGLoadingModal.vue';
 import AGModal from './AGModal.vue';
 import AGModalContext from './AGModalContext.vue';
 import { IAGModal } from './AGModal';
 
-export { AGModal, AGModalContext, IAGModal };
+export { AGAlertModal, AGConfirmModal, AGModal, AGModalContext, AGLoadingModal, IAGModal };

package/src/directives/index.ts

@@ -1,6 +1,6 @@
 import type { Directive } from 'vue';
 
-import { defineBootstrapHook } from '@/bootstrap/hooks';
+import { definePlugin } from '@/plugins';
 
 import initialFocus from './initial-focus';
 
@@ -8,6 +8,8 @@ const directives: Record<string, Directive> = {
     'initial-focus': initialFocus,
 };
 
-export default defineBootstrapHook(async (app) => {
-    Object.entries(directives).forEach(([name, directive]) => app.directive(name, directive));
+export default definePlugin({
+    install(app) {
+        Object.entries(directives).forEach(([name, directive]) => app.directive(name, directive));
+    },
 });

package/src/errors/Errors.state.ts

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,132 @@
+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

@@ -0,0 +1,21 @@
+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' {
+    export interface Services extends ErrorsServices {}
+}

package/src/forms/Form.test.ts

@@ -34,4 +34,25 @@ describe('Form', () => {
         expect(form.errors.name).toEqual(['required']);
     });
 
+    it('resets form', () => {
+        // Arrange
+        const form = useForm({
+            name: {
+                type: FormFieldTypes.String,
+                rules: 'required',
+            },
+        });
+
+        form.name = 'Foo bar';
+        form.submit();
+
+        // Act
+        form.reset();
+
+        // Assert
+        expect(form.valid).toBe(true);
+        expect(form.submitted).toBe(false);
+        expect(form.name).toBeNull();
+    });
+
 });

package/src/forms/Form.ts

@@ -1,11 +1,12 @@
 import { MagicObject } from '@noeldemartin/utils';
-import { reactive, readonly, ref } from 'vue';
+import { computed, reactive, readonly, ref } from 'vue';
 import type { ObjectValues } from '@noeldemartin/utils';
-import type { DeepReadonly, Ref, UnwrapNestedRefs } from 'vue';
+import type { ComputedRef, DeepReadonly, Ref, UnwrapNestedRefs } from 'vue';
 
 export const FormFieldTypes = {
     String: 'string',
     Number: 'number',
+    Boolean: 'boolean',
 } as const;
 
 export interface FormFieldDefinition<TType extends FormFieldType = FormFieldType, TRules extends string = string> {
@@ -18,7 +19,7 @@ export type FormFieldDefinitions = Record<string, FormFieldDefinition>;
 export type FormFieldType = ObjectValues<typeof FormFieldTypes>;
 
 export type FormData<T> = {
-    [k in keyof T]: T[k] extends FormFieldDefinition<infer TType, infer TRules>
+    -readonly [k in keyof T]: T[k] extends FormFieldDefinition<infer TType, infer TRules>
         ? TRules extends 'required'
             ? GetFormFieldValue<TType>
             : GetFormFieldValue<TType> | null
@@ -33,6 +34,8 @@ export type GetFormFieldValue<TType> = TType extends typeof FormFieldTypes.Strin
     ? string
     : TType extends typeof FormFieldTypes.Number
     ? number
+    : TType extends typeof FormFieldTypes.Boolean
+    ? boolean
     : never;
 
 export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinitions> extends MagicObject {
@@ -41,7 +44,7 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
 
     private _fields: Fields;
     private _data: FormData<Fields>;
-    private _valid: Ref<boolean>;
+    private _valid: ComputedRef<boolean>;
     private _submitted: Ref<boolean>;
     private _errors: FormErrors<Fields>;
 
@@ -50,9 +53,9 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
 
         this._fields = fields;
         this._submitted = ref(false);
-        this._valid = ref(true);
         this._data = this.getInitialData(fields);
         this._errors = this.getInitialErrors(fields);
+        this._valid = computed(() => !Object.values(this._errors).some((error) => error !== null));
 
         this.errors = readonly(this._errors);
     }
@@ -78,15 +81,22 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
     }
 
     public validate(): boolean {
-        const errors = Object.entries(this._fields).reduce((errors, [name, definition]) => {
-            errors[name] = this.getFieldErrors(name, definition);
+        const errors = Object.entries(this._fields).reduce((formErrors, [name, definition]) => {
+            formErrors[name] = this.getFieldErrors(name, definition);
 
-            return errors;
+            return formErrors;
         }, {} as Record<string, string[] | null>);
 
-        Object.assign(this._errors, errors);
+        this.resetErrors(errors);
 
-        return (this._valid.value = !Object.values(errors).some((error) => error !== null));
+        return this.valid;
+    }
+
+    public reset(): void {
+        this._submitted.value = false;
+
+        this.resetData();
+        this.resetErrors();
     }
 
     public submit(): boolean {
@@ -128,10 +138,10 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
             return {} as FormData<Fields>;
         }
 
-        const data = Object.entries(fields).reduce((data, [name, definition]) => {
-            data[name as keyof Fields] = (definition.default ?? null) as FormData<Fields>[keyof Fields];
+        const data = Object.entries(fields).reduce((formData, [name, definition]) => {
+            formData[name as keyof Fields] = (definition.default ?? null) as FormData<Fields>[keyof Fields];
 
-            return data;
+            return formData;
         }, {} as FormData<Fields>);
 
         return reactive(data) as FormData<Fields>;
@@ -142,13 +152,25 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
             return {} as FormErrors<Fields>;
         }
 
-        const errors = Object.keys(fields).reduce((errors, name) => {
-            errors[name as keyof Fields] = null;
+        const errors = Object.keys(fields).reduce((formErrors, name) => {
+            formErrors[name as keyof Fields] = null;
 
-            return errors;
+            return formErrors;
         }, {} as FormErrors<Fields>);
 
         return reactive(errors) as FormErrors<Fields>;
     }
 
+    private resetData(): void {
+        for (const [name, field] of Object.entries(this._fields)) {
+            this._data[name as keyof Fields] = (field.default ?? null) as FormData<Fields>[keyof Fields];
+        }
+    }
+
+    private resetErrors(errors?: Record<string, string[] | null>): void {
+        Object.keys(this._errors).forEach((key) => delete this._errors[key as keyof Fields]);
+
+        errors && Object.assign(this._errors, errors);
+    }
+
 }

package/src/forms/utils.ts

@@ -1,6 +1,23 @@
 import { FormFieldTypes } from './Form';
 import type { FormFieldDefinition } from './Form';
 
+export function booleanInput(defaultValue?: boolean): FormFieldDefinition<typeof FormFieldTypes.Boolean> {
+    return {
+        default: defaultValue,
+        type: FormFieldTypes.Boolean,
+    };
+}
+
+export function requiredBooleanInput(
+    defaultValue?: boolean,
+): FormFieldDefinition<typeof FormFieldTypes.Boolean, 'required'> {
+    return {
+        default: defaultValue,
+        type: FormFieldTypes.Boolean,
+        rules: 'required',
+    };
+}
+
 export function requiredNumberInput(
     defaultValue?: number,
 ): FormFieldDefinition<typeof FormFieldTypes.Number, 'required'> {

package/src/globals.ts

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

package/src/lang/Lang.ts

@@ -1,19 +1,58 @@
-import { useI18n } from 'vue-i18n';
-import { facade } from '@noeldemartin/utils';
-import type { Composer } from 'vue-i18n';
+import { facade, toString } from '@noeldemartin/utils';
 
+import App from '@/services/App';
 import Service from '@/services/Service';
 
+export interface LangProvider {
+    translate(key: string, parameters?: Record<string, unknown>): string;
+}
+
 export class LangService extends Service {
 
-    private i18n?: Composer;
+    private provider: LangProvider;
+
+    constructor() {
+        super();
+
+        this.provider = {
+            translate: (key) => {
+                // eslint-disable-next-line no-console
+                App.isDevelopment && console.warn('Lang provider is missing');
+
+                return key;
+            },
+        };
+    }
 
-    public setup(): void {
-        this.i18n = useI18n();
+    public setProvider(provider: LangProvider): void {
+        this.provider = provider;
     }
 
-    public translate(key: string, parameters: Record<string, unknown> = {}): string {
-        return this.i18n?.t(key, parameters) ?? key;
+    public translate(key: string, parameters?: Record<string, unknown>): 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,
+    ): 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;
     }
 
 }