@haruhimemoe/ui 0.6.0 → 0.8.0

package/dist/components/palette/siteCommands.js

@@ -0,0 +1,152 @@
+/**
+ * @file src/components/palette/siteCommands.ts
+ * @desc The default command set every tool gets: "Go to <page>" from the nav items, "Open
+ *       <tool>" from HARUHIME_TOOLS, page actions (copy URL, back, top, reload, GitHub), account
+ *       (sign in, my account, sign out by signedIn), and help (the shortcuts page, report a bug).
+ *       Ids are stable ("site.copy-url") so recents survive relabeling. Client-only: it opens
+ *       tabs and scrolls.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+"use client";
+import { isExternalHref } from "../../utils/href.js";
+import { HARUHIME_TOOLS } from "../shell/haruhimeTools.js";
+const slug = (label) => label
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "") || "page";
+const openTab = (href) => {
+    window.open(href, "_blank", "noopener");
+};
+const go = (href, ctx) => isExternalHref(href) ? openTab(href) : ctx.navigate(href);
+const reducedMotion = () => typeof window.matchMedia === "function" &&
+    window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+const navigate = (options) => {
+    const pages = (options.pages ?? []).flatMap((item) => {
+        const href = item.href;
+        if (!href)
+            return [];
+        return [
+            {
+                id: `site.go.${slug(item.label)}`,
+                title: `Go to ${item.label}`,
+                group: "Navigate",
+                keywords: [href],
+                run: (ctx) => go(href, ctx),
+            },
+        ];
+    });
+    if (options.tools === false)
+        return pages;
+    const tools = HARUHIME_TOOLS.filter((tool) => tool.id !== options.tools).map((tool) => ({
+        id: `site.tool.${tool.id}`,
+        title: `Open ${tool.name}`,
+        subtitle: tool.blurb,
+        group: "Navigate",
+        run: () => openTab(tool.href),
+    }));
+    tools.push({
+        id: "site.tool.home",
+        title: "Open haruhime.moe",
+        subtitle: "all tools",
+        group: "Navigate",
+        run: () => openTab("https://www.haruhime.moe"),
+    });
+    return [...pages, ...tools];
+};
+const page = (options) => {
+    const list = [
+        {
+            id: "site.copy-url",
+            title: "Copy page URL",
+            group: "Page",
+            shortcut: "mod+shift+c",
+            closeOnRun: false,
+            run: (ctx) => ctx.copy(location.href),
+        },
+        { id: "site.back", title: "Go back", group: "Page", run: () => history.back() },
+        {
+            id: "site.top",
+            title: "Scroll to top",
+            group: "Page",
+            run: () => window.scrollTo({ top: 0, behavior: reducedMotion() ? "auto" : "smooth" }),
+        },
+        { id: "site.reload", title: "Reload page", group: "Page", run: () => location.reload() },
+    ];
+    if (options.repo)
+        list.push({
+            id: "site.github",
+            title: "Open on GitHub",
+            group: "Page",
+            keywords: ["source", "repo"],
+            run: () => openTab(options.repo),
+        });
+    return list;
+};
+const account = (options) => {
+    const acct = options.account;
+    if (!acct)
+        return [];
+    const list = [
+        {
+            id: "site.sign-in",
+            title: "Sign in",
+            group: "Account",
+            when: () => !acct.signedIn,
+            run: (ctx) => ctx.navigate(acct.signInHref),
+        },
+    ];
+    if (acct.accountHref)
+        list.push({
+            id: "site.account",
+            title: "My account",
+            group: "Account",
+            when: () => acct.signedIn,
+            run: (ctx) => ctx.navigate(acct.accountHref),
+        });
+    if (acct.signOutHref)
+        list.push({
+            id: "site.sign-out",
+            title: "Sign out",
+            group: "Account",
+            when: () => acct.signedIn,
+            run: (ctx) => ctx.navigate(acct.signOutHref),
+        });
+    return list;
+};
+const help = (options) => {
+    const list = [
+        {
+            id: "site.shortcuts",
+            title: "Keyboard shortcuts",
+            group: "Help",
+            shortcut: "?",
+            closeOnRun: false,
+            run: (ctx) => ctx.push({
+                title: "Keyboard shortcuts",
+                placeholder: "Filter shortcuts…",
+                commands: ctx.commands.filter((c) => c.shortcut && c.id !== "site.shortcuts"),
+            }),
+        },
+    ];
+    if (options.repo)
+        list.push({
+            id: "site.report",
+            title: "Report a bug",
+            group: "Help",
+            keywords: ["issue", "feedback"],
+            run: () => openTab(`${options.repo}/issues/new`),
+        });
+    return list;
+};
+const BUILDERS = { navigate, page, account, help };
+/**
+ * @function siteCommands
+ * @param options {SiteCommandsOptions} pages, tools, repo, account and which groups to include
+ * @returns {Command[]} the defaults in order: Navigate, Page, Account, Help
+ */
+export function siteCommands(options = {}) {
+    const include = options.include ?? ["navigate", "page", "account", "help"];
+    return include.flatMap((group) => BUILDERS[group](options));
+}

