@publish.os/nextjs 0.0.1-alpha.2 → 0.0.1-alpha.4

package/dist/search.js

@@ -0,0 +1,393 @@
+"use client";
+
+// src/search.tsx
+import { useShortcut } from "@publish.os/nextjs/keyboard-shortcuts";
+import { useRouter } from "next/navigation";
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useId,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var EMPTY_SEARCH_OUTPUT = {
+  items: [],
+  nextOffset: null,
+  status: "idle",
+  total: 0
+};
+var MAX_SEARCH_QUERY_LENGTH = 128;
+var MAX_SEARCH_RESULTS = 20;
+var DEFAULT_SEARCH_LIMIT = 10;
+var SEARCH_DEBOUNCE_MS = 140;
+var SearchBlockContext = createContext(null);
+function normalizeSearchInput(input) {
+  return {
+    filters: input.filters,
+    limit: Math.min(
+      Math.max(1, Math.floor(input.limit ?? DEFAULT_SEARCH_LIMIT)),
+      MAX_SEARCH_RESULTS
+    ),
+    offset: Math.max(0, Math.floor(input.offset ?? 0)),
+    q: input.q.trim().slice(0, MAX_SEARCH_QUERY_LENGTH)
+  };
+}
+function inactiveIndexMessage() {
+  return {
+    items: [],
+    message: "Building search index...",
+    nextOffset: null,
+    status: "building",
+    total: 0
+  };
+}
+var SEARCH_STATUS_URL = "/pagefind/publishos-search-status.json";
+var PAGEFIND_URL = "/pagefind/pagefind.js";
+var pagefindModulePromise = null;
+async function fetchSearchStatus(signal) {
+  const response = await fetch(SEARCH_STATUS_URL, {
+    cache: "no-store",
+    signal
+  }).catch((error) => {
+    if (error instanceof DOMException && error.name === "AbortError") {
+      throw error;
+    }
+    return null;
+  });
+  if (!response?.ok) return null;
+  return await response.json();
+}
+async function loadPagefind() {
+  pagefindModulePromise ??= new Function("src", "return import(src)")(PAGEFIND_URL).then(async (mod) => {
+    const pagefind = mod;
+    await pagefind.options?.({ bundlePath: "/pagefind/" });
+    await pagefind.init?.();
+    return pagefind;
+  });
+  return pagefindModulePromise;
+}
+function pagefindFilters(filters) {
+  if (!filters) return void 0;
+  const entries = Object.entries({
+    author: filters.author,
+    group: filters.group,
+    tag: filters.tag
+  }).filter((entry) => Boolean(entry[1]));
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function titleForResult(data) {
+  return data.meta?.title ?? data.sub_results?.find((subResult) => subResult.title)?.title ?? data.url;
+}
+function toSearchResult({
+  data,
+  fallbackId,
+  score
+}) {
+  const title = titleForResult(data);
+  const excerpt = data.excerpt ?? "";
+  return {
+    excerpt,
+    id: data.url || fallbackId,
+    meta: data.meta ?? {},
+    plainExcerpt: data.plain_excerpt ?? excerpt.replace(/<[^>]*>/g, ""),
+    score,
+    subResults: (data.sub_results ?? []).map((result) => ({
+      excerpt: result.excerpt ?? "",
+      plainExcerpt: (result.excerpt ?? "").replace(/<[^>]*>/g, ""),
+      title: result.title ?? title,
+      url: result.url ?? data.url
+    })),
+    title,
+    url: data.url
+  };
+}
+function statusOutput(status) {
+  if (status.status === "ready" || status.status === void 0) return null;
+  if (status.status === "empty") {
+    return {
+      items: [],
+      message: "No searchable pages are available.",
+      nextOffset: null,
+      status: "ready",
+      total: 0
+    };
+  }
+  if (status.status === "building") {
+    return {
+      items: [],
+      message: status.message ?? "Building search index...",
+      nextOffset: null,
+      status: "building",
+      total: 0
+    };
+  }
+  if (status.status === "stale") {
+    return {
+      items: [],
+      message: status.message ?? "Updating search index...",
+      nextOffset: null,
+      status: "stale",
+      total: 0
+    };
+  }
+  if (status.status === "error") {
+    return {
+      items: [],
+      message: status.message ?? "Search is temporarily unavailable",
+      nextOffset: null,
+      status: "error",
+      total: 0
+    };
+  }
+  return null;
+}
+async function runPagefindSearch(input) {
+  const normalized = normalizeSearchInput(input);
+  if (!normalized.q) {
+    return EMPTY_SEARCH_OUTPUT;
+  }
+  const status = await fetchSearchStatus(input.signal);
+  const blockedByStatus = status ? statusOutput(status) : null;
+  if (blockedByStatus) return blockedByStatus;
+  const pagefind = await loadPagefind();
+  const limit = normalized.limit ?? DEFAULT_SEARCH_LIMIT;
+  const offset = normalized.offset ?? 0;
+  const result = await pagefind.search(normalized.q, {
+    filters: pagefindFilters(normalized.filters),
+    limit,
+    offset
+  });
+  if (!result) return EMPTY_SEARCH_OUTPUT;
+  const items = await Promise.all(
+    result.results.map(
+      async (pagefindResult) => toSearchResult({
+        data: await pagefindResult.data(),
+        fallbackId: pagefindResult.id,
+        score: pagefindResult.score
+      })
+    )
+  );
+  const total = result.unfilteredResultCount ?? items.length;
+  const nextOffset = offset + limit < total ? offset + limit : null;
+  return {
+    items,
+    nextOffset,
+    status: "ready",
+    total
+  };
+}
+async function search(input) {
+  const normalized = normalizeSearchInput(input);
+  if (!normalized.q) {
+    return EMPTY_SEARCH_OUTPUT;
+  }
+  try {
+    return await runPagefindSearch(normalized);
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") {
+      return EMPTY_SEARCH_OUTPUT;
+    }
+    return inactiveIndexMessage();
+  }
+}
+function useSearch(input) {
+  const { filters, limit, offset, q } = input;
+  const stableInput = useMemo(
+    () => normalizeSearchInput({ filters, limit, offset, q }),
+    [filters, limit, offset, q]
+  );
+  const [output, setOutput] = useState(EMPTY_SEARCH_OUTPUT);
+  const requestId = useRef(0);
+  useEffect(() => {
+    const nextRequestId = requestId.current + 1;
+    requestId.current = nextRequestId;
+    if (!stableInput.q) {
+      setOutput(EMPTY_SEARCH_OUTPUT);
+      return;
+    }
+    const controller = new AbortController();
+    const timer = window.setTimeout(() => {
+      setOutput((current) => ({ ...current, status: "idle" }));
+      runPagefindSearch({ ...stableInput, signal: controller.signal }).then((result) => {
+        if (requestId.current !== nextRequestId) return;
+        setOutput(result);
+      }).catch((error) => {
+        if (requestId.current !== nextRequestId) return;
+        if (error instanceof DOMException && error.name === "AbortError") {
+          return;
+        }
+        setOutput(inactiveIndexMessage());
+      });
+    }, SEARCH_DEBOUNCE_MS);
+    return () => {
+      window.clearTimeout(timer);
+      controller.abort();
+    };
+  }, [stableInput]);
+  return output;
+}
+function useSearchBlock() {
+  const value = useContext(SearchBlockContext);
+  if (!value) {
+    throw new Error("useSearchBlock must be used inside <Search.Root>.");
+  }
+  return value;
+}
+function SearchProvider({
+  children,
+  defaultOpen = false,
+  limit = DEFAULT_SEARCH_LIMIT,
+  onOpenChange,
+  open: controlledOpen,
+  shortcut = "mod+k",
+  variant = "desktop"
+}) {
+  const [uncontrolledOpen, setUncontrolledOpen] = useState(defaultOpen);
+  const [query, setQuery] = useState("");
+  const [isTyping, setIsTyping] = useState(false);
+  const [selectedValue, setSelectedValue] = useState("");
+  const typingTimer = useRef(null);
+  const inputRef = useRef(null);
+  const listRef = useRef(null);
+  const router = useRouter();
+  const inputId = useId();
+  const listId = useId();
+  const open = controlledOpen ?? uncontrolledOpen;
+  const output = useSearch({ limit, q: query });
+  const [displayResults, setDisplayResults] = useState([]);
+  const selectedResult = displayResults.find((result) => result.id === selectedValue) ?? displayResults[0];
+  const selectedResultId = selectedResult?.id ?? "";
+  const loading = Boolean(query.trim()) && !isTyping && output.status === "idle";
+  const setOpen = useCallback(
+    (nextOpen) => {
+      if (controlledOpen === void 0) {
+        setUncontrolledOpen(nextOpen);
+      }
+      onOpenChange?.(nextOpen);
+      if (!nextOpen) {
+        setQuery("");
+        setSelectedValue("");
+        setIsTyping(false);
+      }
+    },
+    [controlledOpen, onOpenChange]
+  );
+  const setQueryValue = useCallback((value) => {
+    setQuery(value);
+  }, []);
+  const handleInputChange = useCallback((value) => {
+    setQuery(value);
+    setIsTyping(true);
+    if (typingTimer.current !== null) {
+      window.clearTimeout(typingTimer.current);
+    }
+    typingTimer.current = window.setTimeout(() => {
+      setIsTyping(false);
+      typingTimer.current = null;
+    }, SEARCH_DEBOUNCE_MS);
+  }, []);
+  const navigateToResult = useCallback(
+    (result) => {
+      setOpen(false);
+      router.push(result.url);
+    },
+    [router, setOpen]
+  );
+  useEffect(() => {
+    if (!open) return;
+    const frame = window.requestAnimationFrame(() => {
+      inputRef.current?.focus();
+    });
+    return () => window.cancelAnimationFrame(frame);
+  }, [open]);
+  useShortcut(shortcut, () => setOpen(true), {
+    description: "Open search",
+    group: "Search",
+    priority: 100
+  });
+  useEffect(() => {
+    if (!query.trim()) {
+      setDisplayResults([]);
+      setSelectedValue("");
+      return;
+    }
+    if (isTyping || loading) return;
+    if (output.status === "ready") {
+      setDisplayResults(output.items);
+      setSelectedValue(output.items[0]?.id ?? "");
+      return;
+    }
+    if (output.status === "building" || output.status === "stale" || output.status === "error") {
+      setDisplayResults([]);
+      setSelectedValue("");
+    }
+  }, [isTyping, loading, output.items, output.status, query]);
+  useEffect(
+    () => () => {
+      if (typingTimer.current !== null) {
+        window.clearTimeout(typingTimer.current);
+      }
+    },
+    []
+  );
+  const contextValue = useMemo(
+    () => ({
+      actions: {
+        handleInputChange,
+        navigateToResult,
+        setOpen,
+        setQuery: setQueryValue,
+        setSelectedValue
+      },
+      meta: {
+        inputId,
+        inputRef,
+        listId,
+        listRef,
+        shortcut,
+        variant
+      },
+      state: {
+        displayResults,
+        isTyping,
+        loading,
+        message: output.message,
+        open,
+        query,
+        selectedValue: selectedResultId,
+        status: output.status,
+        total: output.total
+      }
+    }),
+    [
+      displayResults,
+      handleInputChange,
+      inputId,
+      isTyping,
+      listId,
+      loading,
+      navigateToResult,
+      open,
+      output.message,
+      output.status,
+      output.total,
+      query,
+      selectedResultId,
+      setOpen,
+      setQueryValue,
+      shortcut,
+      variant
+    ]
+  );
+  return /* @__PURE__ */ jsx(SearchBlockContext.Provider, { value: contextValue, children });
+}
+export {
+  SearchProvider,
+  search,
+  useSearch,
+  useSearchBlock
+};

