lightnet 3.12.1 → 4.0.0

package/__tests__/content/query-media-items.spec.ts

@@ -0,0 +1,213 @@
+import { expect, test, vi } from "vitest"
+
+import type {
+  MediaCollectionEntry,
+  MediaItemEntry,
+} from "../../src/content/content-schema"
+import { queryMediaItems } from "../../src/content/query-media-items"
+
+vi.mock("astro:content", async () => {
+  const { z } = await import("astro/zod")
+
+  return {
+    getCollection: vi.fn(),
+    defineCollection: (definition: unknown) => definition,
+    reference: () => z.object({ id: z.string(), collection: z.string() }),
+  }
+})
+
+const image = {
+  src: "/image.webp",
+  width: 400,
+  height: 600,
+  format: "webp",
+} as const
+
+const mediaItem = ({
+  id,
+  title,
+  type,
+  language,
+  dateCreated,
+  categories,
+}: {
+  id: string
+  title: string
+  type: string
+  language: string
+  dateCreated: string
+  categories?: string[]
+}): MediaItemEntry => ({
+  id,
+  data: {
+    commonId: id,
+    title,
+    type: { id: type, collection: "media-types" },
+    description: "",
+    authors: [],
+    dateCreated,
+    categories: categories?.map((category) => ({
+      id: category,
+      collection: "categories",
+    })),
+    language,
+    image,
+    content: [{ type: "upload", url: "/files/example.pdf" }],
+  },
+})
+
+const mediaItems: MediaItemEntry[] = [
+  mediaItem({
+    id: "a",
+    title: "Alpha",
+    type: "book",
+    language: "en",
+    dateCreated: "2024-01-02",
+    categories: ["family"],
+  }),
+  mediaItem({
+    id: "b",
+    title: "Beta",
+    type: "book",
+    language: "en",
+    dateCreated: "2025-01-03",
+    categories: ["theology"],
+  }),
+  mediaItem({
+    id: "c",
+    title: "Charlie",
+    type: "video",
+    language: "de",
+    dateCreated: "2023-03-04",
+    categories: ["theology"],
+  }),
+  mediaItem({
+    id: "d",
+    title: "Delta",
+    type: "book",
+    language: "en",
+    dateCreated: "2022-01-01",
+  }),
+]
+
+const mediaCollections: MediaCollectionEntry[] = [
+  {
+    id: "featured",
+    data: {
+      label: { en: "Featured" },
+      mediaItems: [
+        { id: "d", collection: "media" },
+        { id: "b", collection: "media" },
+        { id: "a", collection: "media" },
+        { id: "a", collection: "media" },
+      ],
+    },
+  },
+  {
+    id: "german",
+    data: {
+      label: { en: "German" },
+      mediaItems: [{ id: "c", collection: "media" }],
+    },
+  },
+]
+
+test("Should filter by media type", async () => {
+  const result = await queryMediaItems(
+    Promise.resolve(mediaItems),
+    Promise.resolve(mediaCollections),
+    {
+      where: { type: "book" },
+    },
+  )
+
+  expect(result.map((item) => item.id)).toEqual(["a", "b", "d"])
+})
+
+test("Should combine collection and other filters using AND", async () => {
+  const result = await queryMediaItems(
+    Promise.resolve(mediaItems),
+    Promise.resolve(mediaCollections),
+    {
+      where: {
+        collection: "featured",
+        language: "en",
+        type: "book",
+        category: "theology",
+      },
+    },
+  )
+
+  expect(result.map((item) => item.id)).toEqual(["b"])
+})
+
+test("Should keep collection order when no orderBy is set", async () => {
+  const result = await queryMediaItems(
+    Promise.resolve(mediaItems),
+    Promise.resolve(mediaCollections),
+    {
+      where: {
+        collection: "featured",
+      },
+    },
+  )
+
+  expect(result.map((item) => item.id)).toEqual(["d", "b", "a"])
+})
+
+test("Should override collection order when orderBy is set", async () => {
+  const result = await queryMediaItems(
+    Promise.resolve(mediaItems),
+    Promise.resolve(mediaCollections),
+    {
+      where: {
+        collection: "featured",
+      },
+      orderBy: "title",
+    },
+  )
+
+  expect(result.map((item) => item.id)).toEqual(["a", "b", "d"])
+})
+
+test("Should apply limit after ordering", async () => {
+  const result = await queryMediaItems(
+    Promise.resolve(mediaItems),
+    Promise.resolve(mediaCollections),
+    {
+      where: {
+        collection: "featured",
+      },
+      limit: 2,
+    },
+  )
+
+  expect(result.map((item) => item.id)).toEqual(["d", "b"])
+})
+
+test("Should return an empty list for unknown collection filters", async () => {
+  const result = await queryMediaItems(
+    Promise.resolve(mediaItems),
+    Promise.resolve(mediaCollections),
+    {
+      where: {
+        collection: "does-not-exist",
+      },
+    },
+  )
+
+  expect(result).toEqual([])
+})
+
+test("Should sort by dateCreated descending", async () => {
+  const result = await queryMediaItems(
+    Promise.resolve(mediaItems),
+    Promise.resolve(mediaCollections),
+    {
+      where: { type: "book" },
+      orderBy: "dateCreated",
+    },
+  )
+
+  expect(result.map((item) => item.id)).toEqual(["b", "a", "d"])
+})