package/dist/components/palette/store.d.ts

@@ -0,0 +1,94 @@
+/**
+ * @file src/components/palette/store.ts
+ * @desc The palette's state and reducer, pure: open or closed, a stack of page frames (each with
+ *       its own query, active row and provider results, so popping back restores where you
+ *       were), and the argument prompt in progress. Every key the palette handles is an action
+ *       here, so the rules test without a DOM. CommandPalette owns it through useReducer.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+import type { Command, Page } from "./types.js";
+/** One provider's rows on a frame and where its search is. */
+export type ProviderResult = {
+    state: "loading" | "done" | "error";
+    rows: readonly Command[];
+};
+/** One page on the stack. */
+export type Frame = {
+    page: Page;
+    query: string;
+    active: number;
+    providers: Record<string, ProviderResult>;
+};
+/** The argument prompt in progress. */
+export type ArgState = {
+    command: Command;
+    index: number;
+    values: Record<string, string>;
+    query: string;
+    active: number;
+    error?: string | undefined;
+};
+export type PaletteState = {
+    open: boolean;
+    stack: Frame[];
+    arg: ArgState | null;
+};
+export type PaletteAction = {
+    type: "open";
+    root: Page;
+    page?: Page | undefined;
+} | {
+    type: "close";
+} | {
+    type: "query";
+    value: string;
+} | {
+    type: "active";
+    index: number;
+    count: number;
+} | {
+    type: "move";
+    delta: Delta;
+    count: number;
+} | {
+    type: "push";
+    page: Page;
+} | {
+    type: "pop";
+} | {
+    type: "beginArgs";
+    command: Command;
+} | {
+    type: "argAccept";
+    value: string;
+} | {
+    type: "argError";
+    message: string;
+} | {
+    type: "provided";
+    depth: number;
+    providerId: string;
+    result: ProviderResult;
+};
+/**
+ * @function initialState
+ * @returns {PaletteState} closed, empty
+ */
+export declare const initialState: () => PaletteState;
+/**
+ * @function topFrame
+ * @param state {PaletteState} the state
+ * @returns {Frame | undefined} the page on top, undefined while closed
+ */
+export declare const topFrame: (state: PaletteState) => Frame | undefined;
+type Delta = 1 | -1 | "home" | "end";
+/**
+ * @function reduce
+ * @param state {PaletteState} the state before
+ * @param action {PaletteAction} what happened
+ * @returns {PaletteState} the state after; the same object when nothing changes
+ */
+export declare function reduce(state: PaletteState, action: PaletteAction): PaletteState;
+export {};

package/dist/components/palette/store.js

