@baybreezy/docd 0.0.1 → 0.0.3

package/app/assets/css/tailwind.css

@@ -1,5 +1,6 @@
-@import "tailwindcss" source("../../../../../");
+@import "tailwindcss";
 @import "tw-animate-css";
+@source "../../../../";
 
 @config "../../../tailwind.config.cjs";
 

package/modules/css.ts

@@ -0,0 +1,44 @@
+import { addVitePlugin, createResolver, defineNuxtModule } from "@nuxt/kit";
+import { joinURL } from "ufo";
+
+export default defineNuxtModule({
+  meta: {
+    name: "docd:css",
+  },
+  setup(_options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+
+    // Absolute path to the layer's tailwind entry — this is the file that owns
+    // `@import "tailwindcss"` and therefore controls Tailwind's scanner.
+    const tailwindCssPath = resolver.resolve("../app/assets/css/tailwind.css");
+
+    // The consuming app's content directory.  We convert to forward-slashes so
+    // the injected @source glob works on Windows too.
+    const contentDir = joinURL(nuxt.options.rootDir, "content").replace(/\\/g, "/");
+
+    // Inject `@source <contentDir>/**/*` into tailwind.css
+    addVitePlugin({
+      name: "docd:inject-tailwind-sources",
+      enforce: "pre",
+      transform(code: string, id: string) {
+        if (id.split("?")[0] !== tailwindCssPath) return null;
+        return {
+          code: `${code}\n@source ${JSON.stringify(`${contentDir}/**/*`)};`,
+          map: null,
+        };
+      },
+    });
+
+    // Suppress noisy Vite warnings produced during Tailwind's build pass.
+    nuxt.hook("vite:extendConfig", (config) => {
+      const logger = config.customLogger;
+      if (!logger) return;
+      const ignore = ["@tailwindcss/vite:generate:build", "nuxt:module-preload-polyfill"];
+      const originalWarn = logger.warn.bind(logger);
+      logger.warn = (msg, options) => {
+        if (ignore.some((p) => msg.includes(p))) return;
+        originalWarn(msg, options);
+      };
+    });
+  },
+});

package/nuxt.config.ts

