@aerogel/core 0.0.0-next.d7394c3aa6aac799b0971e63819a8713d05a5123 → 0.0.0-next.e4c0d5bd2801fbe93545477ea515af53df69b522

package/src/utils/composition/events.ts

@@ -1,24 +1,22 @@
 import { onUnmounted } from 'vue';
 
-import Events from '@/services/Events';
+import Events from '@aerogel/core/services/Events';
 import type {
     EventListener,
     EventWithPayload,
     EventWithoutPayload,
     EventsPayload,
-    UnknownEvent,
-} from '@/services/Events';
+} from '@aerogel/core/services/Events';
 
 export function useEvent<Event extends EventWithoutPayload>(event: Event, listener: () => unknown): void;
 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/persistent.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { nextTick } from 'vue';
+import { Storage } from '@noeldemartin/utils';
+
+import { persistent } from './persistent';
+
+describe('Vue persistent helper', () => {
+
+    it('serializes to localStorage', async () => {
+        // Arrange
+        const store = persistent<{ foo?: string }>('foobar', {});
+
+        // Act
+        store.foo = 'bar';
+
+        await nextTick();
+
+        // Assert
+        expect(Storage.get('foobar')).toEqual({ foo: 'bar' });
+    });
+
+    it('reads from localStorage', async () => {
+        // Arrange
+        Storage.set('foobar', { foo: 'bar' });
+
+        // Act
+        const store = persistent<{ foo?: string }>('foobar', {});
+
+        // Assert
+        expect(store.foo).toEqual('bar');
+    });
+
+});

package/src/utils/composition/persistent.ts

@@ -0,0 +1,11 @@
+import { reactive, toRaw, watch } from 'vue';
+import { Storage } from '@noeldemartin/utils';
+import type { UnwrapNestedRefs } from 'vue';
+
+export function persistent<T extends object>(name: string, defaults: T): UnwrapNestedRefs<T> {
+    const store = reactive<T>(Storage.get<T>(name) ?? defaults);
+
+    watch(store, () => Storage.set(name, toRaw(store)));
+
+    return store;
+}

package/src/utils/composition/state.test.ts

@@ -0,0 +1,47 @@
+import { after } from '@noeldemartin/utils';
+import { describe, expect, it } from 'vitest';
+import { ref } from 'vue';
+
+import { computedDebounce } from './state';
+
+describe('Vue state helpers', () => {
+
+    it('computes debounced state', async () => {
+        // Initial
+        const state = ref(0);
+        const value = computedDebounce({ delay: 90 }, () => state.value);
+
+        expect(value.value).toBe(null);
+
+        await after({ ms: 100 });
+
+        expect(value.value).toBe(0);
+
+        // Update
+        state.value = 42;
+
+        expect(value.value).toBe(0);
+
+        await after({ ms: 100 });
+
+        expect(value.value).toBe(42);
+
+        // Debounced Update
+        state.value = 23;
+
+        expect(value.value).toBe(42);
+
+        await after({ ms: 50 });
+
+        state.value = 32;
+
+        await after({ ms: 50 });
+
+        expect(value.value).toBe(42);
+
+        await after({ ms: 100 });
+
+        expect(value.value).toBe(32);
+    });
+
+});

package/src/utils/composition/state.ts

@@ -0,0 +1,33 @@
+import { debounce } from '@noeldemartin/utils';
+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>(
+    optionsOrGetter: ComputedGetter<T> | ComputedDebounceOptions<T>,
+    inputGetter?: ComputedGetter<T>,
+): ComputedRef<T> {
+    const inputOptions = inputGetter ? (optionsOrGetter as ComputedDebounceOptions<T>) : {};
+    const getter = inputGetter ?? (optionsOrGetter as ComputedGetter<T>);
+    const state = ref(inputOptions.initial ?? null);
+    const update = debounce((value) => (state.value = value), inputOptions.delay ?? 300);
+
+    watchEffect(() => update(getter()));
+
+    return state as unknown as ComputedRef<T>;
+}

package/src/utils/index.ts

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

package/src/utils/markdown.test.ts

@@ -0,0 +1,50 @@
+/* eslint-disable max-len */
+import { describe, expect, it } from 'vitest';
+
+import { renderMarkdown } from './markdown';
+
+describe('Markdown utils', () => {
+
+    it('renders basic markdown', () => {
+        // Arrange
+        const expectedHTML = `
+            <h1>Title</h1>
+            <p>body with <a target="_blank" href="https://example.com">link</a></p>
+            <ul>
+                <li>One</li>
+                <li>Two</li>
+                <li>Three</li>
+            </ul>
+        `;
+
+        // Act
+        const html = renderMarkdown(
+            ['# Title', 'body with [link](https://example.com)', '- One', '- Two', '- Three'].join('\n'),
+        );
+
+        // Assert
+        expect(normalizeHTML(html)).toMatch(new RegExp(normalizeHTML(expectedHTML)));
+    });
+
+    it('renders button links', () => {
+        // Arrange
+        const expectedHTML = `
+            <p><button type="button" data-markdown-action="do-something">link</button></p>
+        `;
+
+        // Act
+        const html = renderMarkdown('[link](#action:do-something)');
+
+        // Assert
+        expect(normalizeHTML(html)).toMatch(new RegExp(normalizeHTML(expectedHTML)));
+    });
+
+});
+
+function normalizeHTML(html: string): string {
+    return html
+        .split('\n')
+        .map((line) => line.trim())
+        .join('\n')
+        .trim();
+}