@@ -0,0 +1,135 @@
+/**
+ * @file src/components/palette/store.ts
+ * @desc The palette's state and reducer, pure: open or closed, a stack of page frames (each with
+ *       its own query, active row and provider results, so popping back restores where you
+ *       were), and the argument prompt in progress. Every key the palette handles is an action
+ *       here, so the rules test without a DOM. CommandPalette owns it through useReducer.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+const frame = (page) => ({ page, query: "", active: 0, providers: {} });
+/**
+ * @function initialState
+ * @returns {PaletteState} closed, empty
+ */
+export const initialState = () => ({ open: false, stack: [], arg: null });
+/**
+ * @function topFrame
+ * @param state {PaletteState} the state
+ * @returns {Frame | undefined} the page on top, undefined while closed
+ */
+export const topFrame = (state) => state.stack[state.stack.length - 1];
+const clamp = (index, count) => count === 0 ? 0 : Math.min(Math.max(index, 0), count - 1);
+const moved = (active, delta, count) => {
+    if (count === 0)
+        return 0;
+    if (delta === "home")
+        return 0;
+    if (delta === "end")
+        return count - 1;
+    return (active + delta + count) % count;
+};
+const withTop = (state, patch) => {
+    const top = topFrame(state);
+    if (!top)
+        return state;
+    return { ...state, stack: [...state.stack.slice(0, -1), { ...top, ...patch }] };
+};
+const withArg = (state, patch) => state.arg ? { ...state, arg: { ...state.arg, ...patch } } : state;
+/**
+ * @function reduce
+ * @param state {PaletteState} the state before
+ * @param action {PaletteAction} what happened
+ * @returns {PaletteState} the state after; the same object when nothing changes
+ */
+export function reduce(state, action) {
+    switch (action.type) {
+        case "open": {
+            const stack = [frame(action.root)];
+            if (action.page)
+                stack.push(frame(action.page));
+            return { open: true, stack, arg: null };
+        }
+        case "close":
+            return state.open ? { ...state, open: false } : state;
+        case "query":
+            return state.arg
+                ? withArg(state, { query: action.value, active: 0, error: undefined })
+                : withTop(state, { query: action.value, active: 0 });
+        case "active": {
+            const index = clamp(action.index, action.count);
+            const current = state.arg ? state.arg.active : topFrame(state)?.active;
+            if (index === current)
+                return state;
+            return state.arg ? withArg(state, { active: index }) : withTop(state, { active: index });
+        }
+        case "move": {
+            const current = state.arg ? state.arg.active : (topFrame(state)?.active ?? 0);
+            const active = moved(current, action.delta, action.count);
+            return state.arg ? withArg(state, { active }) : withTop(state, { active });
+        }
+        case "push":
+            return { ...state, stack: [...state.stack, frame(action.page)], arg: null };
+        case "pop": {
+            if (state.arg) {
+                if (state.arg.index === 0)
+                    return { ...state, arg: null };
+                const spec = state.arg.command.args?.[state.arg.index - 1];
+                const values = { ...state.arg.values };
+                if (spec)
+                    delete values[spec.name];
+                return withArg(state, {
+                    index: state.arg.index - 1,
+                    values,
+                    query: "",
+                    active: 0,
+                    error: undefined,
+                });
+            }
+            if (state.stack.length <= 1)
+                return state;
+            return { ...state, stack: state.stack.slice(0, -1) };
+        }
+        case "beginArgs":
+            return {
+                ...state,
+                arg: { command: action.command, index: 0, values: {}, query: "", active: 0 },
+            };
+        case "argAccept": {
+            if (!state.arg)
+                return state;
+            const specs = state.arg.command.args ?? [];
+            const spec = specs[state.arg.index];
+            if (!spec)
+                return { ...state, arg: null };
+            const values = { ...state.arg.values, [spec.name]: action.value };
+            if (state.arg.index + 1 >= specs.length)
+                return { ...state, arg: null };
+            return withArg(state, {
+                index: state.arg.index + 1,
+                values,
+                query: "",
+                active: 0,
+                error: undefined,
+            });
+        }
+        case "argError":
+            return withArg(state, { error: action.message });
+        case "provided": {
+            const target = state.stack[action.depth];
+            if (!target)
+                return state;
+            // A search that starts keeps the previous rows on screen until the new ones land.
+            const previous = target.providers[action.providerId];
+            const result = action.result.state === "loading" && previous
+                ? { ...action.result, rows: previous.rows }
+                : action.result;
+            const updated = {
+                ...target,
+                providers: { ...target.providers, [action.providerId]: result },
+            };
+            return { ...state, stack: state.stack.map((f, i) => (i === action.depth ? updated : f)) };
+        }
+    }
+}

