@lupinum/ginko-docs 0.2.2

package/i18n/locales.ts

@@ -0,0 +1,81 @@
+export const defaultLocale = "en" as const;
+
+export const locales = [
+  {
+    code: "en",
+    language: "en-US",
+    name: "English",
+    nativeName: "English",
+    shortLabel: "EN",
+    flagIcon: "circle-flags:us",
+  },
+  {
+    code: "de",
+    language: "de-DE",
+    name: "Deutsch",
+    nativeName: "Deutsch",
+    shortLabel: "DE",
+    flagIcon: "circle-flags:de",
+  },
+] as const;
+
+export type LocaleCode = (typeof locales)[number]["code"];
+
+export const localeCodes = locales.map((locale) => locale.code) as [LocaleCode, ...LocaleCode[]];
+export const nonDefaultLocaleCodes = localeCodes.filter((locale) => locale !== defaultLocale);
+export const localeIconNames = locales.map((locale) => locale.flagIcon);
+
+export function isLocaleCode(value: string): value is LocaleCode {
+  return localeCodes.includes(value as LocaleCode);
+}
+
+export function isDefaultLocale(
+  locale: LocaleCode,
+  primaryLocale: LocaleCode = defaultLocale,
+): boolean {
+  return locale === primaryLocale;
+}
+
+export function localePrefix(
+  locale: LocaleCode,
+  primaryLocale: LocaleCode = defaultLocale,
+): string {
+  return isDefaultLocale(locale, primaryLocale) ? "" : `/${locale}`;
+}
+
+export function localizedPath(
+  locale: LocaleCode,
+  path: string,
+  primaryLocale: LocaleCode = defaultLocale,
+): string {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  const prefix = localePrefix(locale, primaryLocale);
+
+  if (!prefix) return normalizedPath;
+  if (normalizedPath === "/") return prefix;
+  if (normalizedPath === prefix || normalizedPath.startsWith(`${prefix}/`)) return normalizedPath;
+  return `${prefix}${normalizedPath}`;
+}
+
+export function localeFromPath(
+  path: string,
+  primaryLocale: LocaleCode = defaultLocale,
+  supportedLocales: readonly LocaleCode[] = localeCodes,
+): LocaleCode {
+  const normalizedPath = path.replace(/\/{2,}/g, "/") || "/";
+  const routeLocale = supportedLocales.find(
+    (locale) => normalizedPath === `/${locale}` || normalizedPath.startsWith(`/${locale}/`),
+  );
+
+  return routeLocale ?? primaryLocale;
+}
+
+export function stripLocalePrefix(path: string, locale: LocaleCode): string {
+  const normalizedPath = path.replace(/\/{2,}/g, "/") || "/";
+  const prefix = `/${locale}`;
+
+  if (isDefaultLocale(locale)) return normalizedPath;
+  if (normalizedPath === prefix) return "/";
+  if (normalizedPath.startsWith(`${prefix}/`)) return normalizedPath.slice(prefix.length) || "/";
+  return normalizedPath;
+}

package/i18n/messages/global/banner.ts

@@ -0,0 +1,8 @@
+export const banner = {
+  text: {
+    de: "Neu: die Ginko-Content-Dokumentationspipeline.",
+    en: "Introducing the Ginko Content docs pipeline.",
+  },
+  linkLabel: { de: "Ankündigung lesen", en: "Read the announcement" },
+  dismiss: { de: "Banner schließen", en: "Dismiss banner" },
+} as const;

package/i18n/messages/global/blog.ts

@@ -0,0 +1,14 @@
+export const blog = {
+  title: { de: "Blog", en: "Blog" },
+  pageTitle: { de: "Blog", en: "Blog" },
+  description: {
+    de: "Neuigkeiten, Anleitungen und technische Einblicke.",
+    en: "Updates, guides, and technical insights.",
+  },
+  fallbackTitle: { de: "Blog", en: "Blog" },
+  fallbackDescription: { de: "Ein Dokumentationsartikel.", en: "A documentation article." },
+  back: { de: "Zurück zum Blog", en: "Back to Blog" },
+  toc: { de: "Im Artikel", en: "In this article" },
+  readMore: { de: "Weiterlesen", en: "Read more" },
+  moreArticles: { de: "Weitere Artikel", en: "More articles" },
+} as const;