package/__tests__/i18n/resolve-current-locale.spec.ts

@@ -0,0 +1,65 @@
+import { expect, test } from "vitest"
+
+import { resolveCurrentLocaleFromPathname } from "../../src/i18n/resolve-current-locale"
+
+test("Should resolve current locale from localized path", () => {
+  const currentLocale = resolveCurrentLocaleFromPathname({
+    pathname: "/de/media",
+    locales: ["en", "de"],
+    defaultLocale: "en",
+  })
+
+  expect(currentLocale).toBe("de")
+})
+
+test("Should fallback to default locale for unlocalized path", () => {
+  const currentLocale = resolveCurrentLocaleFromPathname({
+    pathname: "/admin",
+    locales: ["en", "de"],
+    defaultLocale: "en",
+  })
+
+  expect(currentLocale).toBe("en")
+})
+
+test("Should resolve current locale from localized path under Astro base", () => {
+  const currentLocale = resolveCurrentLocaleFromPathname({
+    pathname: "/docs/de/media",
+    base: "/docs",
+    locales: ["en", "de"],
+    defaultLocale: "en",
+  })
+
+  expect(currentLocale).toBe("de")
+})
+
+test("Should fallback to default locale for root path", () => {
+  const currentLocale = resolveCurrentLocaleFromPathname({
+    pathname: "/",
+    locales: ["en", "de"],
+    defaultLocale: "en",
+  })
+
+  expect(currentLocale).toBe("en")
+})
+
+test("Should fallback to default locale for base root path", () => {
+  const currentLocale = resolveCurrentLocaleFromPathname({
+    pathname: "/docs",
+    base: "/docs",
+    locales: ["en", "de"],
+    defaultLocale: "en",
+  })
+
+  expect(currentLocale).toBe("en")
+})
+
+test("Should fallback to default locale for unsupported locale-like segment", () => {
+  const currentLocale = resolveCurrentLocaleFromPathname({
+    pathname: "/de-AT/media",
+    locales: ["en", "de"],
+    defaultLocale: "en",
+  })
+
+  expect(currentLocale).toBe("en")
+})

package/__tests__/i18n/translate-map.spec.ts

@@ -0,0 +1,19 @@
+import { expect, test } from "vitest"
+
+import { useTranslateMap } from "../../src/i18n/translate-map"
+
+const tMap = useTranslateMap("de")
+
+test("Should resolve the localized value for the current locale", () => {
+  expect(tMap({ en: "Hello", de: "Hallo" }, { path: ["title"] })).toBe("Hallo")
+})
+
+test("Should fallback to default locale when current locale is missing", () => {
+  expect(tMap({ en: "Hello" }, { path: ["title"] })).toBe("Hello")
+})
+
+test("Should include the context path in missing translation errors", () => {
+  expect(() =>
+    tMap({ fr: "Bonjour" }, { path: ["content", 0, "label"] }),
+  ).toThrow('Missing translation map value for "content.0.label"')
+})

package/__tests__/i18n/translate.spec.ts

