@aerogel/core 0.0.0-next.9a1c5ba39a454b316eba36ec7bdf579fed3d95d2 → 0.0.0-next.9aa7c279868edbedbcee075aef52212597d803fb

package/src/utils/vue.ts

@@ -1,59 +1,21 @@
 import { fail, toString } from '@noeldemartin/utils';
-import { computed, inject, reactive, ref, watch } from 'vue';
-import type { Directive, InjectionKey, MaybeRef, PropType, Ref, UnwrapNestedRefs } from 'vue';
+import { Comment, Static, Text, inject, reactive } from 'vue';
+import type { Directive, InjectionKey, MaybeRef, Ref, UnwrapNestedRefs, VNode } from 'vue';
 
 export type AcceptRefs<T> = { [K in keyof T]: T[K] | RefUnion<T[K]> };
-export type BaseProp<T> = { type?: PropType<T>; validator?(value: unknown): boolean };
-export type ComponentProps<T = {}> = T & Record<string, unknown>;
-export type OptionalProp<T> = BaseProp<T> & { default: T | (() => T) | null };
 export type RefUnion<T> = T extends infer R ? Ref<R> : never;
-export type RequiredProp<T> = BaseProp<T> & { required: true };
 export type Unref<T> = { [K in keyof T]: T[K] extends MaybeRef<infer Value> ? Value : T[K] };
 
