106 lines
4.3 KiB
TypeScript
106 lines
4.3 KiB
TypeScript
// Central menu config (todo §2): config/menu.ts lets an operator set branding (app name, logo,
|
|
// default theme) and reorder/rename/group/hide nav nodes across all plugins. The reorder/rename/
|
|
// group/hide part is the NavOverride composeNav already applies (the override always wins, before
|
|
// the per-user permission filter). Authored as TypeScript (defineMenu types it); loaded once at
|
|
// boot — fail-loud on a malformed file, defaults when absent (clean clone needs no config).
|
|
|
|
import { existsSync } from "node:fs";
|
|
import { dirname, join } from "node:path";
|
|
import { fileURLToPath, pathToFileURL } from "node:url";
|
|
import type { NavOverride } from "./nav.ts";
|
|
|
|
export type Theme = "auto" | "dark" | "light";
|
|
|
|
export interface Branding {
|
|
logo?: string; // optional logo asset path/URL, rendered in the sidebar brand
|
|
name: string; // app name shown in the sidebar brand
|
|
sub?: string; // optional brand subtitle
|
|
theme?: Theme; // default color theme for the theme-switch
|
|
}
|
|
|
|
export interface MenuConfig {
|
|
branding: Branding;
|
|
override: NavOverride;
|
|
}
|
|
|
|
// What config/menu.ts authors — every field optional; the loader fills branding defaults.
|
|
export interface MenuConfigInput {
|
|
branding?: Partial<Branding>;
|
|
override?: NavOverride;
|
|
}
|
|
|
|
export const DEFAULT_BRANDING: Branding = { name: "Plainpages", sub: "Console" };
|
|
export const DEFAULT_MENU: MenuConfig = { branding: DEFAULT_BRANDING, override: {} };
|
|
|
|
const rootDir = join(dirname(fileURLToPath(import.meta.url)), "..");
|
|
export const MENU_CONFIG_FILE = join(rootDir, "config", "menu.ts");
|
|
|
|
// Identity helper: types the authored config, returns it unchanged (mirrors definePlugin).
|
|
export function defineMenu(config: MenuConfigInput): MenuConfigInput {
|
|
return config;
|
|
}
|
|
|
|
export interface LoadMenuOptions {
|
|
file?: string;
|
|
}
|
|
|
|
export async function loadMenuConfig(options: LoadMenuOptions = {}): Promise<MenuConfig> {
|
|
const file = options.file ?? MENU_CONFIG_FILE;
|
|
if (!existsSync(file)) return DEFAULT_MENU; // clean clone: no central override
|
|
|
|
let mod: { default?: unknown };
|
|
try {
|
|
mod = await import(pathToFileURL(file).href);
|
|
} catch (err) {
|
|
throw new Error(`config/menu.ts failed to import — ${err instanceof Error ? err.message : String(err)}`);
|
|
}
|
|
|
|
const errors = validate(mod.default);
|
|
if (errors.length) throw new Error(`config/menu.ts is invalid:\n${errors.map((e) => ` - ${e}`).join("\n")}`);
|
|
|
|
const authored = mod.default as MenuConfigInput;
|
|
return {
|
|
branding: { ...DEFAULT_BRANDING, ...authored.branding },
|
|
override: authored.override ?? {},
|
|
};
|
|
}
|
|
|
|
const THEMES = new Set<string>(["auto", "dark", "light"]);
|
|
|
|
// Validate the authored shape so a typo fails at boot, not silently at render. Only the fields an
|
|
// operator commonly mis-types; composeNav consumes the override defensively beyond that.
|
|
function validate(input: unknown): string[] {
|
|
if (!isObject(input)) return ["default export must be a config object (use defineMenu)"];
|
|
const errors: string[] = [];
|
|
|
|
if (input.branding !== undefined) {
|
|
if (!isObject(input.branding)) errors.push("branding must be an object");
|
|
else {
|
|
for (const key of ["logo", "name", "sub"] as const) {
|
|
if (input.branding[key] !== undefined && typeof input.branding[key] !== "string") errors.push(`branding.${key} must be a string`);
|
|
}
|
|
if (input.branding.theme !== undefined && !THEMES.has(input.branding.theme as string)) errors.push("branding.theme must be one of auto/dark/light");
|
|
}
|
|
}
|
|
|
|
if (input.override !== undefined) {
|
|
if (!isObject(input.override)) errors.push("override must be an object");
|
|
else {
|
|
for (const key of ["hide", "order"] as const) {
|
|
if (input.override[key] !== undefined && !isStringArray(input.override[key])) errors.push(`override.${key} must be an array of strings`);
|
|
}
|
|
if (input.override.groups !== undefined && !Array.isArray(input.override.groups)) errors.push("override.groups must be an array");
|
|
if (input.override.rename !== undefined && !isObject(input.override.rename)) errors.push("override.rename must be an object");
|
|
}
|
|
}
|
|
return errors;
|
|
}
|
|
|
|
function isObject(v: unknown): v is Record<string, unknown> {
|
|
return typeof v === "object" && v !== null && !Array.isArray(v);
|
|
}
|
|
|
|
function isStringArray(v: unknown): boolean {
|
|
return Array.isArray(v) && v.every((x) => typeof x === "string");
|
|
}
|