@@ -50,6 +50,7 @@ export default defineNuxtConfig({
     "@morev/vue-transitions/nuxt",
     "vue-sonner/nuxt",
     resolver.resolve("./modules/routing"),
+    resolver.resolve("./modules/css"),
     resolver.resolve("./modules/config"),
     resolver.resolve("./modules/custom-icons"),
     resolver.resolve("./modules/prose-component-meta"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baybreezy/docd",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "A Nuxt layer for building documentation sites with UI Thing.",
   "repository": {
     "type": "git",

package/utils/component-meta-worker.mjs

@@ -0,0 +1,22 @@
+import { workerData, parentPort } from "node:worker_threads";
+
+import { getComponentMeta } from "nuxt-component-meta/parser";
+
+const { batch, rootDir, cacheDir } = workerData;
+
+const results = [];
+
+for (const { manifestPath, absolutePath } of batch) {
+  try {
+    const raw = getComponentMeta(absolutePath, {
+      rootDir,
+      cache: true,
+      cacheDir,
+    });
+    results.push({ manifestPath, raw, ok: true });
+  } catch (err) {
+    results.push({ manifestPath, raw: null, ok: false, error: String(err) });
+  }
+}
+
+parentPort.postMessage(results);

package/utils/generate-prose-component-meta.ts

@@ -1,8 +1,9 @@
 import { existsSync, readFileSync } from "node:fs";
 import { mkdir, readdir, stat, writeFile } from "node:fs/promises";
+import { cpus } from "node:os";
 import { dirname, join, relative, resolve } from "node:path";
-
-import { getComponentMeta } from "nuxt-component-meta/parser";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
 
 import {
   componentNameFromPath,
@@ -170,6 +171,67 @@ function normalizeExposed(exposed: RawExposedMeta): ProseComponentMetaExposed {
   };
 }
 
+interface WorkerResult {
+  manifestPath: string;
+  raw: Record<string, unknown[]> | null;
+  ok: boolean;
+  error?: string;
+}
+
+const WORKER_PATH = fileURLToPath(new URL("./component-meta-worker.mjs", import.meta.url));
+
+async function runInWorkers(
+  components: ProseComponentMetaSource[],
+  opts: { rootDir: string; cache: boolean; cacheDir: string }
+): Promise<WorkerResult[]> {
+  const numWorkers = Math.min(cpus().length, components.length, 8);
+  const chunkSize = Math.ceil(components.length / numWorkers);
+
+  const chunks: ProseComponentMetaSource[][] = [];
+  for (let i = 0; i < components.length; i += chunkSize) {
+    chunks.push(components.slice(i, i + chunkSize));
+  }
+
+  const spawnWorker = (batch: ProseComponentMetaSource[]) =>
+    new Promise<WorkerResult[]>((resolve, reject) => {
+      const worker = new Worker(WORKER_PATH, {
+        workerData: {
+          batch: batch.map((c) => ({
+            manifestPath: c.manifestPath,
+            absolutePath: c.absolutePath,
+          })),
+          rootDir: opts.rootDir,
+          cacheDir: opts.cacheDir,
+        },
+      });
+      worker.on("message", resolve);
+      worker.on("error", reject);
+      worker.on("exit", (code) => {
+        if (code !== 0) reject(new Error(`Component meta worker exited with code ${code}`));
+      });
+    });
+
+  try {
+    const results = await Promise.all(chunks.map(spawnWorker));
+    return results.flat();
+  } catch {
+    // Fall back to sequential processing if workers fail.
+    const { getComponentMeta } = await import("nuxt-component-meta/parser");
+    return components.map(({ manifestPath, absolutePath }) => {
+      try {
+        const raw = getComponentMeta(absolutePath, {
+          rootDir: opts.rootDir,
+          cache: opts.cache,
+          cacheDir: opts.cacheDir,
+        }) as Record<string, unknown[]>;
+        return { manifestPath, raw, ok: true };
+      } catch (err) {
+        return { manifestPath, raw: null, ok: false, error: String(err) };
+      }
+    });
+  }
+}
+
 async function listVueFiles(dir: string): Promise<string[]> {
   const files: string[] = [];
   const entries = await readdir(dir, { withFileTypes: true });
@@ -233,10 +295,12 @@ export async function generateProseComponentMeta(
   );
   let hasChanges = sources.length !== Object.keys(previousManifest.components || {}).length;
 
+  // First pass: resolve hashes and split into cache hits vs misses.
+  const cacheMisses: ProseComponentMetaSource[] = [];
+
   for (const component of sources) {
     const stats = await stat(component.absolutePath);
     const sourceHash = `${stats.mtimeMs}:${stats.size}`;
-
     sourceHashes[component.manifestPath] = sourceHash;
 
     const cachedEntry = previousManifest.components?.[component.manifestPath];
@@ -244,27 +308,33 @@ export async function generateProseComponentMeta(
 
     if (cachedEntry && cachedHash === sourceHash) {
       components[component.manifestPath] = cachedEntry;
-      continue;
+    } else {
+      hasChanges = true;
+      cacheMisses.push(component);
     }
+  }
 
-    hasChanges = true;
-
-    const meta = getComponentMeta(component.absolutePath, {
+  // Second pass: process cache misses in parallel worker threads.
+  if (cacheMisses.length > 0) {
+    const rawResults = await runInWorkers(cacheMisses, {
       rootDir: options.rootDir,
       cache: options.cache ?? true,
-      cacheDir: options.cacheDir,
+      cacheDir: options.cacheDir ?? "",
     });
 
-    const name = componentNameFromPath(component.manifestPath);
-    components[component.manifestPath] = {
-      name,
-      tag: componentTagFromName(name),
-      path: component.manifestPath,
-      props: meta.props.map(normalizeProp),
-      slots: meta.slots.map(normalizeSlot),
-      events: meta.events.map(normalizeEvent),
-      exposed: meta.exposed.map(normalizeExposed),
-    };
+    for (const result of rawResults) {
+      if (!result.ok || !result.raw) continue;
+      const name = componentNameFromPath(result.manifestPath);
+      components[result.manifestPath] = {
+        name,
+        tag: componentTagFromName(name),
+        path: result.manifestPath,
+        props: (result.raw.props ?? []).map(normalizeProp),
+        slots: (result.raw.slots ?? []).map(normalizeSlot),
+        events: (result.raw.events ?? []).map(normalizeEvent),
+        exposed: (result.raw.exposed ?? []).map(normalizeExposed),
+      };
+    }
   }
 
   if (!hasChanges) {