@axium/tasks 0.1.0

package/LICENSE.md

@@ -0,0 +1,157 @@
+# GNU LESSER GENERAL PUBLIC LICENSE
+
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc.
+<https://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+This version of the GNU Lesser General Public License incorporates the
+terms and conditions of version 3 of the GNU General Public License,
+supplemented by the additional permissions listed below.
+
+## 0. Additional Definitions.
+
+As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the
+GNU General Public License.
+
+"The Library" refers to a covered work governed by this License, other
+than an Application or a Combined Work as defined below.
+
+An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+A "Combined Work" is a work produced by combining or linking an
+Application with the Library. The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+## 1. Exception to Section 3 of the GNU GPL.
+
+You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+## 2. Conveying Modified Versions.
+
+If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+-   a) under this License, provided that you make a good faith effort
+    to ensure that, in the event an Application does not supply the
+    function or data, the facility still operates, and performs
+    whatever part of its purpose remains meaningful, or
+-   b) under the GNU GPL, with none of the additional permissions of
+    this License applicable to that copy.
+
+## 3. Object Code Incorporating Material from Library Header Files.
+
+The object code form of an Application may incorporate material from a
+header file that is part of the Library. You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+-   a) Give prominent notice with each copy of the object code that
+    the Library is used in it and that the Library and its use are
+    covered by this License.
+-   b) Accompany the object code with a copy of the GNU GPL and this
+    license document.
+
+## 4. Combined Works.
+
+You may convey a Combined Work under terms of your choice that, taken
+together, effectively do not restrict modification of the portions of
+the Library contained in the Combined Work and reverse engineering for
+debugging such modifications, if you also do each of the following:
+
+-   a) Give prominent notice with each copy of the Combined Work that
+    the Library is used in it and that the Library and its use are
+    covered by this License.
+-   b) Accompany the Combined Work with a copy of the GNU GPL and this
+    license document.
+-   c) For a Combined Work that displays copyright notices during
+    execution, include the copyright notice for the Library among
+    these notices, as well as a reference directing the user to the
+    copies of the GNU GPL and this license document.
+-   d) Do one of the following:
+    -   0) Convey the Minimal Corresponding Source under the terms of
+        this License, and the Corresponding Application Code in a form
+        suitable for, and under terms that permit, the user to
+        recombine or relink the Application with a modified version of
+        the Linked Version to produce a modified Combined Work, in the
+        manner specified by section 6 of the GNU GPL for conveying
+        Corresponding Source.
+    -   1) Use a suitable shared library mechanism for linking with
+        the Library. A suitable mechanism is one that (a) uses at run
+        time a copy of the Library already present on the user's
+        computer system, and (b) will operate properly with a modified
+        version of the Library that is interface-compatible with the
+        Linked Version.
+-   e) Provide Installation Information, but only if you would
+    otherwise be required to provide such information under section 6
+    of the GNU GPL, and only to the extent that such information is
+    necessary to install and execute a modified version of the
+    Combined Work produced by recombining or relinking the Application
+    with a modified version of the Linked Version. (If you use option
+    4d0, the Installation Information must accompany the Minimal
+    Corresponding Source and Corresponding Application Code. If you
+    use option 4d1, you must provide the Installation Information in
+    the manner specified by section 6 of the GNU GPL for conveying
+    Corresponding Source.)
+
+## 5. Combined Libraries.
+
+You may place library facilities that are a work based on the Library
+side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+-   a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities, conveyed under the terms of this License.
+-   b) Give prominent notice with the combined library that part of it
+    is a work based on the Library, and explaining where to find the
+    accompanying uncombined form of the same work.
+
+## 6. Revised Versions of the GNU Lesser General Public License.
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+as you received it specifies that a certain numbered version of the
+GNU Lesser General Public License "or any later version" applies to
+it, you have the option of following the terms and conditions either
+of that published version or of any later version published by the
+Free Software Foundation. If the Library as you received it does not
+specify a version number of the GNU Lesser General Public License, you
+may choose any version of the GNU Lesser General Public License ever
+published by the Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

