@hutusi/amytis 1.15.0 → 1.17.0

package/tests/unit/immersive-reading-prefs.test.ts

@@ -0,0 +1,144 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  DEFAULT_PREFS,
+  STORAGE_KEY,
+  readStoredPrefs,
+  writeStoredPrefs,
+  type StoredPrefs,
+} from '../../src/lib/immersive-reading-prefs';
+
+// Minimal in-memory mock matching the Storage interface subsets the helpers
+// accept. Per-test instance keeps state isolated and avoids touching
+// globalThis.localStorage. Optional setItem override lets us simulate
+// private-browsing / quota-exceeded throws.
+function makeMockStorage(
+  initial?: Record<string, string>,
+  opts: { setItemThrows?: boolean } = {},
+) {
+  const store: Record<string, string> = { ...(initial ?? {}) };
+  return {
+    getItem(key: string): string | null {
+      return Object.prototype.hasOwnProperty.call(store, key) ? store[key] : null;
+    },
+    setItem(key: string, value: string): void {
+      if (opts.setItemThrows) throw new Error('quota exceeded');
+      store[key] = value;
+    },
+    _store: store,
+  };
+}
+
+describe('readStoredPrefs', () => {
+  test('returns defaults when storage is empty', () => {
+    expect(readStoredPrefs(makeMockStorage())).toEqual(DEFAULT_PREFS);
+  });
+
+  test('returns defaults when no storage is available', () => {
+    // Passing a storage whose getItem always returns null mirrors the
+    // "globalThis.localStorage missing" path. Production callers can also
+    // pass undefined and rely on the lazy default — that path is exercised
+    // by the provider in the browser, not by unit tests.
+    const empty = { getItem: () => null };
+    expect(readStoredPrefs(empty)).toEqual(DEFAULT_PREFS);
+  });
+
+  test('returns defaults when stored JSON is invalid', () => {
+    expect(readStoredPrefs(makeMockStorage({ [STORAGE_KEY]: 'not-json{' }))).toEqual(DEFAULT_PREFS);
+  });
+
+  test('returns defaults when stored value is not an object', () => {
+    expect(readStoredPrefs(makeMockStorage({ [STORAGE_KEY]: '"a string"' }))).toEqual(DEFAULT_PREFS);
+    expect(readStoredPrefs(makeMockStorage({ [STORAGE_KEY]: 'null' }))).toEqual(DEFAULT_PREFS);
+    expect(readStoredPrefs(makeMockStorage({ [STORAGE_KEY]: '42' }))).toEqual(DEFAULT_PREFS);
+  });
+
+  test('returns defaults when storage entry is missing for the key', () => {
+    expect(readStoredPrefs(makeMockStorage({ 'unrelated-key': 'whatever' }))).toEqual(DEFAULT_PREFS);
+  });
+
+  test('round-trips a fully valid prefs blob', () => {
+    const blob: StoredPrefs = {
+      fontSize: 'xl',
+      readingTheme: 'sepia',
+      columnWidth: 'narrow',
+      sidebarOpen: false,
+    };
+    expect(readStoredPrefs(makeMockStorage({ [STORAGE_KEY]: JSON.stringify(blob) }))).toEqual(blob);
+  });
+
+  // The schema-drift case the helpers exist for: one corrupt key must not
+  // discard the whole blob — other valid keys still apply, the bad one
+  // falls back to its default.
+  test('per-key fallback: bad fontSize, others survive', () => {
+    const stored = JSON.stringify({
+      fontSize: 'banana',
+      readingTheme: 'dark',
+      columnWidth: 'full',
+      sidebarOpen: false,
+    });
+    expect(readStoredPrefs(makeMockStorage({ [STORAGE_KEY]: stored }))).toEqual({
+      fontSize: DEFAULT_PREFS.fontSize, // fell back
+      readingTheme: 'dark',
+      columnWidth: 'full',
+      sidebarOpen: false,
+    });
+  });
+
+  test('per-key fallback: bad readingTheme + columnWidth, others survive', () => {
+    const stored = JSON.stringify({
+      fontSize: 's',
+      readingTheme: 'neon',
+      columnWidth: 'ultra-wide',
+      sidebarOpen: true,
+    });
+    expect(readStoredPrefs(makeMockStorage({ [STORAGE_KEY]: stored }))).toEqual({
+      fontSize: 's',
+      readingTheme: DEFAULT_PREFS.readingTheme,
+      columnWidth: DEFAULT_PREFS.columnWidth,
+      sidebarOpen: true,
+    });
+  });
+
+  test('sidebarOpen is strict-boolean — string "true" does not count', () => {
+    const stored = JSON.stringify({
+      fontSize: 'm',
+      readingTheme: 'auto',
+      columnWidth: 'wide',
+      sidebarOpen: 'true',
+    });
+    expect(readStoredPrefs(makeMockStorage({ [STORAGE_KEY]: stored })).sidebarOpen).toBe(
+      DEFAULT_PREFS.sidebarOpen,
+    );
+  });
+
+  test('returns defaults when all keys are missing from a valid object', () => {
+    expect(readStoredPrefs(makeMockStorage({ [STORAGE_KEY]: '{}' }))).toEqual(DEFAULT_PREFS);
+  });
+});
+
+describe('writeStoredPrefs', () => {
+  test('writes the full blob under STORAGE_KEY as JSON', () => {
+    const storage = makeMockStorage();
+    const blob: StoredPrefs = {
+      fontSize: 'l',
+      readingTheme: 'dark',
+      columnWidth: 'medium',
+      sidebarOpen: false,
+    };
+    writeStoredPrefs(blob, storage);
+    expect(JSON.parse(storage._store[STORAGE_KEY])).toEqual(blob);
+  });
+
+  test('swallows throws (private browsing / quota exceeded)', () => {
+    const storage = makeMockStorage(undefined, { setItemThrows: true });
+    // Must not crash — the production caller relies on this silence so the
+    // reader still works in private browsing.
+    expect(() => writeStoredPrefs(DEFAULT_PREFS, storage)).not.toThrow();
+  });
+
+  test('does nothing when no storage is available', () => {
+    // Same as above but exercising the no-storage path. The "no storage"
+    // call site in production happens during SSR.
+    expect(() => writeStoredPrefs(DEFAULT_PREFS, undefined)).not.toThrow();
+  });
+});

