lightnet 3.12.1 → 4.0.0

package/__tests__/utils/paths.spec.ts

@@ -0,0 +1,116 @@
+import { afterEach, expect, test, vi } from "vitest"
+
+afterEach(() => {
+  vi.unstubAllEnvs()
+  vi.resetModules()
+})
+
+test("Should build localized paths at root base", async () => {
+  vi.stubEnv("BASE_URL", "/")
+
+  const { detailsPagePath, localizePath, searchPagePath } =
+    await import("../../src/utils/paths")
+
+  expect(detailsPagePath("en", { id: "my-book" })).toBe("/en/media/my-book")
+  expect(searchPagePath("en", { category: "comics" })).toBe(
+    "/en/media?category=comics",
+  )
+  expect(localizePath("en", "/about")).toBe("/en/about")
+})
+
+test("Should keep internal paths unchanged at root base", async () => {
+  vi.stubEnv("BASE_URL", "/")
+
+  const { pathWithBase } = await import("../../src/utils/paths")
+
+  expect(pathWithBase("/en/about")).toBe("/en/about")
+  expect(pathWithBase("/en/media?category=comics#results")).toBe(
+    "/en/media?category=comics#results",
+  )
+})
+
+test("Should prefix localized paths with Astro base", async () => {
+  vi.stubEnv("BASE_URL", "/docs/")
+
+  const { detailsPagePath, localizePath, searchPagePath } =
+    await import("../../src/utils/paths")
+
+  expect(detailsPagePath("en", { id: "my-book" })).toBe(
+    "/docs/en/media/my-book",
+  )
+  expect(searchPagePath("en", { category: "comics" })).toBe(
+    "/docs/en/media?category=comics",
+  )
+  expect(localizePath("en", "/about")).toBe("/docs/en/about")
+})
+
+test("Should prefix internal API paths with Astro base", async () => {
+  vi.stubEnv("BASE_URL", "/docs/")
+
+  const { pathWithBase } = await import("../../src/utils/paths")
+
+  expect(pathWithBase("/api/internal/search.json")).toBe(
+    "/docs/api/internal/search.json",
+  )
+})
+
+test("Should strip Astro base from pathname", async () => {
+  vi.stubEnv("BASE_URL", "/docs/")
+
+  const { pathWithoutBase } = await import("../../src/utils/paths")
+
+  expect(pathWithoutBase("/docs/en/media")).toBe("/en/media")
+  expect(pathWithoutBase("/docs")).toBe("/")
+})
+
+test("Should leave root-base pathname unchanged", async () => {
+  vi.stubEnv("BASE_URL", "/")
+
+  const { pathWithoutBase } = await import("../../src/utils/paths")
+
+  expect(pathWithoutBase("/en/media")).toBe("/en/media")
+})
+
+test("Should support explicit base when stripping pathname", async () => {
+  const { pathWithoutBase } = await import("../../src/utils/paths")
+
+  expect(pathWithoutBase("/custom/en/media", "/custom/")).toBe("/en/media")
+  expect(pathWithoutBase("/en/media", "/custom/")).toBe("/en/media")
+})
+
+test("Should preserve root path under Astro base", async () => {
+  vi.stubEnv("BASE_URL", "/docs/")
+
+  const { pathWithBase, localizePath } = await import("../../src/utils/paths")
+
+  expect(pathWithBase("/")).toBe("/docs/")
+  expect(localizePath(undefined, "/")).toBe("/docs/")
+})
+
+test("Should preserve root path at root base", async () => {
+  vi.stubEnv("BASE_URL", "/")
+
+  const { pathWithBase, localizePath } = await import("../../src/utils/paths")
+
+  expect(pathWithBase("/")).toBe("/")
+  expect(localizePath(undefined, "/")).toBe("/")
+})
+
+test("Should preserve query strings and hashes", async () => {
+  vi.stubEnv("BASE_URL", "/docs/")
+
+  const { pathWithBase } = await import("../../src/utils/paths")
+
+  expect(pathWithBase("/en/media?category=comics#results")).toBe(
+    "/docs/en/media?category=comics#results",
+  )
+})
+
+test("Should normalize slashes between base and path", async () => {
+  vi.stubEnv("BASE_URL", "/docs/")
+
+  const { pathWithBase } = await import("../../src/utils/paths")
+
+  expect(pathWithBase("/en/about")).toBe("/docs/en/about")
+  expect(pathWithBase("en/about")).toBe("/docs/en/about")
+})

