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

package/src/lang/Lang.ts

@@ -1,19 +1,50 @@
-import { useI18n } from 'vue-i18n';
 import { facade } from '@noeldemartin/utils';
-import type { Composer } from 'vue-i18n';
 
+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 setProvider(provider: LangProvider): void {
+        this.provider = provider;
+    }
 
-    public setup(): void {
-        this.i18n = useI18n();
+    public translate(key: string, parameters?: Record<string, unknown>): string {
+        return this.provider.translate(key, parameters) ?? key;
     }
 
-    public translate(key: string, parameters: Record<string, unknown> = {}): string {
-        return this.i18n?.t(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;
+
+        return message === key ? defaultMessage : message;
     }
 
 }

package/src/lang/index.ts

@@ -1,89 +1,32 @@
-import { createI18n } from 'vue-i18n';
-import { fail, stringMatch } from '@noeldemartin/utils';
-import type { I18nOptions } from 'vue-i18n';
-import type { Plugin } from 'vue';
-
-import { defineBootstrapHook, onAppMounted } from '@/bootstrap/hooks';
 import { bootServices } from '@/services';
-import type { BootstrapOptions } from '@/bootstrap/options';
-
-import Lang from './Lang';
-
-const services = { $lang: Lang };
+import { definePlugin } from '@/plugins';
 
-function getLangOptions(options: BootstrapOptions): LangOptions | null {
-    if (options.lang) {
-        return options.lang;
-    }
-
-    if (options.langMessages) {
-        return { messages: options.langMessages };
-    }
+import Lang, { LangProvider } from './Lang';
 
-    return null;
-}
+export { Lang, LangProvider };
 
-function getMessageLoaders(messageLoaders: Record<string, unknown>): Record<string, LazyMessages> {
-    return Object.entries(messageLoaders).reduce((loaders, [fileName, loader]) => {
-        const locale = stringMatch<2>(fileName, /.*\/lang\/(.+)\.yaml/)?.[1];
-
-        if (locale) {
-            loaders[locale] = () =>
-                (loader as () => Promise<{ default: Record<string, unknown> }>)().then(
-                    ({ default: messages }) => messages,
-                );
-        }
-
-        return loaders;
-    }, {} as Record<string, LazyMessages>);
-}
-
-async function createAppI18n(options: LangOptions): Promise<Plugin> {
-    const locale = options.defaultLocale ?? 'en';
-    const fallbackLocale = options.fallbackLocale ?? 'en';
-    const messageLoaders = getMessageLoaders(options.messages);
-    const lazyMessages = messageLoaders[locale] ?? fail<LazyMessages>(`Missing messages for '${locale}' locale`);
-    const messages = { [locale]: await lazyMessages() } as I18nOptions['messages'];
-
-    return createI18n({ locale, fallbackLocale, messages });
-}
+const services = { $lang: Lang };
 
 export type LangServices = typeof services;
 
-export type LazyMessages = () => Promise<Record<string, unknown>>;
+export const translate = Lang.translate.bind(Lang);
+export const translateWithDefault = Lang.translateWithDefault.bind(Lang);
 
-export interface LangOptions {
-    messages: Record<string, unknown>;
-    defaultLocale?: string;
-    fallbackLocale?: string;
-}
-
-export * from './helpers';
-export { Lang };
-
-export default defineBootstrapHook(async (app, options) => {
-    const langOptions = getLangOptions(options);
-
-    if (!langOptions) {
-        return;
-    }
-
-    onAppMounted(() => Lang.setup());
-
-    const plugin = await createAppI18n(langOptions);
+export default definePlugin({
+    async install(app) {
+        app.config.globalProperties.$t ??= translate;
+        app.config.globalProperties.$td = translateWithDefault;
 
-    app.use(plugin);
-
-    await bootServices(app, services);
+        await bootServices(app, services);
+    },
 });
 
-declare module '@/bootstrap/options' {
-    interface BootstrapOptions {
-        lang?: LangOptions;
-        langMessages?: Record<string, unknown>;
-    }
-}
-
 declare module '@/services' {
     interface Services extends LangServices {}
 }
+
+declare module '@vue/runtime-core' {
+    interface ComponentCustomProperties {
+        $td: typeof translateWithDefault;
+    }
+}

package/src/main.ts

@@ -1,7 +1,10 @@
+import './globals';
+
 export * from './bootstrap';
 export * from './components';
 export * from './forms';
 export * from './lang';
+export * from './plugins';
 export * from './services';
 export * from './ui';
 export * from './utils';

package/src/plugins/Plugin.ts

@@ -0,0 +1,7 @@
+import type { App } from 'vue';
+
+import type { AerogelOptions } from '@/bootstrap/options';
+
+export interface Plugin {
+    install(app: App, options: AerogelOptions): void | Promise<void>;
+}

package/src/plugins/index.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from './Plugin';
+
+export * from './Plugin';
+
+export function definePlugin<T extends Plugin>(plugin: T): T {
+    return plugin;
+}

package/src/services/App.state.ts

@@ -0,0 +1,10 @@
+import { defineServiceState } from '@/services/Service';
+
+export default defineServiceState({
+    initialState: {
+        environment: __AG_ENV,
+    },
+    computed: {
+        isDevelopment: (state) => state.environment === 'development',
+    },
+});

package/src/services/App.ts

@@ -0,0 +1,7 @@
+import { facade } from '@noeldemartin/utils';
+
+import Service from './App.state';
+
+export class AppService extends Service {}
+
+export default facade(new AppService());

package/src/services/Service.ts

@@ -1,5 +1,6 @@
+import { computed, reactive } from 'vue';
 import { MagicObject, PromisedValue } from '@noeldemartin/utils';
-import { reactive } from 'vue';
+import type { ComputedRef } from 'vue';
 import type { Constructor } from '@noeldemartin/utils';
 
 import ServiceBootError from '@/errors/ServiceBootError';
@@ -8,23 +9,39 @@ export type ServiceState = Record<string, any>; // eslint-disable-line @typescri
 export type DefaultServiceState = {};
 export type ServiceConstructor<T extends Service = Service> = Constructor<T> & typeof Service;
 
-export function defineServiceState<State extends ServiceState>(options: {
+export type ComputedStateDefinition<TState extends ServiceState, TComputedState extends ServiceState> = {
+    [K in keyof TComputedState]: (state: TState) => TComputedState[K];
+};
+
+export function defineServiceState<
+    State extends ServiceState = ServiceState,
+    ComputedState extends ServiceState = {}
+>(options: {
     initialState: State;
-}): Constructor<State> & ServiceConstructor {
-    return class extends Service<State> {
+    computed?: ComputedStateDefinition<State, ComputedState>;
+}): Constructor<State> & Constructor<ComputedState> & ServiceConstructor {
+    return class extends Service<State, ComputedState> {
 
         protected getInitialState(): State {
             return options.initialState;
         }
+
+        protected getComputedStateDefinition(): ComputedStateDefinition<State, ComputedState> {
+            return options.computed ?? ({} as ComputedStateDefinition<State, ComputedState>);
+        }
     
-    } as unknown as Constructor<State> & ServiceConstructor;
+    } as unknown as Constructor<State> & Constructor<ComputedState> & ServiceConstructor;
 }
 
-export default class Service<State extends ServiceState = DefaultServiceState> extends MagicObject {
+export default class Service<
+    State extends ServiceState = DefaultServiceState,
+    ComputedState extends ServiceState = {}
+> extends MagicObject {
 
     protected _namespace: string;
     private _booted: PromisedValue<void>;
     private _state: State;
+    private _computedState: Record<keyof ComputedState, ComputedRef>;
 
     constructor() {
         super();
@@ -32,6 +49,14 @@ export default class Service<State extends ServiceState = DefaultServiceState> e
         this._namespace = new.target.name;
         this._booted = new PromisedValue();
         this._state = reactive(this.getInitialState());
+        this._computedState = Object.entries(this.getComputedStateDefinition()).reduce(
+            (computedState, [name, method]) => {
+                computedState[name as keyof ComputedState] = computed(() => method(this._state));
+
+                return computedState;
+            },
+            {} as Record<keyof ComputedState, ComputedRef>,
+        );
     }
 
     public get booted(): PromisedValue<void> {
@@ -55,11 +80,15 @@ export default class Service<State extends ServiceState = DefaultServiceState> e
     }
 
     protected __get(property: string): unknown {
-        if (!this.hasState(property)) {
-            return super.__get(property);
+        if (this.hasState(property)) {
+            return this.getState(property);
         }
 
-        return this.getState(property);
+        if (this.hasComputedState(property)) {
+            return this.getComputedState(property);
+        }
+
+        return super.__get(property);
     }
 
     protected __set(property: string, value: unknown): void {
@@ -70,12 +99,20 @@ export default class Service<State extends ServiceState = DefaultServiceState> e
         return property in this._state;
     }
 
+    protected hasComputedState<P extends keyof State>(property: P): boolean {
+        return property in this._computedState;
+    }
+
     protected getState(): State;
     protected getState<P extends keyof State>(property: P): State[P];
     protected getState<P extends keyof State>(property?: P): State | State[P] {
         return property ? this._state[property] : this._state;
     }
 
+    protected getComputedState<P extends keyof ComputedState>(property: P): ComputedState[P] {
+        return this._computedState[property]?.value;
+    }
+
     protected setState(state: Partial<State>): void {
         Object.assign(this._state, state);
     }
@@ -84,6 +121,10 @@ export default class Service<State extends ServiceState = DefaultServiceState> e
         return {} as State;
     }
 
+    protected getComputedStateDefinition(): ComputedStateDefinition<State, ComputedState> {
+        return {} as ComputedStateDefinition<State, ComputedState>;
+    }
+
     protected async boot(): Promise<void> {
         //
     }

package/src/services/index.ts

@@ -1,15 +1,19 @@
-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';
 
+export * from './App';
 export * from './Events';
 export * from './Service';
 
-export { Events, Service };
+export { App, Events, Service };
 
 const defaultServices = {
+    $app: App,
     $events: Events,
 };
 
@@ -17,7 +21,7 @@ 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
@@ -28,7 +32,11 @@ export async function bootServices(app: App, services: Record<string, Service>):
     Object.assign(app.config.globalProperties, services);
 }
 
-export default defineBootstrapHook((app) => bootServices(app, defaultServices));
+export default definePlugin({
+    async install(app) {
+        await bootServices(app, defaultServices);
+    },
+});
 
 declare module '@vue/runtime-core' {
     interface ComponentCustomProperties extends Services {}

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,6 @@ export interface ModalComponent<
     Result = unknown
 > {}
 
-export default defineServiceState<State>({
-    initialState: { modals: [] },
+export default defineServiceState({
+    initialState: { modals: [] as Modal[] },
 });

package/src/ui/UI.ts

@@ -20,6 +20,7 @@ type ModalResult<TComponent> = TComponent extends ModalComponent<Record<string,
 
 export const UIComponents = {
     AlertModal: 'alert-modal',
+    ConfirmModal: 'confirm-modal',
 } as const;
 
 export type UIComponent = ObjectValues<typeof UIComponents>;
@@ -29,8 +30,25 @@ 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 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 registerComponent(name: UIComponent, component: Component): void {

package/src/ui/index.ts

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

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,3 @@
+export * from './composition/events';
+export * from './composition/hooks';
 export * from './vue';

package/tsconfig.json

@@ -1,15 +1,6 @@
 {
+    "extends": "../../tsconfig.json",
     "compilerOptions": {
-        "target": "esnext",
-        "module": "esnext",
-        "moduleResolution": "node",
-        "strict": true,
-        "types": [],
-        "jsx": "preserve",
-        "noUncheckedIndexedAccess": true,
-        "resolveJsonModule": true,
-        "esModuleInterop": true,
-        "lib": ["esnext", "dom"],
         "baseUrl": ".",
         "paths": {
             "@/*": ["./src/*"]

package/vite.config.ts

@@ -1,17 +1,13 @@
-import I18n from '@intlify/unplugin-vue-i18n/vite';
-import Vue from '@vitejs/plugin-vue';
+import Aerogel from '@aerogel/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()],
     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 {}