dslinter 0.1.5 → 0.2.0

package/vite/plugin.resolve.test.ts

@@ -0,0 +1,72 @@
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServer } from "vite";
+import { describe, expect, it } from "vitest";
+import { loadConsumerAliases } from "./loadConsumerAliases";
+import { collectScanModuleRelPaths } from "./collectScanModules";
+import { resolveExistingModule } from "./resolveWayfinderImport";
+import dslinter from "./plugin";
+
+const packageRoot = resolve(
+  fileURLToPath(new URL(".", import.meta.url)),
+  "..",
+);
+const demoInertiaRoot = resolve(packageRoot, "../../demo-inertia");
+const navFooter = join(
+  demoInertiaRoot,
+  "resources/js/components/nav-footer.tsx",
+);
+
+describe("dslinter vite plugin resolveId", () => {
+  it("has scan paths and consumer aliases for demo-inertia", () => {
+    const relPaths = collectScanModuleRelPaths(demoInertiaRoot);
+    expect(relPaths).toContain("resources/js/components/nav-footer.tsx");
+    const aliases = loadConsumerAliases(demoInertiaRoot, undefined);
+    const file = resolveExistingModule("@/components/ui/sidebar", aliases);
+    expect(file?.replace(/\\/g, "/")).toContain(
+      "demo-inertia/resources/js/components/ui/sidebar.tsx",
+    );
+  });
+
+  it("resolveId hook returns consumer file for playground importer", async () => {
+    const plugin = dslinter({
+      scanRoot: demoInertiaRoot,
+      consumerViteRoot: demoInertiaRoot,
+    });
+    const resolved = await plugin.resolveId?.(
+      "@/components/ui/sidebar",
+      navFooter,
+      { ssr: false },
+    );
+    expect(resolved?.replace(/\\/g, "/")).toContain(
+      "demo-inertia/resources/js/components/ui/sidebar.tsx",
+    );
+  });
+
+  it("resolves @/ imports via pluginContainer", async () => {
+    const server = await createServer({
+      root: packageRoot,
+      plugins: [
+        dslinter({
+          scanRoot: demoInertiaRoot,
+          consumerViteRoot: demoInertiaRoot,
+        }),
+      ],
+      server: { fs: { allow: [packageRoot, demoInertiaRoot] } },
+    });
+
+    try {
+      const resolved = await server.pluginContainer.resolveId(
+        "@/components/ui/sidebar",
+        navFooter,
+      );
+      expect(resolved?.id.replace(/\\/g, "/")).toContain(
+        "demo-inertia/resources/js/components/ui/sidebar",
+      );
+      expect(existsSync(resolved!.id.split("?")[0]!)).toBe(true);
+    } finally {
+      await server.close();
+    }
+  });
+});

package/vite/plugin.ts

@@ -1,29 +1,58 @@
-import { resolve } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { hideComponentInDslintConfig } from "../bin/lib/config-hide-component.mjs";
+import { openFileInEditor } from "./openFileInEditor.mjs";
+import { loadConfigFromFile } from "vite";
 import type { Plugin, UserConfig } from "vite";
+import { resolveServePort } from "../shared/servePort";
+import {
+  REPORT_URL_PATH,
+} from "../shared/paths";
+import { resolveReportFilePath } from "../shared/reportPath";
 import {
   collectScanModuleRelPaths,
   embedGlobKeyFromRelPath,
 } from "./collectScanModules";
+import {
+  buildEmbedIndexCss,
+  embedSourcePathsRelativeToCss,
+  shouldInjectEmbedConsumerSources,
+} from "./embedTailwindSources";
+import {
+  importerUnderScanRoot,
+  INERTIA_SHIM_IDS,
+  ZIGGY_SHIM_ID,
+  type FlatAlias,
+} from "./consumerAlias";
+import { loadConsumerAliases } from "./loadConsumerAliases";
+import {
+  isWayfinderActionsImport,
+  isWayfinderRoutesImport,
+  resolveExistingModule,
+  resolveWayfinderShim,
+} from "./resolveWayfinderImport";
 
 export const VIRTUAL_PLAYGROUND_MODULES_ID = "virtual:dslinter/playground-modules";
 const RESOLVED_VIRTUAL_ID = `\0${VIRTUAL_PLAYGROUND_MODULES_ID}`;
 