package/i18n/messages/global/command.ts

@@ -0,0 +1,44 @@
+export const command = {
+  title: { de: "Command Center", en: "Command center" },
+  description: {
+    de: "Navigation, Dokumentation und Aktionen durchsuchen.",
+    en: "Search navigation, documentation, and shortcuts.",
+  },
+  placeholder: { de: "Docs, Seiten, Aktionen suchen...", en: "Search docs, pages, actions..." },
+  noResults: { de: 'Keine Ergebnisse für "{query}"', en: 'No results for "{query}"' },
+  noResultsHelp: {
+    de: "Suche nach einem Seitentitel, Docs-Bereich oder Stichwort.",
+    en: "Try searching for a page title, doc section, or keyword.",
+  },
+  clear: { de: "Suche löschen", en: "Clear search" },
+  navigate: { de: "Navigieren", en: "Navigate" },
+  open: { de: "Öffnen", en: "Open" },
+  close: { de: "Schließen", en: "Close" },
+  closeHint: { de: "Esc schließen", en: "Esc closes" },
+  groups: {
+    recent: { de: "Zuletzt", en: "Recent" },
+    pages: { de: "Navigation", en: "Navigation" },
+    docs_nav: { de: "Docs-Navigation", en: "Docs Navigation" },
+    blog: { de: "Blog-Ergebnisse", en: "Blog Results" },
+    docs: { de: "Docs-Ergebnisse", en: "Docs Results" },
+    actions: { de: "Aktionen", en: "Actions" },
+  },
+  pages: {
+    home: {
+      title: { de: "Start", en: "Home" },
+      description: {
+        de: "Landingpage und Produktüberblick",
+        en: "Landing page and product overview",
+      },
+    },
+    primary: { de: "Hauptnavigation", en: "Primary navigation" },
+    secondary: { de: "Weitere Seite", en: "Secondary page" },
+    documentation: { de: "Dokumentationsbereich", en: "Documentation section" },
+  },
+  actions: {
+    github: {
+      title: { de: "GitHub öffnen", en: "Open GitHub" },
+      description: { de: "Zum Projekt-Repository springen", en: "Jump to the project repository" },
+    },
+  },
+} as const;

package/i18n/messages/global/docs.ts

@@ -0,0 +1,32 @@
+export const docs = {
+  label: { de: "Dokumentation", en: "Documentation" },
+  fallbackTitle: { de: "Dokumentation", en: "Documentation" },
+  fallbackDescription: { de: "Starter-Dokumentation.", en: "Starter documentation." },
+  pageNavigation: { de: "Seitennavigation", en: "Page navigation" },
+  breadcrumbs: { de: "Brotkrümelnavigation", en: "Breadcrumbs" },
+  previous: { de: "Zurück", en: "Previous" },
+  next: { de: "Weiter", en: "Next" },
+  toc: { de: "Auf dieser Seite", en: "On this page" },
+  mobileToc: { de: "Inhalt", en: "Docs" },
+  copyMarkdown: { de: "Markdown kopieren", en: "Copy Markdown" },
+  copyText: { de: "Text kopieren", en: "Copy text" },
+  copied: { de: "Kopiert", en: "Copied" },
+  copiedText: { de: "Text kopiert", en: "Copied text" },
+  copyFailed: { de: "Kopieren fehlgeschlagen", en: "Copy failed" },
+  codeSample: { de: "Codebeispiel", en: "Code sample" },
+  zoomImage: { de: "Bild vergrößern", en: "Zoom image" },
+  moreActions: { de: "Weitere Seitenaktionen", en: "More page actions" },
+  copyLink: { de: "Markdown-Link kopieren", en: "Copy Markdown link" },
+  viewMarkdown: { de: "Als Markdown anzeigen", en: "View as Markdown" },
+  askChatGpt: { de: "In ChatGPT öffnen", en: "Open in ChatGPT" },
+  askClaude: { de: "In Claude öffnen", en: "Open in Claude" },
+  copyMcpUrl: { de: "MCP-Server-URL kopieren", en: "Copy MCP server URL" },
+  contribute: { de: "Zu dieser Seite beitragen", en: "Contribute to this page" },
+  editPage: { de: "Diese Seite bearbeiten", en: "Edit this page" },
+  reportIssue: { de: "Problem melden", en: "Report an issue" },
+  issueTitle: { de: "Dokumentation: {title}", en: "Docs: {title}" },
+  issueBody: {
+    de: "Dokumentationsseite: {path}\n\nProblem beschreiben:",
+    en: "Documentation page: {path}\n\nDescribe the issue:",
+  },
+} as const;