package/dist/components/palette/types.d.ts

@@ -0,0 +1,102 @@
+/**
+ * @file src/components/palette/types.ts
+ * @desc The command palette's data: a Command (leaf with `run`, or nested with `page`, with
+ *       optional `args` collected first), a Page (static commands and async providers), a
+ *       Provider (search as you type), an ArgSpec (one prompt), the PaletteContext a command
+ *       runs with, and CommandPalette's props. Plain types, server-safe.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+import type { ReactNode } from "react";
+/** One row of a "choice" argument. */
+export type ArgChoice = {
+    value: string;
+    label: string;
+    subtitle?: string | undefined;
+};
+/** One prompt collected before a command runs. */
+export type ArgSpec = {
+    name: string;
+    /** The input's placeholder while collecting it. */
+    label: string;
+    type: "text" | "number" | "choice";
+    /** For "choice": the rows to pick from, fuzzy-filtered by the input. */
+    choices?: readonly ArgChoice[] | undefined;
+    /** Returns a message to block Enter. */
+    validate?: ((value: string) => string | undefined) | undefined;
+};
+/** Rows searched as the query changes. `search` must honor the signal. */
+export type Provider = {
+    id: string;
+    /** Group heading for its rows. Default: the page title. */
+    group?: string | undefined;
+    /** Characters before the first search. Default 2. */
+    minLength?: number | undefined;
+    /** Debounce in ms. Default 200. */
+    debounceMs?: number | undefined;
+    search: (query: string, signal: AbortSignal) => Promise<readonly Command[]>;
+};
+/** A list the palette can show: static rows, async rows, or both. */
+export type Page = {
+    title: string;
+    /** Input placeholder. Default "Search…". */
+    placeholder?: string | undefined;
+    commands?: readonly Command[] | undefined;
+    providers?: readonly Provider[] | undefined;
+};
+/** What a command runs with. */
+export type PaletteContext = {
+    /** `router.push`. */
+    navigate: (href: string) => void;
+    close: () => void;
+    /** Push a page; opens the palette first when it's closed. */
+    push: (page: Page) => void;
+    /** Writes to the clipboard and announces "Copied" (or the failure). */
+    copy: (text: string) => Promise<void>;
+    /** `usePathname()`, "" outside the router. */
+    pathname: string;
+    /** Every root command, after `when`. */
+    commands: readonly Command[];
+};
+/** One row. Exactly one of `run` and `page` is set. */
+export type Command = {
+    /** Unique in the app. Recents are stored by it. */
+    id: string;
+    title: string;
+    subtitle?: string | undefined;
+    icon?: ReactNode;
+    /** Matched at a lower weight than the title. */
+    keywords?: readonly string[] | undefined;
+    /** Heading the row sits under. Default "Commands". */
+    group?: string | undefined;
+    /** "mod+shift+c", "?" or a chord "g p". Shown as kbd and active while the palette is mounted. */
+    shortcut?: string | undefined;
+    /** Hidden when false. Read on every render of the list. */
+    when?: ((ctx: PaletteContext) => boolean) | undefined;
+    run?: ((ctx: PaletteContext, args: Record<string, string>) => void | Promise<void>) | undefined;
+    page?: Page | undefined;
+    args?: readonly ArgSpec[] | undefined;
+    /** Close after `run`. Default true. */
+    closeOnRun?: boolean | undefined;
+};
+/** CommandPalette's props. */
+export type CommandPaletteProps = {
+    commands: readonly Command[];
+    /** Searched at the root once the query reaches each one's minLength. */
+    providers?: readonly Provider[] | undefined;
+    /** Namespaces recents in localStorage. Default "default". */
+    storageKey?: string | undefined;
+    /** Default "mod+k". */
+    hotkey?: string | undefined;
+    /** Root placeholder. Default "Search commands…". */
+    placeholder?: string | undefined;
+    /** The dialog's accessible name. Default "Command palette". */
+    label?: string | undefined;
+    /** Default true. */
+    calculator?: boolean | undefined;
+    /** Default true. */
+    recents?: boolean | undefined;
+    /** Classes for the panel. */
+    className?: string | undefined;
+};

