@praxisjs/ssg 0.1.2 → 0.1.4

package/src/__tests__/plugin.test.ts

@@ -1,161 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile, mkdir } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { describe, it, expect, vi, afterEach } from "vitest";
-
-import type { ResolvedConfig } from "vite";
-
-import { prerender } from "../prerender";
-import { ssgPlugin } from "../index";
-
-vi.mock("../prerender", () => ({
-  prerender: vi.fn(),
-  // Pass-through stand-in — the real DOM-global install/restore mechanics
-  // are covered in prerender.test.ts; here we only need loadEntry() to call
-  // through to whatever function it wraps.
-  withDomGlobals: vi.fn((_html: string, _url: string, fn: () => unknown) => fn()),
-}));
-
-const ssrLoadModule = vi.fn();
-const close = vi.fn();
-const createServer = vi.fn(async (_options: unknown) => ({ ssrLoadModule, close }));
-
-vi.mock("vite", () => ({
-  createServer: (options: unknown) => createServer(options),
-}));
-
-// registerLoaderHook()'s fallback path (module.register with a file URL)
-// assumes a built dist/ layout — loader-hook.js physically next to index.js
-// — which doesn't exist under vitest's on-the-fly source transform. The
-// mechanism itself is covered separately by running the actual built dist/
-// output through Node directly (see the plan's manual verification step);
-// here we only need to confirm ssgPlugin() triggers registration.
-const { registerHooks, register } = vi.hoisted(() => ({
-  registerHooks: vi.fn(),
-  register: vi.fn(),
-}));
-vi.mock("node:module", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("node:module")>();
-  return { ...actual, registerHooks, register };
-});
-
-const RootComponent = class {} as never;
-const routes = [{ path: "/", component: RootComponent }];
-
-function fakeResolvedConfig(root: string, outDir = "dist"): ResolvedConfig {
-  return {
-    root,
-    build: { outDir },
-    configFile: `${root}/vite.config.ts`,
-  } as unknown as ResolvedConfig;
-}
-
-describe("ssgPlugin()", () => {
-  let dir: string;
-
-  afterEach(async () => {
-    vi.clearAllMocks();
-    if (dir) await rm(dir, { recursive: true, force: true });
-  });
-
-  it("loads the root component and routes from a single SSR module load, prerenders, and writes files", async () => {
-    dir = await mkdtemp(join(tmpdir(), "praxisjs-ssg-"));
-    await mkdir(join(dir, "dist"), { recursive: true });
-    await writeFile(join(dir, "dist", "index.html"), "<html><body><div id=\"app\"></div></body></html>");
-
-    ssrLoadModule.mockResolvedValue({ default: RootComponent, routes });
-    vi.mocked(prerender).mockResolvedValue([
-      { path: "/", file: "index.html", html: "<html>home</html>" },
-      { path: "/about", file: "about/index.html", html: "<html>about</html>" },
-    ]);
-
-    const plugin = ssgPlugin({ root: "./src/app.tsx" });
-
-    // ssgPlugin() must register the extensionless-import retry hook
-    // synchronously, before closeBundle ever dynamically imports
-    // ./prerender (which is what actually needs it) — see index.ts.
-    expect(registerHooks.mock.calls.length + register.mock.calls.length).toBeGreaterThan(0);
-
-    const configResolved = plugin.configResolved as (c: ResolvedConfig) => void | Promise<void>;
-    await configResolved(fakeResolvedConfig(dir));
-    const closeBundle = plugin.closeBundle as () => Promise<void>;
-    await closeBundle();
-
-    expect(createServer).toHaveBeenCalledWith(
-      expect.objectContaining({
-        root: dir,
-        configFile: `${dir}/vite.config.ts`,
-        server: { middlewareMode: true, watch: null },
-        appType: "custom",
-        ssr: { external: true },
-        optimizeDeps: { noDiscovery: true, include: [] },
-      }),
-    );
-    // A single ssrLoadModule call reads both the default export and the
-    // named `routes` export — vite.config.ts never imports app source itself.
-    expect(ssrLoadModule).toHaveBeenCalledOnce();
-    expect(ssrLoadModule).toHaveBeenCalledWith("./src/app.tsx");
-    expect(close).toHaveBeenCalledOnce();
-
-    expect(prerender).toHaveBeenCalledWith(
-      expect.objectContaining({
-        root: RootComponent,
-        routes,
-        template: "<html><body><div id=\"app\"></div></body></html>",
-      }),
-    );
-
-    expect(await readFile(join(dir, "dist", "index.html"), "utf-8")).toBe("<html>home</html>");
-    expect(await readFile(join(dir, "dist", "about", "index.html"), "utf-8")).toBe("<html>about</html>");
-  });
-
-  it("throws a clear error when the root module has no default export", async () => {
-    dir = await mkdtemp(join(tmpdir(), "praxisjs-ssg-"));
-    await mkdir(join(dir, "dist"), { recursive: true });
-    await writeFile(join(dir, "dist", "index.html"), "<html><body><div id=\"app\"></div></body></html>");
-
-    ssrLoadModule.mockResolvedValue({ routes });
-
-    const plugin = ssgPlugin({ root: "./src/app.tsx" });
-    const configResolved = plugin.configResolved as (c: ResolvedConfig) => void | Promise<void>;
-    await configResolved(fakeResolvedConfig(dir));
-    const closeBundle = plugin.closeBundle as () => Promise<void>;
-
-    await expect(closeBundle()).rejects.toThrow(/no default export/);
-    expect(close).toHaveBeenCalledOnce(); // server is closed even on failure
-  });
-
-  it("throws a clear error when the root module has no named routes export", async () => {
-    dir = await mkdtemp(join(tmpdir(), "praxisjs-ssg-"));
-    await mkdir(join(dir, "dist"), { recursive: true });
-    await writeFile(join(dir, "dist", "index.html"), "<html><body><div id=\"app\"></div></body></html>");
-
-    ssrLoadModule.mockResolvedValue({ default: RootComponent });
-
-    const plugin = ssgPlugin({ root: "./src/app.tsx" });
-    const configResolved = plugin.configResolved as (c: ResolvedConfig) => void | Promise<void>;
-    await configResolved(fakeResolvedConfig(dir));
-    const closeBundle = plugin.closeBundle as () => Promise<void>;
-
-    await expect(closeBundle()).rejects.toThrow(/no named "routes" export/);
-    expect(close).toHaveBeenCalledOnce();
-  });
-
-  it("passes hydrate: false through to prerender()", async () => {
-    dir = await mkdtemp(join(tmpdir(), "praxisjs-ssg-"));
-    await mkdir(join(dir, "dist"), { recursive: true });
-    await writeFile(join(dir, "dist", "index.html"), "<html><body><div id=\"app\"></div></body></html>");
-
-    ssrLoadModule.mockResolvedValue({ default: RootComponent, routes });
-    vi.mocked(prerender).mockResolvedValue([{ path: "/", file: "index.html", html: "<html></html>" }]);
-
-    const plugin = ssgPlugin({ root: "./src/app.tsx", hydrate: false });
-    const configResolved = plugin.configResolved as (c: ResolvedConfig) => void | Promise<void>;
-    await configResolved(fakeResolvedConfig(dir));
-    const closeBundle = plugin.closeBundle as () => Promise<void>;
-    await closeBundle();
-
-    expect(prerender).toHaveBeenCalledWith(expect.objectContaining({ hydrate: false }));
-  });
-});

