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

package/src/ui/index.ts

@@ -1,17 +1,16 @@
-import type { Component } from 'vue';
-
+import AlertModal from '@aerogel/core/components/ui/AlertModal.vue';
+import ConfirmModal from '@aerogel/core/components/ui/ConfirmModal.vue';
+import ErrorReportModal from '@aerogel/core/components/ui/ErrorReportModal.vue';
+import LoadingModal from '@aerogel/core/components/ui/LoadingModal.vue';
+import PromptModal from '@aerogel/core/components/ui/PromptModal.vue';
+import StartupCrash from '@aerogel/core/components/ui/StartupCrash.vue';
+import Toast from '@aerogel/core/components/ui/Toast.vue';
 import { bootServices } from '@aerogel/core/services';
 import { definePlugin } from '@aerogel/core/plugins';
 
-import UI, { UIComponents } from './UI';
-import AGAlertModal from '../components/modals/AGAlertModal.vue';
-import AGConfirmModal from '../components/modals/AGConfirmModal.vue';
-import AGErrorReportModal from '../components/modals/AGErrorReportModal.vue';
-import AGLoadingModal from '../components/modals/AGLoadingModal.vue';
-import AGPromptModal from '../components/modals/AGPromptModal.vue';
-import AGSnackbar from '../components/snackbars/AGSnackbar.vue';
-import AGStartupCrash from '../components/lib/AGStartupCrash.vue';
-import type { UIComponent } from './UI';
+import UI from './UI';
+import type { UIComponents } from './UI';
+import type { Component } from 'vue';
 
 const services = { $ui: UI };
 
