franksbooklog.com/astro.config.ts at main · fshowalter/franksbooklog.com · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
import type { AstroIntegration } from "astro";

import react from "@astrojs/react";
import sitemap from "@astrojs/sitemap";
import tailwindcss from "@tailwindcss/vite";
import compressor from "astro-compressor";
import { defineConfig } from "astro/config";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { createIndex } from "pagefind";
import sirv from "sirv";

function pagefind(): AstroIntegration {
  let outDir: string;
  let assets: null | string;

  return {
    hooks: {
      "astro:build:done": async ({ logger }) => {
        if (!outDir) {
          logger.warn(
            "astro-pagefind couldn't reliably determine the output directory. Search index will not be built.",
          );
          return;
        }

        const { errors: createErrors, index } = await createIndex({});
        if (!index) {
          logger.error("Pagefind failed to create index");
          for (const e of createErrors) logger.error(e);
          return;
        }
        const { errors: addErrors, page_count } = await index.addDirectory({
          path: outDir,
        });
        if (addErrors.length > 0) {
          logger.error("Pagefind failed to index files");
          for (const e of addErrors) logger.error(e);
          return;
        } else {
          logger.info(`Pagefind indexed ${page_count} pages`);
        }
        const { errors: writeErrors, outputPath } = await index.writeFiles({
          outputPath: path.join(outDir, "pagefind"),
        });
        if (writeErrors.length > 0) {
          logger.error("Pagefind failed to write index");
          for (const e of writeErrors) logger.error(e);
          return;
        } else {
          logger.info(`Pagefind wrote index to ${outputPath}`);
        }
      },
      "astro:config:setup": ({ config }) => {
        outDir = fileURLToPath(config.outDir);

        assets = config.build.assetsPrefix ? null : config.build.assets; //eslint-disable-line unicorn/no-null
      },
      "astro:server:setup": ({ logger, server }) => {
        if (!outDir) {
          logger.warn(
            "astro-pagefind couldn't reliably determine the output directory. Search assets will not be served.",
          );
          return;
        }
        const serve = sirv(outDir, {
          dev: true,
          etag: true,
        });
        server.middlewares.use((req, res, next) => {
          if (
            req.url?.startsWith("/pagefind/") ||
            (assets && req.url?.startsWith(`/${assets}/`))
          ) {
            serve(req, res, next);
          } else {
            next();
          }
        });
      },
    },
    name: "pagefind",
  };
}

// https://astro.build/config
export default defineConfig({
  build: {
    inlineStylesheets: "always",
  },
  devToolbar: {
    enabled: false,
  },
  image: {
    service: {
      config: {
        kernel: "mks2021",
      },
      entrypoint: "astro/assets/services/sharp",
    },
  },
  integrations: [
    react({
      babel: {
        plugins: process.env.TEST_COVERAGE
          ? []
          : [["babel-plugin-react-compiler"]],
      },
    }),
    sitemap({
      filter: (page) => page !== "https://www.franksbooklog.com/gone/",
    }),
    pagefind(),
    compressor(),
  ],
  site: "https://www.franksbooklog.com",
  trailingSlash: "always",
  vite: {
    optimizeDeps: {
      exclude: ["fsevents"],
    },
    plugins: [tailwindcss()],
  },
});