blodemd 0.1.0 → 0.2.0

package/docs/lib/server-cache.ts

@@ -1,83 +0,0 @@
-interface CacheEntry<Value> {
-  expiresAt: number;
-  value: Promise<Value>;
-}
-
-interface TimedPromiseCacheOptions {
-  maxEntries: number;
-  ttlMs: number;
-}
-
-export interface TimedPromiseCache<Key, Value> {
-  clear(): void;
-  delete(key: Key): void;
-  deleteByPrefix(prefix: string): void;
-  getOrCreate(key: Key, factory: () => Promise<Value>): Promise<Value>;
-}
-
-export const createTimedPromiseCache = <Key, Value>({
-  maxEntries,
-  ttlMs,
-}: TimedPromiseCacheOptions): TimedPromiseCache<Key, Value> => {
-  const entries = new Map<Key, CacheEntry<Value>>();
-
-  const deleteOldest = () => {
-    const oldestKey = entries.keys().next().value as Key | undefined;
-    if (oldestKey !== undefined) {
-      entries.delete(oldestKey);
-    }
-  };
-
-  const pruneExpired = (now: number) => {
-    for (const [key, entry] of entries) {
-      if (entry.expiresAt <= now) {
-        entries.delete(key);
-      }
-    }
-  };
-
-  return {
-    clear() {
-      entries.clear();
-    },
-    delete(key) {
-      entries.delete(key);
-    },
-    deleteByPrefix(prefix: string) {
-      for (const key of entries.keys()) {
-        if (typeof key === "string" && key.startsWith(prefix)) {
-          entries.delete(key);
-        }
-      }
-    },
-    getOrCreate(key, factory) {
-      const now = Date.now();
-      pruneExpired(now);
-
-      const existing = entries.get(key);
-      if (existing) {
-        return existing.value;
-      }
-
-      const value = (async () => {
-        try {
-          return await factory();
-        } catch (error) {
-          entries.delete(key);
-          throw error;
-        }
-      })();
-
-      entries.set(key, {
-        expiresAt: now + ttlMs,
-        value,
-      });
-
-      if (entries.size > maxEntries) {
-        deleteOldest();
-      }
-
-      return value;
-    },
-  };
-};

package/docs/lib/shiki.ts

@@ -1,44 +0,0 @@
-import { createHighlighter } from "shiki";
-
-const COMMON_LANGS = [
-  "bash",
-  "css",
-  "diff",
-  "go",
-  "graphql",
-  "html",
-  "javascript",
-  "json",
-  "jsx",
-  "markdown",
-  "mdx",
-  "nginx",
-  "python",
-  "rust",
-  "sh",
-  "shell",
-  "sql",
-  "text",
-  "tsx",
-  "typescript",
-  "yaml",
-] as const;
-
-export const SHIKI_THEME_PAIR = {
-  dark: "github-dark",
-  light: "github-light",
-} as const;
-
-const THEMES = [SHIKI_THEME_PAIR.dark, SHIKI_THEME_PAIR.light] as const;
-
-let highlighterPromise: ReturnType<typeof createHighlighter> | null = null;
-
-export const getHighlighter = () => {
-  if (!highlighterPromise) {
-    highlighterPromise = createHighlighter({
-      langs: [...COMMON_LANGS],
-      themes: [...THEMES],
-    });
-  }
-  return highlighterPromise;
-};

package/docs/lib/supabase.ts

@@ -1,37 +0,0 @@
-import { createBrowserClient, createServerClient } from "@supabase/ssr";
-import type { CookieOptions } from "@supabase/ssr";
-import type { SupabaseClient } from "@supabase/supabase-js";
-
-const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL ?? "";
-const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY ?? "";
-
-let browserClient: SupabaseClient | null = null;
-
-export const createSupabaseClient = (): SupabaseClient => {
-  if (!browserClient) {
-    browserClient = createBrowserClient(supabaseUrl, supabaseAnonKey);
-  }
-  return browserClient;
-};
-
-interface CookieStore {
-  get: (name: string) => { value: string } | undefined;
-  set?: (name: string, value: string, options?: CookieOptions) => void;
-}
-
-export const createSupabaseServerClient = (
-  cookieStore: CookieStore
-): SupabaseClient =>
-  createServerClient(supabaseUrl, supabaseAnonKey, {
-    cookies: {
-      get(name: string) {
-        return cookieStore.get(name)?.value;
-      },
-      remove(name: string, options?: CookieOptions) {
-        cookieStore.set?.(name, "", { ...options, maxAge: 0 });
-      },
-      set(name: string, value: string, options?: CookieOptions) {
-        cookieStore.set?.(name, value, options);
-      },
-    },
-  });

