@abreen/tada 1.5.8 → 1.6.2

package/README.md

@@ -1,5 +1,8 @@
 # Tada :tada:
 
+[![CI/CD](https://github.com/abreen/Tada/actions/workflows/ci.yml/badge.svg)](https://github.com/abreen/Tada/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/%40abreen%2Ftada)](https://www.npmjs.com/package/@abreen/tada)
+
 A static site generator. The successor to Presto.
 
 ## Features

package/build/build-manifest.ts

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { toPosix } from './utils/paths';
 
 const EXCLUDED_DIRS = new Set(['pagefind']);
 const EXCLUDED_FILES = new Set(['tada.manifest.json']);
@@ -68,7 +69,7 @@ export async function walkAndHash(
     }
 
     const abs = path.join(entry.parentPath, entry.name);
-    const rel = path.relative(dir, abs).split(path.sep).join(path.posix.sep);
+    const rel = toPosix(path.relative(dir, abs));
 
     const topLevel = rel.split('/')[0];
     if (EXCLUDED_DIRS.has(topLevel)) {

package/build/bundle.ts

@@ -3,8 +3,13 @@ import os from 'os';
 import path from 'path';
 import _ from 'lodash';
 import * as sass from 'sass';
-import { getPackageDir, getProjectDir, getDistDir } from './utils/paths';
-import { deriveTheme } from './utils/derive-theme';
+import {
+  getPackageDir,
+  getProjectDir,
+  getDistDir,
+  toPosix,
+} from './utils/paths';
+import { deriveTheme, deriveLinkHue } from './utils/derive-theme';
 import type { PluginBuilder } from 'bun';
 import type { SiteVariables } from './types';
 import timezones from '../src/timezone/timezones.json' with { type: 'json' };
@@ -22,6 +27,12 @@ function renderThemeScss(siteVariables: SiteVariables): string {
   const iconColorHoverDark = `hsl(${tintHue}deg ${(6 * tintAmount) / 100}% 60%)`;
   const iconColorTranslucentDark = `hsl(${tintHue}deg ${(85 * tintAmount) / 100}% 90%)`;
 
+  const linkHue = deriveLinkHue(tintHue);
+  const linkColor = `hsl(${linkHue}deg 44.4% 49.4%)`;
+  const linkColorHover = `hsl(${linkHue}deg 34% 60%)`;
+  const linkColorDark = `hsl(${linkHue}deg 50% 72%)`;
+  const linkColorHoverDark = `hsl(${linkHue}deg 40% 80%)`;
+
   const rendered = _.template(template)({
     ...theme,
     tintHue,
@@ -31,6 +42,10 @@ function renderThemeScss(siteVariables: SiteVariables): string {
     iconColorDark,
     iconColorHoverDark,
     iconColorTranslucentDark,
+    linkColor,
+    linkColorHover,
+    linkColorDark,
+    linkColorHoverDark,
   });
 
   const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tada-'));
@@ -104,10 +119,7 @@ export async function bundle(
 
   // Return the output filenames for asset tag injection
   const assetFiles = result.outputs.map(output =>
-    path
-      .relative(resolvedDistDir, output.path)
-      .split(path.sep)
-      .join(path.posix.sep),
+    toPosix(path.relative(resolvedDistDir, output.path)),
   );
 
   return assetFiles;

package/build/copy.ts

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { toPosix } from './utils/paths';
 import { makeLogger } from './log';
 import { B } from './colors';
 
@@ -22,7 +23,7 @@ function collectFiles(dir: string): CollectedFile[] {
     .map(entry => {
       const abs = path.join(entry.parentPath, entry.name);
       const rel = path.relative(dir, abs);
-      return { abs, rel: rel.split(path.sep).join(path.posix.sep) };
+      return { abs, rel: toPosix(rel) };
     });
 }
 
@@ -83,10 +84,7 @@ export function copyPublicFile(
   filePath: string,
   contentAssetRelPaths?: Set<string>,
 ): void {
-  const rel = path
-    .relative(publicDir, filePath)
-    .split(path.sep)
-    .join(path.posix.sep);
+  const rel = toPosix(path.relative(publicDir, filePath));
   if (contentAssetRelPaths && contentAssetRelPaths.has(rel)) {
     log.error`public/${B`${rel}`} conflicts with content/${B`${rel}`}`;
     throw new Error(`public/${rel} and content/${rel} have the same path`);
@@ -103,10 +101,7 @@ export function copyContentFile(
   filePath: string,
   publicRelPaths?: Set<string>,
 ): void {
-  const rel = path
-    .relative(contentDir, filePath)
-    .split(path.sep)
-    .join(path.posix.sep);
+  const rel = toPosix(path.relative(contentDir, filePath));
   if (publicRelPaths && publicRelPaths.has(rel)) {
     log.error`content/${B`${rel}`} conflicts with public/${B`${rel}`}`;
     throw new Error(`content/${rel} and public/${rel} have the same path`);

package/build/external-links-plugin.ts

@@ -1,5 +1,5 @@
 import type MarkdownIt from 'markdown-it';
-import type Token from 'markdown-it/lib/token.mjs';
+import Token from 'markdown-it/lib/token.mjs';
 import { makeLogger } from './log';
 import type { SiteVariables } from './types';
 
@@ -9,38 +9,197 @@ export default function externalLinks(
   md: MarkdownIt,
   siteVariables: SiteVariables,
 ): void {
-  function addClass(token: Token): void {
-    if (token.type === 'link_open') {
-      const href = token.attrGet('href');
-      if (!href) {
-        return;
+  function isExternal(href: string): boolean {
+    if (!href.match(/^https?:\/\/.*$/)) {
+      return false;
+    }
+    const url = new URL(href);
+    return !siteVariables.internalDomains?.includes(url.host);
+  }
+
+  function findMatchingClose(children: Token[], openIdx: number): number {
+    let depth = 1;
+    for (let i = openIdx + 1; i < children.length; i++) {
+      if (children[i].type === 'link_open') {
+        depth++;
+      } else if (children[i].type === 'link_close') {
+        depth--;
+        if (depth === 0) {
+          return i;
+        }
       }
+    }
+    return -1;
+  }
+
+  function makeSpanOpen(): Token {
+    const t = new Token('html_inline', '', 0);
+    t.content = '<span class="external-link-tail">';
+    return t;
+  }
 
-      if (href.match(/^https?:\/\/.*$/)) {
-        const url = new URL(href);
-        if (!siteVariables.internalDomains?.includes(url.host)) {
-          const classAttr = token.attrGet('class');
-          let newClassAttr;
+  function makeSpanClose(): Token {
+    const t = new Token('html_inline', '', 0);
+    t.content = '</span>';
+    return t;
+  }
+
+  // Wrap the trailing word of an external link in
+  // <span class="external-link-tail"> so the icon (added via that span's
+  // ::after) stays glued to the last word and doesn't wrap on its own.
+  // The span is inserted inside any inline-formatting elements (em,
+  // strong, code, ...) that are still open at the split point, so the
+  // resulting markup stays nested.
+  function wrapTail(linkChildren: Token[]): Token[] | null {
+    if (linkChildren.length === 0) {
+      return null;
+    }
 
-          if (classAttr) {
-            newClassAttr = classAttr + ' external';
-          } else {
-            newClassAttr = 'external';
-          }
+    // Find the rightmost split char (space or hyphen) in a text token,
+    // skipping any candidate that would produce an empty tail (e.g. a
+    // trailing hyphen with no content after it).
+    let splitTokenIdx = -1;
+    let splitCharIdx = -1;
+    for (let i = linkChildren.length - 1; i >= 0; i--) {
+      const tok = linkChildren[i];
+      if (tok.type !== 'text') {
+        continue;
+      }
+      const text = tok.content;
+      const hasLaterTokens = i < linkChildren.length - 1;
+      let foundIdx = -1;
+      for (let j = text.length - 1; j >= 0; j--) {
+        const c = text[j];
+        if (c !== ' ' && c !== '-') {
+          continue;
+        }
+        if (j < text.length - 1 || hasLaterTokens) {
+          foundIdx = j;
+          break;
+        }
+      }
+      if (foundIdx !== -1) {
+        splitTokenIdx = i;
+        splitCharIdx = foundIdx;
+        break;
+      }
+    }
 
-          log.debug`${href} -> "${newClassAttr}"`;
-          token.attrSet('class', newClassAttr);
+    if (splitTokenIdx === -1) {
+      // No space anywhere in the link's text. Wrap the whole content.
+      return [makeSpanOpen(), ...linkChildren, makeSpanClose()];
+    }
 
-          log.debug`${href} -> target="_blank"`;
-          token.attrSet('target', '_blank');
+    // Find where to put the span close: walk forward from the split
+    // point tracking nesting depth (locally opened elements after the
+    // split). The span must close before any -1 token that would close
+    // an element that was already open at the split point.
+    let spanCloseIdx = linkChildren.length;
+    let depth = 0;
+    for (let i = splitTokenIdx + 1; i < linkChildren.length; i++) {
+      const tok = linkChildren[i];
+      if (tok.nesting === 1) {
+        depth++;
+      } else if (tok.nesting === -1) {
+        if (depth > 0) {
+          depth--;
+        } else {
+          spanCloseIdx = i;
+          break;
         }
       }
     }
 
-    token.children?.map(addClass);
+    const splitToken = linkChildren[splitTokenIdx];
+    const before = splitToken.content.slice(0, splitCharIdx + 1);
+    const after = splitToken.content.slice(splitCharIdx + 1);
+
+    const result: Token[] = [];
+
+    // Tokens before the split, unchanged.
+    for (let i = 0; i < splitTokenIdx; i++) {
+      result.push(linkChildren[i]);
+    }
+
+    // The "before" part of the split text token.
+    if (before.length > 0) {
+      const beforeToken = new Token('text', '', 0);
+      beforeToken.content = before;
+      result.push(beforeToken);
+    }
+
+    result.push(makeSpanOpen());
+
+    // The "after" part of the split text token.
+    if (after.length > 0) {
+      const afterToken = new Token('text', '', 0);
+      afterToken.content = after;
+      result.push(afterToken);
+    }
+
+    // Tokens between the split and the span close.
+    for (let i = splitTokenIdx + 1; i < spanCloseIdx; i++) {
+      result.push(linkChildren[i]);
+    }
+
+    result.push(makeSpanClose());
+
+    // Tokens from the span close position to the end.
+    for (let i = spanCloseIdx; i < linkChildren.length; i++) {
+      result.push(linkChildren[i]);
+    }
+
+    return result;
+  }
+
+  function processChildren(children: Token[]): Token[] {
+    const result: Token[] = [];
+    let i = 0;
+    while (i < children.length) {
+      const token = children[i];
+
+      if (token.type !== 'link_open') {
+        result.push(token);
+        i++;
+        continue;
+      }
+
+      const href = token.attrGet('href');
+      if (!href || !isExternal(href)) {
+        result.push(token);
+        i++;
+        continue;
+      }
+
+      const classAttr = token.attrGet('class');
+      const newClassAttr = classAttr ? `${classAttr} external` : 'external';
+      token.attrSet('class', newClassAttr);
+      token.attrSet('target', '_blank');
+      log.debug`${href} -> "${newClassAttr}"`;
+
+      const closeIdx = findMatchingClose(children, i);
+      if (closeIdx === -1) {
+        result.push(token);
+        i++;
+        continue;
+      }
+
+      const linkContent = children.slice(i + 1, closeIdx);
+      const wrapped = wrapTail(linkContent);
+
+      result.push(token);
+      result.push(...(wrapped ?? linkContent));
+      result.push(children[closeIdx]);
+      i = closeIdx + 1;
+    }
+    return result;
   }
 
   md.core.ruler.push('external_links', state => {
-    state.tokens.map(addClass);
+    state.tokens.forEach(token => {
+      if (token.children) {
+        token.children = processChildren(token.children);
+      }
+    });
   });
 }

package/build/generate-content-assets.ts

@@ -16,6 +16,7 @@ import {
 } from './util';
 import { isLiterateJava } from './utils/file-types';
 import { checkJavac } from './utils/literate-java';
+import { toPosix } from './utils/paths';
 import type {
   SiteVariables,
   Asset,
@@ -291,10 +292,7 @@ export class ContentRenderer {
     for (const filePath of buildContentFiles) {
       if (isLiterateJava(filePath)) {
         const parsed = path.parse(path.relative(contentDir, filePath));
-        const javaPath = path
-          .join(parsed.dir, parsed.name)
-          .split(path.sep)
-          .join(path.posix.sep);
+        const javaPath = toPosix(path.join(parsed.dir, parsed.name));
         literateJavaOutputPaths.add(`/${javaPath}`);
       }
     }

package/build/utils/content-files.ts

@@ -7,7 +7,7 @@ import {
   isLiterateJava,
   isPartial,
 } from './file-types';
-import { getPublicDir, normalizeOutputPath } from './paths';
+import { getPublicDir, normalizeOutputPath, toPosix } from './paths';
 
 function walkFiles(dir: string): string[] {
   return fs.readdirSync(dir).flatMap(file => {
@@ -111,18 +111,12 @@ export function getValidInternalTargets(
     const relPath = path.relative(contentDir, filePath);
     const parsed = path.parse(relPath);
     const ext = parsed.ext.toLowerCase();
-    const subPath = path
-      .join(parsed.dir, parsed.name)
-      .split(path.sep)
-      .join(path.posix.sep);
+    const subPath = toPosix(path.join(parsed.dir, parsed.name));
 
     if (isLiterateJava(filePath)) {
       // parsed.name is e.g. "VowelCounter.java"; the output page is
       // VowelCounter.java.html and the source file is VowelCounter.java
-      const javaSubPath = path
-        .join(parsed.dir, parsed.name)
-        .split(path.sep)
-        .join(path.posix.sep);
+      const javaSubPath = toPosix(path.join(parsed.dir, parsed.name));
       addGeneratedRouteAliases(targets, `/${javaSubPath}.html`);
       targets.add(normalizeOutputPath(`/${javaSubPath}`));
     } else if (extensionIsMarkdown(ext) || ext === '.html') {

package/build/utils/derive-theme.ts

@@ -14,6 +14,9 @@ const LIGHT_TEXT_L_MAX = 0.5;
 const DARK_TEXT_L_MIN = 0.7;
 const DARK_TEXT_L_MAX = 0.82;
 
+const LINK_ANCHOR_HUE = 212;
+const LINK_TINT_BLEND = 0.05;
+
 function clamp(v: number, min: number, max: number): number {
   return Math.min(Math.max(v, min), max);
 }
@@ -75,6 +78,11 @@ export function deriveTheme(cssColor: string): DerivedTheme {
   };
 }
 
+export function deriveLinkHue(tintHue: number): number {
+  const diff = ((tintHue - LINK_ANCHOR_HUE + 540) % 360) - 180;
+  return (LINK_ANCHOR_HUE + diff * LINK_TINT_BLEND + 360) % 360;
+}
+
 export function getTextOnColor(cssColor: string): '#fff' | '#000' {
   const parsed = parse(cssColor);
   if (!parsed) {

package/build/utils/paths.ts

@@ -45,8 +45,23 @@ export function createApplyBasePath(
   };
 }
 
+export function toPosix(p: string): string {
+  return p.split(path.sep).join(path.posix.sep);
+}
+
+/**
+ * Convert an OS-native relative filesystem path to a URL path: convert
+ * separators to '/', then percent-encode each segment so characters that
+ * are unsafe in URLs (space, ?, #, non-ASCII, etc.) are encoded. Use this
+ * anywhere a filesystem-derived path is emitted as an href or looked up
+ * against a URL-encoded href.
+ */
+export function toUrlPath(p: string): string {
+  return toPosix(p).split('/').map(encodeURIComponent).join('/');
+}
+
 export function normalizeOutputPath(outputPath: string): string {
-  const normalized = path.posix.normalize(outputPath);
+  const normalized = path.posix.normalize(toPosix(outputPath));
   if (normalized === '.' || normalized === '') {
     return '/';
   }

package/build/utils/render.ts

@@ -17,7 +17,12 @@ import {
 import { extensionIsMarkdown } from './file-types';
 import { createTraceHelpers } from './trace';
 import { createIncludeFunction } from './include';
-import { createApplyBasePath, normalizeOutputPath } from './paths';
+import {
+  createApplyBasePath,
+  normalizeOutputPath,
+  toPosix,
+  toUrlPath,
+} from './paths';
 import { parseFrontMatterAndContent } from './front-matter';
 import { createMarkdown } from './markdown';
 import { generateTocHtml, generateCodeTocHtml } from '../toc-plugin';
@@ -41,12 +46,17 @@ const log = makeLogger(import.meta.url);
 
 const REQUIRED_FRONT_MATTER_FIELDS = ['title'];
 
+function isWatchMode(assetFiles: string[]): boolean {
+  return assetFiles.some(f => f.includes('watch-reload-client'));
+}
+
 interface TemplateParametersInput {
   pageVariables: Record<string, unknown>;
   siteVariables: SiteVariables;
   content: string | null;
   applyBasePath: (subPath: string) => string;
   subPath: string;
+  isWatchMode: boolean;
 }
 
 function resolveAuthor(
@@ -96,6 +106,7 @@ function createTemplateParameters({
   content,
   applyBasePath,
   subPath,
+  isWatchMode,
 }: TemplateParametersInput): Record<string, unknown> {
   return {
     vars: siteVariables.vars || {},
@@ -106,6 +117,7 @@ function createTemplateParameters({
     page: pageVariables,
     content,
     applyBasePath,
+    isWatchMode,
   };
 }
 
@@ -164,10 +176,7 @@ export function injectKatexStylesheet(
 }
 
 function toContentAssetPath(contentDir: string, filePath: string): string {
-  return path
-    .relative(contentDir, filePath)
-    .split(path.sep)
-    .join(path.posix.sep);
+  return toPosix(path.relative(contentDir, filePath));
 }
 
 export function renderPlainTextPageAsset({
@@ -182,16 +191,18 @@ export function renderPlainTextPageAsset({
   javacAvailable,
 }: RenderPlainTextOptions): Asset[] {
   const { dir, name, ext } = path.parse(filePath);
-  const subPath = path.relative(contentDir, path.join(dir, name));
+  const subPath = toPosix(path.relative(contentDir, path.join(dir, name)));
   const applyBasePath = createApplyBasePath(siteVariables);
 
   log.info`Rendering page ${B`${subPath + ext}`}`;
+  const watchMode = isWatchMode(assetFiles);
   const { content, pageVariables, tocItems, alertIds } = renderPlainTextContent(
     filePath,
     subPath,
     siteVariables,
     applyBasePath,
     validInternalTargets,
+    watchMode,
     {
       validateInternalLinks: extensionIsMarkdown(ext.toLowerCase()),
       traceCache,
@@ -221,6 +232,7 @@ export function renderPlainTextPageAsset({
     content,
     applyBasePath,
     subPath,
+    isWatchMode: watchMode,
   });
 
   const templateHtml = render(
@@ -248,11 +260,11 @@ export function renderCodePageAsset({
   assetFiles,
 }: RenderCodePageOptions): Asset[] {
   const { dir, name, ext } = path.parse(filePath);
-  const subPath = path.relative(contentDir, path.join(dir, name));
+  const subPath = toPosix(path.relative(contentDir, path.join(dir, name)));
   const applyBasePath = createApplyBasePath(siteVariables);
   const lang = siteVariables.codeLanguages![ext.slice(1).toLowerCase()];
   const sourceCode = fs.readFileSync(filePath, 'utf-8');
-  const pageDirPath = path.relative(contentDir, dir);
+  const pageDirPath = toPosix(path.relative(contentDir, dir));
 
   log.info`Rendering code page ${B`${subPath + ext}`}`;
   const content = renderCodeWithComments(
@@ -262,7 +274,7 @@ export function renderCodePageAsset({
     pageDirPath,
   );
   const codeFilePath = applyBasePath(
-    normalizeOutputPath(`/${toContentAssetPath(contentDir, filePath)}`),
+    normalizeOutputPath(`/${toUrlPath(path.relative(contentDir, filePath))}`),
   );
   const titleHtml = `<tt>${name + ext}</tt>`;
   const tocItems = lang === 'java' ? extractJavaMethodToc(sourceCode) : [];
@@ -284,6 +296,7 @@ export function renderCodePageAsset({
     content,
     applyBasePath,
     subPath,
+    isWatchMode: isWatchMode(assetFiles),
   });
 
   const html = injectAssetTags(
@@ -316,7 +329,9 @@ export function renderCopiedContentAsset({
 
   if (filePath.endsWith('.java') && isFeatureEnabled(siteVariables, 'code')) {
     const sourceCode = fs.readFileSync(filePath, 'utf-8');
-    const pageDirPath = path.relative(contentDir, path.dirname(filePath));
+    const pageDirPath = toPosix(
+      path.relative(contentDir, path.dirname(filePath)),
+    );
     const rewrittenLines = rewriteProseLinks(
       sourceCode.split('\n'),
       siteVariables,
@@ -335,6 +350,7 @@ function renderPlainTextContent(
   siteVariables: SiteVariables,
   applyBasePath: (subPath: string) => string,
   validInternalTargets: Set<string>,
+  isWatchMode: boolean,
   {
     validateInternalLinks = true,
     traceCache,
@@ -392,6 +408,7 @@ function renderPlainTextContent(
     content: null,
     applyBasePath,
     subPath,
+    isWatchMode,
   });
   const pageVariablesProcessed: Record<string, unknown> = Object.entries(
     pageVariables,
@@ -442,6 +459,7 @@ function renderPlainTextContent(
     content: strippedContent,
     applyBasePath,
     subPath,
+    isWatchMode,
   });
 
   if (traceCache && contentDir && distDir) {
@@ -501,7 +519,7 @@ export function renderLiterateJavaPageAsset({
 }: RenderLiterateJavaOptions): Asset[] {
   const { dir, name } = path.parse(filePath);
   const className = deriveClassName(filePath);
-  const subPath = path.relative(contentDir, path.join(dir, className));
+  const subPath = toPosix(path.relative(contentDir, path.join(dir, className)));
   const applyBasePath = createApplyBasePath(siteVariables);
 
   log.info`Rendering literate Java page ${B`${name}`}`;
@@ -619,7 +637,7 @@ export function renderLiterateJavaPageAsset({
   const javaFileName = `${className}.java`;
   const codeFilePath = applyBasePath(
     normalizeOutputPath(
-      `/${toContentAssetPath(contentDir, path.join(dir, javaFileName))}`,
+      `/${toUrlPath(path.relative(contentDir, path.join(dir, javaFileName)))}`,
     ),
   );
 
@@ -645,6 +663,7 @@ export function renderLiterateJavaPageAsset({
     content: contentHtml,
     applyBasePath,
     subPath,
+    isWatchMode: isWatchMode(assetFiles),
   });
 
   const templateHtml = render('literate.html', templateParameters) as string;

package/build/utils/trace.ts

@@ -4,7 +4,7 @@ import path from 'path';
 import { execFileSync } from 'child_process';
 import { makeLogger } from '../log';
 import { B } from '../colors';
-import { normalizeOutputPath } from './paths';
+import { normalizeOutputPath, toPosix } from './paths';
 import { hasMainMethod } from './literate-java';
 import { renderCodeSegment } from './code';
 import { computeLayout } from './trace-layout';
@@ -324,10 +324,7 @@ export function createTraceHelpers(context: TraceContext): {
 
       const highlightedSource = highlightSource(javaFile, source);
 
-      const relDir = path
-        .relative(contentDir, pageDir)
-        .split(path.sep)
-        .join(path.posix.sep);
+      const relDir = toPosix(path.relative(contentDir, pageDir));
       const traceOutputDir = path.join(distDir, relDir, '_traces', className);
 
       const manifest = chunkTraceOutput(

package/build/validate-internal-links-plugin.ts

@@ -69,7 +69,18 @@ function resolveLinkPath(
     ? normalizePathname(hrefPath)
     : normalizePathname(path.posix.join(sourceDir, hrefPath));
 
-  return rewriteCodeLink(resolved, codeExtPattern);
+  // Decode percent-encoded characters so the resolved path can be matched
+  // against `validTargets`, which contains raw filesystem-derived paths.
+  // markdown-it's normalizeLink percent-encodes hrefs, so a link like
+  // `[x](/my notes.md)` arrives here as `/my%20notes.md`.
+  let decoded: string;
+  try {
+    decoded = normalizePathname(decodeURIComponent(resolved));
+  } catch {
+    decoded = resolved;
+  }
+
+  return rewriteCodeLink(decoded, codeExtPattern);
 }
 
 function getDirectoryIndexPath(pathname: string): string {

package/build/watch-reload-client.ts

@@ -26,6 +26,7 @@ declare const __WEBSOCKET_PORT__: number;
       document.body.classList.add('loading-cursor');
     } else if (event.data === 'reload') {
       console.log('[watch-reload] Reloading page...');
+      window.history.scrollRestoration = 'auto';
       window.location.reload();
     }
   };