├── .github
    └── workflows
    │   ├── ci.yml
    │   └── release.yml
├── .gitignore
├── .npmignore
├── README.md
├── cli.js
├── client
    └── reload-client.js
├── cmd.js
├── package.json
├── server.js
├── server
    ├── ipAddress.js
    └── wrapResponse.js
└── test
    ├── sample
        └── test’s
        │   └── sample.txt
    ├── stubs
        ├── alternative
        │   └── test
        │   │   └── .gitkeep
        ├── custom-index.html
        ├── html-with-js.html
        ├── index.html
        ├── index.php
        ├── petite-vue.html
        ├── route space.html
        ├── route1
        │   ├── custom-index.html
        │   └── index.html
        ├── route2.html
        ├── route3.html
        ├── route3
        │   └── index.html
        ├── sample.html
        ├── with-css
        │   ├── index.html
        │   └── style.css
        ├── with-import-map.html
        └── zach’s.html
    ├── testServer.js
    └── testServerRequests.js


/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | name: Node Unit Tests
 2 | on:
 3 |   push:
 4 |     branches-ignore:
 5 |       - "gh-pages"
 6 | jobs:
 7 |   build:
 8 |     runs-on: ${{ matrix.os }}
 9 |     strategy:
10 |       matrix:
11 |         os: ["ubuntu-latest", "macos-latest", "windows-latest"]
12 |         node: ["18", "20", "22"]
13 |     name: Node.js ${{ matrix.node }} on ${{ matrix.os }}
14 |     steps:
15 |       - uses: actions/checkout@v4
16 |       - name: Setup node
17 |         uses: actions/setup-node@v4
18 |         with:
19 |           node-version: ${{ matrix.node }}
20 |           # cache: npm
21 |       - run: npm install
22 |       - run: npm test
23 | env:
24 |   YARN_GPG: no
25 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
 1 | name: Publish Release to npm
 2 | on:
 3 |   release:
 4 |     types: [published]
 5 | permissions: read-all
 6 | jobs:
 7 |   build:
 8 |     runs-on: ubuntu-latest
 9 |     permissions:
