blodemd 0.0.4 → 0.0.6

package/packages/@repo/previewing/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@repo/previewing",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./src/*.ts",
+      "import": "./dist/*.js",
+      "default": "./dist/*.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "check-types": "tsc --noEmit",
+    "lint": "oxlint .",
+    "lint:fix": "oxlint --fix .",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt ."
+  },
+  "dependencies": {
+    "@repo/common": "*",
+    "@repo/models": "*",
+    "@repo/prebuild": "*",
+    "@repo/validation": "*",
+    "yaml": "^2.8.3"
+  },
+  "devDependencies": {
+    "@repo/typescript-config": "*",
+    "@types/node": "^22.19.15",
+    "oxfmt": "^0.42.0",
+    "oxlint": "^1.57.0",
+    "typescript": "6.0.2",
+    "ultracite": "^7.3.2"
+  }
+}

package/packages/@repo/previewing/src/blob-source.ts

@@ -0,0 +1,167 @@
+import path from "node:path";
+
+import { normalizePath } from "@repo/common";
+
+import type { CompiledMdxResult, ContentSource } from "./content-source.js";
+
+interface BlobManifestFile {
+  path: string;
+  url: string;
+}
+
+interface BlobManifest {
+  files: BlobManifestFile[];
+}
+
+type FetchInitWithNext = RequestInit & {
+  next?: {
+    revalidate?: number;
+    tags?: string[];
+  };
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null;
+
+const isBlobManifest = (value: unknown): value is BlobManifest => {
+  if (!isRecord(value) || !Array.isArray(value.files)) {
+    return false;
+  }
+
+  return value.files.every((file) => {
+    if (!isRecord(file)) {
+      return false;
+    }
+
+    return typeof file.path === "string" && typeof file.url === "string";
+  });
+};
+
+const normalizeDirectory = (directory: string) => {
+  const normalized = normalizePath(path.posix.normalize(directory));
+  if (!normalized || normalized === ".") {
+    return "";
+  }
+  return normalized ? `${normalized}/` : "";
+};
+
+const normalizeRelativePath = (value: string) =>
+  normalizePath(path.posix.normalize(value));
+
+export class BlobContentSource implements ContentSource {
+  private readonly manifestUrl: string;
+  private readonly cacheTag?: string;
+  private manifestPromise?: Promise<Map<string, string>>;
+
+  constructor(manifestUrl: string, cacheTag?: string) {
+    this.manifestUrl = manifestUrl;
+    this.cacheTag = cacheTag;
+  }
+
+  private getFetchOptions(): FetchInitWithNext {
+    if (!this.cacheTag) {
+      return { cache: "no-store" };
+    }
+
+    return {
+      next: {
+        revalidate: 3600,
+        tags: [this.cacheTag],
+      },
+    };
+  }
+
+  private async loadManifest(): Promise<Map<string, string>> {
+    if (!this.manifestPromise) {
+      this.manifestPromise = (async () => {
+        const response = await fetch(this.manifestUrl, this.getFetchOptions());
+        if (!response.ok) {
+          throw new Error(
+            `Failed to load deployment manifest: ${response.status}`
+          );
+        }
+
+        const manifest = (await response.json()) as unknown;
+        if (!isBlobManifest(manifest)) {
+          throw new Error("Deployment manifest is invalid.");
+        }
+
+        return new Map(
+          manifest.files.map((file) => [
+            normalizeRelativePath(file.path),
+            file.url,
+          ])
+        );
+      })();
+    }
+
+    return await this.manifestPromise;
+  }
+
+  async readFile(relativePath: string): Promise<string> {
+    const url = await this.resolveUrl(relativePath);
+    if (!url) {
+      throw new Error(`Content file "${relativePath}" not found.`);
+    }
+
+    const response = await fetch(url, this.getFetchOptions());
+    if (!response.ok) {
+      throw new Error(`Failed to load content file: ${response.status}`);
+    }
+
+    return await response.text();
+  }
+
+  async listFiles(directory: string): Promise<string[]> {
+    const manifest = await this.loadManifest();
+    const prefix = normalizeDirectory(directory);
+
+    const files = [...manifest.keys()].filter((file) =>
+      prefix ? file.startsWith(prefix) : true
+    );
+    // oxlint-disable-next-line eslint-plugin-unicorn/no-array-sort
+    files.sort();
+    return files;
+  }
+
+  async exists(relativePath: string): Promise<boolean> {
+    const manifest = await this.loadManifest();
+    return manifest.has(normalizeRelativePath(relativePath));
+  }
+
+  async resolveUrl(relativePath: string): Promise<string | null> {
+    const manifest = await this.loadManifest();
+    return manifest.get(normalizeRelativePath(relativePath)) ?? null;
+  }
+
+  async readCompiledMdx(
+    relativePath: string
+  ): Promise<CompiledMdxResult | null> {
+    const compiledPath = `_compiled/${normalizeRelativePath(relativePath)}.json`;
+    const url = await this.resolveUrl(compiledPath);
+    if (!url) {
+      return null;
+    }
+
+    try {
+      const response = await fetch(url, this.getFetchOptions());
+      if (!response.ok) {
+        return null;
+      }
+
+      const data = (await response.json()) as CompiledMdxResult;
+      if (!data.compiledSource || data.version !== 1) {
+        return null;
+      }
+
+      return data;
+    } catch {
+      return null;
+    }
+  }
+}
+
+export const createBlobSource = (
+  manifestUrl: string,
+  cacheTag?: string
+): ContentSource => new BlobContentSource(manifestUrl, cacheTag);

package/packages/@repo/previewing/src/content-source.ts

@@ -0,0 +1,12 @@
+export interface CompiledMdxResult {
+  compiledSource: string;
+  version: number;
+}
+
+export interface ContentSource {
+  readFile(relativePath: string): Promise<string>;
+  listFiles(directory: string): Promise<string[]>;
+  exists(relativePath: string): Promise<boolean>;
+  resolveUrl?(relativePath: string): Promise<string | null> | string | null;
+  readCompiledMdx?(relativePath: string): Promise<CompiledMdxResult | null>;
+}

package/packages/@repo/previewing/src/fs-source.ts

@@ -0,0 +1,111 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { normalizePath } from "@repo/common";
+
+import type { ContentSource } from "./content-source.js";
+
+const IGNORED_DIRECTORIES = new Set([
+  "app",
+  "components",
+  "content",
+  "lib",
+  "node_modules",
+  "public",
+]);
+const IGNORED_ROOT_FILES = new Set(["AGENTS.md", "README.md"]);
+
+const isNotFoundError = (error: unknown) =>
+  Boolean(
+    error &&
+    typeof error === "object" &&
+    "code" in error &&
+    (error as { code?: string }).code === "ENOENT"
+  );
+
+const isWithinRoot = (root: string, candidate: string) =>
+  candidate === root || candidate.startsWith(`${root}${path.sep}`);
+
+const resolveWithinRoot = (root: string, relativePath: string) => {
+  const normalized = normalizePath(relativePath);
+  const absolutePath = path.resolve(root, normalized);
+
+  if (!isWithinRoot(root, absolutePath)) {
+    throw new Error(`Path "${relativePath}" escapes the content source root.`);
+  }
+
+  return absolutePath;
+};
+
+const walkFiles = async (
+  directory: string,
+  prefix: string
+): Promise<string[]> => {
+  const entries = await fs.readdir(directory, { withFileTypes: true });
+  const files: string[] = [];
+
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) {
+      continue;
+    }
+
+    const absolutePath = path.join(directory, entry.name);
+    const relativePath = prefix ? path.join(prefix, entry.name) : entry.name;
+
+    if (entry.isDirectory()) {
+      if (IGNORED_DIRECTORIES.has(entry.name)) {
+        continue;
+      }
+      files.push(...(await walkFiles(absolutePath, relativePath)));
+      continue;
+    }
+
+    if (entry.isFile()) {
+      if (!prefix && IGNORED_ROOT_FILES.has(entry.name)) {
+        continue;
+      }
+      files.push(normalizePath(relativePath));
+    }
+  }
+
+  return files;
+};
+
+export class FsContentSource implements ContentSource {
+  private readonly root: string;
+
+  constructor(root: string) {
+    this.root = path.resolve(root);
+  }
+
+  async readFile(relativePath: string): Promise<string> {
+    return await fs.readFile(
+      resolveWithinRoot(this.root, relativePath),
+      "utf8"
+    );
+  }
+
+  async listFiles(directory: string): Promise<string[]> {
+    return await walkFiles(resolveWithinRoot(this.root, directory), "");
+  }
+
+  async exists(relativePath: string): Promise<boolean> {
+    try {
+      await fs.access(resolveWithinRoot(this.root, relativePath));
+      return true;
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return false;
+      }
+      throw error;
+    }
+  }
+
+  // oxlint-disable-next-line eslint/class-methods-use-this
+  resolveUrl(): string | null {
+    return null;
+  }
+}
+
+export const createFsSource = (root: string): ContentSource =>
+  new FsContentSource(root);