create-eziwiki 0.1.0

package/template/lib/search/types.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared shapes for the search index.
+ *
+ * This module is isomorphic on purpose: the build script writes the index and
+ * the browser reads it, and both need to agree on the format.
+ */
+
+/** One searchable unit — a whole document, or a section within one. */
+export interface SearchDoc {
+  /** Stable identifier, `path` for a page and `path#anchor` for a section */
+  id: string;
+  /** Content-relative path of the source document */
+  path: string;
+  /** Href to navigate to, resolved under the site's URL strategy */
+  url: string;
+  /** Title of the page this entry belongs to */
+  title: string;
+  /** Heading text when this entry is a section, otherwise undefined */
+  section?: string;
+  /** Anchor id of the section, when applicable */
+  anchor?: string;
+  /** Page description from frontmatter */
+  description?: string;
+  /** Plain-text body of the page or section, used for matching and previews */
+  body: string;
+}
+
+/** The generated index file, as served to the browser. */
+export interface SearchIndex {
+  /** Format version, so a stale cached index can be detected and ignored */
+  version: number;
+  /** Every searchable entry */
+  docs: SearchDoc[];
+}
+
+/** Current index format version. Bump when the SearchDoc shape changes. */
+export const SEARCH_INDEX_VERSION = 1;
+
+/** Public path the generated index is served from. */
+export const SEARCH_INDEX_PATH = '/search-index.json';

package/template/lib/site.ts

@@ -0,0 +1,86 @@
+import { payload } from '@/payload/config';
+import { getNavigation } from './navigation/auto';
+import { getUrlMap } from './navigation/urlMap';
+import { getAllDocPaths, getContentRegistry } from './content/registry';
+import type { NavigationItem, GlobalConfig, ThemeConfig } from './payload/types';
+import type { UrlMap } from './navigation/url';
+
+/**
+ * The resolved site model.
+ *
+ * Pages and layouts read from here rather than from `payload/config.ts`
+ * directly, because navigation and URLs are only fully determined once the
+ * content directory has been scanned. Server-only.
+ */
+export interface Site {
+  /** Global configuration, verbatim from the payload */
+  global: GlobalConfig;
+  /** Theme overrides, if any */
+  theme?: Partial<ThemeConfig>;
+  /** Navigation tree, with discovered documents merged in */
+  navigation: NavigationItem[];
+  /** Bidirectional mapping between content paths and URL segments */
+  urlMap: UrlMap;
+  /** Every buildable document path, including ones hidden from navigation */
+  docPaths: string[];
+  /** Paths that should be built but never listed or indexed */
+  hiddenPaths: Set<string>;
+}
+
+/**
+ * Collects every path that must stay unlisted.
+ *
+ * A page can be marked hidden in two independent places — `hidden: true` in its
+ * frontmatter, or on its entry in the curated navigation — and consulting only
+ * one of them is how a page ends up hidden from the sidebar yet still announced
+ * in the sitemap and in search. Hiding a section hides everything beneath it.
+ *
+ * @param navigation - Resolved navigation tree
+ * @returns Content paths to exclude from listings
+ */
+export function collectHiddenPaths(navigation: NavigationItem[]): Set<string> {
+  const hidden = new Set<string>();
+
+  for (const doc of getContentRegistry().docs) {
+    if (doc.hidden) hidden.add(doc.path);
+  }
+
+  function visit(items: NavigationItem[], inherited: boolean) {
+    for (const item of items) {
+      const isHidden = inherited || item.hidden === true;
+      if (isHidden && item.path) hidden.add(item.path);
+      if (item.children) visit(item.children, isHidden);
+    }
+  }
+
+  visit(navigation, false);
+  return hidden;
+}
+
+/**
+ * Resolves the site model from the payload and the content directory.
+ *
+ * Each underlying piece memoises its own work, so calling this per page is
+ * cheap.
+ *
+ * @returns The resolved site
+ *
+ * @example
+ * ```typescript
+ * const site = getSite();
+ * site.navigation; // curated entries plus discovered documents
+ * site.urlMap.strategy; // 'path' | 'hash'
+ * ```
+ */
+export function getSite(): Site {
+  const navigation = getNavigation(payload.navigation, payload.global.autoNavigation ?? true);
+
+  return {
+    global: payload.global,
+    theme: payload.theme,
+    navigation,
+    urlMap: getUrlMap(),
+    docPaths: getAllDocPaths(),
+    hiddenPaths: collectHiddenPaths(navigation),
+  };
+}

