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

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(options: { keepData?: boolean; keepErrors?: boolean } = {}): void {
+        this._submitted.value = false;
+
+        options.keepData || this.resetData();
+        options.keepErrors || 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/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.development && 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;
     }
 
 }

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.ts

@@ -1,7 +1,9 @@
 export * from './bootstrap';
 export * from './components';
+export * from './errors';
 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,16 @@
+import Build from 'virtual:aerogel';
+
+import { defineServiceState } from '@/services/Service';
+
+export default defineServiceState({
+    name: 'app',
+    initialState: {
+        environment: Build.environment,
+        sourceUrl: Build.sourceUrl,
+        isMounted: false,
+    },
+    computed: {
+        development: (state) => state.environment === 'development',
+        testing: (state) => state.environment === 'testing',
+    },
+});

package/src/services/App.ts

@@ -0,0 +1,15 @@
+import { facade } from '@noeldemartin/utils';
+
+import Events from '@/services/Events';
+
+import Service from './App.state';
+
+export class AppService extends Service {
+
+    protected async boot(): Promise<void> {
+        Events.once('application-mounted', () => this.setState({ isMounted: true }));
+    }
+
+}
+
+export default facade(new AppService());

package/src/services/Service.ts

@@ -1,50 +1,100 @@
-import { MagicObject, PromisedValue } from '@noeldemartin/utils';
-import { reactive } from 'vue';
+import { MagicObject, PromisedValue, Storage, isEmpty, objectDeepClone, objectOnly } from '@noeldemartin/utils';
 import type { Constructor } from '@noeldemartin/utils';
+import type { Store } from 'pinia';
 
 import ServiceBootError from '@/errors/ServiceBootError';
+import { defineServiceStore } from '@/services/store';
 
 export type ServiceState = Record<string, any>; // eslint-disable-line @typescript-eslint/no-explicit-any
-export type DefaultServiceState = {};
+export type DefaultServiceState = any; // eslint-disable-line @typescript-eslint/no-explicit-any
 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];
+} & ThisType<{
+    readonly [K in keyof TComputedState]: TComputedState[K];
+}>;
+
+export function defineServiceState<
+    State extends ServiceState = ServiceState,
+    ComputedState extends ServiceState = {}
+>(options: {
+    name: string;
     initialState: State;
-}): Constructor<State> & ServiceConstructor {
-    return class extends Service<State> {
+    persist?: (keyof State)[];
+    computed?: ComputedStateDefinition<State, ComputedState>;
+    serialize?: (state: Partial<State>) => Partial<State>;
+}): Constructor<State> & Constructor<ComputedState> & Constructor<Service<State, ComputedState, Partial<State>>> {
+    return class extends Service<State, ComputedState> {
+
+        public static persist = (options.persist as string[]) ?? [];
+
+        protected usesStore(): boolean {
+            return true;
+        }
+
+        protected getName(): string | null {
+            return options.name ?? null;
+        }
 
         protected getInitialState(): State {
             return options.initialState;
         }
+
+        protected getComputedStateDefinition(): ComputedStateDefinition<State, ComputedState> {
+            return options.computed ?? ({} as ComputedStateDefinition<State, ComputedState>);
+        }
+
+        protected serializePersistedState(state: Partial<State>): Partial<State> {
+            return options.serialize?.(state) ?? state;
+        }
     
-    } as unknown as Constructor<State> & ServiceConstructor;
+    } as unknown as Constructor<State> &
+        Constructor<ComputedState> &
+        Constructor<Service<State, ComputedState, Partial<State>>>;
 }
 
