livemark 0.16.0 → 0.17.0

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/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,
   ]),
 )