lightnet 4.0.0 → 4.0.1

package/__tests__/astro-integration/config.spec.ts

@@ -1,364 +0,0 @@
-import { expect, test } from "vitest"
-
-import {
-  configSchema,
-  extendedConfigSchema,
-} from "../../src/astro-integration/config"
-
-const requiredConfig = {
-  title: { en: "LightNet" },
-  languages: [
-    {
-      code: "en",
-      label: { en: "English" },
-      isDefaultSiteLanguage: true,
-    },
-  ],
-}
-
-test("Should default credits to false when omitted", () => {
-  const config = configSchema.parse(requiredConfig)
-
-  expect(config.credits).toBe(false)
-})
-
-test("Should preserve explicit credits false", () => {
-  const config = configSchema.parse({
-    ...requiredConfig,
-    credits: false,
-  })
-
-  expect(config.credits).toBe(false)
-})
-
-test("Should reject invalid BCP-47 language code", () => {
-  expect(() =>
-    configSchema.parse({
-      ...requiredConfig,
-      languages: [
-        {
-          ...requiredConfig.languages[0],
-          code: "en_US",
-        },
-      ],
-    }),
-  ).toThrow(/Invalid BCP-47 language code/)
-})
-
-test("Should reject invalid BCP-47 fallback language code", () => {
-  expect(() =>
-    configSchema.parse({
-      ...requiredConfig,
-      languages: [
-        requiredConfig.languages[0],
-        {
-          code: "de",
-          label: { en: "German" },
-          isSiteLanguage: true,
-          fallbackLanguages: ["es_MX"],
-        },
-      ],
-    }),
-  ).toThrow(/Invalid BCP-47 language code/)
-})
-
-test("Should reject duplicate language codes", () => {
-  expect(() =>
-    configSchema.parse({
-      ...requiredConfig,
-      languages: [
-        requiredConfig.languages[0],
-        {
-          ...requiredConfig.languages[0],
-          isDefaultSiteLanguage: false,
-          isSiteLanguage: true,
-        },
-      ],
-    }),
-  ).toThrow(/Duplicate language code/)
-})
-
-test("Should reject object-based language config", () => {
-  expect(() =>
-    configSchema.parse({
-      ...requiredConfig,
-      languages: {
-        en: {
-          label: { en: "English" },
-          isDefaultSiteLanguage: true,
-        },
-      },
-    }),
-  ).toThrow(/expected array, received object/i)
-})
-
-test("Should reject languages without a default", () => {
-  const parsed = extendedConfigSchema.safeParse({
-    ...requiredConfig,
-    languages: [
-      {
-        code: "en",
-        label: { en: "English" },
-        isSiteLanguage: true,
-      },
-      {
-        code: "de",
-        label: { en: "German" },
-        isSiteLanguage: true,
-      },
-    ],
-  })
-
-  expect(parsed.success).toBe(false)
-  if (parsed.success) {
-    return
-  }
-
-  expect(parsed.error.issues).toEqual(
-    expect.arrayContaining([
-      expect.objectContaining({
-        message: "Exactly one language must define isDefaultSiteLanguage: true",
-      }),
-    ]),
-  )
-})
-
-test("Should reject multiple default site languages", () => {
-  const parsed = extendedConfigSchema.safeParse({
-    ...requiredConfig,
-    languages: [
-      requiredConfig.languages[0],
-      {
-        code: "de",
-        label: { en: "German" },
-        isDefaultSiteLanguage: true,
-      },
-    ],
-  })
-
-  expect(parsed.success).toBe(false)
-  if (parsed.success) {
-    return
-  }
-
-  expect(parsed.error.issues).toEqual(
-    expect.arrayContaining([
-      expect.objectContaining({
-        message: "Exactly one language must define isDefaultSiteLanguage: true",
-      }),
-    ]),
-  )
-})
-
-test("Should set isSiteLanguage when language is default", () => {
-  const parsed = extendedConfigSchema.parse(requiredConfig)
-
-  expect(parsed.languages[0].isSiteLanguage).toBe(true)
-  expect(parsed.locales).toEqual(["en"])
-})
-
-test("Should allow fallback values outside configured site languages", () => {
-  const parsed = extendedConfigSchema.safeParse({
-    ...requiredConfig,
-    languages: [
-      requiredConfig.languages[0],
-      {
-        code: "de",
-        label: { en: "German" },
-        isSiteLanguage: true,
-        fallbackLanguages: ["fr"],
-      },
-    ],
-  })
-
-  expect(parsed.success).toBe(true)
-})
-
-test("Should derive locales and defaultLocale", () => {
-  const parsed = extendedConfigSchema.safeParse({
-    ...requiredConfig,
-    title: {
-      de: "LightNet",
-    },
-    languages: [
-      {
-        code: "en",
-        label: { de: "Englisch" },
-      },
-      {
-        code: "de",
-        label: { de: "Deutsch" },
-        isDefaultSiteLanguage: true,
-        fallbackLanguages: ["es"],
-      },
-      {
-        code: "fr",
-        label: { de: "Franzosisch" },
-      },
-    ],
-  })
-
-  expect(parsed.success).toBe(true)
-  if (!parsed.success) {
-    return
-  }
-
-  expect(parsed.data.locales).toEqual(["de"])
-  expect(parsed.data.defaultLocale).toBe("de")
-})
-
-test("Should accept missing non-default locale in title inline translation", () => {
-  const parsed = extendedConfigSchema.safeParse({
-    ...requiredConfig,
-    languages: [
-      requiredConfig.languages[0],
-      {
-        code: "de",
-        label: { en: "German" },
-        isSiteLanguage: true,
-      },
-    ],
-    title: {
-      en: "LightNet",
-    },
-  })
-
-  expect(parsed.success).toBe(true)
-})
-
-test("Should reject missing default locale in nested inline translation", () => {
-  const parsed = extendedConfigSchema.safeParse({
-    ...requiredConfig,
-    languages: [
-      requiredConfig.languages[0],
-      {
-        code: "de",
-        label: { en: "German" },
-        isSiteLanguage: true,
-      },
-    ],
-    title: {
-      en: "LightNet",
-      de: "LichtNet",
-    },
-    mainMenu: [
-      {
-        href: "/about",
-        label: {
-          de: "Uber",
-        },
-        requiresLocale: true,
-      },
-    ],
-  })
-
-  expect(parsed.success).toBe(false)
-  if (parsed.success) {
-    return
-  }
-
-  expect(parsed.error.issues).toEqual(
-    expect.arrayContaining([
-      expect.objectContaining({
-        message: 'Missing translation for default locale "en"',
-        path: ["mainMenu", 0, "label", "en"],
-      }),
-    ]),
-  )
-})
-
-test("Should reject unsupported locale in inline translation", () => {
-  const parsed = extendedConfigSchema.safeParse({
-    ...requiredConfig,
-    languages: [
-      requiredConfig.languages[0],
-      {
-        code: "de",
-        label: { en: "German" },
-        isSiteLanguage: true,
-      },
-    ],
-    title: {
-      en: "LightNet",
-      fr: "LumiereNet",
-    },
-  })
-
-  expect(parsed.success).toBe(false)
-  if (parsed.success) {
-    return
-  }
-
-  expect(parsed.error.issues).toEqual(
-    expect.arrayContaining([
-      expect.objectContaining({
-        message:
-          'Invalid locale "fr". Inline translations only support configured site locales: en, de',
-        path: ["title", "fr"],
-      }),
-    ]),
-  )
-})
-
-test("Should reject unsupported locale in language label", () => {
-  const parsed = extendedConfigSchema.safeParse({
-    ...requiredConfig,
-    languages: [
-      {
-        code: "en",
-        label: { en: "English", fr: "Anglais" },
-        isDefaultSiteLanguage: true,
-      },
-    ],
-  })
-
-  expect(parsed.success).toBe(false)
-  if (parsed.success) {
-    return
-  }
-
-  expect(parsed.error.issues).toEqual(
-    expect.arrayContaining([
-      expect.objectContaining({
-        message:
-          'Invalid locale "fr". Inline translations only support configured site locales: en',
-        path: ["languages", 0, "label", "fr"],
-      }),
-    ]),
-  )
-})
-
-test("Should accept config when inline translations define default locale", () => {
-  const config = configSchema.parse({
-    ...requiredConfig,
-    languages: [
-      requiredConfig.languages[0],
-      {
-        code: "de",
-        label: { en: "German" },
-        isSiteLanguage: true,
-        fallbackLanguages: ["fr"],
-      },
-    ],
-    title: {
-      en: "LightNet",
-    },
-    logo: {
-      src: "/src/assets/logo.png",
-      alt: {
-        en: "LightNet logo",
-      },
-    },
-    mainMenu: [
-      {
-        href: "/about",
-        label: {
-          en: "About",
-        },
-        requiresLocale: true,
-      },
-    ],
-  })
-
-  expect(config).toBeDefined()
-})

