@solidjs/start 2.0.0-alpha.0 → 2.0.0-alpha.1

package/src/server/collect-styles.ts

@@ -2,93 +2,86 @@ import path from "node:path";
 import { resolve } from "pathe";
 import type { DevEnvironment, EnvironmentModuleNode } from "vite";
 
-async function getViteModuleNode(
-	vite: DevEnvironment,
-	file: string,
-) {
-	let nodePath = file;
-	let node = vite.moduleGraph.getModuleById(file);
+async function getViteModuleNode(vite: DevEnvironment, file: string) {
+  let nodePath = file;
+  let node = vite.moduleGraph.getModuleById(file);
 
-	if (!node) {
-		const resolvedId = await vite.pluginContainer.resolveId(file, undefined);
-		if (!resolvedId) return;
+  if (!node) {
+    const resolvedId = await vite.pluginContainer.resolveId(file, undefined);
+    if (!resolvedId) return;
 
-		nodePath = resolvedId.id;
-		node = vite.moduleGraph.getModuleById(file);
-	}
+    nodePath = resolvedId.id;
+    node = vite.moduleGraph.getModuleById(file);
+  }
 
-	if (!node) {
-		nodePath = resolve(nodePath);
-		node = await vite.moduleGraph.getModuleByUrl(file);
-	}
+  if (!node) {
+    nodePath = resolve(nodePath);
+    node = await vite.moduleGraph.getModuleByUrl(file);
+  }
 
-	if (!node) {
-		await vite.moduleGraph.ensureEntryFromUrl(nodePath, false);
-		node = vite.moduleGraph.getModuleById(nodePath);
-	}
+  if (!node) {
+    await vite.moduleGraph.ensureEntryFromUrl(nodePath, false);
+    node = vite.moduleGraph.getModuleById(nodePath);
+  }
 
-	return node;
+  return node;
 }
 
 async function findModuleDependencies(
-	vite: DevEnvironment,
-	file: string,
-	deps: Set<EnvironmentModuleNode>,
-	crawledFiles = new Set<string>()
+  vite: DevEnvironment,
+  file: string,
+  deps: Set<EnvironmentModuleNode>,
+  crawledFiles = new Set<string>(),
 ) {
-	crawledFiles.add(file);
-	const module = await getViteModuleNode(vite, file);
-	if (!module?.id || deps.has(module)) return;
-
-	deps.add(module);
-	
-	if (module.url.endsWith(".css") || module.url.includes("node_modules")) return;
-
-	if (!module.transformResult) {
-		await vite.transformRequest(module.id).catch(() => {});
-	}
-	if (!module.transformResult?.deps) return;
-
-	// Relying on module.transformResult.deps instead of module.importedModules because:
-	// transformResult properly separates imports into deps and dynamicDeps, importedModules doesn't
-	// Style crawling has to skip dynamic imports as such modules load their styles themselves
-	for (const dep of module.transformResult.deps) {
-		if (crawledFiles.has(dep)) {
-			continue;
-		}
-		await findModuleDependencies(vite, dep, deps, crawledFiles);
-	}
+  crawledFiles.add(file);
+  const module = await getViteModuleNode(vite, file);
+  if (!module?.id || deps.has(module)) return;
+
+  deps.add(module);
+
+  if (module.url.endsWith(".css") || module.url.includes("node_modules")) return;
+
+  if (!module.transformResult) {
+    await vite.transformRequest(module.id).catch(() => {});
+  }
+  if (!module.transformResult?.deps) return;
+
+  // Relying on module.transformResult.deps instead of module.importedModules because:
+  // transformResult properly separates imports into deps and dynamicDeps, importedModules doesn't
+  // Style crawling has to skip dynamic imports as such modules load their styles themselves
+  for (const dep of module.transformResult.deps) {
+    if (crawledFiles.has(dep)) {
+      continue;
+    }
+    await findModuleDependencies(vite, dep, deps, crawledFiles);
+  }
 }
 
 // Vite doesn't expose these so we just copy the list for now
 // https://github.com/vitejs/vite/blob/d6bde8b03d433778aaed62afc2be0630c8131908/packages/vite/src/node/constants.ts#L49C23-L50
-const cssFileRegExp =
-	/\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)$/;
+const cssFileRegExp = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)$/;
 // https://github.com/vitejs/vite/blob/d6bde8b03d433778aaed62afc2be0630c8131908/packages/vite/src/node/plugins/css.ts#L160
 const cssModulesRegExp = new RegExp(`\\.module${cssFileRegExp.source}`);
 
 const isCssFile = (file: string) => cssFileRegExp.test(file);
 export const isCssModulesFile = (file: string) => cssModulesRegExp.test(file);
 
