@aerogel/core 0.0.0-next.f1f5a990033d966dc0bb12d251110fbc9350dcc7 → 0.0.0-next.fd1bd21aea7a9ab8c4eab69a5f5776db5de8bf35

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

@@ -9,31 +9,31 @@
                     [unselectedClass ?? 'unselected']: !selected,
                 }"
             >
-                {{ option?.text }}
+                {{ select.renderText(value) }}
             </li>
         </slot>
     </ListboxOption>
 </template>
 
 <script setup lang="ts">
-import { computed } from 'vue';
 import { ListboxOption } from '@headlessui/vue';
 
 import { injectReactiveOrFail, requiredMixedProp, stringProp } from '@/utils/vue';
 import type { ComponentProps } from '@/utils/vue';
+import type { FormFieldValue } from '@/forms/Form';
 
-import type { IAGHeadlessSelect, IAGSelectOptionValue } from './AGHeadlessSelect';
+import type { IAGHeadlessSelect } from './AGHeadlessSelect';
 
-const props = defineProps({
-    value: requiredMixedProp<IAGSelectOptionValue>(),
+defineProps({
+    value: requiredMixedProp<FormFieldValue>(),
     selectedClass: stringProp(),
     unselectedClass: stringProp(),
     activeClass: stringProp(),
     inactiveClass: stringProp(),
 });
+
 const select = injectReactiveOrFail<IAGHeadlessSelect>(
     'select',
     '<AGHeadlessSelectOption> must be a child of a <AGHeadlessSelect>',
 );
-const option = computed(() => select.options.find((selectOption) => selectOption.value === props.value));
 </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/AGErrorMessage.vue

@@ -5,12 +5,12 @@
 <script setup lang="ts">
 import { computed } from 'vue';
 
-import Errors from '@/errors/Errors';
 import { requiredObjectProp } from '@/utils/vue';
+import { getErrorMessage } from '@/errors/utils';
 import type { ErrorSource } from '@/errors/Errors.state';
 
 import AGMarkdown from './AGMarkdown.vue';
 
 const props = defineProps({ error: requiredObjectProp<ErrorSource>() });
-const message = computed(() => Errors.getErrorMessage(props.error));
+const message = computed(() => getErrorMessage(props.error));
 </script>

package/src/components/lib/AGMarkdown.vue

@@ -3,7 +3,7 @@
 </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';
@@ -17,6 +17,7 @@ const props = defineProps({
     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/components/modals/AGPromptModal.ts

@@ -0,0 +1,30 @@
+import { computed } from 'vue';
+import type { ExtractPropTypes } from 'vue';
+import type { ObjectWithoutEmpty } from '@noeldemartin/utils';
+
+import { requiredStringProp, stringProp } from '@/utils';
+import { translateWithDefault } from '@/lang';
+
+export const promptModalProps = {
+    title: stringProp(),
+    message: requiredStringProp(),
+    label: stringProp(),
+    defaultValue: stringProp(),
+    placeholder: stringProp(),
+    acceptText: stringProp(),
+    cancelText: stringProp(),
+};
+
+export type AGPromptModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof promptModalProps>>;
+
+export function usePromptModalProps(): typeof promptModalProps {
+    return promptModalProps;
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export function usePromptModal(props: ExtractPropTypes<typeof promptModalProps>) {
+    const renderedAcceptText = computed(() => props.acceptText ?? translateWithDefault('ui.accept', 'Ok'));
+    const renderedCancelText = computed(() => props.cancelText ?? translateWithDefault('ui.cancel', 'Cancel'));
+
+    return { renderedAcceptText, renderedCancelText };
+}

package/src/components/modals/AGPromptModal.vue

@@ -0,0 +1,34 @@
+<template>
+    <AGModal v-slot="{ close }: IAGModalDefaultSlotProps" :cancellable="false" :title="title">
+        <AGMarkdown :text="message" />
+
+        <AGForm :form="form" @submit="close(form.draft)">
+            <AGInput name="draft" :placeholder="placeholder" :label="label" />
+
+            <div class="mt-2 flex flex-row-reverse gap-2">
+                <AGButton submit>
+                    {{ renderedAcceptText }}
+                </AGButton>
+                <AGButton color="secondary" @click="close()">
+                    {{ renderedCancelText }}
+                </AGButton>
+            </div>
+        </AGForm>
+    </AGModal>
+</template>
+
+<script setup lang="ts">
+import AGModal from './AGModal.vue';
+import { usePromptModal, usePromptModalProps } from './AGPromptModal';
+import type { IAGModalDefaultSlotProps } from './AGModal';
+
+import AGButton from '../forms/AGButton.vue';
+import AGForm from '../forms/AGForm.vue';
+import AGInput from '../forms/AGInput.vue';
+import AGMarkdown from '../lib/AGMarkdown.vue';
+import { requiredStringInput, useForm } from '../../forms';
+
+const props = defineProps(usePromptModalProps());
+const form = useForm({ draft: requiredStringInput(props.defaultValue ?? '') });
+const { renderedAcceptText, renderedCancelText } = usePromptModal(props);
+</script>

package/src/components/modals/index.ts

@@ -1,26 +1,17 @@
-import AGAlertModal from './AGAlertModal.vue';
-import AGConfirmModal from './AGConfirmModal.vue';
-import AGErrorReportModalButtons from './AGErrorReportModalButtons.vue';
-import AGErrorReportModalTitle from './AGErrorReportModalTitle.vue';
-import AGLoadingModal from './AGLoadingModal.vue';
-import AGModal from './AGModal.vue';
-import AGModalTitle from './AGModalTitle.vue';
-import AGModalContext from './AGModalContext.vue';
-
 export * from './AGAlertModal';
 export * from './AGConfirmModal';
 export * from './AGErrorReportModal';
 export * from './AGLoadingModal';
 export * from './AGModal';
 export * from './AGModalContext';
+export * from './AGPromptModal';
 
-export {
-    AGAlertModal,
-    AGConfirmModal,
-    AGErrorReportModalButtons,
-    AGErrorReportModalTitle,
-    AGLoadingModal,
-    AGModal,
-    AGModalTitle,
-    AGModalContext,
-};
+export { default as AGAlertModal } from './AGAlertModal.vue';
+export { default as AGConfirmModal } from './AGConfirmModal.vue';
+export { default as AGErrorReportModalButtons } from './AGErrorReportModalButtons.vue';
+export { default as AGErrorReportModalTitle } from './AGErrorReportModalTitle.vue';
+export { default as AGLoadingModal } from './AGLoadingModal.vue';
+export { default as AGModal } from './AGModal.vue';
+export { default as AGModalContext } from './AGModalContext.vue';
+export { default as AGModalTitle } from './AGModalTitle.vue';
+export { default as AGPromptModal } from './AGPromptModal.vue';

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

@@ -7,6 +7,7 @@ import { translateWithDefault } from '@/lang/utils';
 
 import Service from './Errors.state';
 import { Colors } from '@/components/constants';
+import { Events } from '@/services';
 import type { AGErrorReportModalProps } from '@/components/modals/AGErrorReportModal';
 import type { ErrorReport, ErrorReportLog, ErrorSource } from './Errors.state';
 import type { ModalComponent } from '@/ui/UI.state';
@@ -39,7 +40,13 @@ export class ErrorsService extends Service {
     }
 
     public async report(error: ErrorSource, message?: string): Promise<void> {
-        if (App.development || App.testing) {
+        await Events.emit('error', { error, message });
+
+        if (App.testing) {
+            throw error;
+        }
+
+        if (App.development) {
             this.logError(error);
         }
 
@@ -47,7 +54,7 @@ export class ErrorsService extends Service {
             throw error;
         }
 
-        if (!App.isMounted) {
+        if (!App.isMounted()) {
             const startupError = await this.createStartupErrorReport(error);
 
             if (startupError) {
@@ -110,22 +117,6 @@ export class ErrorsService extends Service {
         });
     }
 
-    public getErrorMessage(error: ErrorSource): string {
-        if (typeof error === 'string') {
-            return error;
-        }
-
-        if (error instanceof Error || error instanceof JSError) {
-            return error.message;
-        }
-
-        if (isObject(error)) {
-            return toString(error['message'] ?? error['description'] ?? 'Unknown error object');
-        }
-
-        return translateWithDefault('errors.unknown', 'Unknown Error');
-    }
-
     private logError(error: unknown): void {
         // eslint-disable-next-line no-console
         console.error(error);
@@ -185,4 +176,10 @@ export class ErrorsService extends Service {
 
 }
 
-export default facade(new ErrorsService());
+export default facade(ErrorsService);
+
+declare module '@/services/Events' {
+    export interface EventsPayload {
+        error: { error: ErrorSource; message?: string };
+    }
+}

package/src/errors/index.ts

@@ -6,20 +6,11 @@ import { definePlugin } from '@/plugins';
 import Errors from './Errors';
 import { ErrorReport, ErrorReportLog, ErrorSource } from './Errors.state';
 
+export * from './utils';
 export { Errors, ErrorSource, ErrorReport, ErrorReportLog };
 
 const services = { $errors: Errors };
 const frameworkHandler: ErrorHandler = (error) => {
-    if (!Errors.instance) {
-        // eslint-disable-next-line no-console
-        console.warn('Errors service hasn\'t been initialized properly!');
-
-        // eslint-disable-next-line no-console
-        console.error(error);
-
-        return true;
-    }
-
     Errors.report(error);
 
     return true;

package/src/errors/utils.ts

@@ -0,0 +1,19 @@
+import { JSError, isObject, toString } from '@noeldemartin/utils';
+import { translateWithDefault } from '@/lang/utils';
+import type { ErrorSource } from './Errors.state';
+
+export function getErrorMessage(error: ErrorSource): string {
+    if (typeof error === 'string') {
+        return error;
+    }
+
+    if (error instanceof Error || error instanceof JSError) {
+        return error.message;
+    }
+
+    if (isObject(error)) {
+        return toString(error['message'] ?? error['description'] ?? 'Unknown error object');
+    }
+
+    return translateWithDefault('errors.unknown', 'Unknown Error');
+}

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> {
@@ -18,6 +19,7 @@ export interface FormFieldDefinition<TType extends FormFieldType = FormFieldType
 
 export type FormFieldDefinitions = Record<string, FormFieldDefinition>;
 export type FormFieldType = ObjectValues<typeof FormFieldTypes>;
+export type FormFieldValue = GetFormFieldValue<FormFieldType>;
 
 export type FormData<T> = {
     -readonly [k in keyof T]: T[k] extends FormFieldDefinition<infer TType, infer TRules>
@@ -39,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>>>;
@@ -51,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();
@@ -88,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);
@@ -110,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/jobs/Job.ts

@@ -0,0 +1,5 @@
+export default abstract class Job {
+
+    public abstract run(): Promise<void>;
+
+}

package/src/jobs/index.ts

@@ -0,0 +1,7 @@
+import Job from './Job';
+
+export { Job };
+
+export async function dispatch(job: Job): Promise<void> {
+    await job.run();
+}

package/src/lang/Lang.ts

@@ -1,10 +1,11 @@
-import { facade, toString } from '@noeldemartin/utils';
+import { facade } from '@noeldemartin/utils';
 
 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;
 }
 
 export class LangService extends Service {
@@ -21,6 +22,12 @@ export class LangService extends Service {
 
                 return key;
             },
+            translateWithDefault: (_, defaultMessage) => {
+                // eslint-disable-next-line no-console
+                App.development && console.warn('Lang provider is missing');
+
+                return defaultMessage;
+            },
         };
     }
 
@@ -32,29 +39,10 @@ export class LangService extends Service {
         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;
+    public translateWithDefault(key: string, defaultMessage: string, parameters: Record<string, unknown> = {}): string {
+        return this.provider.translateWithDefault(key, defaultMessage, parameters);
     }
 
 }
 
-export default facade(new LangService());
+export default facade(LangService);

package/src/main.ts

@@ -1,9 +1,12 @@
 export * from './bootstrap';
 export * from './components';
+export * from './directives';
 export * from './errors';
 export * from './forms';
+export * from './jobs';
 export * from './lang';
 export * from './plugins';
 export * from './services';
+export * from './testing';
 export * from './ui';
 export * from './utils';

package/src/services/App.state.ts

@@ -9,10 +9,9 @@ export default defineServiceState({
         plugins: {} as Record<string, Plugin>,
         environment: Aerogel.environment,
         sourceUrl: Aerogel.sourceUrl,
-        isMounted: false,
     },
     computed: {
         development: (state) => state.environment === 'development',
-        testing: (state) => state.environment === 'testing',
+        testing: (state) => state.environment === 'test' || state.environment === 'testing',
     },
 });

package/src/services/App.ts

@@ -1,4 +1,4 @@
-import { facade, forever, updateLocationQueryParameters } from '@noeldemartin/utils';
+import { PromisedValue, facade, forever, updateLocationQueryParameters } from '@noeldemartin/utils';
 
 import Events from '@/services/Events';
 import type { Plugin } from '@/plugins';
@@ -7,6 +7,23 @@ import Service from './App.state';
 
 export class AppService extends Service {
 
+    public readonly ready = new PromisedValue<void>();
+    public readonly mounted = new PromisedValue<void>();
+
+    public isReady(): boolean {
+        return this.ready.isResolved();
+    }
+
+    public isMounted(): boolean {
+        return this.mounted.isResolved();
+    }
+
+    public async whenReady<T>(callback: () => T): Promise<T> {
+        const result = await this.ready.then(callback);
+
+        return result;
+    }
+
     public async reload(queryParameters?: Record<string, string | undefined>): Promise<void> {
         queryParameters && updateLocationQueryParameters(queryParameters);
 
@@ -21,9 +38,10 @@ export class AppService extends Service {
     }
 
     protected async boot(): Promise<void> {
-        Events.once('application-mounted', () => this.setState({ isMounted: true }));
+        Events.once('application-ready', () => this.ready.resolve());
+        Events.once('application-mounted', () => this.mounted.resolve());
     }
 
 }
 
-export default facade(new AppService());
+export default facade(AppService);