lightnet 4.0.0 → 4.0.2

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

@@ -1,213 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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,153 +0,0 @@
-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" }, tMap, {
-      path: ["content", 0],
-    }),
-  ).toEqual({
-    url: "https://some.host/some.pDf",
-    canBeOpened: true,
-    type: "text",
-    target: "_blank",
-    labelText: "some",
-    isExternal: true,
-    extension: "pdf",
-  })
-})
-;[
-  {
-    url: "https://youtube.com/watch?v=k2exixc",
-    expected: {
-      canBeOpened: true,
-      target: "_blank",
-      labelText: "youtube.com",
-      isExternal: true,
-      extension: "",
-      type: "link",
-    },
-  },
-  {
-    url: "https://wikipedia.org",
-    expected: {
-      canBeOpened: true,
-      target: "_blank",
-      labelText: "wikipedia.org",
-      isExternal: true,
-      extension: "",
-      type: "link",
-    },
-  },
-  {
-    url: "https://some.host/some.pDf",
-    expected: {
-      canBeOpened: true,
-      type: "text",
-      target: "_blank",
-      labelText: "some",
-      isExternal: true,
-      extension: "pdf",
-    },
-  },
-  {
-    url: "https://some.host/some.unknown",
-    expected: {
-      type: "link",
-      canBeOpened: false,
-      target: "_blank",
-      labelText: "some",
-      isExternal: true,
-      extension: "unknown",
-    },
-  },
-  {
-    url: "/files/my.pdf",
-    expected: {
-      canBeOpened: true,
-      type: "text",
-      target: "_self",
-      labelText: "my",
-      isExternal: false,
-      extension: "pdf",
-    },
-  },
-  {
-    url: "/paths/my-id",
-    expected: {
-      canBeOpened: true,
-      target: "_self",
-      labelText: "my-id",
-      isExternal: false,
-      extension: "",
-      type: "link",
-    },
-  },
-  {
-    url: "/files/my.unknown",
-    expected: {
-      canBeOpened: false,
-      target: "_self",
-      labelText: "my",
-      isExternal: false,
-      type: "link",
-      extension: "unknown",
-    },
-  },
-  {
-    url: "/some.zip",
-    expected: {
-      canBeOpened: false,
-      target: "_self",
-      labelText: "some",
-      isExternal: false,
-      extension: "zip",
-      type: "package",
-    },
-  },
-  {
-    url: "/some.zip",
-    label: { en: "foo" },
-    expected: {
-      labelText: "foo",
-      isExternal: false,
-      extension: "zip",
-      type: "package",
-    },
-  },
-].forEach(({ url, expected, label }) => {
-  test(`Should create content metadata for url '${url}' ${label !== undefined ? `and label '${label}'` : ""}`, () => {
-    expect(
-      createContentMetadata({ url, label }, tMap, {
-        path: ["content", 0],
-      }),
-    ).toMatchObject(expected)
-  })
-})
-
-test("Should override name with input", () => {
-  expect(
-    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

@@ -1,56 +0,0 @@
-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" },
-  ])
-})

package/__tests__/utils/markdown.spec.ts

@@ -1,74 +0,0 @@
-import { expect, test } from "vitest"
-
-import { markdownToText } from "../../src/utils/markdown"
-
-test("Should remove '\\' to force new lines", () => {
-  expect(markdownToText("a\\\nb\\ \nc")).toBe("a\nb \nc")
-})
-
-test("Should remove <br> to force new lines", () => {
-  expect(markdownToText("a <br> b<br>\nc")).toBe("a b \nc")
-})
-
-test("Should remove double white space", () => {
-  expect(markdownToText("a  b")).toBe("a b")
-})
-
-test("Should remove triple white space", () => {
-  expect(markdownToText("a   b")).toBe("a b")
-})
-
-test("Should remove escape character '\\'", () => {
-  // eslint-disable-next-line no-useless-escape
-  expect(markdownToText("a \\\* \\\# b")).toBe("a * # b")
-})
-
-test("Should remove headers", () => {
-  expect(markdownToText("# H1\n## H2 words#")).toBe("H1\nH2 words#")
-})
-
-test("Should remove underline", () => {
-  expect(markdownToText("Some <u>underlined</u> Words /u >")).toBe(
-    "Some underlined Words /u >",
-  )
-})
-
-test("Should remove encoded space", () => {
-  expect(markdownToText("Text&#x20;with&#x20;space&#x20;")).toBe(
-    "Text with space ",
-  )
-})
-
-test("Should remove inline modifiers", async () => {
-  expect(markdownToText("this is **some bold** and _italic_ text")).toBe(
-    "this is some bold and italic text",
-  )
-})
-
-test("Should remove code blocks", async () => {
-  expect(markdownToText("some\n```js \ncode\n```\n")).toBe("some\ncode\n")
-})
-
-test("Should remove list", () => {
-  expect(markdownToText("- this is **bold**\n- this is normal")).toBe(
-    "this is bold\nthis is normal",
-  )
-})
-
-test("Should convert links", () => {
-  expect(markdownToText("some [link](https://link.com?foo)")).toBe("some link")
-})
-
-test("Should remove images", () => {
-  expect(markdownToText("![a image](my-image.jpg)")).toBe("a image")
-})
-
-test("Should remove block quotes", () => {
-  expect(markdownToText("> block quote\n>more quote")).toBe(
-    "block quote\nmore quote",
-  )
-})
-
-test("Should return undefined when markdown is undefined", () => {
-  expect(markdownToText(undefined)).toBeUndefined()
-})