@vit-foundation/ui 0.15.0 → 0.16.0

package/dist/utils/weekly-list.svelte.js

@@ -0,0 +1,120 @@
+import { buildQueryString } from './paths.js';
+import { createUrlFilters } from './url-filters.svelte.js';
+/**
+ * The weeklies index's URL defaults: the value a param stands for when it is
+ * absent. Both halves of the URL contract — this module omitting a default,
+ * the host's query schema supplying one — must name the same values, so a
+ * host derives its schema defaults from here rather than restating them.
+ */
+export const WEEKLY_LIST_DEFAULTS = { sort: 'desc', page: 1 };
+/** The index's path, shared by the mirrored URL and the paging hrefs. */
+const WEEKLIES_PATH = '/weeklies';
+/**
+ * The weeklies index view: the filters that ride the URL, the page the
+ * server rendered, and the page a filter change refetched in place.
+ *
+ * The two disagree by design — a changed filter returns to the first page
+ * while the URL still carries the old one — and reconciling them was four
+ * `$state` cells, an `$effect` and three `$derived` sitting in a route file,
+ * where nothing could reach them. Two things went wrong there: `loadError`
+ * was never cleared on navigation, so a failed refetch kept its alert on
+ * screen above fresh results; and a failed refetch left the URL, the grid
+ * and the pagination status giving three different answers.
+ *
+ * `createUrlFilters` owns the URL and deliberately not the fetching, because
+ * the transparency page filters client-side over data it already has. This
+ * owns the fetching and the reconciliation, for the one page that does both.
+ */
+export function createWeeklyList(config) {
+    // The client's answer, or null while the server's still stands.
+    let clientItems = $state(null);
+    let clientTotal = $state(null);
+    let isLoading = $state(false);
+    let loadError = $state(false);
+    const filters = createUrlFilters({
+        path: WEEKLIES_PATH,
+        initial: () => ({ ...config.server().query }),
+        // A param is left out exactly when it holds the value the parse would
+        // have supplied anyway, so both sides read the same declaration —
+        // otherwise "oldest first" builds a link that reloads as newest-first.
+        toQuery: (values) => ({
+            q: values.q,
+            theme: values.theme,
+            sort: values.sort !== WEEKLY_LIST_DEFAULTS.sort ? values.sort : null
+        }),
+        onChange: () => void refresh(),
+        replaceUrl: config.replaceUrl
+    });
+    $effect(() => {
+        // Paging is a real navigation, so the load re-runs and replaces the
+        // server data. Reading it here registers the dependency and drops the
+        // client override, which would otherwise keep the previous filter's
+        // first page on screen while the URL claimed to be on page 2.
+        config.server();
+        clientItems = null;
+        clientTotal = null;
+        // Cleared with the rest: the route file reset only the two lists, so a
+        // refetch that failed kept its alert across the next navigation.
+        loadError = false;
+    });
+    async function refresh() {
+        isLoading = true;
+        const { q, theme, sort } = filters.values;
+        try {
+            const result = await config.fetchPage({
+                q: q || undefined,
+                theme,
+                sort,
+                limit: config.server().pageSize,
+                locale: config.locale()
+            });
+            clientItems = result.items;
+            clientTotal = result.total;
+            loadError = false;
+        }
+        catch {
+            // Keep the stale list on screen; `loadError` explains the failure.
+            loadError = true;
+        }
+        finally {
+            isLoading = false;
+        }
+    }
+    return {
+        get items() {
+            return clientItems ?? config.server().weeklies;
+        },
+        get total() {
+            return clientTotal ?? config.server().total;
+        },
+        get page() {
+            return clientItems ? 1 : config.server().page;
+        },
+        get isLoading() {
+            return isLoading;
+        },
+        get loadError() {
+            return loadError;
+        },
+        get filters() {
+            return filters.values;
+        },
+        /**
+         * Paging is this module's concern and not the URL module's — the
+         * transparency page filters a list it already has and has no page at
+         * all — so the page number is added here rather than held in the
+         * filter state. That is also what makes a filter change drop it: the
+         * mirrored URL carries only filters, and a changed filter invalidates
+         * the position within the old result set.
+         */
+        hrefFor(page) {
+            return `${WEEKLIES_PATH}${buildQueryString({
+                ...filters.query,
+                page: page > WEEKLY_LIST_DEFAULTS.page ? String(page) : null
+            })}`;
+        },
+        update(patch) {
+            filters.update(patch);
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vit-foundation/ui",
-	"version": "0.15.0",
+	"version": "0.16.0",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run prepack",