10 |       contents: read
11 |       id-token: write
12 |     steps:
13 |       - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # 4.1.7
14 |       - uses: actions/setup-node@1e60f620b9541d16bece96c5465dc8ee9832be0b # 4.0.3
15 |         with:
16 |           node-version: "20"
17 |           registry-url: 'https://registry.npmjs.org'
18 |       - run: npm install
19 |       - run: npm test
20 |       - if: ${{ github.event.release.tag_name != '' && env.NPM_PUBLISH_TAG != '' }}
21 |         run: npm publish --provenance --access=public --tag=${{ env.NPM_PUBLISH_TAG }}
22 |         env:
23 |           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
24 |           NPM_PUBLISH_TAG: ${{ contains(github.event.release.tag_name, '-beta.') && 'beta' || 'latest' }}
25 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | package-lock.json


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | test
2 | .*
3 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <p align="center"><img src="https://www.11ty.dev/img/logo-github.svg" width="200" height="200" alt="11ty Logo"></p>
 2 | 
 3 | # eleventy-dev-server 🕚⚡️🎈🐀
 4 | 
 5 | A minimal, modern, generic, hot-reloading local web server to help web developers.
 6 | 
 7 | ## ➡ [Documentation](https://www.11ty.dev/docs/watch-serve/#eleventy-dev-server)
 8 | 
 9 | - Please star [Eleventy on GitHub](https://github.com/11ty/eleventy/)!
10 | - Follow us on Twitter [@eleven_ty](https://twitter.com/eleven_ty)
11 | - Support [11ty on Open Collective](https://opencollective.com/11ty)
12 | - [11ty on npm](https://www.npmjs.com/org/11ty)
13 | - [11ty on GitHub](https://github.com/11ty)
14 | 
15 | [![npm Version](https://img.shields.io/npm/v/@11ty/eleventy-dev-server.svg?style=for-the-badge)](https://www.npmjs.com/package/@11ty/eleventy-dev-server)
16 | 
17 | ## Installation
18 | 
19 | This is bundled with `@11ty/eleventy` (and you do not need to install it separately) in Eleventy v2.0.
20 | 
21 | ## CLI
22 | 
23 | Eleventy Dev Server now also includes a CLI. The CLI is for **standalone** (non-Eleventy) use only: separate installation is unnecessary if you’re using this server with `@11ty/eleventy`.
24 | 
25 | ```sh
26 | npm install -g @11ty/eleventy-dev-server
27 | 
28 | # Alternatively, install locally into your project
29 | npm install @11ty/eleventy-dev-server
30 | ```
31 | 
32 | This package requires Node 18 or newer.
33 | 
34 | ### CLI Usage
35 | 
36 | ```sh
37 | # Serve the current directory
38 | npx @11ty/eleventy-dev-server
39 | 
40 | # Serve a different subdirectory (also aliased as --input)
41 | npx @11ty/eleventy-dev-server --dir=_site
42 | 
43 | # Disable the `domdiff` feature
44 | npx @11ty/eleventy-dev-server --domdiff=false
45 | 
46 | # Full command list in the Help
47 | npx @11ty/eleventy-dev-server --help
48 | ```
49 | 
50 | ## Tests
51 | 
52 | ```
53 | npm run test
54 | ```
55 | 
56 | - We use the [ava JavaScript test runner](https://github.com/avajs/ava) ([Assertions documentation](https://github.com/avajs/ava/blob/master/docs/03-assertions.md))
57 | 
58 | ## Changelog
59 | 
60 | * `v2.0.0` bumps Node.js minimum to 18.


--------------------------------------------------------------------------------
/cli.js:
--------------------------------------------------------------------------------
 1 | const pkg = require("./package.json");
 2 | const EleventyDevServer = require("./server.js");
 3 | 
 4 | const Logger = {
 5 |   info: function(...args) {
 6 |     console.log( "[11ty/eleventy-dev-server]", ...args );
 7 |   },
 8 |   error: function(...args) {
 9 |     console.error( "[11ty/eleventy-dev-server]", ...args );
10 |   },
11 |   fatal: function(...args) {
12 |     Logger.error(...args);
13 |     process.exitCode = 1;
14 |   }
15 | };
16 | 
17 | Logger.log = Logger.info;
18 | 
19 | class Cli {
20 |   static getVersion() {
21 |     return pkg.version;
22 |   }
23 | 
24 |   static getHelp() {
25 |     return `Usage:
26 | 
27 |        eleventy-dev-server
28 |        eleventy-dev-server --dir=_site
29 |        eleventy-dev-server --port=3000
30 | 
31 | Arguments:
32 | 
33 |      --version
34 | 
35 |      --dir=.
36 |        Directory to serve (default: \`.\`)
37 | 
38 |      --input (alias for --dir)
39 | 
40 |      --port=8080
41 |        Run the web server on this port (default: \`8080\`)
42 |        Will autoincrement if already in use.
43 | 
44 |      --domdiff          (enabled, default)
45 |      --domdiff=false    (disabled)
46 |        Apply HTML changes without a full page reload.
47 | 
48 |      --help`;
49 |   }
50 | 
51 |   static getDefaultOptions() {
52 |     return {
53 |       port: "8080",
54 |       input: ".",
55 |       domDiff: true,
56 |     }
57 |   }
58 | 
59 |   async serve(options = {}) {
60 |     this.options = Object.assign(Cli.getDefaultOptions(), options);
61 | 
62 |     this.server = EleventyDevServer.getServer("eleventy-dev-server-cli", this.options.input, {
63 |       // TODO allow server configuration extensions
64 |       showVersion: true,
65 |       logger: Logger,
66 |       domDiff: this.options.domDiff,
67 | 
68 |       // CLI watches all files in the folder by default
69 |       // this is different from Eleventy usage!
70 |       watch: [ this.options.input ],
71 |     });
72 | 
73 |     this.server.serve(this.options.port);
74 | 
75 |     // TODO? send any errors here to the server too
76 |     // with server.sendError({ error });
77 |   }
78 | 
79 |   close() {
80 |     if(this.server) {
81 |       return this.server.close();
82 |     }
83 |   }
84 | }
85 | 
86 | module.exports = {
87 |   Logger,
88 |   Cli
89 | }
90 | 


--------------------------------------------------------------------------------
/client/reload-client.js:
--------------------------------------------------------------------------------
  1 | class Util {
  2 |   static pad(num, digits = 2) {
  3 |     let zeroes = new Array(digits + 1).join(0);
  4 |     return `${zeroes}${num}`.slice(-1 * digits);
  5 |   }
  6 | 
  7 |   static log(message) {
  8 |     Util.output("log", message);
  9 |   }
 10 |   static error(message, error) {
 11 |     Util.output("error", message, error);
 12 |   }
 13 |   static output(type, ...messages) {
 14 |     let now = new Date();
 15 |     let date = `${Util.pad(now.getUTCHours())}:${Util.pad(
 16 |       now.getUTCMinutes()
 17 |     )}:${Util.pad(now.getUTCSeconds())}.${Util.pad(
 18 |       now.getUTCMilliseconds(),
 19 |       3
 20 |     )}`;
 21 |     console[type](`[11ty][${date} UTC]`, ...messages);
 22 |   }
 23 | 
 24 |   static capitalize(word) {
 25 |     return word.substr(0, 1).toUpperCase() + word.substr(1);
 26 |   }
 27 | 
 28 |   static matchRootAttributes(htmlContent) {
 29 |     // Workaround for morphdom bug with attributes on <html> https://github.com/11ty/eleventy-dev-server/issues/6
 30 |     // Note also `childrenOnly: true` above
 31 |     const parser = new DOMParser();
 32 |     let parsed = parser.parseFromString(htmlContent, "text/html");
 33 |     let parsedDoc = parsed.documentElement;
 34 |     let newAttrs = parsedDoc.getAttributeNames();
 35 | 
 36 |     let docEl = document.documentElement;
 37 |     // Remove old
 38 |     let removedAttrs = docEl.getAttributeNames().filter(name => !newAttrs.includes(name));
 39 |     for(let attr of removedAttrs) {
 40 |       docEl.removeAttribute(attr);
 41 |     }
 42 | 
 43 |     // Add new
 44 |     for(let attr of newAttrs) {
 45 |       docEl.setAttribute(attr, parsedDoc.getAttribute(attr));
 46 |     }
 47 |   }
 48 | 
 49 |   static isEleventyLinkNodeMatch(from, to) {
 50 |     // Issue #18 https://github.com/11ty/eleventy-dev-server/issues/18
 51 |     // Don’t update a <link> if the _11ty searchParam is the only thing that’s different
 52 |     if(from.tagName !== "LINK" || to.tagName !== "LINK") {
 53 |       return false;
 54 |     }
 55 | 
 56 |     let oldWithoutHref = from.cloneNode();
 57 |     let newWithoutHref = to.cloneNode();
 58 | 
 59 |     oldWithoutHref.removeAttribute("href");
 60 |     newWithoutHref.removeAttribute("href");
 61 | 
 62 |     // if all other attributes besides href match
 63 |     if(!oldWithoutHref.isEqualNode(newWithoutHref)) {
 64 |       return false;
 65 |     }
 66 | 
 67 |     let oldUrl = new URL(from.href);
 68 |     let newUrl = new URL(to.href);
 69 | 
 70 |     // morphdom wants to force href="style.css?_11ty" => href="style.css"
 71 |     let paramName = EleventyReload.QUERY_PARAM;
 72 |     let isErasing = oldUrl.searchParams.has(paramName) && !newUrl.searchParams.has(paramName);
 73 |     if(!isErasing) {
 74 |       // not a match if _11ty has a new value (not being erased)
 75 |       return false;
 76 |     }
 77 | 
 78 |     oldUrl.searchParams.set(paramName, "");
 79 |     newUrl.searchParams.set(paramName, "");
 80 | 
 81 |     // is a match if erasing and the rest of the href matches too
 82 |     return oldUrl.toString() === newUrl.toString();
 83 |   }
 84 | 
 85 |   // https://github.com/patrick-steele-idem/morphdom/issues/178#issuecomment-652562769
 86 |   static runScript(source, target) {
 87 |     let script = document.createElement('script');
 88 | 
 89 |     // copy over the attributes
 90 |     for(let attr of [...source.attributes]) {
 91 |       script.setAttribute(attr.nodeName ,attr.nodeValue);
 92 |     }
 93 | 
 94 |     script.innerHTML = source.innerHTML;
 95 |     (target || source).replaceWith(script);
 96 |   }
 97 | 
 98 |   static fullPageReload() {
 99 |     Util.log(`Page reload initiated.`);
100 |     window.location.reload();
101 |   }
102 | }
103 | 
104 | class EleventyReload {
105 |   static QUERY_PARAM = "_11ty";
106 | 
107 |   static reloadTypes = {
108 |     css: (files, build = {}) => {
109 |       // Initiate a full page refresh if a CSS change is made but does match any stylesheet url
110 |       // `build.stylesheets` available in Eleventy v3.0.1-alpha.5+
111 |       if(Array.isArray(build.stylesheets)) {
112 |         let match = false;
113 |         for (let link of document.querySelectorAll(`link[rel="stylesheet"]`)) {
114 |           if (link.href) {
115 |             let url = new URL(link.href);
116 |             if(build.stylesheets.includes(url.pathname)) {
117 |               match = true;
118 |             }
119 |           }
120 |         }
121 | 
122 |         if(!match) {
123 |           Util.fullPageReload();
124 |           return;
125 |         }
126 |       }
127 | 
128 |       for (let link of document.querySelectorAll(`link[rel="stylesheet"]`)) {
129 |         if (link.href) {
130 |           let url = new URL(link.href);
131 |           url.searchParams.set(this.QUERY_PARAM, Date.now());
132 |           link.href = url.toString();
133 |         }
134 |       }
135 | 
136 |       Util.log(`CSS updated without page reload.`);
137 |     },
138 |     default: async (files, build = {}) => {
139 |       let morphed = false;
140 |       let domdiffTemplates = (build?.templates || []).filter(({url, inputPath}) => {
141 |         return url === document.location.pathname && (files || []).includes(inputPath);
142 |       });
143 | 
144 |       if(domdiffTemplates.length === 0) {
145 |         Util.fullPageReload();
146 |         return;
147 |       }
148 | 
149 |       try {
150 |         // Important: using `./` allows the `.11ty` folder name to be changed
151 |         const { default: morphdom } = await import(`./morphdom.js`);
152 | 
153 |         for (let {url, inputPath, content} of domdiffTemplates) {
154 |           // Notable limitation: this won’t re-run script elements or JavaScript page lifecycle events (load/DOMContentLoaded)
155 |           morphed = true;
156 | 
157 |           morphdom(document.documentElement, content, {
158 |             childrenOnly: true,
159 |             onBeforeElUpdated: function (fromEl, toEl) {
160 |               if (fromEl.nodeName === "SCRIPT" && toEl.nodeName === "SCRIPT") {
161 |                 if(toEl.innerHTML !== fromEl.innerHTML) {
162 |                   Util.log(`JavaScript modified, reload initiated.`);
163 |                   window.location.reload();
164 |                 }
165 | 
166 |                 return false;
167 |               }
168 | 
169 |               // Speed-up trick from morphdom docs
170 |               // https://dom.spec.whatwg.org/#concept-node-equals
171 |               if (fromEl.isEqualNode(toEl)) {
172 |                 return false;
173 |               }
174 | 
175 |               if(Util.isEleventyLinkNodeMatch(fromEl, toEl)) {
176 |                 return false;
177 |               }
178 | 
179 |               return true;
180 |             },
181 |             addChild: function(parent, child) {
182 |               // Declarative Shadow DOM https://github.com/11ty/eleventy-dev-server/issues/90
183 |               if(child.nodeName === "TEMPLATE" && child.hasAttribute("shadowrootmode")) {
184 |                 let root = parent.shadowRoot;
185 |                 if(root) {
186 |                   // remove all shadow root children
187 |                   while(root.firstChild) {
188 |                     root.removeChild(root.firstChild);
189 |                   }
190 |                 }
191 |                 for(let newChild of child.content.childNodes) {
192 |                   root.appendChild(newChild);
193 |                 }
194 |               } else {
195 |                 parent.appendChild(child);
196 |               }
197 |             },
198 |             onNodeAdded: function (node) {
199 |               if (node.nodeName === 'SCRIPT') {
200 |                 Util.log(`JavaScript added, reload initiated.`);
201 |                 window.location.reload();
202 |               }
203 |             },
204 |             onElUpdated: function(node) {
205 |               // Re-attach custom elements
206 |               if(customElements.get(node.tagName.toLowerCase())) {
207 |                 let placeholder = document.createElement("div");
208 |                 node.replaceWith(placeholder);
209 |                 requestAnimationFrame(() => {
210 |                   placeholder.replaceWith(node);
211 |                   placeholder = undefined;
212 |                 });
213 |               }
214 |             }
215 |           });
216 | 
217 |           Util.matchRootAttributes(content);
218 |           Util.log(`HTML delta applied without page reload.`);
219 |         }
220 |       } catch(e) {
221 |         Util.error( "Morphdom error", e );
222 |       }
223 | 
224 |       if (!morphed) {
225 |         Util.fullPageReload();
226 |       }
227 |     }
228 |   }
229 | 
230 |   constructor() {
231 |     this.connectionMessageShown = false;
232 |     this.reconnectEventCallback = this.reconnect.bind(this);
233 |   }
234 | 
235 |   init(options = {}) {
236 |     if (!("WebSocket" in window)) {
237 |       return;
238 |     }
239 | 
240 |     let documentUrl = new URL(document.location.href);
241 | 
242 |     let reloadPort = new URL(import.meta.url).searchParams.get("reloadPort");
243 |     if(reloadPort) {
244 |       documentUrl.port = reloadPort;
245 |     }
246 | 
247 |     let { protocol, host } = documentUrl;
248 | 
249 |     // works with http (ws) and https (wss)
250 |     let websocketProtocol = protocol.replace("http", "ws");
251 | 
252 |     let socket = new WebSocket(`${websocketProtocol}//${host}`);
253 | 
254 |     socket.addEventListener("message", async (event) => {
255 |       try {
256 |         let data = JSON.parse(event.data);
257 |         // Util.log( JSON.stringify(data, null, 2) );
258 | 
259 |         let { type } = data;
260 | 
261 |         if (type === "eleventy.reload") {
262 |           await this.onreload(data);
263 |         } else if (type === "eleventy.msg") {
264 |           Util.log(`${data.message}`);
265 |         } else if (type === "eleventy.error") {
266 |           // Log Eleventy build errors
267 |           // Extra parsing for Node Error objects
268 |           let e = JSON.parse(data.error);
269 |           Util.error(`Build error: ${e.message}`, e);
270 |         } else if (type === "eleventy.status") {
271 |           // Full page reload on initial reconnect
272 |           if (data.status === "connected" && options.mode === "reconnect") {
273 |             window.location.reload();
274 |           }
275 | 
276 |           if(data.status === "connected") {
277 |             // With multiple windows, only show one connection message
278 |             if(!this.isConnected) {
279 |               Util.log(Util.capitalize(data.status));
280 |             }
281 | 
282 |             this.connectionMessageShown = true;
283 |           } else {
284 |             if(data.status === "disconnected") {
285 |               this.addReconnectListeners();
286 |             }
287 | 
288 |             Util.log(Util.capitalize(data.status));
289 |           }
290 |         } else {
291 |           Util.log("Unknown event type", data);
292 |         }
293 |       } catch (e) {
294 |         Util.error(`Error parsing ${event.data}: ${e.message}`, e);
295 |       }
296 |     });
297 | 
298 |     socket.addEventListener("open", () => {
299 |       // no reconnection when the connect is already open
300 |       this.removeReconnectListeners();
301 |     });
302 | 
303 |     socket.addEventListener("close", () => {
304 |       this.connectionMessageShown = false;
305 |       this.addReconnectListeners();
306 |     });
307 |   }
308 | 
309 |   reconnect() {
310 |     Util.log( "Reconnecting…" );
311 |     this.init({ mode: "reconnect" });
312 |   }
313 | 
314 |   async onreload({ subtype, files, build }) {
315 |     if(!EleventyReload.reloadTypes[subtype]) {
316 |       subtype = "default";
317 |     }
318 | 
319 |     await EleventyReload.reloadTypes[subtype](files, build);
320 |   }
321 | 
322 |   addReconnectListeners() {
323 |     this.removeReconnectListeners();
324 | 
325 |     window.addEventListener("focus", this.reconnectEventCallback);
326 |     window.addEventListener("visibilitychange", this.reconnectEventCallback);
327 |   }
328 | 
329 |   removeReconnectListeners() {
330 |     window.removeEventListener("focus", this.reconnectEventCallback);
331 |     window.removeEventListener("visibilitychange", this.reconnectEventCallback);
332 |   }
333 | }
334 | 
335 | let reloader = new EleventyReload();
336 | reloader.init();


--------------------------------------------------------------------------------
/cmd.js:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | 
 3 | const pkg = require("./package.json");
 4 | 
 5 | // Node check
 6 | require("please-upgrade-node")(pkg, {
 7 |   message: function (requiredVersion) {
 8 |     return (
 9 |       "eleventy-dev-server requires Node " +
10 |       requiredVersion +
11 |       ". You will need to upgrade Node!"
12 |     );
13 |   },
14 | });
15 | 
16 | const { Logger, Cli } = require("./cli.js");
17 | 
18 | const debug = require("debug")("Eleventy:DevServer");
19 | 
20 | try {
21 |   const defaults = Cli.getDefaultOptions();
22 |   for(let key in defaults) {
23 |     if(key.toLowerCase() !== key) {
24 |       defaults[key.toLowerCase()] = defaults[key];
25 |       delete defaults[key];
26 |     }
27 |   }
28 | 
29 |   const argv = require("minimist")(process.argv.slice(2), {
30 |     string: [
31 |       "dir",
32 |       "input", // alias for dir
33 |       "port",
34 |     ],
35 |     boolean: [
36 |       "version",
37 |       "help",
38 |       "domdiff",
39 |     ],
40 |     default: defaults,
41 |     unknown: function (unknownArgument) {
42 |       throw new Error(
43 |         `We don’t know what '${unknownArgument}' is. Use --help to see the list of supported commands.`
44 |       );
45 |     },
46 |   });
47 | 
48 |   debug("command: eleventy-dev-server %o", argv);
49 | 
50 |   process.on("unhandledRejection", (error, promise) => {
51 |     Logger.fatal("Unhandled rejection in promise:", promise, error);
52 |   });
53 |   process.on("uncaughtException", (error) => {
54 |     Logger.fatal("Uncaught exception:", error);
55 |   });
56 | 
57 |   if (argv.version) {
58 |     console.log(Cli.getVersion());
59 |   } else if (argv.help) {
60 |     console.log(Cli.getHelp());
61 |   } else {
62 |     let cli = new Cli();
63 | 
64 |     cli.serve({
65 |       input: argv.dir || argv.input,
66 |       port: argv.port,
67 |       domDiff: argv.domdiff,
68 |     });
69 | 
70 |     process.on("SIGINT", async () => {
71 |       await cli.close();
72 |       process.exitCode = 0;
73 |     });
74 |   }
75 | } catch (e) {
76 |   Logger.fatal("Fatal Error:", e)
77 | }
78 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@11ty/eleventy-dev-server",
 3 |   "version": "2.0.8",
 4 |   "description": "A minimal, modern, generic, hot-reloading local web server to help web developers.",
 5 |   "main": "server.js",
 6 |   "scripts": {
 7 |     "test": "npx ava --verbose",
 8 |     "sample": "node cmd.js --input=test/stubs"
 9 |   },
10 |   "license": "MIT",
11 |   "engines": {
12 |     "node": ">=18"
13 |   },
14 |   "funding": {
15 |     "type": "opencollective",
16 |     "url": "https://opencollective.com/11ty"
17 |   },
18 |   "bin": {
19 |     "eleventy-dev-server": "./cmd.js"
20 |   },
21 |   "keywords": [
22 |     "eleventy",
23 |     "server",
24 |     "cli"
25 |   ],
26 |   "publishConfig": {
27 |     "access": "public"
28 |   },
29 |   "author": {
30 |     "name": "Zach Leatherman",
31 |     "email": "zachleatherman@gmail.com",
32 |     "url": "https://zachleat.com/"
33 |   },
34 |   "repository": {
35 |     "type": "git",
36 |     "url": "git://github.com/11ty/eleventy-dev-server.git"
37 |   },
38 |   "bugs": "https://github.com/11ty/eleventy-dev-server/issues",
39 |   "homepage": "https://github.com/11ty/eleventy-dev-server/",
40 |   "dependencies": {
41 |     "@11ty/eleventy-utils": "^2.0.1",
42 |     "chokidar": "^3.6.0",
43 |     "debug": "^4.4.0",
44 |     "finalhandler": "^1.3.1",
45 |     "mime": "^3.0.0",
46 |     "minimist": "^1.2.8",
47 |     "morphdom": "^2.7.4",
48 |     "please-upgrade-node": "^3.2.0",
49 |     "send": "^1.1.0",
50 |     "ssri": "^11.0.0",
51 |     "urlpattern-polyfill": "^10.0.0",
52 |     "ws": "^8.18.1"
53 |   },
54 |   "devDependencies": {
55 |     "ava": "^6.2.0"
56 |   }
57 | }
58 | 


--------------------------------------------------------------------------------
/server.js:
--------------------------------------------------------------------------------
   1 | const path = require("node:path");
   2 | const fs = require("node:fs");
   3 | 
   4 | const finalhandler = require("finalhandler");
   5 | const WebSocket = require("ws");
   6 | const { WebSocketServer } = WebSocket;
   7 | const mime = require("mime");
   8 | const ssri = require("ssri");
   9 | const send = require("send");
  10 | const chokidar = require("chokidar");
  11 | const { TemplatePath, isPlainObject } = require("@11ty/eleventy-utils");
  12 | 
  13 | const debug = require("debug")("Eleventy:DevServer");
  14 | 
  15 | const pkg = require("./package.json");
  16 | const wrapResponse = require("./server/wrapResponse.js");
  17 | const ipAddress = require("./server/ipAddress.js");
  18 | 
  19 | if (!globalThis.URLPattern) {
  20 |   require("urlpattern-polyfill");
  21 | }
  22 | 
  23 | const DEFAULT_OPTIONS = {
  24 |   port: 8080,
  25 |   reloadPort: false,    // Falsy uses same as `port`
  26 |   liveReload: true,     // Enable live reload at all
  27 |   showAllHosts: false,  // IP address based hosts (other than localhost)
  28 |   injectedScriptsFolder: ".11ty", // Change the name of the special folder used for injected scripts
  29 |   portReassignmentRetryCount: 10, // number of times to increment the port if in use
  30 |   https: {},            // `key` and `cert`, required for http/2 and https
  31 |   domDiff: true,        // Use morphdom to apply DOM diffing delta updates to HTML
  32 |   showVersion: false,   // Whether or not to show the server version on the command line.
  33 |   encoding: "utf-8",    // Default file encoding
  34 |   pathPrefix: "/",      // May be overridden by Eleventy, adds a virtual base directory to your project
  35 |   watch: [],            // Globs to pass to separate dev server chokidar for watching
  36 |   aliases: {},          // Aliasing feature
  37 |   indexFileName: "index.html", // Allow custom index file name
  38 |   useCache: false,      // Use a cache for file contents
  39 |   headers: {},          // Set default response headers
  40 |   messageOnStart: ({ hosts, startupTime, version, options }) => {
  41 |     let hostsStr = " started";
  42 |     if(Array.isArray(hosts) && hosts.length > 0) {
  43 |       // TODO what happens when the cert doesn’t cover non-localhost hosts?
  44 |       hostsStr = ` at ${hosts.join(" or ")}`;
  45 |     }
  46 | 
  47 |     return `Server${hostsStr}${options.showVersion ? ` (v${version})` : ""}`;
  48 |   },
  49 | 
  50 |   onRequest: {},        // Maps URLPatterns to dynamic callback functions that run on a request from a client.
  51 | 
  52 |   // Example:
  53 |   // "/foo/:name": function({ url, pattern, patternGroups }) {
  54 |   //   return {
  55 |   //     headers: {
  56 |   //       "Content-Type": "text/html",
  57 |   //     },
  58 |   //     body: `${url} ${JSON.stringify(patternGroups)}`
  59 |   //   }
  60 |   // }
  61 | 
  62 |   // Logger (fancier one is injected by Eleventy)
  63 |   logger: {
  64 |     info: console.log,
  65 |     log: console.log,
  66 |     error: console.error,
  67 |   }
  68 | }
  69 | 
  70 | class EleventyDevServer {
  71 |   #watcher;
  72 |   #serverClosing;
  73 |   #serverState;
  74 |   #readyPromise;
  75 |   #readyResolve;
  76 | 
  77 |   static getServer(...args) {
  78 |     return new EleventyDevServer(...args);
  79 |   }
  80 | 
  81 |   constructor(name, dir, options = {}) {
  82 |     debug("Creating new Dev Server instance.")
  83 |     this.name = name;
  84 |     this.normalizeOptions(options);
  85 | 
  86 |     this.fileCache = {};
  87 |     // Directory to serve
  88 |     if(!dir) {
  89 |       throw new Error("Missing `dir` to serve.");
  90 |     }
  91 |     this.dir = dir;
  92 |     this.logger = this.options.logger;
  93 |     this.getWatcher();
  94 | 
  95 |     this.#readyPromise = new Promise((resolve) => {
  96 |       this.#readyResolve = resolve;
  97 |     })
  98 |   }
  99 | 
 100 |   normalizeOptions(options = {}) {
 101 |     this.options = Object.assign({}, DEFAULT_OPTIONS, options);
 102 | 
 103 |     // better names for options https://github.com/11ty/eleventy-dev-server/issues/41
 104 |     if(options.folder !== undefined) {
 105 |       this.options.injectedScriptsFolder = options.folder;
 106 |       delete this.options.folder;
 107 |     }
 108 |     if(options.domdiff !== undefined) {
 109 |       this.options.domDiff = options.domdiff;
 110 |       delete this.options.domdiff;
 111 |     }
 112 |     if(options.enabled !== undefined) {
 113 |       this.options.liveReload = options.enabled;
 114 |       delete this.options.enabled;
 115 |     }
 116 | 
 117 |     this.options.pathPrefix = this.cleanupPathPrefix(this.options.pathPrefix);
 118 |   }
 119 | 
 120 |   get watcher() {
 121 |     if(this.#watcher) {
 122 |       return this.#watcher;
 123 |     }
 124 | 
 125 |     debug("Watching %O", this.options.watch);
 126 |     // TODO if using Eleventy and `watch` option includes output folder (_site) this will trigger two update events!
 127 |     this.#watcher = chokidar.watch(this.options.watch, {
 128 |       // TODO allow chokidar configuration extensions (or re-use the ones in Eleventy)
 129 | 
 130 |       ignored: ["**/node_modules/**", ".git"],
 131 |       ignoreInitial: true,
 132 | 
 133 |       // same values as Eleventy
 134 |       awaitWriteFinish: {
 135 |         stabilityThreshold: 150,
 136 |         pollInterval: 25,
 137 |       },
 138 |     });
 139 | 
 140 |     this.#watcher.on("change", (path) => {
 141 |       this.logger.log( `File changed: ${path} (skips build)` );
 142 |       this.reloadFiles([path]);
 143 |     });
 144 | 
 145 |     this.#watcher.on("add", (path) => {
 146 |       this.logger.log( `File added: ${path} (skips build)` );
 147 |       this.reloadFiles([path]);
 148 |     });
 149 | 
 150 |     return this.#watcher;
 151 |   }
 152 | 
 153 |   getWatcher() {
 154 |     // only initialize watcher if watcher via getWatcher if has targets
 155 |     // this.watcher in watchFiles() is a manual workaround
 156 |     if(this.options.watch.length > 0) {
 157 |       return this.watcher;
 158 |     }
 159 |   }
 160 | 
 161 |   watchFiles(files) {
 162 |     if(Array.isArray(files) && files.length > 0) {
 163 |       files = files.map(entry => TemplatePath.stripLeadingDotSlash(entry));
 164 | 
 165 |       debug("Also watching %O", files);
 166 |       this.watcher.add(files);
 167 |     }
 168 |   }
 169 | 
 170 |   cleanupPathPrefix(pathPrefix) {
 171 |     if(!pathPrefix || pathPrefix === "/") {
 172 |       return "/";
 173 |     }
 174 |     if(!pathPrefix.startsWith("/")) {
 175 |       pathPrefix = `/${pathPrefix}`
 176 |     }
 177 |     if(!pathPrefix.endsWith("/")) {
 178 |       pathPrefix = `${pathPrefix}/`;
 179 |     }
 180 |     return pathPrefix;
 181 |   }
 182 | 
 183 |   // Allowed list of files that can be served from outside `dir`
 184 |   setAliases(aliases) {
 185 |     if(aliases) {
 186 |       this.passthroughAliases = aliases;
 187 |       debug( "Setting aliases (emulated passthrough copy) %O", aliases );
 188 |     }
 189 |   }
 190 | 
 191 |   matchPassthroughAlias(url) {
 192 |     let aliases = Object.assign({}, this.options.aliases, this.passthroughAliases);
 193 |     for(let targetUrl in aliases) {
 194 |       if(!targetUrl) {
 195 |         continue;
 196 |       }
 197 | 
 198 |       let file = aliases[targetUrl];
 199 |       if(url.startsWith(targetUrl)) {
 200 |         let inputDirectoryPath = file + url.slice(targetUrl.length);
 201 | 
 202 |         // e.g. addPassthroughCopy("img/") but <img src="/img/built/IdthKOzqFA-350.png">
 203 |         // generated by the image plugin (written to the output folder)
 204 |         // If they do not exist in the input directory, this will fallback to the output directory.
 205 |         if(fs.existsSync(inputDirectoryPath)) {
 206 |           return inputDirectoryPath;
 207 |         }
 208 |       }
 209 |     }
 210 |     return false;
 211 |   }
 212 | 
 213 |   isFileInDirectory(dir, file) {
 214 |     let absoluteDir = TemplatePath.absolutePath(dir);
 215 |     let absoluteFile = TemplatePath.absolutePath(file);
 216 |     return absoluteFile.startsWith(absoluteDir);
 217 |   }
 218 | 
 219 |   getOutputDirFilePath(filepath, filename = "") {
 220 |     let computedPath;
 221 |     if(filename === ".html") {
 222 |       // avoid trailing slash for filepath/.html requests
 223 |       let prefix = path.join(this.dir, filepath);
 224 |       if(prefix.endsWith(path.sep)) {
 225 |         prefix = prefix.substring(0, prefix.length - path.sep.length);
 226 |       }
 227 |       computedPath = prefix + filename;
 228 |     } else {
 229 |       computedPath = path.join(this.dir, filepath, filename);
 230 |     }
 231 | 
 232 |     computedPath = decodeURIComponent(computedPath);
 233 | 
 234 |     if(!filename) { // is a direct URL request (not an implicit .html or index.html add)
 235 |       let alias = this.matchPassthroughAlias(filepath);
 236 | 
 237 |       if(alias) {
 238 |         if(!this.isFileInDirectory(path.resolve("."), alias)) {
 239 |           throw new Error("Invalid path");
 240 |         }
 241 | 
 242 |         return alias;
 243 |       }
 244 |     }
 245 | 
 246 |     // Check that the file is in the output path (error if folks try use `..` in the filepath)
 247 |     if(!this.isFileInDirectory(this.dir, computedPath)) {
 248 |       throw new Error("Invalid path");
 249 |     }
 250 | 
 251 |     return computedPath;
 252 |   }
 253 | 
 254 |   isOutputFilePathExists(rawPath) {
 255 |     return fs.existsSync(rawPath) && !TemplatePath.isDirectorySync(rawPath);
 256 |   }
 257 | 
 258 |   /* Use conventions documented here https://www.zachleat.com/web/trailing-slash/
 259 |    * resource.html exists:
 260 |    *    /resource matches
 261 |    *    /resource/ redirects to /resource
 262 |    * resource/index.html exists:
 263 |    *    /resource redirects to /resource/
 264 |    *    /resource/ matches
 265 |    * both resource.html and resource/index.html exists:
 266 |    *    /resource matches /resource.html
 267 |    *    /resource/ matches /resource/index.html
 268 |    */
 269 |   mapUrlToFilePath(url) {
 270 |     // Note: `localhost` is not important here, any host would work
 271 |     let u = new URL(url, "http://localhost/");
 272 |     url = u.pathname;
 273 | 
 274 |     // Remove PathPrefix from start of URL
 275 |     if (this.options.pathPrefix !== "/") {
 276 |       // Requests to root should redirect to new pathPrefix
 277 |       if(url === "/") {
 278 |         return {
 279 |           statusCode: 302,
 280 |           url: this.options.pathPrefix,
 281 |         }
 282 |       }
 283 | 
 284 |       // Requests to anything outside of root should fail with 404
 285 |       if (!url.startsWith(this.options.pathPrefix)) {
 286 |         return {
 287 |           statusCode: 404,
 288 |         };
 289 |       }
 290 | 
 291 |       url = url.slice(this.options.pathPrefix.length - 1);
 292 |     }
 293 | 
 294 |     let rawPath = this.getOutputDirFilePath(url);
 295 |     if (this.isOutputFilePathExists(rawPath)) {
 296 |       return {
 297 |         statusCode: 200,
 298 |         filepath: rawPath,
 299 |       };
 300 |     }
 301 | 
 302 |     let indexHtmlPath = this.getOutputDirFilePath(url, this.options.indexFileName);
 303 |     let indexHtmlExists = fs.existsSync(indexHtmlPath);
 304 | 
 305 |     let htmlPath = this.getOutputDirFilePath(url, ".html");
 306 |     let htmlExists = fs.existsSync(htmlPath);
 307 | 
 308 |     // /resource/ => /resource/index.html
 309 |     if (indexHtmlExists && url.endsWith("/")) {
 310 |       return {
 311 |         statusCode: 200,
 312 |         filepath: indexHtmlPath,
 313 |       };
 314 |     }
 315 |     // /resource => resource.html
 316 |     if (htmlExists && !url.endsWith("/")) {
 317 |       return {
 318 |         statusCode: 200,
 319 |         filepath: htmlPath,
 320 |       };
 321 |     }
 322 | 
 323 |     // /resource => redirect to /resource/
 324 |     if (indexHtmlExists && !url.endsWith("/")) {
 325 |       return {
 326 |         statusCode: 301,
 327 |         url: u.pathname + "/",
 328 |       };
 329 |     }
 330 | 
 331 |     // /resource/ => redirect to /resource
 332 |     if (htmlExists && url.endsWith("/")) {
 333 |       return {
 334 |         statusCode: 301,
 335 |         url: u.pathname.substring(0, u.pathname.length - 1),
 336 |       };
 337 |     }
 338 | 
 339 |     return {
 340 |       statusCode: 404,
 341 |     };
 342 |   }
 343 | 
 344 |   #readFile(filepath) {
 345 |     if(this.options.useCache && this.fileCache[filepath]) {
 346 |       return this.fileCache[filepath];
 347 |     }
 348 | 
 349 |     let contents = fs.readFileSync(filepath, {
 350 |       encoding: this.options.encoding,
 351 |     });
 352 | 
 353 |     if(this.options.useCache) {
 354 |       this.fileCache[filepath] = contents;
 355 |     }
 356 | 
 357 |     return contents;
 358 |   }
 359 | 
 360 |   #getFileContents(localpath, rootDir) {
 361 |     let filepath;
 362 |     let searchLocations = [];
 363 | 
 364 |     if(rootDir) {
 365 |       searchLocations.push(TemplatePath.absolutePath(rootDir, localpath));
 366 |     }
 367 | 
 368 |     // fallbacks for file:../ installations
 369 |     searchLocations.push(TemplatePath.absolutePath(__dirname, localpath));
 370 |     searchLocations.push(TemplatePath.absolutePath(__dirname, "../../../", localpath));
 371 | 
 372 |     for(let loc of searchLocations) {
 373 |       if(fs.existsSync(loc)) {
 374 |         filepath = loc;
 375 |         break;
 376 |       }
 377 |     }
 378 | 
 379 |     return this.#readFile(filepath);
 380 |   }
 381 | 
 382 |   augmentContentWithNotifier(content, inlineContents = false, options = {}) {
 383 |     let { integrityHash, scriptContents } = options;
 384 |     if(!scriptContents) {
 385 |       scriptContents = this.#getFileContents("./client/reload-client.js");
 386 |     }
 387 |     if(!integrityHash) {
 388 |       integrityHash = ssri.fromData(scriptContents);
 389 |     }
 390 | 
 391 |     let searchParams = new URLSearchParams();
 392 |     if(this.options.reloadPort) {
 393 |       searchParams.set("reloadPort", this.options.reloadPort);
 394 |     }
 395 | 
 396 |     let searchParamsStr = searchParams.size > 0 ? `?${searchParams.toString()}` : "";
 397 | 
 398 |     // This isn’t super necessary because it’s a local file, but it’s included anyway
 399 |     let script = `<script type="module" integrity="${integrityHash}"${inlineContents ? `>${scriptContents}` : ` src="/${this.options.injectedScriptsFolder}/reload-client.js${searchParamsStr}">`}</script>`;
 400 | 
 401 |     if (content.includes("</head>")) {
 402 |       return content.replace("</head>", `${script}</head>`);
 403 |     }
 404 | 
 405 |     // If the HTML document contains an importmap, insert the module script after the importmap element
 406 |     let importMapRegEx = /<script type=\\?importmap\\?[^>]*>(\n|.)*?<\/script>/gmi;
 407 |     let importMapMatch = content.match(importMapRegEx)?.[0];
 408 | 
 409 |     if (importMapMatch) {
 410 |       return content.replace(importMapMatch, `${importMapMatch}${script}`);
 411 |     }
 412 | 
 413 |     // <title> is the only *required* element in an HTML document
 414 |     if (content.includes("</title>")) {
 415 |       return content.replace("</title>", `</title>${script}`);
 416 |     }
 417 | 
 418 |     // If you’ve reached this section, your HTML is invalid!
 419 |     // We want to be super forgiving here, because folks might be in-progress editing the document!
 420 |     if (content.includes("</body>")) {
 421 |       return content.replace("</body>", `${script}</body>`);
 422 |     }
 423 |     if (content.includes("</html>")) {
 424 |       return content.replace("</html>", `${script}</html>`);
 425 |     }
 426 |     if (content.includes("<!doctype html>")) {
 427 |       return content.replace("<!doctype html>", `<!doctype html>${script}`);
 428 |     }
 429 | 
 430 |     // Notably, works without content at all!!
 431 |     return (content || "") + script;
 432 |   }
 433 | 
 434 |   getFileContentType(filepath, res) {
 435 |     let contentType = res.getHeader("Content-Type");
 436 | 
 437 |     // Content-Type might be already set via middleware
 438 |     if (contentType) {
 439 |       return contentType;
 440 |     }
 441 | 
 442 |     let mimeType = mime.getType(filepath);
 443 |     if (!mimeType) {
 444 |       return;
 445 |     }
 446 | 
 447 |     contentType = mimeType;
 448 | 
 449 |     // We only want to append charset if the header is not already set
 450 |     if (contentType === "text/html") {
 451 |       contentType = `text/html; charset=${this.options.encoding}`;
 452 |     }
 453 | 
 454 |     return contentType;
 455 |   }
 456 | 
 457 |   renderFile(filepath, res) {
 458 |     let contents = fs.readFileSync(filepath);
 459 |     let contentType = this.getFileContentType(filepath, res);
 460 | 
 461 |     for(const [key, value] of Object.entries(this.options.headers)){
 462 |       res.setHeader(key, value);
 463 |     }
 464 | 
 465 |     if (!contentType) {
 466 |       return res.end(contents);
 467 |     }
 468 | 
 469 |     res.setHeader("Content-Type", contentType);
 470 | 
 471 |     if (contentType.startsWith("text/html")) {
 472 |       // the string is important here, wrapResponse expects strings internally for HTML content (for now)
 473 |       return res.end(contents.toString());
 474 |     }
 475 | 
 476 |     return res.end(contents);
 477 |   }
 478 | 
 479 |   async eleventyDevServerMiddleware(req, res, next) {
 480 |     if(this.#serverState === "CLOSING") {
 481 |       return res.end("");
 482 |     }
 483 | 
 484 |     for(let urlPatternString in this.options.onRequest) {
 485 |       let fn = this.options.onRequest[urlPatternString];
 486 |       let fullPath = this.getServerPath(urlPatternString);
 487 |       let p = new URLPattern({ pathname: fullPath });
 488 | 
 489 |       // request url should already include pathprefix.
 490 |       let fullUrl = this.getServerUrlRaw("localhost", req.url);
 491 |       let match = p.exec(fullUrl);
 492 | 
 493 |       let u = new URL(fullUrl);
 494 | 
 495 |       if(match) {
 496 |         let result = await fn({
 497 |           url: u,
 498 |           pattern: p,
 499 |           patternGroups: match?.pathname?.groups || {},
 500 |         });
 501 | 
 502 |         if(!result && result !== "") {
 503 |           continue;
 504 |         }
 505 | 
 506 |         if(typeof result === "string") {
 507 |           return res.end(result);
 508 |         }
 509 | 
 510 |         if(isPlainObject(result) || result instanceof Response) {
 511 |           if(typeof result.status === "number") {
 512 |             res.statusCode = result.status;
 513 |           }
 514 | 
 515 |           if(result.headers instanceof Headers) {
 516 |             for(let [key, value] of result.headers.entries()) {
 517 |               res.setHeader(key, value);
 518 |             }
 519 |           } else if(isPlainObject(result.headers)) {
 520 |             for(let key of Object.keys(result.headers)) {
 521 |               res.setHeader(key, result.headers[key]);
 522 |             }
 523 |           }
 524 | 
 525 |           if(result instanceof Response) {
 526 |             // no gzip/br compression here, uncompressed from fetch https://github.com/w3c/ServiceWorker/issues/339
 527 |             res.removeHeader("content-encoding");
 528 | 
 529 |             let arrayBuffer = await result.arrayBuffer();
 530 |             res.setHeader("content-length", arrayBuffer.byteLength);
 531 | 
 532 |             let buffer = Buffer.from(arrayBuffer);
 533 |             return res.end(buffer);
 534 |           }
 535 | 
 536 |           return res.end(result.body || "");
 537 |         }
 538 | 
 539 |         throw new Error(`Invalid return type from \`onRequest\` pattern for ${urlPatternString}: expected string, object literal, or Response instance.`);
 540 |       }
 541 |     } // end onRequest
 542 | 
 543 |     if(req.url.startsWith(`/${this.options.injectedScriptsFolder}/reload-client.js`)) {
 544 |       if(this.options.liveReload) {
 545 |         res.setHeader("Content-Type", mime.getType("js"));
 546 |         return res.end(this.#getFileContents("./client/reload-client.js"));
 547 |       }
 548 |     } else if(req.url === `/${this.options.injectedScriptsFolder}/morphdom.js`) {
 549 |       if(this.options.domDiff) {
 550 |         res.setHeader("Content-Type", mime.getType("js"));
 551 |         let morphdomEsmPath = require.resolve("morphdom").replace("morphdom.js", "morphdom-esm.js");
 552 |         return res.end(this.#readFile(morphdomEsmPath));
 553 |       }
 554 |     }
 555 | 
 556 |     next();
 557 |   }
 558 | 
 559 |   // This runs at the end of the middleware chain
 560 |   eleventyProjectMiddleware(req, res) {
 561 |     // Known issue with `finalhandler` and HTTP/2:
 562 |     // UnsupportedWarning: Status message is not supported by HTTP/2 (RFC7540 8.1.2.4)
 563 |     // https://github.com/pillarjs/finalhandler/pull/34
 564 | 
 565 |     let lastNext = finalhandler(req, res, {
 566 |       onerror: (e) => {
 567 |         if (e.statusCode === 404) {
 568 |           let localPath = TemplatePath.stripLeadingSubPath(
 569 |             e.path,
 570 |             TemplatePath.absolutePath(this.dir)
 571 |           );
 572 |           this.logger.error(
 573 |             `HTTP ${e.statusCode}: Template not found in output directory (${this.dir}): ${localPath}`
 574 |           );
 575 |         } else {
 576 |           this.logger.error(`HTTP ${e.statusCode}: ${e.message}`);
 577 |         }
 578 |       },
 579 |     });
 580 | 
 581 |     // middleware (maybe a serverless request) already set a body upstream, skip this part
 582 |     if(!res._shouldForceEnd) {
 583 |       let match = this.mapUrlToFilePath(req.url);
 584 |       debug( req.url, match );
 585 | 
 586 |       if (match) {
 587 |         if (match.statusCode === 200 && match.filepath) {
 588 |           // Content-Range request, probably Safari trying to stream video
 589 |           if (req.headers.range)  {
 590 |             return send(req, match.filepath).pipe(res);
 591 |           }
 592 | 
 593 |           return this.renderFile(match.filepath, res);
 594 |         }
 595 | 
 596 |         // Redirects, usually for trailing slash to .html stuff
 597 |         if (match.url) {
 598 |           res.statusCode = match.statusCode;
 599 |           res.setHeader("Location", match.url);
 600 |           return res.end();
 601 |         }
 602 | 
 603 |         let raw404Path = this.getOutputDirFilePath("404.html");
 604 |         if(match.statusCode === 404 && this.isOutputFilePathExists(raw404Path)) {
 605 |           res.statusCode = match.statusCode;
 606 |           res.isCustomErrorPage = true;
 607 |           return this.renderFile(raw404Path, res);
 608 |         }
 609 |       }
 610 |     }
 611 | 
 612 |     if(res.body && !res.bodyUsed) {
 613 |       if(res._shouldForceEnd) {
 614 |         res.end();
 615 |       } else {
 616 |         let err = new Error("A response was never written to the stream. Are you missing a server middleware with `res.end()`?");
 617 |         err.statusCode = 500;
 618 |         lastNext(err);
 619 |         return;
 620 |       }
 621 |     }
 622 | 
 623 |     lastNext();
 624 |   }
 625 | 
 626 |   async onRequestHandler (req, res) {
 627 |     res = wrapResponse(res, content => {
 628 | 
 629 |       // check to see if this is a client fetch and not a navigation
 630 |       let isXHR = req.headers["sec-fetch-mode"] && req.headers["sec-fetch-mode"] != "navigate";
 631 | 
 632 |       if(this.options.liveReload !== false && !isXHR) {
 633 |         let scriptContents = this.#getFileContents("./client/reload-client.js");
 634 |         let integrityHash = ssri.fromData(scriptContents);
 635 | 
 636 |         // Bare (not-custom) finalhandler error pages have a Content-Security-Policy `default-src 'none'` that
 637 |         // prevents the client script from executing, so we override it
 638 |         if(res.statusCode !== 200 && !res.isCustomErrorPage) {
 639 |           res.setHeader("Content-Security-Policy", `script-src '${integrityHash}'`);
 640 |         }
 641 |         return this.augmentContentWithNotifier(content, res.statusCode !== 200, {
 642 |           scriptContents,
 643 |           integrityHash
 644 |         });
 645 |       }
 646 | 
 647 |       return content;
 648 |     });
 649 | 
 650 |     let middlewares = this.options.middleware || [];
 651 |     middlewares = middlewares.slice();
 652 | 
 653 |     // TODO because this runs at the very end of the middleware chain,
 654 |     // if we move the static stuff up in the order we could use middleware to modify
 655 |     // the static content in middleware!
 656 |     middlewares.push(this.eleventyProjectMiddleware);
 657 |     middlewares.reverse();
 658 | 
 659 |     // Runs very first in the middleware chain
 660 |     middlewares.push(this.eleventyDevServerMiddleware);
 661 | 
 662 |     let bound = [];
 663 |     let next;
 664 | 
 665 |     for(let ware of middlewares) {
 666 |       let fn;
 667 |       if(next) {
 668 |         fn = ware.bind(this, req, res, next);
 669 |       } else {
 670 |         fn = ware.bind(this, req, res);
 671 |       }
 672 |       bound.push(fn);
 673 |       next = fn;
 674 |     }
 675 | 
 676 |     bound.reverse();
 677 | 
 678 |     let [first] = bound;
 679 |     await first();
 680 |   }
 681 | 
 682 |   getHosts() {
 683 |     let hosts = new Set();
 684 |     if(this.options.showAllHosts) {
 685 |       for(let host of ipAddress()) {
 686 |         hosts.add(this.getServerUrl(host));
 687 |       }
 688 |     }
 689 |     hosts.add(this.getServerUrl("localhost"));
 690 |     return Array.from(hosts);
 691 |   }
 692 | 
 693 |   get server() {
 694 |     if (this._server) {
 695 |       return this._server;
 696 |     }
 697 | 
 698 |     this.start = Date.now();
 699 | 
 700 |     // Check for secure server requirements, otherwise use HTTP
 701 |     let { key, cert } = this.options.https;
 702 |     if(key && cert) {
 703 |       const { createSecureServer } = require("http2");
 704 | 
 705 |       let options = {
 706 |         allowHTTP1: true,
 707 | 
 708 |         // Credentials
 709 |         key: fs.readFileSync(key),
 710 |         cert: fs.readFileSync(cert),
 711 |       };
 712 |       this._server = createSecureServer(options, this.onRequestHandler.bind(this));
 713 |       this._serverProtocol = "https:";
 714 |     } else {
 715 |       const { createServer } = require("http");
 716 | 
 717 |       this._server = createServer(this.onRequestHandler.bind(this));
 718 |       this._serverProtocol = "http:";
 719 |     }
 720 | 
 721 |     this.portRetryCount = 0;
 722 |     this._server.on("error", (err) => {
 723 |       if (err.code == "EADDRINUSE") {
 724 |         if (this.portRetryCount < this.options.portReassignmentRetryCount) {
 725 |           this.portRetryCount++;
 726 |           debug(
 727 |             "Server already using port %o, trying the next port %o. Retry number %o of %o",
 728 |             err.port,
 729 |             err.port + 1,
 730 |             this.portRetryCount,
 731 |             this.options.portReassignmentRetryCount
 732 |           );
 733 |           this._serverListen(err.port + 1);
 734 |         } else {
 735 |           throw new Error(
 736 |             `Tried ${this.options.portReassignmentRetryCount} different ports but they were all in use. You can a different starter port using --port on the command line.`
 737 |           );
 738 |         }
 739 |       } else {
 740 |         this._serverErrorHandler(err);
 741 |       }
 742 |     });
 743 | 
 744 |     this._server.on("listening", (e) => {
 745 |       this.setupReloadNotifier();
 746 | 
 747 |       let logMessageCallback = typeof this.options.messageOnStart === "function" ? this.options.messageOnStart : () => false;
 748 |       let hosts = this.getHosts();
 749 |       let message = logMessageCallback({
 750 |         hosts,
 751 |         localhostUrl: this.getServerUrl("localhost"),
 752 |         options: this.options,
 753 |         version: pkg.version,
 754 |         startupTime: Date.now() - this.start,
 755 |       });
 756 | 
 757 |       if(message) {
 758 |         this.logger.info(message);
 759 |       }
 760 | 
 761 |       this.#readyResolve();
 762 |     });
 763 | 
 764 |     return this._server;
 765 |   }
 766 | 
 767 |   async ready() {
 768 |     return this.#readyPromise;
 769 |   }
 770 | 
 771 |   _serverListen(port) {
 772 |     this.server.listen({
 773 |       port,
 774 |     });
 775 |   }
 776 | 
 777 |   getServerPath(pathname) {
 778 |     // duplicate slashes
 779 |     if(this.options.pathPrefix.endsWith("/") && pathname.startsWith("/")) {
 780 |       pathname = pathname.slice(1);
 781 |     }
 782 |     return `${this.options.pathPrefix}${pathname}`;
 783 |   }
 784 | 
 785 |   getServerUrlRaw(host, pathname = "", isRaw = true) {
 786 |     if(!this._server || !this._serverProtocol) {
 787 |       throw new Error("Access to server url not yet available.");
 788 |     }
 789 | 
 790 |     let address = this._server.address();
 791 |     if(!address?.port) {
 792 |       throw new Error("Access to server port not yet available.");
 793 |     }
 794 | 
 795 |     return `${this._serverProtocol}//${host}:${address.port}${isRaw ? pathname : this.getServerPath(pathname)}`;
 796 |   }
 797 | 
 798 |   getServerUrl(host, pathname = "") {
 799 |     return this.getServerUrlRaw(host, pathname, false);
 800 |   }
 801 | 
 802 |   async getPort() {
 803 |     return new Promise(resolve => {
 804 |       this.server.on("listening", (e) => {
 805 |         let { port } = this._server.address();
 806 |         resolve(port);
 807 |       });
 808 |     })
 809 |   }
 810 | 
 811 |   serve(port) {
 812 |     this.getWatcher();
 813 | 
 814 |     this._serverListen(port);
 815 |   }
 816 | 
 817 |   _serverErrorHandler(err) {
 818 |     if (err.code == "EADDRINUSE") {
 819 |       this.logger.error(`Server error: Port in use ${err.port}`);
 820 |     } else {
 821 |       this.logger.error(`Server error: ${err.message}`);
 822 |     }
 823 |   }
 824 | 
 825 |   // Websocket Notifications
 826 |   setupReloadNotifier() {
 827 |     let options = {};
 828 |     if(this.options.reloadPort) {
 829 |       options.port = this.options.reloadPort;
 830 |     } else {
 831 |       // includes the port
 832 |       options.server = this.server;
 833 |     }
 834 | 
 835 |     let updateServer = new WebSocketServer(options);
 836 | 
 837 |     updateServer.on("connection", (ws) => {
 838 |       this.sendUpdateNotification({
 839 |         type: "eleventy.status",
 840 |         status: "connected",
 841 |       });
 842 |     });
 843 | 
 844 |     updateServer.on("error", (err) => {
 845 |       this._serverErrorHandler(err);
 846 |     });
 847 | 
 848 |     this.updateServer = updateServer;
 849 |   }
 850 | 
 851 |   // Broadcasts to all open browser windows
 852 |   sendUpdateNotification(obj) {
 853 |     if(!this.updateServer?.clients) {
 854 |       return;
 855 |     }
 856 | 
 857 |     for(let client of this.updateServer.clients) {
 858 |       if (client.readyState === WebSocket.OPEN) {
 859 |         client.send(JSON.stringify(obj));
 860 |       }
 861 |     }
 862 |   }
 863 | 
 864 |   // Helper for promisifying close methods with callbacks, like http.Server or ws.WebSocketServer.
 865 |   async _closeServer(server) {
 866 |     return new Promise((resolve, reject) => {
 867 |       server.close(err => {
 868 |         if (err) {
 869 |           reject(err);
 870 |         }
 871 |         resolve();
 872 |       });
 873 | 
 874 |       // Note: this method won’t exist for updateServer
 875 |       if("closeAllConnections" in server) {
 876 |         // Node 18.2+
 877 |         server.closeAllConnections();
 878 |       }
 879 |     });
 880 |   }
 881 | 
 882 |   async close() {
 883 |     // Prevent multiple invocations.
 884 |     if (this.#serverClosing) {
 885 |       return this.#serverClosing;
 886 |     }
 887 | 
 888 |     // TODO would be awesome to set a delayed redirect when port changed to redirect to new _server_
 889 |     this.sendUpdateNotification({
 890 |       type: "eleventy.status",
 891 |       status: "disconnected",
 892 |     });
 893 | 
 894 |     let promises = []
 895 |     if(this.updateServer) {
 896 |       // Close all existing WS connections.
 897 |       this.updateServer?.clients.forEach(socket => socket.close());
 898 |       promises.push(this._closeServer(this.updateServer));
 899 |     }
 900 | 
 901 |     if(this._server?.listening) {
 902 |       promises.push(this._closeServer(this.server));
 903 |     }
 904 | 
 905 |     if(this.#watcher) {
 906 |       promises.push(this.#watcher.close());
 907 |       this.#watcher = undefined;
 908 |     }
 909 | 
 910 |     this.#serverClosing = Promise.all(promises).then(() => {
 911 |       this.#serverState = "CLOSED";
 912 |       this.#serverClosing = undefined;
 913 |     });
 914 | 
 915 |     this.#serverState = "CLOSING";
 916 | 
 917 |     return this.#serverClosing;
 918 |   }
 919 | 
 920 |   sendError({ error }) {
 921 |     this.sendUpdateNotification({
 922 |       type: "eleventy.error",
 923 |       // Thanks https://stackoverflow.com/questions/18391212/is-it-not-possible-to-stringify-an-error-using-json-stringify
 924 |       error: JSON.stringify(error, Object.getOwnPropertyNames(error)),
 925 |     });
 926 |   }
 927 | 
 928 |   // reverse of mapUrlToFilePath
 929 |   // /resource/ <= /resource/index.html
 930 |   // /resource <= resource.html
 931 |   getUrlsFromFilePath(path) {
 932 |     if(this.dir === ".") {
 933 |       path = `/${path}`
 934 |     } else {
 935 |       path = path.slice(this.dir.length);
 936 |     }
 937 | 
 938 |     let urls = [];
 939 |     urls.push(path);
 940 | 
 941 |     if(path.endsWith(`/${this.options.indexFileName}`)) {
 942 |       urls.push(path.slice(0, -1 * this.options.indexFileName.length));
 943 |     } else if(path.endsWith(".html")) {
 944 |       urls.push(path.slice(0, -1 * ".html".length));
 945 |     }
 946 | 
 947 |     return urls;
 948 |   }
 949 | 
 950 |   // returns [{ url, inputPath, content }]
 951 |   getBuildTemplatesFromFilePath(path) {
 952 |     // We can skip this for non-html files, dom-diffing will not apply
 953 |     if(!path.endsWith(".html")) {
 954 |       return [];
 955 |     }
 956 | 
 957 |     let urls = this.getUrlsFromFilePath(path);
 958 |     let obj = {
 959 |       inputPath: path,
 960 |       content: fs.readFileSync(path, "utf8"),
 961 |     }
 962 | 
 963 |     return urls.map(url => {
 964 |       return Object.assign({ url }, obj);
 965 |     });
 966 |   }
 967 | 
 968 |   reloadFiles(files, useDomDiffingForHtml = true) {
 969 |     if(!Array.isArray(files)) {
 970 |       throw new Error("reloadFiles method requires an array of file paths.");
 971 |     }
 972 | 
 973 |     let subtype;
 974 |     if(!files.some((entry) => !entry.endsWith(".css"))) {
 975 |       // only if all changes are css changes
 976 |       subtype = "css";
 977 |     }
 978 | 
 979 |     let templates = [];
 980 |     if(useDomDiffingForHtml && this.options.domDiff) {
 981 |       for(let filePath of files) {
 982 |         if(!filePath.endsWith(".html")) {
 983 |           continue;
 984 |         }
 985 |         for(let templateEntry of this.getBuildTemplatesFromFilePath(filePath)) {
 986 |           templates.push(templateEntry);
 987 |         }
 988 |       }
 989 |     }
 990 | 
 991 |     this.reload({
 992 |       files,
 993 |       subtype,
 994 |       build: {
 995 |         templates
 996 |       }
 997 |     });
 998 |   }
 999 | 
1000 |   reload(event = {}) {
1001 |     let { subtype, files, build } = event;
1002 |     if (build?.templates) {
1003 |       build.templates = build.templates
1004 |         .filter(entry => {
1005 |           if(!this.options.domDiff) {
1006 |             // Don’t include any files if the dom diffing option is disabled
1007 |             return false;
1008 |           }
1009 | 
1010 |           // Filter to only include watched templates that were updated
1011 |           return (files || []).includes(entry.inputPath);
1012 |         });
1013 |     }
1014 | 
1015 |     this.sendUpdateNotification({
1016 |       type: "eleventy.reload",
1017 |       subtype,
1018 |       files,
1019 |       build,
1020 |     });
1021 |   }
1022 | }
1023 | 
1024 | module.exports = EleventyDevServer;
1025 | 