package/src/__tests__/prerender.test.ts

@@ -1,181 +0,0 @@
-// @vitest-environment jsdom
-import { describe, it, expect } from "vitest";
-
-import { StatefulComponent } from "@praxisjs/core";
-import { resource } from "@praxisjs/core/internal";
-import { Head } from "@praxisjs/head";
-import type { RouteDefinition, RouteLocation } from "@praxisjs/router";
-import { Location } from "@praxisjs/router";
-import { getCurrentScope, mountComponent, mountElement, render } from "@praxisjs/runtime";
-
-import { prerender, withDomGlobals } from "../prerender";
-
-const TEMPLATE =
-  '<!doctype html><html><head><title>App</title></head><body><div id="app"></div></body></html>';
-
-@Head((self) => ({ title: `Page: ${(self as Page).location().path}` }))
-class Page extends StatefulComponent {
-  static __isComponent = true as const;
-  static __isStateless = false;
-  @Location() location!: RouteLocation;
-
-  render() {
-    return mountElement("main", {
-      id: "root",
-      children: [
-        mountElement("h1", { children: `Path: ${this.location().path}` }, getCurrentScope()),
-        mountElement("button", { id: "btn", onClick: () => {}, children: "Click" }, getCurrentScope()),
-      ],
-    }, getCurrentScope());
-  }
-}
-
-class AsyncPage extends StatefulComponent {
-  static __isComponent = true as const;
-  static __isStateless = false;
-  data = resource(() => Promise.resolve("loaded content"));
-
-  render() {
-    return mountElement("p", { id: "data", children: () => this.data.data() ?? "pending" }, getCurrentScope());
-  }
-}
-
-describe("prerender()", () => {
-  it("renders each static route to its own page with the hydration marker", async () => {
-    const routes: RouteDefinition[] = [
-      { path: "/", component: Page as never },
-      { path: "/about", component: Page as never },
-    ];
-
-    const pages = await prerender({ root: Page as never, routes, template: TEMPLATE });
-
-    expect(pages.map((p) => p.path).sort()).toEqual(["/", "/about"]);
-    const home = pages.find((p) => p.path === "/")!;
-    expect(home.file).toBe("index.html");
-    expect(home.html).toContain("Path: /");
-    expect(home.html).toContain('data-praxis-ssg="1"');
-
-    const about = pages.find((p) => p.path === "/about")!;
-    expect(about.file).toBe("about/index.html");
-    expect(about.html).toContain("Path: /about");
-  });
-
-  it("omits the hydration marker when hydrate: false", async () => {
-    const routes: RouteDefinition[] = [{ path: "/", component: Page as never }];
-    const pages = await prerender({ root: Page as never, routes, template: TEMPLATE, hydrate: false });
-    expect(pages[0].html).not.toContain("data-praxis-ssg");
-  });
-
-  it("expands a dynamic route via getStaticPaths", async () => {
-    const routes: RouteDefinition[] = [{ path: "/blog/:slug", component: Page as never }];
-    const pages = await prerender({
-      root: Page as never,
-      routes,
-      template: TEMPLATE,
-      getStaticPaths: async () => ["/blog/hello", "/blog/world"],
-    });
-    expect(pages.map((p) => p.file).sort()).toEqual(["blog/hello/index.html", "blog/world/index.html"]);
-  });
-
-  it("waits for resource() data to settle before serializing", async () => {
-    const routes: RouteDefinition[] = [{ path: "/", component: AsyncPage as never }];
-    const pages = await prerender({ root: AsyncPage as never, routes, template: TEMPLATE });
-    expect(pages[0].html).toContain("loaded content");
-    expect(pages[0].html).not.toContain("pending");
-  });
-
-  it("sets per-route <title> via @Head and does not leak it across routes", async () => {
-    const routes: RouteDefinition[] = [
-      { path: "/", component: Page as never },
-      { path: "/about", component: Page as never },
-    ];
-    const pages = await prerender({ root: Page as never, routes, template: TEMPLATE });
-    const home = pages.find((p) => p.path === "/")!;
-    const about = pages.find((p) => p.path === "/about")!;
-    expect(home.html).toContain("<title>Page: /</title>");
-    expect(about.html).toContain("<title>Page: /about</title>");
-  });
-
-  it("does not leak globalThis.document/window back to the caller's environment", async () => {
-    const outer = document;
-    const routes: RouteDefinition[] = [{ path: "/", component: Page as never }];
-    await prerender({ root: Page as never, routes, template: TEMPLATE });
-    expect(globalThis.document).toBe(outer);
-  });
-
-  it("throws a clear error when the container selector is not found in the template", async () => {
-    const routes: RouteDefinition[] = [{ path: "/", component: Page as never }];
-    await expect(
-      prerender({ root: Page as never, routes, template: "<html><body></body></html>" }),
-    ).rejects.toThrow(/No element matching/);
-  });
-});
-
-describe("withDomGlobals", () => {
-  it("deletes a patched global on restore when it had no prior descriptor, and restores others that did", async () => {
-    const priorDescriptor = Object.getOwnPropertyDescriptor(globalThis, "Comment");
-    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- simulating a Node environment where this global never existed
-    delete (globalThis as Record<string, unknown>).Comment;
-
-    try {
-      let sawCommentDuring: unknown;
-      await withDomGlobals("<!doctype html><html><body></body></html>", "http://localhost/", async () => {
-        sawCommentDuring = globalThis.Comment;
-        // document existed before this call (vitest's jsdom environment) — restoreGlobals
-        // must put its original descriptor back, not delete it.
-        expect(globalThis.document).toBeDefined();
-      });
-
-      expect(sawCommentDuring).toBeDefined();
-      expect(Object.getOwnPropertyDescriptor(globalThis, "Comment")).toBeUndefined();
-      expect(globalThis.document).toBeDefined();
-    } finally {
-      if (priorDescriptor) Object.defineProperty(globalThis, "Comment", priorDescriptor);
-    }
-  });
-});
-
-describe("prerender() -> render() round trip", () => {
-  it("produces HTML the client can hydrate without recreating the adopted nodes", async () => {
-    const routes: RouteDefinition[] = [{ path: "/", component: Page as never }];
-    const pages = await prerender({ root: Page as never, routes, template: TEMPLATE });
-    const html = pages[0].html;
-
-    const parsed = new DOMParser().parseFromString(html, "text/html");
-    const appHTML = parsed.querySelector("#app")?.innerHTML ?? "";
-
-    const container = document.createElement("div");
-    container.innerHTML = appHTML;
-    container.setAttribute("data-praxis-ssg", "1");
-    document.body.appendChild(container);
-
-    const h1Before = container.querySelector("h1");
-    const btnBefore = container.querySelector("#btn");
-    expect(h1Before?.textContent).toBe("Path: /");
-
-    let clicks = 0;
-    class ClientPage extends StatefulComponent {
-      static __isComponent = true as const;
-      static __isStateless = false;
-      render() {
-        return mountElement("main", {
-          id: "root",
-          children: [
-            mountElement("h1", { children: "Path: /" }, getCurrentScope()),
-            mountElement("button", { id: "btn", onClick: () => { clicks++; }, children: "Click" }, getCurrentScope()),
-          ],
-        }, getCurrentScope());
-      }
-    }
-
-    render(() => mountComponent(ClientPage as never, {}, getCurrentScope()), container);
-
-    expect(container.querySelector("h1")).toBe(h1Before);
-    expect(container.querySelector("#btn")).toBe(btnBefore);
-
-    container.querySelector("#btn")?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
-    expect(clicks).toBe(1);
-
-    document.body.removeChild(container);
-  });
-});