package/docs/lib/tenancy.ts

@@ -1,364 +0,0 @@
-import { getLocalRootHostsFromEnv, normalizeHost } from "@repo/common";
-import type { Tenant } from "@repo/contracts";
-import { TenantResolutionSchema } from "@repo/contracts";
-
-import {
-  getTenantEdgeHostRecord,
-  getTenantEdgeSlugRecord,
-  isEdgeConfigEnabled,
-} from "./edge-config";
-import { docsApiBase } from "./env";
-import { platformConfig } from "./platform-config";
-import { createTimedPromiseCache } from "./server-cache";
-
-const DEFAULT_RESERVED_PATHS = [
-  "/_internal",
-  "/_next",
-  "/.well-known",
-  "/api",
-  "/app",
-  "/docs.json",
-  "/favicon.ico",
-  "/llms.txt",
-  "/logos",
-  "/mcp",
-  "/oauth",
-  "/robots.txt",
-  "/sitemap.xml",
-];
-
-const STATIC_ASSET_EXTENSIONS = new Set([
-  ".avif",
-  ".css",
-  ".eot",
-  ".gif",
-  ".ico",
-  ".jpeg",
-  ".jpg",
-  ".js",
-  ".json",
-  ".map",
-  ".png",
-  ".svg",
-  ".ttf",
-  ".webp",
-  ".woff",
-  ".woff2",
-]);
-
-const isRootStaticAsset = (pathname: string): boolean => {
-  const segments = pathname.split("/").filter(Boolean);
-  if (segments.length !== 1) {
-    return false;
-  }
-  const lastDot = pathname.lastIndexOf(".");
-  if (lastDot === -1) {
-    return false;
-  }
-  return STATIC_ASSET_EXTENSIONS.has(pathname.slice(lastDot).toLowerCase());
-};
-
-const LOCAL_ROOT_HOSTS = new Set(["localhost", "127.0.0.1"]);
-const TRAILING_SLASHES_REGEX = /\/+$/;
-const LEADING_SLASHES_REGEX = /^\/+/;
-const BACKSLASH_TO_SLASH_REGEX = /\\/g;
-const DEFAULT_DOCS_BASE_PATH = "/docs";
-const TENANT_RESOLUTION_REVALIDATE_SECONDS = 300;
-const ROOT_TENANT_UTILITY_PATHS = new Set([
-  "/.well-known/llms-full.txt",
-  "/.well-known/llms.txt",
-  "/llms-full.txt",
-  "/llms.txt",
-  "/robots.txt",
-  "/sitemap.xml",
-]);
-const WELL_KNOWN_SKILLS_SEGMENT = "/.well-known/skills/";
-const LLMS_SEGMENT_SEGMENT = "/llms/";
-
-export const isTenantUtilityPath = (pathname: string) =>
-  ROOT_TENANT_UTILITY_PATHS.has(pathname) ||
-  pathname.startsWith(WELL_KNOWN_SKILLS_SEGMENT) ||
-  (pathname.startsWith(LLMS_SEGMENT_SEGMENT) && pathname.endsWith(".txt"));
-
-const isPathMatch = (pathname: string, prefix: string) =>
-  pathname === prefix || pathname.startsWith(`${prefix}/`);
-
-const slugifyPath = (value: string) => {
-  const trimmed = value
-    .replace(BACKSLASH_TO_SLASH_REGEX, "/")
-    .replace(TRAILING_SLASHES_REGEX, "");
-  return trimmed.replace(LEADING_SLASHES_REGEX, "");
-};
-
-const stripPrefix = (pathname: string, prefix: string | null) => {
-  if (!prefix) {
-    return slugifyPath(pathname);
-  }
-
-  const normalizedPath = slugifyPath(pathname);
-  const normalizedPrefix = slugifyPath(prefix);
-  if (!normalizedPrefix) {
-    return normalizedPath;
-  }
-
-  if (normalizedPath === normalizedPrefix) {
-    return "";
-  }
-
-  if (normalizedPath.startsWith(`${normalizedPrefix}/`)) {
-    return normalizedPath.slice(normalizedPrefix.length + 1);
-  }
-
-  return null;
-};
-
-const tenantResolutionCache = createTimedPromiseCache<
-  string,
-  Awaited<ReturnType<typeof fetchTenantResolution>>
->({
-  maxEntries: 512,
-  ttlMs: TENANT_RESOLUTION_REVALIDATE_SECONDS * 1000,
-});
-
-export const getRequestHost = (headerSource: Pick<Headers, "get">) => {
-  const forwardedHost = headerSource.get("x-forwarded-host");
-  return normalizeHost(
-    forwardedHost?.split(",")[0]?.trim() || headerSource.get("host") || ""
-  );
-};
-
-export const getRequestProtocol = (headerSource: Pick<Headers, "get">) =>
-  headerSource.get("x-forwarded-proto")?.split(",")[0]?.trim() || "https";
-
-export const isRootRuntimeHost = (host: string) => {
-  const normalizedHost = normalizeHost(host);
-  return (
-    normalizedHost === platformConfig.rootDomain ||
-    LOCAL_ROOT_HOSTS.has(normalizedHost) ||
-    getLocalRootHostsFromEnv(process.env).has(normalizedHost)
-  );
-};
-
-export const isReservedPath = (pathname: string) => {
-  const { assetPrefix } = platformConfig;
-  if (assetPrefix && pathname.startsWith(assetPrefix)) {
-    return true;
-  }
-  if (isRootStaticAsset(pathname)) {
-    return true;
-  }
-  return DEFAULT_RESERVED_PATHS.some((prefix) => isPathMatch(pathname, prefix));
-};
-
-const resolveSubdomainBasePath = (pathname: string): string => {
-  const normalizedPath = slugifyPath(pathname);
-
-  if (
-    normalizedPath === "docs" ||
-    normalizedPath.startsWith(`${slugifyPath(DEFAULT_DOCS_BASE_PATH)}/`)
-  ) {
-    return DEFAULT_DOCS_BASE_PATH;
-  }
-
-  return "";
-};
-
-const buildTenantPathResolution = (
-  tenant: Tenant,
-  strategy: "preview" | "subdomain" | "custom-domain",
-  host: string,
-  pathname: string,
-  basePath: string
-) => {
-  if (isTenantUtilityPath(pathname)) {
-    return {
-      basePath,
-      host,
-      rewrittenPath: `/sites/${tenant.slug}${pathname}`,
-      strategy,
-      tenant,
-    };
-  }
-
-  const slugPath = stripPrefix(pathname, basePath || null);
-  if (slugPath === null) {
-    return null;
-  }
-
-  const rewrittenPath = slugPath
-    ? `/sites/${tenant.slug}/${slugPath}`
-    : `/sites/${tenant.slug}/`;
-
-  return {
-    basePath,
-    host,
-    rewrittenPath,
-    strategy,
-    tenant,
-  };
-};
-
-const buildPathTenantResolution = (
-  tenant: Tenant,
-  host: string,
-  pathname: string
-) => {
-  const normalized = slugifyPath(pathname);
-  const parts = normalized ? normalized.split("/") : [];
-  const [projectSlug, ...rest] = parts;
-  if (!projectSlug || projectSlug !== tenant.slug) {
-    return null;
-  }
-
-  const remainder = rest.join("/");
-  return {
-    basePath: `/${tenant.slug}`,
-    host,
-    rewrittenPath: remainder
-      ? `/sites/${tenant.slug}/${remainder}`
-      : `/sites/${tenant.slug}/`,
-    strategy: "path" as const,
-    tenant,
-  };
-};
-
-const fetchTenantResolutionFromApi = async (host: string, pathname: string) => {
-  const url = new URL("/tenants/resolve", docsApiBase);
-  url.searchParams.set("host", normalizeHost(host));
-  url.searchParams.set("path", pathname);
-  let response: Response;
-  try {
-    response = await fetch(url.toString(), {
-      next: { revalidate: TENANT_RESOLUTION_REVALIDATE_SECONDS },
-    });
-  } catch {
-    return null;
-  }
-  if (!response.ok) {
-    return null;
-  }
-  const json = (await response.json()) as unknown;
-  const parsed = TenantResolutionSchema.safeParse(json);
-  if (!parsed.success) {
-    return null;
-  }
-  return parsed.data;
-};
-
-export const resolveTenantFromEdgeConfig = async (
-  host: string,
-  pathname: string
-) => {
-  const normalizedHost = normalizeHost(host);
-  const hostRecord = await getTenantEdgeHostRecord(normalizedHost);
-  if (hostRecord) {
-    const basePath =
-      hostRecord.strategy === "subdomain"
-        ? resolveSubdomainBasePath(pathname)
-        : (hostRecord.pathPrefix ?? "");
-
-    return buildTenantPathResolution(
-      hostRecord.tenant,
-      hostRecord.strategy,
-      normalizedHost,
-      pathname,
-      basePath
-    );
-  }
-
-  const previewPrefix = normalizedHost.includes("---")
-    ? normalizedHost.split("---")[0]
-    : null;
-  if (previewPrefix) {
-    const previewRecord = await getTenantEdgeSlugRecord(previewPrefix);
-    if (previewRecord) {
-      return buildTenantPathResolution(
-        previewRecord.tenant,
-        "preview",
-        normalizedHost,
-        pathname,
-        resolveSubdomainBasePath(pathname)
-      );
-    }
-  }
-
-  const localSuffixes = ["localhost", "127.0.0.1"];
-  const localRootHosts = getLocalRootHostsFromEnv(process.env);
-  const localSuffix = localRootHosts.has(normalizedHost)
-    ? null
-    : localSuffixes.find((suffix) => normalizedHost.endsWith(`.${suffix}`));
-  if (localSuffix) {
-    const subdomain = normalizedHost.slice(0, -1 * (localSuffix.length + 1));
-    if (subdomain) {
-      const subdomainRecord = await getTenantEdgeSlugRecord(subdomain);
-      if (subdomainRecord) {
-        return buildTenantPathResolution(
-          subdomainRecord.tenant,
-          "subdomain",
-          normalizedHost,
-          pathname,
-          resolveSubdomainBasePath(pathname)
-        );
-      }
-    }
-  }
-
-  if (normalizedHost.endsWith(`.${platformConfig.rootDomain}`)) {
-    const subdomain = normalizedHost.slice(
-      0,
-      -1 * (platformConfig.rootDomain.length + 1)
-    );
-    if (
-      subdomain &&
-      !["www", "app", "admin", "dashboard"].includes(subdomain)
-    ) {
-      const subdomainRecord = await getTenantEdgeSlugRecord(subdomain);
-      if (subdomainRecord) {
-        return buildTenantPathResolution(
-          subdomainRecord.tenant,
-          "subdomain",
-          normalizedHost,
-          pathname,
-          resolveSubdomainBasePath(pathname)
-        );
-      }
-    }
-  }
-
-  if (isRootRuntimeHost(normalizedHost)) {
-    const normalizedPath = slugifyPath(pathname);
-    const [projectSlug] = normalizedPath.split("/");
-    if (projectSlug) {
-      const pathRecord = await getTenantEdgeSlugRecord(projectSlug);
-      if (pathRecord) {
-        return buildPathTenantResolution(
-          pathRecord.tenant,
-          normalizedHost,
-          pathname
-        );
-      }
-    }
-  }
-
-  return null;
-};
-
-const fetchTenantResolution = async (host: string, pathname: string) => {
-  if (isEdgeConfigEnabled()) {
-    return await resolveTenantFromEdgeConfig(host, pathname);
-  }
-
-  return await fetchTenantResolutionFromApi(host, pathname);
-};
-
-export const clearTenantResolutionCache = () => {
-  tenantResolutionCache.clear();
-};
-
-export const resolveTenant = async (host: string, pathname: string) => {
-  const cacheKey = `${normalizeHost(host)}:${pathname}`;
-  return await tenantResolutionCache.getOrCreate(
-    cacheKey,
-    async () => await fetchTenantResolution(host, pathname)
-  );
-};