package/i18n/messages/global/errors.ts

@@ -0,0 +1,36 @@
+export const errors = {
+  accessDenied: {
+    title: { de: "Zugriff verweigert", en: "Access denied" },
+    description: {
+      de: "Diese Seite ist nicht fuer den oeffentlichen Zugriff freigegeben.",
+      en: "This page is not available for public access.",
+    },
+  },
+  actions: {
+    contact: { de: "Kontakt aufnehmen", en: "Contact us" },
+    docs: { de: "Dokumentation lesen", en: "Read the docs" },
+    home: { de: "Zur Startseite", en: "Go home" },
+    retry: { de: "Erneut versuchen", en: "Try again" },
+  },
+  notFound: {
+    title: { de: "Seite nicht gefunden", en: "Page not found" },
+    description: {
+      de: "Die angeforderte Seite existiert nicht oder wurde verschoben.",
+      en: "The requested page does not exist or has moved.",
+    },
+  },
+  server: {
+    title: { de: "Etwas ist schiefgelaufen", en: "Something went wrong" },
+    description: {
+      de: "Die Seite konnte gerade nicht geladen werden. Bitte versuche es spaeter erneut oder kontaktiere uns.",
+      en: "The page could not be loaded right now. Please try again later or contact us.",
+    },
+  },
+  unavailable: {
+    title: { de: "Seite nicht verfuegbar", en: "Page unavailable" },
+    description: {
+      de: "Diese Anfrage konnte gerade nicht verarbeitet werden.",
+      en: "This request could not be processed right now.",
+    },
+  },
+} as const;

package/i18n/messages/global/feedback.ts

@@ -0,0 +1,11 @@
+export const feedback = {
+  label: { de: "War diese Seite hilfreich?", en: "Was this page helpful?" },
+  articleLabel: { de: "War dieser Artikel hilfreich?", en: "Was this article helpful?" },
+  yes: { de: "Ja", en: "Yes" },
+  no: { de: "Nein", en: "No" },
+  thanks: { de: "Danke für dein Feedback.", en: "Thanks for your feedback." },
+  issueTitle: {
+    de: "Feedback: {path}",
+    en: "Feedback: {path}",
+  },
+} as const;

package/i18n/messages/global/index.ts

@@ -0,0 +1,21 @@
+import { site } from "./site";
+import { banner } from "./banner";
+import { nav } from "./nav";
+import { docs } from "./docs";
+import { blog } from "./blog";
+import { theme } from "./theme";
+import { command } from "./command";
+import { feedback } from "./feedback";
+import { errors } from "./errors";
+
+export const globalMessages = {
+  site,
+  banner,
+  nav,
+  docs,
+  blog,
+  theme,
+  command,
+  feedback,
+  errors,
+} as const;

package/i18n/messages/global/nav.ts

