21

assets/scripts/pages/house.js

@@ -0,0 +1,356 @@
+(function () {
+  "use strict";
+
+  const STORAGE_KEY = "zxh_house_of_pages_v1";
+  const MAIN_ROOM_IDS = Object.freeze([
+    "foyer", "library", "study", "kitchen", "workshop", "playroom", "attic", "garden"
+  ]);
+
+  const ROOMS = Object.freeze({
+    foyer: room({
+      title: "Foyer",
+      eyebrow: "Arrivals",
+      description: "The front door opens onto the newest corners of the site.",
+      caption: "A brass key waits in a blue bowl beside the door.",
+      curated: [
+        ["Home", "/"],
+        ["Recently updated", "/recently-updated.html"],
+        ["Contact", "/home/contact.html"]
+      ],
+      include: ["/recently-updated.html", "/home/contact.html"]
+    }),
+    library: room({
+      title: "Library",
+      eyebrow: "Knowledge",
+      description: "Notes and lasting ideas gather here, arranged less strictly than the shelves suggest.",
+      caption: "One book has been returned with a pressed leaf instead of a bookmark.",
+      curated: [
+        ["All posts", "/posts/posts-list.html"],
+        ["Categories", "/home/categories.html"],
+        ["Posts introduction", "/posts/posts-intro.html"]
+      ],
+      include: ["/posts/"],
+      exclude: ["/posts/career/"]
+    }),
+    study: room({
+      title: "Study",
+      eyebrow: "Work",
+      description: "Engineering notes, professional lessons, and active competencies cover the desk.",
+      caption: "The lamp is still warm; somebody meant to come back after tea.",
+      curated: [
+        ["Career library", "/posts/career/career-list.html"],
+        ["Competency status", "/home/status.html"],
+        ["Probation objectives", "/posts/career/probation-objectives.html"]
+      ],
+      include: ["/posts/career/"]
+    }),
+    kitchen: room({
+      title: "Kitchen",
+      eyebrow: "Daily life",
+      description: "Weekly reviews and ordinary days stay close to the kettle.",
+      caption: "A shopping list shares the table with a thought worth keeping.",
+      curated: [
+        ["All blogs", "/blogs/blogs-list.html"],
+        ["Weekly reviews", "/tags/review.html"],
+        ["Blog introduction", "/blogs/blogs-intro.html"]
+      ],
+      include: ["/blogs/"]
+    }),
+    workshop: room({
+      title: "Workshop",
+      eyebrow: "Living systems",
+      description: "Trackers, services, plans, and practical machinery keep the house running.",
+      caption: "Every drawer is labelled except the one containing all the labels.",
+      curated: [
+        ["Services", "/home/services.html"],
+        ["Wird tracker", "/home/wird-tracker.html"],
+        ["Countdowns", "/home/countdown.html"],
+        ["Backlog", "/home/backlog.html"]
+      ],
+      include: ["/home/services.html", "/home/wird-tracker.html", "/home/countdown.html", "/home/backlog.html"]
+    }),
+    playroom: room({
+      title: "Playroom",
+      eyebrow: "Experiments",
+      description: "Games, generators, puzzles, and stranger little mechanisms wait on the floor.",
+      caption: "A wooden moon rolls beneath the cabinet whenever nobody is looking.",
+      curated: [
+        ["Play hub", "/play/play.html"],
+        ["Ash Below the Lake", "/play/rpg.html"],
+        ["The Rain Index", "/play/the-rain-index.html"]
+      ],
+      include: ["/play/"],
+      exclude: ["/play/house.html", "/play/play.html"]
+    }),
+    attic: room({
+      title: "Attic",
+      eyebrow: "Keepsakes",
+      description: "Personal fragments and older writing rest beneath the roof beams.",
+      caption: "The smallest box is labelled: things that became important later.",
+      curated: [
+        ["Lima archive", "/lima/index.html"],
+        ["Blog archive", "/blogs/blogs-list.html"],
+        ["Memory Cabinet", "/play/memory.html"]
+      ],
+      include: ["/lima/", "/blogs/2025/"]
+    }),
+    garden: room({
+      title: "Garden",
+      eyebrow: "Notes left outside",
+      description: "Loose notes, paths between topics, and recently tended pages grow beyond the back step.",
+      caption: "Someone has tied a question to the pear tree with green thread.",
+      curated: [
+        ["Notes wall", "/home/notes.html"],
+        ["Categories", "/home/categories.html"],
+        ["Recently updated", "/recently-updated.html"],
+        ["Sitemap", "/sitemap.html"]
+      ],
+      include: ["/tags/", "/home/notes.html", "/home/categories.html"]
+    }),
+    archive: room({
+      title: "Archive Room",
+      eyebrow: "The Ninth Door",
+      description: "The house keeps one room for the shape of itself: maps, labels, plans, and unfinished intentions.",
+      caption: "On the inside of the door: A house is an index that learned how to wait.",
+      curated: [
+        ["Sitemap", "/sitemap.html"],
+        ["Categories", "/home/categories.html"],
+        ["Backlog", "/home/backlog.html"]
+      ],
+      include: ["/sitemap.html", "/home/categories.html", "/home/backlog.html"]
+    })
+  });
+
+  function room(config) {
+    return Object.freeze(Object.assign({ exclude: [] }, config, {
+      curated: Object.freeze(config.curated.map((link) => Object.freeze(link.slice()))),
+      include: Object.freeze(config.include.slice()),
+      exclude: Object.freeze((config.exclude || []).slice())
+    }));
+  }
+
+  document.addEventListener("DOMContentLoaded", () => {
+    const root = document.querySelector('.house-root[data-play-page="house"]');
+    if (!root) return;
+    initHouse(root);
+  });
+
+  function initHouse(root) {
+    const roomButtons = Array.from(root.querySelectorAll("[data-house-room]"));
+    const mainButtons = roomButtons.filter((button) => MAIN_ROOM_IDS.includes(button.dataset.houseRoom));
+    const secretButton = root.querySelector(".house-secret-door");
+    const panel = root.querySelector("[data-house-panel]");
+    const status = root.querySelector("[data-house-status]");
+    const reset = root.querySelector("[data-house-reset]");
+    const state = loadState();
+    let pages = [];
+    let indexStatus = "loading";
+
+    root.classList.add("is-enhanced");
+    state.visited = state.visited.filter((id) => MAIN_ROOM_IDS.includes(id));
+    if (state.visited.length === MAIN_ROOM_IDS.length) state.secretUnlocked = true;
+    renderSecret();
+
+    roomButtons.forEach((button) => {
+      button.addEventListener("click", () => selectRoom(button.dataset.houseRoom, true));
+      button.addEventListener("keydown", (event) => moveRoomFocus(event, button));
+    });
+
+    reset.addEventListener("click", () => {
+      state.visited = [];
+      state.secretUnlocked = false;
+      saveState(state);
+      roomButtons.forEach((button) => button.classList.remove("is-visited"));
+      renderSecret();
+      selectRoom("foyer", false);
+      status.textContent = "The house has forgotten this visit. Choose a room to begin again.";
+    });
+
+    fetch("/search-index.json", { credentials: "same-origin" })
+      .then((response) => {
+        if (!response.ok) throw new Error(`Search index returned ${response.status}`);
+        return response.json();
+      })
+      .then((index) => {
+        pages = flattenIndex(index);
+        indexStatus = "ready";
+        renderRoom(root.querySelector("[data-house-room][aria-selected='true']")?.dataset.houseRoom || "foyer");
+      })
+      .catch((error) => {
+        console.warn("House shelves could not be catalogued", error);
+        indexStatus = "failed";
+        renderRoom(root.querySelector("[data-house-room][aria-selected='true']")?.dataset.houseRoom || "foyer");
+      });
+
+    function selectRoom(id, countVisit) {
+      const config = ROOMS[id];
+      const selected = roomButtons.find((button) => button.dataset.houseRoom === id);
+      if (!config || !selected) return;
+
+      roomButtons.forEach((button) => {
+        const active = button === selected;
+        button.classList.toggle("is-selected", active);
+        button.setAttribute("aria-selected", String(active));
+        button.tabIndex = active ? 0 : -1;
+      });
+
+      if (countVisit && MAIN_ROOM_IDS.includes(id) && !state.visited.includes(id)) {
+        state.visited.push(id);
+        selected.classList.add("is-visited");
+        if (state.visited.length === MAIN_ROOM_IDS.length) state.secretUnlocked = true;
+        saveState(state);
+        renderSecret();
+      }
+
+      panel.setAttribute("aria-labelledby", selected.id);
+      root.dataset.houseActive = id;
+      renderRoom(id);
+      updateStatus();
+    }
+
+    function renderRoom(id) {
+      const config = ROOMS[id];
+      if (!config) return;
+      root.querySelector("[data-house-eyebrow]").textContent = config.eyebrow;
+      root.querySelector("[data-house-title]").textContent = config.title;
+      root.querySelector("[data-house-description]").textContent = config.description;
+      root.querySelector("[data-house-caption]").textContent = config.caption;
+      renderLinks(root.querySelector("[data-house-curated]"), config.curated.map(([title, href]) => ({ title, href })));
+
+      const dynamicList = root.querySelector("[data-house-dynamic]");
+      if (indexStatus === "loading") {
+        renderEmpty(dynamicList, "The shelves are being catalogued…");
+        return;
+      }
+      if (indexStatus === "failed") {
+        renderEmpty(dynamicList, "The shelves could not be catalogued today.");
+        return;
+      }
+
+      const curatedPaths = new Set(config.curated.map((link) => normalizePath(link[1])));
+      const matches = pages
+        .filter((page) => matchesRoom(page.path, config))
+        .filter((page) => !curatedPaths.has(page.path))
+        .filter((page) => !isGeneratedListing(page.path))
+        .sort((a, b) => a.path.localeCompare(b.path))
+        .slice(0, 4);
+
+      if (matches.length === 0) renderEmpty(dynamicList, "Nothing else is resting here yet.");
+      else renderLinks(dynamicList, matches.map((page) => ({ title: humanizeFilename(page.name), href: page.path })));
+    }
+
+    function renderSecret() {
+      secretButton.hidden = !state.secretUnlocked;
+      mainButtons.forEach((button) => button.classList.toggle("is-visited", state.visited.includes(button.dataset.houseRoom)));
+      root.classList.toggle("has-secret", state.secretUnlocked);
+    }
+
+    function updateStatus() {
+      if (state.secretUnlocked) {
+        status.textContent = "All eight rooms remember you. Somewhere nearby, a ninth door has appeared.";
+      } else {
+        const remaining = MAIN_ROOM_IDS.length - state.visited.length;
+        status.textContent = `${state.visited.length} of ${MAIN_ROOM_IDS.length} rooms visited · ${remaining} ${remaining === 1 ? "room" : "rooms"} still unlit.`;
+      }
+    }
+
+    function moveRoomFocus(event, current) {
+      if (!MAIN_ROOM_IDS.includes(current.dataset.houseRoom)) return;
+      const movement = { ArrowRight: 1, ArrowDown: 1, ArrowLeft: -1, ArrowUp: -1 }[event.key];
+      if (!movement) return;
+      event.preventDefault();
+      const index = mainButtons.indexOf(current);
+      const next = mainButtons[(index + movement + mainButtons.length) % mainButtons.length];
+      next.focus();
+      selectRoom(next.dataset.houseRoom, true);
+    }
+
+    selectRoom("foyer", true);
+  }
+
+  function flattenIndex(root) {
+    const found = [];
+    const seen = new Set();
+
+    function visit(node) {
+      if (!node || typeof node !== "object") return;
+      if (node.type === "file" && typeof node.url === "string") {
+        const path = normalizePath(node.url);
+        if (path.endsWith(".html") && !seen.has(path)) {
+          seen.add(path);
+          found.push({ name: node.name || path.split("/").pop(), path });
+        }
+      }
+      if (Array.isArray(node.children)) node.children.forEach(visit);
+    }
+
+    visit(root);
+    return found;
+  }
+
+  function matchesRoom(path, config) {
+    const included = config.include.some((prefix) => path.startsWith(normalizePath(prefix)));
+    const excluded = config.exclude.some((prefix) => path.startsWith(normalizePath(prefix)));
+    return included && !excluded && path !== "/play/house.html";
+  }
+
+  function isGeneratedListing(path) {
+    const filename = path.split("/").pop() || "";
+    return filename === "index.html" || filename.endsWith("-list.html") || filename.endsWith("-intro.html");
+  }
+
+  function humanizeFilename(name) {
+    return String(name || "Untitled page")
+      .replace(/\.html$/i, "")
+      .replace(/^\d{2}-\d{2}-/, "")
+      .replace(/[._-]+/g, " ")
+      .replace(/\b\w/g, (letter) => letter.toUpperCase())
+      .trim();
+  }
+
+  function normalizePath(path) {
+    const clean = String(path || "").replace(/\\/g, "/").split(/[?#]/)[0];
+    return clean.startsWith("/") ? clean : `/${clean}`;
+  }
+
+  function renderLinks(list, links) {
+    list.replaceChildren(...links.map(({ title, href }) => {
+      const item = document.createElement("li");
+      const anchor = document.createElement("a");
+      anchor.href = href;
+      anchor.textContent = title;
+      item.appendChild(anchor);
+      return item;
+    }));
+  }
+
+  function renderEmpty(list, message) {
+    const item = document.createElement("li");
+    item.className = "house-empty";
+    item.textContent = message;
+    list.replaceChildren(item);
+  }
+
+  function loadState() {
+    try {
+      const saved = JSON.parse(localStorage.getItem(STORAGE_KEY) || "{}");
+      return {
+        visited: Array.isArray(saved.visited) ? saved.visited.slice() : [],
+        secretUnlocked: saved.secretUnlocked === true
+      };
+    } catch (_error) {
+      return { visited: [], secretUnlocked: false };
+    }
+  }
+
+  function saveState(state) {
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify({
+        visited: state.visited,
+        secretUnlocked: state.secretUnlocked
+      }));
+    } catch (_error) {
+      // The house remains navigable when storage is unavailable.
+    }
+  }
+})();