@@ -0,0 +1,91 @@
+import { expect, test, vi } from "vitest"
+
+const importTranslate = async () => import("../../src/i18n/translate")
+const importTranslations = async () => import("../../src/i18n/translations")
+
+test("Should load built-in translations for non-default site locales", async () => {
+  const { useTranslate } = await importTranslate()
+  const t = await useTranslate("de")
+  expect(t("ln.search.title")).toBe("Suche")
+  expect(t("ln.header.select-language")).toBe("Sprache auswählen")
+})
+
+test("Should fail on missing translation key", async () => {
+  const { useTranslate } = await importTranslate()
+  const t = await useTranslate("de")
+  expect(() => t("x.missing-translation")).toThrow(
+    "Missing translation: 'x.missing-translation' is undefined for language 'de'.",
+  )
+})
+
+test("Should not load user translations for missing locale file", async () => {
+  const { loadTranslations } = await importTranslations()
+  const translations = await loadTranslations("en")
+  expect(translations["home.all-items"]).toBeUndefined()
+  expect(translations["ln.search.title"]).toBe("Search")
+})
+
+test("Should fallback to configured fallback languages for missing keys", async () => {
+  vi.resetModules()
+  vi.doMock("../../src/i18n/translations", async () => {
+    const actual = await vi.importActual<
+      typeof import("../../src/i18n/translations")
+    >("../../src/i18n/translations")
+
+    return {
+      ...actual,
+      loadTranslations: vi.fn(async (bcp47: string) => {
+        if (bcp47 === "de") {
+          return {}
+        }
+        if (bcp47 === "en") {
+          return {
+            "x.fallback-only": "Fallback value",
+          }
+        }
+        return {}
+      }),
+    }
+  })
+
+  const { useTranslate } = await importTranslate()
+  const t = await useTranslate("de")
+  expect(t("x.fallback-only")).toBe("Fallback value")
+
+  vi.doUnmock("../../src/i18n/translations")
+  vi.resetModules()
+})
+
+test("Should allow translations whose value matches the key", async () => {
+  vi.resetModules()
+  vi.doMock("../../src/i18n/translations", async () => {
+    const actual = await vi.importActual<
+      typeof import("../../src/i18n/translations")
+    >("../../src/i18n/translations")
+
+    return {
+      ...actual,
+      loadTranslations: vi.fn(async (bcp47: string) => {
+        if (bcp47 === "de") {
+          return {
+            "ln.search.title": "Suche",
+            "x.same-as-value": "x.same-as-value",
+          }
+        }
+        if (bcp47 === "en") {
+          return {
+            "ln.search.title": "Search",
+          }
+        }
+        return {}
+      }),
+    }
+  })
+
+  const { useTranslate } = await importTranslate()
+  const t = await useTranslate("de")
+  expect(t("x.same-as-value")).toBe("x.same-as-value")
+
+  vi.doUnmock("../../src/i18n/translations")
+  vi.resetModules()
+})

package/__tests__/pages/details-page/create-content-metadata.spec.ts

@@ -1,14 +1,22 @@
 import { expect, test } from "vitest"
 
+import { useTranslateMap } from "../../../src/i18n/translate-map"
 import { createContentMetadata } from "../../../src/pages/details-page/utils/create-content-metadata"
 
