stropress 0.0.1

package/dist/theme-default/src/lib/config.ts

@@ -0,0 +1,195 @@
+export interface NavItem {
+  label: string;
+  link: string;
+  icon?: string;
+}
+
+export interface HomeAction {
+  text: string;
+  link: string;
+  theme?: "brand" | "alt";
+}
+
+export interface HomeFeature {
+  title: string;
+  details: string;
+  icon?: string;
+}
+
+export interface HomeConfig {
+  title?: string;
+  tagline?: string;
+  description?: string;
+  actions?: HomeAction[];
+  features?: HomeFeature[];
+}
+
+export interface SidebarGroup {
+  label: string;
+  icon?: string;
+  items: NavItem[];
+}
+
+export interface LocaleConfig {
+  label: string;
+  lang?: string;
+  site?: {
+    url?: string;
+    title?: string;
+    description?: string;
+  };
+  home?: HomeConfig;
+  nav?: NavItem[];
+  socialLinks?: NavItem[];
+  navbar?: NavItem[];
+  sidebar?: SidebarGroup[];
+}
+
+export interface SiteConfig {
+  site?: {
+    url?: string;
+    title?: string;
+    description?: string;
+  };
+  home?: HomeConfig;
+  nav?: NavItem[];
+  socialLinks?: NavItem[];
+  navbar?: NavItem[];
+  sidebar?: SidebarGroup[];
+  locales?: Record<string, LocaleConfig>;
+}
+
+export interface LocaleLink {
+  key: string;
+  label: string;
+  link: string;
+  isActive: boolean;
+}
+
+export interface ResolvedSiteConfig {
+  localeKey: string;
+  localeLabel: string;
+  localeLang: string;
+  siteTitle: string;
+  siteDescription: string;
+  homeConfig: HomeConfig;
+  nav: NavItem[];
+  socialLinks: NavItem[];
+  sidebar: SidebarGroup[];
+  localeLinks: LocaleLink[];
+}
+
+const rawConfig = import.meta.env.STROPRESS_SITE_CONFIG;
+
+export const siteConfig: SiteConfig =
+  typeof rawConfig === "string" ? JSON.parse(rawConfig) : rawConfig || {};
+export const siteTitle = siteConfig.site?.title || "Stropress Docs";
+export const siteDescription =
+  siteConfig.site?.description || "Documentation site";
+export const homeConfig = siteConfig.home || {};
+
+const normalizeLocaleKey = (key: string) => {
+  const value = key.trim();
+  if (!value || value === "/") {
+    return "/";
+  }
+
+  const prefixed = value.startsWith("/") ? value : `/${value}`;
+  return prefixed.endsWith("/") ? prefixed : `${prefixed}/`;
+};
+
+const normalizePathname = (pathname: string) => {
+  if (!pathname || pathname === "/") {
+    return "/";
+  }
+
+  return pathname.endsWith("/") ? pathname : `${pathname}/`;
+};
+
+const mapLocaleEntries = () => {
+  const locales = siteConfig.locales || {};
+  const entries = Object.entries(locales).map(
+    ([key, value]) => [normalizeLocaleKey(key), value] as const,
+  );
+
+  if (!entries.some(([key]) => key === "/")) {
+    entries.unshift(["/", { label: "Default" }]);
+  }
+
+  return entries.sort((a, b) => b[0].length - a[0].length);
+};
+
+const stripLocalePrefix = (pathname: string, localeKey: string) => {
+  if (localeKey === "/") {
+    return pathname;
+  }
+
+  const normalizedPath = normalizePathname(pathname);
+  if (!normalizedPath.startsWith(localeKey)) {
+    return pathname;
+  }
+
+  const stripped = normalizedPath.slice(localeKey.length - 1);
+  return stripped || "/";
+};
+
+const joinLocalePath = (localeKey: string, subPath: string) => {
+  const normalizedSubPath = subPath.startsWith("/") ? subPath : `/${subPath}`;
+  if (localeKey === "/") {
+    return normalizedSubPath;
+  }
+
+  const suffix = normalizedSubPath === "/" ? "" : normalizedSubPath;
+  const joined = `${localeKey.slice(0, -1)}${suffix}`;
+  return joined || "/";
+};
+
+export const getResolvedSiteConfig = (pathname: string): ResolvedSiteConfig => {
+  const localeEntries = mapLocaleEntries();
+  const normalizedPath = normalizePathname(pathname);
+
+  const currentEntry =
+    localeEntries.find(([key]) => {
+      if (key === "/") {
+        return true;
+      }
+
+      return normalizedPath.startsWith(key);
+    }) || localeEntries[localeEntries.length - 1];
+
+  const [localeKey, localeConfig] = currentEntry;
+  const localeSubPath = stripLocalePrefix(pathname, localeKey);
+
+  const resolvedTitle =
+    localeConfig.site?.title || siteConfig.site?.title || "Stropress Docs";
+  const resolvedDescription =
+    localeConfig.site?.description ||
+    siteConfig.site?.description ||
+    "Documentation site";
+
+  const localeLinks = localeEntries.map(([key, config]) => ({
+    key,
+    label: config.label || (key === "/" ? "Default" : key),
+    link: joinLocalePath(key, localeSubPath),
+    isActive: key === localeKey,
+  }));
+
+  return {
+    localeKey,
+    localeLabel:
+      localeConfig.label || (localeKey === "/" ? "Default" : localeKey),
+    localeLang: localeConfig.lang || "en",
+    siteTitle: resolvedTitle,
+    siteDescription: resolvedDescription,
+    homeConfig: localeConfig.home || siteConfig.home || {},
+    nav:
+      localeConfig.nav ||
+      siteConfig.nav ||
+      localeConfig.navbar ||
+      siteConfig.navbar ||
+      [],
+    socialLinks: localeConfig.socialLinks || siteConfig.socialLinks || [],
+    sidebar: localeConfig.sidebar || siteConfig.sidebar || [],
+    localeLinks,
+  };
+};