package/src/utils/markdown.ts

@@ -1,21 +1,68 @@
-import { tap } from '@noeldemartin/utils';
 import DOMPurify from 'dompurify';
+import { stringMatchAll, tap } from '@noeldemartin/utils';
 import { Renderer, marked } from 'marked';
 
+let router: MarkdownRouter | null = null;
+
 function makeRenderer(): Renderer {
     return tap(new Renderer(), (renderer) => {
-        renderer.link = function(href, title, text) {
-            return Renderer.prototype.link.apply(this, [href, title, text]).replace('<a', '<a target="_blank"');
+        renderer.link = function(link) {
+            const defaultLink = Renderer.prototype.link.apply(this, [link]);
+
+            if (!link.href.startsWith('#')) {
+                return defaultLink.replace('<a', '<a target="_blank"');
+            }
+
+            return defaultLink;
         };
     });
 }
 
+function renderActionLinks(html: string): string {
+    const matches = stringMatchAll<3>(html, /<a[^>]*href="#action:([^"]+)"[^>]*>([^<]+)<\/a>/g);
+
+    for (const [link, action, text] of matches) {
+        html = html.replace(link, `<button type="button" data-markdown-action="${action}">${text}</button>`);
+    }
+
+    return html;
+}
+
+function renderRouteLinks(html: string): string {
+    const matches = stringMatchAll<3>(html, /<a[^>]*href="#route:([^"]+)"[^>]*>([^<]+)<\/a>/g);
+
+    for (const [link, route, text] of matches) {
+        const url = router?.resolve(route) ?? route;
+
+        html = html.replace(link, `<a data-markdown-route="${route}" href="${url}">${text}</a>`);
+    }
+
+    return html;
+}
+
+export interface MarkdownRouter {
+    resolve(route: string): string;
+    visit(route: string): Promise<void>;
+}
+
+export function getMarkdownRouter(): MarkdownRouter | null {
+    return router;
+}
+
+export function setMarkdownRouter(markdownRouter: MarkdownRouter): void {
+    router = markdownRouter;
+}
+
 export function renderMarkdown(markdown: string): string {
-    return safeHtml(marked(markdown, { mangle: false, headerIds: false, renderer: makeRenderer() }));
+    let html = marked(markdown, { renderer: makeRenderer(), async: false });
+
+    html = safeHtml(html);
+    html = renderActionLinks(html);
+    html = renderRouteLinks(html);
+
+    return html;
 }
 
 export function safeHtml(html: string): string {
-    // TODO improve target="_blank" exception
-    // See https://github.com/cure53/DOMPurify/issues/317
     return DOMPurify.sanitize(html, { ADD_ATTR: ['target'] });
 }

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,61 +1,26 @@
-import { fail } from '@noeldemartin/utils';
-import { computed, inject, reactive, ref, watch } from 'vue';
-import type { Directive, InjectionKey, PropType, Ref, UnwrapNestedRefs } from 'vue';
-
-type BaseProp<T> = {
-    type?: PropType<T>;
-    validator?(value: unknown): boolean;
-};
-
-type RequiredProp<T> = BaseProp<T> & { required: true };
-type OptionalProp<T> = BaseProp<T> & { default: T | (() => T) | null };
-
-export type ComponentProps = Record<string, unknown>;
-
-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;
-}
-
-export function defineDirective(directive: Directive): Directive {
+import { fail, toString } from '@noeldemartin/utils';
+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 RefUnion<T> = T extends infer R ? Ref<R> : never;
+export type Unref<T> = { [K in keyof T]: T[K] extends MaybeRef<infer Value> ? Value : T[K] };
+
+function renderVNodeAttrs(node: VNode): string {
+    return Object.entries(node.props ?? {}).reduce((attrs, [name, value]) => {
+        return attrs + `${name}="${toString(value)}"`;
+    }, '');
+}
+
+// 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);
 
@@ -66,92 +31,31 @@ export function injectReactiveOrFail<T extends object>(
     key: InjectionKey<T> | string,
     errorMessage?: string,
 ): UnwrapNestedRefs<T> {
-    return injectReactive(key) ?? fail(errorMessage ?? `Could not resolve '${key}' injection key`);
+    return injectReactive(key) ?? fail(errorMessage ?? `Could not resolve '${toString(key)}' injection key`);
 }
 
 export function injectOrFail<T>(key: InjectionKey<T> | string, errorMessage?: string): T {
-    return inject(key) ?? fail(errorMessage ?? `Could not resolve '${key}' injection key`);
-}
-
-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);
-
-    return {
-        type: String as unknown as PropType<Enum[keyof Enum]>,
-        required: true,
-        validator: (value) => values.includes(value),
-    };
+    return inject(key) ?? fail(errorMessage ?? `Could not resolve '${toString(key)}' injection key`);
 }
 
-export function requiredMixedProp<T>(type?: PropType<T>): RequiredProp<T> {
-    return {
-        type,
-        required: true,
-    };
-}
+export function renderVNode(node: VNode | string): string {
+    if (typeof node === 'string') {
+        return node;
+    }
 
-export function requiredNumberProp(): RequiredProp<number> {
-    return {
-        type: Number,
-        required: true,
-    };
-}
+    if (node.type === Comment) {
+        return '';
+    }
 
-export function requiredObjectProp<T = Object>(): RequiredProp<T> {
-    return {
-        type: Object,
-        required: true,
-    };
-}
+    if (node.type === Text || node.type === Static) {
+        return node.children as string;
+    }
 
-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}>`;
 }