+const tMap = useTranslateMap("en")
+const tMapDe = useTranslateMap("de")
+
 test("Should create complete content metadata", () => {
-  expect(createContentMetadata({ url: "https://some.host/some.pDf" })).toEqual({
+  expect(
+    createContentMetadata({ url: "https://some.host/some.pDf" }, tMap, {
+      path: ["content", 0],
+    }),
+  ).toEqual({
     url: "https://some.host/some.pDf",
     canBeOpened: true,
     type: "text",
     target: "_blank",
-    label: "some",
+    labelText: "some",
     isExternal: true,
     extension: "pdf",
   })
@@ -19,7 +27,7 @@ test("Should create complete content metadata", () => {
     expected: {
       canBeOpened: true,
       target: "_blank",
-      label: "youtube.com",
+      labelText: "youtube.com",
       isExternal: true,
       extension: "",
       type: "link",
@@ -30,7 +38,7 @@ test("Should create complete content metadata", () => {
     expected: {
       canBeOpened: true,
       target: "_blank",
-      label: "wikipedia.org",
+      labelText: "wikipedia.org",
       isExternal: true,
       extension: "",
       type: "link",
@@ -42,7 +50,7 @@ test("Should create complete content metadata", () => {
       canBeOpened: true,
       type: "text",
       target: "_blank",
-      label: "some",
+      labelText: "some",
       isExternal: true,
       extension: "pdf",
     },
@@ -53,7 +61,7 @@ test("Should create complete content metadata", () => {
       type: "link",
       canBeOpened: false,
       target: "_blank",
-      label: "some",
+      labelText: "some",
       isExternal: true,
       extension: "unknown",
     },
@@ -64,7 +72,7 @@ test("Should create complete content metadata", () => {
       canBeOpened: true,
       type: "text",
       target: "_self",
-      label: "my",
+      labelText: "my",
       isExternal: false,
       extension: "pdf",
     },
@@ -74,7 +82,7 @@ test("Should create complete content metadata", () => {
     expected: {
       canBeOpened: true,
       target: "_self",
-      label: "my-id",
+      labelText: "my-id",
       isExternal: false,
       extension: "",
       type: "link",
@@ -85,7 +93,7 @@ test("Should create complete content metadata", () => {
     expected: {
       canBeOpened: false,
       target: "_self",
-      label: "my",
+      labelText: "my",
       isExternal: false,
       type: "link",
       extension: "unknown",
@@ -96,7 +104,7 @@ test("Should create complete content metadata", () => {
     expected: {
       canBeOpened: false,
       target: "_self",
-      label: "some",
+      labelText: "some",
       isExternal: false,
       extension: "zip",
       type: "package",
@@ -104,19 +112,9 @@ test("Should create complete content metadata", () => {
   },
   {
     url: "/some.zip",
-    label: "foo",
+    label: { en: "foo" },
     expected: {
-      label: "foo",
-      isExternal: false,
-      extension: "zip",
-      type: "package",
-    },
-  },
-  {
-    url: "/some.zip",
-    label: "",
-    expected: {
-      label: "some",
+      labelText: "foo",
       isExternal: false,
       extension: "zip",
       type: "package",
@@ -124,12 +122,32 @@ test("Should create complete content metadata", () => {
   },
 ].forEach(({ url, expected, label }) => {
   test(`Should create content metadata for url '${url}' ${label !== undefined ? `and label '${label}'` : ""}`, () => {
-    expect(createContentMetadata({ url, label })).toMatchObject(expected)
+    expect(
+      createContentMetadata({ url, label }, tMap, {
+        path: ["content", 0],
+      }),
+    ).toMatchObject(expected)
   })
 })
 
 test("Should override name with input", () => {
   expect(
-    createContentMetadata({ url: "/path/to/a.file", label: "My file" }),
-  ).toMatchObject({ label: "My file" })
+    createContentMetadata(
+      { url: "/path/to/a.file", label: { en: "My file" } },
+      tMap,
+      { path: ["content", 0] },
+    ),
+  ).toMatchObject({ labelText: "My file" })
+})
+
+test("Should resolve localized content labels by locale", () => {
+  const result = createContentMetadata(
+    {
+      url: "/files/book.pdf",
+      label: { en: "Read", de: "Lesen" },
+    },
+    tMapDe,
+    { path: ["content", 0] },
+  )
+  expect(result.labelText).toBe("Lesen")
 })

package/__tests__/pages/details-page/get-translations.spec.ts

@@ -0,0 +1,56 @@
+import { beforeEach, expect, test, vi } from "vitest"
+
+const mocks = vi.hoisted(() => ({
+  getMediaItems: vi.fn(),
+  getMediaItem: vi.fn(),
+}))
+
+vi.mock("../../../src/content/get-media-items", () => ({
+  getMediaItems: mocks.getMediaItems,
+  getMediaItem: mocks.getMediaItem,
+}))
+
+beforeEach(() => {
+  vi.resetModules()
+  vi.clearAllMocks()
+})
+
+test("Should return empty translations when commonId is missing", async () => {
+  mocks.getMediaItems.mockResolvedValue([
+    { id: "book-en", data: { commonId: "book", language: "en" } },
+    { id: "book-de", data: { commonId: "book", language: "de" } },
+  ])
+  mocks.getMediaItem.mockResolvedValue({
+    id: "standalone-en",
+    data: { language: "en" },
+  })
+
+  const { getTranslations } =
+    await import("../../../src/pages/details-page/utils/get-translations")
+  const result = await getTranslations("standalone-en")
+
+  expect(result).toEqual([])
+})
+
+test("Should return sorted translations and ignore unique or missing commonId", async () => {
+  mocks.getMediaItems.mockResolvedValue([
+    { id: "book-de", data: { commonId: "book", language: "de" } },
+    { id: "book-en", data: { commonId: "book", language: "en" } },
+    { id: "book-es", data: { commonId: "book", language: "es" } },
+    { id: "guide-en", data: { commonId: "guide", language: "en" } },
+    { id: "standalone-fr", data: { language: "fr" } },
+  ])
+  mocks.getMediaItem.mockResolvedValue({
+    id: "book-en",
+    data: { commonId: "book", language: "en" },
+  })
+
+  const { getTranslations } =
+    await import("../../../src/pages/details-page/utils/get-translations")
+  const result = await getTranslations("book-en")
+
+  expect(result).toEqual([
+    { id: "book-de", language: "de" },
+    { id: "book-es", language: "es" },
+  ])
+})