-export async function findStylesInModuleGraph(
-	vite: DevEnvironment,
-	id: string,
-) {
-	const absolute = path.resolve(process.cwd(), id);
-	const dependencies = new Set<EnvironmentModuleNode>();
-
-	try {
-		await findModuleDependencies(vite, absolute, dependencies);
-	} catch (e) {
-		console.error(e);
-	}
-
-	const styles: Record<string, any> = {};
-	for (const dep of dependencies) {
-		if (dep.id && isCssFile(dep.url)) {
-			styles[dep.id] = dep.url;
-		}
-	}
-
-	return styles;
+export async function findStylesInModuleGraph(vite: DevEnvironment, id: string) {
+  const absolute = path.resolve(process.cwd(), id);
+  const dependencies = new Set<EnvironmentModuleNode>();
+
+  try {
+    await findModuleDependencies(vite, absolute, dependencies);
+  } catch (e) {
+    console.error(e);
+  }
+
+  const styles: Record<string, any> = {};
+  for (const dep of dependencies) {
+    if (dep.id && isCssFile(dep.url)) {
+      styles[dep.id] = dep.url;
+    }
+  }
+
+  return styles;
 }

package/src/server/fetchEvent.spec.ts

@@ -1,89 +1,85 @@
 import * as h3 from "h3";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
-import {
-	createFetchEvent,
-	getFetchEvent,
-	mergeResponseHeaders,
-} from "./fetchEvent.ts";
-
-vi.mock(import("h3"), async (mod) => {
-	return {
-		...(await mod()),
-		getRequestIP: vi.fn(),
-	};
+import { createFetchEvent, getFetchEvent, mergeResponseHeaders } from "./fetchEvent.ts";
+
+vi.mock(import("h3"), async mod => {
+  return {
+    ...(await mod()),
+    getRequestIP: vi.fn(),
+  };
 });
 
 const mockedH3 = vi.mocked(h3);
 
 const createMockH3Event = (): h3.H3Event => {
-	const event = new h3.H3Event(new Request("http://localhost/test"));
+  const event = new h3.H3Event(new Request("http://localhost/test"));
 
-	event.res.status = 200;
-	event.res.statusText = "OK";
+  event.res.status = 200;
+  event.res.statusText = "OK";
 
-	return event;
+  return event;
 };
 
 describe("fetchEvent", () => {
-	let mockH3Event: h3.H3Event;
-
-	beforeEach(() => {
-		mockH3Event = createMockH3Event();
-		vi.clearAllMocks();
-
-		mockedH3.getRequestIP.mockReturnValue("127.0.0.1");
-	});
-
-	describe("createFetchEvent", () => {
-		it("should create a FetchEvent from H3Event", () => {
-			const fetchEvent = createFetchEvent(mockH3Event);
-
-			expect(fetchEvent).toEqual({
-				request: mockH3Event.req,
-				response: expect.any(Object),
-				clientAddress: "127.0.0.1",
-				locals: {},
-				nativeEvent: mockH3Event,
-			});
-		});
-
-		it("should create response stub with correct properties", () => {
-			const fetchEvent = createFetchEvent(mockH3Event);
-
-			expect(fetchEvent.response).toHaveProperty("status");
-			expect(fetchEvent.response).toHaveProperty("statusText");
-			expect(fetchEvent.response).toHaveProperty("headers");
-		});
-	});
-
-	describe("getFetchEvent", () => {
-		it("should create and cache FetchEvent on first call", () => {
-			const fetchEvent = getFetchEvent(mockH3Event);
-
-			expect(mockH3Event.context.solidFetchEvent).toBe(fetchEvent);
-			expect(fetchEvent.nativeEvent).toBe(mockH3Event);
-		});
-
-		it("should return cached FetchEvent on subsequent calls", () => {
-			const firstCall = getFetchEvent(mockH3Event);
-			const secondCall = getFetchEvent(mockH3Event);
-
-			expect(firstCall).toBe(secondCall);
-		});
-	});
-
-	describe("mergeResponseHeaders", () => {
-		it("should merge headers from Headers object to H3Event", () => {
-			const headers = new Headers({
-				"content-type": "application/json",
-				"x-custom": "value",
-			});
-
-			mergeResponseHeaders(mockH3Event, headers);
-
-			expect(headers.get("content-type")).toBe("application/json");
-			expect(headers.get("x-custom")).toBe("value");
-		});
-	});
+  let mockH3Event: h3.H3Event;
+
+  beforeEach(() => {
+    mockH3Event = createMockH3Event();
+    vi.clearAllMocks();
+
+    mockedH3.getRequestIP.mockReturnValue("127.0.0.1");
+  });
+
+  describe("createFetchEvent", () => {
+    it("should create a FetchEvent from H3Event", () => {
+      const fetchEvent = createFetchEvent(mockH3Event);
+
+      expect(fetchEvent).toEqual({
+        request: mockH3Event.req,
+        response: expect.any(Object),
+        clientAddress: "127.0.0.1",
+        locals: {},
+        nativeEvent: mockH3Event,
+      });
+    });
+
+    it("should create response stub with correct properties", () => {
+      const fetchEvent = createFetchEvent(mockH3Event);
+
+      expect(fetchEvent.response).toHaveProperty("status");
+      expect(fetchEvent.response).toHaveProperty("statusText");
+      expect(fetchEvent.response).toHaveProperty("headers");
+    });
+  });
+
+  describe("getFetchEvent", () => {
+    it("should create and cache FetchEvent on first call", () => {
+      const fetchEvent = getFetchEvent(mockH3Event);
+
+      expect(mockH3Event.context.solidFetchEvent).toBe(fetchEvent);
+      expect(fetchEvent.nativeEvent).toBe(mockH3Event);
+    });
+
+    it("should return cached FetchEvent on subsequent calls", () => {
+      const firstCall = getFetchEvent(mockH3Event);
+      const secondCall = getFetchEvent(mockH3Event);
+
+      expect(firstCall).toBe(secondCall);
+    });
+  });
+
+  describe("mergeResponseHeaders", () => {
+    it("should merge headers from Headers object to H3Event", () => {
+      const headers = new Headers({
+        "content-type": "application/json",
+        "x-custom": "value",
+      });
+
+      mergeResponseHeaders(mockH3Event, headers);
+
+      expect(headers.get("content-type")).toBe("application/json");
+      expect(headers.get("x-custom")).toBe("value");
+    });
+  });
 });

package/src/server/fetchEvent.ts

@@ -5,32 +5,32 @@ import type { FetchEvent } from "./types.ts";
 const FETCH_EVENT_CONTEXT = "solidFetchEvent";
 
 export function createFetchEvent(event: H3Event): FetchEvent {
-	return {
-		request: event.req,
-		response: event.res,
-		clientAddress: getRequestIP(event),
-		locals: {},
-		nativeEvent: event,
-	};
+  return {
+    request: event.req,
+    response: event.res,
+    clientAddress: getRequestIP(event),
+    locals: {},
+    nativeEvent: event,
+  };
 }
 
 export function getFetchEvent(h3Event: H3Event): FetchEvent {
-	if (!h3Event.context[FETCH_EVENT_CONTEXT]) {
-		const fetchEvent = createFetchEvent(h3Event);
-		h3Event.context[FETCH_EVENT_CONTEXT] = fetchEvent;
-	}
+  if (!h3Event.context[FETCH_EVENT_CONTEXT]) {
+    const fetchEvent = createFetchEvent(h3Event);
+    h3Event.context[FETCH_EVENT_CONTEXT] = fetchEvent;
+  }
 
-	return h3Event.context[FETCH_EVENT_CONTEXT] as any;
+  return h3Event.context[FETCH_EVENT_CONTEXT] as any;
 }
 
 export function mergeResponseHeaders(h3Event: H3Event, headers: Headers) {
-	for (const [key, value] of headers.entries()) {
-		h3Event.res.headers.append(key, value);
-	}
+  for (const [key, value] of headers.entries()) {
+    h3Event.res.headers.append(key, value);
+  }
 }
 
 export const decorateHandler = <T extends EventHandler>(fn: T) =>
-	(event => provideRequestEvent(getFetchEvent(event), () => fn(event))) as T;
+  (event => provideRequestEvent(getFetchEvent(event), () => fn(event))) as T;
 
 export const decorateMiddleware = <T extends Middleware>(fn: T) =>
-	((event, next) => provideRequestEvent(getFetchEvent(event), () => fn(event, next))) as T;
+  ((event, next) => provideRequestEvent(getFetchEvent(event), () => fn(event, next))) as T;