-export function arrayProp<T>(defaultValue?: () => T[]): OptionalProp<T[]> {
-    return {
-        type: Array as PropType<T[]>,
-        default: defaultValue ?? (() => []),
-    };
-}
-
-export function booleanProp(defaultValue: boolean = false): OptionalProp<boolean> {
-    return {
-        type: Boolean,
-        default: defaultValue,
-    };
-}
-
-export function componentRef<T>(): Ref<UnwrapNestedRefs<T> | undefined> {
-    return ref<UnwrapNestedRefs<T>>();
-}
-
-export function computedAsync<T>(getter: () => Promise<T>): Ref<T | undefined> {
-    const result = ref<T>();
-    const asyncValue = computed(getter);
-
-    watch(asyncValue, async () => (result.value = await asyncValue.value), { immediate: true });
-
-    return result;
+function renderVNodeAttrs(node: VNode): string {
+    return Object.entries(node.props ?? {}).reduce((attrs, [name, value]) => {
+        return attrs + `${name}="${toString(value)}"`;
+    }, '');
 }
 
 export function defineDirective(directive: Directive): Directive {
     return directive;
 }
 
-export function enumProp<Enum extends Record<string, unknown>>(
-    enumeration: Enum,
-    defaultValue?: Enum[keyof Enum],
-): OptionalProp<Enum[keyof Enum]> {
-    const values = Object.values(enumeration) as Enum[keyof Enum][];
-
-    return {
-        type: String as unknown as PropType<Enum[keyof Enum]>,
-        default: defaultValue ?? values[0] ?? null,
-        validator: (value) => values.includes(value as Enum[keyof Enum]),
-    };
-}
-
 export function injectReactive<T extends object>(key: InjectionKey<T> | string): UnwrapNestedRefs<T> | undefined {
     const value = inject(key);
 
@@ -71,92 +33,24 @@ export function injectOrFail<T>(key: InjectionKey<T> | string, errorMessage?: st
     return inject(key) ?? fail(errorMessage ?? `Could not resolve '${toString(key)}' injection key`);
 }
 
-export function listenerProp<T extends Function = Function>(): OptionalProp<T | null> {
-    return {
-        type: Function as PropType<T>,
-        default: null,
-    };
-}
-
-export function mixedProp<T>(type?: PropType<T>): OptionalProp<T | null>;
-export function mixedProp<T>(type: PropType<T>, defaultValue: T): OptionalProp<T>;
-export function mixedProp<T>(type?: PropType<T>, defaultValue?: T): OptionalProp<T | null> {
-    return {
-        type,
-        default: defaultValue ?? null,
-    };
-}
-
-export function numberProp(): OptionalProp<number | null>;
-export function numberProp(defaultValue: number): OptionalProp<number>;
-export function numberProp(defaultValue: number | null = null): OptionalProp<number | null> {
-    return {
-        type: Number,
-        default: defaultValue,
-    };
-}
-
-export function objectProp<T = Object>(): OptionalProp<T | null>;
-export function objectProp<T>(defaultValue: () => T): OptionalProp<T>;
-export function objectProp<T = Object>(defaultValue: (() => T) | null = null): OptionalProp<T | null> {
-    return {
-        type: Object,
-        default: defaultValue,
-    };
-}
-
-export function requiredArrayProp<T>(): RequiredProp<T[]> {
-    return {
-        type: Array as PropType<T[]>,
-        required: true,
-    };
-}
-
-export function requiredEnumProp<Enum extends Record<string, unknown>>(
-    enumeration: Enum,
-): RequiredProp<Enum[keyof Enum]> {
-    const values = Object.values(enumeration);
+export function renderVNode(node: VNode | string): string {
+    if (typeof node === 'string') {
+        return node;
+    }
 
-    return {
-        type: String as unknown as PropType<Enum[keyof Enum]>,
-        required: true,
-        validator: (value) => values.includes(value),
-    };
-}
-
-export function requiredMixedProp<T>(type?: PropType<T>): RequiredProp<T> {
-    return {
-        type,
-        required: true,
-    };
-}
+    if (node.type === Comment) {
+        return '';
+    }
 
-export function requiredNumberProp(): RequiredProp<number> {
-    return {
-        type: Number,
-        required: true,
-    };
-}
+    if (node.type === Text || node.type === Static) {
+        return node.children as string;
+    }
 
-export function requiredObjectProp<T = Object>(): RequiredProp<T> {
-    return {
-        type: Object,
-        required: true,
-    };
-}
-
-export function requiredStringProp(): RequiredProp<string> {
-    return {
-        type: String,
-        required: true,
-    };
-}
+    if (node.type === 'br') {
+        return '\n\n';
+    }
 
-export function stringProp(): OptionalProp<string | null>;
-export function stringProp(defaultValue: string): OptionalProp<string>;
-export function stringProp(defaultValue: string | null = null): OptionalProp<string | null> {
-    return {
-        type: String,
-        default: defaultValue,
-    };
+    return `<${node.type} ${renderVNodeAttrs(node)}>${Array.from(node.children as Array<VNode | string>)
+        .map(renderVNode)
+        .join('')}</${node.type}>`;
 }

package/src/components/AGAppLayout.vue

@@ -1,16 +0,0 @@
-<template>
-    <div class="flex min-h-full flex-col text-base font-normal leading-tight text-gray-900 antialiased">
-        <slot v-if="$errors.hasStartupErrors" name="startup-crash">
-            <component :is="$ui.requireComponent(UIComponents.StartupCrash)" />
-        </slot>
-        <slot v-else />
-
-        <AGAppOverlays />
-    </div>
-</template>
-
-<script setup lang="ts">
-import { UIComponents } from '@aerogel/core/ui/UI';
-
-import AGAppOverlays from './AGAppOverlays.vue';
-</script>

package/src/components/AGAppOverlays.vue

@@ -1,41 +0,0 @@
-<template>
-    <div
-        id="aerogel-overlays-backdrop"
-        ref="$backdrop"
-        class="pointer-events-none fixed inset-0 z-50 bg-black/30 opacity-0"
-    />
-    <AGAppModals />
-    <AGAppSnackbars />
-</template>
-
-<script setup lang="ts">
-import { ref } from 'vue';
-
-import { useEvent } from '@aerogel/core/utils/composition/events';
-
-import AGAppModals from './AGAppModals.vue';
-import AGAppSnackbars from './AGAppSnackbars.vue';
-
-const $backdrop = ref<HTMLElement | null>(null);
-const backdropHidden = ref(true);
-
-useEvent('show-overlays-backdrop', async () => {
-    if (!$backdrop.value || !backdropHidden.value) {
-        return;
-    }
-
-    backdropHidden.value = false;
-
-    $backdrop.value.classList.remove('opacity-0');
-});
-
-useEvent('hide-overlays-backdrop', async () => {
-    if (!$backdrop.value || backdropHidden.value) {
-        return;
-    }
-
-    backdropHidden.value = true;
-
-    $backdrop.value.classList.add('opacity-0');
-});
-</script>

package/src/components/AGAppSnackbars.vue

@@ -1,13 +0,0 @@
-<template>
-    <div aria-live="assertive" class="pointer-events-none fixed inset-0 z-50 flex items-end px-4 py-6 sm:p-6">
-        <div class="flex w-full flex-col items-end space-y-4">
-            <component
-                :is="snackbar.component"
-                v-for="snackbar of $ui.snackbars"
-                :id="snackbar.id"
-                :key="snackbar.id"
-                v-bind="snackbar.properties"
-            />
-        </div>
-    </div>
-</template>

package/src/components/composition.ts

@@ -1,23 +0,0 @@
-import { customRef } from 'vue';
-import type { Ref } from 'vue';
-
-import { getElement } from '@aerogel/core/components/utils';
-
-export function elementRef(): Ref<HTMLElement | undefined> {
-    return customRef((track, trigger) => {
-        let value: HTMLElement | undefined = undefined;
-
-        return {
-            get() {
-                track();
-
-                return value;
-            },
-            set(newValue) {
-                value = getElement(newValue);
-
-                trigger();
-            },
-        };
-    });
-}

package/src/components/constants.ts

@@ -1,8 +0,0 @@
-export const Colors = {
-    Primary: 'primary',
-    Secondary: 'secondary',
-    Danger: 'danger',
-    Clear: 'clear',
-} as const;
-
-export type Color = (typeof Colors)[keyof typeof Colors];

package/src/components/contracts/shared.ts

@@ -1,9 +0,0 @@
-import type { Ref } from 'vue';
-
-export interface HasElement {
-    $el: Readonly<Ref<HTMLElement | undefined>>;
-}
-
-export interface __SetsElement {
-    __setElement(element?: HTMLElement): void;
-}

package/src/components/forms/AGButton.vue

@@ -1,44 +0,0 @@
-<template>
-    <AGHeadlessButton class="px-2.5 py-1.5 focus-visible:outline focus-visible:outline-2" :class="colorClasses">
-        <slot />
-    </AGHeadlessButton>
-</template>
-
-<script setup lang="ts">
-import { computed } from 'vue';
-
-import { enumProp } from '@aerogel/core/utils/vue';
-import { Colors } from '@aerogel/core/components/constants';
-
-import AGHeadlessButton from '../headless/forms/AGHeadlessButton.vue';
-
-const props = defineProps({
-    color: enumProp(Colors, Colors.Primary),
-});
-
-const colorClasses = computed(() => {
-    switch (props.color) {
-        case Colors.Secondary:
-            return [
-                'text-white bg-gray-600',
-                'hover:bg-gray-500',
-                'focus-visible:outline-offset-2 focus-visible:outline-gray-600',
-            ].join(' ');
-        case Colors.Clear:
-            return 'hover:bg-gray-500/20 focus-visible:outline-gray-500/60';
-        case Colors.Danger:
-            return [
-                'text-white bg-red-600',
-                'hover:bg-red-500',
-                'focus-visible:outline-offset-2 focus-visible:outline-red-600',
-            ].join(' ');
-        case Colors.Primary:
-        default:
-            return [
-                'text-white bg-indigo-600',
-                'hover:bg-indigo-500',
-                'focus-visible:outline-offset-2 focus-visible:outline-indigo-600',
-            ].join(' ');
-    }
-});
-</script>

package/src/components/forms/AGCheckbox.vue

@@ -1,42 +0,0 @@
-<template>
-    <AGHeadlessInput
-        ref="$input"
-        :name="name"
-        class="flex"
-        @update:model-value="$emit('update:modelValue', $event)"
-    >
-        <AGHeadlessInputInput
-            v-bind="$attrs"
-            type="checkbox"
-            :class="{
-                'text-indigo-600 focus:ring-indigo-600': !$input?.errors,
-                'border-red-200 text-red-600 focus:ring-red-600': $input?.errors,
-            }"
-        />
-
-        <div class="ml-2">
-            <AGHeadlessInputLabel v-if="$slots.default">
-                <slot />
-            </AGHeadlessInputLabel>
-            <AGHeadlessInputError class="text-sm text-red-600" />
-        </div>
-    </AGHeadlessInput>
-</template>
-
-<script setup lang="ts">
-import { componentRef, stringProp } from '@aerogel/core/utils/vue';
-
-import { useInputEmits } from '@aerogel/core/components/headless/forms/AGHeadlessInput';
-import type { IAGHeadlessInput } from '@aerogel/core/components/headless/forms/AGHeadlessInput';
-
-import AGHeadlessInput from '../headless/forms/AGHeadlessInput.vue';
-import AGHeadlessInputError from '../headless/forms/AGHeadlessInputError.vue';
-import AGHeadlessInputInput from '../headless/forms/AGHeadlessInputInput.vue';
-import AGHeadlessInputLabel from '../headless/forms/AGHeadlessInputLabel.vue';
-
-defineProps({ name: stringProp() });
-defineOptions({ inheritAttrs: false });
-defineEmits(useInputEmits());
-
-const $input = componentRef<IAGHeadlessInput>();
-</script>

package/src/components/forms/AGInput.vue

@@ -1,42 +0,0 @@
-<template>
-    <AGHeadlessInput
-        ref="$input"
-        class="relative flex flex-col items-center"
-        :class="className"
-        v-bind="props"
-        @update:model-value="$emit('update:modelValue', $event)"
-    >
-        <AGHeadlessInputLabel class="sr-only" />
-        <AGHeadlessInputInput
-            v-bind="attrs"
-            class="block w-full border-0 py-1.5 text-gray-900 ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-indigo-600"
-            :class="{
-                'ring-1 ring-red-500': $input?.errors,
-            }"
-        />
-        <AGHeadlessInputDescription />
-        <div class="absolute bottom-0 left-0 translate-y-full">
-            <AGHeadlessInputError class="mt-1 text-sm text-red-500" />
-        </div>
-    </AGHeadlessInput>
-</template>
-
-<script setup lang="ts">
-import { componentRef } from '@aerogel/core/utils/vue';
-import { useInputAttrs } from '@aerogel/core/utils/composition/forms';
-import { useInputEmits, useInputProps } from '@aerogel/core/components/headless/forms/AGHeadlessInput';
-import type { IAGHeadlessInput } from '@aerogel/core/components/headless/forms/AGHeadlessInput';
-
-import AGHeadlessInput from '../headless/forms/AGHeadlessInput.vue';
-import AGHeadlessInputDescription from '../headless/forms/AGHeadlessInputDescription.vue';
-import AGHeadlessInputError from '../headless/forms/AGHeadlessInputError.vue';
-import AGHeadlessInputInput from '../headless/forms/AGHeadlessInputInput.vue';
-import AGHeadlessInputLabel from '../headless/forms/AGHeadlessInputLabel.vue';
-
-defineOptions({ inheritAttrs: false });
-defineEmits(useInputEmits());
-
-const props = defineProps(useInputProps());
-const $input = componentRef<IAGHeadlessInput>();
-const [attrs, className] = useInputAttrs();
-</script>

package/src/components/forms/AGSelect.story.vue

@@ -1,46 +0,0 @@
-<template>
-    <Story>
-        <div class="h-96">
-            <AGSelect v-model="bestMugiwara" :label="bestMugiwaraLabel" :options="bestMugiwaraOptions" />
-            <AGSelect
-                v-model="bestFood"
-                :label="bestFoodLabel"
-                :options="bestFoodOptions"
-                options-text="name"
-            />
-        </div>
-    </Story>
-</template>
-
-<script setup lang="ts">
-import { ref } from 'vue';
-
-import AGSelect from './AGSelect.vue';
-
-const bestMugiwara = ref(null);
-const bestFood = ref(null);
-const bestMugiwaraLabel = 'Who\'s the best Mugiwara?';
-const bestFoodLabel = 'What\'s the best food?';
-const bestMugiwaraOptions = [
-    'Monkey D. Luffy',
-    'Roronoa Zoro',
-    'Nami',
-    'Usopp',
-    'Sanji',
-    'Tony Tony Chopper',
-    'Nico Robin',
-    'Franky',
-    'Brook',
-    'Jinbe',
-];
-const bestFoodOptions = [
-    {
-        id: 'ramen',
-        name: 'Ramen',
-    },
-    {
-        id: 'pizza',
-        name: 'Pizza',
-    },
-];
-</script>

package/src/components/forms/AGSelect.vue

@@ -1,54 +0,0 @@
-<template>
-    <AGHeadlessSelect
-        v-bind="props"
-        ref="$select"
-        as="div"
-        @update:model-value="$emit('update:modelValue', $event)"
-    >
-        <div class="relative" :class="{ 'mt-2': $select?.label }">
-            <AGHeadlessSelectTrigger
-                class="relative w-full cursor-default bg-white py-1.5 pr-10 pl-3 text-left text-gray-900 ring-1 ring-gray-300 ring-inset focus:ring-2 focus:ring-indigo-600 focus:outline-hidden"
-                text-class="block truncate"
-                :class="{
-                    'ring-1 ring-red-500': $select?.errors,
-                }"
-            >
-                <template #icon>
-                    <span class="pointer-events-none absolute inset-y-0 right-0 flex items-center pr-2">
-                        <IconCheveronDown class="size-5 text-gray-400" />
-                    </span>
-                </template>
-            </AGHeadlessSelectTrigger>
-            <AGHeadlessSelectOptions
-                class="absolute z-10 mt-1 max-h-60 w-full overflow-auto border border-gray-300 bg-white py-1 text-base ring-1 ring-black/5 focus:outline-hidden"
-            >
-                <AGHeadlessSelectOption
-                    v-for="(option, index) in $select?.options ?? []"
-                    :key="index"
-                    :value="option"
-                    class="relative block cursor-default truncate py-2 pr-9 pl-3 text-gray-900 select-none data-[highlighted]:bg-indigo-600 data-[highlighted]:text-white data-[state=checked]:font-semibold data-[state=unchecked]:font-normal"
-                />
-            </AGHeadlessSelectOptions>
-        </div>
-        <AGHeadlessSelectError class="mt-2 text-sm text-red-600" />
-    </AGHeadlessSelect>
-</template>
-
-<script setup lang="ts">
-import IconCheveronDown from '~icons/zondicons/cheveron-down';
-
-import { componentRef } from '@aerogel/core/utils/vue';
-import { useSelectEmits, useSelectProps } from '@aerogel/core/components/headless/forms/AGHeadlessSelect';
-import type { IAGHeadlessSelect } from '@aerogel/core/components/headless/forms/AGHeadlessSelect';
-
-import AGHeadlessSelect from '../headless/forms/AGHeadlessSelect.vue';
-import AGHeadlessSelectTrigger from '../headless/forms/AGHeadlessSelectTrigger.vue';
-import AGHeadlessSelectError from '../headless/forms/AGHeadlessSelectError.vue';
-import AGHeadlessSelectOption from '../headless/forms/AGHeadlessSelectOption.vue';
-import AGHeadlessSelectOptions from '../headless/forms/AGHeadlessSelectOptions.vue';
-
-defineEmits(useSelectEmits());
-
-const props = defineProps(useSelectProps());
-const $select = componentRef<IAGHeadlessSelect>();
-</script>