package/README.md

@@ -0,0 +1,3 @@
+# Axium Tasks
+
+This is a plugin for managing tasks using Axium.

package/dist/client.d.ts

@@ -0,0 +1,2 @@
+import type { TaskList } from './common.js';
+export declare function parseList<const T extends TaskList>(list: T): T;

package/dist/client.js

@@ -0,0 +1,8 @@
+export function parseList(list) {
+    list.created = new Date(list.created);
+    for (const task of list.tasks || []) {
+        task.created = new Date(task.created);
+        task.due = task.due ? new Date(task.due) : null;
+    }
+    return list;
+}

package/dist/common.d.ts

@@ -0,0 +1,46 @@
+import type { Permission } from '@axium/core';
+import type { WithRequired } from 'utilium';
+import * as z from 'zod';
+export declare const TaskInit: z.ZodObject<{
+    summary: z.ZodDefault<z.ZodString>;
+    description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    listId: z.ZodUUID;
+    parentId: z.ZodNullable<z.ZodOptional<z.ZodUUID>>;
+    completed: z.ZodOptional<z.ZodBoolean>;
+    due: z.ZodNullable<z.ZodOptional<z.ZodDate>>;
+}, z.core.$strip>;
+export type TaskInit = z.infer<typeof TaskInit>;
+export interface Task extends TaskInit {
+    id: string;
+    created: Date;
+}
+export declare const TaskListInit: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export type TaskListInit = z.infer<typeof TaskListInit>;
+export interface TaskList extends TaskListInit {
+    id: string;
+    userId: string;
+    created: Date;
+    publicPermission: Permission;
+    tasks?: Task[];
+}
+declare module '@axium/core/api' {
+    interface _apiTypes {
+        'users/:id/task_lists': {
+            GET: WithRequired<TaskList, 'tasks'>[];
+            PUT: [z.input<typeof TaskListInit>, TaskList];
+        };
+        'task_lists/:id': {
+            GET: WithRequired<TaskList, 'tasks'>;
+            PATCH: [z.input<typeof TaskListInit>, TaskList];
+            PUT: [Omit<z.input<typeof TaskInit>, 'listId'>, Task];
+            DELETE: TaskList;
+        };
+        'tasks/:id': {
+            PATCH: [Omit<z.input<typeof TaskInit>, 'listId'>, Task];
+            DELETE: Task;
+        };
+    }
+}

package/dist/common.js

@@ -0,0 +1,13 @@
+import * as z from 'zod';
+export const TaskInit = z.object({
+    summary: z.string().max(100).default(''),
+    description: z.string().max(500).optional().nullable(),
+    listId: z.uuid(),
+    parentId: z.uuid().optional().nullable(),
+    completed: z.boolean().optional(),
+    due: z.date().optional().nullable(),
+});
+export const TaskListInit = z.object({
+    name: z.string().min(1).max(50),
+    description: z.string().max(500).optional().nullable(),
+});

package/dist/plugin.d.ts

@@ -0,0 +1,56 @@
+import './common.js';
+import './server.js';
+declare function statusText(): Promise<string>;
+declare function db_init(): Promise<void>;
+declare function db_wipe(): Promise<void>;
+declare function remove(): Promise<void>;
+declare const _default: {
+    statusText: typeof statusText;
+    hooks: {
+        db_init: typeof db_init;
+        db_wipe: typeof db_wipe;
+        remove: typeof remove;
+    };
+    name: string;
+    version: string;
+    author: string;
+    description: string;
+    funding: {
+        type: string;
+        url: string;
+    };
+    license: string;
+    repository: {
+        type: string;
+        url: string;
+    };
+    homepage: string;
+    bugs: {
+        url: string;
+    };
+    type: string;
+    main: string;
+    types: string;
+    exports: {
+        ".": string;
+        "./*": string;
+        "./components": string;
+        "./components/*": string;
+    };
+    routes: string;
+    files: string[];
+    scripts: {
+        build: string;
+    };
+    peerDependencies: {
+        "@axium/client": string;
+        "@axium/core": string;
+        "@axium/server": string;
+        "@sveltejs/kit": string;
+        utilium: string;
+    };
+    dependencies: {
+        zod: string;
+    };
+};
+export default _default;