+const pluginDir = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(pluginDir, "..");
+const embedIndexCssPath = resolve(packageRoot, "embed", "index.css");
+const inertiaShimPath = resolve(pluginDir, "shims/inertia-react.tsx");
+const ziggyShimPath = resolve(pluginDir, "shims/ziggy-js.ts");
+const wayfinderRoutesShimPath = resolve(pluginDir, "shims/wayfinder-routes.ts");
+const wayfinderActionsShimPath = resolve(pluginDir, "shims/wayfinder-actions.ts");
+
 export type DslinterVitePluginOptions = {
-  /** Scan root (repo root passed to `npx dslinter`). Defaults to `DSLINT_SCAN_ROOT` or `process.cwd()`. */
+  /** Scan root (repo root passed to `npx dslinter`). Defaults to `DSLINTER_SCAN_ROOT` or `process.cwd()`. */
   scanRoot?: string;
+  /** Host Vite project root for `@/` aliases (Laravel/Inertia). */
+  consumerViteRoot?: string;
   /** Scanner HTTP port for report + SSE proxy in `serve` mode. */
   servePort?: number;
 };
 
-function defaultServePort(): number {
-  const fromEnv = process.env.DSLINT_SERVE_PORT?.trim();
-  if (fromEnv) {
-    const n = Number.parseInt(fromEnv, 10);
-    if (Number.isFinite(n) && n > 0 && n <= 65535) return n;
-  }
-  return 7878;
-}
-
 function generatePlaygroundModulesSource(
   scanRoot: string,
   relPaths: string[],
@@ -63,21 +92,34 @@ export default function dslinter(
 ): Plugin {
   const scanRoot = resolve(
     options.scanRoot ??
-      process.env.DSLINT_SCAN_ROOT ??
+      process.env.DSLINTER_SCAN_ROOT ??
       process.cwd(),
   );
-  const servePort = options.servePort ?? defaultServePort();
-  let relPaths: string[] = [];
+  const consumerViteRoot = resolve(
+    options.consumerViteRoot ??
+      process.env.DSLINTER_CONSUMER_VITE_ROOT ??
+      "",
+  );
+  const servePort = options.servePort ?? resolveServePort();
+  const consumerRoot =
+    consumerViteRoot && existsSync(consumerViteRoot) ? consumerViteRoot : null;
+  /** Populated synchronously so resolveId works before async configResolved. */
+  let relPaths = collectScanModuleRelPaths(scanRoot);
+  let consumerAliases: FlatAlias[] = consumerRoot
+    ? loadConsumerAliases(consumerRoot, undefined)
+    : [];
 
   return {
     name: "dslinter",
     enforce: "pre",
+    /** Run before vite:alias so consumer @/ imports are not rewritten to embed src. */
+    order: "pre",
 
     config(config, { mode }): UserConfig {
       const proxy =
         mode === "serve"
           ? {
-              "/dslint-report.json": {
+              [REPORT_URL_PATH]: {
                 target: `http://127.0.0.1:${servePort}`,
                 changeOrigin: true,
               },
@@ -88,10 +130,14 @@ export default function dslinter(
             }
           : undefined;
 
+      const allowRoots = [scanRoot];
+      if (consumerViteRoot && existsSync(consumerViteRoot)) {
+        allowRoots.push(consumerViteRoot);
+      }
       const existingAllow = config.server?.fs?.allow;
       const fsAllow = Array.isArray(existingAllow)
-        ? [...existingAllow, scanRoot]
-        : [scanRoot];
+        ? [...existingAllow, ...allowRoots]
+        : allowRoots;
 
       return {
         resolve: {
@@ -109,14 +155,63 @@ export default function dslinter(
       };
     },
 
-    configResolved() {
+    async configResolved(config) {
       relPaths = collectScanModuleRelPaths(scanRoot);
+      if (!consumerRoot) {
+        consumerAliases = [];
+        return;
+      }
+      try {
+        const loaded = await loadConfigFromFile(
+          { command: config.command, mode: config.mode },
+          undefined,
+          consumerRoot,
+        );
+        consumerAliases = loadConsumerAliases(
+          consumerRoot,
+          loaded?.config?.resolve?.alias,
+        );
+      } catch {
+        consumerAliases = loadConsumerAliases(consumerRoot, undefined);
+      }
     },
 
-    resolveId(id) {
+    resolveId(id, importer) {
       if (id === VIRTUAL_PLAYGROUND_MODULES_ID) {
         return RESOLVED_VIRTUAL_ID;
       }
+
+      if (!importer || !importerUnderScanRoot(importer, scanRoot)) {
+        return null;
+      }
+
+      if (INERTIA_SHIM_IDS.has(id) || id.startsWith("@inertiajs/react/")) {
+        return inertiaShimPath;
+      }
+      if (id === ZIGGY_SHIM_ID || id === "ziggy") {
+        return ziggyShimPath;
+      }
+
+      if (
+        isWayfinderRoutesImport(id) ||
+        isWayfinderActionsImport(id)
+      ) {
+        const onDisk = resolveExistingModule(id, consumerAliases);
+        if (onDisk) return onDisk;
+        const shim = resolveWayfinderShim(
+          id,
+          wayfinderRoutesShimPath,
+          wayfinderActionsShimPath,
+        );
+        if (shim) return shim;
+      }
+
+      if (consumerAliases.length > 0) {
+        const onDisk = resolveExistingModule(id, consumerAliases);
+        if (onDisk) return onDisk;
+      }
+
+      return null;
     },
 
     load(id) {
@@ -124,7 +219,109 @@ export default function dslinter(
       return generatePlaygroundModulesSource(scanRoot, relPaths);
     },
 
+    transform(code, id) {
+      const normalizedId = id.split("?")[0]!.replace(/\\/g, "/");
+      if (!normalizedId.endsWith("/embed/index.css")) return;
+
+      if (!shouldInjectEmbedConsumerSources(scanRoot, packageRoot)) {
+        return null;
+      }
+
+      const consumerSources = embedSourcePathsRelativeToCss(
+        scanRoot,
+        packageRoot,
+        embedIndexCssPath,
+      );
+      if (consumerSources.length === 0) return null;
+
+      return {
+        code: buildEmbedIndexCss(code, consumerSources),
+        map: null,
+      };
+    },
+
     configureServer(server) {
+      const reportFile = resolveReportFilePath(scanRoot);
+      const configHidePath = "/dslinter-config/hide-component";
+      const openFilePath = "/dslinter/open-file";
+
+      server.middlewares.use(async (req, res, next) => {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        const path = url.pathname;
+        if (path === openFilePath && (req.method === "POST" || req.method === "GET")) {
+          try {
+            const file = url.searchParams.get("path")?.trim();
+            if (!file) {
+              throw new Error("Missing path query parameter");
+            }
+            const line = Number(url.searchParams.get("line") ?? "1");
+            const column = Number(url.searchParams.get("column") ?? "1");
+            openFileInEditor({
+              file,
+              line: Number.isFinite(line) ? line : 1,
+              column: Number.isFinite(column) ? column : 1,
+              scanRoot,
+            });
+            res.setHeader("Content-Type", "application/json; charset=utf-8");
+            res.statusCode = 200;
+            res.end(JSON.stringify({ ok: true }));
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.statusCode = 400;
+            res.setHeader("Content-Type", "application/json; charset=utf-8");
+            res.end(JSON.stringify({ ok: false, error: message }));
+          }
+          return;
+        }
+        if (path === configHidePath && req.method === "POST") {
+          try {
+            const chunks: Buffer[] = [];
+            for await (const chunk of req) {
+              chunks.push(chunk as Buffer);
+            }
+            const raw = Buffer.concat(chunks).toString("utf8");
+            const body = JSON.parse(raw || "{}") as { name?: string };
+            const result = hideComponentInDslintConfig(scanRoot, body.name ?? "");
+            res.setHeader("Content-Type", "application/json; charset=utf-8");
+            res.statusCode = 200;
+            res.end(JSON.stringify({ ok: true, ...result }));
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.statusCode = 400;
+            res.setHeader("Content-Type", "application/json; charset=utf-8");
+            res.end(JSON.stringify({ ok: false, error: message }));
+          }
+          return;
+        }
+        if (path !== REPORT_URL_PATH) {
+          next();
+          return;
+        }
+        if (!existsSync(reportFile)) {
+          next();
+          return;
+        }
+        try {
+          const stat = statSync(reportFile);
+          const etag = `"${stat.mtimeMs}"`;
+          res.setHeader("Content-Type", "application/json; charset=utf-8");
+          res.setHeader("Cache-Control", "no-store");
+          res.setHeader("ETag", etag);
+          if (req.method === "HEAD") {
+            res.statusCode = 200;
+            res.end();
+            return;
+          }
+          if (req.method === "GET") {
+            res.end(readFileSync(reportFile));
+            return;
+          }
+        } catch {
+          // fall through to proxy / 404
+        }
+        next();
+      });
+
       const refresh = () => {
         relPaths = collectScanModuleRelPaths(scanRoot);
         const mod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ID);

package/vite/reportPath.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { join, resolve } from "node:path";
+import { resolveReportFilePath } from "../shared/reportPath";
+
+describe("resolveReportFilePath", () => {
+  it("defaults to public/dslinter-report.json under scan root", () => {
+    const root = "/app/demo-inertia";
+    expect(resolveReportFilePath(root, {})).toBe(
+      resolve(root, "public", "dslinter-report.json"),
+    );
+  });
+
+  it("uses DSLINTER_REPORT_PATH when set", () => {
+    const custom = join("/tmp", "custom-report.json");
+    expect(
+      resolveReportFilePath("/app", { DSLINTER_REPORT_PATH: custom }),
+    ).toBe(resolve(custom));
+  });
+});

package/vite/resolveWayfinderImport.ts

@@ -0,0 +1,56 @@
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { resolveWithConsumerAliases, type FlatAlias } from "./consumerAlias";
+
+const FILE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"] as const;
+
+export const WAYFINDER_ROUTES_PREFIX = "@/routes";
+export const WAYFINDER_ACTIONS_PREFIX = "@/actions";
+
+export function isWayfinderRoutesImport(id: string): boolean {
+  return id === WAYFINDER_ROUTES_PREFIX || id.startsWith(`${WAYFINDER_ROUTES_PREFIX}/`);
+}
+
+export function isWayfinderActionsImport(id: string): boolean {
+  return id === WAYFINDER_ACTIONS_PREFIX || id.startsWith(`${WAYFINDER_ACTIONS_PREFIX}/`);
+}
+
+/** Resolve import to an existing file on disk, trying common extensions. */
+export function resolveExistingModule(
+  id: string,
+  aliases: FlatAlias[],
+): string | null {
+  const base = resolveWithConsumerAliases(id, aliases);
+  if (!base) return null;
+
+  if (existsSync(base)) {
+    try {
+      if (!statSync(base).isDirectory()) return base;
+    } catch {
+      return null;
+    }
+  }
+
+  for (const ext of FILE_EXTENSIONS) {
+    const candidate = `${base}${ext}`;
+    if (existsSync(candidate)) return candidate;
+  }
+
+  for (const ext of FILE_EXTENSIONS) {
+    const candidate = join(base, `index${ext}`);
+    if (existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+/** When Wayfinder output is missing, map @/routes/* and @/actions/* to dslinter shims. */
+export function resolveWayfinderShim(
+  id: string,
+  routesShimPath: string,
+  actionsShimPath: string,
+): string | null {
+  if (isWayfinderRoutesImport(id)) return routesShimPath;
+  if (isWayfinderActionsImport(id)) return actionsShimPath;
+  return null;
+}

package/vite/shims/inertia-react.tsx

@@ -0,0 +1,85 @@
+import type { ReactNode } from "react";
+
+/** Minimal Inertia stubs for dslinter component previews (no Laravel backend). */
+
+/** No-op entry bootstrap when `app.tsx` is pulled into the playground graph. */
+export function createInertiaApp(_options: Record<string, unknown>) {
+  return undefined;
+}
+
+/** No-op layout prop helper used by some auth pages. */
+export function setLayoutProps(_props: Record<string, unknown>) {
+  return undefined;
+}
+
+const emptyPage = {
+  component: "Preview",
+  props: {} as Record<string, unknown>,
+  url: "/",
+  version: null as string | null,
+  clearHistory: false,
+  encryptHistory: false,
+  rememberedState: {} as Record<string, unknown>,
+  scrollRegions: [] as unknown[],
+};
+
+export function usePage<T extends Record<string, unknown> = Record<string, unknown>>() {
+  return {
+    ...emptyPage,
+    props: {} as T,
+  };
+}
+
+export function Link({
+  href = "#",
+  children,
+  ...rest
+}: {
+  href?: string;
+  children?: ReactNode;
+  [key: string]: unknown;
+}) {
+  return (
+    <a href={href} {...rest}>
+      {children}
+    </a>
+  );
+}
+
+export function Head({ children }: { children?: ReactNode }) {
+  return <>{children}</>;
+}
+
+/** Stub for components that use Inertia `<Form>` in playground previews. */
+export function Form({
+  children,
+  ...rest
+}: {
+  children?: ReactNode;
+  [key: string]: unknown;
+}) {
+  return <form {...rest}>{children}</form>;
+}
+
+export const router = {
+  visit: () => undefined,
+  get: () => undefined,
+  post: () => undefined,
+  put: () => undefined,
+  patch: () => undefined,
+  delete: () => undefined,
+  reload: () => undefined,
+  replace: () => undefined,
+};
+
+/** Stub for hooks that fetch JSON via Inertia HTTP helpers in playground previews. */
+export function useHttp() {
+  return {
+    submit: async (url?: unknown) => {
+      const path = String(url ?? "");
+      if (path.includes("recovery")) return [];
+      if (path.includes("secret")) return { secretKey: "" };
+      return { svg: "", url: "" };
+    },
+  };
+}

package/vite/shims/wayfinder-actions.ts

@@ -0,0 +1,33 @@
+/**
+ * Minimal Wayfinder action stubs for dslinter component previews (no Laravel backend).
+ */
+
+type ActionMethod = {
+  url: (id?: number | string) => string;
+  form: (options?: Record<string, unknown>) => Record<string, unknown>;
+};
+
+function actionMethod(path = "#"): ActionMethod {
+  return {
+    url: () => path,
+    form: () => ({ action: path, method: "post" }),
+  };
+}
+
+const controllerHandler: ProxyHandler<Record<string, ActionMethod>> = {
+  get(_target, prop) {
+    if (typeof prop !== "string") return undefined;
+    return actionMethod(`/${prop}`);
+  },
+};
+
+const controllerStub = new Proxy(
+  {} as Record<string, ActionMethod>,
+  controllerHandler,
+);
+
+/** Default export used as `ProfileController.destroy.form()`. */
+export default controllerStub;
+
+/** Named export used as `destroy.url(id)`. */
+export const destroy = actionMethod("/passkeys");

package/vite/shims/wayfinder-routes.ts

@@ -0,0 +1,30 @@
+/**
+ * Minimal Wayfinder route stubs for dslinter component previews (no Laravel backend).
+ */
+
+type RouteHelper = {
+  url: (params?: Record<string, unknown>) => string;
+  form: (options?: Record<string, unknown>) => Record<string, unknown>;
+};
+
+function routeHelper(path = "#"): RouteHelper {
+  return {
+    url: () => path,
+    form: () => ({ action: path, method: "post" }),
+  };
+}
+
+export const dashboard = routeHelper("/dashboard");
+export const logout = routeHelper("/logout");
+export const home = routeHelper("/");
+export const login = routeHelper("/login");
+export const register = routeHelper("/register");
+
+export const edit = routeHelper("/profile");
+export const confirm = routeHelper("/two-factor/confirm");
+export const enable = routeHelper("/two-factor/enable");
+export const disable = routeHelper("/two-factor/disable");
+export const regenerateRecoveryCodes = routeHelper("/two-factor/recovery-codes");
+export const qrCode = routeHelper("/two-factor/qr-code");
+export const recoveryCodes = routeHelper("/two-factor/recovery-codes");
+export const secretKey = routeHelper("/two-factor/secret-key");

package/vite/shims/ziggy-js.ts

@@ -0,0 +1,12 @@
+/** Stub for ziggy-js in dslinter previews. */
+export default function route(
+  _name?: string,
+  _params?: Record<string, unknown>,
+  _absolute?: boolean,
+): string {
+  return "#";
+}
+
+export function routeFn(...args: Parameters<typeof route>): string {
+  return route(...args);
+}