package/src/__tests__/register-fallback.test.ts

@@ -1,23 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-// Simulates Node < 22.15, which has no module.registerHooks — registerLoaderHook()
-// must fall back to the older, off-thread module.register() API instead.
-const { register } = vi.hoisted(() => ({
-  register: vi.fn(),
-}));
-
-vi.mock("node:module", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("node:module")>();
-  return { ...actual, registerHooks: undefined, register };
-});
-
-describe("registerLoaderHook() fallback (no module.registerHooks)", () => {
-  it("registers the standalone loader-hook module via module.register()", async () => {
-    const { registerLoaderHook } = await import("../index");
-    registerLoaderHook();
-
-    expect(register).toHaveBeenCalledOnce();
-    const [specifier] = register.mock.calls[0] as [URL];
-    expect(specifier.href).toContain("loader-hook.js");
-  });
-});

package/src/__tests__/resolve-sync.test.ts

@@ -1,91 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-import type { ResolveFnOutput, ResolveHookContext } from "node:module";
-
-import { registerLoaderHook } from "../index";
-
-const { registerHooks } = vi.hoisted(() => ({
-  registerHooks: vi.fn(),
-}));
-
-vi.mock("node:module", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("node:module")>();
-  return { ...actual, registerHooks, register: vi.fn() };
-});
-
-const CONTEXT = {} as ResolveHookContext;
-
-function notFound(): never {
-  const err = new Error("not found") as Error & { code?: string };
-  err.code = "ERR_MODULE_NOT_FOUND";
-  throw err;
-}
-
-function ok(url: string): ResolveFnOutput {
-  return { url, shortCircuit: true } as ResolveFnOutput;
-}
-
-describe("resolveSync (registered via module.registerHooks())", () => {
-  registerLoaderHook();
-  const resolveSync = registerHooks.mock.calls[0][0].resolve as (
-    specifier: string,
-    context: ResolveHookContext,
-    nextResolve: (specifier: string, context?: Partial<ResolveHookContext>) => ResolveFnOutput,
-  ) => ResolveFnOutput;
-
-  it("registers exactly once via module.registerHooks()", () => {
-    expect(registerHooks).toHaveBeenCalledOnce();
-  });
-
-  it("returns nextResolve's result directly when it succeeds", () => {
-    const nextResolve = vi.fn(() => ok("file:///real.js"));
-    expect(resolveSync("./real", CONTEXT, nextResolve)).toEqual(ok("file:///real.js"));
-    expect(nextResolve).toHaveBeenCalledOnce();
-  });
-
-  it("rethrows without retrying for a bare (non-relative) specifier", () => {
-    const nextResolve = vi.fn(() => notFound());
-    expect(() => resolveSync("some-package", CONTEXT, nextResolve)).toThrow("not found");
-    expect(nextResolve).toHaveBeenCalledOnce();
-  });
-
-  it("rethrows without retrying when the error has no code", () => {
-    const nextResolve = vi.fn(() => {
-      throw new Error("weird failure");
-    });
-    expect(() => resolveSync("./router", CONTEXT, nextResolve)).toThrow("weird failure");
-    expect(nextResolve).toHaveBeenCalledOnce();
-  });
-
-  it("rethrows without retrying for a non-retryable error code", () => {
-    const nextResolve = vi.fn(() => {
-      const err = new Error("permission denied") as Error & { code?: string };
-      err.code = "EACCES";
-      throw err;
-    });
-    expect(() => resolveSync("./router", CONTEXT, nextResolve)).toThrow("permission denied");
-    expect(nextResolve).toHaveBeenCalledOnce();
-  });
-
-  it("retries with a .js suffix and returns it when that succeeds", () => {
-    const nextResolve = vi.fn((specifier: string) =>
-      specifier === "./router.js" ? ok("file:///router.js") : notFound(),
-    );
-    expect(resolveSync("./router", CONTEXT, nextResolve)).toEqual(ok("file:///router.js"));
-    expect(nextResolve).toHaveBeenCalledTimes(2);
-  });
-
-  it("falls back to /index.js when the .js candidate also fails", () => {
-    const nextResolve = vi.fn((specifier: string) =>
-      specifier === "./router/index.js" ? ok("file:///router/index.js") : notFound(),
-    );
-    expect(resolveSync("./router", CONTEXT, nextResolve)).toEqual(ok("file:///router/index.js"));
-    expect(nextResolve).toHaveBeenCalledTimes(3);
-  });
-
-  it("rethrows the original error when both retry candidates fail", () => {
-    const nextResolve = vi.fn(() => notFound());
-    expect(() => resolveSync("../router", CONTEXT, nextResolve)).toThrow("not found");
-    expect(nextResolve).toHaveBeenCalledTimes(3);
-  });
-});

