pressy 0.1.0

package/dist/runtime/client.js

@@ -0,0 +1,660 @@
+// src/runtime/client.tsx
+import { render } from "preact";
+import { useState, useEffect } from "preact/hooks";
+import { signal as signal2, effect } from "@preact/signals";
+import { Reader, DownloadBook, BookProgress } from "@pressy-pub/components";
+import { useMDXComponents } from "@pressy-pub/components/content";
+
+// src/runtime/offline.ts
+import { signal } from "@preact/signals";
+var CACHED_BOOKS_KEY = "pressy-cached-books";
+var offlineStatus = signal("online");
+var cacheProgress = signal(null);
+var swReady = signal(false);
+function loadCachedBooks() {
+  if (typeof localStorage === "undefined") return /* @__PURE__ */ new Set();
+  try {
+    const stored = localStorage.getItem(CACHED_BOOKS_KEY);
+    if (stored) return new Set(JSON.parse(stored));
+  } catch {
+  }
+  return /* @__PURE__ */ new Set();
+}
+var cachedBooks = signal(loadCachedBooks());
+if (typeof window !== "undefined") {
+  offlineStatus.value = navigator.onLine ? "online" : "offline";
+  window.addEventListener("online", () => {
+    offlineStatus.value = "online";
+  });
+  window.addEventListener("offline", () => {
+    offlineStatus.value = "offline";
+  });
+}
+async function registerServiceWorker(basePath2 = "") {
+  if (!("serviceWorker" in navigator)) {
+    console.warn("Service workers are not supported");
+    return null;
+  }
+  const swUrl = basePath2 ? `${basePath2}/sw.js` : "/sw.js";
+  const scope = basePath2 ? `${basePath2}/` : "/";
+  try {
+    const registration = await navigator.serviceWorker.register(swUrl, {
+      scope
+    });
+    navigator.serviceWorker.addEventListener("message", handleSWMessage);
+    if (navigator.serviceWorker.controller) {
+      swReady.value = true;
+    } else {
+      navigator.serviceWorker.addEventListener("controllerchange", () => {
+        swReady.value = true;
+      });
+    }
+    registration.addEventListener("updatefound", () => {
+      const newWorker = registration.installing;
+      if (!newWorker) return;
+      newWorker.addEventListener("statechange", () => {
+        if (newWorker.state === "activated") {
+          swReady.value = true;
+        }
+      });
+    });
+    return registration;
+  } catch (err) {
+    console.error("Service worker registration failed:", err);
+    return null;
+  }
+}
+function persistCachedBooks() {
+  try {
+    localStorage.setItem(CACHED_BOOKS_KEY, JSON.stringify([...cachedBooks.value]));
+  } catch {
+  }
+}
+function handleSWMessage(event) {
+  const { type } = event.data;
+  if (type === "CACHE_PROGRESS") {
+    const { bookSlug, current, total } = event.data;
+    cacheProgress.value = { bookSlug, current, total };
+  }
+  if (type === "CACHE_COMPLETE") {
+    const { bookSlug } = event.data;
+    cacheProgress.value = null;
+    const newCached = new Set(cachedBooks.value);
+    newCached.add(bookSlug);
+    cachedBooks.value = newCached;
+    persistCachedBooks();
+  }
+  if (type === "CACHE_STATUS") {
+    const { cached } = event.data;
+    const newCached = /* @__PURE__ */ new Set();
+    for (const url of cached) {
+      const match = url.match(/\/books\/([^/]+)/);
+      if (match) {
+        newCached.add(match[1]);
+      }
+    }
+    cachedBooks.value = newCached;
+    persistCachedBooks();
+  }
+  if (type === "CACHE_CLEARED") {
+    const { bookSlug } = event.data;
+    const newCached = new Set(cachedBooks.value);
+    newCached.delete(bookSlug);
+    cachedBooks.value = newCached;
+    persistCachedBooks();
+  }
+}
+async function downloadBookForOffline(bookSlug, chapterUrls) {
+  if (!("serviceWorker" in navigator) || !navigator.serviceWorker.controller) {
+    console.warn("Service worker not available");
+    return false;
+  }
+  const urls = chapterUrls.map(
+    (url) => url.startsWith("http") ? url : `${window.location.origin}${url}`
+  );
+  cacheProgress.value = { bookSlug, current: 0, total: urls.length };
+  const newCached = new Set(cachedBooks.value);
+  newCached.add(bookSlug);
+  cachedBooks.value = newCached;
+  persistCachedBooks();
+  navigator.serviceWorker.controller.postMessage({
+    type: "CACHE_BOOK",
+    bookSlug,
+    urls
+  });
+  return true;
+}
+async function clearBookCache(bookSlug) {
+  const newCached = new Set(cachedBooks.value);
+  newCached.delete(bookSlug);
+  cachedBooks.value = newCached;
+  persistCachedBooks();
+  if (!("serviceWorker" in navigator) || !navigator.serviceWorker.controller) {
+    try {
+      const cache = await caches.open("pressy-offline-books");
+      const keys = await cache.keys();
+      for (const request of keys) {
+        if (request.url.includes(`/books/${bookSlug}`)) {
+          await cache.delete(request);
+        }
+      }
+      return true;
+    } catch (err) {
+      console.error("Failed to clear cache:", err);
+      return false;
+    }
+  }
+  navigator.serviceWorker.controller.postMessage({
+    type: "CLEAR_BOOK_CACHE",
+    bookSlug
+  });
+  return true;
+}
+
+// src/runtime/client.tsx
+import { jsx, jsxs } from "preact/jsx-runtime";
+var currentRoute = signal2("/");
+var currentTheme = signal2("light");
+var isOffline = signal2(!navigator.onLine);
+var DB_NAME = "pressy";
+var DB_VERSION = 1;
+var PROGRESS_STORE = "reading-progress";
+var UNLOCKS_STORE = "unlocks";
+var db = null;
+async function initDB() {
+  if (db) return db;
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onerror = () => reject(request.error);
+    request.onsuccess = () => {
+      db = request.result;
+      resolve(db);
+    };
+    request.onupgradeneeded = (event) => {
+      const database = event.target.result;
+      if (!database.objectStoreNames.contains(PROGRESS_STORE)) {
+        database.createObjectStore(PROGRESS_STORE, { keyPath: "chapterSlug" });
+      }
+      if (!database.objectStoreNames.contains(UNLOCKS_STORE)) {
+        database.createObjectStore(UNLOCKS_STORE, { keyPath: "bookSlug" });
+      }
+    };
+  });
+}
+async function saveReadingProgress(progress) {
+  const database = await initDB();
+  return new Promise((resolve, reject) => {
+    const tx = database.transaction(PROGRESS_STORE, "readwrite");
+    const store = tx.objectStore(PROGRESS_STORE);
+    const request = store.put(progress);
+    request.onsuccess = () => resolve();
+    request.onerror = () => reject(request.error);
+  });
+}
+async function getReadingProgress(chapterSlug) {
+  const database = await initDB();
+  return new Promise((resolve, reject) => {
+    const tx = database.transaction(PROGRESS_STORE, "readonly");
+    const store = tx.objectStore(PROGRESS_STORE);
+    const request = store.get(chapterSlug);
+    request.onsuccess = () => resolve(request.result || null);
+    request.onerror = () => reject(request.error);
+  });
+}
+async function getAllReadingProgress() {
+  const database = await initDB();
+  return new Promise((resolve, reject) => {
+    const tx = database.transaction(PROGRESS_STORE, "readonly");
+    const store = tx.objectStore(PROGRESS_STORE);
+    const request = store.getAll();
+    request.onsuccess = () => resolve(request.result || []);
+    request.onerror = () => reject(request.error);
+  });
+}
+async function isBookUnlocked(bookSlug) {
+  const database = await initDB();
+  return new Promise((resolve, reject) => {
+    const tx = database.transaction(UNLOCKS_STORE, "readonly");
+    const store = tx.objectStore(UNLOCKS_STORE);
+    const request = store.get(bookSlug);
+    request.onsuccess = () => resolve(!!request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+async function unlockBook(bookSlug, orderId) {
+  const database = await initDB();
+  return new Promise((resolve, reject) => {
+    const tx = database.transaction(UNLOCKS_STORE, "readwrite");
+    const store = tx.objectStore(UNLOCKS_STORE);
+    const request = store.put({ bookSlug, orderId, unlockedAt: Date.now() });
+    request.onsuccess = () => resolve();
+    request.onerror = () => reject(request.error);
+  });
+}
+function navigate(path, replace = false) {
+  if (replace) {
+    history.replaceState(null, "", path);
+  } else {
+    history.pushState(null, "", path);
+  }
+  currentRoute.value = path;
+}
+function resolveSystemTheme() {
+  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function setTheme(theme) {
+  currentTheme.value = theme;
+  localStorage.setItem("pressy-theme", theme);
+  const resolved = theme === "system" ? resolveSystemTheme() : theme;
+  document.documentElement.setAttribute("data-theme", resolved);
+}
+function loadTheme() {
+  const saved = localStorage.getItem("pressy-theme");
+  if (saved) {
+    setTheme(saved);
+  } else if (window.matchMedia("(prefers-color-scheme: dark)").matches) {
+    setTheme("dark");
+  }
+  window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", () => {
+    if (currentTheme.value === "system") {
+      document.documentElement.setAttribute("data-theme", resolveSystemTheme());
+    }
+  });
+}
+function setupOfflineDetection() {
+  window.addEventListener("online", () => {
+    isOffline.value = false;
+  });
+  window.addEventListener("offline", () => {
+    isOffline.value = true;
+  });
+}
+function renderBookPage(book, articles = []) {
+  const chapterUrls = book.chapters.map(
+    (ch) => `/books/${book.slug}/${ch.slug}`
+  );
+  return /* @__PURE__ */ jsxs("div", { class: "pressy-home", children: [
+    /* @__PURE__ */ jsxs("header", { class: "pressy-home-header", children: [
+      /* @__PURE__ */ jsx("h1", { children: book.metadata.title }),
+      /* @__PURE__ */ jsxs("p", { class: "pressy-home-author", children: [
+        "by ",
+        book.metadata.author
+      ] }),
+      book.metadata.description && /* @__PURE__ */ jsx("p", { class: "pressy-home-desc", children: book.metadata.description })
+    ] }),
+    /* @__PURE__ */ jsx(
+      DownloadBook,
+      {
+        bookSlug: book.slug,
+        chapterUrls,
+        cachedBooks,
+        cacheProgress,
+        onDownload: downloadBookForOffline,
+        onRemove: clearBookCache
+      }
+    ),
+    /* @__PURE__ */ jsxs("section", { class: "pressy-home-section", children: [
+      /* @__PURE__ */ jsx("h2", { children: "Chapters" }),
+      /* @__PURE__ */ jsx(
+        BookProgress,
+        {
+          bookSlug: book.slug,
+          chapters: book.chapters.map((ch) => ({
+            slug: ch.slug,
+            title: ch.title,
+            order: ch.order,
+            wordCount: ch.wordCount || 0
+          })),
+          basePath,
+          loadAllProgress: getAllReadingProgress
+        }
+      )
+    ] }),
+    articles.length > 0 && /* @__PURE__ */ jsxs("section", { class: "pressy-home-section", children: [
+      /* @__PURE__ */ jsx("h2", { children: "Articles" }),
+      /* @__PURE__ */ jsx("nav", { class: "pressy-chapter-list", children: articles.map((article) => /* @__PURE__ */ jsx(
+        "a",
+        {
+          href: `${basePath}/articles/${article.slug}`,
+          class: "pressy-chapter-link",
+          children: article.metadata.title
+        }
+      )) })
+    ] }),
+    /* @__PURE__ */ jsx("style", { children: HOME_STYLES })
+  ] });
+}
+function renderHomePage(manifest) {
+  if (manifest.books.length === 1) {
+    return renderBookPage(manifest.books[0], manifest.articles);
+  }
+  const siteTitle = manifest.books[0]?.metadata.title || "Library";
+  return /* @__PURE__ */ jsxs("div", { class: "pressy-home", children: [
+    /* @__PURE__ */ jsxs("header", { class: "pressy-home-header", children: [
+      /* @__PURE__ */ jsx("h1", { children: siteTitle }),
+      manifest.books[0]?.metadata.description && /* @__PURE__ */ jsx("p", { class: "pressy-home-desc", children: manifest.books[0].metadata.description })
+    ] }),
+    manifest.books.length > 0 && /* @__PURE__ */ jsxs("section", { class: "pressy-home-section", children: [
+      /* @__PURE__ */ jsx("h2", { children: "Books" }),
+      /* @__PURE__ */ jsx("nav", { class: "pressy-chapter-list", children: manifest.books.map((book) => /* @__PURE__ */ jsx(
+        "a",
+        {
+          href: `${basePath}/books/${book.slug}`,
+          class: "pressy-chapter-link",
+          children: book.metadata.title
+        }
+      )) })
+    ] }),
+    manifest.articles.length > 0 && /* @__PURE__ */ jsxs("section", { class: "pressy-home-section", children: [
+      /* @__PURE__ */ jsx("h2", { children: "Articles" }),
+      /* @__PURE__ */ jsx("nav", { class: "pressy-chapter-list", children: manifest.articles.map((article) => /* @__PURE__ */ jsx(
+        "a",
+        {
+          href: `${basePath}/articles/${article.slug}`,
+          class: "pressy-chapter-link",
+          children: article.metadata.title
+        }
+      )) })
+    ] }),
+    /* @__PURE__ */ jsx("style", { children: HOME_STYLES })
+  ] });
+}
+function calculateBookProgressPercent(book, currentChapterSlug, currentPage, currentTotalPages, allProgress) {
+  const totalWords = book.chapters.reduce((sum, ch) => sum + (ch.wordCount || 0), 0);
+  if (totalWords === 0) return 0;
+  const progressMap = new Map(allProgress.map((p) => [p.chapterSlug, p]));
+  let wordsRead = 0;
+  for (const ch of book.chapters) {
+    const chapterWords = ch.wordCount || 0;
+    if (ch.slug === currentChapterSlug) {
+      if (currentTotalPages > 0) {
+        wordsRead += currentPage / Math.max(1, currentTotalPages - 1) * chapterWords;
+      }
+    } else {
+      const progress = progressMap.get(ch.slug);
+      if (!progress) continue;
+      if (progress.totalPages > 0 && progress.page >= progress.totalPages - 1) {
+        wordsRead += chapterWords;
+      } else if (progress.page > 0 && progress.totalPages > 0) {
+        wordsRead += progress.page / progress.totalPages * chapterWords;
+      }
+    }
+  }
+  return Math.min(100, wordsRead / totalWords * 100);
+}
+function ChapterReaderWithProgress({
+  book,
+  chapterSlug,
+  chapter,
+  prevChapter,
+  nextChapter,
+  paginationMode,
+  Content,
+  chapterMapData
+}) {
+  const [bookProgressPercent, setBookProgressPercent] = useState(void 0);
+  useEffect(() => {
+    getAllReadingProgress().then((allProgress) => {
+      const percent = calculateBookProgressPercent(book, chapterSlug, 0, 0, allProgress);
+      setBookProgressPercent(percent);
+    });
+  }, [book, chapterSlug]);
+  const handleSaveProgress = (data) => {
+    saveReadingProgress({
+      chapterSlug,
+      page: data.page,
+      totalPages: data.totalPages,
+      scrollPosition: data.scrollPosition,
+      timestamp: Date.now()
+    });
+    if (data.totalPages > 0) {
+      getAllReadingProgress().then((allProgress) => {
+        const percent = calculateBookProgressPercent(
+          book,
+          chapterSlug,
+          data.page,
+          data.totalPages,
+          allProgress
+        );
+        setBookProgressPercent(percent);
+      });
+    }
+  };
+  const handleRestoreProgress = async () => {
+    const progress = await getReadingProgress(chapterSlug);
+    if (!progress) return null;
+    return {
+      page: progress.page,
+      totalPages: progress.totalPages,
+      scrollPosition: progress.scrollPosition
+    };
+  };
+  const handleChapterChange = (slug, page, chapterTotalPages) => {
+    saveReadingProgress({
+      chapterSlug: slug,
+      page,
+      totalPages: chapterTotalPages,
+      scrollPosition: 0,
+      timestamp: Date.now()
+    });
+    getAllReadingProgress().then((allProgress) => {
+      const percent = calculateBookProgressPercent(book, slug, page, chapterTotalPages, allProgress);
+      setBookProgressPercent(percent);
+    });
+  };
+  useEffect(() => {
+    if (prevChapter) {
+      const link = document.createElement("link");
+      link.rel = "prefetch";
+      link.href = prevChapter.slug;
+      document.head.appendChild(link);
+      return () => {
+        document.head.removeChild(link);
+      };
+    }
+  }, [prevChapter]);
+  return /* @__PURE__ */ jsx(
+    Reader,
+    {
+      title: chapter?.title || chapterSlug,
+      bookTitle: book.metadata.title,
+      chapterSlug,
+      prevChapter,
+      nextChapter,
+      paginationMode,
+      onSaveProgress: handleSaveProgress,
+      onRestoreProgress: handleRestoreProgress,
+      bookProgressPercent,
+      initialContent: Content,
+      chapterMapData,
+      currentChapterSlug: chapterSlug,
+      allChapters: book.chapters.map((ch) => ({ slug: ch.slug, title: ch.title, wordCount: ch.wordCount })),
+      bookBasePath: `${basePath}/books/${book.slug}`,
+      onChapterChange: handleChapterChange,
+      mdxComponents: useMDXComponents(),
+      children: /* @__PURE__ */ jsx(Content, { components: useMDXComponents() })
+    }
+  );
+}
+function renderChapterPage(manifest, route, Content, paginationMode, chapterMapData) {
+  const parts = route.split("/");
+  const bookSlug = parts[2];
+  const chapterSlug = parts[3];
+  const book = manifest.books.find((b) => b.slug === bookSlug);
+  const chapterIdx = book ? book.chapters.findIndex((c) => c.slug === chapterSlug) : -1;
+  const chapter = book?.chapters[chapterIdx];
+  const chapterPath = (ch) => `${basePath}/books/${bookSlug}/${ch.slug}`;
+  const prevChapter = book && chapterIdx > 0 ? { slug: chapterPath(book.chapters[chapterIdx - 1]), title: book.chapters[chapterIdx - 1].title } : book ? { slug: `${basePath}/books/${bookSlug}`, title: book.metadata.title } : void 0;
+  const nextChapter = book && chapterIdx >= 0 && chapterIdx < book.chapters.length - 1 ? { slug: chapterPath(book.chapters[chapterIdx + 1]), title: book.chapters[chapterIdx + 1].title } : book ? { slug: `${basePath}/books/${bookSlug}`, title: book.metadata.title } : void 0;
+  const MDXContent = Content;
+  if (!book) {
+    return /* @__PURE__ */ jsx(
+      Reader,
+      {
+        title: chapter?.title || chapterSlug,
+        prevChapter,
+        nextChapter,
+        paginationMode,
+        children: /* @__PURE__ */ jsx(MDXContent, { components: useMDXComponents() })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    ChapterReaderWithProgress,
+    {
+      book,
+      chapterSlug,
+      chapter,
+      prevChapter,
+      nextChapter,
+      paginationMode,
+      Content: MDXContent,
+      chapterMapData
+    }
+  );
+}
+function renderArticlePage(manifest, route, Content) {
+  const articleSlug = route.split("/")[2];
+  const article = manifest.articles.find((a) => a.slug === articleSlug);
+  const MDXContent = Content;
+  return /* @__PURE__ */ jsx(Reader, { title: article?.metadata.title || articleSlug, children: /* @__PURE__ */ jsx(MDXContent, { components: useMDXComponents() }) });
+}
+var HOME_STYLES = `
+  .pressy-home {
+    max-width: 65ch;
+    margin: 0 auto;
+    padding: 2rem 1.5rem;
+    font-family: var(--font-body, Georgia, 'Times New Roman', serif);
+    color: var(--color-text, #1a1a1a);
+  }
+  .pressy-home-header {
+    margin-bottom: 3rem;
+    text-align: center;
+  }
+  .pressy-home-header h1 {
+    font-size: 2rem;
+    margin-bottom: 0.5rem;
+  }
+  .pressy-home-author {
+    font-style: italic;
+    color: var(--color-text-muted, #666);
+  }
+  .pressy-home-desc {
+    color: var(--color-text-muted, #666);
+    line-height: 1.6;
+    max-width: 50ch;
+    margin: 0.5rem auto 0;
+  }
+  .pressy-home-section {
+    margin-bottom: 2rem;
+  }
+  .pressy-home-section h2 {
+    font-size: 1.25rem;
+    margin-bottom: 1rem;
+    border-bottom: 1px solid var(--color-border, #e5e5e5);
+    padding-bottom: 0.5rem;
+  }
+  .pressy-chapter-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+  }
+  .pressy-chapter-link {
+    display: flex;
+    gap: 0.75rem;
+    padding: 0.75rem 1rem;
+    text-decoration: none;
+    color: var(--color-text, #1a1a1a);
+    border-radius: 0.5rem;
+    transition: background 0.15s;
+  }
+  .pressy-chapter-link:hover {
+    background: var(--color-bg-subtle, #f5f5f5);
+  }
+  .pressy-chapter-order {
+    color: var(--color-text-muted, #666);
+    min-width: 2ch;
+  }
+`;
+function getBasePath(route) {
+  const pathname = window.location.pathname;
+  const cleanPath = pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+  const cleanRoute = route.endsWith("/") ? route.slice(0, -1) : route;
+  if (cleanRoute === "" || cleanRoute === "/") {
+    return cleanPath.replace(/\/index\.html$/, "") || "";
+  }
+  const idx = cleanPath.indexOf(cleanRoute);
+  if (idx > 0) {
+    return cleanPath.slice(0, idx);
+  }
+  return "";
+}
+var basePath = "";
+function hydrate(data, Content, chapterMapData) {
+  basePath = getBasePath(data.route);
+  currentRoute.value = data.route;
+  loadTheme();
+  setupOfflineDetection();
+  initDB();
+  registerServiceWorker(basePath);
+  window.addEventListener("popstate", () => {
+    currentRoute.value = window.location.pathname;
+  });
+  document.addEventListener("click", (e) => {
+    const link = e.target.closest("a");
+    if (!link) return;
+    const href = link.getAttribute("href");
+    if (!href) return;
+    if (href.startsWith("http") || href.startsWith("#")) return;
+    if (href.startsWith(data.route + "#")) {
+      e.preventDefault();
+      const hash = href.slice(href.indexOf("#"));
+      const target = document.querySelector(hash);
+      if (target) target.scrollIntoView({ behavior: "smooth" });
+      return;
+    }
+  });
+  let page;
+  switch (data.routeType) {
+    case "home":
+      page = renderHomePage(data.manifest);
+      break;
+    case "book": {
+      const bookSlug = data.route.split("/")[2];
+      const book = data.manifest.books.find((b) => b.slug === bookSlug);
+      page = book ? renderBookPage(book) : /* @__PURE__ */ jsx("div", { children: "Book not found" });
+      break;
+    }
+    case "chapter":
+      page = Content ? renderChapterPage(data.manifest, data.route, Content, data.pagination?.defaultMode, chapterMapData) : /* @__PURE__ */ jsx("div", { children: "Loading..." });
+      break;
+    case "article":
+      page = Content ? renderArticlePage(data.manifest, data.route, Content) : /* @__PURE__ */ jsx("div", { children: "Loading..." });
+      break;
+    case "books":
+      page = renderHomePage(data.manifest);
+      break;
+    case "articles":
+      page = renderHomePage(data.manifest);
+      break;
+    default:
+      page = /* @__PURE__ */ jsx("div", { children: "Page not found" });
+  }
+  render(page, document.getElementById("app"));
+}
+export {
+  currentRoute,
+  currentTheme,
+  effect,
+  getAllReadingProgress,
+  getReadingProgress,
+  hydrate,
+  isBookUnlocked,
+  isOffline,
+  navigate,
+  saveReadingProgress,
+  setTheme,
+  signal2 as signal,
+  unlockBook
+};
+//# sourceMappingURL=client.js.map