package/__tests__/utils/urls.spec.ts

@@ -1,6 +1,5 @@
 import config from "virtual:lightnet/config"
-import projectContext from "virtual:lightnet/project-context"
-import { expect, test } from "vitest"
+import { afterEach, expect, test, vi } from "vitest"
 
 import { isExternalUrl } from "../../src/utils/urls"
 
@@ -9,9 +8,15 @@ test("Should treat relative paths as internal", () => {
   expect(isExternalUrl("/page")).toBe(false)
 })
 
+afterEach(() => {
+  vi.unstubAllEnvs()
+})
+
 // absolute url that matches the configured site should be internal
-test("Should treat URLs matching projectContext.site as internal", () => {
-  expect(isExternalUrl(`${projectContext.site}/page`)).toBe(false)
+test("Should treat URLs matching import.meta.env.SITE as internal", () => {
+  vi.stubEnv("SITE", "https://sk8-ministries.dev")
+
+  expect(isExternalUrl("https://sk8-ministries.dev/page")).toBe(false)
 })
 
 // domains listed in internalDomains should be treated as internal

package/exports/content.ts

@@ -13,6 +13,11 @@ import {
   queryMediaItems,
 } from "../src/content/query-media-items"
 
-export const getMediaItems = (
+export const getMediaItems = async (
   query?: MediaItemQuery<CollectionEntry<"media">>,
-) => queryMediaItems(getCollection("media"), query ?? {})
+) =>
+  queryMediaItems(
+    getCollection("media"),
+    getCollection("media-collections"),
+    query ?? {},
+  )

package/exports/i18n.ts

@@ -1,2 +1 @@
 export { getLocalePaths } from "../src/i18n/get-locale-paths"
-export { resolveDefaultLocale } from "../src/i18n/resolve-default-locale"

package/exports/index.ts

@@ -1,6 +1,2 @@
-export {
-  type Language,
-  type LightnetConfig,
-  type Link,
-} from "../src/astro-integration/config"
+export { type LightnetConfig, type Link } from "../src/astro-integration/config"
 export { lightnet as default } from "../src/astro-integration/integration"

package/exports/utils.ts

@@ -1,2 +1 @@
 export { detailsPagePath, searchPagePath } from "../src/utils/paths"
-export { verifySchema, verifySchemaAsync } from "../src/utils/verify-schema"

package/package.json

@@ -3,7 +3,7 @@
   "description": "LightNet makes it easy to run your own digital media library.",
   "type": "module",
   "license": "MIT",
-  "version": "3.12.1",
+  "version": "4.0.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/LightNetDev/lightnet",
@@ -35,38 +35,42 @@
     "./api/versions.ts": "./src/api/versions.ts"
   },
   "peerDependencies": {
-    "astro": "^5.1.0",
+    "astro": "^6.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "tailwindcss": ">=3.4.0 <4.0.0"
   },
   "dependencies": {
-    "@astrojs/react": "^4.4.2",
-    "@astrojs/tailwind": "^6.0.2",
+    "@astrojs/react": "^5.0.2",
+    "@iconify-json/lucide": "^1.2.100",
     "@iconify-json/mdi": "^1.2.3",
     "@iconify/tailwind": "^1.2.0",
     "@tailwindcss/typography": "^0.5.19",
-    "@tanstack/react-virtual": "^3.13.18",
-    "daisyui": "^4.12.24",
+    "@tanstack/react-virtual": "^3.13.23",
+    "autoprefixer": "^10.4.27",
     "embla-carousel": "^8.6.0",
     "embla-carousel-wheel-gestures": "^8.1.0",
     "fuse.js": "^7.1.0",
-    "i18next": "^25.8.5",
-    "marked": "^16.4.2",
-    "yaml": "^2.8.2"
+    "i18next": "^25.10.10",
+    "lucide-react": "^1.7.0",
+    "marked": "^17.0.5",
+    "postcss": "^8.5.8",
+    "postcss-load-config": "^6.0.1",
+    "yaml": "^2.8.3"
   },
   "devDependencies": {
+    "@internal/e2e-test-utils": "^0.0.1",
     "@playwright/test": "^1.58.2",
-    "@types/node": "^22.19.11",
     "@types/react": "^19.2.14",
+    "astro": "^6.1.1",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
+    "vitest": "^4.1.2"
   },
   "engines": {
     "node": ">=22"
   },
   "scripts": {
     "test": "vitest",
-    "e2e": "playwright install --with-deps chromium && playwright test"
+    "e2e": "playwright test"
   }
 }