package/dist/components/palette/types.js

@@ -0,0 +1,11 @@
+/**
+ * @file src/components/palette/types.ts
+ * @desc The command palette's data: a Command (leaf with `run`, or nested with `page`, with
+ *       optional `args` collected first), a Page (static commands and async providers), a
+ *       Provider (search as you type), an ArgSpec (one prompt), the PaletteContext a command
+ *       runs with, and CommandPalette's props. Plain types, server-safe.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+export {};

package/dist/components/palette/useProviderSearch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file src/components/palette/useProviderSearch.ts
+ * @desc Runs a frame's providers as the query changes: each one waits for its minLength,
+ *       debounces, and gets an AbortSignal that fires when a newer query starts, the frame goes
+ *       away, or the palette closes. A superseded search's result is dropped even if it
+ *       resolves. Results go to the store by frame depth and provider id.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+import type { PaletteAction } from "./store.js";
+import type { Provider } from "./types.js";
+/** What the hook needs. */
+export type ProviderSearchArgs = {
+    providers: readonly Provider[];
+    query: string;
+    /** The frame's index in the stack, so results land on it even after a push. */
+    depth: number;
+    dispatch: (action: PaletteAction) => void;
+    /** False while the palette is closed, or the frame isn't on top. */
+    enabled: boolean;
+};
+/**
+ * @function useProviderSearch
+ * @param args {ProviderSearchArgs} providers, the query, the frame depth, dispatch and enabled
+ * @returns {void}
+ */
+export declare function useProviderSearch({ providers, query, depth, dispatch, enabled, }: ProviderSearchArgs): void;

package/dist/components/palette/useProviderSearch.js

@@ -0,0 +1,68 @@
+/**
+ * @file src/components/palette/useProviderSearch.ts
+ * @desc Runs a frame's providers as the query changes: each one waits for its minLength,
+ *       debounces, and gets an AbortSignal that fires when a newer query starts, the frame goes
+ *       away, or the palette closes. A superseded search's result is dropped even if it
+ *       resolves. Results go to the store by frame depth and provider id.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+"use client";
+import { useEffect } from "react";
+const DEFAULT_DEBOUNCE = 200;
+const DEFAULT_MIN = 2;
+/**
+ * @function useProviderSearch
+ * @param args {ProviderSearchArgs} providers, the query, the frame depth, dispatch and enabled
+ * @returns {void}
+ */
+export function useProviderSearch({ providers, query, depth, dispatch, enabled, }) {
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const trimmed = query.trim();
+        const controllers = [];
+        const timers = [];
+        for (const provider of providers) {
+            if (trimmed.length < (provider.minLength ?? DEFAULT_MIN))
+                continue;
+            const controller = new AbortController();
+            controllers.push(controller);
+            dispatch({
+                type: "provided",
+                depth,
+                providerId: provider.id,
+                result: { state: "loading", rows: [] },
+            });
+            timers.push(setTimeout(() => {
+                provider.search(trimmed, controller.signal).then((rows) => {
+                    if (controller.signal.aborted)
+                        return;
+                    dispatch({
+                        type: "provided",
+                        depth,
+                        providerId: provider.id,
+                        result: { state: "done", rows },
+                    });
+                }, (error) => {
+                    if (controller.signal.aborted)
+                        return;
+                    console.error(`CommandPalette: provider "${provider.id}" failed`, error);
+                    dispatch({
+                        type: "provided",
+                        depth,
+                        providerId: provider.id,
+                        result: { state: "error", rows: [] },
+                    });
+                });
+            }, provider.debounceMs ?? DEFAULT_DEBOUNCE));
+        }
+        return () => {
+            for (const timer of timers)
+                clearTimeout(timer);
+            for (const controller of controllers)
+                controller.abort();
+        };
+    }, [providers, query, depth, dispatch, enabled]);
+}

package/dist/components/shell/HeaderMenu.d.ts

