@xingwangzhe/stalux 1.35.11 → 1.35.13

package/src/scripts/pagefind-api.ts

@@ -0,0 +1,63 @@
+import { sitePath } from "../utils/site-path";
+import { createClientLogger } from "./logger";
+
+export interface PagefindData {
+    url: string;
+    meta?: { title?: string };
+    plain_excerpt?: string;
+    content?: string;
+}
+
+export interface PagefindApi {
+    search: (
+        query: string | null,
+        options?: { filters?: Record<string, string> },
+    ) => Promise<{
+        results: Array<{ data: () => Promise<PagefindData> }>;
+    }>;
+}
+
+/** Share successful imports and in-flight work; a failed attempt remains retryable. */
+export function createPagefindLoader(
+    importModule: (url: string) => Promise<unknown> = (url) => import(/* @vite-ignore */ url),
+    origin: () => string = () => location.origin,
+    base = import.meta.env.BASE_URL,
+): () => Promise<PagefindApi | null> {
+    let pending: Promise<PagefindApi | null> | undefined;
+    let failedAttempts = 0;
+    const logger = createClientLogger("webmcp/pagefind");
+    return () => {
+        if (!pending) {
+            pending = (async () => {
+                try {
+                    const url = new URL(sitePath("pagefind/pagefind.js", base), origin());
+                    // Browsers can retain a failed ESM fetch; retry with a fresh module URL.
+                    if (failedAttempts)
+                        url.searchParams.set("stalux_retry", String(failedAttempts));
+                    const loaded = await importModule(url.href);
+                    const namespace = loaded as {
+                        default?: PagefindApi;
+                        search?: PagefindApi["search"];
+                    };
+                    const api = namespace.default ?? namespace;
+                    if (typeof api.search !== "function")
+                        throw new Error("Invalid Pagefind module");
+                    return api as PagefindApi;
+                } catch {
+                    failedAttempts++;
+                    logger.warn(
+                        "Pagefind index unavailable; build the static search index and retry",
+                    );
+                    return null;
+                }
+            })();
+            const attempt = pending;
+            void attempt.then((result) => {
+                if (!result && pending === attempt) pending = undefined;
+            });
+        }
+        return pending;
+    };
+}
+
+export const loadPagefind = createPagefindLoader();

package/src/scripts/photoswipe.ts

@@ -7,9 +7,10 @@ const logger = createClientLogger("photoswipe");
 
 const GALLERY_SELECTOR = "a.pswp-gallery-item";
 
