@aerogel/core 0.1.1-next.c3c3c32e9b674ba4ae2d33973d4659e37c863c35 → 0.1.1-next.d3af81f1f7f69a65742c4d298e0c77c6c3977d2b

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@aerogel/core",
-    "version": "0.1.1-next.c3c3c32e9b674ba4ae2d33973d4659e37c863c35",
+    "version": "0.1.1-next.d3af81f1f7f69a65742c4d298e0c77c6c3977d2b",
     "type": "module",
     "sideEffects": false,
     "exports": {

package/src/components/contracts/Select.ts

@@ -1,8 +1,11 @@
+import { computed, inject, provide, readonly } from 'vue';
+import { evaluate, toString, uuid } from '@noeldemartin/utils';
 import type { AcceptableValue, AsTag, SelectContentProps } from 'reka-ui';
-import type { Component, ComputedRef, HTMLAttributes } from 'vue';
+import type { Component, ComputedRef, EmitFn, HTMLAttributes } from 'vue';
 import type { Nullable } from '@noeldemartin/utils';
 
-import type { FormFieldValue } from '@aerogel/core/forms';
+import { translateWithDefault } from '@aerogel/core/lang';
+import type { FormController, FormFieldValue } from '@aerogel/core/forms';
 
 import type { InputEmits, InputExpose, InputProps } from './Input';
 
@@ -38,8 +41,92 @@ export interface SelectExpose<T extends Nullable<FormFieldValue> = Nullable<Form
     optionsClass?: HTMLAttributes['class'];
     align?: SelectContentProps['align'];
     side?: SelectContentProps['side'];
+    renderOption: (option: T) => string;
 }
 
 export function hasSelectOptionLabel(option: unknown): option is HasSelectOptionLabel {
     return typeof option === 'object' && option !== null && 'label' in option;
 }
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export function useSelect<T extends Nullable<FormFieldValue>>(props: SelectProps<T>, emit: EmitFn<SelectEmits<T>>) {
+    const form = inject<FormController | null>('form', null);
+    const renderOption = (option: T): string => {
+        if (option === undefined) {
+            return '';
+        }
+
+        return props.renderOption
+            ? props.renderOption(option)
+            : hasSelectOptionLabel(option)
+                ? evaluate(option.label as string)
+                : toString(option);
+    };
+    const computedValue = computed(() => {
+        if (form && props.name) {
+            return form.getFieldValue(props.name) as T;
+        }
+
+        return props.modelValue as T;
+    });
+    const acceptableValue = computed(() => computedValue.value as AcceptableValue);
+    const errors = computed(() => {
+        if (!form || !props.name) {
+            return null;
+        }
+
+        return form.errors[props.name] ?? null;
+    });
+    const computedOptions = computed(() => {
+        if (!props.options) {
+            return null;
+        }
+
+        return props.options.map((option) => ({
+            key: uuid(),
+            label: renderOption(option),
+            value: option as AcceptableValue,
+        }));
+    });
+
+    const expose = {
+        renderOption,
+        labelClass: props.labelClass,
+        optionsClass: props.optionsClass,
+        align: props.align,
+        side: props.side,
+        value: computedValue,
+        id: `select-${uuid()}`,
+        name: computed(() => props.name),
+        label: computed(() => props.label),
+        description: computed(() => props.description),
+        placeholder: computed(() => props.placeholder ?? translateWithDefault('ui.select', 'Select an option')),
+        options: computedOptions,
+        selectedOption: computed(() => computedOptions.value?.find((option) => option.value === props.modelValue)),
+        errors: readonly(errors),
+        required: computed(() => {
+            if (!props.name || !form) {
+                return;
+            }
+
+            return form.getFieldRules(props.name).includes('required');
+        }),
+        update(value) {
+            if (form && props.name) {
+                form.setFieldValue(props.name, value as FormFieldValue);
+
+                return;
+            }
+
+            emit('update:modelValue', value);
+        },
+    } satisfies SelectExpose<T>;
+
+    function update(value: AcceptableValue) {
+        expose.update(value as T);
+    }
+
+    provide('select', expose);
+
+    return { expose, acceptableValue, update, renderOption };
+}

package/src/components/headless/HeadlessSelect.vue

@@ -2,7 +2,7 @@
     <SelectRoot
         v-slot="{ open }"
         :model-value="acceptableValue"