package/src/__tests__/routes.test.ts

@@ -1,175 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import type { RouteDefinition } from "@praxisjs/router";
-
-import { flattenRoutes, isStaticPath, pathToOutputFile, resolvePaths } from "../routes";
-
-const Noop = class {} as never;
-
-describe("flattenRoutes", () => {
-  it("flattens a flat route list unchanged", () => {
-    const routes: RouteDefinition[] = [
-      { path: "/", component: Noop },
-      { path: "/about", component: Noop },
-    ];
-    expect(flattenRoutes(routes).map((r) => r.fullPath)).toEqual(["/", "/about"]);
-  });
-
-  it("prefixes nested children with the parent path", () => {
-    const routes: RouteDefinition[] = [
-      {
-        path: "/blog",
-        component: Noop,
-        children: [
-          { path: "/", component: Noop },
-          { path: "/:slug", component: Noop },
-        ],
-      },
-    ];
-    expect(flattenRoutes(routes).map((r) => r.fullPath)).toEqual(["/blog", "/blog/", "/blog/:slug"]);
-  });
-
-  it("treats a root parent's prefix as empty, matching RouterInstance.addRoute", () => {
-    const routes: RouteDefinition[] = [
-      {
-        path: "/",
-        component: Noop,
-        children: [{ path: "/dashboard", component: Noop }],
-      },
-    ];
-    expect(flattenRoutes(routes).map((r) => r.fullPath)).toEqual(["/", "/dashboard"]);
-  });
-});
-
-describe("isStaticPath", () => {
-  it("treats plain paths as static", () => {
-    expect(isStaticPath("/about")).toBe(true);
-    expect(isStaticPath("/")).toBe(true);
-  });
-
-  it("treats :param segments as dynamic", () => {
-    expect(isStaticPath("/blog/:slug")).toBe(false);
-  });
-
-  it("treats optional :param? segments as dynamic", () => {
-    expect(isStaticPath("/users/:id?")).toBe(false);
-  });
-
-  it("treats ** catch-alls as dynamic", () => {
-    expect(isStaticPath("/docs/**")).toBe(false);
-  });
-});
-
-describe("resolvePaths", () => {
-  it("returns static paths as-is", async () => {
-    const routes: RouteDefinition[] = [
-      { path: "/", component: Noop },
-      { path: "/about", component: Noop },
-    ];
-    expect(await resolvePaths({ routes })).toEqual(["/", "/about"]);
-  });
-
-  it("expands a dynamic route via getStaticPaths", async () => {
-    const routes: RouteDefinition[] = [{ path: "/blog/:slug", component: Noop }];
-    const paths = await resolvePaths({
-      routes,
-      getStaticPaths: async () => ["/blog/hello", "/blog/world"],
-    });
-    expect(paths).toEqual(["/blog/hello", "/blog/world"]);
-  });
-
-  it("skips dynamic routes with no getStaticPaths", async () => {
-    const routes: RouteDefinition[] = [
-      { path: "/", component: Noop },
-      { path: "/blog/:slug", component: Noop },
-    ];
-    expect(await resolvePaths({ routes })).toEqual(["/"]);
-  });
-
-  it("passes the route and its full path pattern to getStaticPaths", async () => {
-    const target: RouteDefinition = { path: "/blog/:slug", component: Noop };
-    const routes: RouteDefinition[] = [target];
-    let seen: [RouteDefinition, string] | undefined;
-    await resolvePaths({
-      routes,
-      getStaticPaths: async (route, fullPath) => {
-        seen = [route, fullPath];
-        return [];
-      },
-    });
-    expect(seen).toEqual([target, "/blog/:slug"]);
-  });
-
-  it("de-duplicates paths across routes", async () => {
-    const routes: RouteDefinition[] = [
-      { path: "/blog/:slug", component: Noop },
-      { path: "/other/:slug", component: Noop },
-    ];
-    const paths = await resolvePaths({
-      routes,
-      getStaticPaths: async () => ["/shared"],
-    });
-    expect(paths).toEqual(["/shared"]);
-  });
-
-  it("expands a dynamic route via its own colocated getStaticPaths, with no global fallback needed", async () => {
-    const routes: RouteDefinition[] = [
-      { path: "/blog/:slug", component: Noop, getStaticPaths: async () => ["/blog/hello", "/blog/world"] } as RouteDefinition,
-    ];
-    expect(await resolvePaths({ routes })).toEqual(["/blog/hello", "/blog/world"]);
-  });
-
-  it("passes the route's own full path to its colocated getStaticPaths", async () => {
-    let seen: string | undefined;
-    const routes: RouteDefinition[] = [
-      {
-        path: "/blog/:slug",
-        component: Noop,
-        getStaticPaths: async (fullPath: string) => {
-          seen = fullPath;
-          return [];
-        },
-      } as RouteDefinition,
-    ];
-    await resolvePaths({ routes });
-    expect(seen).toBe("/blog/:slug");
-  });
-
-  it("prefers a route's own getStaticPaths over the global fallback", async () => {
-    const routes: RouteDefinition[] = [
-      { path: "/blog/:slug", component: Noop, getStaticPaths: async () => ["/blog/own"] } as RouteDefinition,
-    ];
-    const paths = await resolvePaths({
-      routes,
-      getStaticPaths: async () => ["/blog/global"],
-    });
-    expect(paths).toEqual(["/blog/own"]);
-  });
-
-  it("falls back to the global getStaticPaths for routes with no colocated one, alongside routes that have their own", async () => {
-    const routes: RouteDefinition[] = [
-      { path: "/blog/:slug", component: Noop, getStaticPaths: async () => ["/blog/own"] } as RouteDefinition,
-      { path: "/other/:slug", component: Noop },
-    ];
-    const paths = await resolvePaths({
-      routes,
-      getStaticPaths: async (_route, fullPath) => (fullPath === "/other/:slug" ? ["/other/global"] : []),
-    });
-    expect(paths).toEqual(["/blog/own", "/other/global"]);
-  });
-});
-
-describe("pathToOutputFile", () => {
-  it("maps the root path to index.html", () => {
-    expect(pathToOutputFile("/")).toBe("index.html");
-  });
-
-  it("maps a nested path to <path>/index.html", () => {
-    expect(pathToOutputFile("/about")).toBe("about/index.html");
-    expect(pathToOutputFile("/blog/hello-world")).toBe("blog/hello-world/index.html");
-  });
-
-  it("normalizes surrounding slashes", () => {
-    expect(pathToOutputFile("/about/")).toBe("about/index.html");
-  });
-});

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "types": ["node"]
-  },
-  "include": ["src"]
-}