package/src/components/forms/index.ts

@@ -1,5 +0,0 @@
-export { default as AGButton } from './AGButton.vue';
-export { default as AGCheckbox } from './AGCheckbox.vue';
-export { default as AGForm } from './AGForm.vue';
-export { default as AGInput } from './AGInput.vue';
-export { default as AGSelect } from './AGSelect.vue';

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

@@ -1,3 +0,0 @@
-import type { HasElement } from '@aerogel/core/components/contracts/shared';
-
-export interface IAGHeadlessButton extends HasElement {}

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

@@ -1,62 +0,0 @@
-<template>
-    <component :is="component.as" ref="$root" v-bind="component.props">
-        <slot />
-    </component>
-</template>
-
-<script setup lang="ts">
-import { computed } from 'vue';
-import { objectWithoutEmpty } from '@noeldemartin/utils';
-
-import { booleanProp, objectProp, stringProp } from '@aerogel/core/utils/vue';
-import { elementRef } from '@aerogel/core/components/composition';
-
-import type { IAGHeadlessButton } from './AGHeadlessButton';
-
-const props = defineProps({
-    as: objectProp(),
-    href: stringProp(),
-    url: stringProp(),
-    route: stringProp(),
-    routeParams: objectProp(() => ({})),
-    routeQuery: objectProp(() => ({})),
-    submit: booleanProp(),
-});
-
-const $root = elementRef();
-const component = computed(() => {
-    if (props.as) {
-        return { as: props.as, props: {} };
-    }
-
-    if (props.route) {
-        return {
-            as: 'router-link',
-            props: {
-                to: objectWithoutEmpty({
-                    name: props.route,
-                    params: props.routeParams,
-                    query: props.routeQuery,
-                }),
-            },
-        };
-    }
-
-    if (props.href || props.url) {
-        return {
-            as: 'a',
-            props: {
-                target: '_blank',
-                href: props.href || props.url,
-            },
-        };
-    }
-
-    return {
-        as: 'button',
-        props: { type: props.submit ? 'submit' : 'button' },
-    };
-});
-
-defineExpose<IAGHeadlessButton>({ $el: $root });
-</script>

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

