@aerogel/core 0.0.0-next.a68f133e2c9a1ae9ba84b4e2e42df909289e5fba → 0.0.0-next.aa6e27a9c197d1ee10c9fe018ee8c0fc6ff77767

package/src/components/headless/HeadlessInput.vue

@@ -0,0 +1,59 @@
+<template>
+    <component :is="as">
+        <slot />
+    </component>
+</template>
+
+<script setup lang="ts">
+import { computed, inject, provide, readonly } from 'vue';
+import { uuid } from '@noeldemartin/utils';
+
+import type FormController from '@aerogel/core/forms/FormController';
+import type { FormFieldValue } from '@aerogel/core/forms/FormController';
+import type { InputEmits, InputExpose, InputProps } from '@aerogel/core/components/contracts/Input';
+
+const { as = 'div', name, label, description, modelValue } = defineProps<InputProps & { as?: string }>();
+const emit = defineEmits<InputEmits>();
+const form = inject<FormController | null>('form', null);
+const errors = computed(() => {
+    if (!form || !name) {
+        return null;
+    }
+
+    return form.errors[name] ?? null;
+});
+
+const context = {
+    id: `input-${uuid()}`,
+    name: computed(() => name),
+    label: computed(() => label),
+    description: computed(() => description),
+    value: computed(() => {
+        if (form && name) {
+            return form.getFieldValue(name);
+        }
+
+        return modelValue;
+    }),
+    errors: readonly(errors),
+    required: computed(() => {
+        if (!name || !form) {
+            return;
+        }
+
+        return form.getFieldRules(name).includes('required');
+    }),
+    update(value) {
+        if (form && name) {
+            form.setFieldValue(name, value as FormFieldValue);
+
+            return;
+        }
+
+        emit('update:modelValue', value);
+    },
+} satisfies InputExpose;
+
+provide('input', context);
+defineExpose(context);
+</script>

package/src/components/headless/HeadlessInputDescription.vue

@@ -0,0 +1,27 @@
+<template>
+    <slot :id="`${input.id}-description`">
+        <Markdown
+            v-if="show"
+            v-bind="$attrs"
+            :id="`${input.id}-description`"
+            :text
+        />
+    </slot>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue';
+
+import Markdown from '@aerogel/core/components/ui/Markdown.vue';
+import { injectReactiveOrFail } from '@aerogel/core/utils/vue';
+import type { InputExpose } from '@aerogel/core/components/contracts/Input';
+
+defineOptions({ inheritAttrs: false });
+
+const input = injectReactiveOrFail<InputExpose>(
+    'input',
+    '<HeadlessInputDescription> must be a child of a <HeadlessInput>',
+);
+const text = computed(() => (typeof input.description === 'string' ? input.description : ''));
+const show = computed(() => !!input.description);
+</script>

package/src/components/headless/{forms/AGHeadlessInputError.vue → HeadlessInputError.vue}

@@ -7,15 +7,11 @@
 <script setup lang="ts">
 import { computed } from 'vue';
 
-import { injectReactiveOrFail } from '@/utils/vue';
-import { translateWithDefault } from '@/lang/utils';
+import { injectReactiveOrFail } from '@aerogel/core/utils/vue';
+import { translateWithDefault } from '@aerogel/core/lang/utils';
+import type { InputExpose } from '@aerogel/core/components/contracts/Input';
 
