dslinter 0.1.5 → 0.2.0

package/vite/embedTailwindSources.ts

@@ -0,0 +1,97 @@
+import { existsSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { projectRootForConfig, readIncludeDirs } from "./collectScanModules";
+
+const FALLBACK_INCLUDE_DIRS = ["resources/js", "src", "app"];
+
+const DASHBOARD_SRC_MARKER = `${join("packages", "dashboard", "src")}`;
+
+function normalizePosixPath(path: string): string {
+  return path.replace(/\\/g, "/").replace(/\/$/, "");
+}
+
+function isDashboardPackageSrc(absPath: string): boolean {
+  return normalizePosixPath(absPath).endsWith(DASHBOARD_SRC_MARKER);
+}
+
+function resolveConsumerSourceAbsDirs(
+  scanRoot: string,
+  packageRoot: string,
+): string[] {
+  const scanAbs = resolve(scanRoot);
+  const projectRoot = projectRootForConfig(scanAbs);
+  let dirs = readIncludeDirs(projectRoot);
+
+  if (!dirs?.length) {
+    dirs = FALLBACK_INCLUDE_DIRS.filter((dir) =>
+      existsSync(join(projectRoot, dir)),
+    );
+  }
+
+  const unique = new Set<string>();
+  for (const dir of dirs) {
+    const norm = dir.trim().replace(/\\/g, "/").replace(/\/$/, "");
+    if (!norm) continue;
+    const abs = resolve(projectRoot, norm);
+    if (!existsSync(abs)) continue;
+    if (isDashboardPackageSrc(abs)) continue;
+    unique.add(abs);
+  }
+
+  if (unique.size === 0 && normalizePosixPath(scanAbs) !== normalizePosixPath(packageRoot)) {
+    for (const dir of FALLBACK_INCLUDE_DIRS) {
+      const abs = resolve(scanAbs, dir);
+      if (!existsSync(abs)) continue;
+      if (isDashboardPackageSrc(abs)) continue;
+      unique.add(abs);
+    }
+  }
+
+  return [...unique].sort();
+}
+
+/** Absolute consumer include dirs to register with Tailwind `@source`. */
+export function resolveEmbedConsumerSourceDirs(
+  scanRoot: string,
+  packageRoot: string,
+): string[] {
+  return resolveConsumerSourceAbsDirs(scanRoot, packageRoot);
+}
+
+/** `@source` paths relative to `embed/index.css`. */
+export function embedSourcePathsRelativeToCss(
+  scanRoot: string,
+  packageRoot: string,
+  embedCssPath: string,
+): string[] {
+  const embedCssDir = dirname(resolve(embedCssPath));
+  return resolveEmbedConsumerSourceDirs(scanRoot, packageRoot).map((abs) => {
+    let rel = relative(embedCssDir, abs).replace(/\\/g, "/");
+    if (!rel.startsWith(".")) rel = `./${rel}`;
+    return rel;
+  });
+}
+
+export function buildEmbedIndexCss(
+  base: string,
+  consumerSources: string[],
+): string {
+  if (consumerSources.length === 0) return base;
+  const injected = consumerSources.map((p) => `@source "${p}";`).join("\n");
+  return base.replace(
+    '@source "../src";',
+    `@source "../src";\n${injected}`,
+  );
+}
+
+export function shouldInjectEmbedConsumerSources(
+  scanRoot: string,
+  packageRoot: string,
+): boolean {
+  const scanAbs = resolve(scanRoot);
+  const pkgAbs = resolve(packageRoot);
+  if (normalizePosixPath(scanAbs) !== normalizePosixPath(pkgAbs)) {
+    return true;
+  }
+  return resolveEmbedConsumerSourceDirs(scanRoot, packageRoot).length > 0;
+}

package/vite/loadConsumerAliases.test.ts

@@ -0,0 +1,131 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { describe, expect, it } from "vitest";
+import {
+  flattenTsconfigPaths,
+  loadConsumerAliases,
+  stripJsonComments,
+} from "./loadConsumerAliases";
+import { resolveWithConsumerAliases } from "./consumerAlias";
+import {
+  isWayfinderActionsImport,
+  isWayfinderRoutesImport,
+  resolveExistingModule,
+  resolveWayfinderShim,
+} from "./resolveWayfinderImport";
+
+describe("stripJsonComments", () => {
+  it("removes line and block comments outside strings", () => {
+    const input = `{
+      // line comment
+      "compilerOptions": {
+        /* block */
+        "paths": { "@/*": ["./resources/js/*"] }
+      }
+    }`;
+    const stripped = stripJsonComments(input);
+    expect(JSON.parse(stripped)).toEqual({
+      compilerOptions: {
+        paths: { "@/*": ["./resources/js/*"] },
+      },
+    });
+  });
+});
+
+describe("flattenTsconfigPaths", () => {
+  it("maps @/* to resources/js", () => {
+    const root = mkdtempSync(join(tmpdir(), "dslinter-tsconfig-"));
+    const aliases = flattenTsconfigPaths(
+      { "@/*": ["./resources/js/*"] },
+      root,
+    );
+    const resolved = resolveWithConsumerAliases(
+      "@/components/ui/sidebar",
+      aliases,
+    );
+    expect(resolved?.replace(/\\/g, "/")).toContain("resources/js/components/ui/sidebar");
+  });
+});
+
+describe("loadConsumerAliases", () => {
+  it("reads @/* from tsconfig.json when vite alias is empty", () => {
+    const root = mkdtempSync(join(tmpdir(), "dslinter-load-alias-"));
+    mkdirSync(join(root, "resources", "js", "components", "ui"), {
+      recursive: true,
+    });
+    writeFileSync(
+      join(root, "resources", "js", "components", "ui", "sidebar.tsx"),
+      "export {}",
+    );
+    writeFileSync(
+      join(root, "tsconfig.json"),
+      JSON.stringify({
+        compilerOptions: {
+          baseUrl: ".",
+          paths: { "@/*": ["./resources/js/*"] },
+        },
+      }),
+    );
+
+    const aliases = loadConsumerAliases(root, undefined);
+    const resolved = resolveExistingModule(
+      "@/components/ui/sidebar",
+      aliases,
+    );
+    expect(resolved?.replace(/\\/g, "/")).toContain(
+      "resources/js/components/ui/sidebar.tsx",
+    );
+  });
+
+  it("falls back to resources/js when no tsconfig", () => {
+    const root = mkdtempSync(join(tmpdir(), "dslinter-laravel-fallback-"));
+    mkdirSync(join(root, "resources", "js", "lib"), { recursive: true });
+    writeFileSync(join(root, "resources", "js", "lib", "utils.ts"), "export {}");
+
+    const aliases = loadConsumerAliases(root, undefined);
+    const resolved = resolveExistingModule("@/lib/utils", aliases);
+    expect(resolved?.replace(/\\/g, "/")).toContain("resources/js/lib/utils.ts");
+  });
+});
+
+describe("resolveWayfinderImport", () => {
+  it("detects routes and actions prefixes", () => {
+    expect(isWayfinderRoutesImport("@/routes")).toBe(true);
+    expect(isWayfinderRoutesImport("@/routes/two-factor")).toBe(true);
+    expect(isWayfinderActionsImport("@/actions/App/Http/Controllers/Foo")).toBe(
+      true,
+    );
+    expect(isWayfinderRoutesImport("@/components/foo")).toBe(false);
+  });
+
+  it("returns shim paths when generated files are missing", () => {
+    const shim = resolveWayfinderShim(
+      "@/routes/two-factor",
+      "/shims/wayfinder-routes.ts",
+      "/shims/wayfinder-actions.ts",
+    );
+    expect(shim).toBe("/shims/wayfinder-routes.ts");
+
+    const actionShim = resolveWayfinderShim(
+      "@/actions/App/Http/Controllers/Settings/ProfileController",
+      "/shims/wayfinder-routes.ts",
+      "/shims/wayfinder-actions.ts",
+    );
+    expect(actionShim).toBe("/shims/wayfinder-actions.ts");
+  });
+
+  it("resolves directory imports to index.ts", () => {
+    const root = mkdtempSync(join(tmpdir(), "dslinter-routes-dir-"));
+    mkdirSync(join(root, "resources", "js", "routes"), { recursive: true });
+    writeFileSync(
+      join(root, "resources", "js", "routes", "index.ts"),
+      "export const dashboard = () => '/';",
+    );
+    const aliases = loadConsumerAliases(root, undefined);
+    const resolved = resolveExistingModule("@/routes", aliases);
+    expect(resolved?.replace(/\\/g, "/")).toContain(
+      "resources/js/routes/index.ts",
+    );
+  });
+});

package/vite/loadConsumerAliases.ts

@@ -0,0 +1,155 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import type { AliasOptions } from "vite";
+import { flattenViteAlias, type FlatAlias } from "./consumerAlias";
+
+const TSCONFIG_NAMES = ["tsconfig.json", "jsconfig.json"] as const;
+
+/** Strip line and block comments so JSONC tsconfig files parse. */
+export function stripJsonComments(text: string): string {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === '"' || text[i] === "'") {
+      const quote = text[i]!;
+      out += quote;
+      i++;
+      while (i < text.length) {
+        if (text[i] === "\\") {
+          out += text[i]!;
+          i++;
+          if (i < text.length) {
+            out += text[i]!;
+            i++;
+          }
+          continue;
+        }
+        if (text[i] === quote) {
+          out += text[i]!;
+          i++;
+          break;
+        }
+        out += text[i]!;
+        i++;
+      }
+      continue;
+    }
+    if (text[i] === "/" && text[i + 1] === "/") {
+      i += 2;
+      while (i < text.length && text[i] !== "\n") i++;
+      continue;
+    }
+    if (text[i] === "/" && text[i + 1] === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    out += text[i]!;
+    i++;
+  }
+  return out;
+}
+
+type TsPaths = Record<string, string[]>;
+
+function readTsPaths(consumerRoot: string): TsPaths | null {
+  const root = resolve(consumerRoot);
+  for (const name of TSCONFIG_NAMES) {
+    const filePath = join(root, name);
+    if (!existsSync(filePath)) continue;
+    try {
+      const raw = readFileSync(filePath, "utf8");
+      const parsed = JSON.parse(stripJsonComments(raw)) as {
+        compilerOptions?: { paths?: TsPaths };
+      };
+      const paths = parsed.compilerOptions?.paths;
+      if (paths && typeof paths === "object") return paths;
+    } catch {
+      // try next file
+    }
+  }
+  return null;
+}
+
+/** Convert tsconfig paths (e.g. @/* → ./resources/js/*) into Vite-style aliases. */
+export function flattenTsconfigPaths(
+  paths: TsPaths,
+  consumerRoot: string,
+): FlatAlias[] {
+  const root = resolve(consumerRoot);
+  const out: FlatAlias[] = [];
+
+  for (const [find, targets] of Object.entries(paths)) {
+    if (!Array.isArray(targets) || targets.length === 0) continue;
+    const target = targets[0]!;
+    if (typeof target !== "string") continue;
+
+    if (find.endsWith("/*")) {
+      const prefix = find.slice(0, -2);
+      const targetBase = target.endsWith("/*")
+        ? target.slice(0, -2)
+        : target.replace(/\*$/, "");
+      out.push({
+        find: prefix,
+        replacement: resolve(root, targetBase),
+      });
+      continue;
+    }
+
+    out.push({
+      find,
+      replacement: resolve(root, target),
+    });
+  }
+
+  return out.sort((a, b) => {
+    const al = typeof a.find === "string" ? a.find.length : 0;
+    const bl = typeof b.find === "string" ? b.find.length : 0;
+    return bl - al;
+  });
+}
+
+function hasAtAlias(aliases: FlatAlias[]): boolean {
+  return aliases.some(
+    (a) =>
+      typeof a.find === "string" &&
+      (a.find === "@" || a.find === "@/"),
+  );
+}
+
+function laravelResourcesJsAlias(consumerRoot: string): FlatAlias | null {
+  const jsDir = join(resolve(consumerRoot), "resources", "js");
+  if (!existsSync(jsDir)) return null;
+  return { find: "@", replacement: jsDir };
+}
+
+/** Build consumer aliases: static Vite config, tsconfig paths, then Laravel @ fallback. */
+export function loadConsumerAliases(
+  consumerRoot: string,
+  viteAlias: AliasOptions | undefined,
+): FlatAlias[] {
+  const root = resolve(consumerRoot);
+  const merged: FlatAlias[] = [];
+
+  const fromVite = flattenViteAlias(viteAlias, root);
+  merged.push(...fromVite);
+
+  if (!hasAtAlias(merged)) {
+    const paths = readTsPaths(root);
+    if (paths) {
+      merged.push(...flattenTsconfigPaths(paths, root));
+    }
+  }
+
+  if (!hasAtAlias(merged)) {
+    const laravel = laravelResourcesJsAlias(root);
+    if (laravel) merged.push(laravel);
+  }
+
+  return merged.sort((a, b) => {
+    const al = typeof a.find === "string" ? a.find.length : 0;
+    const bl = typeof b.find === "string" ? b.find.length : 0;
+    return bl - al;
+  });
+}