-        :by="compareOptions as Closure<[AcceptableValue, AcceptableValue], boolean>"
+        :by="compareOptions"
         @update:model-value="update($event)"
     >
         <component :is="as" v-bind="$attrs">
@@ -15,16 +15,11 @@
 </template>
 
 <script setup lang="ts" generic="T extends Nullable<FormFieldValue>">
-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 type { Closure, Nullable } from '@noeldemartin/utils';
+import type { Nullable } from '@noeldemartin/utils';
 
-import { translateWithDefault } from '@aerogel/core/lang';
-import { hasSelectOptionLabel } from '@aerogel/core/components/contracts/Select';
-import type FormController from '@aerogel/core/forms/FormController';
-import type { SelectEmits, SelectExpose, SelectProps } from '@aerogel/core/components/contracts/Select';
+import { useSelect } from '@aerogel/core/components/contracts/Select';
+import type { SelectEmits, SelectProps } from '@aerogel/core/components/contracts/Select';
 import type { FormFieldValue } from '@aerogel/core/forms/FormController';
 
 import HeadlessSelectTrigger from './HeadlessSelectTrigger.vue';
@@ -32,89 +27,9 @@ import HeadlessSelectOptions from './HeadlessSelectOptions.vue';
 
 defineOptions({ inheritAttrs: false });
 
-const {
-    name,
-    as = 'div',
-    label,
-    options,
-    labelClass,
-    optionsClass,
-    renderOption,
-    compareOptions = (a, b) => a === b,
-    description,
-    placeholder,
-    modelValue,
-    align,
-    side,
-} = defineProps<SelectProps<T>>();
 const emit = defineEmits<SelectEmits<T>>();
-const form = inject<FormController | null>('form', null);
-const computedValue = computed(() => {
-    if (form && name) {
-        return form.getFieldValue(name) as T;
-    }
+const { as = 'div', compareOptions = (a, b) => a === b, ...props } = defineProps<SelectProps<T>>();
+const { expose, acceptableValue, update } = useSelect({ as, compareOptions, ...props }, emit);
 
-    return modelValue as T;
-});
-const acceptableValue = computed(() => computedValue.value 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 expose = {
-    labelClass,
-    optionsClass,
-    align,
-    side,
-    value: computedValue,
-    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)),
-    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<T>;
-
-function update(value: AcceptableValue) {
-    expose.update(value as T);
-}
-
-provide('select', expose);
 defineExpose(expose);
 </script>

package/src/components/headless/HeadlessSelectOption.vue

