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

package/src/ui/UI.ts

@@ -1,12 +1,18 @@
-import { facade, fail, uuid } from '@noeldemartin/utils';
+import { after, facade, fail, required, uuid } from '@noeldemartin/utils';
 import { markRaw, nextTick } from 'vue';
 import type { Component } from 'vue';
 import type { ObjectValues } from '@noeldemartin/utils';
 
+import App from '@/services/App';
 import Events from '@/services/Events';
+import type { AcceptRefs } from '@/utils';
+import type { Color } from '@/components/constants';
+import type { SnackbarAction, SnackbarColor } from '@/components/headless/snackbars';
+import type { AGAlertModalProps, AGConfirmModalProps, AGLoadingModalProps, AGPromptModalProps } from '@/components';
 
 import Service from './UI.state';
-import type { Modal, ModalComponent } from './UI.state';
+import { MOBILE_BREAKPOINT, getCurrentLayout } from './utils';
+import type { Modal, ModalComponent, Snackbar } from './UI.state';
 
 interface ModalCallbacks<T = unknown> {
     willClose(result: T | undefined): void;
@@ -21,49 +27,226 @@ type ModalResult<TComponent> = TComponent extends ModalComponent<Record<string,
 export const UIComponents = {
     AlertModal: 'alert-modal',
     ConfirmModal: 'confirm-modal',
+    ErrorReportModal: 'error-report-modal',
     LoadingModal: 'loading-modal',
+    PromptModal: 'prompt-modal',
+    Snackbar: 'snackbar',
+    StartupCrash: 'startup-crash',
 } as const;
 
 export type UIComponent = ObjectValues<typeof UIComponents>;
 
+export type ConfirmCheckboxes = Record<string, { label: string; default?: boolean; required?: boolean }>;
+
+export type ConfirmOptions = AcceptRefs<{
+    acceptText?: string;
+    acceptColor?: Color;
+    cancelText?: string;
+    cancelColor?: Color;
+    actions?: Record<string, () => unknown>;
+}>;
+
+export type LoadingOptions = AcceptRefs<{
+    title?: string;
+    message?: string;
+    progress?: number;
+}>;
+
+export interface ConfirmOptionsWithCheckboxes<T extends ConfirmCheckboxes = ConfirmCheckboxes> extends ConfirmOptions {
+    checkboxes?: T;
+}
+
+export type PromptOptions = AcceptRefs<{
+    label?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    acceptText?: string;
+    acceptColor?: Color;
+    cancelText?: string;
+    cancelColor?: Color;
+    trim?: boolean;
+}>;
+
+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 {
-        const options = typeof message === 'string' ? { title: messageOrTitle, message } : { message: messageOrTitle };
+        const getProperties = (): AGAlertModalProps => {
+            if (typeof message !== 'string') {
+                return { message: messageOrTitle };
+            }
 
-        this.openModal(this.requireComponent(UIComponents.AlertModal), options);
+            return {
+                title: messageOrTitle,
+                message,
+            };
+        };
+
+        this.openModal(this.requireComponent(UIComponents.AlertModal), getProperties());
     }
 
-    public async confirm(message: string): Promise<boolean>;
-    public async confirm(title: string, message: string): Promise<boolean>;
-    public async confirm(messageOrTitle: string, message?: string): Promise<boolean> {
-        const options = typeof message === 'string' ? { title: messageOrTitle, message } : { message: messageOrTitle };
-        const modal = await this.openModal<ModalComponent<{ message: string }, boolean>>(
-            this.requireComponent(UIComponents.ConfirmModal),
-            options,
-        );
+    /* eslint-disable max-len */
+    public async confirm(message: string, options?: ConfirmOptions): Promise<boolean>;
+    public async confirm(title: string, message: string, options?: ConfirmOptions): Promise<boolean>;
+    public async confirm<T extends ConfirmCheckboxes>(message: string, options?: ConfirmOptionsWithCheckboxes<T>): Promise<[boolean, Record<keyof T, boolean>]>; // prettier-ignore
+    public async confirm<T extends ConfirmCheckboxes>(title: string, message: string, options?: ConfirmOptionsWithCheckboxes<T>): Promise<[boolean, Record<keyof T, boolean>]>; // prettier-ignore
+    /* eslint-enable max-len */
+
+    public async confirm(
+        messageOrTitle: string,
+        messageOrOptions?: string | ConfirmOptions | ConfirmOptionsWithCheckboxes,
+        options?: ConfirmOptions | ConfirmOptionsWithCheckboxes,
+    ): Promise<boolean | [boolean, Record<string, boolean>]> {
+        const getProperties = (): AGConfirmModalProps => {
+            if (typeof messageOrOptions !== 'string') {
+                return {
+                    message: messageOrTitle,
+                    ...(messageOrOptions ?? {}),
+                };
+            }
+
+            return {
+                title: messageOrTitle,
+                message: messageOrOptions,
+                ...(options ?? {}),
+            };
+        };
+        const properties = getProperties();
+        const modal = await this.openModal<
+            ModalComponent<AGConfirmModalProps, boolean | [boolean, Record<string, boolean>]>
+        >(this.requireComponent(UIComponents.ConfirmModal), properties);
         const result = await modal.beforeClose;
 
-        return result ?? false;
+        const confirmed = typeof result === 'object' ? result[0] : result ?? false;
+        const checkboxes =
+            typeof result === 'object'
+                ? result[1]
+                : Object.entries(properties.checkboxes ?? {}).reduce(
+                    (values, [checkbox, { default: defaultValue }]) => ({
+                        [checkbox]: defaultValue ?? false,
+                        ...values,
+                    }),
+                      {} as Record<string, boolean>,
+                );
+
+        for (const [name, checkbox] of Object.entries(properties.checkboxes ?? {})) {
+            if (!checkbox.required || checkboxes[name]) {
+                continue;
+            }
+
+            if (confirmed && App.development) {
+                // eslint-disable-next-line no-console
+                console.warn(`Confirmed confirm modal was suppressed because required '${name}' checkbox was missing`);
+            }
+
+            return [false, checkboxes];
+        }
+
+        return 'checkboxes' in properties ? [confirmed, checkboxes] : confirmed;
+    }
+
+    public async prompt(message: string, options?: PromptOptions): Promise<string | null>;
+    public async prompt(title: string, message: string, options?: PromptOptions): Promise<string | null>;
+    public async prompt(
+        messageOrTitle: string,
+        messageOrOptions?: string | PromptOptions,
+        options?: PromptOptions,
+    ): Promise<string | null> {
+        const trim = options?.trim ?? true;
+        const getProperties = (): AGPromptModalProps => {
+            if (typeof messageOrOptions !== 'string') {
+                return {
+                    message: messageOrTitle,
+                    ...(messageOrOptions ?? {}),
+                } as AGPromptModalProps;
+            }
+
+            return {
+                title: messageOrTitle,
+                message: messageOrOptions,
+                ...(options ?? {}),
+            } as AGPromptModalProps;
+        };
+
+        const modal = await this.openModal<ModalComponent<AGPromptModalProps, string | null>>(
+            this.requireComponent(UIComponents.PromptModal),
+            getProperties(),
+        );
+        const rawResult = await modal.beforeClose;
+        const result = trim && typeof rawResult === 'string' ? rawResult?.trim() : rawResult;
+
+        return result ?? null;
+    }
+
+    public async loading<T>(operation: Promise<T> | (() => T)): Promise<T>;
+    public async loading<T>(message: string, operation: Promise<T> | (() => T)): Promise<T>;
+    public async loading<T>(options: LoadingOptions, operation: Promise<T> | (() => T)): Promise<T>;
+    public async loading<T>(
+        operationOrMessageOrOptions: string | LoadingOptions | Promise<T> | (() => T),
+        operation?: Promise<T> | (() => T),
+    ): Promise<T> {
+        const processOperation = (o: Promise<T> | (() => T)) => (typeof o === 'function' ? Promise.resolve(o()) : o);
+        const processArgs = (): { operationPromise: Promise<T>; props?: AGLoadingModalProps } => {
+            if (typeof operationOrMessageOrOptions === 'string') {
+                return {
+                    props: { message: operationOrMessageOrOptions },
+                    operationPromise: processOperation(operation as Promise<T> | (() => T)),
+                };
+            }
+
+            if (typeof operationOrMessageOrOptions === 'function' || operationOrMessageOrOptions instanceof Promise) {
+                return { operationPromise: processOperation(operationOrMessageOrOptions) };
+            }
+
+            return {
+                props: operationOrMessageOrOptions,
+                operationPromise: processOperation(operation as Promise<T> | (() => T)),
+            };
+        };
+
+        const { operationPromise, props } = processArgs();
+        const modal = await this.openModal(this.requireComponent(UIComponents.LoadingModal), props);
+
+        try {
+            const [result] = await Promise.all([operationPromise, after({ seconds: 1 })]);
+
+            return result;
+        } finally {
+            await this.closeModal(modal.id);
+        }
     }
 
-    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;
+    public showSnackbar(message: string, options: ShowSnackbarOptions = {}): void {
+        const snackbar: Snackbar = {
+            id: uuid(),
+            properties: { message, ...options },
+            component: markRaw(options.component ?? this.requireComponent(UIComponents.Snackbar)),
+        };
 
-        const message = typeof messageOrOperation === 'string' ? messageOrOperation : undefined;
-        const modal = await this.openModal(this.requireComponent(UIComponents.LoadingModal), { message });
-        const result = await operation;
+        this.setState('snackbars', this.snackbars.concat(snackbar));
 
-        await this.closeModal(modal.id);
+        setTimeout(() => this.hideSnackbar(snackbar.id), 5000);
+    }
 
-        return result;
+    public hideSnackbar(id: string): void {
+        this.setState(
+            'snackbars',
+            this.snackbars.filter((snackbar) => snackbar.id !== id),
+        );
     }
 
     public registerComponent(name: UIComponent, component: Component): void {
@@ -101,17 +284,40 @@ export class UIService extends Service {
     }
 
     public async closeModal(id: string, result?: unknown): Promise<void> {
+        if (!App.isMounted()) {
+            await this.removeModal(id, result);
+
+            return;
+        }
+
         await Events.emit('close-modal', { id, result });
     }
 
-    protected async boot(): Promise<void> {
-        await super.boot();
+    public async closeAllModals(): Promise<void> {
+        while (this.modals.length > 0) {
+            await this.closeModal(required(this.modals[this.modals.length - 1]).id);
+        }
+    }
 
+    protected async boot(): Promise<void> {
         this.watchModalEvents();
+        this.watchMountedEvent();
+        this.watchViewportBreakpoints();
     }
 
-    private requireComponent(name: UIComponent): Component {
-        return this.components[name] ?? fail(`UI Component '${name}' is not defined!`);
+    private async removeModal(id: string, result?: unknown): Promise<void> {
+        this.setState(
+            'modals',
+            this.modals.filter((m) => m.id !== id),
+        );
+
+        this.modalCallbacks[id]?.closed?.(result);
+
+        delete this.modalCallbacks[id];
+
+        const activeModal = this.modals.at(-1);
+
+        await (activeModal && Events.emit('show-modal', { id: activeModal.id }));
     }
 
     private watchModalEvents(): void {
@@ -123,29 +329,55 @@ export class UIService extends Service {
             }
         });
 
-        Events.on('modal-closed', async ({ modal, result }) => {
-            this.setState({ modals: this.modals.filter((m) => m.id !== modal.id) });
+        Events.on('modal-closed', async ({ modal: { id }, result }) => {
+            await this.removeModal(id, result);
+        });
+    }
 
-            this.modalCallbacks[modal.id]?.closed?.(result);
+    private watchMountedEvent(): void {
+        Events.once('application-mounted', async () => {
+            if (!globalThis.document || !globalThis.getComputedStyle) {
+                return;
+            }
 
-            delete this.modalCallbacks[modal.id];
+            const splash = globalThis.document.getElementById('splash');
 
-            const activeModal = this.modals.at(-1);
+            if (!splash) {
+                return;
+            }
+
+            if (globalThis.getComputedStyle(splash).opacity !== '0') {
+                splash.style.opacity = '0';
+
+                await after({ ms: 600 });
+            }
 
-            await (activeModal && Events.emit('show-modal', { id: activeModal.id }));
+            splash.remove();
         });
     }
 
+    private watchViewportBreakpoints(): void {
+        if (!globalThis.matchMedia) {
+            return;
+        }
+
+        const media = globalThis.matchMedia(`(min-width: ${MOBILE_BREAKPOINT}px)`);
+
+        media.addEventListener('change', () => this.setState({ layout: getCurrentLayout() }));
+    }
+
 }
 
-export default facade(new UIService());
+export default facade(UIService);
 
 declare module '@/services/Events' {
     export interface EventsPayload {
-        'modal-will-close': { modal: Modal; result?: unknown };
-        'modal-closed': { modal: Modal; result?: unknown };
         'close-modal': { id: string; result?: unknown };
         'hide-modal': { id: string };
+        'hide-overlays-backdrop': void;
+        'modal-closed': { modal: Modal; result?: unknown };
+        'modal-will-close': { modal: Modal; result?: unknown };
         'show-modal': { id: string };
+        'show-overlays-backdrop': void;
     }
 }

package/src/ui/index.ts

@@ -6,13 +6,19 @@ 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 AGPromptModal from '../components/modals/AGPromptModal.vue';
+import AGSnackbar from '../components/snackbars/AGSnackbar.vue';
+import AGStartupCrash from '../components/lib/AGStartupCrash.vue';
 import type { UIComponent } from './UI';
 
-export { UI, UIComponents, UIComponent };
-
 const services = { $ui: UI };
 
+export * from './UI';
+export * from './utils';
+export { default as UI } from './UI';
+
 export type UIServices = typeof services;
 
 export default definePlugin({
@@ -20,7 +26,11 @@ export default definePlugin({
         const defaultComponents = {
             [UIComponents.AlertModal]: AGAlertModal,
             [UIComponents.ConfirmModal]: AGConfirmModal,
+            [UIComponents.ErrorReportModal]: AGErrorReportModal,
             [UIComponents.LoadingModal]: AGLoadingModal,
+            [UIComponents.PromptModal]: AGPromptModal,
+            [UIComponents.Snackbar]: AGSnackbar,
+            [UIComponents.StartupCrash]: AGStartupCrash,
         };
 
         Object.entries({
@@ -33,7 +43,7 @@ export default definePlugin({
 });
 
 declare module '@/bootstrap/options' {
-    interface AerogelOptions {
+    export interface AerogelOptions {
         components?: Partial<Record<UIComponent, Component>>;
     }
 }

package/src/ui/utils.ts

@@ -0,0 +1,16 @@
+export const MOBILE_BREAKPOINT = 768;
+
+export const Layouts = {
+    Mobile: 'mobile',
+    Desktop: 'desktop',
+} as const;
+
+export type Layout = (typeof Layouts)[keyof typeof Layouts];
+
+export function getCurrentLayout(): Layout {
+    if (globalThis.innerWidth > MOBILE_BREAKPOINT) {
+        return Layouts.Desktop;
+    }
+
+    return Layouts.Mobile;
+}

package/src/utils/composition/events.ts

@@ -14,6 +14,7 @@ export function useEvent<Event extends EventWithPayload>(
     event: Event,
     listener: EventListener<EventsPayload[Event]>
 ): void;
+export function useEvent<Payload>(event: string, listener: (payload: Payload) => unknown): void;
 export function useEvent<Event extends string>(event: UnknownEvent<Event>, listener: EventListener): void;
 
 export function useEvent(event: string, listener: EventListener): void {

package/src/utils/composition/persistent.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { nextTick } from 'vue';
+import { Storage } from '@noeldemartin/utils';
+
+import { persistent } from './persistent';
+
+describe('Vue persistent helper', () => {
+
+    it('serializes to localStorage', async () => {
+        // Arrange
+        const store = persistent<{ foo?: string }>('foobar', {});
+
+        // Act
+        store.foo = 'bar';
+
+        await nextTick();
+
+        // Assert
+        expect(Storage.get('foobar')).toEqual({ foo: 'bar' });
+    });
+
+    it('reads from localStorage', async () => {
+        // Arrange
+        Storage.set('foobar', { foo: 'bar' });
+
+        // Act
+        const store = persistent<{ foo?: string }>('foobar', {});
+
+        // Assert
+        expect(store.foo).toEqual('bar');
+    });
+
+});

package/src/utils/composition/persistent.ts

@@ -0,0 +1,11 @@
+import { reactive, toRaw, watch } from 'vue';
+import { Storage } from '@noeldemartin/utils';
+import type { UnwrapNestedRefs } from 'vue';
+
+export function persistent<T extends object>(name: string, defaults: T): UnwrapNestedRefs<T> {
+    const store = reactive<T>(Storage.get<T>(name) ?? defaults);
+
+    watch(store, () => Storage.set(name, toRaw(store)));
+
+    return store;
+}

package/src/utils/composition/state.test.ts

@@ -0,0 +1,47 @@
+import { after } from '@noeldemartin/utils';
+import { describe, expect, it } from 'vitest';
+import { ref } from 'vue';
+
+import { computedDebounce } from './state';
+
+describe('Vue state helpers', () => {
+
+    it('computes debounced state', async () => {
+        // Initial
+        const state = ref(0);
+        const value = computedDebounce({ delay: 90 }, () => state.value);
+
+        expect(value.value).toBe(null);
+
+        await after({ ms: 100 });
+
+        expect(value.value).toBe(0);
+
+        // Update
+        state.value = 42;
+
+        expect(value.value).toBe(0);
+
+        await after({ ms: 100 });
+
+        expect(value.value).toBe(42);
+
+        // Debounced Update
+        state.value = 23;
+
+        expect(value.value).toBe(42);
+
+        await after({ ms: 50 });
+
+        state.value = 32;
+
+        await after({ ms: 50 });
+
+        expect(value.value).toBe(42);
+
+        await after({ ms: 100 });
+
+        expect(value.value).toBe(32);
+    });
+
+});

package/src/utils/composition/state.ts

@@ -0,0 +1,24 @@
+import { debounce } from '@noeldemartin/utils';
+import { ref, watchEffect } from 'vue';
+import type { ComputedGetter, ComputedRef } from '@vue/runtime-core';
+
+export interface ComputedDebounceOptions<T> {
+    initial?: T;
+    delay?: number;
+}
+
+export function computedDebounce<T>(options: ComputedDebounceOptions<T>, getter: ComputedGetter<T>): ComputedRef<T>;
+export function computedDebounce<T>(getter: ComputedGetter<T>): ComputedRef<T | null>;
+export function computedDebounce<T>(
+    optionsOrGetter: ComputedGetter<T> | ComputedDebounceOptions<T>,
+    inputGetter?: ComputedGetter<T>,
+): ComputedRef<T> {
+    const inputOptions = inputGetter ? (optionsOrGetter as ComputedDebounceOptions<T>) : {};
+    const getter = inputGetter ?? (optionsOrGetter as ComputedGetter<T>);
+    const state = ref(inputOptions.initial ?? null);
+    const update = debounce((value) => (state.value = value), inputOptions.delay ?? 300);
+
+    watchEffect(() => update(getter()));
+
+    return state as unknown as ComputedRef<T>;
+}

package/src/utils/index.ts

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

package/src/utils/markdown.test.ts

@@ -0,0 +1,50 @@
+/* eslint-disable max-len */
+import { describe, expect, it } from 'vitest';
+
+import { renderMarkdown } from './markdown';
+
+describe('Markdown utils', () => {
+
+    it('renders basic markdown', () => {
+        // Arrange
+        const expectedHTML = `
+            <h1>Title</h1>
+            <p>body with <a target="_blank" href="https://example.com">link</a></p>
+            <ul>
+                <li>One</li>
+                <li>Two</li>
+                <li>Three</li>
+            </ul>
+        `;
+
+        // Act
+        const html = renderMarkdown(
+            ['# Title', 'body with [link](https://example.com)', '- One', '- Two', '- Three'].join('\n'),
+        );
+
+        // Assert
+        expect(normalizeHTML(html)).toMatch(new RegExp(normalizeHTML(expectedHTML)));
+    });
+
+    it('renders button links', () => {
+        // Arrange
+        const expectedHTML = `
+            <p><button type="button" data-markdown-action="do-something">link</button></p>
+        `;
+
+        // Act
+        const html = renderMarkdown('[link](#action:do-something)');
+
+        // Assert
+        expect(normalizeHTML(html)).toMatch(new RegExp(normalizeHTML(expectedHTML)));
+    });
+
+});
+
+function normalizeHTML(html: string): string {
+    return html
+        .split('\n')
+        .map((line) => line.trim())
+        .join('\n')
+        .trim();
+}

package/src/utils/markdown.ts

@@ -1,8 +1,32 @@
 import DOMPurify from 'dompurify';
-import { marked } from 'marked';
+import { stringMatchAll, tap } from '@noeldemartin/utils';
+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"');
+        };
+    });
+}
+
+function renderActionLinks(html: string): string {
+    const matches = stringMatchAll<3>(html, /<a[^>]*href="#action:([^"]+)"[^>]*>([^<]+)<\/a>/g);
+
+    for (const [link, action, text] of matches) {
+        html = html.replace(link, `<button type="button" data-markdown-action="${action}">${text}</button>`);
+    }
+
+    return html;
+}
 
 export function renderMarkdown(markdown: string): string {
-    return safeHtml(marked(markdown, { mangle: false, headerIds: false }));
+    let html = marked(markdown, { mangle: false, headerIds: false, renderer: makeRenderer() });
+
+    html = safeHtml(html);
+    html = renderActionLinks(html);
+
+    return html;
 }
 
 export function safeHtml(html: string): string {