package/docs/lib/tenant-headers.ts

@@ -1,43 +0,0 @@
-import type { ProjectAnalytics } from "@repo/contracts";
-
-export const TENANT_HEADERS = {
-  ANALYTICS: "x-tenant-analytics",
-  BASE_PATH: "x-tenant-base-path",
-  CUSTOM_DOMAINS: "x-tenant-custom-domains",
-  DEPLOYMENT_ID: "x-tenant-deployment-id",
-  DOMAIN: "x-tenant-domain",
-  ID: "x-tenant-id",
-  MANIFEST_URL: "x-tenant-manifest-url",
-  NAME: "x-tenant-name",
-  PATH_PREFIX: "x-tenant-path-prefix",
-  PRIMARY_DOMAIN: "x-tenant-primary-domain",
-  SLUG: "x-tenant-slug",
-  STRATEGY: "x-tenant-strategy",
-  SUBDOMAIN: "x-tenant-subdomain",
-} as const;
-
-const hasAnyProvider = (value: ProjectAnalytics): boolean =>
-  Boolean(value.ga4?.measurementId || value.posthog?.projectKey);
-
-export const encodeTenantAnalyticsHeader = (
-  analytics: ProjectAnalytics | undefined
-): string | null => {
-  if (!analytics || !hasAnyProvider(analytics)) {
-    return null;
-  }
-  return encodeURIComponent(JSON.stringify(analytics));
-};
-
-export const decodeTenantAnalyticsHeader = (
-  encoded: string | null | undefined
-): ProjectAnalytics | null => {
-  if (!encoded) {
-    return null;
-  }
-  try {
-    const parsed = JSON.parse(decodeURIComponent(encoded)) as ProjectAnalytics;
-    return hasAnyProvider(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-};