livemark 0.15.0 → 0.17.0

package/source/helpers/resolve-base.unit.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vite-plus/test"
+import { resolveBase } from "./resolve-base.ts"
+
+describe("resolveBase", () => {
+  it("should return undefined for undefined input", () => {
+    expect(resolveBase(undefined, "build")).toBeUndefined()
+    expect(resolveBase(undefined, "serve")).toBeUndefined()
+  })
+
+  it("should return undefined for empty or root-only string", () => {
+    expect(resolveBase("", "build")).toBeUndefined()
+    expect(resolveBase("/", "build")).toBeUndefined()
+  })
+
+  it("should normalize a string without slashes", () => {
+    expect(resolveBase("repo", "build")).toBe("/repo")
+  })
+
+  it("should normalize a string with leading slash", () => {
+    expect(resolveBase("/repo", "build")).toBe("/repo")
+  })
+
+  it("should normalize a string with trailing slash", () => {
+    expect(resolveBase("repo/", "build")).toBe("/repo")
+  })
+
+  it("should normalize a string with both slashes", () => {
+    expect(resolveBase("/repo/", "build")).toBe("/repo")
+  })
+
+  it("should preserve multi-segment paths", () => {
+    expect(resolveBase("/a/b/", "build")).toBe("/a/b")
+  })
+
+  it("should call a function with command=build", () => {
+    const fn = (cmd: "build" | "serve") => (cmd === "build" ? "prod" : "dev")
+    expect(resolveBase(fn, "build")).toBe("/prod")
+  })
+
+  it("should call a function with command=serve", () => {
+    const fn = (cmd: "build" | "serve") => (cmd === "build" ? "prod" : "dev")
+    expect(resolveBase(fn, "serve")).toBe("/dev")
+  })
+
+  it("should handle a function returning undefined", () => {
+    const fn = (cmd: "build" | "serve") =>
+      cmd === "serve" ? undefined : "prod"
+    expect(resolveBase(fn, "serve")).toBeUndefined()
+    expect(resolveBase(fn, "build")).toBe("/prod")
+  })
+
+  it("should handle a function returning empty string", () => {
+    const fn = () => ""
+    expect(resolveBase(fn, "build")).toBeUndefined()
+  })
+
+  it("should normalize the function-returned string", () => {
+    const fn = () => "/repo/"
+    expect(resolveBase(fn, "build")).toBe("/repo")
+  })
+})

package/source/helpers/section.ts

@@ -1,16 +1,32 @@
 import type { Section } from "../models/section.ts"
 
