@aerogel/core 0.0.0-next.9a02fcd3bcf698211dd7a71d4c48257c96dd7832 → 0.0.0-next.9f9564ab9f8da05f60d7868db361edbc5601ee39

package/package.json

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

package/src/components/AGAppSnackbars.vue

@@ -1,5 +1,5 @@
 <template>
-    <div aria-live="assertive" class="z-60 pointer-events-none fixed inset-0 flex items-end px-4 py-6 sm:p-6">
+    <div aria-live="assertive" class="pointer-events-none fixed inset-0 z-50 flex items-end px-4 py-6 sm:p-6">
         <div class="flex w-full flex-col items-end space-y-4">
             <component
                 :is="snackbar.component"

package/src/components/forms/AGForm.vue

@@ -1,26 +1,25 @@
 <template>
-    <form @submit.prevent="submit">
+    <form @submit.prevent="form?.submit()">
         <slot />
     </form>
 </template>
 
 <script setup lang="ts">
-import { provide } from 'vue';
+import { provide, watchEffect } from 'vue';
 
 import { objectProp } from '@/utils/vue';
 import type Form from '@/forms/Form';
 
+let offSubmit: (() => void) | undefined;
 const props = defineProps({ form: objectProp<Form>() });
-
 const emit = defineEmits<{ submit: [] }>();
 
-provide('form', props.form);
+watchEffect((onCleanup) => {
+    offSubmit?.();
+    offSubmit = props.form?.on('submit', () => emit('submit'));
 
-function submit() {
-    if (props.form && !props.form.submit()) {
-        return;
-    }
+    onCleanup(() => offSubmit?.());
+});
 
-    emit('submit');
-}
+provide('form', props.form);
 </script>

package/src/components/forms/AGInput.vue

@@ -13,6 +13,7 @@
                 'ring-1 ring-red-500': $input?.errors,
             }"
         />
+        <AGHeadlessInputDescription />
         <div class="absolute bottom-0 left-0 translate-y-full">
             <AGHeadlessInputError class="mt-1 text-sm text-red-500" />
         </div>
@@ -26,6 +27,7 @@ import { useInputProps } from '@/components/headless/forms/AGHeadlessInput';
 import type { IAGHeadlessInput } from '@/components/headless/forms/AGHeadlessInput';
 
 import AGHeadlessInput from '../headless/forms/AGHeadlessInput.vue';
+import AGHeadlessInputDescription from '../headless/forms/AGHeadlessInputDescription.vue';
 import AGHeadlessInputError from '../headless/forms/AGHeadlessInputError.vue';
 import AGHeadlessInputInput from '../headless/forms/AGHeadlessInputInput.vue';
 import AGHeadlessInputLabel from '../headless/forms/AGHeadlessInputLabel.vue';

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

@@ -1,5 +1,5 @@
 <template>
-    <component :is="component.tag" v-bind="component.props">
+    <component :is="component.as" v-bind="component.props">
         <slot />
     </component>
 </template>