package/dist/types.cjs

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -15,4 +19,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 
 // src/types.ts
 var types_exports = {};
+__export(types_exports, {
+  __publishOsTypesModule: () => __publishOsTypesModule
+});
 module.exports = __toCommonJS(types_exports);
+var __publishOsTypesModule = true;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __publishOsTypesModule
+});

package/dist/types.d.cts

@@ -1,11 +1,103 @@
+import { RefObject } from 'react';
+
+type SearchInput = {
+    filters?: {
+        author?: string;
+        group?: string;
+        tag?: string;
+    };
+    limit?: number;
+    offset?: number;
+    q: string;
+};
+type SearchStatus = "idle" | "building" | "stale" | "ready" | "error";
+type SearchSubResult = {
+    excerpt: string;
+    plainExcerpt: string;
+    title: string;
+    url: string;
+};
+type SearchResult = {
+    excerpt: string;
+    id: string;
+    meta: {
+        author?: string;
+        description?: string;
+        group?: string;
+        image?: string;
+        nodeId?: string;
+        path?: string;
+        publishedAt?: string;
+        section?: string;
+        tags?: string;
+        title?: string;
+        updatedAt?: string;
+    };
+    plainExcerpt: string;
+    score?: number;
+    subResults: SearchSubResult[];
+    title: string;
+    url: string;
+};
+type SearchOutput = {
+    items: SearchResult[];
+    message?: string;
+    nextOffset: number | null;
+    status: SearchStatus;
+    total: number;
+};
+type SearchBlockVariant = "desktop" | "mobile";
+type SearchBlockState = {
+    displayResults: SearchResult[];
+    isTyping: boolean;
+    loading: boolean;
+    message?: string;
+    open: boolean;
+    query: string;
+    selectedValue: string;
+    status: SearchStatus;
+    total: number;
+};
+type SearchBlockActions = {
+    handleInputChange(value: string): void;
+    navigateToResult(result: SearchResult): void;
+    setOpen(open: boolean): void;
+    setQuery(value: string): void;
+    setSelectedValue(id: string): void;
+};
+type SearchBlockMeta = {
+    inputId: string;
+    inputRef: RefObject<HTMLInputElement | null>;
+    listId: string;
+    listRef: RefObject<HTMLDivElement | null>;
+    shortcut: string;
+    variant: SearchBlockVariant;
+};
+type SearchBlockContextValue = {
+    actions: SearchBlockActions;
+    meta: SearchBlockMeta;
+    state: SearchBlockState;
+};
+
 type Heading = {
     id: string;
     depth: number;
     text: string;
 };
 type SiteData = {
-    title: string;
+    name: string;
     description?: string;
+    url?: string;
+    og?: OgMetadata;
+};
+type OgImageMetadata = string | {
+    src: string;
+    alt?: string;
+};
+type OgMetadata = {
+    title?: string;
+    description?: string;
+    image?: OgImageMetadata;
 };
 type Author = {
     id?: string;
@@ -16,7 +108,6 @@ type Author = {
 };
 type PageStatus = "published" | "draft" | "archived";
 type PageFrontmatter = {
-    id: string;
     title: string;
     slug?: string;
     description?: string;
@@ -28,7 +119,7 @@ type PageFrontmatter = {
     [key: string]: unknown;
 };
 type PageData<TMeta extends Record<string, unknown> = Record<string, unknown>> = {
-    id: string;
+    fileID: string;
     group: string;
     slug: string;
     path: string;
@@ -39,6 +130,7 @@ type PageData<TMeta extends Record<string, unknown> = Record<string, unknown>> =
     updatedAt?: string;
     authors: Author[];
     tags: string[];
+    og?: OgMetadata;
     meta: TMeta;
     body: string;
 };
@@ -47,7 +139,7 @@ type PageSummary<TMeta extends Record<string, unknown> = Record<string, unknown>
 };
 type PageNode = {
     type: "page";
-    id: string;
+    fileID: string;
     title: string;
     path: string;
     group: string;
@@ -57,6 +149,7 @@ type PageNode = {
     updatedAt?: string;
     authors: Author[];
     tags?: string[];
+    og?: OgMetadata;
     meta: Record<string, unknown>;
 };
 type SectionNode = {
@@ -71,6 +164,7 @@ type FolderNode = {
     type: "folder";
     id: string;
     title: string;
+    path?: string;
     group?: string;
     children: TreeNode[];
 };
@@ -87,16 +181,26 @@ type NavSection = SectionNode;
 type NavFolder = FolderNode;
 type NavItem = TreeNode;
 type RouteRecord = {
-    id: string;
+    fileID: string;
     slug: string;
     path: string;
     group: string;
 };
+type ResolvedAttribution = {
+    enabled: false;
+} | {
+    enabled: true;
+    variant: "publish-dev";
+    label?: string;
+    hrefLabel?: string;
+    href: string;
+};
 type GroupManifest = {
     key: string;
     title: string;
     path: string;
-    contentDir: string;
+    ancestry?: string[];
+    meta?: Record<string, unknown>;
     tree: TreeNode[];
     pages: PageData[];
 };
@@ -106,12 +210,16 @@ type ManifestLike = {
     routes: RouteRecord[];
     pages: PageData[];
     tree: TreeNode[];
+    attribution?: Record<string, ResolvedAttribution>;
     contentHash: string;
 };
 type RootLayoutProps = {
     children: React.ReactNode;
     site: SiteData;
     tree: TreeNode[];
+    currentPath?: string;
+    currentGroup?: GroupContext;
+    activeGroups?: readonly GroupContext[];
 };
 type RootPageProps = {
     site: SiteData;
@@ -140,5 +248,22 @@ type IndexPageProps = {
     currentPath: string;
     group: string;
 };
+type ThemeMode = "system" | "light" | "dark";
+type GroupForcedMode = "light" | "dark" | "none";
+type GroupContext = {
+    key: string;
+    title: string;
+    path: string;
+    ancestry: readonly string[];
+    hasThemeCss: boolean;
+    hasFontScope: boolean;
+    defaultMode?: ThemeMode;
+    forcedMode?: GroupForcedMode;
+    resolvedForcedMode?: "light" | "dark";
+    escapesForcedMode?: boolean;
+    meta?: Record<string, unknown>;
+};
+
+declare const __publishOsTypesModule = true;
 
-export type { Author, FolderNode, GroupManifest, Heading, IndexPageProps, LayoutProps, LinkNode, ManifestLike, NavFolder, NavItem, NavLink, NavPage, NavSection, PageData, PageFrontmatter, PageNode, PageProps, PageStatus, PageSummary, RootLayoutProps, RootPageProps, RouteRecord, SectionNode, SiteData, TreeNode };
+export { type Author, type FolderNode, type GroupContext, type GroupForcedMode, type GroupManifest, type Heading, type IndexPageProps, type LayoutProps, type LinkNode, type ManifestLike, type NavFolder, type NavItem, type NavLink, type NavPage, type NavSection, type OgImageMetadata, type OgMetadata, type PageData, type PageFrontmatter, type PageNode, type PageProps, type PageStatus, type PageSummary, type ResolvedAttribution, type RootLayoutProps, type RootPageProps, type RouteRecord, type SearchBlockActions, type SearchBlockContextValue, type SearchBlockMeta, type SearchBlockState, type SearchBlockVariant, type SearchInput, type SearchOutput, type SearchResult, type SearchStatus, type SearchSubResult, type SectionNode, type SiteData, type ThemeMode, type TreeNode, __publishOsTypesModule };