-export default class Service<State extends ServiceState = DefaultServiceState> extends MagicObject {
+export default class Service<
+    State extends ServiceState = DefaultServiceState,
+    ComputedState extends ServiceState = {},
+    ServiceStorage extends Partial<State> = Partial<State>
+> extends MagicObject {
 
-    protected _namespace: string;
+    public static persist: string[] = [];
+
+    protected _name: string;
     private _booted: PromisedValue<void>;
-    private _state: State;
+    private _computedStateKeys: Set<keyof State>;
+    private _store?: Store | false;
 
     constructor() {
         super();
 
-        this._namespace = new.target.name;
+        const getters = this.getComputedStateDefinition();
+
+        this._name = this.getName() ?? new.target.name;
         this._booted = new PromisedValue();
-        this._state = reactive(this.getInitialState());
+        this._computedStateKeys = new Set(Object.keys(getters));
+        this._store =
+            this.usesStore() &&
+            defineServiceStore(this._name, {
+                state: () => this.getInitialState(),
+
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                getters: getters as any,
+            });
     }
 
     public get booted(): PromisedValue<void> {
         return this._booted;
     }
 
-    public launch(namespace?: string): Promise<void> {
-        const handleError = (error: unknown) => this._booted.reject(new ServiceBootError(this._namespace, error));
-
-        this._namespace = namespace ?? this._namespace;
+    public launch(): Promise<void> {
+        const handleError = (error: unknown) => this._booted.reject(new ServiceBootError(this._name, error));
 
         try {
-            this.boot()
+            this.frameworkBoot()
+                .then(() => this.boot())
                 .then(() => this._booted.resolve())
                 .catch(handleError);
         } catch (error) {
@@ -54,38 +104,116 @@ export default class Service<State extends ServiceState = DefaultServiceState> e
         return this._booted;
     }
 
+    public hasState<P extends keyof State>(property: P): boolean {
+        if (!this._store) {
+            return false;
+        }
+
+        return property in this._store.$state || this._computedStateKeys.has(property);
+    }
+
+    public getState(): State;
+    public getState<P extends keyof State>(property: P): State[P];
+    public getState<P extends keyof State>(property?: P): State | State[P] {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const store = this._store as any;
+
+        if (property) {
+            return store ? store[property] : undefined;
+        }
+
+        return store ? store : {};
+    }
+
+    public setState<P extends keyof State>(property: P, value: State[P]): void;
+    public setState(state: Partial<State>): void;
+    public setState<P extends keyof State>(stateOrProperty: P | Partial<State>, value?: State[P]): void {
+        if (!this._store) {
+            return;
+        }
+
+        const state = (
+            typeof stateOrProperty === 'string' ? { [stateOrProperty]: value } : stateOrProperty
+        ) as Partial<State>;
+
+        Object.assign(this._store.$state, state);
+
+        this.onStateUpdated(state);
+    }
+
     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);
+        return super.__get(property);
     }
 
     protected __set(property: string, value: unknown): void {
         this.setState({ [property]: value } as Partial<State>);
     }
 
-    protected hasState<P extends keyof State>(property: P): boolean {
-        return property in this._state;
+    protected onStateUpdated(state: Partial<State>): void {
+        // TODO fix this.static()
+        const persist = (this.constructor as unknown as { persist: string[] }).persist;
+        const persisted = objectOnly(state, persist);
+
+        if (isEmpty(persisted)) {
+            return;
+        }
+
+        const storage = Storage.require<ServiceStorage>(this._name);
+
+        Storage.set(this._name, {
+            ...storage,
+            ...this.serializePersistedState(objectDeepClone(persisted) as Partial<State>),
+        });
     }
 
-    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 usesStore(): boolean {
+        return false;
     }
 
-    protected setState(state: Partial<State>): void {
-        Object.assign(this._state, state);
+    protected getName(): string | null {
+        return null;
     }
 
     protected getInitialState(): State {
         return {} as State;
     }
 
+    protected getComputedStateDefinition(): ComputedStateDefinition<State, ComputedState> {
+        return {} as ComputedStateDefinition<State, ComputedState>;
+    }
+
+    protected serializePersistedState(state: Partial<State>): Partial<State> {
+        return state;
+    }
+
+    protected async frameworkBoot(): Promise<void> {
+        this.restorePersistedState();
+    }
+
     protected async boot(): Promise<void> {
-        //
+        // Override.
+    }
+
+    protected restorePersistedState(): void {
+        // TODO fix this.static()
+        const persist = (this.constructor as unknown as { persist: string[] }).persist;
+
+        if (!this.usesStore() || isEmpty(persist)) {
+            return;
+        }
+
+        if (Storage.has(this._name)) {
+            const persisted = Storage.require<ServiceStorage>(this._name);
+            this.setState(persisted);
+
+            return;
+        }
+
+        Storage.set(this._name, objectOnly(this.getState(), persist));
     }
 
 }