@@ -1,41 +0,0 @@
-import type { ComputedRef, DeepReadonly, ExtractPropTypes, Ref } from 'vue';
-import type { Writable } from '@noeldemartin/utils';
-
-import { mixedProp, stringProp } from '@aerogel/core/utils';
-import { extractComponentProps } from '@aerogel/core/components/utils';
-import type { FormFieldValue } from '@aerogel/core/forms/Form';
-import type { HasElement } from '@aerogel/core/components/contracts/shared';
-
-export interface IAGHeadlessInput extends HasElement {
-    id: string;
-    name: ComputedRef<string | null>;
-    label: ComputedRef<string | null>;
-    description: ComputedRef<string | boolean | null>;
-    value: ComputedRef<FormFieldValue | null>;
-    required: ComputedRef<boolean | null>;
-    errors: DeepReadonly<Ref<string[] | null>>;
-    update(value: FormFieldValue | null): void;
-}
-
-export const inputProps = {
-    name: stringProp(),
-    label: stringProp(),
-    description: stringProp(),
-    modelValue: mixedProp<FormFieldValue>([String, Number, Boolean]),
-};
-
-export const inputEmits = ['update:modelValue'] as const;
-
-export function useInputEmits(): Writable<typeof inputEmits> {
-    return [...inputEmits];
-}
-
-export function useInputProps(): typeof inputProps {
-    return inputProps;
-}
-
-export function extractInputProps<T extends ExtractPropTypes<typeof inputProps>>(
-    props: T,
-): Pick<T, keyof typeof inputProps> {
-    return extractComponentProps(props, inputProps);
-}