--------------------------------------------------------------------------------
/server/ipAddress.js:
--------------------------------------------------------------------------------
1 | const os = require("node:os");
2 | 
3 | const INTERFACE_FAMILIES = ["IPv4"];
4 | 
5 | module.exports = function() {
6 |     return Object.values(os.networkInterfaces()).flat().filter(interface => {
7 |         return interface.internal === false && INTERFACE_FAMILIES.includes(interface.family);
8 |     }).map(interface => interface.address);
9 | };


--------------------------------------------------------------------------------
/server/wrapResponse.js:
--------------------------------------------------------------------------------
  1 | function getContentType(headers) {
  2 |   if(!headers) {
  3 |     return;
  4 |   }
  5 | 
  6 |   for(let key in headers) {
  7 |     if(key.toLowerCase() === "content-type") {
  8 |       return headers[key];
  9 |     }
 10 |   }
 11 | }
 12 | 
 13 | // Inspired by `resp-modifier` https://github.com/shakyShane/resp-modifier/blob/4a000203c9db630bcfc3b6bb8ea2abc090ae0139/index.js
 14 | function wrapResponse(resp, transformHtml) {
 15 |   resp._wrappedOriginalWrite = resp.write;
 16 |   resp._wrappedOriginalWriteHead = resp.writeHead;
 17 |   resp._wrappedOriginalEnd = resp.end;
 18 | 
 19 |   resp._wrappedHeaders = [];
 20 |   resp._wrappedTransformHtml = transformHtml;
 21 |   resp._hasEnded = false;
 22 |   resp._shouldForceEnd = false;
 23 | 
 24 |   // Compatibility with web standards Response()
 25 |   Object.defineProperty(resp, "body", {
 26 |     // Returns write cache
 27 |     get: function() {
 28 |       if(typeof this._writeCache === "string") {
 29 |         return this._writeCache;
 30 |       }
 31 |     },
 32 |     // Usage:
 33 |     // res.body = ""; // overwrite existing content
 34 |     // res.body += ""; // append to existing content, can also res.write("") to append
 35 |     set: function(data) {
 36 |       if(typeof data === "string") {
 37 |         this._writeCache = data;
 38 |       }
 39 |     }
 40 |   });
 41 | 
 42 |   // Compatibility with web standards Response()
 43 |   Object.defineProperty(resp, "bodyUsed", {
 44 |     get: function() {
 45 |       return this._hasEnded;
 46 |     }
 47 |   })
 48 | 
 49 |   // Original signature writeHead(statusCode[, statusMessage][, headers])
 50 |   resp.writeHead = function(statusCode, ...args) {
 51 |     let headers = args[args.length - 1];
 52 |     // statusMessage is a string
 53 |     if(typeof headers !== "string") {
 54 |       this._contentType = getContentType(headers);
 55 |     }
 56 | 
 57 |     if((this._contentType || "").startsWith("text/html")) {
 58 |       this._wrappedHeaders.push([statusCode, ...args]);
 59 |     } else {
 60 |       return this._wrappedOriginalWriteHead(statusCode, ...args);
 61 |     }
 62 |     return this;
 63 |   }
 64 | 
 65 |   // data can be a String or Buffer
 66 |   resp.write = function(data, ...args) {
 67 |     if(typeof data === "string") {
 68 |       if(!this._writeCache) {
 69 |         this._writeCache = "";
 70 |       }
 71 | 
 72 |       // TODO encoding and callback args
 73 |       this._writeCache += data;
 74 |     } else {
 75 |       // Buffers
 76 |       return this._wrappedOriginalWrite(data, ...args);
 77 |     }
 78 |     return this;
 79 |   }
 80 | 
 81 |   // data can be a String or Buffer
 82 |   resp.end = function(data, encoding, callback) {
 83 |     resp._hasEnded = true;
 84 | 
 85 |     if(typeof this._writeCache === "string" || typeof data === "string") {
 86 |       // Strings
 87 |       if(!this._writeCache) {
 88 |         this._writeCache = "";
 89 |       }
 90 |       if(typeof data === "string") {
 91 |         this._writeCache += data;
 92 |       }
 93 | 
 94 |       let result = this._writeCache;
 95 | 
 96 |       // Only transform HTML
 97 |       // Note the “setHeader versus writeHead” note on https://nodejs.org/api/http.html#responsewriteheadstatuscode-statusmessage-headers
 98 |       let contentType = this._contentType || getContentType(this.getHeaders());
 99 |       if(contentType?.startsWith("text/html")) {
100 |         if(this._wrappedTransformHtml && typeof this._wrappedTransformHtml === "function") {
101 |           result = this._wrappedTransformHtml(result);
102 |           // uncompressed size: https://github.com/w3c/ServiceWorker/issues/339
103 |           this.setHeader("Content-Length", Buffer.byteLength(result));
104 |         }
105 |       }
106 | 
107 |       for(let headers of this._wrappedHeaders) {
108 |         this._wrappedOriginalWriteHead(...headers);
109 |       }
110 | 
111 |       this._writeCache = [];
112 |       this._wrappedOriginalWrite(result, encoding)
113 |       return this._wrappedOriginalEnd(callback);
114 |     } else {
115 |       // Buffer or Uint8Array
116 |       for(let headers of this._wrappedHeaders) {
117 |         this._wrappedOriginalWriteHead(...headers);
118 |       }
119 | 
120 |       if(data) {
121 |         this._wrappedOriginalWrite(data, encoding);
122 |       }
123 |       return this._wrappedOriginalEnd(callback);
124 |     }
125 |   }
126 | 
127 |   return resp;
128 | }
129 | 
130 | module.exports = wrapResponse;