package/src/astro-integration/config.ts

@@ -1,5 +1,25 @@
 import { z } from "astro/zod"
 
+import { isBcp47 } from "../i18n/bcp-47"
+import { validateInlineTranslations } from "./validators/validate-inline-translations"
+import { validateLanguages } from "./validators/validate-languages"
+
+/**
+ * Translations by BCP-47 tags.
+ * We can only do basic validation here because we cannot access locales
+ * from the same config.
+ *
+ * @example
+ * {
+ *   de: "Hallo",
+ *   en: "Hello"
+ * }
+ */
+export const inlineTranslationSchema = z.record(
+  z.string(),
+  z.string().nonempty(),
+)
+
 /**
  * Link Schema.
  */
@@ -12,9 +32,10 @@ const linkSchema = z.object({
   href: z.string(),
   /**
    * Label to be used for the link.
-   * Can either be a translation key or a fixed string.
+   * Must define a value for the default site locale.
+   * Other configured site locales are optional.
    */
-  label: z.string(),
+  label: inlineTranslationSchema,
   /**
    * If this is set to true the currentLocale will be appended to
    * the href path. Eg. for href="/about"
@@ -27,63 +48,35 @@ const linkSchema = z.object({
   requiresLocale: z.boolean().default(true),
 })
 
-/**
- * Language Schema.
- */
+const bcp47Schema = z.string().refine(isBcp47, {
+  message: "Invalid BCP-47 language code",
+})
+
 const languageSchema = z
   .object({
     /**
-     * IETF BCP-47 language tag for this language.
-     *
-     * This will be the identifier of this language and will
-     * also appear on the URL paths of the website.
+     * BCP-47 code for this language.
      */
-    code: z.string(),
+    code: bcp47Schema,
     /**
-     * The name of the language that will be shown on the Website.
-     *
-     * Can either be a fixed string or a translation key.
+     * Display name for this language.
      */
-    label: z.string(),
+    label: inlineTranslationSchema,
     /**
-     * Should this language be used as a site language?
-     *
-     * Make sure to provide translations inside the `src/translations/` folder.
-     *
-     * Default is `false`
+     * Whether this language should be exposed as a site UI language.
      */
     isSiteLanguage: z.boolean().default(false),
     /**
-     * Should this language be used as the default site language?
-     *
-     * The default language will be used as a fallback when translations are missing
-     * also this will be the language selected when a user visits the site on the `/` path.
-     *
-     * Setting this to `true` will also set `isSiteLanguage` to `true`.
-     *
-     * Default is `false`
+     * Whether this language is the default site language.
      */
     isDefaultSiteLanguage: z.boolean().default(false),
     /**
-     * An array of fallback language codes.
-     *
-     * This is used when no translation key is defined for this language.
-     * The system will iterate over this array in order and use the first language for which a
-     * matching translation key is found.
-     *
-     * If no match is found from the fallback languages, the system will
-     * attempt the translation using the default site language.
-     *
-     * If the translation still cannot be resolved, it will then fall back to the English
-     * translation as a final resort.
-     *
-     * @example ["fr", "it"]
+     * Ordered fallback language codes used when a translation key is missing.
      */
-    fallbackLanguages: z.string().array().default([]),
+    fallbackLanguages: z.array(bcp47Schema).default([]),
   })
   .transform((language) => ({
     ...language,
-    // if language is default site language also set is site language to true.
     isSiteLanguage: language.isDefaultSiteLanguage || language.isSiteLanguage,
   }))
 
@@ -123,11 +116,11 @@ export const configSchema = z.object({
   /**
    * Title of the web site.
    */
-  title: z.string(),
+  title: inlineTranslationSchema,
   /**
-   * All languages: content languages and site languages.
+   * Languages supported by this site.
    */
-  languages: languageSchema.array(),
+  languages: z.array(languageSchema).min(1).superRefine(validateLanguages),
   /**
    * Favicons for your site.
    */
@@ -155,9 +148,10 @@ export const configSchema = z.object({
       src: z.string(),
       /**
        * Alt attribute to add for screen reader etc.
-       * This can be a fixed string or a translation key.
+       * Must define a value for the default site locale.
+       * Other configured site locales are optional.
        */
-      alt: z.string().optional(),
+      alt: inlineTranslationSchema.optional(),
       /**
        * Size in px to use for the logo on the header bar.
        * The size will be applied to the shorter side of your logo image.
@@ -223,8 +217,25 @@ export const configSchema = z.object({
   experimental: z.object({}).optional(),
 })
 
-export type Language = z.input<typeof languageSchema>
+export const extendedConfigSchema = configSchema.transform((config, ctx) => {
+  const locales = config.languages
+    .filter((language) => language.isSiteLanguage)
+    .map((language) => language.code)
+  const defaultLocale =
+    config.languages.find((language) => language.isDefaultSiteLanguage)?.code ??
+    ""
+
+  validateInlineTranslations(config, locales, defaultLocale, ctx)
+
+  return {
+    ...config,
+    locales,
+    defaultLocale,
+  }
+})
+
 export type Link = z.input<typeof linkSchema>
+export type Language = z.output<typeof languageSchema>
 
 export type LightnetConfig = z.input<typeof configSchema>
-export type PreparedLightnetConfig = z.output<typeof configSchema>
+export type ExtendedLightnetConfig = z.output<typeof extendedConfigSchema>

package/src/astro-integration/integration.ts

@@ -1,12 +1,11 @@
 /// <reference path="../i18n/locals.d.ts" />
 import react from "@astrojs/react"
-import tailwind from "@astrojs/tailwind"
 import type { AstroIntegration } from "astro"
+import { AstroError } from "astro/errors"
 
-import { resolveDefaultLocale } from "../i18n/resolve-default-locale"
-import { resolveLocales } from "../i18n/resolve-locales"
 import { verifySchema } from "../utils/verify-schema"
-import { configSchema, type LightnetConfig } from "./config"
+import { extendedConfigSchema, type LightnetConfig } from "./config"
+import tailwind from "./tailwind"
 import { vitePluginLightnetConfig } from "./vite-plugin-lightnet-config"
 
 export function lightnet(lightnetConfig: LightnetConfig): AstroIntegration {
@@ -20,11 +19,18 @@ export function lightnet(lightnetConfig: LightnetConfig): AstroIntegration {
         logger,
         addMiddleware,
       }) => {
+        if (!astroConfig.site) {
+          throw new AstroError(
+            "Invalid LightNet configuration",
+            "Set `site` in your Astro config. LightNet requires Astro `site` to be configured.",
+          )
+        }
+
         const config = verifySchema(
-          configSchema,
+          extendedConfigSchema,
           lightnetConfig,
           "Invalid LightNet configuration",
-          "Fix these errors on the LightNet configuration inside astro.config.mjs:",
+          "Fix these errors on the LightNet configuration:",
         )
 
         injectRoute({
@@ -65,28 +71,11 @@ export function lightnet(lightnetConfig: LightnetConfig): AstroIntegration {
 
         addMiddleware({ entrypoint: "lightnet/locals", order: "pre" })
 
-        astroConfig.integrations.push(
-          tailwind({ applyBaseStyles: false }),
-          react(),
-        )
-
         updateConfig({
+          integrations: [tailwind(), react()],
           vite: {
             plugins: [vitePluginLightnetConfig(config, astroConfig, logger)],
           },
-          i18n: {
-            defaultLocale: resolveDefaultLocale(config),
-            locales: resolveLocales(config),
-            routing: {
-              redirectToDefaultLocale: false,
-              // We need to set this to false to allow for
-              // admin paths without locale. But actually
-              // the default locale will be prefixed for regular
-              // LightNet pages.
-              prefixDefaultLocale: false,
-              fallbackType: "rewrite",
-            },
-          },
         })
       },
     },

package/src/astro-integration/tailwind.ts

@@ -0,0 +1,86 @@
+import { fileURLToPath } from "node:url"
+
+import type { AstroIntegration } from "astro"
+import autoprefixerPlugin from "autoprefixer"
+import type { AcceptedPlugin, ProcessOptions } from "postcss"
+import postcssrc from "postcss-load-config"
+import tailwindPlugin from "tailwindcss"
+
+type PostcssInlineOptions =
+  | undefined
+  | string
+  | (ProcessOptions & {
+      plugins?: AcceptedPlugin[]
+    })
+
+function isInlinePostCssOptions(
+  postcssInlineOptions: PostcssInlineOptions,
+): postcssInlineOptions is Exclude<PostcssInlineOptions, undefined | string> {
+  return (
+    typeof postcssInlineOptions === "object" && postcssInlineOptions !== null
+  )
+}
+
+async function getPostCssConfig(
+  root: string,
+  postcssInlineOptions: PostcssInlineOptions,
+) {
+  let postcssConfigResult
+  if (!isInlinePostCssOptions(postcssInlineOptions)) {
+    const searchPath =
+      typeof postcssInlineOptions === "string" ? postcssInlineOptions : root
+    try {
+      postcssConfigResult = await postcssrc({}, searchPath)
+    } catch {
+      postcssConfigResult = null
+    }
+  }
+  return postcssConfigResult
+}
+async function getViteConfiguration(
+  root: string,
+  postcssInlineOptions: PostcssInlineOptions,
+) {
+  const postcssConfigResult = await getPostCssConfig(root, postcssInlineOptions)
+  const inlinePostcssOptions = isInlinePostCssOptions(postcssInlineOptions)
+    ? postcssInlineOptions
+    : null
+  const postcssOptions = inlinePostcssOptions
+    ? { ...inlinePostcssOptions }
+    : (postcssConfigResult?.options ?? {})
+  const postcssPlugins =
+    inlinePostcssOptions?.plugins?.slice() ??
+    postcssConfigResult?.plugins?.slice() ??
+    []
+  postcssPlugins.push(tailwindPlugin())
+  postcssPlugins.push(autoprefixerPlugin())
+  return {
+    css: {
+      postcss: {
+        ...postcssOptions,
+        plugins: postcssPlugins,
+      },
+    },
+  }
+}
+
+// Astro v6 no longer supports Tailwind CSS v3 through `@astrojs/tailwind`,
+// so LightNet provides its own minimal integration for now.
+// Remove this in the next major release once Tailwind v4 is the baseline,
+// and then also remove `autoprefixer`, `postcss`, and `postcss-load-config`.
+function tailwindIntegration(): AstroIntegration {
+  return {
+    name: "@lightnet/tailwind",
+    hooks: {
+      "astro:config:setup": async ({ config, updateConfig }) => {
+        updateConfig({
+          vite: await getViteConfiguration(
+            fileURLToPath(config.root),
+            config.vite.css?.postcss,
+          ),
+        })
+      },
+    },
+  }
+}
+export { tailwindIntegration as default }

package/src/astro-integration/validators/validate-inline-translations.ts

@@ -0,0 +1,51 @@
+import { z } from "astro/zod"
+
+export const validateInlineTranslations = (
+  config: {
+    title: Record<string, string>
+    languages: { label: Record<string, string> }[]
+    mainMenu?: { label: Record<string, string> }[]
+    logo?: { alt?: Record<string, string> }
+  },
+  locales: string[],
+  defaultLocale: string,
+  ctx: z.RefinementCtx,
+) => {
+  const validateInlineTranslation = (
+    inlineTranslation: Record<string, string> | undefined,
+    path: (string | number)[],
+  ) => {
+    if (!inlineTranslation) {
+      return
+    }
+
+    if (!(defaultLocale in inlineTranslation)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Missing translation for default locale "${defaultLocale}"`,
+        path: [...path, defaultLocale],
+      })
+    }
+
+    for (const locale of Object.keys(inlineTranslation)) {
+      if (locales.includes(locale)) {
+        continue
+      }
+
+      ctx.addIssue({
+        code: "custom",
+        message: `Invalid locale "${locale}". Inline translations only support configured site locales: ${locales.join(", ")}`,
+        path: [...path, locale],
+      })
+    }
+  }
+
+  validateInlineTranslation(config.title, ["title"])
+  for (const [index, language] of config.languages.entries()) {
+    validateInlineTranslation(language.label, ["languages", index, "label"])
+  }
+  for (const [index, link] of (config.mainMenu ?? []).entries()) {
+    validateInlineTranslation(link.label, ["mainMenu", index, "label"])
+  }
+  validateInlineTranslation(config.logo?.alt, ["logo", "alt"])
+}

package/src/astro-integration/validators/validate-languages.ts

@@ -0,0 +1,39 @@
+import { z } from "astro/zod"
+
+type Language = {
+  code: string
+  isDefaultSiteLanguage?: boolean
+}
+
+export const validateLanguages = (
+  languages: Language[],
+  ctx: z.RefinementCtx,
+) => {
+  const seen = new Set<string>()
+  let defaultCount = 0
+
+  for (const [index, language] of languages.entries()) {
+    const { code, isDefaultSiteLanguage } = language
+
+    if (!seen.has(code)) {
+      seen.add(code)
+    } else {
+      ctx.addIssue({
+        code: "custom",
+        message: `Duplicate language code "${code}"`,
+        path: [index, "code"],
+      })
+    }
+
+    if (isDefaultSiteLanguage) {
+      defaultCount += 1
+    }
+  }
+
+  if (defaultCount !== 1) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Exactly one language must define isDefaultSiteLanguage: true",
+    })
+  }
+}

package/src/astro-integration/virtual.d.ts

@@ -1,5 +1,5 @@
 declare module "virtual:lightnet/config" {
-  const config: import("./config").PreparedLightnetConfig
+  const config: import("./config").ExtendedLightnetConfig
   export default config
 }
 
@@ -8,11 +8,6 @@ declare module "virtual:lightnet/logo" {
   export default logo
 }
 
-declare module "virtual:lightnet/project-context" {
-  const context: import("./project-context").ProjectContext
-  export default context
-}
-
 declare module "virtual:lightnet/components/CustomHead" {
   const CustomHead: ((props: Record<string, any>) => any) | undefined
   export default CustomHead
@@ -22,3 +17,10 @@ declare module "virtual:lightnet/components/CustomFooter" {
   const CustomFooter: ((props: Record<string, any>) => any) | undefined
   export default CustomFooter
 }
+
+declare module "virtual:lightnet/components/media-item-edit-button-controller" {
+  const mediaItemEditButtonController:
+    | { shouldShow: () => boolean; createHref: (mediaId: string) => string }
+    | undefined
+  export default mediaItemEditButtonController
+}