@aerogel/core 0.0.0-next.7f6ed5a1f91688a86bf5ede2adc465e4fd6cfdea → 0.0.0-next.824cf5311c4335d119158f507dad094ed4f4f0b6

package/src/lang/index.ts

@@ -1,89 +1,30 @@
-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 };
-
-function getLangOptions(options: BootstrapOptions): LangOptions | null {
-    if (options.lang) {
-        return options.lang;
-    }
-
-    if (options.langMessages) {
-        return { messages: options.langMessages };
-    }
-
-    return null;
-}
+import { definePlugin } from '@/plugins';
 
-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];
+import Lang, { LangProvider } from './Lang';
+import { translate, translateWithDefault } from './utils';
 
-        if (locale) {
-            loaders[locale] = () =>
-                (loader as () => Promise<{ default: Record<string, unknown> }>)().then(
-                    ({ default: messages }) => messages,
-                );
-        }
+export { Lang, LangProvider, translate, translateWithDefault };
 
-        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 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' {
+    export interface Services extends LangServices {}
 }
 
-declare module '@/services' {
-    interface Services extends LangServices {}
+declare module '@vue/runtime-core' {
+    interface ComponentCustomProperties {
+        $td: typeof translateWithDefault;
+    }
 }

package/src/lang/utils.ts

@@ -0,0 +1,4 @@
+import Lang from './Lang';
+
+export const translate = Lang.translate.bind(Lang);
+export const translateWithDefault = Lang.translateWithDefault.bind(Lang);

package/src/main.histoire.ts

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

package/src/main.ts

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

package/src/plugins/Plugin.ts

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

@@ -0,0 +1,26 @@
+import type { GetClosureArgs } from '@noeldemartin/utils';
+
+import App from '@/services/App';
+
+import type { Plugin } from './Plugin';
+
+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

@@ -0,0 +1,17 @@
+import Aerogel from 'virtual:aerogel';
+
+import { defineServiceState } from '@/services/Service';
+import type { Plugin } from '@/plugins/Plugin';
+
+export default defineServiceState({
+    name: 'app',
+    initialState: {
+        plugins: {} as Record<string, Plugin>,
+        environment: Aerogel.environment,
+        sourceUrl: Aerogel.sourceUrl,
+    },
+    computed: {
+        development: (state) => state.environment === 'development',
+        testing: (state) => state.environment === 'test' || state.environment === 'testing',
+    },
+});

package/src/services/App.ts

@@ -0,0 +1,47 @@
+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 {
+
+    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;
+    }
+
+    protected async boot(): Promise<void> {
+        Events.once('application-ready', () => this.ready.resolve());
+        Events.once('application-mounted', () => this.mounted.resolve());
+    }
+
+}
+
+export default facade(AppService);

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']);
+    });
+
+});

package/src/services/Events.ts

@@ -1,9 +1,11 @@
-import { arr, facade, tap } from '@noeldemartin/utils';
-import type { FluentArray } from '@noeldemartin/utils';
+import { arrayRemove, facade, fail, tap } from '@noeldemartin/utils';
 
 import Service from '@/services/Service';
 
 export interface EventsPayload {}
+export interface EventListenerOptions {
+    priority: number;
+}
 
 export type EventListener<T = unknown> = (payload: T) => unknown;
 export type UnknownEvent<T> = T extends keyof EventsPayload ? never : T;
@@ -16,70 +18,126 @@ export type EventWithPayload = {
     [K in keyof EventsPayload]: EventsPayload[K] extends void ? never : K;
 }[keyof EventsPayload];
 