--------------------------------------------------------------------------------
/test/sample/test’s/sample.txt:
--------------------------------------------------------------------------------
1 | Testing!


--------------------------------------------------------------------------------
/test/stubs/alternative/test/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/11ty/eleventy-dev-server/1c658605f75224fdc76f68aebe7a412eeb4f1bc9/test/stubs/alternative/test/.gitkeep


--------------------------------------------------------------------------------
/test/stubs/custom-index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | 	<head>
 4 | 		<meta charset="utf-8">
 5 | 		<meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 | 		<meta name="description" content="">
 7 | 		<title></title>
 8 | 	</head>
 9 | 	<body>
10 | 		<code>test/stubs/custom-index.html</code>
11 | 	</body>
12 | </html>


--------------------------------------------------------------------------------
/test/stubs/html-with-js.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | 	<head>
 4 | 		<meta charset="utf-8">
 5 | 		<meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 | 		<meta name="description" content="">
 7 | 		<title></title>
 8 | 	</head>
 9 | 	<body>
10 | 		<p>I love <span id="test"></span></p>
11 | <script>
12 | document.getElementById('test').innerText = '11ty';
13 | console.log( "this runs with domdiff" );
14 | </script>
15 | 	</body>
16 | </html>


--------------------------------------------------------------------------------
/test/stubs/index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | 	<head>
 4 | 		<meta charset="utf-8">
 5 | 		<meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 | 		<meta name="description" content="">
 7 | 		<title></title>
 8 | 	</head>
 9 | 	<body>