@@ -11,6 +11,7 @@ import { objectWithoutEmpty } from '@noeldemartin/utils';
 import { booleanProp, objectProp, stringProp } from '@/utils/vue';
 
 const props = defineProps({
+    as: objectProp(),
     href: stringProp(),
     url: stringProp(),
     route: stringProp(),
@@ -20,9 +21,13 @@ const props = defineProps({
 });
 
 const component = computed(() => {
+    if (props.as) {
+        return { as: props.as, props: {} };
+    }
+
     if (props.route) {
         return {
-            tag: 'router-link',
+            as: 'router-link',
             props: {
                 to: objectWithoutEmpty({
                     name: props.route,
@@ -35,7 +40,7 @@ const component = computed(() => {
 
     if (props.href || props.url) {
         return {
-            tag: 'a',
+            as: 'a',
             props: {
                 target: '_blank',
                 href: props.href || props.url,
@@ -44,7 +49,7 @@ const component = computed(() => {
     }
 
     return {
-        tag: 'button',
+        as: 'button',
         props: { type: props.submit ? 'submit' : 'button' },
     };
 });

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

@@ -1,20 +1,24 @@
 import type { ComputedRef, DeepReadonly, ExtractPropTypes, Ref } from 'vue';
 
-import { stringProp } from '@/utils';
+import { mixedProp, stringProp } from '@/utils';
 import { extractComponentProps } from '@/components/utils';
+import type { FormFieldValue } from '@/forms/Form';
 
 export interface IAGHeadlessInput {
     id: string;
     name: ComputedRef<string | null>;
     label: ComputedRef<string | null>;
-    value: ComputedRef<string | number | boolean | null>;
+    description: ComputedRef<string | boolean | null>;
+    value: ComputedRef<FormFieldValue | null>;
     errors: DeepReadonly<Ref<string[] | null>>;
-    update(value: string | number | boolean | null): void;
+    update(value: FormFieldValue | null): void;
 }
 
 export const inputProps = {
     name: stringProp(),
     label: stringProp(),
+    description: stringProp(),
+    modelValue: mixedProp<FormFieldValue>([String, Number, Boolean]),
 };
 
 export function useInputProps(): typeof inputProps {

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

@@ -9,7 +9,7 @@
 import { computed, inject, provide, readonly } from 'vue';
 import { uuid } from '@noeldemartin/utils';
 
-import { mixedProp, stringProp } from '@/utils/vue';
+import { stringProp } from '@/utils/vue';
 import type Form from '@/forms/Form';
 
 import { useInputProps } from './AGHeadlessInput';
@@ -18,7 +18,6 @@ import type { IAGHeadlessInput } from './AGHeadlessInput';
 const emit = defineEmits(['update:modelValue']);
 const props = defineProps({
     as: stringProp('div'),
-    modelValue: mixedProp<string | number | boolean>([String, Number, Boolean]),
     ...useInputProps(),
 });
 const errors = computed(() => {
@@ -33,9 +32,10 @@ const api: IAGHeadlessInput = {
     id: `input-${uuid()}`,
     name: computed(() => props.name),
     label: computed(() => props.label),
+    description: computed(() => props.description),
     value: computed(() => {
         if (form && props.name) {
-            return form.getFieldValue(props.name) as string | number | boolean | null;
+            return form.getFieldValue(props.name);
         }
 
         return props.modelValue;

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

@@ -0,0 +1,28 @@
+<template>
+    <slot :id="`${input.id}-description`">
+        <AGMarkdown
+            v-if="show"
+            v-bind="$attrs"
+            :id="`${input.id}-description`"
+            :text="text"
+        />
+    </slot>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue';
+
+import { injectReactiveOrFail } from '@/utils/vue';
+
+import AGMarkdown from '../../lib/AGMarkdown.vue';
+import type { IAGHeadlessInput } from './AGHeadlessInput';
+
+defineOptions({ inheritAttrs: false });
+
+const input = injectReactiveOrFail<IAGHeadlessInput>(
+    'input',
+    '<AGHeadlessInputDescription> must be a child of a <AGHeadlessInput>',
+);
+const text = computed(() => (typeof input.description === 'string' ? input.description : ''));
+const show = computed(() => !!input.description);
+</script>

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

@@ -4,19 +4,23 @@
         ref="$input"
         :name="name"
         :type="type"
-        :value="value"
         :aria-invalid="input.errors ? 'true' : 'false'"
-        :aria-describedby="input.errors ? `${input.id}-error` : undefined"
+        :aria-describedby="
+            input.errors ? `${input.id}-error` : input.description ? `${input.id}-description` : undefined
+        "
         :checked="checked"
         @input="update"
     >
 </template>
 
 <script setup lang="ts">
-import { computed, ref } from 'vue';
+import { computed, ref, watchEffect } from 'vue';
 
 import { injectReactiveOrFail, stringProp } from '@/utils';
 import type { IAGHeadlessInput } from '@/components/headless/forms/AGHeadlessInput';
+import type { FormFieldValue } from '@/forms/Form';
+
+import { onFormFocus } from './composition';
 
 const props = defineProps({
     type: stringProp('text'),
@@ -42,6 +46,36 @@ function update() {
         return;
     }
 
-    input.update(props.type === 'checkbox' ? $input.value.checked : $input.value.value);
+    input.update(getValue());
 }
+
+function getValue(): FormFieldValue | null {
+    if (!$input.value) {
+        return null;
+    }
+
+    switch (props.type) {
+        case 'checkbox':
+            return $input.value.checked;
+        case 'date':
+            return $input.value.valueAsDate;
+        default:
+            return $input.value.value;
+    }
+}
+
+onFormFocus(input, () => $input.value?.focus());
+watchEffect(() => {
+    if (!$input.value) {
+        return;
+    }
+
+    if (props.type === 'date') {
+        $input.value.valueAsDate = value.value as Date;
+
+        return;
+    }
+
+    $input.value.value = value.value as string;
+});
 </script>

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

@@ -0,0 +1,40 @@
+<template>
+    <textarea
+        :id="input.id"
+        ref="$textArea"
+        :name="name"
+        :value="value"
+        :aria-invalid="input.errors ? 'true' : 'false'"
+        :aria-describedby="
+            input.errors ? `${input.id}-error` : input.description ? `${input.id}-description` : undefined
+        "
+        @input="update"
+    />
+</template>
+
+<script setup lang="ts">
+import { computed, ref } from 'vue';
+
+import { injectReactiveOrFail } from '@/utils';
+import type { IAGHeadlessInput } from '@/components/headless/forms/AGHeadlessInput';
+
+import { onFormFocus } from './composition';
+
+const $textArea = ref<HTMLTextAreaElement>();
+const input = injectReactiveOrFail<IAGHeadlessInput>(
+    'input',
+    '<AGHeadlessInputTextArea> must be a child of a <AGHeadlessInput>',
+);
+const name = computed(() => input.name ?? undefined);
+const value = computed(() => input.value as string);
+
+function update() {
+    if (!$textArea.value) {
+        return;
+    }
+
+    input.update($textArea.value.value);
+}
+
+onFormFocus(input, () => $textArea.value?.focus());
+</script>

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

@@ -0,0 +1,10 @@
+import { inject, onUnmounted } from 'vue';
+
+import type Form from '@/forms/Form';
+
+export function onFormFocus(input: { name: string | null }, listener: () => unknown): void {
+    const form = inject<Form | null>('form', null);
+    const stop = form?.on('focus', (name) => input.name === name && listener());
+
+    onUnmounted(() => stop?.());
+}

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

@@ -1,11 +1,14 @@
+export * from './composition';
 export * from './AGHeadlessInput';
 export * from './AGHeadlessSelect';
 export * from './AGHeadlessSelectOption';
 export { default as AGHeadlessButton } from './AGHeadlessButton.vue';
 export { default as AGHeadlessInput } from './AGHeadlessInput.vue';
+export { default as AGHeadlessInputDescription } from './AGHeadlessInputDescription.vue';
 export { default as AGHeadlessInputError } from './AGHeadlessInputError.vue';
 export { default as AGHeadlessInputInput } from './AGHeadlessInputInput.vue';
 export { default as AGHeadlessInputLabel } from './AGHeadlessInputLabel.vue';
+export { default as AGHeadlessInputTextArea } from './AGHeadlessInputTextArea.vue';
 export { default as AGHeadlessSelect } from './AGHeadlessSelect.vue';
 export { default as AGHeadlessSelectButton } from './AGHeadlessSelectButton.vue';
 export { default as AGHeadlessSelectError } from './AGHeadlessSelectError.vue';

package/src/components/lib/AGMarkdown.vue

@@ -3,20 +3,21 @@
 </template>
 
 <script setup lang="ts">
-import { computed, h } from 'vue';
+import { computed, h, useAttrs } from 'vue';
 
 import { renderMarkdown } from '@/utils/markdown';
-import { booleanProp, objectProp, stringProp } from '@/utils/vue';
+import { booleanProp, mixedProp, stringProp } from '@/utils/vue';
 import { translate } from '@/lang';
 
 const props = defineProps({
     as: stringProp(),
     inline: booleanProp(),
     langKey: stringProp(),
-    langParams: objectProp<Record<string, unknown>>(),
+    langParams: mixedProp<number | Record<string, unknown>>(),
     text: stringProp(),
 });
 
+const attrs = useAttrs();
 const markdown = computed(() => props.text ?? (props.langKey && translate(props.langKey, props.langParams ?? {})));
 const html = computed(() => {
     if (!markdown.value) {
@@ -32,5 +33,9 @@ const html = computed(() => {
     return renderedHtml;
 });
 const root = () =>
-    h(props.as ?? (props.inline ? 'span' : 'div'), { class: props.inline ? '' : 'prose', innerHTML: html.value });
+    h(props.as ?? (props.inline ? 'span' : 'div'), {
+        innerHTML: html.value,
+        ...attrs,
+        class: `${attrs.class ?? ''} ${props.inline ? '' : 'prose'}`,
+    });
 </script>

package/src/directives/index.ts

@@ -10,6 +10,8 @@ const builtInDirectives: Record<string, Directive> = {
     'measure': measure,
 };
 
+export * from './measure';
+
 export default definePlugin({
     install(app, options) {
         const directives = {

package/src/directives/measure.ts

@@ -1,12 +1,21 @@
 import { defineDirective } from '@/utils/vue';
 
+export interface ElementSize {
+    width: number;
+    height: number;
+}
+
+export type MeasureDirectiveListener = (size: ElementSize) => unknown;
+
 export default defineDirective({
-    mounted(element: HTMLElement, { value }: { value?: () => unknown }) {
+    mounted(element: HTMLElement, { value }) {
+        const listener = typeof value === 'function' ? (value as MeasureDirectiveListener) : null;
         const sizes = element.getBoundingClientRect();
 
+        // TODO guard with modifiers.css once typed properly
         element.style.setProperty('--width', `${sizes.width}px`);
         element.style.setProperty('--height', `${sizes.height}px`);
 
-        value?.();
+        listener?.({ width: sizes.width, height: sizes.height });
     },
 });

package/src/forms/Form.ts

@@ -1,5 +1,5 @@
-import { MagicObject } from '@noeldemartin/utils';
-import { computed, reactive, readonly, ref } from 'vue';
+import { MagicObject, arrayRemove } 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';
 
@@ -8,6 +8,7 @@ export const FormFieldTypes = {
     Number: 'number',
     Boolean: 'boolean',
     Object: 'object',
+    Date: 'date',
 } as const;
 
 export interface FormFieldDefinition<TType extends FormFieldType = FormFieldType, TRules extends string = string> {
@@ -40,10 +41,15 @@ export type GetFormFieldValue<TType> = TType extends typeof FormFieldTypes.Strin
     ? boolean
     : TType extends typeof FormFieldTypes.Object
     ? object
+    : TType extends typeof FormFieldTypes.Date
+    ? Date
     : never;
 
 const validForms: WeakMap<Form, ComputedRef<boolean>> = new WeakMap();
 
+export type SubmitFormListener = () => unknown;
+export type FocusFormListener = (input: string) => unknown;
+
 export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinitions> extends MagicObject {
 
     public errors: DeepReadonly<UnwrapNestedRefs<FormErrors<Fields>>>;
@@ -52,6 +58,7 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
     private _data: FormData<Fields>;
     private _submitted: Ref<boolean>;
     private _errors: FormErrors<Fields>;
+    private _listeners: { focus?: FocusFormListener[]; submit?: SubmitFormListener[] } = {};
 
     constructor(fields: Fields) {
         super();
@@ -89,6 +96,10 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
         return this._data[field] as unknown as GetFormFieldValue<Fields[T]['type']>;
     }
 
+    public data(): FormData<Fields> {
+        return { ...this._data };
+    }
+
     public validate(): boolean {
         const errors = Object.entries(this._fields).reduce((formErrors, [name, definition]) => {
             formErrors[name] = this.getFieldErrors(name, definition);
@@ -111,7 +122,35 @@ export default class Form<Fields extends FormFieldDefinitions = FormFieldDefinit
     public submit(): boolean {
         this._submitted.value = true;
 
-        return this.validate();
+        const valid = this.validate();
+
+        valid && this._listeners['submit']?.forEach((listener) => listener());
+
+        return valid;
+    }
+
+    public on(event: 'focus', listener: FocusFormListener): () => void;
+    public on(event: 'submit', listener: SubmitFormListener): () => void;
+    public on(event: 'focus' | 'submit', listener: FocusFormListener | SubmitFormListener): () => void {
+        this._listeners[event] ??= [];
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this._listeners[event]?.push(listener as any);
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return () => this.off(event as any, listener);
+    }
+
+    public off(event: 'focus', listener: FocusFormListener): void;
+    public off(event: 'submit', listener: SubmitFormListener): void;
+    public off(event: 'focus' | 'submit', listener: FocusFormListener | SubmitFormListener): void {
+        arrayRemove(this._listeners[event] ?? [], listener);
+    }
+
+    public async focus(input: string): Promise<void> {
+        await nextTick();
+
+        this._listeners['focus']?.forEach((listener) => listener(input));
     }
 
     protected __get(property: string): unknown {

package/src/forms/index.ts

@@ -1,3 +1,4 @@
 export * from './Form';
 export * from './composition';
 export * from './utils';
+export { default as Form } from './Form';

package/src/forms/utils.ts

@@ -8,6 +8,13 @@ export function booleanInput(defaultValue?: boolean): FormFieldDefinition<typeof
     };
 }
 
+export function dateInput(defaultValue?: Date): FormFieldDefinition<typeof FormFieldTypes.Date> {
+    return {
+        default: defaultValue,
+        type: FormFieldTypes.Date,
+    };
+}
+
 export function requiredBooleanInput(
     defaultValue?: boolean,
 ): FormFieldDefinition<typeof FormFieldTypes.Boolean, 'required'> {
@@ -18,6 +25,14 @@ export function requiredBooleanInput(
     };
 }
 
+export function requiredDateInput(defaultValue?: Date): FormFieldDefinition<typeof FormFieldTypes.Date> {
+    return {
+        default: defaultValue,
+        type: FormFieldTypes.Date,
+        rules: 'required',
+    };
+}
+
 export function requiredNumberInput(
     defaultValue?: number,
 ): FormFieldDefinition<typeof FormFieldTypes.Number, 'required'> {

package/src/lang/Lang.ts

@@ -4,8 +4,8 @@ import App from '@/services/App';
 import Service from '@/services/Service';
 
 export interface LangProvider {
-    translate(key: string, parameters?: Record<string, unknown>): string;
-    translateWithDefault(key: string, defaultMessage: string, parameters?: Record<string, unknown>): string;
+    translate(key: string, parameters?: Record<string, unknown> | number): string;
+    translateWithDefault(key: string, defaultMessage: string, parameters?: Record<string, unknown> | number): string;
 }
 
 export class LangService extends Service {
@@ -35,11 +35,15 @@ export class LangService extends Service {
         this.provider = provider;
     }
 
-    public translate(key: string, parameters?: Record<string, unknown>): string {
+    public translate(key: string, parameters?: Record<string, unknown> | number): string {
         return this.provider.translate(key, parameters) ?? key;
     }
 
-    public translateWithDefault(key: string, defaultMessage: string, parameters: Record<string, unknown> = {}): string {
+    public translateWithDefault(
+        key: string,
+        defaultMessage: string,
+        parameters: Record<string, unknown> | number = {},
+    ): string {
         return this.provider.translateWithDefault(key, defaultMessage, parameters);
     }
 

package/src/main.ts

@@ -1,5 +1,6 @@
 export * from './bootstrap';
 export * from './components';
+export * from './directives';
 export * from './errors';
 export * from './forms';
 export * from './jobs';

package/src/services/Cache.ts

@@ -0,0 +1,43 @@
+import { PromisedValue, facade, tap } from '@noeldemartin/utils';
+
+import Service from '@/services/Service';
+
+export class CacheService extends Service {
+
+    private cache?: PromisedValue<Cache> = undefined;
+
+    public async get(url: string): Promise<Response | null> {
+        const cache = await this.open();
+        const response = await cache.match(url);
+
+        return response ?? null;
+    }
+
+    public async store(url: string, response: Response): Promise<void> {
+        const cache = await this.open();
+
+        await cache.put(url, response);
+    }
+
+    public async replace(url: string, response: Response): Promise<void> {
+        const cache = await this.open();
+        const keys = await cache.keys(url);
+
+        if (keys.length === 0) {
+            return;
+        }
+
+        await cache.put(url, response);
+    }
+
+    protected async open(): Promise<Cache> {
+        return (this.cache =
+            this.cache ??
+            tap(new PromisedValue<Cache>(), (cache) => {
+                caches.open('app').then((instance) => cache.resolve(instance));
+            }));
+    }
+
+}
+
+export default facade(CacheService);

package/src/services/index.ts

@@ -3,16 +3,18 @@ import type { App as VueApp } from 'vue';
 import { definePlugin } from '@/plugins';
 
 import App from './App';
+import Cache from './Cache';
 import Events from './Events';
 import Service from './Service';
 import { getPiniaStore } from './store';
 
 export * from './App';
+export * from './Cache';
 export * from './Events';
 export * from './Service';
 export * from './store';
 
-export { App, Events, Service };
+export { App, Cache, Events, Service };
 
 const defaultServices = {
     $app: App,

package/src/ui/UI.ts

@@ -43,6 +43,7 @@ export interface PromptOptions {
     placeholder?: string;
     acceptText?: string;
     cancelText?: string;
+    trim?: boolean;
 }
 
 export interface ShowSnackbarOptions {
@@ -115,6 +116,7 @@ export class UIService extends Service {
         messageOrOptions?: string | PromptOptions,
         options?: PromptOptions,
     ): Promise<string | null> {
+        const trim = options?.trim ?? true;
         const getProperties = (): AGPromptModalProps => {
             if (typeof messageOrOptions !== 'string') {
                 return {
@@ -134,7 +136,8 @@ export class UIService extends Service {
             this.requireComponent(UIComponents.PromptModal),
             getProperties(),
         );
-        const result = await modal.beforeClose;
+        const rawResult = await modal.beforeClose;
+        const result = trim ? rawResult?.trim() : rawResult;
 
         return result ?? null;
     }