package/dist/theme-default/src/lib/custom-home.ts

@@ -0,0 +1,40 @@
+export interface CustomHomeModule {
+  default: any;
+  title?: string;
+  description?: string;
+  sidebar?: boolean;
+  contentClass?: string;
+}
+
+const customHomeModules = import.meta.glob<CustomHomeModule>(
+  "../content/docs/**/index.astro",
+);
+
+const normalizePathname = (pathname: string) => {
+  if (!pathname || pathname === "/") {
+    return "/";
+  }
+
+  return pathname.endsWith("/") ? pathname : `${pathname}/`;
+};
+
+const getCustomHomeModulePath = (pathname: string) => {
+  const normalizedPath = normalizePathname(pathname);
+
+  if (normalizedPath === "/") {
+    return "../content/docs/index.astro";
+  }
+
+  return `../content/docs${normalizedPath.slice(0, -1)}/index.astro`;
+};
+
+export const getCustomHomeModule = async (pathname: string) => {
+  const modulePath = getCustomHomeModulePath(pathname);
+  const loader = customHomeModules[modulePath];
+
+  if (!loader) {
+    return null;
+  }
+
+  return loader();
+};

package/dist/theme-default/src/lib/custom-style.ts

@@ -0,0 +1,11 @@
+const customStyleModules = import.meta.glob<string>(
+  "../content/docs/index.css",
+  {
+    query: "?raw",
+    import: "default",
+    eager: true,
+  },
+);
+
+export const customGlobalStyle =
+  customStyleModules["../content/docs/index.css"];

package/dist/theme-default/src/lib/og.ts