10 | 		<code>test/stubs/index.html</code>
11 | 	</body>
12 | </html>


--------------------------------------------------------------------------------
/test/stubs/index.php:
--------------------------------------------------------------------------------
1 | SAMPLE PHP
2 | 


--------------------------------------------------------------------------------
/test/stubs/petite-vue.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | 	<head>
 4 | 		<meta charset="utf-8">
 5 | 		<meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 | 		<meta name="description" content="">
 7 | 		<title></title>
 8 | 	</head>
 9 | 	<body>
10 | 		<div @vue:mounted="test">test ljskdlfjlkdsjflk</div>
11 | 		<div @vue:mounted="test">test ljskdlfjlkdsjflk</div>
12 | 		<div @vue:mounted="test">test ljskdlfjlkdsjflk</div>
13 | 	</body>
14 | </html>


--------------------------------------------------------------------------------
/test/stubs/route space.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/11ty/eleventy-dev-server/1c658605f75224fdc76f68aebe7a412eeb4f1bc9/test/stubs/route space.html


--------------------------------------------------------------------------------
/test/stubs/route1/custom-index.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/11ty/eleventy-dev-server/1c658605f75224fdc76f68aebe7a412eeb4f1bc9/test/stubs/route1/custom-index.html


--------------------------------------------------------------------------------
/test/stubs/route1/index.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/11ty/eleventy-dev-server/1c658605f75224fdc76f68aebe7a412eeb4f1bc9/test/stubs/route1/index.html