@@ -0,0 +1,18 @@
+export const nav = {
+  skip: { de: "Zum Hauptinhalt springen", en: "Skip to main content" },
+  home: { de: "Startseite", en: "Home" },
+  main: { de: "Hauptnavigation", en: "Main navigation" },
+  mobile: { de: "Mobile Navigation", en: "Mobile navigation" },
+  navigationSection: { de: "Navigation", en: "Navigation" },
+  settingsHelp: { de: "Einstellungen & Hilfe", en: "Settings & Help" },
+  language: { de: "Sprache wechseln", en: "Change language" },
+  openMenu: { de: "Menü öffnen", en: "Open menu" },
+  closeMenu: { de: "Menü schließen", en: "Close menu" },
+  search: { de: "Suchen", en: "Search" },
+  resources: { de: "Ressourcen", en: "Resources" },
+  company: { de: "Unternehmen", en: "Company" },
+  documentation: { de: "Dokumentation", en: "Documentation" },
+  blog: { de: "Blog", en: "Blog" },
+  github: { de: "GitHub", en: "GitHub" },
+  externalLink: { de: "externer Link", en: "external link" },
+} as const;

package/i18n/messages/global/site.ts

@@ -0,0 +1,4 @@
+export const site = {
+  footer: { de: "Alle Rechte vorbehalten.", en: "All rights reserved." },
+  openSourceBy: { de: "Open Source von", en: "Open source by" },
+} as const;

package/i18n/messages/global/theme.ts

@@ -0,0 +1,7 @@
+export const theme = {
+  label: { de: "Darstellung", en: "Appearance" },
+  toggle: { de: "Darstellung umschalten", en: "Toggle theme" },
+  light: { de: "Hell", en: "Light" },
+  dark: { de: "Dunkel", en: "Dark" },
+  system: { de: "System", en: "System" },
+} as const;

package/i18n/messages/index.ts

@@ -0,0 +1,20 @@
+import { type LocaleCode, localeCodes } from "../locales";
+import { localizedRoutes } from "../routes";
+import { localizeMessages } from "./localize";
+import { messageSource } from "./source";
+
+export const messages = localeCodes.reduce(
+  (localizedMessages, locale) => {
+    localizedMessages[locale] = {
+      ...localizeMessages(messageSource, locale),
+      routes: localizedRoutes[locale],
+    };
+    return localizedMessages;
+  },
+  {} as Record<
+    LocaleCode,
+    ReturnType<typeof localizeMessages<typeof messageSource>> & {
+      routes: (typeof localizedRoutes)[LocaleCode];
+    }
+  >,
+);

package/i18n/messages/localize.ts

@@ -0,0 +1,35 @@
+import type { LocaleCode } from "../locales";
+import { localeCodes } from "../locales";
+
+type LocalizedLeaf = Record<LocaleCode, string>;
+
+export type LocalizedMessages<T> = T extends LocalizedLeaf
+  ? string
+  : T extends readonly (infer TItem)[]
+    ? LocalizedMessages<TItem>[]
+    : T extends object
+      ? { [TKey in keyof T]: LocalizedMessages<T[TKey]> }
+      : T;
+
+function isLocalizedLeaf(value: unknown): value is LocalizedLeaf {
+  return (
+    !!value &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    Object.keys(value).length === localeCodes.length &&
+    localeCodes.every((locale) => typeof (value as Partial<LocalizedLeaf>)[locale] === "string")
+  );
+}
+
+export function localizeMessages<T>(source: T, locale: LocaleCode): LocalizedMessages<T> {
+  if (isLocalizedLeaf(source)) return source[locale] as LocalizedMessages<T>;
+  if (Array.isArray(source)) {
+    return source.map((item) => localizeMessages(item, locale)) as LocalizedMessages<T>;
+  }
+  if (source && typeof source === "object") {
+    return Object.fromEntries(
+      Object.entries(source).map(([key, value]) => [key, localizeMessages(value, locale)]),
+    ) as LocalizedMessages<T>;
+  }
+  return source as LocalizedMessages<T>;
+}

