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

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

@@ -1,37 +1,40 @@
 import type { ComputedRef, DeepReadonly, ExtractPropTypes, Ref } from 'vue';
+import type { Writable } from '@noeldemartin/utils';
 
-import { requiredArrayProp, stringProp } from '@/utils/vue';
+import { mixedProp, requiredArrayProp, stringProp } from '@/utils/vue';
 import { extractComponentProps } from '@/components/utils';
-
-export interface IAGSelectOption {
-    value: string | number | boolean | object | null;
-    text: string;
-}
-
-export type IAGSelectOptionValue = string | number | boolean | object | null;
+import type { FormFieldValue } from '@/forms/Form';
 
 export interface IAGHeadlessSelect {
     id: string;
     label: ComputedRef<string | null>;
     noSelectionText: ComputedRef<string>;
     buttonText: ComputedRef<string>;
-    selectedOption: ComputedRef<IAGSelectOption | undefined>;
-    options: ComputedRef<IAGSelectOption[]>;
+    renderText: ComputedRef<(value: FormFieldValue) => string>;
+    selectedOption: ComputedRef<FormFieldValue | null>;
+    options: ComputedRef<FormFieldValue[]>;
     errors: DeepReadonly<Ref<string[] | null>>;
-    update(value: IAGSelectOptionValue): void;
+    update(value: FormFieldValue): void;
 }
 
 export const selectProps = {
     name: stringProp(),
     label: stringProp(),
-    options: requiredArrayProp<IAGSelectOptionValue>(),
+    options: requiredArrayProp<FormFieldValue>(),
     noSelectionText: stringProp(),
+    optionsText: mixedProp<string | ((option: FormFieldValue) => string)>(),
 };
 
+export const selectEmits = ['update:modelValue'] as const;
+
 export function useSelectProps(): typeof selectProps {
     return selectProps;
 }
 