--------------------------------------------------------------------------------
/test/stubs/route2.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/11ty/eleventy-dev-server/1c658605f75224fdc76f68aebe7a412eeb4f1bc9/test/stubs/route2.html


--------------------------------------------------------------------------------
/test/stubs/route3.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/11ty/eleventy-dev-server/1c658605f75224fdc76f68aebe7a412eeb4f1bc9/test/stubs/route3.html


--------------------------------------------------------------------------------
/test/stubs/route3/index.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/11ty/eleventy-dev-server/1c658605f75224fdc76f68aebe7a412eeb4f1bc9/test/stubs/route3/index.html


--------------------------------------------------------------------------------
/test/stubs/sample.html:
--------------------------------------------------------------------------------
1 | SAMPLE


--------------------------------------------------------------------------------
/test/stubs/with-css/index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | 	<head>
 4 | 		<meta charset="utf-8">
 5 | 		<meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 | 		<meta name="description" content="">
 7 | 		<title></title>
 8 | 		<link rel="stylesheet" href="style.css">
 9 | 	</head>
10 | 	<body>
11 | 		BODY TEXT
12 | 	</body>
13 | </html>


--------------------------------------------------------------------------------
/test/stubs/with-css/style.css:
--------------------------------------------------------------------------------
1 | body {
2 |   color: blue;
3 | }