package/i18n/messages/source.ts

@@ -0,0 +1,5 @@
+import { globalMessages } from "./global";
+
+export const messageSource = {
+  ...globalMessages,
+} as const;

package/i18n/routes.ts

@@ -0,0 +1,33 @@
+import { type LocaleCode, localeCodes } from "./locales";
+import { routeSlugs } from "../shared/route-slugs";
+
+export const localizedRoutes = {
+  en: {
+    home: routeSlugs.home.en,
+    docs: routeSlugs.docs.en,
+    blog: routeSlugs.blog.en,
+  },
+  de: {
+    home: routeSlugs.home.de,
+    docs: routeSlugs.docs.de,
+    blog: routeSlugs.blog.de,
+  },
+} as const satisfies Record<LocaleCode, Record<string, string>>;
+
+export type LocalizedRouteKey = keyof (typeof localizedRoutes)[LocaleCode];
+
+const catchAllPage = <const T extends string>(route: T): `${T}/[...slug]` => `${route}/[...slug]`;
+const singleSlugPage = <const T extends string>(route: T): `${T}/[slug]` => `${route}/[slug]`;
+const routeMap = <T>(getRoute: (locale: LocaleCode) => T): Record<LocaleCode, T> =>
+  Object.fromEntries(localeCodes.map((locale) => [locale, getRoute(locale)])) as Record<
+    LocaleCode,
+    T
+  >;
+
+export const i18nPages = {
+  index: routeMap((locale) => localizedRoutes[locale].home),
+  docs: routeMap((locale) => localizedRoutes[locale].docs),
+  "docs-slug": routeMap((locale) => catchAllPage(localizedRoutes[locale].docs)),
+  blog: routeMap((locale) => localizedRoutes[locale].blog),
+  "blog-slug": routeMap((locale) => singleSlugPage(localizedRoutes[locale].blog)),
+};

package/icon-bundle.ts