@@ -6,7 +6,7 @@
  *       a click on a link, or focus leaving it closes it too.
  * @author David @dvhsh (https://dvh.sh)
  * @created Mon Sep 28, 2026
- * @modified Mon Sep 28, 2026
+ * @modified Sat Oct 3, 2026
  */
 import { type ComponentProps, type ReactNode } from "react";
 /** One link in the panel. */

package/dist/components/shell/HeaderMenu.js

@@ -6,7 +6,7 @@
  *       a click on a link, or focus leaving it closes it too.
  * @author David @dvhsh (https://dvh.sh)
  * @created Mon Sep 28, 2026
- * @modified Mon Sep 28, 2026
+ * @modified Sat Oct 3, 2026
  */
 "use client";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
@@ -54,5 +54,5 @@ export function HeaderMenu({ label, items = [], children, align = "end", buttonL
             box?.removeEventListener("focusout", onFocusOut);
         };
     }, [open]);
-    return (_jsxs("div", { ref: wrapper, className: cx("relative", className), ...props, children: [_jsx("button", { ref: button, type: "button", "aria-expanded": open, "aria-controls": panelId, "aria-label": buttonLabel, onClick: () => setOpen(!open), className: cx("flex items-center gap-2 font-bold text-c1 text-sm transition-colors hover:text-h1", buttonClassName), children: label }), _jsxs("div", { id: panelId, hidden: !open, className: cx("absolute z-10 mt-2 w-44 flex-col gap-1 rounded-lg border border-b3 bg-b6 p-2", open && "flex", align === "end" ? "right-0" : "left-0"), children: [items.length > 0 ? (_jsx("ul", { className: "flex flex-col gap-1", children: items.map((item) => (_jsx("li", { children: _jsx(AutoLink, { href: item.href, className: ITEM, onClick: () => setOpen(false), children: item.label }) }, item.href))) })) : null, children] })] }));
+    return (_jsxs("div", { ref: wrapper, className: cx("relative", className), ...props, children: [_jsx("button", { ref: button, type: "button", "aria-expanded": open, "aria-controls": panelId, "aria-label": buttonLabel, onClick: () => setOpen(!open), className: cx("flex min-h-6 items-center gap-2 font-bold text-c1 text-sm transition-colors hover:text-h1", buttonClassName), children: label }), _jsxs("div", { id: panelId, hidden: !open, className: cx("absolute z-10 mt-2 w-44 flex-col gap-1 rounded-lg border border-b3 bg-b6 p-2", open && "flex", align === "end" ? "right-0" : "left-0"), children: [items.length > 0 ? (_jsx("ul", { className: "flex flex-col gap-1", children: items.map((item) => (_jsx("li", { children: _jsx(AutoLink, { href: item.href, className: ITEM, onClick: () => setOpen(false), children: item.label }) }, item.href))) })) : null, children] })] }));
 }

package/dist/components/shell/NavItem.d.ts

@@ -5,7 +5,7 @@
  *       browser, so both lists print the same markup.
  * @author David @dvhsh (https://dvh.sh)
  * @created Thu Sep 24, 2026
- * @modified Mon Sep 28, 2026
+ * @modified Sat Oct 3, 2026
  */
 import type { SiteLinkItem } from "./links.js";
 /** One nav entry, its aria-current and the finished classes for its link. */

package/dist/components/shell/NavItem.js

@@ -6,7 +6,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  *       browser, so both lists print the same markup.
  * @author David @dvhsh (https://dvh.sh)
  * @created Thu Sep 24, 2026
- * @modified Mon Sep 28, 2026
+ * @modified Sat Oct 3, 2026
  */
 import { AutoLink } from "../basics/AutoLink.js";
 import { LinkNote } from "./LinkNote.js";
@@ -17,7 +17,7 @@ import { LinkNote } from "./LinkNote.js";
  */
 export function NavItem({ item, current, linkClassName }) {
     if (!item.href) {
-        return (_jsx("li", { children: _jsxs("span", { "aria-disabled": "true", className: "text-c4", children: [item.label, _jsx(LinkNote, { note: item.note })] }) }));
+        return (_jsx("li", { children: _jsxs("span", { className: "text-c4", children: [item.label, _jsx(LinkNote, { note: item.note })] }) }));
     }
     return (_jsx("li", { children: _jsx(AutoLink, { href: item.href, "aria-current": current, className: linkClassName, children: item.label }) }));
 }