--------------------------------------------------------------------------------
/test/stubs/with-import-map.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | 	<head>
 4 | 		<meta charset="utf-8">
 5 | 		<meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 | 		<meta name="description" content="">
 7 | 		<title></title>
 8 | 		<script type="importmap">
 9 | 		{
10 | 			"imports": {
11 | 				"petite-vue": "https://unpkg.com/petite-vue@0.4.1/dist/petite-vue.es.js",
12 | 				"vue": "https://unpkg.com/vue@3.2.36/dist/vue.esm-browser.prod.js"
13 | 			}
14 | 		}
15 | 		</script>
16 | 	</head>
17 | 	<body>
18 | 		This page has an importmap
19 | 	</body>
20 | </html>


--------------------------------------------------------------------------------
/test/stubs/zach’s.html:
--------------------------------------------------------------------------------
1 | This is a test


--------------------------------------------------------------------------------
/test/testServer.js:
--------------------------------------------------------------------------------
  1 | const test = require("ava");
  2 | const path = require("path");
  3 | const EleventyDevServer = require("../");
  4 | 
  5 | function testNormalizeFilePath(filepath) {
  6 |   return filepath.split("/").join(path.sep);
  7 | }
  8 | 
  9 | test("Url mappings for resource/index.html", async (t) => {
 10 |   let server = new EleventyDevServer("test-server", "./test/stubs/");
 11 | 
 12 |   t.deepEqual(server.mapUrlToFilePath("/route1/"), {
 13 |     statusCode: 200,
 14 |     filepath: testNormalizeFilePath("test/stubs/route1/index.html")
 15 |   });
 16 | 
 17 |   t.deepEqual(server.mapUrlToFilePath("/route1"), {
 18 |     statusCode: 301,
 19 |     url: "/route1/"
 20 |   });
 21 | 
 22 |   t.deepEqual(server.mapUrlToFilePath("/route1.html"), {
 23 |     statusCode: 404
 24 |   });
 25 | 
 26 |   t.deepEqual(server.mapUrlToFilePath("/route1/index.html"), {
 27 |     statusCode: 200,
 28 |     filepath: testNormalizeFilePath("test/stubs/route1/index.html")
 29 |   });
 30 | 
 31 |   await server.close();
 32 | });
 33 | 
 34 | test("Url mappings for resource.html", async (t) => {
 35 |   let server = new EleventyDevServer("test-server", "./test/stubs/");
 36 | 
 37 |   t.deepEqual(server.mapUrlToFilePath("/route2/"), {
 38 |     statusCode: 301,
 39 |     url: "/route2"
 40 |   });
 41 | 
 42 |   t.deepEqual(server.mapUrlToFilePath("/route2/index.html"), {
 43 |     statusCode: 404
 44 |   });
 45 | 
 46 |   t.deepEqual(server.mapUrlToFilePath("/route2"), {
 47 |     statusCode: 200,
 48 |     filepath: testNormalizeFilePath("test/stubs/route2.html")
 49 |   });
 50 | 
 51 |   t.deepEqual(server.mapUrlToFilePath("/route2.html"), {
 52 |     statusCode: 200,
 53 |     filepath: testNormalizeFilePath("test/stubs/route2.html",)
 54 |   });
 55 | 
 56 |   await server.close();
 57 | });
 58 | 
 59 | test("Url mappings for resource.html and resource/index.html", async (t) => {
 60 |   let server = new EleventyDevServer("test-server", "./test/stubs/");
 61 | 
 62 |   // Production mismatch warning: Netlify 301 redirects to /route3 here
 63 |   t.deepEqual(server.mapUrlToFilePath("/route3/"), {
 64 |     statusCode: 200,
 65 |     filepath: testNormalizeFilePath("test/stubs/route3/index.html",)
 66 |   });
 67 | 
 68 |   t.deepEqual(server.mapUrlToFilePath("/route3/index.html"), {
 69 |     statusCode: 200,
 70 |     filepath: testNormalizeFilePath("test/stubs/route3/index.html",)
 71 |   });
 72 | 
 73 |   t.deepEqual(server.mapUrlToFilePath("/route3"), {
 74 |     statusCode: 200,
 75 |     filepath: testNormalizeFilePath("test/stubs/route3.html")
 76 |   });
 77 | 
 78 |   t.deepEqual(server.mapUrlToFilePath("/route3.html"), {
 79 |     statusCode: 200,
 80 |     filepath: testNormalizeFilePath("test/stubs/route3.html",)
 81 |   });
 82 | 
 83 |   await server.close();
 84 | });
 85 | 
 86 | test("Url mappings for missing resource", async (t) => {
 87 |   let server = new EleventyDevServer("test-server", "./test/stubs/");
 88 | 
 89 |   // 404s
 90 |   t.deepEqual(server.mapUrlToFilePath("/does-not-exist/"), {
 91 |     statusCode: 404
 92 |   });
 93 | 
 94 |   await server.close();
 95 | });
 96 | 
 97 | test("Url mapping for a filename with a space in it", async (t) => {
 98 |   let server = new EleventyDevServer("test-server", "./test/stubs/");
 99 | 
100 |   t.deepEqual(server.mapUrlToFilePath("/route space.html"), {
101 |     statusCode: 200,
102 |     filepath: testNormalizeFilePath("test/stubs/route space.html",)
103 |   });
104 | 
105 |   await server.close();
106 | });
107 | 
108 | test("matchPassthroughAlias", async (t) => {
109 |   let server = new EleventyDevServer("test-server", "./test/stubs/");
110 | 
111 |   // url => project root input
112 |   server.setAliases({
113 |     // works with directories
114 |     "/img": "./test/stubs/img",
115 |     "/elsewhere": "./test/stubs/alternative",
116 |     // or full paths
117 |     "/elsewhere/index.css": "./test/stubs/with-css/style.css",
118 |   });
119 | 
120 |   // No map entry
121 |   t.is(server.matchPassthroughAlias("/"), false);
122 |   t.is(server.matchPassthroughAlias("/index.html"), false); // file exists
123 | 
124 |   // File exists
125 |   t.is(server.matchPassthroughAlias("/elsewhere"), "./test/stubs/alternative");
126 |   t.is(server.matchPassthroughAlias("/elsewhere/test"), "./test/stubs/alternative/test");
127 | 
128 |   // Map entry exists but file does not exist
129 |   t.is(server.matchPassthroughAlias("/elsewhere/test.png"), false);
130 |   t.is(server.matchPassthroughAlias("/elsewhere/another.css"), false);
131 | 
132 |   // Map entry exists, file exists
133 |   t.is(server.matchPassthroughAlias("/elsewhere/index.css"), "./test/stubs/with-css/style.css");
134 | 
135 |   await server.close();
136 | });
137 | 
138 | 
139 | test("pathPrefix matching", async (t) => {
140 |   let server = new EleventyDevServer("test-server", "./test/stubs/", {
141 |     pathPrefix: "/pathprefix/"
142 |   });
143 | 
144 |   t.deepEqual(server.mapUrlToFilePath("/pathprefix/route1/"), {
145 |     statusCode: 200,
146 |     filepath: testNormalizeFilePath("test/stubs/route1/index.html")
147 |   });
148 | 
149 |   t.deepEqual(server.mapUrlToFilePath("/pathprefix/"), {
150 |     statusCode: 200,
151 |     filepath: testNormalizeFilePath("test/stubs/index.html")
152 |   });
153 | 
154 |   // `/` should redirect to pathprefix
155 |   t.deepEqual(server.mapUrlToFilePath("/"), {
156 |     statusCode: 302,
157 |     url: '/pathprefix/',
158 |   });
159 | 
160 |   await server.close();
161 | });
162 | 
163 | test("pathPrefix without leading slash", async (t) => {
164 |   let server = new EleventyDevServer("test-server", "./test/stubs/", {
165 |     pathPrefix: "pathprefix/"
166 |   });
167 | 
168 |   t.deepEqual(server.mapUrlToFilePath("/pathprefix/route1/"), {
169 |     statusCode: 200,
170 |     filepath: testNormalizeFilePath("test/stubs/route1/index.html")
171 |   });
172 | 
173 |   t.deepEqual(server.mapUrlToFilePath("/pathprefix/"), {
174 |     statusCode: 200,
175 |     filepath: testNormalizeFilePath("test/stubs/index.html")
176 |   });
177 | 
178 |   // `/` should redirect to pathprefix
179 |   t.deepEqual(server.mapUrlToFilePath("/"), {
180 |     statusCode: 302,
181 |     url: '/pathprefix/',
182 |   });
183 | 
184 |   await server.close();
185 | });
186 | 
187 | test("pathPrefix without trailing slash", async (t) => {
188 |   let server = new EleventyDevServer("test-server", "./test/stubs/", {
189 |     pathPrefix: "/pathprefix"
190 |   });
191 | 
192 |   t.deepEqual(server.mapUrlToFilePath("/pathprefix/route1/"), {
193 |     statusCode: 200,
194 |     filepath: testNormalizeFilePath("test/stubs/route1/index.html")
195 |   });
196 | 
197 |   t.deepEqual(server.mapUrlToFilePath("/pathprefix/"), {
198 |     statusCode: 200,
199 |     filepath: testNormalizeFilePath("test/stubs/index.html")
200 |   });
201 | 
202 |   // `/` should redirect to pathprefix
203 |   t.deepEqual(server.mapUrlToFilePath("/"), {
204 |     statusCode: 302,
205 |     url: '/pathprefix/',
206 |   });
207 | 
208 |   await server.close();
209 | });
210 | 
211 | test("pathPrefix without leading or trailing slash", async (t) => {
212 |   let server = new EleventyDevServer("test-server", "./test/stubs/", {
213 |     pathPrefix: "pathprefix"
214 |   });
215 | 
216 |   t.deepEqual(server.mapUrlToFilePath("/pathprefix/route1/"), {
217 |     statusCode: 200,
218 |     filepath: testNormalizeFilePath("test/stubs/route1/index.html")
219 |   });
220 | 
221 |   t.deepEqual(server.mapUrlToFilePath("/pathprefix/"), {
222 |     statusCode: 200,
223 |     filepath: testNormalizeFilePath("test/stubs/index.html")
224 |   });
225 | 
226 |   // `/` should redirect to pathprefix
227 |   t.deepEqual(server.mapUrlToFilePath("/"), {
228 |     statusCode: 302,
229 |     url: '/pathprefix/',
230 |   });
231 | 
232 |   await server.close();
233 | });
234 | 
235 | test("indexFileName option: serve custom index when provided", async (t) => {
236 |   let server = new EleventyDevServer("test-server", "./test/stubs/", { indexFileName: 'custom-index.html' });
237 | 
238 |   t.deepEqual(server.mapUrlToFilePath("/"), {
239 |     statusCode: 200,
240 |     filepath: testNormalizeFilePath("test/stubs/custom-index.html"),
241 |   });
242 | 
243 | 
244 |   t.deepEqual(server.mapUrlToFilePath("/route1/"), {
245 |     statusCode: 200,
246 |     filepath: testNormalizeFilePath("test/stubs/route1/custom-index.html"),
247 |   });
248 | 
249 |   await server.close();
250 | });
251 | 
252 | test("indexFileName option: return 404 when custom index file doesn't exist", async (t) => {
253 |   let server = new EleventyDevServer("test-server", "./test/stubs/", { indexFileName: 'does-not-exist.html' });
254 | 
255 |   t.deepEqual(server.mapUrlToFilePath("/"), {
256 |     statusCode: 404,
257 |   });
258 | 
259 |   await server.close();
260 | });
261 | 
262 | test("Test watch getter", async (t) => {
263 |   let server = new EleventyDevServer("test-server", "./test/stubs/");
264 | 
265 |   t.truthy(server.watcher);
266 | 
267 |   await server.close();
268 | });
269 | 


