@unterberg/nivel 0.2.0 → 0.2.2

package/dist/{chunk-G6PC37P5.js → chunk-IEWXVGSC.js}

@@ -1,16 +1,425 @@
 import {
-  extractDocHeadings
-} from "./chunk-SOVTSE5J.js";
+  extractDocHeadings,
+  getDocsIconMapKey
+} from "./chunk-AT4O3RRN.js";
 import {
-  getDocsIconMapKey,
-  getResolvedPageById,
-  resolveDocsConfig
-} from "./chunk-UMH7S7OB.js";
+  nivelAssetUrl,
+  resolvePublicAssetUrl,
+  withSiteBaseUrl
+} from "./chunk-PYYPYIBD.js";
+
+// src/docs/icons.ts
+import * as lucideIcons from "lucide-react";
+var excludedLucideExports = /* @__PURE__ */ new Set(["createLucideIcon", "Icon", "icons", "LucideProvider", "useLucideContext"]);
+var isLucideIconExport = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return "$$typeof" in value && "render" in value;
+};
+var docsIconNames = Object.freeze(
+  Object.entries(lucideIcons).filter(([name, value]) => !excludedLucideExports.has(name) && isLucideIconExport(value)).map(([name]) => name).sort()
+);
+var docsIconNameSet = new Set(docsIconNames);
+var isDocsIconName = (value) => {
+  return docsIconNameSet.has(value);
+};
+var assertDocsIconName = (value, context) => {
+  if (isDocsIconName(value)) {
+    return;
+  }
+  throw new Error(
+    `${context} must be a valid lucide-react icon export. Received "${value}". See https://lucide.dev/icons/`
+  );
+};
+
+// src/docs/resolveDocsConfig.ts
+var isExternalHref = (value) => {
+  return /^(?:[a-z]+:)?\/\//i.test(value) || value.startsWith("mailto:") || value.startsWith("tel:");
+};
+var normalizeBasePath = (value) => {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error("Docs basePath must be a non-empty absolute path.");
+  }
+  if (!normalized.startsWith("/") || normalized.startsWith("//")) {
+    throw new Error(`Docs basePath must start with "/". Received ${JSON.stringify(value)}.`);
+  }
+  if (normalized.includes("?") || normalized.includes("#")) {
+    throw new Error(`Docs basePath cannot include query strings or hashes. Received ${JSON.stringify(value)}.`);
+  }
+  const collapsed = normalized.replace(/\/+/g, "/").replace(/\/+$/g, "");
+  return collapsed === "" ? "/" : collapsed;
+};
+var normalizeContentDir = (value) => {
+  const normalized = (value ?? "docs").trim();
+  if (!normalized) {
+    throw new Error("Docs contentDir must be a non-empty project-relative path.");
+  }
+  if (normalized.startsWith("/") || normalized.startsWith("\\")) {
+    throw new Error(`Docs contentDir must be project-relative. Received ${JSON.stringify(value)}.`);
+  }
+  if (/^[a-zA-Z]:[\\/]/.test(normalized)) {
+    throw new Error(`Docs contentDir must be project-relative. Received ${JSON.stringify(value)}.`);
+  }
+  const segments = normalized.replaceAll("\\", "/").split("/");
+  const resolvedSegments = [];
+  for (const segment of segments) {
+    if (segment === "" || segment === ".") {
+      continue;
+    }
+    if (segment === "..") {
+      throw new Error(`Docs contentDir cannot escape the project root. Received ${JSON.stringify(value)}.`);
+    }
+    resolvedSegments.push(segment);
+  }
+  if (resolvedSegments.length === 0) {
+    throw new Error(`Docs contentDir must contain at least one path segment. Received ${JSON.stringify(value)}.`);
+  }
+  return resolvedSegments.join("/");
+};
+var normalizeSlug = (value) => value.replace(/^\/+|\/+$/g, "");
+var joinDocsHref = (basePath, slug) => {
+  const normalizedBasePath = normalizeBasePath(basePath);
+  const normalizedSlug = normalizeSlug(slug);
+  if (!normalizedSlug) {
+    return normalizedBasePath === "/" ? "/" : `${normalizedBasePath}/`;
+  }
+  return normalizedBasePath === "/" ? `/${normalizedSlug}/` : `${normalizedBasePath}/${normalizedSlug}/`;
+};
+var normalizePathname = (value) => {
+  const pathname = value.split("?")[0]?.split("#")[0] ?? value;
+  const normalized = pathname.trim().replace(/\/+$/g, "");
+  return normalized === "" ? "/" : `${normalized}/`.replace(/\/+/g, "/");
+};
+var resolveDocsHref = (basePath, href) => {
+  const normalized = href.trim();
+  if (!normalized || normalized.startsWith("#") || isExternalHref(normalized)) {
+    return null;
+  }
+  const pathname = normalized.split("?")[0]?.split("#")[0] ?? normalized;
+  if (!pathname) {
+    return null;
+  }
+  if (pathname.startsWith("/")) {
+    const normalizedPathname = normalizePathname(pathname);
+    const normalizedBasePath = normalizeBasePath(basePath);
+    if (normalizedBasePath === "/") {
+      return normalizedPathname;
+    }
+    return normalizedPathname === `${normalizedBasePath}/` || normalizedPathname.startsWith(`${normalizedBasePath}/`) ? normalizedPathname : null;
+  }
+  if (pathname.startsWith("./") || pathname.startsWith("../")) {
+    return null;
+  }
+  return joinDocsHref(basePath, pathname);
+};
+var normalizeSourcePath = (value) => {
+  const segments = value.replaceAll("\\", "/").split("/");
+  const normalizedSegments = [];
+  for (const segment of segments) {
+    if (segment === "" || segment === ".") {
+      continue;
+    }
+    if (segment === "..") {
+      normalizedSegments.pop();
+      continue;
+    }
+    normalizedSegments.push(segment);
+  }
+  return normalizedSegments.join("/");
+};
+var getSectionHref = (items, visibleOnly = false) => {
+  for (const item of items) {
+    if (item.kind === "page") {
+      if (visibleOnly && !item.showInNav) {
+        continue;
+      }
+      return item.href;
+    }
+    if (item.kind === "group") {
+      if (visibleOnly && !item.showInNav) {
+        continue;
+      }
+      const href = getSectionHref(item.items, visibleOnly);
+      if (href) {
+        return href;
+      }
+    }
+  }
+  return null;
+};
+var resolveNavigationHref = (value, fieldName, basePath) => {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`Docs ${fieldName} must be a non-empty string.`);
+  }
+  if (normalized.startsWith("#") || isExternalHref(normalized)) {
+    return normalized;
+  }
+  if (!normalized.startsWith("/")) {
+    return joinDocsHref(basePath, normalized);
+  }
+  return normalizePathname(normalized);
+};
+var resolveThemeConfig = (theme) => {
+  return {
+    light: theme?.light ?? "consumer-light",
+    dark: theme?.dark ?? "consumer-dark",
+    defaultPreference: theme?.defaultPreference ?? "light"
+  };
+};
+var resolveFooterConfig = (footer) => {
+  return {
+    pagination: footer?.pagination ?? false
+  };
+};
+var resolveRobotsConfig = (robots) => {
+  return robots ?? true;
+};
+var resolveBrandConfig = (brand, siteTitle) => {
+  const text = brand?.text ?? siteTitle;
+  return {
+    text,
+    href: withSiteBaseUrl(brand?.href ?? "/"),
+    logoLight: resolvePublicAssetUrl(brand?.logoLight),
+    logoDark: resolvePublicAssetUrl(brand?.logoDark),
+    logoAlt: brand?.logoAlt ?? `${text} logo`
+  };
+};
+var resolveHeadConfig = (head) => {
+  const fontPreset = head?.fontPreset ?? "inter";
+  const defaultFontStylesheetHref = fontPreset === "inter" ? nivelAssetUrl("fonts/fonts-inter.css") : void 0;
+  const defaultFontPreloadHrefs = fontPreset === "inter" ? [
+    nivelAssetUrl("fonts/inter-v20-latin-regular.woff2"),
+    nivelAssetUrl("fonts/inter-v20-latin-600.woff2"),
+    nivelAssetUrl("fonts/inter-v20-latin-800.woff2")
+  ] : [];
+  return {
+    faviconSvg: resolvePublicAssetUrl(head?.faviconSvg),
+    faviconIco: resolvePublicAssetUrl(head?.faviconIco),
+    appleTouchIcon: resolvePublicAssetUrl(head?.appleTouchIcon),
+    fontPreset,
+    fontStylesheetHref: head?.fontStylesheetHref ?? defaultFontStylesheetHref,
+    fontPreloadHrefs: head?.fontPreloadHrefs ?? defaultFontPreloadHrefs
+  };
+};
+var resolvePartnerAssetUrl = (value) => {
+  if (!value) {
+    return void 0;
+  }
+  return resolvePublicAssetUrl(value);
+};
+var resolvePartner = (partner) => {
+  return {
+    name: partner.name,
+    href: withSiteBaseUrl(partner.href),
+    logoLight: resolvePartnerAssetUrl(partner.logoLight) ?? partner.logoLight,
+    logoDark: resolvePartnerAssetUrl(partner.logoDark),
+    logoAlt: partner.logoAlt ?? `${partner.name} logo`
+  };
+};
+var resolveSocialConfig = (social) => {
+  return {
+    ...social
+  };
+};
+var resolvePartnersConfig = (partners) => {
+  return {
+    primary: (partners?.primary ?? []).map(resolvePartner),
+    gold: (partners?.gold ?? []).map(resolvePartner)
+  };
+};
+var requireTrimmedString = (value, fieldName) => {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`Docs algolia config "${fieldName}" must be a non-empty string.`);
+  }
+  return normalized;
+};
+var resolveAlgoliaConfig = (algolia) => {
+  if (!algolia) {
+    return null;
+  }
+  return {
+    appId: requireTrimmedString(algolia.appId, "appId"),
+    apiKey: requireTrimmedString(algolia.apiKey, "apiKey"),
+    indexName: requireTrimmedString(algolia.indexName, "indexName"),
+    fields: {
+      href: algolia.fields?.href?.trim() || "href",
+      title: algolia.fields?.title?.trim() || "title",
+      excerpt: algolia.fields?.excerpt?.trim() || "excerpt",
+      sectionTitle: algolia.fields?.sectionTitle?.trim() || "sectionTitle"
+    },
+    searchParams: algolia.searchParams ?? {}
+  };
+};
+var normalizeAliases = (aliases, slug) => {
+  const normalizedAliases = /* @__PURE__ */ new Set();
+  for (const alias of aliases ?? []) {
+    const normalizedAlias = normalizeSlug(alias);
+    if (!normalizedAlias || normalizedAlias === slug) {
+      continue;
+    }
+    normalizedAliases.add(normalizedAlias);
+  }
+  return [...normalizedAliases];
+};
+var resolveDocsConfig = (config) => {
+  const normalizedBasePath = normalizeBasePath(config.basePath);
+  const normalizedContentDir = normalizeContentDir(config.contentDir);
+  const pageIds = /* @__PURE__ */ new Set();
+  const pageSlugs = /* @__PURE__ */ new Set();
+  const pageAliases = /* @__PURE__ */ new Set();
+  const groupIds = /* @__PURE__ */ new Set();
+  const sectionIds = /* @__PURE__ */ new Set();
+  const pages = [];
+  const navbarItems = [];
+  const resolveSidebarNodes = (nodes, sectionId) => {
+    return nodes.map((node) => {
+      if (node.kind === "group") {
+        if (groupIds.has(node.id)) {
+          throw new Error(`Duplicate docs group id "${node.id}".`);
+        }
+        if (node.icon) {
+          assertDocsIconName(node.icon, `Docs group "${node.id}" icon`);
+        }
+        groupIds.add(node.id);
+        return {
+          kind: "group",
+          id: node.id,
+          title: node.title,
+          href: node.href ? resolveNavigationHref(node.href, `group "${node.id}" href`, normalizedBasePath) : void 0,
+          showInNav: node.showInNav ?? true,
+          collapsible: node.collapsible,
+          items: resolveSidebarNodes(node.items, sectionId),
+          icon: node.icon
+        };
+      }
+      if (node.kind !== "page") {
+        throw new Error(`Invalid docs sidebar node: ${JSON.stringify(node)}`);
+      }
+      const pageNode = node;
+      const slug = normalizeSlug(pageNode.slug);
+      const aliases = normalizeAliases(pageNode.aliases, slug);
+      if (pageNode.icon) {
+        assertDocsIconName(pageNode.icon, `Docs page "${pageNode.id}" icon`);
+      }
+      if (!slug) {
+        throw new Error(`Docs page "${pageNode.id}" must define a non-empty slug.`);
+      }
+      if (pageIds.has(pageNode.id)) {
+        throw new Error(`Duplicate docs page id "${pageNode.id}".`);
+      }
+      if (pageSlugs.has(slug)) {
+        throw new Error(`Duplicate docs page slug "${slug}".`);
+      }
+      for (const alias of aliases) {
+        if (pageSlugs.has(alias) || pageAliases.has(alias)) {
+          throw new Error(`Duplicate docs page alias "${alias}".`);
+        }
+      }
+      pageIds.add(pageNode.id);
+      pageSlugs.add(slug);
+      for (const alias of aliases) {
+        pageAliases.add(alias);
+      }
+      const href = joinDocsHref(normalizedBasePath, slug);
+      const page = {
+        ...pageNode,
+        slug,
+        aliases,
+        href,
+        aliasHrefs: aliases.map((alias) => joinDocsHref(normalizedBasePath, alias)),
+        tableOfContents: pageNode.tableOfContents ?? true,
+        sectionId,
+        documentTitle: `${pageNode.title} | ${config.siteTitle}`,
+        source: normalizeSourcePath(pageNode.source)
+      };
+      pages.push(page);
+      return {
+        kind: "page",
+        id: pageNode.id,
+        title: pageNode.title,
+        navTitle: pageNode.navTitle ?? pageNode.title,
+        href,
+        showInNav: pageNode.showInNav ?? true,
+        icon: pageNode.icon
+      };
+    });
+  };
+  const sections = config.graph.items.map((section) => {
+    if (section.kind !== "section") {
+      throw new Error(`Top-level docs graph items must be sections. Received ${JSON.stringify(section)}`);
+    }
+    if (sectionIds.has(section.id)) {
+      throw new Error(`Duplicate docs section id "${section.id}".`);
+    }
+    if (section.icon) {
+      assertDocsIconName(section.icon, `Docs section "${section.id}" icon`);
+    }
+    sectionIds.add(section.id);
+    const items = resolveSidebarNodes(section.items, section.id);
+    const firstVisibleHref = getSectionHref(items, true);
+    const href = section.href ? resolveNavigationHref(section.href, `section "${section.id}" href`, normalizedBasePath) : firstVisibleHref ?? getSectionHref(items);
+    if (!href) {
+      throw new Error(`Docs section "${section.id}" must contain at least one page.`);
+    }
+    const resolvedSection = {
+      id: section.id,
+      title: section.title,
+      navTitle: section.navTitle ?? section.title,
+      href,
+      items,
+      icon: section.icon
+    };
+    navbarItems.push({
+      id: section.id,
+      title: resolvedSection.navTitle,
+      href: resolvedSection.href
+    });
+    return resolvedSection;
+  });
+  if (pages.length === 0) {
+    throw new Error("Docs graph must contain at least one page.");
+  }
+  return {
+    siteTitle: config.siteTitle,
+    siteDescription: config.siteDescription ?? null,
+    robots: resolveRobotsConfig(config.robots),
+    basePath: normalizedBasePath,
+    contentDir: normalizedContentDir,
+    theme: resolveThemeConfig(config.theme),
+    footer: resolveFooterConfig(config.footer),
+    brand: resolveBrandConfig(config.brand, config.siteTitle),
+    head: resolveHeadConfig(config.head),
+    partners: resolvePartnersConfig(config.partners),
+    social: resolveSocialConfig(config.social),
+    algolia: resolveAlgoliaConfig(config.algolia),
+    pages,
+    sections,
+    navbarItems
+  };
+};
+var getResolvedPageById = (config, pageId) => {
+  const page = config.pages.find((candidate) => candidate.id === pageId);
+  if (!page) {
+    throw new Error(`Unknown docs page id "${pageId}".`);
+  }
+  return page;
+};
 
 // src/runtime/node/codegen.ts
 import fs from "fs";
