@aerogel/core 0.0.0-next.d34923f3b144e8f6720e6a9cdadb2cd4fb4ab289 → 0.0.0-next.d7394c3aa6aac799b0971e63819a8713d05a5123

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@aerogel/core",
     "description": "The Lightest Solid",
-    "version": "0.0.0-next.d34923f3b144e8f6720e6a9cdadb2cd4fb4ab289",
+    "version": "0.0.0-next.d7394c3aa6aac799b0971e63819a8713d05a5123",
     "main": "dist/aerogel-core.cjs.js",
     "module": "dist/aerogel-core.esm.js",
     "types": "dist/aerogel-core.d.ts",

package/src/bootstrap/bootstrap.test.ts

@@ -11,7 +11,6 @@ import { bootstrap } from './index';
 describe('Aerogel', () => {
 
     beforeEach(() => {
-        vi.stubGlobal('document', { getElementById: () => null });
         vi.mock('vue', async () => {
             const vue = (await vi.importActual('vue')) as Object;
 

package/src/components/composition.ts

@@ -0,0 +1,23 @@
+import { customRef } from 'vue';
+import type { Ref } from 'vue';
+
+import { getElement } from '@/components/interfaces';
+
+export function elementRef(): Ref<HTMLElement | undefined> {
+    return customRef((track, trigger) => {
+        let value: HTMLElement | undefined = undefined;
+
+        return {
+            get() {
+                track();
+
+                return value;
+            },
+            set(newValue) {
+                value = getElement(newValue);
+
+                trigger();
+            },
+        };
+    });
+}

package/src/components/headless/forms/AGHeadlessButton.ts

@@ -0,0 +1,3 @@
+import type { HasElement } from '@/components/interfaces';
+
+export interface IAGHeadlessButton extends HasElement {}

package/src/components/headless/forms/AGHeadlessButton.vue

@@ -1,5 +1,5 @@
 <template>
-    <component :is="component.as" v-bind="component.props">
+    <component :is="component.as" ref="$root" v-bind="component.props">
         <slot />
     </component>
 </template>
@@ -9,6 +9,9 @@ import { computed } from 'vue';
 import { objectWithoutEmpty } from '@noeldemartin/utils';
 
 import { booleanProp, objectProp, stringProp } from '@/utils/vue';
+import { elementRef } from '@/components/composition';
+
+import type { IAGHeadlessButton } from './AGHeadlessButton';
 
 const props = defineProps({
     as: objectProp(),
@@ -20,6 +23,7 @@ const props = defineProps({
     submit: booleanProp(),
 });
 
+const $root = elementRef();
 const component = computed(() => {
     if (props.as) {
         return { as: props.as, props: {} };
@@ -53,4 +57,6 @@ const component = computed(() => {
         props: { type: props.submit ? 'submit' : 'button' },
     };
 });
+
+defineExpose<IAGHeadlessButton>({ $el: $root });
 </script>

package/src/components/headless/forms/AGHeadlessInput.ts

@@ -11,6 +11,7 @@ export interface IAGHeadlessInput extends HasElement {
     label: ComputedRef<string | null>;
     description: ComputedRef<string | boolean | null>;
     value: ComputedRef<FormFieldValue | null>;
+    required: ComputedRef<boolean | null>;
     errors: DeepReadonly<Ref<string[] | null>>;
     update(value: FormFieldValue | null): void;
 }

package/src/components/headless/forms/AGHeadlessInput.vue

@@ -8,11 +8,10 @@
 <script setup lang="ts">
 import { computed, inject, provide, readonly, ref } from 'vue';
 import { uuid } from '@noeldemartin/utils';
-import type { Ref } from 'vue';
 
 import { stringProp } from '@/utils/vue';
 import type Form from '@/forms/Form';
-import type { __HasElement } from '@/components/interfaces';
+import type { __SetsElement } from '@/components/interfaces';
 
 import { useInputProps } from './AGHeadlessInput';
 import type { IAGHeadlessInput } from './AGHeadlessInput';
@@ -31,8 +30,8 @@ const errors = computed(() => {
     return form.errors[props.name] ?? null;
 });
 const form = inject<Form | null>('form', null);
-const api: IAGHeadlessInput & __HasElement = {
-    $el: readonly($el) as Readonly<Ref<HTMLElement>>,
+const api: IAGHeadlessInput & __SetsElement = {
+    $el,
     id: `input-${uuid()}`,
     name: computed(() => props.name),
     label: computed(() => props.label),
@@ -45,6 +44,13 @@ const api: IAGHeadlessInput & __HasElement = {
         return props.modelValue;
     }),
     errors: readonly(errors),
+    required: computed(() => {
+        if (!props.name || !form) {
+            return null;
+        }
+
+        return form.getFieldRules(props.name).includes('required');
+    }),
     update(value) {
         if (form && props.name) {
             form.setFieldValue(props.name, value);

package/src/components/headless/forms/AGHeadlessInputInput.vue

@@ -4,6 +4,7 @@
         ref="$input"
         :name="name"
         :type="type"
+        :required="input.required ?? undefined"
         :aria-invalid="input.errors ? 'true' : 'false'"
         :aria-describedby="
             input.errors ? `${input.id}-error` : input.description ? `${input.id}-description` : undefined
@@ -17,7 +18,7 @@
 import { computed, ref, watchEffect } from 'vue';
 
 import { injectReactiveOrFail, stringProp } from '@/utils/vue';
-import type { __HasElement } from '@/components/interfaces';
+import type { __SetsElement } from '@/components/interfaces';
 import type { FormFieldValue } from '@/forms/Form';
 import type { IAGHeadlessInput } from '@/components/headless/forms/AGHeadlessInput';
 
@@ -66,7 +67,7 @@ function getValue(): FormFieldValue | null {
 }
 
 onFormFocus(input, () => $input.value?.focus());
-watchEffect(() => (input as unknown as __HasElement).__setElement($input.value));
+watchEffect(() => (input as unknown as __SetsElement).__setElement($input.value));
 watchEffect(() => {
     if (!$input.value) {
         return;

package/src/components/headless/forms/AGHeadlessInputTextArea.vue

@@ -3,6 +3,7 @@
         :id="input.id"
         ref="$textArea"
         :name="name"
+        :required="input.required ?? undefined"
         :value="value"
         :aria-invalid="input.errors ? 'true' : 'false'"
         :aria-describedby="
@@ -17,7 +18,7 @@ import { computed, ref, watchEffect } from 'vue';
 
 import { injectReactiveOrFail } from '@/utils/vue';
 import type { IAGHeadlessInput } from '@/components/headless/forms/AGHeadlessInput';
-import type { __HasElement } from '@/components/interfaces';
+import type { __SetsElement } from '@/components/interfaces';
 
 import { onFormFocus } from './composition';
 
@@ -37,6 +38,6 @@ function update() {
     input.update($textArea.value.value);
 }
 
-watchEffect(() => (input as unknown as __HasElement).__setElement($textArea.value));
+watchEffect(() => (input as unknown as __SetsElement).__setElement($textArea.value));
 onFormFocus(input, () => $textArea.value?.focus());
 </script>

package/src/components/headless/forms/index.ts

@@ -1,4 +1,5 @@
 export * from './composition';
+export * from './AGHeadlessButton';
 export * from './AGHeadlessInput';
 export * from './AGHeadlessSelect';
 export * from './AGHeadlessSelectOption';

package/src/components/index.ts

@@ -3,6 +3,7 @@ import AGAppOverlays from './AGAppOverlays.vue';
 
 export { AGAppLayout, AGAppOverlays };
 
+export * from './composition';
 export * from './constants';
 export * from './forms';
 export * from './headless';

package/src/components/interfaces.ts

@@ -1,6 +1,21 @@
-import type { Ref } from 'vue';
+import { isObject } from '@noeldemartin/utils';
+import type { Ref, UnwrapNestedRefs } from 'vue';
 
-export interface __HasElement {
+export function getElement(value: unknown): HTMLElement | undefined {
+    if (value instanceof HTMLElement) {
+        return value;
+    }
+
+    if (hasElement(value)) {
+        return value.$el;
+    }
+}
+
+export function hasElement(value: unknown): value is UnwrapNestedRefs<HasElement> {
+    return isObject(value) && '$el' in value;
+}
+
+export interface __SetsElement {
     __setElement(element?: HTMLElement): void;
 }
 

package/src/components/lib/AGMeasured.vue

@@ -11,5 +11,6 @@ import { stringProp } from '@/utils/vue';
 
 defineProps({ as: stringProp('span') });
 
+// TODO use v-measure.css
 const measured = ref(false);
 </script>

package/src/directives/measure.ts

@@ -1,4 +1,7 @@
 import { defineDirective } from '@/utils/vue';
+import { tap } from '@noeldemartin/utils';
+
+const resizeObservers: WeakMap<HTMLElement, ResizeObserver> = new WeakMap();
 
 export interface ElementSize {
     width: number;
@@ -9,13 +12,29 @@ export type MeasureDirectiveListener = (size: ElementSize) => unknown;
 
 export default defineDirective({
     mounted(element: HTMLElement, { value }) {
+        // TODO replace with argument when typed properly
+        const modifiers = { css: true, watch: true };
+
         const listener = typeof value === 'function' ? (value as MeasureDirectiveListener) : null;
-        const sizes = element.getBoundingClientRect();
+        const update = () => {
+            const sizes = element.getBoundingClientRect();
+
+            if (modifiers.css) {
+                element.style.setProperty('--width', `${sizes.width}px`);
+                element.style.setProperty('--height', `${sizes.height}px`);
+            }
 
-        // TODO guard with modifiers.css once typed properly
-        element.style.setProperty('--width', `${sizes.width}px`);
-        element.style.setProperty('--height', `${sizes.height}px`);
+            listener?.({ width: sizes.width, height: sizes.height });
+        };
 
-        listener?.({ width: sizes.width, height: sizes.height });
+        if (modifiers.watch) {
+            resizeObservers.set(element, tap(new ResizeObserver(update)).observe(element));
+        }
+
+        update();
+    },
+    unmounted(element) {
+        resizeObservers.get(element)?.unobserve(element);
+        resizeObservers.delete(element);
     },
 });

package/src/forms/Form.test.ts

@@ -55,4 +55,32 @@ describe('Form', () => {
         expect(form.name).toBeNull();
     });
 
+    it('trims values', () => {
+        // Arrange
+        const form = useForm({
+            trimmed: {
+                type: FormFieldTypes.String,
+                rules: 'required',
+            },
+            untrimmed: {
+                type: FormFieldTypes.String,
+                rules: 'required',
+                trim: false,
+            },
+        });
+
+        // Act
+        form.trimmed = '   ';
+        form.untrimmed = '   ';
+
+        form.submit();
+
+        // Assert
+        expect(form.valid).toBe(false);
+        expect(form.submitted).toBe(true);
+        expect(form.trimmed).toEqual('');
+        expect(form.untrimmed).toEqual('   ');
+        expect(form.errors).toEqual({ trimmed: ['required'], untrimmed: null });
+    });
+
 });

package/src/forms/Form.ts

@@ -1,4 +1,4 @@
-import { MagicObject, arrayRemove } from '@noeldemartin/utils';
+import { MagicObject, arrayRemove, fail, toString } from '@noeldemartin/utils';
 import { computed, nextTick, reactive, readonly, ref } from 'vue';
 import type { ObjectValues } from '@noeldemartin/utils';
 import type { ComputedRef, DeepReadonly, Ref, UnwrapNestedRefs } from 'vue';
@@ -13,6 +13,7 @@ export const FormFieldTypes = {
 
 export interface FormFieldDefinition<TType extends FormFieldType = FormFieldType, TRules extends string = string> {
     type: TType;
+    trim?: boolean;
     default?: GetFormFieldValue<TType>;
     rules?: TRules;
 }
@@ -85,7 +86,13 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
     }
 
     public setFieldValue<T extends keyof Fields>(field: T, value: FormData<Fields>[T]): void {
-        this._data[field] = value;
+        const definition =
+            this._fields[field] ?? fail<FormFieldDefinition>(`Trying to set undefined '${toString(field)}' field`);
+
+        this._data[field] =
+            definition.type === FormFieldTypes.String && (definition.trim ?? true)
+                ? (toString(value).trim() as FormData<Fields>[T])
+                : value;
 
         if (this._submitted.value) {
             this.validate();
@@ -96,6 +103,10 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
         return this._data[field] as unknown as GetFormFieldValue<Fields[T]['type']>;
     }
 
+    public getFieldRules<T extends keyof Fields>(field: T): string[] {
+        return this._fields[field]?.rules?.split('|') ?? [];
+    }
+
     public data(): FormData<Fields> {
         return { ...this._data };
     }
@@ -158,7 +169,7 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
             return super.__get(property);
         }
 
-        return this._data[property];
+        return this.getFieldValue(property);
     }
 
     protected __set(property: string, value: unknown): void {
@@ -168,7 +179,7 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
             return;
         }
 
-        Object.assign(this._data, { [property]: value });
+        this.setFieldValue(property, value as FormData<Fields>[string]);
     }
 
     private getFieldErrors(name: keyof Fields, definition: FormFieldDefinition): string[] | null {

package/src/lang/DefaultLangProvider.ts

@@ -0,0 +1,43 @@
+import App from '@/services/App';
+
+import type { LangProvider } from './Lang';
+
+export default class DefaultLangProvider implements LangProvider {
+
+    constructor(private locale: string, private fallbackLocale: string) {}
+
+    public getLocale(): string {
+        return this.locale;
+    }
+
+    public async setLocale(locale: string): Promise<void> {
+        this.locale = locale;
+    }
+
+    public getFallbackLocale(): string {
+        return this.fallbackLocale;
+    }
+
+    public async setFallbackLocale(fallbackLocale: string): Promise<void> {
+        this.fallbackLocale = fallbackLocale;
+    }
+
+    public getLocales(): string[] {
+        return ['en'];
+    }
+
+    public translate(key: string): string {
+        // eslint-disable-next-line no-console
+        App.development && console.warn('Lang provider is missing');
+
+        return key;
+    }
+
+    public translateWithDefault(_: string, defaultMessage: string): string {
+        // eslint-disable-next-line no-console
+        App.development && console.warn('Lang provider is missing');
+
+        return defaultMessage;
+    }
+
+}

package/src/lang/Lang.state.ts

@@ -0,0 +1,11 @@
+import { defineServiceState } from '@/services/Service';
+
+export default defineServiceState({
+    name: 'lang',
+    persist: ['locale', 'fallbackLocale'],
+    initialState: {
+        locale: null as string | null,
+        locales: ['en'],
+        fallbackLocale: 'en',
+    },
+});

package/src/lang/Lang.ts

@@ -1,9 +1,14 @@
 import { facade } from '@noeldemartin/utils';
 
-import App from '@/services/App';
-import Service from '@/services/Service';
+import DefaultLangProvider from './DefaultLangProvider';
+import Service from './Lang.state';
 
 export interface LangProvider {
+    getLocale(): string;
+    setLocale(locale: string): Promise<void>;
+    getFallbackLocale(): string;
+    setFallbackLocale(fallbackLocale: string): Promise<void>;
+    getLocales(): string[];
     translate(key: string, parameters?: Record<string, unknown> | number): string;
     translateWithDefault(key: string, defaultMessage: string, parameters?: Record<string, unknown> | number): string;
 }
@@ -15,24 +20,18 @@ export class LangService extends Service {
     constructor() {
         super();
 
-        this.provider = {
-            translate: (key) => {
-                // eslint-disable-next-line no-console
-                App.development && console.warn('Lang provider is missing');
-
-                return key;
-            },
-            translateWithDefault: (_, defaultMessage) => {
-                // eslint-disable-next-line no-console
-                App.development && console.warn('Lang provider is missing');
-
-                return defaultMessage;
-            },
-        };
+        this.provider = new DefaultLangProvider(
+            this.getState('locale') ?? this.getBrowserLocale(),
+            this.getState('fallbackLocale'),
+        );
     }
 
-    public setProvider(provider: LangProvider): void {
+    public async setProvider(provider: LangProvider): Promise<void> {
         this.provider = provider;
+        this.locales = provider.getLocales();
+
+        await provider.setLocale(this.locale ?? this.getBrowserLocale());
+        await provider.setFallbackLocale(this.fallbackLocale);
     }
 
     public translate(key: string, parameters?: Record<string, unknown> | number): string {
@@ -47,6 +46,26 @@ export class LangService extends Service {
         return this.provider.translateWithDefault(key, defaultMessage, parameters);
     }
 
+    public getBrowserLocale(): string {
+        const locales = this.getState('locales');
+
+        return navigator.languages.find((locale) => locales.includes(locale)) ?? 'en';
+    }
+
+    protected async boot(): Promise<void> {
+        this.requireStore().$subscribe(
+            async () => {
+                await this.provider.setLocale(this.locale ?? this.getBrowserLocale());
+                await this.provider.setFallbackLocale(this.fallbackLocale);
+
+                this.locale
+                    ? document.querySelector('html')?.setAttribute('lang', this.locale)
+                    : document.querySelector('html')?.removeAttribute('lang');
+            },
+            { immediate: true },
+        );
+    }
+
 }
 
 export default facade(LangService);

package/src/services/Service.ts

@@ -1,4 +1,4 @@
-import { MagicObject, PromisedValue, Storage, isEmpty, objectDeepClone, objectOnly } from '@noeldemartin/utils';
+import { MagicObject, PromisedValue, Storage, fail, isEmpty, objectDeepClone, objectOnly } from '@noeldemartin/utils';
 import type { Constructor } from '@noeldemartin/utils';
 import type { MaybeRef } from 'vue';
 import type { Store } from 'pinia';
@@ -91,7 +91,7 @@ export default class Service<
     protected _name: string;
     private _booted: PromisedValue<void>;
     private _computedStateKeys: Set<keyof State>;
-    private _store: Store | false;
+    private _store: Store<string, State, ComputedState, {}> | false;
 
     constructor() {
         super();
@@ -250,4 +250,12 @@ export default class Service<
         Storage.set(this._name, objectOnly(this.getState(), persist));
     }
 
+    protected requireStore(): Store<string, State, ComputedState, {}> {
+        if (!this._store) {
+            return fail(`Failed getting '${this._name}' store`);
+        }
+
+        return this._store;
+    }
+
 }

package/src/testing/setup.ts

@@ -0,0 +1,25 @@
+import { mock, tap } from '@noeldemartin/utils';
+import { beforeEach, vi } from 'vitest';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+tap(globalThis, (global: any) => {
+    global.jest = vi;
+    global.navigator = { languages: ['en'] };
+    global.window = mock<Window>({
+        matchMedia: () =>
+            mock<MediaQueryList>({
+                addEventListener: () => null,
+            }),
+    });
+    global.localStorage = mock<Storage>({
+        getItem: () => null,
+        setItem: () => null,
+    });
+});
+
+beforeEach(() => {
+    vi.stubGlobal('document', {
+        querySelector: () => null,
+        getElementById: () => null,
+    });
+});

package/src/ui/UI.state.ts

@@ -2,6 +2,8 @@ import type { Component } from 'vue';
 
 import { defineServiceState } from '@/services/Service';
 
+import { Layouts, getCurrentLayout } from './utils';
+
 export interface Modal<T = unknown> {
     id: string;
     properties: Record<string, unknown>;
@@ -28,5 +30,10 @@ export default defineServiceState({
     initialState: {
         modals: [] as Modal[],
         snackbars: [] as Snackbar[],
+        layout: getCurrentLayout(),
+    },
+    computed: {
+        mobile: ({ layout }) => layout === Layouts.Mobile,
+        desktop: ({ layout }) => layout === Layouts.Desktop,
     },
 });

package/src/ui/UI.ts

@@ -9,6 +9,7 @@ import type { SnackbarAction, SnackbarColor } from '@/components/headless/snackb
 import type { AGAlertModalProps, AGConfirmModalProps, AGLoadingModalProps, AGPromptModalProps } from '@/components';
 
 import Service from './UI.state';
+import { MOBILE_BREAKPOINT, getCurrentLayout } from './utils';
 import type { Modal, ModalComponent, Snackbar } from './UI.state';
 
 interface ModalCallbacks<T = unknown> {
@@ -147,9 +148,12 @@ export class UIService extends Service {
         return result ?? null;
     }
 
-    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> {
+    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>(
+        messageOrOperation: string | Promise<T> | (() => T),
+        operation?: Promise<T> | (() => T),
+    ): Promise<T> {
         const getProperties = (): AGLoadingModalProps => {
             if (typeof messageOrOperation !== 'string') {
                 return {};
@@ -161,7 +165,8 @@ export class UIService extends Service {
         const modal = await this.openModal(this.requireComponent(UIComponents.LoadingModal), getProperties());
 
         try {
-            operation = typeof messageOrOperation === 'string' ? (operation as Promise<T>) : messageOrOperation;
+            operation = typeof messageOrOperation === 'string' ? (operation as () => T) : messageOrOperation;
+            operation = typeof operation === 'function' ? Promise.resolve(operation()) : operation;
 
             const [result] = await Promise.all([operation, after({ seconds: 1 })]);
 
@@ -231,6 +236,7 @@ export class UIService extends Service {
     protected async boot(): Promise<void> {
         this.watchModalEvents();
         this.watchMountedEvent();
+        this.watchWindowMedia();
     }
 
     private watchModalEvents(): void {
@@ -276,6 +282,12 @@ export class UIService extends Service {
         });
     }
 
+    private watchWindowMedia(): void {
+        const media = window.matchMedia(`(min-width: ${MOBILE_BREAKPOINT}px)`);
+
+        media.addEventListener('change', () => this.setState({ layout: getCurrentLayout() }));
+    }
+
 }
 
 export default facade(UIService);

package/src/ui/index.ts

@@ -16,6 +16,7 @@ import type { UIComponent } from './UI';
 const services = { $ui: UI };
 
 export * from './UI';
+export * from './utils';
 export { default as UI } from './UI';
 
 export type UIServices = typeof services;

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 (window.innerWidth > MOBILE_BREAKPOINT) {
+        return Layouts.Desktop;
+    }
+
+    return Layouts.Mobile;
+}

package/src/utils/vue.ts

@@ -73,10 +73,12 @@ export function injectOrFail<T>(key: InjectionKey<T> | string, errorMessage?: st
     return inject(key) ?? fail(errorMessage ?? `Could not resolve '${key}' injection key`);
 }
 
-export function mixedProp<T>(type?: PropType<T>): OptionalProp<T | null> {
+export function mixedProp<T>(type?: PropType<T>): OptionalProp<T | null>;
+export function mixedProp<T>(type: PropType<T>, defaultValue: T): OptionalProp<T>;
+export function mixedProp<T>(type?: PropType<T>, defaultValue?: T): OptionalProp<T | null> {
     return {
         type,
-        default: null,
+        default: defaultValue ?? null,
     };
 }