@axium/server 0.6.4 → 0.7.1

package/dist/cli.js

@@ -16,9 +16,9 @@ program
     .option('--no-debug', 'override debug mode')
     .option('-c, --config <path>', 'path to the config file');
 program.on('option:debug', () => config.set({ debug: true }));
-program.on('option:config', () => config.load(program.opts().config));
+program.on('option:config', () => void config.load(program.opts().config));
 program.hook('preAction', async function (_, action) {
-    config.loadDefaults();
+    await config.loadDefaults();
     await loadDefaultPlugins();
     const opt = action.optsWithGlobals();
     opt.force && output.warn('--force: Protections disabled.');
@@ -196,7 +196,7 @@ program
     for (const plugin of plugins) {
         if (!plugin.statusText)
             continue;
-        console.log(styleText('bold', plugin.name + ':'));
+        console.log(styleText('bold', plugin.name), plugin.version + ':');
         console.log(await plugin.statusText());
     }
     await db.database.destroy();

package/dist/config.d.ts

@@ -54,76 +54,119 @@ export declare const Schema: z.ZodObject<{
     }, {
         prefix: string;
     }>;
-}, "strip", z.ZodTypeAny, {
-    debug: boolean;
-    auth: {
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    auth: z.ZodObject<{
+        credentials: z.ZodBoolean;
+        debug: z.ZodBoolean;
+        secret: z.ZodString;
+        secure_cookies: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        debug: boolean;
+        credentials: boolean;
+        secret: string;
+        secure_cookies: boolean;
+    }, {
         debug: boolean;
         credentials: boolean;
         secret: string;
         secure_cookies: boolean;
-    };
-    db: {
+    }>;
+    db: z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+        password: z.ZodString;
+        user: z.ZodString;
+        database: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        host: string;
+        port: number;
+        password: string;
+        user: string;
+        database: string;
+    }, {
         host: string;
         port: number;
         password: string;
         user: string;
         database: string;
-    };
-    log: {
+    }>;
+    debug: z.ZodBoolean;
+    log: z.ZodObject<{
+        level: z.ZodEnum<["error", "warn", "notice", "info", "debug"]>;
+        console: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        level: "debug" | "info" | "warn" | "error" | "notice";
+        console: boolean;
+    }, {
         level: "debug" | "info" | "warn" | "error" | "notice";
         console: boolean;
-    };
-    web: {
+    }>;
+    web: z.ZodObject<{
+        prefix: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
         prefix: string;
-    };
-}, {
-    debug: boolean;
-    auth: {
+    }, {
+        prefix: string;
+    }>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    auth: z.ZodObject<{
+        credentials: z.ZodBoolean;
+        debug: z.ZodBoolean;
+        secret: z.ZodString;
+        secure_cookies: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
         debug: boolean;
         credentials: boolean;
         secret: string;
         secure_cookies: boolean;
-    };
-    db: {
+    }, {
+        debug: boolean;
+        credentials: boolean;
+        secret: string;
+        secure_cookies: boolean;
+    }>;
+    db: z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+        password: z.ZodString;
+        user: z.ZodString;
+        database: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        host: string;
+        port: number;
+        password: string;
+        user: string;
+        database: string;
+    }, {
         host: string;
         port: number;
         password: string;
         user: string;
         database: string;
-    };
-    log: {
+    }>;
+    debug: z.ZodBoolean;
+    log: z.ZodObject<{
+        level: z.ZodEnum<["error", "warn", "notice", "info", "debug"]>;
+        console: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
         level: "debug" | "info" | "warn" | "error" | "notice";
         console: boolean;
-    };
-    web: {
+    }, {
+        level: "debug" | "info" | "warn" | "error" | "notice";
+        console: boolean;
+    }>;
+    web: z.ZodObject<{
+        prefix: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
         prefix: string;
-    };
-}>;
+    }, {
+        prefix: string;
+    }>;
+}, z.ZodTypeAny, "passthrough">>;
 export interface Config extends Record<string, unknown>, z.infer<typeof Schema> {
 }
 export declare const configFiles: Map<string, PartialRecursive<Config>>;