package/vite/openFileInEditor.mjs

@@ -0,0 +1,196 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+const CONFIG_NAMES = [".dslinter.json", "dslinter.json"];
+
+/** @typedef {{ file: string; line?: number; column?: number; scanRoot: string }} OpenFileOptions */
+
+/**
+ * @param {string} startDir
+ * @returns {string | null}
+ */
+function findConfigPath(startDir) {
+  let dir = resolve(startDir);
+  for (;;) {
+    for (const name of CONFIG_NAMES) {
+      const candidate = join(dir, name);
+      if (existsSync(candidate)) return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string | null}
+ */
+function readEditorOpenCommand(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+/**
+ * @param {string} projectRoot
+ * @returns {string | null}
+ */
+export function loadEditorOpenCommand(projectRoot) {
+  const fromEnv = process.env.DSLINTER_EDITOR?.trim();
+  if (fromEnv) return fromEnv;
+
+  const configPath = findConfigPath(projectRoot);
+  if (!configPath) return null;
+  try {
+    const raw = readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return readEditorOpenCommand(parsed.editor_open_command);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} absPath
+ * @param {string} root
+ */
+export function isPathUnderRoot(absPath, root) {
+  const normalized = resolve(absPath);
+  const normalizedRoot = resolve(root);
+  if (normalized === normalizedRoot) return true;
+  const prefix = normalizedRoot.endsWith("/")
+    ? normalizedRoot
+    : `${normalizedRoot}/`;
+  return normalized.startsWith(prefix);
+}
+
+/**
+ * @param {string} template
+ * @param {{ file: string; line: number; column: number }} ctx
+ * @returns {string[]}
+ */
+export function expandEditorOpenCommand(template, ctx) {
+  const withPlaceholders = template
+    .replaceAll("{file}", ctx.file)
+    .replaceAll("{line}", String(ctx.line))
+    .replaceAll("{column}", String(ctx.column));
+  return splitShellArgs(withPlaceholders);
+}
+
+/**
+ * Minimal shell-like split (no nested quotes); good enough for editor commands.
+ * @param {string} input
+ * @returns {string[]}
+ */
+function splitShellArgs(input) {
+  const args = [];
+  let current = "";
+  let quote = null;
+  for (let i = 0; i < input.length; i += 1) {
+    const ch = input[i];
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (current.length > 0) {
+        args.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += ch;
+  }
+  if (current.length > 0) args.push(current);
+  return args;
+}
+
+/**
+ * @param {string} command
+ * @returns {boolean}
+ */
+function commandExists(command) {
+  const probe =
+    process.platform === "win32" ? "where" : "command";
+  const args =
+    process.platform === "win32" ? [command] : ["-v", command];
+  const result = spawnSync(probe, args, { stdio: "ignore" });
+  return result.status === 0;
+}
+
+/**
+ * @param {{ file: string; line: number; column: number }} ctx
+ * @param {string | null} configured
+ * @returns {string[] | null}
+ */
+export function resolveEditorOpenArgv(ctx, configured) {
+  if (configured) {
+    const argv = expandEditorOpenCommand(configured, ctx);
+    return argv.length > 0 ? argv : null;
+  }
+
+  const templates = [
+    "cursor --goto {file}:{line}:{column}",
+    "code --goto {file}:{line}:{column}",
+    "codium --goto {file}:{line}:{column}",
+    "subl {file}:{line}:{column}",
+    "webstorm --line {line} {file}",
+    "idea --line {line} {file}",
+  ];
+
+  for (const template of templates) {
+    const argv = expandEditorOpenCommand(template, ctx);
+    if (argv.length > 0 && commandExists(argv[0])) return argv;
+  }
+
+  if (process.platform === "darwin") {
+    return ["open", "-t", ctx.file];
+  }
+  if (process.platform === "win32") {
+    return ["cmd", "/c", "start", "", ctx.file];
+  }
+  return ["xdg-open", ctx.file];
+}
+
+/**
+ * @param {OpenFileOptions} options
+ */
+export function openFileInEditor(options) {
+  const file = resolve(options.file);
+  const scanRoot = resolve(options.scanRoot);
+  if (!isPathUnderRoot(file, scanRoot)) {
+    throw new Error("Refusing to open path outside scan root");
+  }
+  if (!existsSync(file)) {
+    throw new Error(`File not found: ${file}`);
+  }
+
+  const ctx = {
+    file,
+    line: options.line ?? 1,
+    column: options.column ?? 1,
+  };
+  const configured = loadEditorOpenCommand(scanRoot);
+  const argv = resolveEditorOpenArgv(ctx, configured);
+  if (!argv) {
+    throw new Error("No editor command configured");
+  }
+
+  const [command, ...args] = argv;
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: "ignore",
+  });
+  child.unref();
+}

package/vite/openFileInEditor.test.mjs

@@ -0,0 +1,87 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  expandEditorOpenCommand,
+  isPathUnderRoot,
+  resolveEditorOpenArgv,
+} from "./openFileInEditor.mjs";
+
+describe("expandEditorOpenCommand", () => {
+  it("replaces file, line, and column placeholders", () => {
+    expect(
+      expandEditorOpenCommand("cursor --goto {file}:{line}:{column}", {
+        file: "/repo/Button.tsx",
+        line: 4,
+        column: 2,
+      }),
+    ).toEqual(["cursor", "--goto", "/repo/Button.tsx:4:2"]);
+  });
+
+  it("supports quoted paths with spaces", () => {
+    expect(
+      expandEditorOpenCommand('code -g "{file}:{line}:{column}"', {
+        file: "/repo/My Button.tsx",
+        line: 1,
+        column: 1,
+      }),
+    ).toEqual(["code", "-g", "/repo/My Button.tsx:1:1"]);
+  });
+});
+
+describe("isPathUnderRoot", () => {
+  it("accepts files under the scan root", () => {
+    expect(
+      isPathUnderRoot("/repo/src/Button.tsx", "/repo"),
+    ).toBe(true);
+  });
+
+  it("rejects paths outside the scan root", () => {
+    expect(
+      isPathUnderRoot("/etc/passwd", "/repo"),
+    ).toBe(false);
+  });
+});
+
+describe("resolveEditorOpenArgv", () => {
+  const ctx = {
+    file: "/repo/src/Button.tsx",
+    line: 10,
+    column: 1,
+  };
+
+  it("uses configured command when provided", () => {
+    expect(
+      resolveEditorOpenArgv(
+        ctx,
+        "my-editor --jump {file}:{line}:{column}",
+      ),
+    ).toEqual(["my-editor", "--jump", "/repo/src/Button.tsx:10:1"]);
+  });
+});
+
+describe("loadEditorOpenCommand", () => {
+  let tempDir = "";
+
+  afterEach(() => {
+    tempDir = "";
+  });
+
+  it("reads editor_open_command from .dslinter.json", async () => {
+    tempDir = mkdtempSync(join(tmpdir(), "dslinter-open-"));
+    writeFileSync(
+      join(tempDir, ".dslinter.json"),
+      JSON.stringify({ editor_open_command: "zed {file}:{line}" }),
+    );
+    const previous = process.env.DSLINTER_EDITOR;
+    delete process.env.DSLINTER_EDITOR;
+    try {
+      const { loadEditorOpenCommand } = await import("./openFileInEditor.mjs");
+      expect(loadEditorOpenCommand(tempDir)).toBe("zed {file}:{line}");
+    } finally {
+      if (previous === undefined) delete process.env.DSLINTER_EDITOR;
+      else process.env.DSLINTER_EDITOR = previous;
+    }
+  });
+});