+export const EventListenerPriorities = {
+    Low: -256,
+    Default: 0,
+    High: 256,
+} as const;
+
 export class EventsService extends Service {
 
-    private listeners: Record<string, FluentArray<EventListener>> = {};
+    private listeners: Record<string, { priorities: number[]; handlers: Record<number, EventListener[]> }> = {};
 
     public emit<Event extends EventWithoutPayload>(event: Event): Promise<void>;
     public emit<Event extends EventWithPayload>(event: Event, payload: EventsPayload[Event]): Promise<void>;
     public emit<Event extends string>(event: UnknownEvent<Event>, payload?: unknown): Promise<void>;
     public async emit(event: string, payload?: unknown): Promise<void> {
-        const listeners = [...(this.listeners[event] ?? [])];
+        const listeners = this.listeners[event] ?? { priorities: [], handlers: {} };
 
-        await Promise.all(listeners.map((listener) => listener(payload)) ?? []);
+        for (const priority of listeners.priorities) {
+            await Promise.all(listeners.handlers[priority]?.map((listener) => listener(payload)) ?? []);
+        }
     }
 
+    /* eslint-disable max-len */
     public on<Event extends EventWithoutPayload>(event: Event, listener: () => unknown): () => void;
-    public on<Event extends EventWithPayload>(
-        event: Event,
-        listener: EventListener<EventsPayload[Event]>
-    ): () => void | void;
-
+    public on<Event extends EventWithoutPayload>(event: Event, options: Partial<EventListenerOptions>, listener: () => unknown): () => void; // prettier-ignore
+    public on<Event extends EventWithPayload>(event: Event, listener: EventListener<EventsPayload[Event]>): () => void | void; // prettier-ignore
+    public on<Event extends EventWithPayload>(event: Event, options: Partial<EventListenerOptions>, listener: EventListener<EventsPayload[Event]>): () => void | void; // prettier-ignore
     public on<Event extends string>(event: UnknownEvent<Event>, listener: EventListener): () => void;
-    public on(event: string, listener: EventListener): () => void {
-        (this.listeners[event] ??= arr<EventListener>([])).push(listener);
+    public on<Event extends string>(event: UnknownEvent<Event>, options: Partial<EventListenerOptions>, listener: EventListener): () => void; // prettier-ignore
+    /* eslint-enable max-len */
+
+    public on(
+        event: string,
+        optionsOrListener: Partial<EventListenerOptions> | EventListener,
+        listener?: EventListener,
+    ): () => void {
+        const options = typeof optionsOrListener === 'function' ? {} : optionsOrListener;
+        const handler = typeof optionsOrListener === 'function' ? optionsOrListener : (listener as EventListener);
 
-        return () => this.off(event, listener);
+        this.registerListener(event, options, handler);
+
+        return () => this.off(event, handler);
     }
 
+    /* eslint-disable max-len */
     public once<Event extends EventWithoutPayload>(event: Event, listener: () => unknown): () => void;
-    public once<Event extends EventWithPayload>(
-        event: Event,
-        listener: EventListener<EventsPayload[Event]>
-    ): () => void | void;
-
+    public once<Event extends EventWithoutPayload>(event: Event, options: Partial<EventListenerOptions>, listener: () => unknown): () => void; // prettier-ignore
+    public once<Event extends EventWithPayload>(event: Event, listener: EventListener<EventsPayload[Event]>): () => void | void; // prettier-ignore
+    public once<Event extends EventWithPayload>(event: Event, options: Partial<EventListenerOptions>, listener: EventListener<EventsPayload[Event]>): () => void | void; // prettier-ignore
     public once<Event extends string>(event: UnknownEvent<Event>, listener: EventListener): () => void;
-    public once(event: string, listener: EventListener): () => void {
+    public once<Event extends string>(event: UnknownEvent<Event>, options: Partial<EventListenerOptions>, listener: EventListener): () => void; // prettier-ignore
+    /* eslint-enable max-len */
+
+    public once(
+        event: string,
+        optionsOrListener: Partial<EventListenerOptions> | EventListener,
+        listener?: EventListener,
+    ): () => void {
         let onceListener: EventListener | null = null;
+        const options = typeof optionsOrListener === 'function' ? {} : optionsOrListener;
+        const handler = typeof optionsOrListener === 'function' ? optionsOrListener : (listener as EventListener);
 
         return tap(
             () => onceListener && this.off(event, onceListener),
             (off) => {
-                (this.listeners[event] ??= arr<EventListener>([])).push(
-                    (onceListener = (...args) => {
-                        off();
+                onceListener = (...args) => {
+                    off();
+
+                    return handler(...args);
+                };
 
-                        return listener(...args);
-                    }),
-                );
+                this.registerListener(event, options, handler);
             },
         );
     }
 
     public off(event: string, listener: EventListener): void {
-        const eventListeners = this.listeners[event];
+        const listeners = this.listeners[event];
 
-        if (!eventListeners) {
+        if (!listeners) {
             return;
         }
 
-        eventListeners.remove(listener);
+        const priorities = [...listeners.priorities];
 
-        if (eventListeners.isEmpty()) {
+        for (const priority of priorities) {
+            arrayRemove(listeners.handlers[priority] ?? [], listener);
+
+            if (listeners.handlers[priority]?.length === 0) {
+                delete listeners.handlers[priority];
+                arrayRemove(listeners.priorities, priority);
+            }
+        }
+
+        if (listeners.priorities.length === 0) {
             delete this.listeners[event];
         }
     }
 
+    protected registerListener(event: string, options: Partial<EventListenerOptions>, handler: EventListener): void {
+        const priority = options.priority ?? 0;
+
+        if (!(event in this.listeners)) {
+            this.listeners[event] = { priorities: [], handlers: {} };
+        }
+
+        const priorities =
+            this.listeners[event]?.priorities ?? fail<number[]>(`priorities missing for event '${event}'`);
+        const handlers =
+            this.listeners[event]?.handlers ??
+            fail<Record<number, EventListener[]>>(`handlers missing for event '${event}'`);
+
+        if (!priorities.includes(priority)) {
+            priorities.push(priority);
+            priorities.sort((a, b) => b - a);
+            handlers[priority] = [];
+        }
+
+        handlers[priority]?.push(handler);
+    }
+
 }
 
-export default facade(new EventsService());
+export default facade(EventsService);