package/__tests__/astro-integration/integration.spec.ts

@@ -1,125 +0,0 @@
-import { expect, test, vi } from "vitest"
-
-import { lightnet } from "../../src/astro-integration/integration"
-
-const requiredLightnetConfig = {
-  title: { en: "LightNet", de: "LightNet" },
-  languages: [
-    {
-      code: "en",
-      label: { en: "English" },
-      isDefaultSiteLanguage: true,
-    },
-    {
-      code: "de",
-      label: { en: "German" },
-      isSiteLanguage: true,
-    },
-  ],
-}
-
-const runSetup = ({
-  lightnetConfig = {},
-  astroSite,
-}: {
-  lightnetConfig?: Record<string, unknown>
-  astroSite?: string | URL
-}) => {
-  const integration = lightnet({
-    ...requiredLightnetConfig,
-    ...lightnetConfig,
-  })
-  const setupHook = integration.hooks["astro:config:setup"]!
-  const updateConfig = vi.fn()
-
-  setupHook({
-    injectRoute: vi.fn(),
-    config: {
-      integrations: [],
-      root: new URL("file:///tmp/lightnet"),
-      srcDir: new URL("file:///tmp/lightnet/src"),
-      site: astroSite,
-    } as never,
-    updateConfig,
-    logger: {
-      info: vi.fn(),
-      warn: vi.fn(),
-      error: vi.fn(),
-      debug: vi.fn(),
-    } as never,
-    addMiddleware: vi.fn(),
-  } as never)
-
-  return { updateConfig }
-}
-
-const getThrownError = (run: () => void) => {
-  try {
-    run()
-  } catch (error) {
-    return error as Error & { hint?: string }
-  }
-  throw new Error("Expected function to throw")
-}
-
-test("Should use lightnet.site and not inject Astro i18n config", () => {
-  const { updateConfig } = runSetup({
-    astroSite: "https://lightnet.community",
-  })
-
-  expect(updateConfig).toHaveBeenCalledWith({
-    integrations: expect.arrayContaining([
-      expect.objectContaining({ name: "@lightnet/tailwind" }),
-      expect.objectContaining({ name: "@astrojs/react" }),
-    ]),
-    vite: {
-      plugins: expect.any(Array),
-    },
-  })
-  expect(updateConfig.mock.calls[0][0]).not.toHaveProperty("site")
-  expect(updateConfig.mock.calls[0][0]).not.toHaveProperty("i18n")
-})
-
-test("Should use Astro site when lightnet.site is not set", () => {
-  const { updateConfig } = runSetup({
-    astroSite: "https://lightnet.community",
-  })
-
-  expect(updateConfig).toHaveBeenCalledWith({
-    integrations: expect.arrayContaining([
-      expect.objectContaining({ name: "@lightnet/tailwind" }),
-      expect.objectContaining({ name: "@astrojs/react" }),
-    ]),
-    vite: {
-      plugins: expect.any(Array),
-    },
-  })
-  expect(updateConfig.mock.calls[0][0]).not.toHaveProperty("site")
-})
-
-test("Should fail schema validation when no site is set", () => {
-  const error = getThrownError(() => runSetup({}))
-
-  expect(error).toMatchObject({
-    message: "Invalid LightNet configuration",
-    hint: expect.stringContaining("Set `site` in your Astro config"),
-  })
-})
-
-test("Should include path when inline translation misses default locale", () => {
-  const error = getThrownError(() =>
-    runSetup({
-      lightnetConfig: {
-        title: { de: "LightNet" },
-      },
-      astroSite: "https://lightnet.community",
-    }),
-  )
-
-  expect(error).toMatchObject({
-    message: "Invalid LightNet configuration",
-    hint: expect.stringContaining(
-      'title.en: Missing translation for default locale "en"',
-    ),
-  })
-})