-export declare const config: {
-    auth: {
-        credentials: false;
-        debug: false;
-        secret: string;
-        secure_cookies: true;
-    };
-    db: {
-        database: string;
-        host: string;
-        password: string;
-        port: number;
-        user: string;
-    };
-    debug: false;
-    log: {
-        console: true;
-        level: "info";
-    };
-    web: {
-        prefix: string;
-    };
+declare const configShortcuts: {
     findPath: typeof findConfigPath;
     load: typeof loadConfig;
     loadDefaults: typeof loadDefaultConfigs;
@@ -132,6 +175,7 @@ export declare const config: {
     set: typeof setConfig;
     files: Map<string, PartialRecursive<Config>>;
 };
+export declare const config: Config & typeof configShortcuts;
 export default config;
 export declare const File: z.ZodObject<z.objectUtil.extendShape<{
     auth: z.ZodOptional<z.ZodObject<{
@@ -189,53 +233,122 @@ export declare const File: z.ZodObject<z.objectUtil.extendShape<{
     }>>;
 }, {
     include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}>, "strip", z.ZodTypeAny, {
-    debug?: boolean | undefined;
-    auth?: {
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}>, "passthrough", z.ZodTypeAny, z.objectOutputType<z.objectUtil.extendShape<{
+    auth: z.ZodOptional<z.ZodObject<{
+        credentials: z.ZodOptional<z.ZodBoolean>;
+        debug: z.ZodOptional<z.ZodBoolean>;
+        secret: z.ZodOptional<z.ZodString>;
+        secure_cookies: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        debug?: boolean | undefined;
+        credentials?: boolean | undefined;
+        secret?: string | undefined;
+        secure_cookies?: boolean | undefined;
+    }, {
         debug?: boolean | undefined;
         credentials?: boolean | undefined;
         secret?: string | undefined;
         secure_cookies?: boolean | undefined;
-    } | undefined;
-    db?: {
+    }>>;
+    db: z.ZodOptional<z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        password: z.ZodOptional<z.ZodString>;
+        user: z.ZodOptional<z.ZodString>;
+        database: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        host?: string | undefined;
+        port?: number | undefined;
+        password?: string | undefined;
+        user?: string | undefined;
+        database?: string | undefined;
+    }, {
         host?: string | undefined;
         port?: number | undefined;
         password?: string | undefined;
         user?: string | undefined;
         database?: string | undefined;
-    } | undefined;
-    log?: {
+    }>>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+    log: z.ZodOptional<z.ZodObject<{
+        level: z.ZodOptional<z.ZodEnum<["error", "warn", "notice", "info", "debug"]>>;
+        console: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
         level?: "debug" | "info" | "warn" | "error" | "notice" | undefined;
         console?: boolean | undefined;
-    } | undefined;
-    web?: {
+    }, {
+        level?: "debug" | "info" | "warn" | "error" | "notice" | undefined;
+        console?: boolean | undefined;
+    }>>;
+    web: z.ZodOptional<z.ZodObject<{
+        prefix: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        prefix?: string | undefined;
+    }, {
         prefix?: string | undefined;
-    } | undefined;
-    include?: string[] | undefined;
+    }>>;
 }, {
-    debug?: boolean | undefined;
-    auth?: {
+    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}>, z.ZodTypeAny, "passthrough">, z.objectInputType<z.objectUtil.extendShape<{
+    auth: z.ZodOptional<z.ZodObject<{
+        credentials: z.ZodOptional<z.ZodBoolean>;
+        debug: z.ZodOptional<z.ZodBoolean>;
+        secret: z.ZodOptional<z.ZodString>;
+        secure_cookies: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        debug?: boolean | undefined;
+        credentials?: boolean | undefined;
+        secret?: string | undefined;
+        secure_cookies?: boolean | undefined;
+    }, {
         debug?: boolean | undefined;
         credentials?: boolean | undefined;
         secret?: string | undefined;
         secure_cookies?: boolean | undefined;
-    } | undefined;
-    db?: {
+    }>>;
+    db: z.ZodOptional<z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        password: z.ZodOptional<z.ZodString>;
+        user: z.ZodOptional<z.ZodString>;
+        database: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
         host?: string | undefined;
         port?: number | undefined;
         password?: string | undefined;
         user?: string | undefined;
         database?: string | undefined;
-    } | undefined;
-    log?: {
+    }, {
+        host?: string | undefined;
+        port?: number | undefined;
+        password?: string | undefined;
+        user?: string | undefined;
+        database?: string | undefined;
+    }>>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+    log: z.ZodOptional<z.ZodObject<{
+        level: z.ZodOptional<z.ZodEnum<["error", "warn", "notice", "info", "debug"]>>;
+        console: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
         level?: "debug" | "info" | "warn" | "error" | "notice" | undefined;
         console?: boolean | undefined;
-    } | undefined;
-    web?: {
+    }, {
+        level?: "debug" | "info" | "warn" | "error" | "notice" | undefined;
+        console?: boolean | undefined;
+    }>>;
+    web: z.ZodOptional<z.ZodObject<{
+        prefix: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
         prefix?: string | undefined;
-    } | undefined;
-    include?: string[] | undefined;
-}>;
+    }, {
+        prefix?: string | undefined;
+    }>>;
+}, {
+    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}>, z.ZodTypeAny, "passthrough">>;
 export interface File extends PartialRecursive<Config>, z.infer<typeof File> {
 }
 /**
@@ -259,8 +372,8 @@ export interface LoadOptions {
 /**
  * Load the config from the provided path
  */