@@ -25,10 +25,6 @@ const select = injectReactiveOrFail<SelectExpose>(
 const renderedLabel = computed(() => {
     const itemOption = select.options?.find((option) => option.value === value);
 
-    if (itemOption) {
-        return itemOption.label;
-    }
-
-    return toString(value);
+    return itemOption ? select.renderOption(itemOption.value) : toString(value);
 });
 </script>

package/src/components/index.ts

@@ -5,3 +5,4 @@ export { default as AppToasts } from './AppToasts.vue';
 export * from './contracts';
 export * from './headless';
 export * from './ui';
+export * from './vue';

package/src/components/ui/Combobox.vue

@@ -0,0 +1,41 @@
+<template>
+    <ComboboxRoot
+        open-on-focus
+        ignore-filter
+        :model-value="acceptableValue"
+        :by="compareOptions"
+        @update:model-value="update($event)"
+    >
+        <ProvideRef v-model="input" name="combobox-input">
+            <ComboboxLabel />
+            <ComboboxTrigger />
+            <ComboboxOptions :new-input-value />
+        </ProvideRef>
+    </ComboboxRoot>
+</template>
+
+<script setup lang="ts" generic="T extends Nullable<FormFieldValue>">
+import { ComboboxRoot } from 'reka-ui';
+import { ref } from 'vue';
+import type { Nullable } from '@noeldemartin/utils';
+
+import ProvideRef from '@aerogel/core/components/vue/ProvideRef.vue';
+import { useSelect } from '@aerogel/core/components/contracts/Select';
+import type { SelectEmits, SelectProps } from '@aerogel/core/components/contracts/Select';
+import type { FormFieldValue } from '@aerogel/core/forms';
+
+import ComboboxOptions from './ComboboxOptions.vue';
+import ComboboxTrigger from './ComboboxTrigger.vue';
+import ComboboxLabel from './ComboboxLabel.vue';
+
+const emit = defineEmits<SelectEmits<T>>();
+const {
+    as = 'div',
+    compareOptions = (a, b) => a === b,
+    ...props
+} = defineProps<SelectProps<T> & { newInputValue?: (value: string) => T }>();
+const { expose, acceptableValue, update, renderOption } = useSelect({ as, compareOptions, ...props }, emit);
+const input = ref(acceptableValue.value ? renderOption(acceptableValue.value as T) : '');
+
+defineExpose(expose);
+</script>

package/src/components/ui/ComboboxLabel.vue

@@ -0,0 +1,29 @@
+<template>
+    <Label
+        v-if="show"
+        :for="select.id"
+        :class="renderedClasses"
+        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 { classes } from '@aerogel/core/utils';
+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', '<ComboboxLabel> must be a child of a <Combobox>');
+const slots = useSlots();
+const show = computed(() => !!(select.label || slots.default));
+const renderedClasses = computed(() => classes('block text-sm leading-6 font-medium text-gray-900', select.labelClass));
+</script>

package/src/components/ui/ComboboxOption.vue

@@ -0,0 +1,28 @@
+<template>
+    <ComboboxItem v-bind="$props" class="group p-1 outline-none">
+        <div
+            class="relative flex max-w-[calc(100vw-2rem)] cursor-pointer items-center gap-2 truncate rounded-md px-2 py-1 text-sm select-none *:truncate group-data-[highlighted]:bg-gray-100 group-data-[state=checked]:font-semibold group-data-[state=unchecked]:opacity-50"
+        >
+            <slot>
+                {{ renderedLabel }}
+            </slot>
+        </div>
+    </ComboboxItem>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue';
+import { ComboboxItem, type ComboboxItemProps } from 'reka-ui';
+import { toString } from '@noeldemartin/utils';
+
+import { injectReactiveOrFail } from '@aerogel/core/utils';
+import type { SelectExpose } from '@aerogel/core/components/contracts/Select';
+
+const { value } = defineProps<ComboboxItemProps>();
+const select = injectReactiveOrFail<SelectExpose>('select', '<ComboboxOption> must be a child of a <Combobox>');
+const renderedLabel = computed(() => {
+    const itemOption = select.options?.find((option) => option.value === value);
+
+    return itemOption ? select.renderOption(itemOption.value) : toString(value);
+});
+</script>

package/src/components/ui/ComboboxOptions.vue

@@ -0,0 +1,58 @@
+<template>
+    <ComboboxPortal>
+        <ComboboxContent
+            position="popper"
+            :align="select.align"
+            :side="select.side"
+            :side-offset="4"
+            :class="renderedClasses"
+        >
+            <ComboboxViewport>
+                <ComboboxEmpty class="group p-1 outline-none">
+                    <div
+                        class="relative flex max-w-[calc(100vw-2rem)] items-center gap-2 truncate rounded-md px-2 py-1 text-sm select-none *:truncate"
+                    >
+                        {{ $td('ui.comboboxEmpty', 'No options found') }}
+                    </div>
+                </ComboboxEmpty>
+
+                <ComboboxGroup>
+                    <ComboboxOption
+                        v-if="showInputOption"
+                        :value="newInputValue?.(input) ?? (input as AcceptableValue)"
+                    >
+                        {{ input }}
+                    </ComboboxOption>
+                    <ComboboxOption v-for="option in filteredOptions" :key="option.key" :value="option.value" />
+                </ComboboxGroup>
+            </ComboboxViewport>
+        </ComboboxContent>
+    </ComboboxPortal>
+</template>
+
+<script setup lang="ts">
+import { ComboboxContent, ComboboxEmpty, ComboboxGroup, ComboboxPortal, ComboboxViewport, useFilter } from 'reka-ui';
+import { computed } from 'vue';
+import type { Ref } from 'vue';
+import type { Nullable } from '@noeldemartin/utils';
+import type { AcceptableValue } from 'reka-ui';
+
+import { classes, injectOrFail, injectReactiveOrFail } from '@aerogel/core/utils';
+import type { FormFieldValue } from '@aerogel/core/forms';
+import type { SelectExpose } from '@aerogel/core/components/contracts/Select';
+
+import ComboboxOption from './ComboboxOption.vue';
+
+const { contains } = useFilter({ sensitivity: 'base' });
+const { newInputValue } = defineProps<{ newInputValue?: (value: string) => Nullable<FormFieldValue> }>();
+const select = injectReactiveOrFail<SelectExpose>('select', '<ComboboxOptions> must be a child of a <Combobox>');
+const input = injectOrFail<Ref<string>>('combobox-input');
+const filteredOptions = computed(() => select.options?.filter((option) => contains(option.label, input.value)) ?? []);
+const showInputOption = computed(
+    () => input.value && !filteredOptions.value.some((option) => option.label === input.value),
+);
+const renderedClasses = classes(
+    'max-h-(--reka-combobox-content-available-height) min-w-(--reka-combobox-trigger-width)',
+    'z-50 overflow-auto rounded-lg bg-white text-base shadow-lg ring-1 ring-black/5 focus:outline-hidden',
+);
+</script>

package/src/components/ui/ComboboxTrigger.vue

@@ -0,0 +1,35 @@
+<template>
+    <ComboboxAnchor>
+        <ComboboxInput
+            :id="select.id"
+            v-model="input"
+            :placeholder="select.placeholder"
+            :class="renderedRootClasses"
+            :display-value="select.renderOption"
+            :name="select.name"
+        />
+    </ComboboxAnchor>
+</template>
+
+<script setup lang="ts">
+import { ComboboxAnchor, ComboboxInput } from 'reka-ui';
+import { computed } from 'vue';
+import type { Ref } from 'vue';
+
+import { classes, injectOrFail, injectReactiveOrFail } from '@aerogel/core/utils';
+import type { SelectExpose } from '@aerogel/core/components/contracts/Select';
+
+const select = injectReactiveOrFail<SelectExpose>('select', '<ComboboxTrigger> must be a child of a <Combobox>');
+const input = injectOrFail<Ref<string>>('combobox-input');
+const renderedRootClasses = computed(() =>
+    classes(
+        // eslint-disable-next-line vue/max-len
+        'block w-full rounded-md border-0 py-1.5 ring-1 ring-inset focus:ring-2 focus:ring-inset sm:text-sm sm:leading-6',
+        {
+            'mt-1': select.label,
+            'focus:ring-primary-600': !select.errors,
+            'text-gray-900 shadow-2xs ring-gray-900/10 placeholder:text-gray-400': !select.errors,
+            'pr-10 text-red-900 ring-red-900/10 placeholder:text-red-300 focus:ring-red-500': select.errors,
+        },
+    ));
+</script>

package/src/components/ui/Details.vue

@@ -26,7 +26,7 @@ const {
 const renderedContentClasses = computed(() => classes('pt-2 pl-4', contentClass));
 const renderedSummaryClasses = computed(() =>
     classes(
-        '-ml-2 flex w-[max-content] items-center rounded-lg py-2 pr-3 pl-1',
+        '-ml-2 flex w-[max-content] items-center rounded-lg py-2 pr-3 pl-1 max-w-full',
         'hover:bg-gray-100 focus-visible:outline focus-visible:outline-gray-700',
         summaryClass,
     ));

package/src/components/ui/index.ts

@@ -2,6 +2,11 @@ export { default as AdvancedOptions } from './AdvancedOptions.vue';
 export { default as AlertModal } from './AlertModal.vue';
 export { default as Button } from './Button.vue';
 export { default as Checkbox } from './Checkbox.vue';
+export { default as Combobox } from './Combobox.vue';
+export { default as ComboboxLabel } from './ComboboxLabel.vue';
+export { default as ComboboxOption } from './ComboboxOption.vue';
+export { default as ComboboxOptions } from './ComboboxOptions.vue';
+export { default as ComboboxTrigger } from './ComboboxTrigger.vue';
 export { default as ConfirmModal } from './ConfirmModal.vue';
 export { default as Details } from './Details.vue';
 export { default as DropdownMenu } from './DropdownMenu.vue';

package/src/components/vue/ProvideRef.vue

@@ -0,0 +1,12 @@
+<template>
+    <slot />
+</template>
+
+<script setup lang="ts">
+import { provide } from 'vue';
+
+const { name } = defineProps<{ name: string }>();
+const model = defineModel<unknown>();
+
+provide(name, model);
+</script>

package/src/components/vue/index.ts

@@ -0,0 +1 @@
+export { default as ProvideRef } from './ProvideRef.vue';