@@ -0,0 +1,141 @@
+import { createRequire } from "node:module";
+
+export const layerIconNames = [
+  "circle-flags:de",
+  "circle-flags:us",
+  "logos:bun",
+  "logos:npm-icon",
+  "logos:nuxt-icon",
+  "logos:pnpm",
+  "logos:typescript-icon",
+  "logos:vue",
+  "logos:yarn",
+  "lucide:arrow-left",
+  "lucide:arrow-right",
+  "lucide:arrow-up-right",
+  "lucide:atom",
+  "lucide:badge-check",
+  "lucide:blocks",
+  "lucide:book-open",
+  "lucide:bookmark",
+  "lucide:braces",
+  "lucide:building-2",
+  "lucide:check",
+  "lucide:chevron-down",
+  "lucide:chevron-left",
+  "lucide:chevron-right",
+  "lucide:chevrons-up-down",
+  "lucide:circle",
+  "lucide:circle-alert",
+  "lucide:circle-check",
+  "lucide:circle-help",
+  "lucide:circle-x",
+  "lucide:clipboard",
+  "lucide:clock",
+  "lucide:code-xml",
+  "lucide:copy",
+  "lucide:file",
+  "lucide:file-code",
+  "lucide:file-code-2",
+  "lucide:file-cog",
+  "lucide:file-json",
+  "lucide:file-key",
+  "lucide:file-text",
+  "lucide:git-branch",
+  "lucide:github",
+  "lucide:hash",
+  "lucide:home",
+  "lucide:info",
+  "lucide:lightbulb",
+  "lucide:link",
+  "lucide:linkedin",
+  "lucide:list",
+  "lucide:menu",
+  "lucide:message-circle",
+  "lucide:monitor",
+  "lucide:moon",
+  "lucide:newspaper",
+  "lucide:package",
+  "lucide:palette",
+  "lucide:panel-left-open",
+  "lucide:pen-line",
+  "lucide:plug",
+  "lucide:search",
+  "lucide:server",
+  "lucide:sparkles",
+  "lucide:sun",
+  "lucide:table",
+  "lucide:terminal",
+  "lucide:thumbs-down",
+  "lucide:thumbs-up",
+  "lucide:triangle-alert",
+  "lucide:trophy",
+  "lucide:x",
+  "lucide:zap",
+] as const;
+
+type IconTransform = {
+  width?: number;
+  height?: number;
+  left?: number;
+  top?: number;
+  rotate?: number;
+  hFlip?: boolean;
+  vFlip?: boolean;
+};
+type IconData = IconTransform & { body: string };
+type IconAlias = IconTransform & { parent: string };
+type IconCollection = {
+  prefix: string;
+  width?: number;
+  height?: number;
+  icons: Record<string, IconData>;
+  aliases?: Record<string, IconAlias>;
+};
+
+const require = createRequire(import.meta.url);
+const sourceCollections = new Map<string, IconCollection>(
+  ["circle-flags", "logos", "lucide"].map((prefix) => [
+    prefix,
+    require(`@iconify-json/${prefix}/icons.json`) as IconCollection,
+  ]),
+);
+
+export const layerIconCollections: IconCollection[] = [...sourceCollections.values()].map(
+  ({ prefix, width, height }) => ({ prefix, width, height, icons: {}, aliases: {} }),
+);
+
+const bundledCollections = new Map(
+  layerIconCollections.map((collection) => [collection.prefix, collection]),
+);
+
+function includeIcon(prefix: string, name: string, seen = new Set<string>()) {
+  const key = `${prefix}:${name}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+
+  const source = sourceCollections.get(prefix);
+  const target = bundledCollections.get(prefix);
+  if (!source || !target) return;
+
+  const icon = source.icons[name];
+  if (icon) {
+    target.icons[name] = icon;
+    return;
+  }
+
+  const alias = source.aliases?.[name];
+  if (!alias) return;
+  target.aliases![name] = alias;
+  includeIcon(prefix, alias.parent, seen);
+}
+
+export function includeIconNames(names: Iterable<string>) {
+  for (const icon of names) {
+    const separator = icon.indexOf(":");
+    if (separator < 1) continue;
+    includeIcon(icon.slice(0, separator), icon.slice(separator + 1));
+  }
+}
+
+includeIconNames(layerIconNames);

package/index.d.ts

@@ -0,0 +1,13 @@
+import type { GinkoDocsAppConfig } from "./shared/types/app-config";
+
+declare module "nuxt/schema" {
+  interface AppConfig {
+    ginkoDocs: GinkoDocsAppConfig;
+  }
+
+  interface AppConfigInput {
+    ginkoDocs?: Partial<GinkoDocsAppConfig>;
+  }
+}
+
+export {};

package/modules/feature-routing.ts

@@ -0,0 +1,32 @@
+import { defineNuxtModule } from "@nuxt/kit";
+import type {} from "@lupinum/ginko-content";
+
+interface PageRoute {
+  path: string;
+}
+
+export function removeBlogPages(pages: PageRoute[], blogEnabled: boolean) {
+  if (blogEnabled) return;
+
+  for (let index = pages.length - 1; index >= 0; index -= 1) {
+    const page = pages[index];
+    if (page && (page.path === "/blog" || page.path.startsWith("/blog/"))) {
+      pages.splice(index, 1);
+    }
+  }
+}
+
+export default defineNuxtModule({
+  meta: { name: "ginko-docs-feature-routing" },
+  setup(_options, nuxt) {
+    let blogEnabled = false;
+
+    nuxt.hook("content:context", (context) => {
+      blogEnabled = Boolean(context.collections.blog);
+    });
+
+    nuxt.hook("pages:extend", (pages) => {
+      removeBlogPages(pages, blogEnabled);
+    });
+  },
+});