-export declare function loadConfig(path: string, options?: LoadOptions): void;
-export declare function loadDefaultConfigs(): void;
+export declare function loadConfig(path: string, options?: LoadOptions): Promise<void>;
+export declare function loadDefaultConfigs(): Promise<void>;
 /**
  * Update the current config and write the updated config to the appropriate file
  */

package/dist/config.js

@@ -5,7 +5,9 @@ import { dirname, join } from 'node:path/posix';
 import { deepAssign } from 'utilium';
 import * as z from 'zod';
 import { findDir, logger, output } from './io.js';
-export const Schema = z.object({
+import { loadPlugin } from './plugins.js';
+export const Schema = z
+    .object({
     auth: z.object({
         credentials: z.boolean(),
         debug: z.boolean(),
@@ -27,9 +29,20 @@ export const Schema = z.object({
     web: z.object({
         prefix: z.string(),
     }),
-});
+})
+    .passthrough();
 export const configFiles = new Map();
+const configShortcuts = {
+    findPath: findConfigPath,
+    load: loadConfig,
+    loadDefaults: loadDefaultConfigs,
+    save: saveConfig,
+    saveTo: saveConfigTo,
+    set: setConfig,
+    files: configFiles,
+};
 export const config = {
+    ...configShortcuts,
     auth: {
         credentials: false,
         debug: false,
@@ -51,19 +64,15 @@ export const config = {
     web: {
         prefix: '',
     },
-    findPath: findConfigPath,
-    load: loadConfig,
-    loadDefaults: loadDefaultConfigs,
-    save: saveConfig,
-    saveTo: saveConfigTo,
-    set: setConfig,
-    files: configFiles,
 };
 export default config;
 // config from file
-export const File = Schema.deepPartial().extend({
+export const File = Schema.deepPartial()
+    .extend({
     include: z.array(z.string()).optional(),
-});
+    plugins: z.array(z.string()).optional(),
+})
+    .passthrough();
 /**
  * Update the current config
  */
@@ -76,7 +85,7 @@ export function setConfig(other) {
 /**
  * Load the config from the provided path
  */
-export function loadConfig(path, options = {}) {
+export async function loadConfig(path, options = {}) {
     let json;
     try {
         json = JSON.parse(readFileSync(path, 'utf8'));
@@ -91,11 +100,13 @@ export function loadConfig(path, options = {}) {
     configFiles.set(path, file);
     setConfig(file);
     for (const include of file.include ?? [])
-        loadConfig(join(dirname(path), include), { optional: true });
+        await loadConfig(join(dirname(path), include), { optional: true });
+    for (const plugin of file.plugins ?? [])
+        await loadPlugin(plugin);
 }
-export function loadDefaultConfigs() {
-    loadConfig(findConfigPath(true), { optional: true });
-    loadConfig(findConfigPath(false), { optional: true });
+export async function loadDefaultConfigs() {
+    await loadConfig(findConfigPath(true), { optional: true });
+    await loadConfig(findConfigPath(false), { optional: true });
 }
 /**
  * Update the current config and write the updated config to the appropriate file
@@ -122,4 +133,4 @@ export function findConfigPath(global) {
     return join(findDir(global), 'config.json');
 }
 if (process.env.AXIUM_CONFIG)
-    loadConfig(process.env.AXIUM_CONFIG);
+    await loadConfig(process.env.AXIUM_CONFIG);

package/dist/database.d.ts

@@ -49,8 +49,10 @@ export interface Schema {
         transports: string | null;
     };
 }
-export declare let database: Kysely<Schema> & AsyncDisposable;
-export declare function connect(): Kysely<Schema> & AsyncDisposable;
+export interface Database extends Kysely<Schema>, AsyncDisposable {
+}
+export declare let database: Database;
+export declare function connect(): Database;
 export interface Stats {
     users: number;
     accounts: number;
@@ -67,6 +69,10 @@ export interface InitOptions extends OpOptions {
     skip: boolean;
 }
 export declare function shouldRecreate(opt: InitOptions & WithOutput): boolean;
+export interface PluginShortcuts {
+    done: () => void;
+    warnExists: (error: string | Error) => void;
+}
 export declare function init(opt: InitOptions): Promise<void>;
 /**
  * Completely remove Axium from the database.

package/dist/database.js

@@ -208,10 +208,10 @@ export async function init(opt) {
         opt.output('start', 'Creating index for Authenticator.credentialID');
         await db.schema.createIndex('Authenticator_credentialID_key').on('Authenticator').column('credentialID').execute().then(done).catch(warnExists);
         for (const plugin of plugins) {
-            if (!plugin.db)
+            if (!plugin.db_init)
                 continue;
             opt.output('plugin', plugin.name);
-            await plugin.db.init(opt, db, { warnExists, done });
+            await plugin.db_init(opt, db, { warnExists, done });
         }
     }
     catch (e_1) {
@@ -231,10 +231,10 @@ export async function uninstall(opt) {
     _fixOutput(opt);
     const db = connect();
     for (const plugin of plugins) {
-        if (!plugin.db)
+        if (!plugin.db_remove)
             continue;
         opt.output('plugin', plugin.name);
-        await plugin.db.remove(opt, db);
+        await plugin.db_remove(opt, db);
     }
     await db.destroy();
     const _sql = (command, message) => run(opt, message, `sudo -u postgres psql -c "${command}"`);
@@ -249,10 +249,10 @@ export async function wipe(opt) {
     _fixOutput(opt);
     const db = connect();
     for (const plugin of plugins) {
-        if (!plugin.db)
+        if (!plugin.db_wipe)
             continue;
         opt.output('plugin', plugin.name);
-        await plugin.db.wipe(opt, db);
+        await plugin.db_wipe(opt, db);
     }
     for (const table of ['User', 'Account', 'Session', 'VerificationToken', 'Authenticator']) {
         opt.output('start', `Removing data from ${table}`);

package/dist/plugins.d.ts

@@ -5,47 +5,33 @@ export declare const Plugin: z.ZodObject<{
     version: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     statusText: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodPromise<z.ZodString>]>>>;
-    db: z.ZodOptional<z.ZodObject<{
-        init: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
-        remove: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
-        wipe: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
-    }, "strip", z.ZodTypeAny, {
-        init: (...args: unknown[]) => unknown;
-        remove: (...args: unknown[]) => unknown;
-        wipe: (...args: unknown[]) => unknown;
-    }, {
-        init: (...args: unknown[]) => unknown;
-        remove: (...args: unknown[]) => unknown;
-        wipe: (...args: unknown[]) => unknown;
-    }>>;
+    db_init: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    db_remove: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    db_wipe: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     id: string;
     version: string;
-    db?: {
-        init: (...args: unknown[]) => unknown;
-        remove: (...args: unknown[]) => unknown;
-        wipe: (...args: unknown[]) => unknown;
-    } | undefined;
     description?: string | undefined;
     statusText?: ((...args: unknown[]) => string | Promise<string>) | undefined;
+    db_init?: ((...args: unknown[]) => unknown) | undefined;
+    db_remove?: ((...args: unknown[]) => unknown) | undefined;
+    db_wipe?: ((...args: unknown[]) => unknown) | undefined;
 }, {
     name: string;
     id: string;
     version: string;
-    db?: {
-        init: (...args: unknown[]) => unknown;
-        remove: (...args: unknown[]) => unknown;
-        wipe: (...args: unknown[]) => unknown;
-    } | undefined;
     description?: string | undefined;
     statusText?: ((...args: unknown[]) => string | Promise<string>) | undefined;
+    db_init?: ((...args: unknown[]) => unknown) | undefined;
+    db_remove?: ((...args: unknown[]) => unknown) | undefined;
+    db_wipe?: ((...args: unknown[]) => unknown) | undefined;
 }>;
 export interface Plugin extends z.infer<typeof Plugin> {
 }
 export declare const plugins: Set<Plugin>;
 export declare function resolvePlugin(search: string): Plugin | undefined;
 export declare function pluginText(plugin: Plugin): string;
-export declare function loadPlugin(path: string): Promise<void>;
+export declare function loadPlugin(specifier: string): Promise<void>;
 export declare function loadPlugins(dir: string): Promise<void>;
 export declare function loadDefaultPlugins(): Promise<void>;

package/dist/plugins.js

@@ -1,9 +1,10 @@
 import * as fs from 'node:fs';
-import { join, resolve } from 'node:path/posix';
+import { join } from 'node:path/posix';
 import { styleText } from 'node:util';
 import * as z from 'zod';
-import { findDir, output } from './io.js';
 import { fromZodError } from 'zod-validation-error';
+import { findDir, output } from './io.js';
+import { fileURLToPath } from 'node:url';
 export const Plugin = z.object({
     id: z.string(),
     name: z.string(),
@@ -14,13 +15,9 @@ export const Plugin = z.object({
         .args()
         .returns(z.union([z.string(), z.promise(z.string())]))
         .optional(),
-    db: z
-        .object({
-        init: z.function(),
-        remove: z.function(),
-        wipe: z.function(),
-    })
-        .optional(),
+    db_init: z.function().optional(),
+    db_remove: z.function().optional(),
+    db_wipe: z.function().optional(),
 });
 export const plugins = new Set();
 export function resolvePlugin(search) {
@@ -36,23 +33,26 @@ export function pluginText(plugin) {
         `Version: ${plugin.version}`,
         `Description: ${plugin.description ?? styleText('dim', '(none)')}`,
         `Status text integration: ${plugin.statusText ? styleText('whiteBright', 'yes') : styleText('yellow', 'no')}`,
-        `Database integration: ${plugin.db ? 'yes' : 'no'}`,
+        `Database integration: ${[plugin.db_init, plugin.db_remove, plugin.db_wipe]
+            .filter(Boolean)
+            .map(fn => fn?.name.slice(3))
+            .join(', ') || styleText('dim', '(none)')}`,
     ].join('\n');
 }
-export async function loadPlugin(path) {
-    path = resolve(path);
-    const stats = fs.statSync(path);
-    if (stats.isDirectory() || !['.js', '.mjs'].some(ext => path.endsWith(ext)))
+export async function loadPlugin(specifier) {
+    specifier = fileURLToPath(import.meta.resolve(specifier));
+    const stats = fs.statSync(specifier);
+    if (stats.isDirectory() || !['.js', '.mjs'].some(ext => specifier.endsWith(ext)))
         return;
     try {
-        const plugin = await Plugin.parseAsync(await import(path)).catch(e => {
+        const plugin = await Plugin.parseAsync(await import(specifier)).catch(e => {
             throw fromZodError(e);
         });
         plugins.add(plugin);
         output.debug(`Loaded plugin: "${plugin.name}" (${plugin.id}) ${plugin.version}`);
     }
     catch (e) {
-        output.debug(`Failed to load plugin from ${path}: ${e}`);
+        output.debug(`Failed to load plugin from ${specifier}: ${e}`);
     }
 }
 export async function loadPlugins(dir) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/server",
-	"version": "0.6.4",
+	"version": "0.7.1",
 	"author": "James Prevett <axium@jamespre.dev> (https://jamespre.dev)",
 	"funding": {
 		"type": "individual",

package/web/auth.ts

@@ -7,6 +7,6 @@ import { findDir, logger } from '../dist/io.js';
 import { allLogLevels } from 'logzen';
 
 logger.attach(createWriteStream(join(findDir(false), 'server.log')), { output: allLogLevels });
-config.loadDefaults();
+await config.loadDefaults();
 
 export const { handle, signIn, signOut } = SvelteKitAuth(getConfig());

package/web/lib/UserCard.svelte

@@ -0,0 +1,48 @@
+<script lang="ts">
+	import type { User } from '@axium/core/schemas';
+	import { getUserImage } from '@axium/core';
+
+	const {
+		user,
+		compact = false,
+		self = false,
+		href = `/users/${user.id}`,
+		you = false,
+	}: {
+		user: { [K in keyof User]?: User[K] | null };
+		/** If true, don't show the picture */
+		compact?: boolean;
+		/** Whether the user is viewing their own profile */
+		self?: boolean;
+		/** The URL to link to */
+		href?: string;
+		/** Whether to display a "You" label if `self` */
+		you?: boolean;
+	} = $props();
+</script>
+
+<a class={['User', self && 'self']} {href}>
+	{#if !compact}
+		<img src={getUserImage(user as Required<User>)} alt={user.name} />
+	{/if}
+	{user.name}
+	{#if self && you}
+		<span class="subtle">(You)</span>
+	{/if}
+</a>
+
+<style>
+	.User {
+		cursor: pointer;
+		width: max-content;
+		height: max-content;
+	}
+
+	img {
+		width: 2em;
+		height: 2em;
+		border-radius: 50%;
+		vertical-align: middle;
+		margin-right: 0.5em;
+	}
+</style>

package/web/lib/index.ts

@@ -4,3 +4,4 @@ export { default as FormDialog } from './FormDialog.svelte';
 export { default as Icon } from './Icon.svelte';
 export { default as SignUp } from './SignUp.svelte';
 export { default as Toast } from './Toast.svelte';
+export { default as UserCard } from './UserCard.svelte';