package/__tests__/astro-integration/tailwind.spec.ts

@@ -1,36 +0,0 @@
-import { expect, test, vi } from "vitest"
-
-import tailwind from "../../src/astro-integration/tailwind"
-
-test("Should preserve inline PostCSS options when injecting Tailwind", async () => {
-  const existingPlugin = {
-    postcssPlugin: "existing-plugin",
-    Once: () => {},
-  }
-  const updateConfig = vi.fn()
-
-  await tailwind().hooks["astro:config:setup"]?.({
-    config: {
-      root: new URL("file:///tmp/lightnet"),
-      vite: {
-        css: {
-          postcss: {
-            map: { inline: false },
-            parser: "sugarss",
-            plugins: [existingPlugin],
-          },
-        },
-      },
-    } as never,
-    updateConfig,
-  } as never)
-
-  const viteConfig = updateConfig.mock.calls[0][0].vite
-
-  expect(viteConfig.css.postcss).toMatchObject({
-    map: { inline: false },
-    parser: "sugarss",
-  })
-  expect(viteConfig.css.postcss.plugins).toHaveLength(3)
-  expect(viteConfig.css.postcss.plugins[0]).toBe(existingPlugin)
-})

package/__tests__/content/content-schema.spec.ts

@@ -1,109 +0,0 @@
-import { z } from "astro/zod"
-import { expect, test, vi } from "vitest"
-
-vi.mock("astro:content", () => ({
-  defineCollection: (definition: unknown) => definition,
-  reference: () => z.string(),
-}))
-
-const {
-  categorySchema,
-  inlineTranslationSchema,
-  mediaCollectionSchema,
-  mediaItemSchema,
-} = await import("../../src/content/content-schema")
-
-test("Should accept inline translation with only default locale", () => {
-  const parsed = inlineTranslationSchema.safeParse({
-    en: "Hello",
-  })
-
-  expect(parsed.success).toBe(true)
-})
-
-test("Should accept inline translation without a specific default locale", () => {
-  const parsed = inlineTranslationSchema.safeParse({
-    de: "Hallo",
-  })
-
-  expect(parsed.success).toBe(true)
-})
-
-test("Should accept arbitrary locale keys in inline translation", () => {
-  const parsed = inlineTranslationSchema.safeParse({
-    en: "Hello",
-    fr: "Bonjour",
-  })
-
-  expect(parsed.success).toBe(true)
-})
-
-test("Should reject empty inline translations", () => {
-  const parsed = inlineTranslationSchema.safeParse({})
-
-  expect(parsed.success).toBe(false)
-  if (parsed.success) {
-    return
-  }
-
-  expect(parsed.error.issues).toEqual(
-    expect.arrayContaining([
-      expect.objectContaining({
-        message: "Inline translations must contain at least one entry",
-        path: [],
-      }),
-    ]),
-  )
-})
-
-test("Should accept category label with default locale only", () => {
-  const parsed = categorySchema.safeParse({
-    label: {
-      en: "Category",
-    },
-  })
-
-  expect(parsed.success).toBe(true)
-})
-
-test("Should accept media collection with media item references", () => {
-  const parsed = mediaCollectionSchema.safeParse({
-    label: {
-      en: "Collection",
-    },
-    mediaItems: ["book-a--en", "book-b--en"],
-  })
-
-  expect(parsed.success).toBe(true)
-})
-
-test("Should reject media collection without media item references", () => {
-  const parsed = mediaCollectionSchema.safeParse({
-    label: {
-      en: "Collection",
-    },
-  })
-
-  expect(parsed.success).toBe(false)
-})
-
-test("Should accept media item without commonId", () => {
-  const parsed = mediaItemSchema.safeParse({
-    title: "A book about love",
-    type: "book",
-    description: "Description",
-    authors: ["George Miller"],
-    dateCreated: "2024-09-10",
-    categories: ["family"],
-    language: "en",
-    image: {
-      src: "/images/a-book-about-love--en.jpg",
-      width: 600,
-      height: 900,
-      format: "webp",
-    },
-    content: [{ type: "upload", url: "/files/a-book-about-love.pdf" }],
-  })
-
-  expect(parsed.success).toBe(true)
-})