package/dist/plugin.js

@@ -0,0 +1,69 @@
+import * as acl from '@axium/server/acl';
+import { addApp } from '@axium/server/apps';
+import { count, createIndex, database, warnExists } from '@axium/server/database';
+import { done, start } from '@axium/server/io';
+import { sql } from 'kysely';
+import pkg from '../package.json' with { type: 'json' };
+import './common.js';
+import './server.js';
+async function statusText() {
+    const { tasks, task_lists } = await count('tasks', 'task_lists');
+    return `${tasks} tasks, ${task_lists} lists`;
+}
+async function db_init() {
+    start('Creating table task_lists');
+    await database.schema
+        .createTable('task_lists')
+        .addColumn('id', 'uuid', col => col.primaryKey().defaultTo(sql `gen_random_uuid()`))
+        .addColumn('userId', 'uuid', col => col.notNull().references('users.id').onDelete('cascade'))
+        .addColumn('created', 'timestamptz', col => col.notNull().defaultTo(sql `now()`))
+        .addColumn('publicPermission', 'integer', col => col.notNull().defaultTo(0))
+        .addColumn('name', 'text', col => col.notNull())
+        .addColumn('description', 'text')
+        .execute()
+        .then(done)
+        .catch(warnExists);
+    await createIndex('task_lists', 'userId');
+    await acl.createTable('task_lists');
+    start('Creating table tasks');
+    await database.schema
+        .createTable('tasks')
+        .addColumn('id', 'uuid', col => col.primaryKey().defaultTo(sql `gen_random_uuid()`))
+        .addColumn('created', 'timestamptz', col => col.notNull().defaultTo(sql `now()`))
+        .addColumn('listId', 'uuid', col => col.notNull().references('task_lists.id').onDelete('cascade'))
+        .addColumn('summary', 'text', col => col.notNull())
+        .addColumn('description', 'text')
+        .addColumn('parentId', 'uuid', col => col.references('tasks.id').onDelete('cascade'))
+        .addColumn('completed', 'boolean', col => col.notNull().defaultTo(false))
+        .addColumn('due', 'timestamptz')
+        .execute()
+        .then(done)
+        .catch(warnExists);
+    await createIndex('tasks', 'listId');
+    await createIndex('tasks', 'parentId');
+}
+async function db_wipe() {
+    start('Wiping data from tasks');
+    await database.deleteFrom('tasks').execute().then(done);
+    start('Wiping data from task_lists');
+    await database.deleteFrom('task_lists').execute().then(done);
+    await acl.wipeTable('task_lists');
+}
+async function remove() {
+    start('Dropping table tasks');
+    await database.schema.dropTable('tasks').execute().then(done);
+    start('Dropping table task_lists');
+    await database.schema.dropTable('task_lists').execute().then(done);
+    await acl.dropTable('task_lists');
+}
+addApp({
+    id: 'tasks',
+    name: 'Tasks',
+    icon: 'list-check',
+    version: pkg.version,
+});
+export default {
+    ...pkg,
+    statusText,
+    hooks: { db_init, db_wipe, remove },
+};

package/dist/server.d.ts

@@ -0,0 +1,28 @@
+import { Permission } from '@axium/core';
+import type { Generated, GeneratedAlways } from 'kysely';
+declare module '@axium/server/database' {
+    interface Schema {
+        tasks: {
+            id: GeneratedAlways<string>;
+            created: GeneratedAlways<Date>;
+            summary: string;
+            description?: string | null;
+            listId: string;
+            parentId?: string | null;
+            completed: Generated<boolean>;
+            due?: Date | null;
+        };
+        task_lists: {
+            id: GeneratedAlways<string>;
+            userId: string;
+            created: GeneratedAlways<Date>;
+            publicPermission: Generated<Permission>;
+            name: string;
+            description?: string | null;
+        };
+    }
+    interface ExpectedSchema {
+        tasks: ColumnTypes<Schema['tasks']>;
+        task_lists: ColumnTypes<Schema['task_lists']>;
+    }
+}

