radiant-docs 0.1.62 → 0.1.64

package/template/src/lib/proxy-allowed-origins.mjs

@@ -0,0 +1,189 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+
+export function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+function isHttpUrl(value) {
+  return /^https?:\/\//i.test(String(value).trim());
+}
+
+function collectOpenApiSourcesFromNavigation(navigationNode, target) {
+  if (!isRecord(navigationNode)) {
+    return;
+  }
+
+  const openApiConfig = navigationNode.openapi;
+  if (typeof openApiConfig === "string") {
+    const trimmed = openApiConfig.trim();
+    if (trimmed) {
+      target.add(trimmed);
+    }
+  } else if (
+    isRecord(openApiConfig) &&
+    typeof openApiConfig.source === "string"
+  ) {
+    const trimmed = openApiConfig.source.trim();
+    if (trimmed) {
+      target.add(trimmed);
+    }
+  }
+
+  const menu = navigationNode.menu;
+  if (isRecord(menu) && Array.isArray(menu.items)) {
+    for (const menuItem of menu.items) {
+      if (!isRecord(menuItem)) {
+        continue;
+      }
+      collectOpenApiSourcesFromNavigation(menuItem, target);
+    }
+  }
+
+  const tabs = navigationNode.tabs;
+  if (isRecord(tabs) && Array.isArray(tabs.items)) {
+    for (const tabItem of tabs.items) {
+      if (!isRecord(tabItem)) {
+        continue;
+      }
+      collectOpenApiSourcesFromNavigation(tabItem, target);
+    }
+  }
+}
+
+function resolveServerTemplateUrl(rawUrl, rawVariables) {
+  let unresolved = false;
+  const variables = isRecord(rawVariables) ? rawVariables : null;
+
+  const resolved = rawUrl.replace(/\{([^}]+)\}/g, (_match, tokenName) => {
+    if (!variables) {
+      unresolved = true;
+      return "";
+    }
+
+    const variableConfig = variables[tokenName];
+    if (
+      !isRecord(variableConfig) ||
+      typeof variableConfig.default !== "string"
+    ) {
+      unresolved = true;
+      return "";
+    }
+
+    const defaultValue = variableConfig.default.trim();
+    if (!defaultValue) {
+      unresolved = true;
+      return "";
+    }
+
+    return defaultValue;
+  });
+
+  if (unresolved) {
+    return null;
+  }
+
+  return resolved;
+}
+
+export function normalizeAllowedOrigin(rawUrl) {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    return null;
+  }
+
+  if (parsed.protocol !== "https:") {
+    return null;
+  }
+
+  if (!parsed.hostname || parsed.username || parsed.password) {
+    return null;
+  }
+
+  return parsed.origin.toLowerCase();
+}
+
+async function loadOpenApiSpec(source, { docsDir, fetchImpl }) {
+  let fileContent;
+
+  if (isHttpUrl(source)) {
+    const response = await fetchImpl(source);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch OpenAPI spec (${response.status} ${response.statusText})`,
+      );
+    }
+    fileContent = await response.text();
+  } else {
+    const absolutePath = path.join(docsDir, source);
+    fileContent = await fs.readFile(absolutePath, "utf8");
+  }
+
+  const trimmed = fileContent.trim();
+  if (trimmed.startsWith("<!DOCTYPE") || trimmed.startsWith("<html")) {
+    throw new Error("OpenAPI source returned HTML instead of JSON or YAML");
+  }
+
+  try {
+    return JSON.parse(fileContent);
+  } catch {
+    return YAML.parse(fileContent);
+  }
+}
+
+export async function buildAllowedOrigins({
+  cwd = process.cwd(),
+  docsDir = path.join(cwd, "src/content/docs"),
+  docsConfigPath = path.join(docsDir, "docs.json"),
+  fetchImpl = fetch,
+  onSourceError = undefined,
+} = {}) {
+  const docsConfigRaw = await fs.readFile(docsConfigPath, "utf8");
+  const docsConfig = JSON.parse(docsConfigRaw);
+
+  if (!isRecord(docsConfig) || !isRecord(docsConfig.navigation)) {
+    return [];
+  }
+
+  const sources = new Set();
+  collectOpenApiSourcesFromNavigation(docsConfig.navigation, sources);
+  if (sources.size === 0) {
+    return [];
+  }
+
+  const allowedOrigins = new Set();
+
+  for (const source of sources) {
+    try {
+      const spec = await loadOpenApiSpec(source, { docsDir, fetchImpl });
+      const servers =
+        isRecord(spec) && Array.isArray(spec.servers) ? spec.servers : [];
+
+      for (const server of servers) {
+        if (!isRecord(server) || typeof server.url !== "string") {
+          continue;
+        }
+
+        const resolvedUrl = resolveServerTemplateUrl(
+          server.url,
+          server.variables,
+        );
+        if (!resolvedUrl) {
+          continue;
+        }
+
+        const normalizedOrigin = normalizeAllowedOrigin(resolvedUrl);
+        if (normalizedOrigin) {
+          allowedOrigins.add(normalizedOrigin);
+        }
+      }
+    } catch (error) {
+      onSourceError?.(source, error);
+    }
+  }
+
+  return Array.from(allowedOrigins).sort();
+}

package/template/src/styles/global.css

@@ -75,14 +75,14 @@
   --rd-panel-transition-easing: cubic-bezier(0.22, 1, 0.36, 1);
   --rd-code-surface: color-mix(
     in srgb,
-    var(--color-neutral-100) 60%,
-    var(--background) 40%
+    var(--color-neutral-100) 70%,
+    var(--background) 30%
   );
   --rd-code-tab-edge-bg: var(--rd-code-surface);
   --rd-code-tab-edge-border: color-mix(
     in oklab,
-    var(--color-neutral-900) 4%,
-    var(--color-white) 96%
+    var(--color-neutral-900) 6%,
+    var(--color-white) 94%
   );
 }
 

package/template/src/components/ui/demo/CodeDemo.astro

@@ -1,15 +0,0 @@
-<span class="demo-component">
-  <slot />
-</span>
-
-<style>
-  @reference "../../../styles/global.css";
-
-  :global(.demo-component .frame) {
-    @apply shadow-none! my-0!;
-  }
-
-  :global(.demo-component .frame pre) {
-    @apply border-none! rounded-none rounded-b-xl bg-neutral-50! inset-shadow-xs;
-  }
-</style>

package/template/src/components/ui/demo/Demo.astro

@@ -1,3 +0,0 @@
-<div class="border rounded-xl shadow-xs my-5!">
-  <slot />
-</div>

package/template/src/components/ui/demo/UiDisplay.astro

@@ -1,13 +0,0 @@
----
-interface Props {
-  centerUi?: boolean;
-}
-
-const { centerUi } = Astro.props;
----
-
-<div
-  class:list={["px-8 flex justify-center", centerUi && "items-center min-h-96"]}
->
-  <slot />
-</div>