@aerogel/core 0.0.0-next.8e6b2bcc764fa682decbb41aa6848c77a744dec3 → 0.0.0-next.906ec80f260b7e5cb54a0c97bd4905bdaf4bf916

package/src/components/lib/AGMarkdown.vue

@@ -3,20 +3,23 @@
 </template>
 
 <script setup lang="ts">
-import { computed, h } from 'vue';
+import { computed, h, useAttrs } from 'vue';
+import { isInstanceOf } from '@noeldemartin/utils';
 
 import { renderMarkdown } from '@/utils/markdown';
-import { booleanProp, objectProp, stringProp } from '@/utils/vue';
+import { booleanProp, mixedProp, objectProp, 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(),
+    actions: objectProp<Record<string, () => unknown>>(),
 });
 
+const attrs = useAttrs();
 const markdown = computed(() => props.text ?? (props.langKey && translate(props.langKey, props.langParams ?? {})));
 const html = computed(() => {
     if (!markdown.value) {
@@ -32,5 +35,20 @@ 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,
+        onClick,
+        ...attrs,
+        class: `${attrs.class ?? ''} ${props.inline ? '' : 'prose'}`,
+    });
+
+async function onClick(event: Event) {
+    const { target } = event;
+
+    if (isInstanceOf(target, HTMLElement) && target.dataset.markdownAction) {
+        props.actions?.[target.dataset.markdownAction]?.();
+
+        return;
+    }
+}
 </script>

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/components/lib/AGProgressBar.vue

@@ -0,0 +1,55 @@
+<template>
+    <div class="mt-1 h-2 w-full overflow-hidden rounded-full bg-gray-200">
+        <div :class="barClasses" :style="`transform:translateX(-${(1 - renderedProgress) * 100}%)`" />
+        <span class="sr-only">
+            {{
+                $td('ui.progress', '{progress}% complete', {
+                    progress: renderedProgress * 100,
+                })
+            }}
+        </span>
+    </div>
+</template>
+
+<script setup lang="ts">
+import { computed, onUnmounted, ref, watch } from 'vue';
+
+import { numberProp, objectProp, stringProp } from '@/utils/vue';
+import type { Job } from '@/jobs';
+
+const props = defineProps({
+    progress: numberProp(),
+    barClass: stringProp(''),
+    job: objectProp<Job>(),
+});
+
+let cleanup: Function | undefined;
+const jobProgress = ref(0);
+const barClasses = computed(() => {
+    const classes = props.barClass ?? '';
+
+    return `h-full w-full transition-transform duration-500 ease-linear ${
+        classes.includes('bg-') ? classes : `${classes} bg-gray-700`
+    }`;
+});
+const renderedProgress = computed(() => {
+    if (typeof props.progress === 'number') {
+        return props.progress;
+    }
+
+    return jobProgress.value;
+});
+
+watch(
+    () => props.job,
+    () => {
+        cleanup?.();
+
+        jobProgress.value = props.job?.progress ?? 0;
+        cleanup = props.job?.listeners.add({ onUpdated: (progress) => (jobProgress.value = progress) });
+    },
+    { immediate: true },
+);
+
+onUnmounted(() => cleanup?.());
+</script>

package/src/components/lib/index.ts

@@ -2,4 +2,5 @@ export { default as AGErrorMessage } from './AGErrorMessage.vue';
 export { default as AGLink } from './AGLink.vue';
 export { default as AGMarkdown } from './AGMarkdown.vue';
 export { default as AGMeasured } from './AGMeasured.vue';
+export { default as AGProgressBar } from './AGProgressBar.vue';
 export { default as AGStartupCrash } from './AGStartupCrash.vue';

package/src/components/modals/AGAlertModal.ts

@@ -1,14 +1,17 @@
 import type { ExtractPropTypes } from 'vue';
-import type { ObjectWithoutEmpty } from '@noeldemartin/utils';
+import type { ObjectWithout, Pretty } from '@noeldemartin/utils';
 
 import { requiredStringProp, stringProp } from '@/utils';
+import type { AcceptRefs } from '@/utils';
 
 export const alertModalProps = {
     title: stringProp(),
     message: requiredStringProp(),
 };
 
-export type AGAlertModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof alertModalProps>>;
+export type AGAlertModalProps = Pretty<
+    AcceptRefs<ObjectWithout<ExtractPropTypes<typeof alertModalProps>, null | undefined>>
+>;
 
 export function useAlertModalProps(): typeof alertModalProps {
     return alertModalProps;

package/src/components/modals/AGConfirmModal.ts

@@ -1,18 +1,33 @@
 import { computed } from 'vue';
 import type { ExtractPropTypes } from 'vue';
-import type { ObjectWithoutEmpty } from '@noeldemartin/utils';
+import type { ObjectWithout, Pretty, SubPartial } from '@noeldemartin/utils';
 
-import { requiredStringProp, stringProp } from '@/utils';
+import { Colors } from '@/components/constants';
+import { booleanProp, enumProp, objectProp, requiredStringProp, stringProp } from '@/utils';
 import { translateWithDefault } from '@/lang';
+import type { AcceptRefs } from '@/utils';
+import type { ConfirmCheckboxes } from '@/ui';
 
 export const confirmModalProps = {
     title: stringProp(),
     message: requiredStringProp(),
     acceptText: stringProp(),
+    acceptColor: enumProp(Colors, Colors.Primary),
     cancelText: stringProp(),
+    cancelColor: enumProp(Colors, Colors.Clear),
+    checkboxes: objectProp<ConfirmCheckboxes>(),
+    actions: objectProp<Record<string, () => unknown>>(),
+    required: booleanProp(false),
 };
 
-export type AGConfirmModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof confirmModalProps>>;
+export type AGConfirmModalProps = Pretty<
+    AcceptRefs<
+        SubPartial<
+            ObjectWithout<ExtractPropTypes<typeof confirmModalProps>, null | undefined>,
+            'acceptColor' | 'cancelColor'
+        >
+    >
+>;
 
 export function useConfirmModalProps(): typeof confirmModalProps {
     return confirmModalProps;

package/src/components/modals/AGConfirmModal.vue

@@ -1,12 +1,12 @@
 <template>
     <AGModal v-slot="{ close }: IAGModalDefaultSlotProps" :cancellable="false" :title="title">
-        <AGMarkdown :text="message" />
+        <AGMarkdown :text="message" :actions="actions" />
 
         <div class="mt-2 flex flex-row-reverse gap-2">
-            <AGButton @click="close(true)">
+            <AGButton :color="acceptColor" @click="close(true)">
                 {{ renderedAcceptText }}
             </AGButton>
-            <AGButton color="secondary" @click="close()">
+            <AGButton v-if="!required" :color="cancelColor" @click="close()">
                 {{ renderedCancelText }}
             </AGButton>
         </div>

package/src/components/modals/AGErrorReportModal.ts

@@ -1,9 +1,10 @@
 import { computed, ref } from 'vue';
 import type { Component, ExtractPropTypes } from 'vue';
-import type { ObjectWithoutEmpty } from '@noeldemartin/utils';
+import type { ObjectWithout, Pretty } from '@noeldemartin/utils';
 
 import { requiredArrayProp } from '@/utils/vue';
 import { translateWithDefault } from '@/lang';
+import type { AcceptRefs } from '@/utils/vue';
 import type { ErrorReport } from '@/errors';
 
 export interface IAGErrorReportModalButtonsDefaultSlotProps {
@@ -18,7 +19,9 @@ export const errorReportModalProps = {
     reports: requiredArrayProp<ErrorReport>(),
 };
 
-export type AGErrorReportModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof errorReportModalProps>>;
+export type AGErrorReportModalProps = Pretty<
+    AcceptRefs<ObjectWithout<ExtractPropTypes<typeof errorReportModalProps>, null | undefined>>
+>;
 
 export function useErrorReportModalProps(): typeof errorReportModalProps {
     return errorReportModalProps;

package/src/components/modals/AGLoadingModal.ts

@@ -1,15 +1,20 @@
 import { computed } from 'vue';
 import type { ExtractPropTypes } from 'vue';
-import type { ObjectWithoutEmpty } from '@noeldemartin/utils';
+import type { ObjectWithout } from '@noeldemartin/utils';
 
-import { stringProp } from '@/utils';
+import { numberProp, stringProp } from '@/utils';
 import { translateWithDefault } from '@/lang';
+import type { AcceptRefs } from '@/utils';
 
 export const loadingModalProps = {
+    title: stringProp(),
     message: stringProp(),
+    progress: numberProp(),
 };
 
-export type AGLoadingModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof loadingModalProps>>;
+export type AGLoadingModalProps = AcceptRefs<
+    ObjectWithout<ExtractPropTypes<typeof loadingModalProps>, null | undefined>
+>;
 
 export function useLoadingModalProps(): typeof loadingModalProps {
     return loadingModalProps;
@@ -18,6 +23,7 @@ export function useLoadingModalProps(): typeof loadingModalProps {
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 export function useLoadingModal(props: ExtractPropTypes<typeof loadingModalProps>) {
     const renderedMessage = computed(() => props.message ?? translateWithDefault('ui.loading', 'Loading...'));
+    const showProgress = computed(() => typeof props.progress === 'number');
 
-    return { renderedMessage };
+    return { renderedMessage, showProgress };
 }

package/src/components/modals/AGModal.ts

@@ -1,6 +1,7 @@
 import type { Ref } from 'vue';
 
 export interface IAGModal {
+    inline: Ref<boolean>;
     cancellable: Ref<boolean>;
     close(result?: unknown): Promise<void>;
 }

package/src/components/modals/AGModalContext.vue

@@ -1,18 +1,28 @@
 <template>
-    <component :is="modal.component" v-bind="modal.properties" />
+    <component :is="modal.component" v-bind="modalProperties" />
 </template>
 
 <script setup lang="ts">
-import { provide, toRef } from 'vue';
+import { computed, provide, toRef, unref } from 'vue';
 
-import { requiredNumberProp, requiredObjectProp } from '@/utils/vue';
+import { numberProp, requiredObjectProp } from '@/utils/vue';
 import type { Modal } from '@/ui/UI.state';
 
 import type { IAGModalContext } from './AGModalContext';
 
 const props = defineProps({
     modal: requiredObjectProp<Modal>(),
-    childIndex: requiredNumberProp(),
+    childIndex: numberProp(0),
+});
+
+const modalProperties = computed(() => {
+    const properties = {} as typeof props.modal.properties;
+
+    for (const property in props.modal.properties) {
+        properties[property] = unref(props.modal.properties[property]);
+    }
+
+    return properties;
 });
 
 provide<IAGModalContext>('modal', {

package/src/components/modals/AGPromptModal.ts

@@ -1,9 +1,11 @@
 import { computed } from 'vue';
 import type { ExtractPropTypes } from 'vue';
-import type { ObjectWithoutEmpty } from '@noeldemartin/utils';
+import type { ObjectWithout, Pretty, SubPartial } from '@noeldemartin/utils';
 
-import { requiredStringProp, stringProp } from '@/utils';
+import { Colors } from '@/components/constants';
+import { enumProp, requiredStringProp, stringProp } from '@/utils';
 import { translateWithDefault } from '@/lang';
+import type { AcceptRefs } from '@/utils';
 
 export const promptModalProps = {
     title: stringProp(),
@@ -12,10 +14,19 @@ export const promptModalProps = {
     defaultValue: stringProp(),
     placeholder: stringProp(),
     acceptText: stringProp(),
+    acceptColor: enumProp(Colors, Colors.Primary),
     cancelText: stringProp(),
+    cancelColor: enumProp(Colors, Colors.Clear),
 };
 
-export type AGPromptModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof promptModalProps>>;
+export type AGPromptModalProps = Pretty<
+    AcceptRefs<
+        SubPartial<
+            ObjectWithout<ExtractPropTypes<typeof promptModalProps>, null | undefined>,
+            'acceptColor' | 'cancelColor'
+        >
+    >
+>;
 
 export function usePromptModalProps(): typeof promptModalProps {
     return promptModalProps;

package/src/components/modals/AGPromptModal.vue

@@ -6,10 +6,10 @@
             <AGInput name="draft" :placeholder="placeholder" :label="label" />
 
             <div class="mt-2 flex flex-row-reverse gap-2">
-                <AGButton submit>
+                <AGButton :color="acceptColor" submit>
                     {{ renderedAcceptText }}
                 </AGButton>
-                <AGButton color="secondary" @click="close()">
+                <AGButton :color="cancelColor" @click="close()">
                     {{ renderedCancelText }}
                 </AGButton>
             </div>

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/errors/JobCancelledError.ts

@@ -0,0 +1,3 @@
+import { JSError } from '@noeldemartin/utils';
+
+export default class JobCancelledError extends JSError {}

package/src/errors/index.ts

@@ -8,6 +8,8 @@ import { ErrorReport, ErrorReportLog, ErrorSource } from './Errors.state';
 
 export * from './utils';
 export { Errors, ErrorSource, ErrorReport, ErrorReportLog };
+export { default as JobCancelledError } from './JobCancelledError';
+export { default as ServiceBootError } from './ServiceBootError';
 
 const services = { $errors: Errors };
 const frameworkHandler: ErrorHandler = (error) => {

package/src/errors/utils.ts

@@ -2,7 +2,23 @@ import { JSError, isObject, toString } from '@noeldemartin/utils';
 import { translateWithDefault } from '@/lang/utils';
 import type { ErrorSource } from './Errors.state';
 
+const handlers: ErrorHandler[] = [];
+
+export type ErrorHandler = (error: ErrorSource) => string | undefined;
+
+export function registerErrorHandler(handler: ErrorHandler): void {
+    handlers.push(handler);
+}
+
 export function getErrorMessage(error: ErrorSource): string {
+    for (const handler of handlers) {
+        const result = handler(error);
+
+        if (result) {
+            return result;
+        }
+    }
+
     if (typeof error === 'string') {
         return error;
     }

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,5 +1,6 @@
-import { MagicObject } from '@noeldemartin/utils';
-import { computed, reactive, readonly, ref } from 'vue';
+import { computed, nextTick, reactive, readonly, ref } from 'vue';
+import { MagicObject, arrayRemove, fail, toString } from '@noeldemartin/utils';
+import { validate } from './validation';
 import type { ObjectValues } from '@noeldemartin/utils';
 import type { ComputedRef, DeepReadonly, Ref, UnwrapNestedRefs } from 'vue';
 
@@ -8,10 +9,12 @@ export const FormFieldTypes = {
     Number: 'number',
     Boolean: 'boolean',
     Object: 'object',
+    Date: 'date',
 } as const;
 
 export interface FormFieldDefinition<TType extends FormFieldType = FormFieldType, TRules extends string = string> {
     type: TType;
+    trim?: boolean;
     default?: GetFormFieldValue<TType>;
     rules?: TRules;
 }
@@ -40,10 +43,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 +60,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();
@@ -78,7 +87,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();
@@ -89,6 +104,14 @@ 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 };
+    }
+
     public validate(): boolean {
         const errors = Object.entries(this._fields).reduce((formErrors, [name, definition]) => {
             formErrors[name] = this.getFieldErrors(name, definition);
@@ -111,7 +134,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 {
@@ -119,7 +170,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 {
@@ -129,14 +180,20 @@ 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 {
         const errors = [];
+        const value = this._data[name];
+        const rules = definition.rules?.split('|') ?? [];
+
+        for (const rule of rules) {
+            if (rule !== 'required' && (value === null || value === undefined)) {
+                continue;
+            }
 
-        if (definition.rules?.includes('required') && !this._data[name]) {
-            errors.push('required');
+            errors.push(...validate(value, rule));
         }
 
         return errors.length > 0 ? errors : null;

package/src/forms/index.ts

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