-async function enrichPhotoSwipeData(container: Element): Promise<void> {
+async function enrichPhotoSwipeData(container: Element, signal: AbortSignal): Promise<void> {
     const links = container.querySelectorAll<HTMLAnchorElement>(GALLERY_SELECTOR);
     for (const link of links) {
+        if (signal.aborted) return;
         const image = link.querySelector<HTMLImageElement>("img");
         if (!image) continue;
 
@@ -21,12 +22,18 @@ async function enrichPhotoSwipeData(container: Element): Promise<void> {
 
         const temporaryImage = new Image();
         temporaryImage.src = image.currentSrc || image.src;
+        const cancel = () => temporaryImage.removeAttribute("src");
+        signal.addEventListener("abort", cancel, { once: true });
         try {
             await temporaryImage.decode();
         } catch {
+            if (signal.aborted) return;
             logger.debug("image dimensions unavailable; skipping enrichment");
             continue;
+        } finally {
+            signal.removeEventListener("abort", cancel);
         }
+        if (signal.aborted) return;
         link.dataset.pswpWidth = String(temporaryImage.naturalWidth);
         link.dataset.pswpHeight = String(temporaryImage.naturalHeight);
     }
@@ -41,6 +48,7 @@ registerPageLifecycle("photoswipe", () => {
     const controller = new AbortController();
     let lightbox: import("photoswipe/lightbox").default | undefined;
     let initialized = false;
+    let disposed = false;
 
     const initialize = async () => {
         logger.debug("loading lightbox modules");
@@ -48,8 +56,8 @@ registerPageLifecycle("photoswipe", () => {
             import("photoswipe/lightbox"),
             import("photoswipe"),
         ]);
-
-        void enrichPhotoSwipeData(container);
+        if (disposed) return;
+        void enrichPhotoSwipeData(container, controller.signal);
         lightbox = new PhotoSwipeLightbox({
             gallery: container,
             children: GALLERY_SELECTOR,
@@ -77,6 +85,7 @@ registerPageLifecycle("photoswipe", () => {
 
         void ensureInitialized()
             .then(() => {
+                if (disposed) return;
                 initialized = true;
                 logger.debug(`opening image index=${clickedIndex}`);
                 lightbox?.loadAndOpen(clickedIndex, undefined, initialPoint);
@@ -92,6 +101,7 @@ registerPageLifecycle("photoswipe", () => {
     });
 
     return () => {
+        disposed = true;
         controller.abort();
         lightbox?.destroy();
         lightbox = undefined;

package/src/scripts/random-posts.ts

@@ -5,21 +5,23 @@ const logger = createClientLogger("random-posts");
 
 const sleep = (ms: number, signal: AbortSignal) =>
     new Promise<void>((resolve) => {
-        const timer = window.setTimeout(resolve, ms);
-        signal.addEventListener(
-            "abort",
-            () => {
-                window.clearTimeout(timer);
-                resolve();
-            },
-            { once: true },
-        );
+        const finish = () => {
+            signal.removeEventListener("abort", aborted);
+            resolve();
+        };
+        const timer = window.setTimeout(finish, ms);
+        const aborted = () => {
+            window.clearTimeout(timer);
+            finish();
+        };
+        if (signal.aborted) aborted();
+        else signal.addEventListener("abort", aborted, { once: true });
     });
 
 function shuffle<T extends object>(items: T[]): T[] {
     const result = [...items];
+    const bytes = new Uint32Array(1);
     for (let i = result.length - 1; i > 0; i -= 1) {
-        const bytes = new Uint32Array(1);
         const j = (crypto.getRandomValues(bytes)[0] ?? 0) % (i + 1);
         const current = result[i];
         const target = result[j];

package/src/scripts/search-dialog.ts

@@ -34,9 +34,10 @@ export async function ensureSearchStyles(link: HTMLLinkElement | null): Promise<
 export async function upgradeAndOpenSearchDialog<ElementType extends SearchDialogLike>(
     registry: CustomElementRegistryLike<ElementType>,
     dialog: ElementType | null,
+    signal?: AbortSignal,
 ): Promise<void> {
     await registry.whenDefined("pagefind-modal");
-    if (!dialog) return;
+    if (!dialog || signal?.aborted) return;
     registry.upgrade(dialog);
     dialog.open?.();
 }

package/src/scripts/view-transitions.ts

@@ -1,5 +1,6 @@
 import { getRouteKind } from "@utils/public-routes";
 import { createClientLogger } from "./logger";
+import { prepareNavigationFont } from "./navigation-font";
 
 const logger = createClientLogger("view-transitions");
 
@@ -19,6 +20,9 @@ interface NavigationEvent {
     from: URL;
     to: URL;
     direction: string;
+    loader: () => Promise<void>;
+    newDocument: Document;
+    signal: AbortSignal;
 }
 
 function setNavigationState(event: NavigationEvent): void {
@@ -35,7 +39,14 @@ if (!transitionWindow.__STALUX_VT_LISTENER__) {
     transitionWindow.__STALUX_VT_LISTENER__ = true;
 
     document.addEventListener("astro:before-preparation", (event) => {
-        setNavigationState(event as NavigationEvent);
+        const navigation = event as unknown as NavigationEvent;
+        setNavigationState(navigation);
+        const loader = navigation.loader;
+        navigation.loader = async () => {
+            await loader();
+            if (!event.defaultPrevented)
+                await prepareNavigationFont(navigation.newDocument, navigation.signal);
+        };
     });
 
     document.addEventListener("astro:after-swap", () => {