package/dist/server.js

@@ -0,0 +1,142 @@
+import { Permission } from '@axium/core';
+import { checkAuthForItem, checkAuthForUser } from '@axium/server/auth';
+import { database, expectedTypes } from '@axium/server/database';
+import { parseBody, withError } from '@axium/server/requests';
+import { addRoute } from '@axium/server/routes';
+import * as z from 'zod';
+import { TaskInit, TaskListInit } from './common.js';
+import { jsonArrayFrom } from 'kysely/helpers/postgres';
+expectedTypes.tasks = {
+    id: { type: 'uuid', required: true, hasDefault: true },
+    created: { type: 'timestamptz', required: true, hasDefault: true },
+    summary: { type: 'text', required: true },
+    description: { type: 'text' },
+    listId: { type: 'uuid', required: true },
+    parentId: { type: 'uuid' },
+    completed: { type: 'bool', required: true, hasDefault: true },
+    due: { type: 'timestamptz' },
+};
+expectedTypes.task_lists = {
+    id: { type: 'uuid', required: true, hasDefault: true },
+    userId: { type: 'uuid', required: true },
+    created: { type: 'timestamptz', required: true, hasDefault: true },
+    publicPermission: { type: 'int4', required: true, hasDefault: true },
+    name: { type: 'text', required: true },
+    description: { type: 'text' },
+};
+addRoute({
+    path: '/api/users/:id/task_lists',
+    params: { id: z.uuid() },
+    async GET(event) {
+        const userId = event.params.id;
+        await checkAuthForUser(event, userId);
+        const lists = await database
+            .selectFrom('task_lists')
+            .selectAll()
+            .select(eb => jsonArrayFrom(eb.selectFrom('tasks').selectAll().whereRef('tasks.listId', '=', 'task_lists.id')).as('tasks'))
+            .where('userId', '=', userId)
+            .execute()
+            .catch(withError('Could not get task lists'));
+        return lists.map(list => ({
+            ...list,
+            tasks: list.tasks.map(t => ({ ...t, created: new Date(t.created), due: t.due ? new Date(t.due) : null })),
+        }));
+    },
+    async PUT(event) {
+        const init = await parseBody(event, TaskListInit);
+        const userId = event.params.id;
+        await checkAuthForUser(event, userId);
+        return await database
+            .insertInto('task_lists')
+            .values({ ...init, userId })
+            .returningAll()
+            .executeTakeFirstOrThrow()
+            .catch(withError('Could not create task list'));
+    },
+});
+addRoute({
+    path: '/api/task_lists/:id',
+    params: { id: z.uuid() },
+    async GET(event) {
+        const id = event.params.id;
+        const { item } = await checkAuthForItem(event, 'task_lists', id, Permission.Read);
+        const tasks = await database
+            .selectFrom('tasks')
+            .selectAll()
+            .where('listId', '=', id)
+            .execute()
+            .catch(withError('Could not get tasks'));
+        return Object.assign(item, { tasks });
+    },
+    async PUT(event) {
+        const listId = event.params.id;
+        const init = await parseBody(event, TaskInit.omit({ listId: true }));
+        await checkAuthForItem(event, 'task_lists', listId, Permission.Edit);
+        return await database
+            .insertInto('tasks')
+            .values({ ...init, listId })
+            .returningAll()
+            .executeTakeFirstOrThrow()
+            .catch(withError('Could not update task list'));
+    },
+    async PATCH(event) {
+        const id = event.params.id;
+        await checkAuthForItem(event, 'task_lists', id, Permission.Edit);
+        const init = await parseBody(event, TaskListInit);
+        return await database
+            .updateTable('task_lists')
+            .set(init)
+            .where('id', '=', id)
+            .returningAll()
+            .executeTakeFirstOrThrow()
+            .catch(withError('Could not update task list'));
+    },
+    async DELETE(event) {
+        const id = event.params.id;
+        await checkAuthForItem(event, 'task_lists', id, Permission.Manage);
+        return await database
+            .deleteFrom('task_lists')
+            .where('id', '=', id)
+            .returningAll()
+            .executeTakeFirstOrThrow()
+            .catch(withError('Could not delete task list'));
+    },
+});
+addRoute({
+    path: '/api/tasks/:id',
+    params: { id: z.uuid() },
+    async PATCH(event) {
+        const init = await parseBody(event, TaskInit.omit({ listId: true }));
+        const id = event.params.id;
+        const task = await database
+            .selectFrom('tasks')
+            .select('listId')
+            .where('id', '=', id)
+            .executeTakeFirstOrThrow()
+            .catch(withError('Could not get task'));
+        await checkAuthForItem(event, 'task_lists', task.listId, Permission.Edit);
+        return await database
+            .updateTable('tasks')
+            .set(init)
+            .where('id', '=', id)
+            .returningAll()
+            .executeTakeFirstOrThrow()
+            .catch(withError('Could not update task'));
+    },
+    async DELETE(event) {
+        const id = event.params.id;
+        const task = await database
+            .selectFrom('tasks')
+            .select('listId')
+            .where('id', '=', id)
+            .executeTakeFirstOrThrow()
+            .catch(withError('Could not fetch task'));
+        await checkAuthForItem(event, 'task_lists', task.listId, Permission.Manage);
+        return await database
+            .deleteFrom('tasks')
+            .where('id', '=', id)
+            .returningAll()
+            .executeTakeFirstOrThrow()
+            .catch(withError('Could not delete task'));
+    },
+});