@@ -0,0 +1,275 @@
+import { constants as fsConstants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import satori from "satori";
+import { html } from "satori-html";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+const { Resvg } =
+  require("@resvg/resvg-js") as typeof import("@resvg/resvg-js");
+
+interface LoadedFont {
+  name: string;
+  data: ArrayBuffer;
+  weight: 400 | 700;
+  style: "normal";
+}
+
+export interface OgRenderInput {
+  title: string;
+  description?: string;
+  siteTitle?: string;
+  routePath?: string;
+}
+
+let cachedOgFonts: LoadedFont[] | null = null;
+
+const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+
+export const renderOgPng = async (input: OgRenderInput) => {
+  const fonts = await loadOgFonts();
+  const svg = await buildOgSvg({
+    title: truncateText(input.title || "Untitled", 84),
+    description: truncateText(input.description || "", 160),
+    siteTitle: truncateText(input.siteTitle || "Stropress Docs", 60),
+    routePath: input.routePath || "/preview",
+    fonts,
+  });
+
+  return renderSvgToPng(svg);
+};
+
+const loadOgFonts = async (): Promise<LoadedFont[]> => {
+  if (cachedOgFonts) {
+    return cachedOgFonts;
+  }
+
+  const regularPath = await resolveFontsourceFontFile(
+    "@fontsource/inter",
+    "400",
+  );
+  const boldPath = await resolveFontsourceFontFile("@fontsource/inter", "700");
+
+  const regular = await readFile(regularPath);
+  const bold = await readFile(boldPath);
+
+  cachedOgFonts = [
+    {
+      name: "OG Sans",
+      data: regular.buffer.slice(
+        regular.byteOffset,
+        regular.byteOffset + regular.byteLength,
+      ),
+      weight: 400,
+      style: "normal",
+    },
+    {
+      name: "OG Sans",
+      data: bold.buffer.slice(
+        bold.byteOffset,
+        bold.byteOffset + bold.byteLength,
+      ),
+      weight: 700,
+      style: "normal",
+    },
+  ];
+
+  return cachedOgFonts;
+};
+
+const resolveFontsourceFontFile = async (
+  packageName: string,
+  weight: "400" | "700",
+) => {
+  const cssCandidates = [
+    path.resolve(process.cwd(), `node_modules/${packageName}/${weight}.css`),
+    path.resolve(
+      process.cwd(),
+      `themes/default/node_modules/${packageName}/${weight}.css`,
+    ),
+    path.resolve(
+      process.cwd(),
+      `cli/node_modules/${packageName}/${weight}.css`,
+    ),
+    path.resolve(moduleDir, `../node_modules/${packageName}/${weight}.css`),
+    path.resolve(moduleDir, `../../node_modules/${packageName}/${weight}.css`),
+  ];
+
+  const cssPath = await resolvePathCandidate(cssCandidates);
+  const cssContent = await readFile(cssPath, "utf8");
+  const fontUrl = extractFontUrlFromCss(cssContent);
+
+  return path.resolve(path.dirname(cssPath), fontUrl);
+};
+
+const resolvePathCandidate = async (candidates: string[]) => {
+  for (const candidate of candidates) {
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+  }
+
+  throw new Error(
+    "Could not locate Fontsource CSS files for OG generation. Ensure @fontsource/inter is installed.",
+  );
+};
+
+const pathExists = async (filePath: string) => {
+  try {
+    await access(filePath, fsConstants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const extractFontUrlFromCss = (css: string) => {
+  const match =
+    css.match(
+      /url\(([^)]+)\)\s+format\(['\"]?(woff2?|truetype|opentype)['\"]?\)/i,
+    ) || css.match(/url\(([^)]+)\)/i);
+
+  if (!match) {
+    throw new Error("Could not parse a font URL from Fontsource CSS.");
+  }
+
+  const rawUrl = match[1].trim().replace(/^['\"]|['\"]$/g, "");
+  if (!rawUrl || rawUrl.startsWith("data:")) {
+    throw new Error("Unsupported Fontsource URL format for OG generation.");
+  }
+
+  return rawUrl;
+};
+
+const buildOgSvg = async (input: {
+  title: string;
+  description: string;
+  siteTitle: string;
+  routePath: string;
+  fonts: LoadedFont[];
+}) => {
+  const routeText = input.routePath === "/" ? "home" : input.routePath;
+
+  try {
+    return await satori(
+      html`<div
+        style="
+        width: 1200px;
+        height: 630px;
+        display: flex;
+        position: relative;
+        overflow: hidden;
+        background: linear-gradient(120deg, #0f172a 0%, #1e293b 100%);
+        color: #f8fafc;
+        font-family: 'OG Sans';
+        box-sizing: border-box;
+        padding: 56px;
+      "
+      >
+        <div
+          style="
+          width: 100%;
+          height: 100%;
+          border-radius: 24px;
+          border: 1px solid rgba(148, 163, 184, 0.3);
+          background: rgba(15, 23, 42, 0.68);
+          display: flex;
+          flex-direction: column;
+          justify-content: space-between;
+          padding: 42px;
+          box-sizing: border-box;
+        "
+        >
+          <div
+            style="
+            font-size: 30px;
+            color: #93c5fd;
+            font-weight: 700;
+          "
+          >
+            ${input.siteTitle}
+          </div>
+          <div style="display: flex; flex-direction: column; gap: 18px;">
+            <div
+              style="
+              font-size: 56px;
+              color: #f8fafc;
+              font-weight: 700;
+              line-height: 1.2;
+            "
+            >
+              ${input.title}
+            </div>
+            <div
+              style="
+              font-size: 30px;
+              color: #cbd5e1;
+              line-height: 1.45;
+            "
+            >
+              ${input.description}
+            </div>
+          </div>
+          <div
+            style="
+            font-size: 24px;
+            color: #94a3b8;
+          "
+          >
+            ${routeText}
+          </div>
+        </div>
+      </div>`,
+      {
+        width: 1200,
+        height: 630,
+        fonts: input.fonts,
+      },
+    );
+  } catch {
+    // Fallback for environments where ultrahtml/satori-html has parser incompatibilities.
+    return `<svg width="1200" height="630" viewBox="0 0 1200 630" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="bg" x1="0" y1="0" x2="1200" y2="630" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#0f172a"/>
+      <stop offset="1" stop-color="#1e293b"/>
+    </linearGradient>
+  </defs>
+  <rect width="1200" height="630" fill="url(#bg)"/>
+  <rect x="56" y="56" width="1088" height="518" rx="24" fill="rgba(15, 23, 42, 0.68)" stroke="rgba(148, 163, 184, 0.30)"/>
+  <text x="96" y="132" fill="#93c5fd" font-size="30" font-family="Arial, sans-serif" font-weight="700">${escapeXml(input.siteTitle)}</text>
+  <text x="96" y="228" fill="#f8fafc" font-size="56" font-family="Arial, sans-serif" font-weight="700">${escapeXml(input.title)}</text>
+  <text x="96" y="304" fill="#cbd5e1" font-size="30" font-family="Arial, sans-serif" font-weight="400">${escapeXml(input.description)}</text>
+  <text x="96" y="532" fill="#94a3b8" font-size="24" font-family="Arial, sans-serif" font-weight="400">${escapeXml(routeText)}</text>
+</svg>`;
+  }
+};
+
+const renderSvgToPng = (svg: string) => {
+  return new Resvg(svg, {
+    fitTo: {
+      mode: "width",
+      value: 1200,
+    },
+  })
+    .render()
+    .asPng();
+};
+
+const escapeXml = (value: string) =>
+  value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+
+const truncateText = (value: string, maxLength: number) => {
+  if (value.length <= maxLength) {
+    return value;
+  }
+
+  return `${value.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+};

package/dist/theme-default/src/pages/[...slug]/index.astro

@@ -0,0 +1,83 @@
+---
+import DocsLayout from "../../layouts/DocsLayout.astro";
+import HomePage from "../../components/HomePage.astro";
+import { getCollection, render, type CollectionEntry } from "astro:content";
+import { getResolvedSiteConfig } from "../../lib/config";
+import { getCustomHomeModule } from "../../lib/custom-home";
+
+export const getStaticPaths = async () => {
+  const docs = await getCollection("docs");
+
+  return docs
+    .filter((entry) => entry.id !== "index")
+    .map((entry) => ({
+      params: {
+        slug: entry.id.endsWith("/index")
+          ? entry.id.slice(0, -"/index".length)
+          : entry.id,
+      },
+      props: {
+        entry,
+      },
+    }));
+};
+
+interface Props {
+  entry: CollectionEntry<"docs">;
+}
+
+const { entry } = Astro.props;
+const { Content, headings } = await render(entry);
+
+const resolvedConfig = getResolvedSiteConfig(Astro.url.pathname);
+const normalizedPathname = Astro.url.pathname.endsWith("/")
+  ? Astro.url.pathname
+  : `${Astro.url.pathname}/`;
+const isLocaleHome =
+  resolvedConfig.localeKey !== "/" &&
+  normalizedPathname === resolvedConfig.localeKey;
+const customHomeModule = isLocaleHome
+  ? await getCustomHomeModule(Astro.url.pathname)
+  : null;
+const CustomHome = customHomeModule?.default;
+const customTitle = customHomeModule?.title;
+const customDescription = customHomeModule?.description;
+const customSidebar = customHomeModule?.sidebar;
+const customContentClass = customHomeModule?.contentClass;
+const localeHomeConfig = isLocaleHome ? resolvedConfig.homeConfig : null;
+const hasHomeContent =
+  isLocaleHome &&
+  !customHomeModule &&
+  (Boolean(localeHomeConfig?.title) ||
+    Boolean(localeHomeConfig?.tagline) ||
+    Boolean(localeHomeConfig?.description) ||
+    (localeHomeConfig?.actions?.length || 0) > 0 ||
+    (localeHomeConfig?.features?.length || 0) > 0);
+---
+
+<DocsLayout
+  title={customTitle || entry.data.title}
+  description={customDescription || entry.data.description}
+  sidebar={typeof customSidebar === "boolean" ? customSidebar : !hasHomeContent}
+  tocHeadings={hasHomeContent || customHomeModule ? undefined : headings}
+  contentClass={customContentClass ||
+    (hasHomeContent || customHomeModule
+      ? undefined
+      : "docs-content markdown-content")}
+>
+  {
+    customHomeModule ? (
+      <CustomHome />
+    ) : hasHomeContent ? (
+      <HomePage />
+    ) : (
+      <Content />
+    )
+  }
+</DocsLayout>
+
+<style is:global>
+  .docs-content {
+    padding: 1rem;
+  }
+</style>

package/dist/theme-default/src/pages/index.astro

@@ -0,0 +1,47 @@
+---
+import DocsLayout from "../layouts/DocsLayout.astro";
+import HomePage from "../components/HomePage.astro";
+import { homeConfig } from "../lib/config";
+import { getCustomHomeModule } from "../lib/custom-home";
+import { getCollection, render } from "astro:content";
+
+const customHomeModule = await getCustomHomeModule(Astro.url.pathname);
+const pages = await getCollection("docs");
+const homeDoc = pages.find((entry) => entry.id === "index");
+
+if (!homeDoc && !customHomeModule) {
+  throw new Error("docs/index.md is required");
+}
+
+const CustomHome = customHomeModule?.default;
+const customTitle = customHomeModule?.title;
+const customDescription = customHomeModule?.description;
+const customSidebar = customHomeModule?.sidebar;
+const customContentClass = customHomeModule?.contentClass;
+const renderedHomeDoc = homeDoc ? await render(homeDoc) : null;
+const Content = renderedHomeDoc?.Content;
+const hasHomeContent =
+  Boolean(homeConfig.title) ||
+  Boolean(homeConfig.tagline) ||
+  Boolean(homeConfig.description) ||
+  (homeConfig.actions?.length || 0) > 0 ||
+  (homeConfig.features?.length || 0) > 0;
+const useCustomHome = Boolean(CustomHome);
+---
+
+<DocsLayout
+  title={customTitle || homeDoc?.data.title}
+  description={customDescription || homeDoc?.data.description}
+  sidebar={typeof customSidebar === "boolean" ? customSidebar : !hasHomeContent}
+  contentClass={customContentClass}
+>
+  {
+    useCustomHome ? (
+      <CustomHome />
+    ) : hasHomeContent ? (
+      <HomePage />
+    ) : Content ? (
+      <Content />
+    ) : null
+  }
+</DocsLayout>