livemark 0.16.0 → 0.18.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,15 +1,16 @@
-import type { Section } from "../models/section.ts"
-
-const DEFAULT_ICONS: Record<Section["type"], string> = {
-  article: "book-open",
-  blog: "rss",
-  changelog: "history",
-  external: "external-link",
-}
-
-/** Return the section's icon, falling back to a type-based default */
-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 */

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/hooks/media.ts

@@ -1,6 +1,6 @@
 import { useSyncExternalStore } from "react"
 
-export const MOBILE_BREAKPOINT = 768
+export const MOBILE_BREAKPOINT = 1024
 
 export function useIsMobile() {
   return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot)

package/source/models/article.ts

@@ -45,6 +45,6 @@ export interface ArticleNode {
   path: string
   title: string
   label?: string
-  icon: string
+  icon?: string
   children: 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

@@ -29,10 +29,12 @@ export const ChangelogSection = BaseSection.extend({
   version: z.boolean().optional(),
 })
 
-/** External section: renders as a link to an arbitrary URL. */
-export type ExternalSection = z.infer<typeof ExternalSection>
-export const ExternalSection = BaseSection.extend({
-  type: z.literal("external"),
+/** 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(),
 })
 
@@ -54,6 +56,6 @@ export const Section = z.preprocess(
     ArticleSection,
     BlogSection,
     ChangelogSection,
-    ExternalSection,
+    CustomSection,
   ]),
 )