package/tests/unit/static-params.test.ts

@@ -21,6 +21,7 @@
  *   • afterAll restores the real module so any subsequent tests see real data.
  */
 import { describe, test, expect, mock, beforeAll, beforeEach, afterAll, afterEach } from 'bun:test';
+import { setEnvVar, restoreEnvVar } from '../helpers/env';
 
 // ─── Capture real modules ─────────────────────────────────────────────────────
 // Static imports are hoisted and resolved before any executable code (including
@@ -36,7 +37,18 @@ import * as realUrls from '../../src/lib/urls';
 // reference, but they are never mutated during tests so this is safe.
 const snapshotUrls = { ...realUrls };
 
-let mockedPosts: Array<{ slug: string; series?: string; redirectFrom?: string[] }> = [];
+// Mock-post shape: only `slug` is required; the named fields are the ones
+// production code paths read. Extra fields (full Post shape) are allowed via
+// the index signature so individual tests can pass realistic fixtures without
+// every property having to be enumerated here.
+let mockedPosts: Array<{
+  slug: string;
+  series?: string;
+  redirectFrom?: string[];
+  draft?: boolean;
+  title?: string;
+  [key: string]: unknown;
+}> = [];
 let mockedNotes: Array<{ slug: string }> = [];
 let mockedSeries: Record<string, Array<{ slug: string }>> = {};
 let mockedSeriesData: Record<string, { redirectFrom?: string[]; title?: string }> = {};