@@ -23,20 +22,20 @@ export type UIServices = typeof services;
 
 export default definePlugin({
     async install(app, options) {
-        const defaultComponents = {
-            [UIComponents.AlertModal]: AGAlertModal,
-            [UIComponents.ConfirmModal]: AGConfirmModal,
-            [UIComponents.ErrorReportModal]: AGErrorReportModal,
-            [UIComponents.LoadingModal]: AGLoadingModal,
-            [UIComponents.PromptModal]: AGPromptModal,
-            [UIComponents.Snackbar]: AGSnackbar,
-            [UIComponents.StartupCrash]: AGStartupCrash,
+        const components: Partial<Record<keyof UIComponents, Component>> = {
+            'alert-modal': AlertModal,
+            'confirm-modal': ConfirmModal,
+            'error-report-modal': ErrorReportModal,
+            'loading-modal': LoadingModal,
+            'prompt-modal': PromptModal,
+            'startup-crash': StartupCrash,
+            'toast': Toast,
+            ...options.components,
         };
 
-        Object.entries({
-            ...defaultComponents,
-            ...options.components,
-        }).forEach(([name, component]) => UI.registerComponent(name as UIComponent, component));
+        for (const [name, component] of Object.entries(components)) {
+            UI.registerComponent(name as keyof UIComponents, component as UIComponents[keyof UIComponents]);
+        }
 
         await bootServices(app, services);
     },
@@ -44,7 +43,7 @@ export default definePlugin({
 
 declare module '@aerogel/core/bootstrap/options' {
     export interface AerogelOptions {
-        components?: Partial<Record<UIComponent, Component>>;
+        components?: Partial<Partial<UIComponents>>;
     }
 }
 

package/src/utils/classes.ts

@@ -0,0 +1,41 @@
+import clsx from 'clsx';
+import { unref } from 'vue';
+import { cva } from 'class-variance-authority';
+import { twMerge } from 'tailwind-merge';
+import type { ClassValue } from 'clsx';
+import type { PropType } from 'vue';
+import type { GetClosureArgs, GetClosureResult } from '@noeldemartin/utils';
+
+export type CVAConfig<T> = NonNullable<GetClosureArgs<typeof cva<T>>[1]>;
+export type CVAProps<T> = NonNullable<GetClosureArgs<GetClosureResult<typeof cva<T>>>[0]>;
+export type Variants<T extends Record<string, string | boolean>> = Required<{
+    [K in keyof T]: Exclude<T[K], undefined> extends string
+        ? { [key in Exclude<T[K], undefined>]: string | null }
+        : { true: string | null; false: string | null };
+}>;
+
+export type ComponentPropDefinitions<T> = {
+    [K in keyof T]: {
+        type?: PropType<T[K]>;
+        default: T[K] | (() => T[K]) | null;
+    };
+};
+
+export type PickComponentProps<TValues, TDefinitions> = {
+    [K in keyof TValues]: K extends keyof TDefinitions ? TValues[K] : never;
+};
+
+export function variantClasses<T>(
+    value: { baseClasses?: string } & CVAProps<T>,
+    config: { baseClasses?: string } & CVAConfig<T>,
+): string {
+    const { baseClasses: valueBaseClasses, ...values } = value;
+    const { baseClasses: configBaseClasses, ...configs } = config;
+    const variants = cva(configBaseClasses, configs as CVAConfig<T>);
+
+    return classes(variants(values as CVAProps<T>), unref(valueBaseClasses));
+}
+
+export function classes(...inputs: ClassValue[]): string {
+    return twMerge(clsx(inputs));
+}

package/src/utils/composition/events.ts

@@ -6,7 +6,6 @@ import type {
     EventWithPayload,
     EventWithoutPayload,
     EventsPayload,
-    UnknownEvent,
 } from '@aerogel/core/services/Events';
 
 export function useEvent<Event extends EventWithoutPayload>(event: Event, listener: () => unknown): void;
@@ -14,11 +13,10 @@ export function useEvent<Event extends EventWithPayload>(
     event: Event,
     listener: EventListener<EventsPayload[Event]>
 ): void;
-export function useEvent<Payload>(event: string, listener: (payload: Payload) => unknown): void;
-export function useEvent<Event extends string>(event: UnknownEvent<Event>, listener: EventListener): void;
 
 export function useEvent(event: string, listener: EventListener): void {
-    const unsubscribe = Events.on(event, listener);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const unsubscribe = Events.on(event as any, listener);
 
     onUnmounted(() => unsubscribe());
 }

package/src/utils/composition/forms.ts

@@ -1,11 +1,27 @@
 import { objectWithout } from '@noeldemartin/utils';
-import { computed, useAttrs } from 'vue';
+import { computed, inject, onUnmounted, useAttrs } from 'vue';
+import type { ClassValue } from 'clsx';
 import type { ComputedRef } from 'vue';
+import type { Nullable } from '@noeldemartin/utils';
 
-export function useInputAttrs(): [ComputedRef<{}>, ComputedRef<unknown>] {
+import FormController from '@aerogel/core/forms/FormController';
+import type { FormData, FormFieldDefinitions } from '@aerogel/core/forms/FormController';
+
+export function onFormFocus(input: { name: Nullable<string> }, listener: () => unknown): void {
+    const form = inject<FormController | null>('form', null);
+    const stop = form?.on('focus', (name) => input.name === name && listener());
+
+    onUnmounted(() => stop?.());
+}
+
+export function useForm<const T extends FormFieldDefinitions>(fields: T): FormController<T> & FormData<T> {
+    return new FormController(fields) as FormController<T> & FormData<T>;
+}
+
+export function useInputAttrs(): [ComputedRef<{}>, ComputedRef<ClassValue>] {
     const attrs = useAttrs();
-    const className = computed(() => attrs.class);
+    const classes = computed(() => attrs.class);
     const inputAttrs = computed(() => objectWithout(attrs, 'class'));
 
-    return [inputAttrs, className];
+    return [inputAttrs, classes as ComputedRef<ClassValue>];
 }

package/src/utils/composition/state.ts

@@ -1,12 +1,21 @@
 import { debounce } from '@noeldemartin/utils';
-import { ref, watchEffect } from 'vue';
-import type { ComputedGetter, ComputedRef } from '@vue/runtime-core';
+import { computed, ref, watch, watchEffect } from 'vue';
+import type { ComputedGetter, ComputedRef, Ref } from 'vue';
 
 export interface ComputedDebounceOptions<T> {
     initial?: T;
     delay?: number;
 }
 
+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;
+}
+
 export function computedDebounce<T>(options: ComputedDebounceOptions<T>, getter: ComputedGetter<T>): ComputedRef<T>;
 export function computedDebounce<T>(getter: ComputedGetter<T>): ComputedRef<T | null>;
 export function computedDebounce<T>(

package/src/utils/index.ts

@@ -1,7 +1,9 @@
+export * from './classes';
 export * from './composition/events';
 export * from './composition/forms';
 export * from './composition/hooks';
 export * from './composition/persistent';
+export * from './composition/state';
 export * from './markdown';
-export * from './tailwindcss';
+export * from './types';
 export * from './vue';

package/src/utils/types.ts

@@ -0,0 +1,3 @@
+import type { Nullable } from '@noeldemartin/utils';
+
+export type Falsifiable<T> = Nullable<T> | false;

package/src/utils/vue.ts

@@ -1,59 +1,26 @@
 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 ?? (() => []),
-    };
+function renderVNodeAttrs(node: VNode): string {
+    return Object.entries(node.props ?? {}).reduce((attrs, [name, value]) => {
+        return attrs + `${name}="${toString(value)}"`;
+    }, '');
 }
 
-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;
-}
-
-export function defineDirective(directive: Directive): Directive {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function defineDirective<TValue = any, TModifiers extends string = string>(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    directive: Directive<any, TValue, TModifiers>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+): Directive<any, TValue, TModifiers> {
     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 +38,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>