-const DEFAULT_ICONS: Record<Section["type"], string> = {
+const DEFAULT_ICONS: Partial<Record<Section["type"], string>> = {
   article: "book-open",
   blog: "rss",
   changelog: "history",
 }
 
-/** Return the section's icon, falling back to a type-based default */
+/** Return the section's icon, falling back to a type-based default.
+ *  Custom sections have no default — the user opts in via `icon`. */
 export function sectionIcon(section: Pick<Section, "icon" | "type">) {
   return section.icon ?? DEFAULT_ICONS[section.type]
 }
 
+/** Whether a custom section's URL should highlight as active for the
+ *  current pathname. Only `/`-leading internal paths participate;
+ *  protocol-absolute (`https://…`, `//cdn…`) URLs never highlight.
+ *  Match semantics mirror routed sections — exact path or any
+ *  descendant. A URL of `/` only highlights the home page itself
+ *  (otherwise it would always match). */
+export function customSectionActive(url: string, pathname: string) {
+  if (!url.startsWith("/") || url.startsWith("//")) return false
+  const stripped = url.split(/[?#]/)[0] ?? ""
+  const target = `/${stripped.replace(/^\/|\/$/g, "")}/`
+  const current = `/${pathname.replace(/^\/|\/$/g, "")}/`
+  if (target === "/") return current === "/"
+  return current === target || current.startsWith(target)
+}
+
 /** Find the section whose prefix is the longest prefix of the article path */
 export function matchSection<S extends { prefix: string }>(
   articlePath: string,

package/source/helpers/section.unit.ts

@@ -1,5 +1,9 @@
 import { describe, expect, it } from "vite-plus/test"
-import { matchSection, partitionBySection } from "./section.ts"
+import {
+  customSectionActive,
+  matchSection,
+  partitionBySection,
+} from "./section.ts"
 
 describe("matchSection", () => {
   const sections = [
@@ -69,3 +73,41 @@ describe("partitionBySection", () => {
     ])
   })
 })
+
+describe("customSectionActive", () => {
+  it("should not match an absolute http url", () => {
+    expect(customSectionActive("https://x.com/y", "/y/")).toBe(false)
+    expect(customSectionActive("http://x.com/y", "/y/")).toBe(false)
+  })
+
+  it("should not match a protocol-relative url", () => {
+    expect(customSectionActive("//cdn.x.com/y", "/y/")).toBe(false)
+  })
+
+  it("should not match a hash url", () => {
+    expect(customSectionActive("#section", "/section/")).toBe(false)
+  })
+
+  it("should match the exact path", () => {
+    expect(customSectionActive("/about", "/about/")).toBe(true)
+    expect(customSectionActive("/about/", "/about/")).toBe(true)
+  })
+
+  it("should match a descendant path", () => {
+    expect(customSectionActive("/about", "/about/team/")).toBe(true)
+  })
+
+  it("should not match a sibling path with shared prefix", () => {
+    expect(customSectionActive("/about", "/aboutus/")).toBe(false)
+  })
+
+  it("should match exact root only", () => {
+    expect(customSectionActive("/", "/")).toBe(true)
+    expect(customSectionActive("/", "/about/")).toBe(false)
+  })
+
+  it("should ignore query and hash on the url", () => {
+    expect(customSectionActive("/about?x=1", "/about/")).toBe(true)
+    expect(customSectionActive("/about#top", "/about/team/")).toBe(true)
+  })
+})

package/source/models/article.ts

@@ -12,7 +12,6 @@ export const Article = z.object({
   icon: nonEmptyString.optional(),
   order: z.number().optional(),
   path: nonEmptyString.optional(),
-  group: nonEmptyString.optional(),
   sidebar: z.boolean().default(true),
   toc: z.boolean().default(true),
   image: nonEmptyString.optional(),
@@ -49,12 +48,3 @@ export interface ArticleNode {
   icon: string
   children: ArticleNode[]
 }
-
-/**
- * A contiguous section of root articles sharing the same `group` label.
- * `name: undefined` represents the leading ungrouped section (at most one).
- */
-export interface ArticleGroup {
-  name?: string
-  nodes: ArticleNode[]
-}

package/source/models/config.ts

@@ -15,22 +15,33 @@ export type ViteOverride =
   | ViteUserConfig
   | ((env: ConfigEnv) => ViteUserConfig | Promise<ViteUserConfig>)
 
+/** Sub-path mount. String form is used as-is; function form is called
+ *  with Vite's `command` (`"serve"` in dev, `"build"` in production) so
+ *  the user can branch (typical case: serve at `/` in dev but at
+ *  `/repo/` in production for GitHub Pages). The build pipeline
+ *  resolves it to a string before any runtime sees it. */
+export type Base = string | ((command: "build" | "serve") => string | undefined)
+
 /**
  * User-provided configuration for Livemark.
+ *
+ * `vite` and `base` are lifted from `unknown` to their public types so
+ * `defineConfig` shows the right shape in editors. Use this type for
+ * the input to `defineConfig` — it keeps defaulted fields optional
+ * (because zod input ≠ output for fields with `.default()`).
  */
-export type UserConfig = Omit<z.infer<typeof UserConfig>, "vite"> & {
+export type UserConfig = Omit<z.input<typeof UserConfig>, "vite" | "base"> & {
   vite?: ViteOverride
+  base?: Base
 }
 export const UserConfig = z.object({
   site: z.string().optional(),
-  base: z
-    .string()
-    .optional()
-    .transform(v => {
-      if (!v) return undefined
-      const trimmed = v.replace(/^\/|\/$/g, "")
-      return trimmed ? `/${trimmed}` : undefined
-    }),
+  // Stored as `unknown` in the schema (zod can't type a function and
+  // string union meaningfully); the public TypeScript surface above
+  // lifts it back to `Base` for editor support. The build pipeline
+  // resolves it via `resolveBase()` before any runtime consumer sees
+  // it, so the runtime `WebsiteConfig.base` is strictly `string`.
+  base: z.unknown().optional(),
   favicon: z.string().optional(),
   logo: z.string().optional(),
   title: z.string().default("Livemark"),
@@ -48,17 +59,20 @@ export const UserConfig = z.object({
   vite: z.unknown().optional(),
 })
 
-/** Website configuration injected at build time via Vite define */
+/** Website configuration injected at build time via Vite define.
+ *  `base` is strictly a string here — the build pipeline has already
+ *  resolved any function form via `resolveBase()`. */
 export type WebsiteConfig = z.infer<typeof WebsiteConfig>
 export const WebsiteConfig = UserConfig.pick({
   title: true,
   description: true,
   site: true,
-  base: true,
   favicon: true,
   logo: true,
   links: true,
   sections: true,
+}).extend({
+  base: z.string().optional(),
 })
 
 /**
@@ -73,9 +87,13 @@ export const SystemConfig = z.object({
 /**
  * Fully resolved Livemark configuration.
  *
- * `vite` stays `unknown` here because that's what the runtime schema
+ * `vite` stays `unknown` because that's what the runtime schema
  * produces — consumer-facing typing happens via {@link UserConfig} so
- * `defineConfig` shows the right shape in editors.
+ * `defineConfig` shows the right shape in editors. `base` is lifted to
+ * `string | undefined` because `loadConfig()` resolves any function
+ * form via `resolveBase()` before returning.
  */
-export type Config = z.infer<typeof Config>
+export type Config = Omit<z.infer<typeof Config>, "base"> & {
+  base?: string
+}
 export const Config = UserConfig.merge(SystemConfig)

package/source/models/section.ts

@@ -3,7 +3,6 @@ import { z } from "zod"
 const BaseSection = z.object({
   icon: z.string().optional(),
   title: z.string(),
-  prefix: z.string(),
   position: z.enum(["header", "sidebar"]).default("header"),
 })
 
@@ -11,22 +10,34 @@ const BaseSection = z.object({
 export type ArticleSection = z.infer<typeof ArticleSection>
 export const ArticleSection = BaseSection.extend({
   type: z.literal("article"),
+  prefix: z.string(),
 })
 
 /** Blog section: date-sorted posts with tags and index. */
 export type BlogSection = z.infer<typeof BlogSection>
 export const BlogSection = BaseSection.extend({
   type: z.literal("blog"),
+  prefix: z.string(),
 })
 
 /** Changelog section: single file or GitHub releases, split per version. */
 export type ChangelogSection = z.infer<typeof ChangelogSection>
 export const ChangelogSection = BaseSection.extend({
   type: z.literal("changelog"),
+  prefix: z.string(),
   source: z.string(),
   version: z.boolean().optional(),
 })
 
+/** Custom section: renders as a link to an arbitrary URL — absolute
+ *  (`https://…`) or internal (`/changelog`). Internal URLs participate
+ *  in active-state highlighting like routed sections. */
+export type CustomSection = z.infer<typeof CustomSection>
+export const CustomSection = BaseSection.extend({
+  type: z.literal("custom"),
+  url: z.string(),
+})
+
 /**
  * A site section. Discriminated on `type`.
  * When `type` is omitted, it defaults to "article" so plain
@@ -41,5 +52,10 @@ export const Section = z.preprocess(
     const record = input as Record<string, unknown>
     return "type" in record ? record : { ...record, type: "article" }
   },
-  z.discriminatedUnion("type", [ArticleSection, BlogSection, ChangelogSection]),
+  z.discriminatedUnion("type", [
+    ArticleSection,
+    BlogSection,
+    ChangelogSection,
+    CustomSection,
+  ]),
 )