package/template/lib/store/searchStore.ts

@@ -0,0 +1,26 @@
+import { create } from 'zustand';
+
+/**
+ * Open/closed state for the search dialog.
+ *
+ * Kept in a store rather than in component state because the dialog is opened
+ * from several places — the sidebar, the mobile header, and a global keyboard
+ * shortcut — that share no common ancestor short of the layout.
+ */
+interface SearchState {
+  /** Whether the dialog is showing */
+  isOpen: boolean;
+  /** Opens the dialog */
+  open: () => void;
+  /** Closes the dialog */
+  close: () => void;
+  /** Toggles the dialog */
+  toggle: () => void;
+}
+
+export const useSearchStore = create<SearchState>((set) => ({
+  isOpen: false,
+  open: () => set({ isOpen: true }),
+  close: () => set({ isOpen: false }),
+  toggle: () => set((state) => ({ isOpen: !state.isOpen })),
+}));

package/template/lib/store/tabStore.ts

@@ -0,0 +1,313 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+export interface HistoryEntry {
+  path: string;
+  title: string;
+}
+
+export interface Tab {
+  id: string;
+  title: string;
+  path: string;
+  scrollPosition?: number;
+  history: HistoryEntry[]; // History stack for this tab
+  historyIndex: number; // Current position in history
+}
+
+interface TabStore {
+  tabs: Tab[];
+  activeTabId: string | null;
+  sidebarWidth: number;
+  sidebarCollapsed: boolean;
+  hasHydrated: boolean;
+  setHasHydrated: (hydrated: boolean) => void;
+  addTab: (tab?: Omit<Tab, 'id' | 'history' | 'historyIndex'>) => string;
+  removeTab: (id: string) => void;
+  setActiveTab: (id: string) => void;
+  updateTabPath: (id: string, path: string, title: string) => void;
+  navigateInHistory: (id: string, path: string, title: string) => void;
+  goBack: (id: string) => { path: string; title: string } | null;
+  goForward: (id: string) => { path: string; title: string } | null;
+  canGoBack: (id: string) => boolean;
+  canGoForward: (id: string) => boolean;
+  updateTabHistoryIndex: (id: string, index: number) => void;
+  updateTabScroll: (id: string, scrollPosition: number) => void;
+  closeOtherTabs: (id: string) => void;
+  closeTabsToRight: (id: string) => void;
+  reorderTabs: (fromIndex: number, toIndex: number) => void;
+  setSidebarWidth: (width: number) => void;
+  setSidebarCollapsed: (collapsed: boolean) => void;
+}
+
+export const useTabStore = create<TabStore>()(
+  persist(
+    (set, get) => ({
+      tabs: [],
+      activeTabId: null,
+      sidebarWidth: 256, // Default 256px (w-64)
+      sidebarCollapsed: false,
+      hasHydrated: false,
+
+      setHasHydrated: (hydrated) => {
+        set({ hasHydrated: hydrated });
+
+        // After hydration, ensure at least one tab exists
+        if (hydrated) {
+          const { tabs } = get();
+          if (tabs.length === 0) {
+            // No tabs in storage, will be created by PageLayout based on URL
+            return;
+          }
+        }
+      },
+
+      addTab: (tab) => {
+        const { tabs } = get();
+
+        // Create new tab with default title "New Tab" and initial history
+        const initialPath = tab?.path || '';
+        const initialTitle = tab?.title || 'New Tab';
+        const newTab: Tab = {
+          title: initialTitle,
+          path: initialPath,
+          id: `tab-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+          history: [{ path: initialPath, title: initialTitle }],
+          historyIndex: 0,
+        };
+
+        set({
+          tabs: [...tabs, newTab],
+          activeTabId: newTab.id,
+        });
+
+        return newTab.id;
+      },
+
+      removeTab: (id) => {
+        const { tabs, activeTabId } = get();
+        const index = tabs.findIndex((t) => t.id === id);
+
+        if (index === -1) return;
+
+        const newTabs = tabs.filter((t) => t.id !== id);
+
+        // If closed tab was active, activate adjacent tab
+        let newActiveTabId = activeTabId;
+        if (activeTabId === id) {
+          if (newTabs.length > 0) {
+            // Activate right tab if exists, otherwise left
+            newActiveTabId = newTabs[Math.min(index, newTabs.length - 1)]?.id || null;
+          } else {
+            newActiveTabId = null;
+          }
+        }
+
+        set({
+          tabs: newTabs,
+          activeTabId: newActiveTabId,
+        });
+      },
+
+      setActiveTab: (id) => {
+        const { tabs } = get();
+        const tab = tabs.find((t) => t.id === id);
+
+        // Only update if the tab exists
+        if (tab) {
+          set({ activeTabId: id });
+        }
+      },
+
+      updateTabPath: (id, path, title) => {
+        set((state) => ({
+          tabs: state.tabs.map((tab) => (tab.id === id ? { ...tab, path, title } : tab)),
+        }));
+      },
+
+      navigateInHistory: (id, path, title) => {
+        set((state) => ({
+          tabs: state.tabs.map((tab) => {
+            if (tab.id !== id) return tab;
+
+            // If navigating to a new page (not back/forward), add to history
+            const currentEntry = tab.history[tab.historyIndex];
+            if (currentEntry.path === path) {
+              // Same page, just update title if needed
+              const updatedHistory = [...tab.history];
+              updatedHistory[tab.historyIndex] = { path, title };
+              return { ...tab, title, history: updatedHistory };
+            }
+
+            // Remove any forward history and add new entry
+            const newHistory = tab.history.slice(0, tab.historyIndex + 1);
+            newHistory.push({ path, title });
+
+            return {
+              ...tab,
+              path,
+              title,
+              history: newHistory,
+              historyIndex: newHistory.length - 1,
+            };
+          }),
+        }));
+      },
+
+      goBack: (id) => {
+        const { tabs } = get();
+        const tab = tabs.find((t) => t.id === id);
+
+        if (!tab || !tab.history || tab.historyIndex <= 0) return null;
+
+        const newIndex = tab.historyIndex - 1;
+        const newEntry = tab.history[newIndex];
+
+        if (!newEntry) return null;
+
+        set((state) => ({
+          tabs: state.tabs.map((t) =>
+            t.id === id
+              ? { ...t, path: newEntry.path, title: newEntry.title, historyIndex: newIndex }
+              : t,
+          ),
+        }));
+
+        return { path: newEntry.path, title: newEntry.title };
+      },
+
+      goForward: (id) => {
+        const { tabs } = get();
+        const tab = tabs.find((t) => t.id === id);
+
+        if (!tab || !tab.history || tab.historyIndex >= tab.history.length - 1) return null;
+
+        const newIndex = tab.historyIndex + 1;
+        const newEntry = tab.history[newIndex];
+
+        if (!newEntry) return null;
+
+        set((state) => ({
+          tabs: state.tabs.map((t) =>
+            t.id === id
+              ? { ...t, path: newEntry.path, title: newEntry.title, historyIndex: newIndex }
+              : t,
+          ),
+        }));
+
+        return { path: newEntry.path, title: newEntry.title };
+      },
+
+      canGoBack: (id) => {
+        const { tabs } = get();
+        const tab = tabs.find((t) => t.id === id);
+        return tab && tab.history ? tab.historyIndex > 0 : false;
+      },
+
+      canGoForward: (id) => {
+        const { tabs } = get();
+        const tab = tabs.find((t) => t.id === id);
+        return tab && tab.history ? tab.historyIndex < tab.history.length - 1 : false;
+      },
+
+      updateTabHistoryIndex: (id, index) => {
+        const { tabs } = get();
+        const tab = tabs.find((t) => t.id === id);
+
+        if (!tab || !tab.history || index < 0 || index >= tab.history.length) return;
+
+        const entry = tab.history[index];
+
+        if (!entry) return;
+
+        set((state) => ({
+          tabs: state.tabs.map((t) =>
+            t.id === id ? { ...t, path: entry.path, title: entry.title, historyIndex: index } : t,
+          ),
+        }));
+      },
+
+      updateTabScroll: (id, scrollPosition) => {
+        set((state) => ({
+          tabs: state.tabs.map((tab) => (tab.id === id ? { ...tab, scrollPosition } : tab)),
+        }));
+      },
+
+      closeOtherTabs: (id) => {
+        set((state) => ({
+          tabs: state.tabs.filter((tab) => tab.id === id),
+          activeTabId: id,
+        }));
+      },
+
+      closeTabsToRight: (id) => {
+        set((state) => {
+          const index = state.tabs.findIndex((tab) => tab.id === id);
+          return {
+            tabs: state.tabs.slice(0, index + 1),
+          };
+        });
+      },
+
+      reorderTabs: (fromIndex, toIndex) => {
+        set((state) => {
+          const newTabs = [...state.tabs];
+          const [movedTab] = newTabs.splice(fromIndex, 1);
+          newTabs.splice(toIndex, 0, movedTab);
+          return { tabs: newTabs };
+        });
+      },
+
+      setSidebarWidth: (width) => {
+        set({ sidebarWidth: width });
+      },
+
+      setSidebarCollapsed: (collapsed) => {
+        set({ sidebarCollapsed: collapsed });
+      },
+    }),
+    {
+      name: 'tab-storage',
+      // Exclude scroll position when saving to localStorage
+      partialize: (state) => ({
+        tabs: state.tabs.map((tab) => {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+          const { scrollPosition, ...rest } = tab;
+          return rest;
+        }),
+        activeTabId: state.activeTabId,
+        sidebarWidth: state.sidebarWidth,
+        sidebarCollapsed: state.sidebarCollapsed,
+      }),
+      // Migrate old tabs without history
+      migrate: (persistedState: unknown) => {
+        const state = persistedState as Record<string, unknown>;
+        if (state?.tabs && Array.isArray(state.tabs)) {
+          state.tabs = state.tabs.map((tab: Record<string, unknown>) => {
+            // Handle old format (string array) or missing history
+            let history = tab.history;
+            if (!history) {
+              history = [{ path: tab.path || '', title: tab.title || 'New Tab' }];
+            } else if (Array.isArray(history) && typeof history[0] === 'string') {
+              // Migrate from old string array format to new object format
+              history = history.map((path: string) => ({
+                path,
+                title: tab.title || 'New Tab',
+              }));
+            }
+
+            return {
+              ...tab,
+              history,
+              historyIndex: tab.historyIndex ?? 0,
+            };
+          });
+        }
+        return state;
+      },
+      onRehydrateStorage: () => (state) => {
+        state?.setHasHydrated(true);
+      },
+    },
+  ),
+);

package/template/next-env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/building-your-application/configuring/typescript for more information.

package/template/next.config.js

@@ -0,0 +1,43 @@
+/**
+ * Deployment base path.
+ *
+ * GitHub Pages project sites are served from a subdirectory; everywhere else
+ * the site sits at the root. Next rewrites its own links and assets for this,
+ * but code that fetches a file itself — the search index, for one — has to
+ * prefix the path, so it is exposed to the client too.
+ *
+ * Read from the environment rather than inferred from CI: `GITHUB_ACTIONS` is
+ * set for every job in a workflow, so inferring from it applied the prefix
+ * during tests and on forks as well as during the deploy it was meant for. The
+ * deploy workflow sets this explicitly.
+ */
+const basePath = process.env.NEXT_PUBLIC_BASE_PATH || '';
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  // Only use static export in production builds
+  ...(process.env.NODE_ENV === 'production' && { output: 'export' }),
+  images: {
+    unoptimized: true, // Required for static export
+  },
+  reactStrictMode: true,
+  ...(basePath && { basePath, assetPrefix: basePath }),
+  env: {
+    NEXT_PUBLIC_BASE_PATH: basePath,
+  },
+  trailingSlash: true, // Ensures proper routing for static hosting
+
+  // Disable source maps in production to prevent viewing original source
+  productionBrowserSourceMaps: false,
+
+  // Additional optimization for production
+  ...(process.env.NODE_ENV === 'production' && {
+    compiler: {
+      removeConsole: {
+        exclude: ['error', 'warn'], // Remove console.log but keep error/warn
+      },
+    },
+  }),
+};
+
+module.exports = nextConfig;