package/__tests__/content/get-media-collections.spec.ts

@@ -1,72 +0,0 @@
-import { beforeEach, expect, test, vi } from "vitest"
-
-const getCollectionMock = vi.fn()
-
-vi.mock("astro:content", async () => {
-  const { z } = await import("astro/zod")
-
-  return {
-    getCollection: getCollectionMock,
-    defineCollection: (definition: unknown) => definition,
-    reference: () => z.object({ id: z.string(), collection: z.string() }),
-  }
-})
-
-beforeEach(() => {
-  vi.resetModules()
-  getCollectionMock.mockReset()
-})
-
-test("Should build a reverse index and ignore duplicate media items in a collection", async () => {
-  getCollectionMock.mockResolvedValue([
-    {
-      id: "series-a",
-      data: {
-        label: { en: "Series A" },
-        mediaItems: [
-          { id: "item-2", collection: "media" },
-          { id: "item-1", collection: "media" },
-          { id: "item-1", collection: "media" },
-        ],
-      },
-    },
-    {
-      id: "series-b",
-      data: {
-        label: { en: "Series B" },
-        mediaItems: [{ id: "item-1", collection: "media" }],
-      },
-    },
-  ])
-
-  const { getCollectionsForMediaItem } =
-    await import("../../src/content/get-media-collections")
-
-  expect(await getCollectionsForMediaItem("item-1")).toEqual([
-    "series-a",
-    "series-b",
-  ])
-  expect(await getCollectionsForMediaItem("item-2")).toEqual(["series-a"])
-})
-
-test("Should return empty for unknown media ids and load collections once", async () => {
-  getCollectionMock.mockResolvedValue([
-    {
-      id: "series-a",
-      data: {
-        label: { en: "Series A" },
-        mediaItems: [
-          { id: "item-2", collection: "media" },
-          { id: "item-1", collection: "media" },
-        ],
-      },
-    },
-  ])
-
-  const { getCollectionsForMediaItem } =
-    await import("../../src/content/get-media-collections")
-
-  expect(await getCollectionsForMediaItem("missing-id")).toEqual([])
-  expect(await getCollectionsForMediaItem("item-1")).toEqual(["series-a"])
-  expect(getCollectionMock).toHaveBeenCalledTimes(1)
-})