--------------------------------------------------------------------------------
/test/testServerRequests.js:
--------------------------------------------------------------------------------
  1 | const test = require("ava");
  2 | const path = require("path");
  3 | const http = require("http");
  4 | const EleventyDevServer = require("../");
  5 | 
  6 | function getOptions(options = {}) {
  7 |   options.logger = {
  8 |     info: function() {},
  9 |     error: function() {},
 10 |   };
 11 |   options.portReassignmentRetryCount = 100;
 12 |   return options;
 13 | }
 14 | 
 15 | async function makeRequestTo(t, server, path) {
 16 |   let port = await server.getPort();
 17 | 
 18 |   return new Promise(resolve => {
 19 |     const options = {
 20 |       hostname: 'localhost',
 21 |       port,
 22 |       path,
 23 |       method: 'GET',
 24 |     };
 25 | 
 26 |     http.get(options, (res) => {
 27 |       const { statusCode } = res;
 28 |       if(statusCode !== 200) {
 29 |         throw new Error("Invalid status code" + statusCode);
 30 |       }
 31 | 
 32 |       res.setEncoding('utf8');
 33 | 
 34 |       let rawData = '';
 35 |       res.on('data', (chunk) => { rawData += chunk; });
 36 |       res.on('end', () => {
 37 |         t.true( true );
 38 |         resolve(rawData);
 39 |       });
 40 |     }).on('error', (e) => {
 41 |       console.error(`Got error: ${e.message}`);
 42 |     });
 43 |   })
 44 | }
 45 | 
 46 | async function fetchHeadersForRequest(t, server, path, extras) {
 47 |   let port = await server.getPort();
 48 | 
 49 |   return new Promise(resolve => {
 50 |     const options = {
 51 |       hostname: 'localhost',
 52 |       port,
 53 |       path,
 54 |       method: 'GET',
 55 |       ...extras,
 56 |     };
 57 | 
 58 |     // Available status codes can be found here: http.STATUS_CODES
 59 |     const successCodes = [
 60 |       200, // OK
 61 |       206, // Partial Content
 62 |     ];
 63 |     http.get(options, (res) => {
 64 |       const { statusCode } = res;
 65 |       if (!successCodes.includes(statusCode)) {
 66 |         throw new Error("Invalid status code " + statusCode);
 67 |       }
 68 | 
 69 |       let headers = res.headers;
 70 |       resolve(headers);
 71 | 
 72 |     }).on('error', (e) => {
 73 |       console.error(`Got error: ${e.message}`);
 74 |     });
 75 |   })
 76 | }
 77 | 
 78 | test("Standard request", async (t) => {
 79 |   let server = new EleventyDevServer("test-server", "./test/stubs/", getOptions());
 80 |   server.serve(8100);
 81 | 
 82 |   let data = await makeRequestTo(t, server, "/sample");
 83 |   t.true(data.includes("<script "));
 84 |   t.true(data.startsWith("SAMPLE"));
 85 | 
 86 |   await server.close();  
 87 | });
 88 | 
 89 | test("One sync middleware", async t => {
 90 |   let server = new EleventyDevServer("test-server", "./test/stubs/", getOptions({
 91 |     middleware: [
 92 |       function(req, res, next) {
 93 |         return next();
 94 |       }
 95 |     ],
 96 |   }));
 97 | 
 98 |   server.serve(8100);
 99 | 
100 |   let data = await makeRequestTo(t, server, "/sample");
101 |   t.true(data.includes("<script "));
102 |   t.true(data.startsWith("SAMPLE"));
103 | 
104 |   await server.close();
105 | });
106 | 
107 | test("Two sync middleware", async t => {
108 |   let server = new EleventyDevServer("test-server", "./test/stubs/", getOptions({
109 |     middleware: [
110 |       function(req, res, next) {
111 |         return next();
112 |       },
113 |       function(req, res, next) {
114 |         return next();
115 |       }
116 |     ],
117 |   }));
118 |   server.serve(8100);
119 | 
120 |   let data = await makeRequestTo(t, server, "/sample");
121 |   t.true(data.includes("<script "));
122 |   t.true(data.startsWith("SAMPLE"));
123 | 
124 |   await server.close();
125 | });
126 | 
127 | test("One async middleware", async t => {
128 |   let server = new EleventyDevServer("test-server", "./test/stubs/", getOptions({
129 |     middleware: [
130 |       async function(req, res, next) {
131 |         return next();
132 |       }
133 |     ],
134 |   }));
135 |   server.serve(8100);
136 | 
137 |   let data = await makeRequestTo(t, server, "/sample");
138 |   t.true(data.includes("<script "));
139 |   t.true(data.startsWith("SAMPLE"));
140 | 
141 |   await server.close();
142 | });
143 | 
144 | test("Two async middleware", async t => {
145 |   let server = new EleventyDevServer("test-server", "./test/stubs/", getOptions({
146 |     middleware: [
147 |       async function(req, res, next) {
148 |         return next();
149 |       },
150 |       async function(req, res, next) {
151 |         return next();
152 |       }
153 |     ],
154 |   }));
155 |   server.serve(8100);
156 | 
157 |   let data = await makeRequestTo(t, server, "/sample");
158 |   t.true(data.includes("<script "));
159 |   t.true(data.startsWith("SAMPLE"));
160 | 
161 |   await server.close();
162 | });
163 | 
164 | test("Async middleware that writes", async t => {
165 |   let server = new EleventyDevServer("test-server", "./test/stubs/", getOptions({
166 |     // enabled: false,
167 |     middleware: [
168 |       async function(req, res, next) {
169 |         let data = await new Promise((resolve) => {
170 |           setTimeout(() => {
171 |             resolve("Injected")
172 |           }, 10);
173 |         });
174 | 
175 |         res.writeHead(200, {
176 |           "Content-Type": "text/html",
177 |         });
178 |         res.write("Injected");
179 |         res.end();
180 |       },
181 |     ],
182 |   }));
183 |   server.serve(8100);
184 | 
185 |   let data = await makeRequestTo(t, server, "/sample");
186 |   t.true(data.includes("<script "));
187 |   t.true(data.startsWith("Injected"));
188 | 
189 |   await server.close();
190 | });
191 | 
192 | test("Second async middleware that writes", async t => {
193 |   let server = new EleventyDevServer("test-server", "./test/stubs/", getOptions({
194 |     // enabled: false,
195 |     middleware: [
196 |       async function(req, res, next) {
197 |         await new Promise((resolve) => {
198 |           setTimeout(() => {
199 |             resolve()
200 |           }, 10);
201 |         });
202 | 
203 |         next()
204 |       },
205 |       async function(req, res, next) {
206 |         let data = await new Promise((resolve) => {
207 |           setTimeout(() => {
208 |             resolve("Injected")
209 |           }, 10);
210 |         });
211 | 
212 |         res.writeHead(200, {
213 |           "Content-Type": "text/html",
214 |         });
215 |         res.write(data);
216 |         res.end();
217 |       },
218 |     ],
219 |   }));
220 |   server.serve(8100);
221 | 
222 |   let data = await makeRequestTo(t, server, "/sample");
223 |   t.true(data.includes("<script "));
224 |   t.true(data.startsWith("Injected"));
225 | 
226 |   await server.close();
227 | });
228 | 
229 | 
230 | test("Second middleware that consumes first middleware response body, issue #29", async t => {
231 |   let server = new EleventyDevServer("test-server", "./test/stubs/", getOptions({
232 |     // enabled: false,
233 |     middleware: [
234 |       async function(req, res, next) {
235 |         res.writeHead(200, {"Content-Type": "text/html"});
236 |         res.write("First ");
237 | 
238 |         next()
239 |       },
240 |       async function(req, res, next) {
241 |         res.body += "Second ";
242 |         // No need for `next()` when you do `end()`
243 |         res.end();
244 |       },
245 |     ],
246 |   }));
247 |   server.serve(8100);
248 | 
249 |   let data = await makeRequestTo(t, server, "/sample");
250 |   t.true(data.includes("<script "));
251 |   t.true(data.startsWith("First Second "));
252 | 
253 |   await server.close();
254 | });
255 | 
256 | test("Two middlewares, end() in the first, skip the second", async t => {
257 |   let server = new EleventyDevServer("test-server", "./test/stubs/", getOptions({
258 |     // enabled: false,
259 |     middleware: [
260 |       async function(req, res, next) {
261 |         res.writeHead(200, {"Content-Type": "text/html"});
262 |         res.write("First ");
263 |         res.end();
264 |       },
265 |       async function(req, res, next) {
266 |         res.body += "Second ";
267 | 
268 |         next();
269 |       },
270 |     ],
271 |   }));
272 |   server.serve(8100);
273 | 
274 |   let data = await makeRequestTo(t, server, "/sample");
275 |   t.true(data.includes("<script "));
276 |   t.true(data.startsWith("First "));
277 |   t.true(!data.startsWith("First Second "));
278 | 
279 |   await server.close();
280 | });
281 | 
282 | test("Fun unicode paths", async t => {
283 |   let server = new EleventyDevServer("test-server", "./test/stubs/", getOptions());
284 |   server.serve(8100);
285 | 
286 |   let data = await makeRequestTo(t, server, encodeURI(`/zach’s.html`));
287 |   t.true(data.includes("<script "));
288 |   t.true(data.startsWith("This is a test"));
289 | 
290 |   await server.close();
291 | });
292 | 
293 | test("Content-Type header via middleware", async t => {
294 |   let server = new EleventyDevServer("test-server", "./test/stubs/", getOptions({
295 |     middleware: [
296 |       function (req, res, next) {
297 |         if (/.*\.php$/.test(req.url)) {
298 |           res.setHeader('Content-Type', 'text/html; charset=utf-8');
299 |         }
300 | 
301 |         next();
302 |       }
303 |     ]
304 |   }));
305 |   server.serve(8100);
306 | 
307 |   let data = await fetchHeadersForRequest(t, server, encodeURI(`/index.php`));
308 |   t.true(data['content-type'] === 'text/html; charset=utf-8');
309 | 
310 |   await server.close();
311 | });
312 | 
313 | test("Content-Range request", async (t) => {
314 |   let server = new EleventyDevServer(
315 |     "test-server",
316 |     "./test/stubs/",
317 |     getOptions()
318 |   );
319 |   server.serve(8100);
320 | 
321 |   const options = { headers: { Range: "bytes=0-48" } };
322 |   let data = await fetchHeadersForRequest(t, server, `/index.html`, options);
323 |   t.true("accept-ranges" in data);
324 |   t.true(data["accept-ranges"] === "bytes");
325 |   t.true("content-range" in data);
326 |   t.true(data["content-range"].startsWith("bytes 0-48/"));
327 | 
328 |   await server.close();
329 | });
330 | 
331 | test("Standard request does not include range headers", async (t) => {
332 |   let server = new EleventyDevServer(
333 |     "test-server",
334 |     "./test/stubs/",
335 |     getOptions()
336 |   );
337 |   server.serve(8100);
338 | 
339 |   let data = await fetchHeadersForRequest(t, server, `/index.html`);
340 |   t.false("accept-ranges" in data);
341 |   t.false("content-range" in data);
342 | 
343 |   await server.close();
344 | });
345 | 
346 | test("Setting default response headers", async (t) => {
347 |   let server = new EleventyDevServer(
348 |     "test-server",
349 |     "./test/stubs/",
350 |     getOptions({
351 |       headers: {
352 |         "access-control-allow-origin": "*",
353 |         "x-foo": "y-bar",
354 |       }
355 |     })
356 |   );
357 |   server.serve(8100);
358 | 
359 |   let data = await fetchHeadersForRequest(t, server, "/index.html");
360 |   t.true(data["access-control-allow-origin"] === "*");
361 |   t.true(data["x-foo"] === "y-bar");
362 | 
363 |   await server.close();
364 | });
365 | 
366 | test("Default response headers cannot overwrite content-type", async (t) => {
367 |   let server = new EleventyDevServer(
368 |     "test-server",
369 |     "./test/stubs/",
370 |     getOptions({
371 |       headers: {
372 |         "Content-Type": "text/plain",
373 |       }
374 |     })
375 |   );
376 |   server.serve(8100);
377 | 
378 |   let data = await fetchHeadersForRequest(t, server, "/index.html");
379 |   t.false(data["Content-Type"] === "text/plain");
380 | 
381 |   await server.close();
382 | });
383 | 


--------------------------------------------------------------------------------