-import type { IAGHeadlessInput } from './AGHeadlessInput';
-
-const input = injectReactiveOrFail<IAGHeadlessInput>(
-    'input',
-    '<AGHeadlessInputError> must be a child of a <AGHeadlessInput>',
-);
+const input = injectReactiveOrFail<InputExpose>('input', '<HeadlessInputError> must be a child of a <HeadlessInput>');
 const errorMessage = computed(() => {
     if (!input.errors) {
         return null;

package/src/components/headless/HeadlessInputInput.vue

@@ -0,0 +1,75 @@
+<template>
+    <input
+        :id="input.id"
+        ref="$input"
+        :name
+        :type
+        :checked
+        :required="input.required ?? undefined"
+        :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, watchEffect } from 'vue';
+
+import { injectReactiveOrFail } from '@aerogel/core/utils/vue';
+import { onFormFocus } from '@aerogel/core/components/utils';
+import type { FormFieldValue } from '@aerogel/core/forms/FormController';
+import type { InputExpose } from '@aerogel/core/components/contracts/Input';
+
+const { type = 'text' } = defineProps<{ type?: string }>();
+const $input = ref<HTMLInputElement>();
+const input = injectReactiveOrFail<InputExpose>('input', '<HeadlessInputInput> must be a child of a <HeadlessInput>');
+const name = computed(() => input.name ?? undefined);
+const value = computed(() => input.value);
+const checked = computed(() => {
+    if (type !== 'checkbox') {
+        return;
+    }
+
+    return !!value.value;
+});
+
+function update() {
+    if (!$input.value) {
+        return;
+    }
+
+    input.update(getValue());
+}
+
+function getValue(): FormFieldValue | null {
+    if (!$input.value) {
+        return null;
+    }
+
+    switch (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 (type === 'date') {
+        $input.value.valueAsDate = value.value as Date;
+
+        return;
+    }
+
+    $input.value.value = (value.value as string) ?? null;
+});
+</script>

package/src/components/headless/{forms/AGHeadlessInputLabel.vue → HeadlessInputLabel.vue}

@@ -9,14 +9,10 @@
 <script setup lang="ts">
 import { computed, useSlots } from 'vue';
 
-import { injectReactiveOrFail } from '@/utils/vue';
+import { injectReactiveOrFail } from '@aerogel/core/utils/vue';
+import type { InputExpose } from '@aerogel/core/components/contracts/Input';
 
-import type { IAGHeadlessInput } from './AGHeadlessInput';
-
-const input = injectReactiveOrFail<IAGHeadlessInput>(
-    'input',
-    '<AGHeadlessInputLabel> must be a child of a <AGHeadlessInput>',
-);
+const input = injectReactiveOrFail<InputExpose>('input', '<HeadlessInputLabel> must be a child of a <HeadlessInput>');
 const slots = useSlots();
 const show = computed(() => !!(input.label || slots.default));
 </script>

package/src/components/headless/HeadlessInputTextArea.vue

@@ -0,0 +1,40 @@
+<template>
+    <textarea
+        :id="input.id"
+        ref="$textArea"
+        :name
+        :value
+        :required="input.required ?? undefined"
+        :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 { onFormFocus } from '@aerogel/core/components/utils';
+import { injectReactiveOrFail } from '@aerogel/core/utils/vue';
+import type { InputExpose } from '@aerogel/core/components/contracts/Input';
+
+const $textArea = ref<HTMLTextAreaElement>();
+const input = injectReactiveOrFail<InputExpose>(
+    'input',
+    '<HeadlessInputTextArea> must be a child of a <HeadlessInput>',
+);
+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/{modals/AGHeadlessModal.vue → HeadlessModal.vue}

@@ -1,29 +1,30 @@
 <template>
-    <Dialog ref="$root" :open="true" @close="cancellable && close()">
-        <slot :close="close" />
-    </Dialog>
+    <DialogRoot ref="$root" open @update:open="persistent || close()">
+        <DialogPortal>
+            <slot :close="close" />
+        </DialogPortal>
+    </DialogRoot>
 </template>
 
 <script setup lang="ts">
-import { ref, toRef } from 'vue';
-import { Dialog } from '@headlessui/vue';
-import type { VNode } from 'vue';
+import { ref } from 'vue';
+import { DialogPortal, DialogRoot } from 'reka-ui';
 
-import Events from '@/services/Events';
-import { useEvent } from '@/utils/composition/events';
-import { injectReactiveOrFail } from '@/utils/vue';
-import type { IAGModalContext } from '@/components/modals/AGModalContext';
+import Events from '@aerogel/core/services/Events';
+import { useEvent } from '@aerogel/core/utils/composition/events';
+import { injectReactiveOrFail } from '@aerogel/core/utils/vue';
+import type { UIModalContext } from '@aerogel/core/ui/UI.state';
+import type { ModalExpose, ModalProps, ModalSlots } from '@aerogel/core/components/contracts/Modal';
 
-import { useModalProps } from './AGHeadlessModal';
-import type { IAGHeadlessModal, IAGHeadlessModalDefaultSlotProps } from './AGHeadlessModal';
+defineProps<ModalProps>();
+defineSlots<ModalSlots>();
 
-const props = defineProps(useModalProps());
 const $root = ref<{ $el?: HTMLElement } | null>(null);
 const hidden = ref(true);
 const closed = ref(false);
-const { modal } = injectReactiveOrFail<IAGModalContext>(
+const { modal } = injectReactiveOrFail<UIModalContext>(
     'modal',
-    'could not obtain modal reference from <AGHeadlessModal>, ' +
+    'could not obtain modal reference from <HeadlessModal>, ' +
         'did you render this component manually? Show it using $ui.openModal() instead',
 );
 
@@ -81,6 +82,5 @@ useEvent('show-modal', async ({ id }) => {
     await show();
 });
 
-defineSlots<{ default(props: IAGHeadlessModalDefaultSlotProps): VNode[] }>();
-defineExpose<IAGHeadlessModal>({ close, cancellable: toRef(props, 'cancellable') });
+defineExpose<ModalExpose>({ close });
 </script>

package/src/components/headless/HeadlessModalContent.vue

@@ -0,0 +1,24 @@
+<template>
+    <DialogContent>
+        <slot />
+
+        <ModalContext v-if="childModal" :child-index="childIndex + 1" :modal="childModal" />
+    </DialogContent>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue';
+import { DialogContent } from 'reka-ui';
+
+import ModalContext from '@aerogel/core/components/ui/ModalContext.vue';
+import UI from '@aerogel/core/ui/UI';
+import { injectReactiveOrFail } from '@aerogel/core/utils/vue';
+import type { UIModalContext } from '@aerogel/core/ui/UI.state';
+
+const { childIndex = 0 } = injectReactiveOrFail<UIModalContext>(
+    'modal',
+    'could not obtain modal reference from <HeadlessModalContent>, ' +
+        'did you render this component manually? Show it using $ui.openModal() instead',
+);
+const childModal = computed(() => UI.modals[childIndex] ?? null);
+</script>

package/src/components/headless/HeadlessModalOverlay.vue

@@ -0,0 +1,12 @@
+<template>
+    <DialogOverlay v-bind="$props">
+        <slot />
+    </DialogOverlay>
+</template>
+
+<script setup lang="ts">
+import { DialogOverlay } from 'reka-ui';
+import type { DialogOverlayProps } from 'reka-ui';
+
+defineProps<DialogOverlayProps>();
+</script>

package/src/components/headless/HeadlessModalTitle.vue

@@ -0,0 +1,12 @@
+<template>
+    <DialogTitle v-bind="$props">
+        <slot />
+    </DialogTitle>
+</template>
+
+<script setup lang="ts">
+import { DialogTitle } from 'reka-ui';
+import type { DialogTitleProps } from 'reka-ui';
+
+defineProps<DialogTitleProps>();
+</script>

package/src/components/headless/HeadlessSelect.vue

@@ -0,0 +1,105 @@
+<template>
+    <SelectRoot v-slot="{ open }: ComponentProps" :model-value="acceptableValue" @update:model-value="update($event)">
+        <component :is="as" v-bind="$attrs">
+            <slot :model-value :open>
+                <HeadlessSelectTrigger />
+                <HeadlessSelectOptions />
+            </slot>
+        </component>
+    </SelectRoot>
+</template>
+
+<script setup lang="ts">
+import { computed, inject, provide, readonly } from 'vue';
+import { value as evaluate, toString, uuid } from '@noeldemartin/utils';
+import { SelectRoot } from 'reka-ui';
+import type { AcceptableValue } from 'reka-ui';
+
+import { translateWithDefault } from '@aerogel/core/lang';
+import { hasSelectOptionLabel } from '@aerogel/core/components/contracts/Select';
+import type FormController from '@aerogel/core/forms/FormController';
+import type { ComponentProps } from '@aerogel/core/utils/vue';
+import type { SelectEmits, SelectExpose, SelectProps } from '@aerogel/core/components/contracts/Select';
+import type { FormFieldValue } from '@aerogel/core/forms/FormController';
+
+import HeadlessSelectTrigger from './HeadlessSelectTrigger.vue';
+import HeadlessSelectOptions from './HeadlessSelectOptions.vue';
+
+defineOptions({ inheritAttrs: false });
+
+const {
+    name,
+    as = 'template',
+    label,
+    options,
+    renderOption,
+    description,
+    placeholder,
+    modelValue,
+} = defineProps<SelectProps>();
+const emit = defineEmits<SelectEmits>();
+const form = inject<FormController | null>('form', null);
+const acceptableValue = computed(() => modelValue as AcceptableValue);
+const errors = computed(() => {
+    if (!form || !name) {
+        return null;
+    }
+
+    return form.errors[name] ?? null;
+});
+const computedOptions = computed(() => {
+    if (!options) {
+        return null;
+    }
+
+    return options.map((option) => ({
+        key: uuid(),
+        label: renderOption
+            ? renderOption(option)
+            : hasSelectOptionLabel(option)
+                ? evaluate(option.label as string)
+                : toString(option),
+        value: option as AcceptableValue,
+    }));
+});
+const context = {
+    id: `select-${uuid()}`,
+    name: computed(() => name),
+    label: computed(() => label),
+    description: computed(() => description),
+    placeholder: computed(() => placeholder ?? translateWithDefault('ui.select', 'Select an option')),
+    options: computedOptions,
+    selectedOption: computed(() => computedOptions.value?.find((option) => option.value === modelValue)),
+    value: computed(() => {
+        if (form && name) {
+            return form.getFieldValue(name);
+        }
+
+        return modelValue;
+    }),
+    errors: readonly(errors),
+    required: computed(() => {
+        if (!name || !form) {
+            return;
+        }
+
+        return form.getFieldRules(name).includes('required');
+    }),
+    update(value) {
+        if (form && name) {
+            form.setFieldValue(name, value as FormFieldValue);
+
+            return;
+        }
+
+        emit('update:modelValue', value);
+    },
+} satisfies SelectExpose;
+
+function update(value: AcceptableValue) {
+    context.update(value as FormFieldValue);
+}
+
+provide('select', context);
+defineExpose(context);
+</script>

package/src/components/headless/{forms/AGHeadlessSelectError.vue → HeadlessSelectError.vue}

@@ -7,14 +7,13 @@
 <script setup lang="ts">
 import { computed } from 'vue';
 
-import { injectReactiveOrFail } from '@/utils/vue';
-import { translateWithDefault } from '@/lang/utils';
+import { injectReactiveOrFail } from '@aerogel/core/utils/vue';
+import { translateWithDefault } from '@aerogel/core/lang/utils';
+import type { SelectExpose } from '@aerogel/core/components/contracts/Select';
 
-import type { IAGHeadlessSelect } from './AGHeadlessSelect';
-
-const select = injectReactiveOrFail<IAGHeadlessSelect>(
+const select = injectReactiveOrFail<SelectExpose>(
     'select',
-    '<AGHeadlessSelectError> must be a child of a <AGHeadlessSelect>',
+    '<HeadlessSelectError> must be a child of a <HeadlessSelect>',
 );
 const errorMessage = computed(() => {
     if (!select.errors) {

package/src/components/headless/HeadlessSelectLabel.vue

@@ -0,0 +1,25 @@
+<template>
+    <Label v-if="show" :for="select.id" v-bind="$props">
+        <slot>
+            {{ select.label }}
+        </slot>
+    </Label>
+</template>
+
+<script setup lang="ts">
+import { computed, useSlots } from 'vue';
+import { Label } from 'reka-ui';
+import type { LabelProps } from 'reka-ui';
+
+import { injectReactiveOrFail } from '@aerogel/core/utils/vue';
+import type { SelectExpose } from '@aerogel/core/components/contracts/Select';
+
+defineProps<Omit<LabelProps, 'for'>>();
+
+const select = injectReactiveOrFail<SelectExpose>(
+    'select',
+    '<HeadlessSelectLabel> must be a child of a <HeadlessSelect>',
+);
+const slots = useSlots();
+const show = computed(() => !!(select.label || slots.default));
+</script>

package/src/components/headless/HeadlessSelectOption.vue

@@ -0,0 +1,34 @@
+<template>
+    <SelectItem v-bind="$props">
+        <SelectItemText class="the-text">
+            <slot>
+                {{ renderedLabel }}
+            </slot>
+        </SelectItemText>
+    </SelectItem>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue';
+import { SelectItem, SelectItemText } from 'reka-ui';
+import { toString } from '@noeldemartin/utils';
+import type { SelectItemProps } from 'reka-ui';
+
+import { injectReactiveOrFail } from '@aerogel/core/utils/vue';
+import type { SelectExpose } from '@aerogel/core/components/contracts/Select';
+
+const { value } = defineProps<SelectItemProps>();
+const select = injectReactiveOrFail<SelectExpose>(
+    'select',
+    '<HeadlessSelectOption> must be a child of a <HeadlessSelect>',
+);
+const renderedLabel = computed(() => {
+    const itemOption = select.options?.find((option) => option.value === value);
+
+    if (itemOption) {
+        return itemOption.label;
+    }
+
+    return toString(value);
+});
+</script>

package/src/components/headless/HeadlessSelectOptions.vue

@@ -0,0 +1,30 @@
+<template>
+    <SelectPortal>
+        <SelectContent :class="classes">
+            <SelectViewport>
+                <slot>
+                    <HeadlessSelectOption
+                        v-for="option in select.options ?? []"
+                        :key="option.key"
+                        :value="option.value"
+                    />
+                </slot>
+            </SelectViewport>
+        </SelectContent>
+    </SelectPortal>
+</template>
+
+<script setup lang="ts">
+import { SelectContent, SelectPortal, SelectViewport } from 'reka-ui';
+
+import { injectReactiveOrFail } from '@aerogel/core/utils';
+import type { SelectExpose } from '@aerogel/core/components/contracts/Select';
+
+import HeadlessSelectOption from './HeadlessSelectOption.vue';
+
+const { class: classes } = defineProps<{ class?: string }>();
+const select = injectReactiveOrFail<SelectExpose>(
+    'select',
+    '<HeadlessSelectOptions> must be a child of a <HeadlessSelect>',
+);
+</script>

package/src/components/headless/HeadlessSelectTrigger.vue

@@ -0,0 +1,22 @@
+<template>
+    <SelectTrigger :id="select.id">
+        <slot>
+            <HeadlessSelectValue :placeholder="select.placeholder" />
+            <SelectIcon />
+        </slot>
+    </SelectTrigger>
+</template>
+
+<script setup lang="ts">
+import { SelectIcon, SelectTrigger } from 'reka-ui';
+
+import { injectReactiveOrFail } from '@aerogel/core/utils';
+import type { SelectExpose } from '@aerogel/core/components/contracts/Select';
+
+import HeadlessSelectValue from './HeadlessSelectValue.vue';
+
+const select = injectReactiveOrFail<SelectExpose>(
+    'select',
+    '<HeadlessSelectTrigger> must be a child of a <HeadlessSelect>',
+);
+</script>

package/src/components/headless/HeadlessSelectValue.vue

@@ -0,0 +1,15 @@
+<template>
+    <SelectValue :placeholder="select.placeholder" />
+</template>
+
+<script setup lang="ts">
+import { SelectValue } from 'reka-ui';
+
+import { injectReactiveOrFail } from '@aerogel/core/utils/vue';
+import type { SelectExpose } from '@aerogel/core/components/contracts/Select';
+
+const select = injectReactiveOrFail<SelectExpose>(
+    'select',
+    '<HeadlessSelectValue> must be a child of a <HeadlessSelect>',
+);
+</script>

package/src/components/headless/HeadlessToast.vue

@@ -0,0 +1,18 @@
+<template>
+    <ToastRoot>
+        <slot>
+            <span v-if="message">{{ message }}</span>
+            <HeadlessToastAction v-for="(action, key) of actions" :key :action />
+        </slot>
+    </ToastRoot>
+</template>
+
+<script setup lang="ts">
+import { ToastRoot } from 'reka-ui';
+
+import type { ToastProps } from '@aerogel/core/components/contracts/Toast';
+
+import HeadlessToastAction from './HeadlessToastAction.vue';
+
+defineProps<ToastProps>();
+</script>

package/src/components/headless/HeadlessToastAction.vue

@@ -0,0 +1,13 @@
+<template>
+    <component :is="action.dismiss ? ToastClose : 'button'" type="button" @click="action.click">
+        {{ action.label }}
+    </component>
+</template>
+
+<script setup lang="ts">
+import { ToastClose } from 'reka-ui';
+
+import type { ToastAction as IToastAction } from '@aerogel/core/components/contracts/Toast';
+
+defineProps<{ action: IToastAction }>();
+</script>

package/src/components/headless/index.ts

@@ -1,3 +1,18 @@
-export * from './forms';
-export * from './modals';
-export * from './snackbars';
+export { default as HeadlessButton } from './HeadlessButton.vue';
+export { default as HeadlessInput } from './HeadlessInput.vue';
+export { default as HeadlessInputDescription } from './HeadlessInputDescription.vue';
+export { default as HeadlessInputError } from './HeadlessInputError.vue';
+export { default as HeadlessInputInput } from './HeadlessInputInput.vue';
+export { default as HeadlessInputLabel } from './HeadlessInputLabel.vue';
+export { default as HeadlessInputTextArea } from './HeadlessInputTextArea.vue';
+export { default as HeadlessModal } from './HeadlessModal.vue';
+export { default as HeadlessModalContent } from './HeadlessModalContent.vue';
+export { default as HeadlessModalOverlay } from './HeadlessModalOverlay.vue';
+export { default as HeadlessModalTitle } from './HeadlessModalTitle.vue';
+export { default as HeadlessSelect } from './HeadlessSelect.vue';
+export { default as HeadlessSelectLabel } from './HeadlessSelectLabel.vue';
+export { default as HeadlessSelectOption } from './HeadlessSelectOption.vue';
+export { default as HeadlessSelectOptions } from './HeadlessSelectOptions.vue';
+export { default as HeadlessSelectTrigger } from './HeadlessSelectTrigger.vue';
+export { default as HeadlessSelectValue } from './HeadlessSelectValue.vue';
+export { default as HeadlessToast } from './HeadlessToast.vue';