+import { createRequire } from "module";
 import path from "path";
 var GENERATED_DIRNAME = "(nivel-generated)";
+var require2 = createRequire(import.meta.url);
+var lucidePackageRoot = path.dirname(require2.resolve("lucide-react/package.json"));
+var lucideEsmEntryPath = path.join(lucidePackageRoot, "dist", "esm", "lucide-react.js");
+var lucideEsmIconsDirectoryPath = path.join(lucidePackageRoot, "dist", "esm", "icons");
+var lucideIconModuleNameByExportName = null;
+var lucideIconNodeByName = /* @__PURE__ */ new Map();
 var writeFileIfChanged = (filePath, source) => {
   const current = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : null;
   if (current === source) {
@@ -110,6 +519,105 @@ var getGeneratedIconMapSource = (entries) => {
   }
   return ["{", ...entries.map(({ iconKey, iconName }) => `  ${JSON.stringify(iconKey)}: ${iconName},`), "}"].join("\n");
 };
+var getLucideIconModuleNameByExportName = () => {
+  if (lucideIconModuleNameByExportName) {
+    return lucideIconModuleNameByExportName;
+  }
+  const lucideEntrySource = fs.readFileSync(lucideEsmEntryPath, "utf8");
+  const exportMap = /* @__PURE__ */ new Map();
+  const exportPattern = /export\s+\{\s*([\s\S]*?)\s*\}\s+from\s+'\.\/icons\/([^']+)\.js';/g;
+  for (const match of lucideEntrySource.matchAll(exportPattern)) {
+    const exportsSource = match[1];
+    const moduleName = match[2];
+    if (!exportsSource || !moduleName) {
+      continue;
+    }
+    for (const exportPart of exportsSource.split(",").map((value) => value.trim())) {
+      const exportMatch = /^default as (\w+)$/.exec(exportPart);
+      if (!exportMatch?.[1]) {
+        continue;
+      }
+      exportMap.set(exportMatch[1], moduleName);
+    }
+  }
+  lucideIconModuleNameByExportName = exportMap;
+  return exportMap;
+};
+var getDocsIconNode = (iconName) => {
+  const cachedIconNode = lucideIconNodeByName.get(iconName);
+  if (cachedIconNode) {
+    return cachedIconNode;
+  }
+  const moduleName = getLucideIconModuleNameByExportName().get(iconName);
+  if (!moduleName) {
+    throw new Error(`Unable to resolve lucide-react module for docs icon "${iconName}".`);
+  }
+  const iconModuleSource = fs.readFileSync(path.join(lucideEsmIconsDirectoryPath, `${moduleName}.js`), "utf8");
+  const iconNodeMatch = /const __iconNode = (\[[\s\S]*?\]);\s*const /.exec(iconModuleSource);
+  if (!iconNodeMatch?.[1]) {
+    throw new Error(`Unable to read lucide-react icon node for docs icon "${iconName}".`);
+  }
+  const iconNode = Function(`"use strict"; return (${iconNodeMatch[1]})`)();
+  lucideIconNodeByName.set(iconName, iconNode);
+  return iconNode;
+};
+var getGeneratedIconDefinitionsSource = (iconNames) => {
+  if (iconNames.length === 0) {
+    return [];
+  }
+  const definitions = iconNames.flatMap((iconName) => {
+    return [`const ${iconName} = createDocsIcon(${JSON.stringify(getDocsIconNode(iconName))})`, ""];
+  });
+  return [
+    "import { createElement, forwardRef, type SVGProps } from 'react'",
+    "",
+    "type DocsGeneratedIconProps = SVGProps<SVGSVGElement> & {",
+    "  size?: string | number",
+    "  absoluteStrokeWidth?: boolean",
+    "}",
+    "",
+    "type DocsGeneratedIconNode = [tagName: string, attrs: Record<string, string>][]",
+    "",
+    "const docsGeneratedIconSvgAttrs = {",
+    "  xmlns: 'http://www.w3.org/2000/svg',",
+    "  fill: 'none',",
+    "  viewBox: '0 0 24 24',",
+    "  stroke: 'currentColor',",
+    "  strokeWidth: 2,",
+    "  strokeLinecap: 'round',",
+    "  strokeLinejoin: 'round',",
+    "} as const",
+    "",
+    "const createDocsIcon = (iconNode: DocsGeneratedIconNode) => {",
+    "  return forwardRef<SVGSVGElement, DocsGeneratedIconProps>(",
+    '    ({ color = "currentColor", size = 24, strokeWidth = 2, absoluteStrokeWidth, children, ...props }, ref) => {',
+    "      const resolvedSize = typeof size === 'number' ? size : Number(size)",
+    "      const resolvedStrokeWidth =",
+    "        absoluteStrokeWidth && Number.isFinite(resolvedSize) && resolvedSize > 0",
+    "          ? (Number(strokeWidth) * 24) / resolvedSize",
+    "          : strokeWidth",
+    "",
+    "      return createElement(",
+    "        'svg',",
+    "        {",
+    "          ...docsGeneratedIconSvgAttrs,",
+    "          ...props,",
+    "          ref,",
+    "          width: size,",
+    "          height: size,",
+    "          stroke: color,",
+    "          strokeWidth: resolvedStrokeWidth,",
+    "        },",
+    "        ...iconNode.map(([tagName, attrs]) => createElement(tagName, attrs)),",
+    "        children,",
+    "      )",
+    "    },",
+    "  )",
+    "}",
+    "",
+    ...definitions
+  ];
+};
 var getGeneratedGlobalContextSource = (data) => {
   const iconEntries = data.sidebarSections.flatMap((section) => {
     const sectionIconEntries = section.icon ? [{ iconKey: getDocsIconMapKey("section", section.id), iconName: section.icon }] : [];
@@ -118,7 +626,7 @@ var getGeneratedGlobalContextSource = (data) => {
   const iconImports = [...new Set(iconEntries.map(({ iconName }) => iconName))].sort();
   return [
     "import type { DocsGlobalContextData, DocsGlobalContextSerializableData, DocsIconMap } from '@unterberg/nivel'",
-    ...iconImports.length > 0 ? [`import { ${iconImports.join(", ")} } from '@unterberg/nivel/icons'`] : [],
+    ...getGeneratedIconDefinitionsSource(iconImports),
     "",
     `const docsGlobalContextSerializableData: DocsGlobalContextSerializableData = ${serializeData(data)}`,
     "",
@@ -194,6 +702,7 @@ var syncGeneratedDocsPages = (options) => {
   fs.mkdirSync(generatedPagesRoot, { recursive: true });
   const globalContextData = {
     siteTitle: resolved.siteTitle,
+    robots: resolved.robots,
     basePath: resolved.basePath,
     theme: resolved.theme,
     footer: resolved.footer,
@@ -314,6 +823,8 @@ var getDocsConfigTemplate = () => {
     "  siteDescription: 'Documentation site powered by @unterberg/nivel.',",
     "  // Add siteUrl to enable automatic sitemap.xml and robots.txt generation.",
     "  // siteUrl: 'https://docs.example.com',",
+    "  // Set robots to false to emit noindex/nofollow and a disallow-all robots.txt.",
+    "  // robots: false,",
     "  basePath: '/docs',",
     "} satisfies DocsConfig",
     "",
@@ -762,6 +1273,9 @@ var initConsumer = (options) => {
 };
 
 export {
+  resolveDocsHref,
+  resolveDocsConfig,
+  getResolvedPageById,
   getGeneratedPagesRoot,
   getDocsSourcePaths,
   isDocsSourcePath,
@@ -772,4 +1286,4 @@ export {
   getInitSummary,
   initConsumer
 };
-//# sourceMappingURL=chunk-G6PC37P5.js.map
+//# sourceMappingURL=chunk-IEWXVGSC.js.map