package/lib/TaskList.svelte

@@ -0,0 +1,158 @@
+<script lang="ts">
+	import { goto } from '$app/navigation';
+	import { fetchAPI } from '@axium/client/requests';
+	import { Icon, Popover } from '@axium/server/components';
+	import type { Task, TaskList } from '@axium/tasks/common';
+	import type { WithRequired } from 'utilium';
+
+	let { list = $bindable(), lists = $bindable() }: { list: WithRequired<TaskList, 'tasks'>; lists?: WithRequired<TaskList, 'tasks'>[] } =
+		$props();
+
+	let tasks = $state(list.tasks);
+</script>
+
+{#snippet task_tree(root: Task)}
+	<div class="task">
+		<label for="task-completed#{root.id}">
+			<Icon i="regular/circle{root.completed ? '-check' : ''}" --size="20px" />
+		</label>
+		<input
+			type="checkbox"
+			name="completed"
+			bind:checked={root.completed}
+			id="task-completed#{root.id}"
+			style:display="none"
+			onchange={e => {
+				root.completed = e.currentTarget.checked;
+				fetchAPI('PATCH', 'tasks/:id', { completed: root.completed }, root.id);
+			}}
+		/>
+		<input
+			type="text"
+			name="summary"
+			class="editable-text"
+			bind:value={root.summary}
+			onchange={e => {
+				root.summary = e.currentTarget.value;
+				fetchAPI('PATCH', 'tasks/:id', { summary: root.summary }, root.id);
+			}}
+		/>
+		<Popover>
+			<div
+				class="menu-item"
+				onclick={e => {
+					e.stopPropagation();
+					fetchAPI('DELETE', 'tasks/:id', {}, root.id).then(() => {
+						tasks.splice(tasks.indexOf(root), 1);
+					});
+				}}
+			>
+				<Icon i="trash" /> Delete
+			</div>
+		</Popover>
+	</div>
+	{#each tasks.filter(task => task.parentId == root.id) as child}
+		{@render task_tree(child)}
+	{/each}
+{/snippet}
+
+<div class="task-list">
+	<div class="task-list-header">
+		<input
+			type="text"
+			bind:value={list.name}
+			class="editable-text"
+			onblur={e => {
+				list.name = e.currentTarget.value;
+				fetchAPI('PATCH', 'task_lists/:id', { name: list.name }, list.id);
+			}}
+		/>
+		<Popover>
+			<div
+				class="menu-item"
+				onclick={e => {
+					e.stopPropagation();
+					fetchAPI('DELETE', 'task_lists/:id', {}, list.id).then(() => {
+						if (!lists) goto('/tasks');
+						else lists.splice(lists.indexOf(list), 1);
+					});
+				}}
+			>
+				<Icon i="trash" /> Delete
+			</div>
+		</Popover>
+	</div>
+	<div>
+		<button
+			class="icon-text"
+			onclick={e => {
+				e.stopPropagation();
+				fetchAPI('PUT', 'task_lists/:id', { summary: '' }, list.id)
+					.then(t => t)
+					.then(tasks.push.bind(tasks));
+			}}
+		>
+			<Icon i="regular/circle-plus" /> Add Task
+		</button>
+	</div>
+	<h4>Pending</h4>
+	{#each tasks.filter(task => !task.parentId && !task.completed) as task}
+		{@render task_tree(task)}
+	{:else}
+		<i>No pending tasks.</i>
+	{/each}
+	<h4>Completed</h4>
+	{#each tasks.filter(task => !task.parentId && task.completed) as task}
+		{@render task_tree(task)}
+	{:else}
+		<i>No completed tasks.</i>
+	{/each}
+</div>
+
+<style>
+	.editable-text {
+		background: none;
+		border: none;
+	}
+
+	.task {
+		display: grid;
+		grid-template-columns: 1em 1fr 2em;
+		align-items: center;
+		gap: 1em;
+
+		.task {
+			padding-left: 1em;
+		}
+	}
+
+	.task-list {
+		display: flex;
+		flex-direction: column;
+		gap: 0.5em;
+		border-radius: 1em;
+		padding: 1em;
+		border: 1px solid #334;
+		background-color: #232325;
+	}
+
+	.task-list-header {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+
+		input {
+			font-size: 1.5em;
+			font-weight: bold;
+			padding: 0;
+		}
+	}
+
+	.task :global(.popover-toggle) {
+		visibility: hidden;
+	}
+
+	.task:hover :global(.popover-toggle) {
+		visibility: visible;
+	}
+</style>

package/lib/index.ts

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

package/lib/tsconfig.json

@@ -0,0 +1,12 @@
+{
+	"extends": ["../tsconfig.json", "../.svelte-kit/tsconfig.json"],
+	"compilerOptions": {
+		"rootDir": "..",
+		"noEmit": true,
+		"module": "preserve",
+		"moduleResolution": "Bundler"
+	},
+	"include": ["**/*.svelte", "**/*.ts"],
+	"exclude": [],
+	"references": [{ "path": ".." }]
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+	"name": "@axium/tasks",
+	"version": "0.1.0",
+	"author": "James Prevett <axium@jamespre.dev> (https://jamespre.dev)",
+	"description": "",
+	"funding": {
+		"type": "individual",
+		"url": "https://github.com/sponsors/james-pre"
+	},
+	"license": "LGPL-3.0-or-later",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/james-pre/axium.git"
+	},
+	"homepage": "https://github.com/james-pre/axium#readme",
+	"bugs": {
+		"url": "https://github.com/james-pre/axium/issues"
+	},
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": "./dist/index.js",
+		"./*": "./dist/*.js",
+		"./components": "./lib/index.js",
+		"./components/*": "./lib/*.svelte"
+	},
+	"routes": "routes",
+	"files": [
+		"dist",
+		"lib",
+		"routes"
+	],
+	"scripts": {
+		"build": "tsc"
+	},
+	"peerDependencies": {
+		"@axium/client": ">=0.1.0",
+		"@axium/core": ">=0.5.4",
+		"@axium/server": ">=0.22.0",
+		"@sveltejs/kit": "^2.27.3",
+		"utilium": "^2.3.8"
+	},
+	"dependencies": {
+		"zod": "^4.0.5"
+	}
+}

package/routes/tasks/+page.svelte

@@ -0,0 +1,66 @@
+<script lang="ts">
+	import { fetchAPI } from '@axium/client/requests';
+	import { Dialog, FormDialog, Icon } from '@axium/server/components';
+	import { parseList } from '@axium/tasks/client';
+	import { TaskListInit } from '@axium/tasks/common';
+	import { TaskList } from '@axium/tasks/components';
+
+	const { data } = $props();
+
+	let lists = $state(data.lists);
+	let dialog = $state<HTMLDialogElement>();
+</script>
+
+<svelte:head>
+	<title>Tasks</title>
+</svelte:head>
+
+<div class="tasks-main">
+	<h1>Tasks</h1>
+	<span>
+		<button class="icon-text" onclick={() => dialog!.showModal()}>
+			<Icon i="plus" /> New List
+		</button>
+	</span>
+	<div class="lists-container">
+		{#each lists as list}
+			<TaskList {list} bind:lists />
+		{/each}
+	</div>
+</div>
+
+<FormDialog
+	bind:dialog
+	submitText="Create List"
+	submit={async rawInit => {
+		const init = TaskListInit.parse(rawInit);
+		const result = await fetchAPI('PUT', 'users/:id/task_lists', init, data.session.userId);
+		parseList(result);
+		lists.push(Object.assign(result, { tasks: [] }));
+	}}
+>
+	<div>
+		<label for="name">Name</label>
+		<input name="name" type="text" required />
+	</div>
+	<div>
+		<label for="description">Description <span class="subtle">(optional)</span></label>
+		<input name="description" type="text" />
+	</div>
+</FormDialog>
+
+<style>
+	.tasks-main {
+		padding: 2em;
+		inset: 0;
+		display: flex;
+		flex-direction: column;
+		gap: 1em;
+	}
+
+	.lists-container {
+		display: grid;
+		grid-template-columns: repeat(auto-fill, minmax(400px, 1fr));
+		gap: 1em;
+	}
+</style>

package/routes/tasks/+page.ts

@@ -0,0 +1,17 @@
+import { fetchAPI } from '@axium/client/requests';
+import { getCurrentSession } from '@axium/client/user';
+import type { Session } from '@axium/core';
+import { parseList } from '@axium/tasks/client';
+import type { LoadEvent } from '@sveltejs/kit';
+
+export async function load({ parent }: LoadEvent) {
+	let { session }: { session?: Session } = await parent();
+
+	session ||= await getCurrentSession();
+
+	const lists = await fetchAPI('GET', 'users/:id/task_lists', {}, session.userId);
+
+	for (const list of lists) parseList(list);
+
+	return { lists, session };
+}

package/routes/tasks/[id]/+page.svelte

@@ -0,0 +1,11 @@
+<script lang="ts">
+	import { TaskList } from '@axium/tasks/components';
+
+	const { data } = $props();
+</script>
+
+<svelte:head>
+	<title>Tasks — {data.list.name}</title>
+</svelte:head>
+
+<TaskList list={data.list} />

package/routes/tasks/[id]/+page.ts

@@ -0,0 +1,11 @@
+import { fetchAPI } from '@axium/client/requests';
+import type { LoadEvent } from '@sveltejs/kit';
+import { parseList } from '@axium/tasks/client';
+
+export async function load({ params }: LoadEvent) {
+	const list = await fetchAPI('GET', 'task_lists/:id', {}, params.id!);
+
+	parseList(list);
+
+	return { list };
+}

package/routes/tsconfig.json

@@ -0,0 +1,12 @@
+{
+	"extends": ["../tsconfig.json", "../.svelte-kit/tsconfig.json"],
+	"compilerOptions": {
+		"moduleResolution": "bundler",
+		"module": "esnext",
+		"noEmit": true,
+		"target": "esnext",
+		"rootDir": ".."
+	},
+	"include": ["**/*", "../lib/*"],
+	"references": [{ "path": ".." }]
+}