+export function useSelectEmits(): Writable<typeof selectEmits> {
+    return [...selectEmits];
+}
+
 export function extractSelectProps<T extends ExtractPropTypes<typeof selectProps>>(
     props: T,
 ): Pick<T, keyof typeof selectProps> {

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

@@ -1,7 +1,7 @@
 <template>
     <Listbox
         v-slot="{ value, open, disabled }: ComponentProps"
-        :model-value="selectedOption?.value"
+        :model-value="selectedOption"
         @update:model-value="update($event)"
     >
         <slot :value="value" :open="open" :disabled="disabled" />
@@ -10,38 +10,37 @@
 
 <script setup lang="ts">
 import { computed, inject, provide } from 'vue';
-import { isObject, toString, uuid } from '@noeldemartin/utils';
+import { toString, uuid } from '@noeldemartin/utils';
 import { Listbox } from '@headlessui/vue';
 
 import { mixedProp } from '@/utils/vue';
 import { translateWithDefault } from '@/lang/utils';
 import type Form from '@/forms/Form';
+import type { FormFieldValue } from '@/forms/Form';
 import type { ComponentProps } from '@/utils/vue';
 
-import { useSelectProps } from './AGHeadlessSelect';
-import type { IAGHeadlessSelect, IAGSelectOption, IAGSelectOptionValue } from './AGHeadlessSelect';
+import { useSelectEmits, useSelectProps } from './AGHeadlessSelect';
+import type { IAGHeadlessSelect } from './AGHeadlessSelect';
 
-const emit = defineEmits(['update:modelValue']);
+const emit = defineEmits(useSelectEmits());
 const props = defineProps({
-    modelValue: mixedProp<IAGSelectOptionValue>(),
+    modelValue: mixedProp<FormFieldValue>(),
     ...useSelectProps(),
 });
-const form = inject<Form | null>('form', null);
-const noSelectionText = computed(() => props.noSelectionText ?? translateWithDefault('select.noSelection', '-'));
-const options = computed(() =>
-    props.options.map((value) => {
-        const option: IAGSelectOption = {
-            value,
-            text: toString(isObject(value) && 'text' in value ? value.text : value),
-        };
+const renderText = computed(() => {
+    if (typeof props.optionsText === 'function') {
+        return props.optionsText;
+    }
 
-        return option;
-    }));
-const selectedOption = computed(() => {
-    const selectedOptionValue = form && props.name ? form.getFieldValue(props.name) : props.modelValue;
+    if (typeof props.optionsText === 'string') {
+        return (option: FormFieldValue): string => toString(option[props.optionsText as keyof FormFieldValue]);
+    }
 
-    return options.value.find((option) => option.value === selectedOptionValue);
+    return (option: FormFieldValue) => toString(option);
 });
+const form = inject<Form | null>('form', null);
+const noSelectionText = computed(() => props.noSelectionText ?? translateWithDefault('select.noSelection', '-'));
+const selectedOption = computed(() => (form && props.name ? form.getFieldValue(props.name) : props.modelValue));
 const errors = computed(() => {
     if (!form || !props.name) {
         return null;
@@ -50,7 +49,7 @@ const errors = computed(() => {
     return form.errors[props.name] ?? null;
 });
 
-function update(value: IAGSelectOptionValue) {
+function update(value: FormFieldValue) {
     if (form && props.name) {
         form.setFieldValue(props.name, value);
 
@@ -62,12 +61,14 @@ function update(value: IAGSelectOptionValue) {
 
 const api: IAGHeadlessSelect = {
     id: `select-${uuid()}`,
-    options,
     noSelectionText,
     selectedOption,
     errors,
+    options: computed(() => props.options),
     label: computed(() => props.label),
-    buttonText: computed(() => selectedOption.value?.text ?? noSelectionText.value),
+    buttonText: computed(() =>
+        selectedOption.value === null ? noSelectionText.value : renderText.value(selectedOption.value)),
+    renderText,
     update,
 };
 

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,15 @@
+export * from './composition';
+export * from './AGHeadlessButton';
 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/index.ts

@@ -3,9 +3,11 @@ import AGAppOverlays from './AGAppOverlays.vue';
 
 export { AGAppLayout, AGAppOverlays };
 
+export * from './composition';
 export * from './constants';
 export * from './forms';
 export * from './headless';
+export * from './interfaces';
 export * from './lib';
 export * from './modals';
 export * from './snackbars';

package/src/components/interfaces.ts

@@ -0,0 +1,24 @@
+import { isObject } from '@noeldemartin/utils';
+import type { Ref, UnwrapNestedRefs } from 'vue';
+
+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;
+}
+
+export interface HasElement {
+    $el: Readonly<Ref<HTMLElement | undefined>>;
+}

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,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/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/modals/AGConfirmModal.ts

@@ -1,18 +1,24 @@
 import { computed } from 'vue';
 import type { ExtractPropTypes } from 'vue';
-import type { ObjectWithoutEmpty } from '@noeldemartin/utils';
+import type { ObjectWithoutEmpty, SubPartial } from '@noeldemartin/utils';
 
-import { requiredStringProp, stringProp } from '@/utils';
+import { Colors } from '@/components/constants';
+import { enumProp, requiredStringProp, stringProp } from '@/utils';
 import { translateWithDefault } from '@/lang';
 
 export const confirmModalProps = {
     title: stringProp(),
     message: requiredStringProp(),
     acceptText: stringProp(),
+    acceptColor: enumProp(Colors, Colors.Primary),
     cancelText: stringProp(),
+    cancelColor: enumProp(Colors, Colors.Clear),
 };
 
-export type AGConfirmModalProps = ObjectWithoutEmpty<ExtractPropTypes<typeof confirmModalProps>>;
+export type AGConfirmModalProps = SubPartial<
+    ObjectWithoutEmpty<ExtractPropTypes<typeof confirmModalProps>>,
+    'acceptColor' | 'cancelColor'
+>;
 
 export function useConfirmModalProps(): typeof confirmModalProps {
     return confirmModalProps;

package/src/components/modals/AGConfirmModal.vue

@@ -3,10 +3,10 @@
         <AGMarkdown :text="message" />
 
         <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 :color="cancelColor" @click="close()">
                 {{ renderedCancelText }}
             </AGButton>
         </div>

package/src/components/modals/AGPromptModal.ts

@@ -0,0 +1,36 @@
+import { computed } from 'vue';
+import type { ExtractPropTypes } from 'vue';
+import type { ObjectWithoutEmpty, SubPartial } from '@noeldemartin/utils';
+
+import { Colors } from '@/components/constants';
+import { enumProp, requiredStringProp, stringProp } from '@/utils';
+import { translateWithDefault } from '@/lang';
+
+export const promptModalProps = {
+    title: stringProp(),
+    message: requiredStringProp(),
+    label: stringProp(),
+    defaultValue: stringProp(),
+    placeholder: stringProp(),
+    acceptText: stringProp(),
+    acceptColor: enumProp(Colors, Colors.Primary),
+    cancelText: stringProp(),
+    cancelColor: enumProp(Colors, Colors.Clear),
+};
+
+export type AGPromptModalProps = SubPartial<
+    ObjectWithoutEmpty<ExtractPropTypes<typeof promptModalProps>>,
+    'acceptColor' | 'cancelColor'
+>;
+
+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 :color="acceptColor" submit>
+                    {{ renderedAcceptText }}
+                </AGButton>
+                <AGButton :color="cancelColor" @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,40 @@
 import { defineDirective } from '@/utils/vue';
+import { tap } from '@noeldemartin/utils';
+
+const resizeObservers: WeakMap<HTMLElement, ResizeObserver> = new WeakMap();
+
+export interface ElementSize {
+    width: number;
+    height: number;
+}
+
+export type MeasureDirectiveListener = (size: ElementSize) => unknown;
 
 export default defineDirective({
-    mounted(element: HTMLElement, { value }: { value?: () => unknown }) {
-        const sizes = element.getBoundingClientRect();
+    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 update = () => {
+            const sizes = element.getBoundingClientRect();
 
-        element.style.setProperty('--width', `${sizes.width}px`);
-        element.style.setProperty('--height', `${sizes.height}px`);
+            if (modifiers.css) {
+                element.style.setProperty('--width', `${sizes.width}px`);
+                element.style.setProperty('--height', `${sizes.height}px`);
+            }
 
-        value?.();
+            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/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,35 @@
+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;
+    }
+
+    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');
+}