@@ -148,7 +160,7 @@ beforeEach(() => {
   mockedNotes = [];
   mockedSeries = {};
   mockedSeriesData = {};
-  process.env.NODE_ENV = originalNodeEnv;
+  restoreEnvVar('NODE_ENV', originalNodeEnv);
 });
 
 afterEach(() => {
@@ -156,7 +168,7 @@ afterEach(() => {
   mockedNotes = [];
   mockedSeries = {};
   mockedSeriesData = {};
-  process.env.NODE_ENV = originalNodeEnv;
+  restoreEnvVar('NODE_ENV', originalNodeEnv);
 });
 
 // ─── Restore real modules ─────────────────────────────────────────────────────
@@ -201,7 +213,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('notes/[slug] includes raw and encoded Unicode slug in non-production', async () => {
       mockedNotes = [{ slug: '推理模型' }];
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/notes/[slug]/page');
       const params = generateStaticParams();
       expect(params).toContainEqual({ slug: '推理模型' });
@@ -210,7 +222,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('notes/[slug] includes only raw Unicode slug in production', async () => {
       mockedNotes = [{ slug: '推理模型' }];
-      process.env.NODE_ENV = 'production';
+      setEnvVar('NODE_ENV', 'production');
       const { generateStaticParams } = await import('../../src/app/notes/[slug]/page');
       const params = generateStaticParams();
       expect(params).toContainEqual({ slug: '推理模型' });
@@ -232,10 +244,10 @@ describe('generateStaticParams — placeholder when content is empty', () => {
       expect(params).toEqual([{ slug: '_' }]);
     });
 
-    test('books/[slug]/[chapter] returns [{ slug: "_", chapter: "_" }]', async () => {
-      const { generateStaticParams } = await import('../../src/app/books/[slug]/[chapter]/page');
+    test('books/[slug]/[...chapter] returns [{ slug: "_", chapter: ["_"] }]', async () => {
+      const { generateStaticParams } = await import('../../src/app/books/[slug]/[...chapter]/page');
       const params = await generateStaticParams();
-      expect(params).toEqual([{ slug: '_', chapter: '_' }]);
+      expect(params).toEqual([{ slug: '_', chapter: ['_'] }]);
     });
   });
 
@@ -257,7 +269,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('series/[slug] includes raw and encoded Unicode slug in non-production', async () => {
       mockedSeries = { '软件构架设计': [] };
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/series/[slug]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: '软件构架设计' });
@@ -266,7 +278,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('series/[slug] includes only raw Unicode slug in production', async () => {
       mockedSeries = { '软件构架设计': [] };
-      process.env.NODE_ENV = 'production';
+      setEnvVar('NODE_ENV', 'production');
       const { generateStaticParams } = await import('../../src/app/series/[slug]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: '软件构架设计' });
@@ -281,7 +293,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('series/[slug]/page/[page] includes encoded Unicode slug in non-production', async () => {
       mockedSeries = { '软件构架设计': Array.from({ length: 6 }, (_, i) => ({ slug: `p${i + 1}` })) };
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/series/[slug]/page/[page]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: '软件构架设计', page: '2' });
@@ -361,7 +373,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('posts/[slug] includes raw and encoded Unicode slug in non-production', async () => {
       mockedPosts = [{ slug: '中文测试文章' }];
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/posts/[slug]/page');
       const params = await generateStaticParams();
 
@@ -371,7 +383,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('posts/[slug] includes only raw Unicode slug in production', async () => {
       mockedPosts = [{ slug: '中文测试文章' }];
-      process.env.NODE_ENV = 'production';
+      setEnvVar('NODE_ENV', 'production');
       const { generateStaticParams } = await import('../../src/app/posts/[slug]/page');
       const params = await generateStaticParams();
 
@@ -485,7 +497,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('[slug]/page does not include single-segment redirectFrom for draft posts in production', async () => {
       mockedPosts = [{ slug: 'my-post', draft: true, redirectFrom: ['/old-slug'] }];
-      process.env.NODE_ENV = 'production';
+      setEnvVar('NODE_ENV', 'production');
       const { generateStaticParams } = await import('../../src/app/[slug]/page');
       const params = await generateStaticParams();
       expect(params).not.toContainEqual({ slug: 'old-slug' });
@@ -588,7 +600,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
     test('[slug]/[postSlug] includes encoded Unicode postSlug variants in non-production', async () => {
       // Use redirectFrom to place a Unicode postSlug at a 2-segment path — no url mock needed.
       mockedPosts = [{ slug: 'my-post', redirectFrom: ['/old-prefix/中文文章'] }];
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: 'old-prefix', postSlug: '中文文章' });
@@ -597,7 +609,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('[slug]/[postSlug] includes encoded Unicode prefix variants in non-production', async () => {
       mockedSeries = { '软件构架设计': [{ slug: 'architecture-post' }] };
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: '软件构架设计', postSlug: 'architecture-post' });
@@ -606,7 +618,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('[slug]/[postSlug] includes encoded Unicode prefix and postSlug variants together in non-production', async () => {
       mockedSeries = { '软件构架设计': [{ slug: '中文文章' }] };
-      process.env.NODE_ENV = 'development';
+      setEnvVar('NODE_ENV', 'development');
       const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: '软件构架设计', postSlug: '中文文章' });
@@ -617,7 +629,7 @@ describe('generateStaticParams — placeholder when content is empty', () => {
 
     test('[slug]/[postSlug] does not include encoded Unicode postSlug variants in production', async () => {
       mockedPosts = [{ slug: 'my-post', redirectFrom: ['/old-prefix/中文文章'] }];
-      process.env.NODE_ENV = 'production';
+      setEnvVar('NODE_ENV', 'production');
       const { generateStaticParams } = await import('../../src/app/[slug]/[postSlug]/page');
       const params = await generateStaticParams();
       expect(params).toContainEqual({ slug: 'old-prefix', postSlug: '中文文章' });
@@ -641,7 +653,8 @@ describe('generateStaticParams — placeholder when content is empty', () => {
         imageBaseSlug: 'posts',
         category: 'Test',
         tags: [],
-        readingTime: '1 min read',
+        readingMinutes: 1,
+        wordCount: 0,
       }];
 
       const page = await import('../../src/app/[slug]/[postSlug]/page');

package/vercel.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://openapi.vercel.sh/vercel.json",
+  "framework": "nextjs",
+  "buildCommand": "bun run build",
+  "installCommand": "bun install --frozen-lockfile",
+  "outputDirectory": "out"
+}