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

package/src/services/index.ts

@@ -1,15 +1,20 @@
-import type { App } from 'vue';
+import type { App as VueApp } from 'vue';
 
+import { definePlugin } from '@/plugins';
+
+import App from './App';
 import Events from './Events';
 import Service from './Service';
-import { defineBootstrapHook } from '@/bootstrap/hooks';
+import { getPiniaStore } from './store';
 
+export * from './App';
 export * from './Events';
 export * from './Service';
 
-export { Events, Service };
+export { App, Events, Service };
 
 const defaultServices = {
+    $app: App,
     $events: Events,
 };
 
@@ -17,18 +22,38 @@ export type DefaultServices = typeof defaultServices;
 
 export interface Services extends DefaultServices {}
 
-export async function bootServices(app: App, services: Record<string, Service>): Promise<void> {
+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 defineBootstrapHook((app) => bootServices(app, defaultServices));
+export default definePlugin({
+    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/types/vite.d.ts

@@ -1,3 +1 @@
 /// <reference types="vite/client" />
-
-declare const __AG_BASE_PATH: string | undefined;

package/src/ui/UI.state.ts

@@ -2,10 +2,6 @@ import type { Component } from 'vue';
 
 import { defineServiceState } from '@/services/Service';
 
-export interface State {
-    modals: Modal[];
-}
-
 export interface Modal<T = unknown> {
     id: string;
     properties: Record<string, unknown>;
@@ -21,6 +17,16 @@ export interface ModalComponent<
     Result = unknown
 > {}
 
-export default defineServiceState<State>({
-    initialState: { modals: [] },
+export interface Snackbar {
+    id: string;
+    component: Component;
+    properties: Record<string, unknown>;
+}
+
+export default defineServiceState({
+    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;
@@ -20,17 +21,81 @@ 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 alert(message: string): void {
-        this.openModal(this.requireComponent(UIComponents.AlertModal), { message });
+    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 };
+
+        this.openModal(this.requireComponent(UIComponents.AlertModal), options);
+    }
+
+    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,
+        );
+        const result = await modal.beforeClose;
+
+        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 {
@@ -72,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);
@@ -91,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

@@ -1,10 +1,14 @@
 import type { Component } from 'vue';
 
 import { bootServices } from '@/services';
-import { defineBootstrapHook } from '@/bootstrap/hooks';
+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 };
@@ -13,25 +17,31 @@ const services = { $ui: UI };
 
 export type UIServices = typeof services;
 
-export default defineBootstrapHook(async (app, options) => {
-    const defaultComponents = {
-        [UIComponents.AlertModal]: AGAlertModal,
-    };
-
-    Object.entries({
-        ...defaultComponents,
-        ...options.components,
-    }).forEach(([name, component]) => UI.registerComponent(name as UIComponent, component));
-
-    await bootServices(app, services);
+export default definePlugin({
+    async install(app, options) {
+        const defaultComponents = {
+            [UIComponents.AlertModal]: AGAlertModal,
+            [UIComponents.ConfirmModal]: AGConfirmModal,
+            [UIComponents.ErrorReportModal]: AGErrorReportModal,
+            [UIComponents.LoadingModal]: AGLoadingModal,
+            [UIComponents.Snackbar]: AGSnackbar,
+        };
+
+        Object.entries({
+            ...defaultComponents,
+            ...options.components,
+        }).forEach(([name, component]) => UI.registerComponent(name as UIComponent, component));
+
+        await bootServices(app, services);
+    },
 });
 
 declare module '@/bootstrap/options' {
-    interface BootstrapOptions {
+    interface AerogelOptions {
         components?: Partial<Record<UIComponent, Component>>;
     }
 }
 
 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/composition/hooks.ts

@@ -0,0 +1,9 @@
+import { noop } from '@noeldemartin/utils';
+import { onMounted, onUnmounted } from 'vue';
+
+export function onCleanMounted(operation: () => Function): void {
+    let cleanUp: Function = noop;
+
+    onMounted(() => (cleanUp = operation()));
+    onUnmounted(() => cleanUp());
+}

package/src/utils/index.ts

@@ -1 +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,15 +1,7 @@
 {
+    "extends": "../../tsconfig.json",
     "compilerOptions": {
-        "target": "esnext",
-        "module": "esnext",
-        "moduleResolution": "node",
-        "strict": true,
-        "types": [],
-        "jsx": "preserve",
-        "noUncheckedIndexedAccess": true,
-        "resolveJsonModule": true,
-        "esModuleInterop": true,
-        "lib": ["esnext", "dom"],
+        "types": ["unplugin-icons/types/vue3"],
         "baseUrl": ".",
         "paths": {
             "@/*": ["./src/*"]

package/vite.config.ts

@@ -1,17 +1,14 @@
-import I18n from '@intlify/unplugin-vue-i18n/vite';
-import Vue from '@vitejs/plugin-vue';
+import Aerogel from '@aerogel/vite';
+import Icons from 'unplugin-icons/vite';
 import { defineConfig } from 'vitest/config';
 import { resolve } from 'path';
 
-const isTesting = process.env.NODE_ENV === 'test';
-
 export default defineConfig({
     test: { clearMocks: true },
-    plugins: [Vue(), I18n({ include: resolve(__dirname, './src/testing/stubs/lang/**/*.yaml') })],
+    plugins: [Aerogel(), Icons()],
     resolve: {
         alias: {
             '@': resolve(__dirname, './src'),
         },
     },
-    define: isTesting ? { __AG_BASE_PATH: 'undefined' } : undefined,
 });

package/src/bootstrap/hooks.ts

@@ -1,19 +0,0 @@
-import type { App } from 'vue';
-
-import type { BootstrapOptions } from '@/bootstrap/options';
-
-const mountedHooks: Function[] = [];
-
-export type BootstrapHook = (app: App, options: BootstrapOptions) => Promise<void>;
-
-export function onAppMounted(hook: Function): void {
-    mountedHooks.push(hook);
-}
-
-export function runAppMountedHooks(): void {
-    mountedHooks.forEach((hook) => hook());
-}
-
-export function defineBootstrapHook<T extends BootstrapHook>(hook: T): T {
-    return hook;
-}

package/src/lang/helpers.ts

@@ -1,5 +0,0 @@
-import Lang from '@/lang/Lang';
-
-export function lang(key: string, parameters: Record<string, unknown> = {}): string {
-    return Lang.translate(key, parameters);
-}

package/src/models/index.ts

@@ -1,18 +0,0 @@
-import { IndexedDBEngine, bootModelsFromViteGlob, setEngine } from 'soukai';
-
-import { defineBootstrapHook } from '@/bootstrap/hooks';
-
-export default defineBootstrapHook(async (_, options) => {
-    if (!options.models) {
-        return;
-    }
-
-    setEngine(new IndexedDBEngine());
-    bootModelsFromViteGlob(options.models);
-});
-
-declare module '@/bootstrap/options' {
-    interface BootstrapOptions {
-        models?: Record<string, Record<string, unknown>>;
-    }
-}

package/src/routing/index.ts

@@ -1,33 +0,0 @@
-import { createRouter, createWebHistory } from 'vue-router';
-import type { Plugin } from 'vue';
-
-import { defineBootstrapHook } from '@/bootstrap/hooks';
-
-function createAppRouter(options: { routes: RouteRecordRaw[]; basePath?: string }): Plugin {
-    return createRouter({
-        history: createWebHistory(options.basePath),
-        routes: options.routes,
-    });
-}
-
-export default defineBootstrapHook(async (app, options) => {
-    if (!options.routes) {
-        return;
-    }
-
-    const plugin = createAppRouter({
-        routes: options.routes,
-        basePath: options.basePath ?? __AG_BASE_PATH,
-    });
-
-    app.use(plugin);
-});
-
-declare module '@/bootstrap/options' {
-    interface BootstrapOptions {
-        routes?: RouteRecordRaw[];
-        basePath?: string;
-    }
-}
-
-import type { RouteRecordRaw } from 'vue-router';

package/src/testing/stubs/lang/en.yaml

@@ -1 +0,0 @@
-foo: Bar

package/src/testing/stubs/models/User.ts

@@ -1,3 +0,0 @@
-import { Model } from 'soukai';
-
-export default class User extends Model {}