@publish.os/nextjs 0.0.1-alpha.6 → 0.0.1-alpha.8

package/dist/search.js

@@ -1,6 +1,6 @@
 "use client";
 
-// src/search.tsx
+// src/modules/search/search.tsx
 import { useShortcut } from "@publish.os/nextjs/keyboard-shortcuts";
 import { useRouter } from "next/navigation";
 import {
@@ -19,12 +19,7 @@ var EMPTY_SEARCH_OUTPUT = {
   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);
+}, MAX_SEARCH_QUERY_LENGTH = 128, MAX_SEARCH_RESULTS = 20, DEFAULT_SEARCH_LIMIT = 10, SEARCH_DEBOUNCE_MS = 140, SearchBlockContext = createContext(null);
 function normalizeSearchInput(input) {
   return {
     filters: input.filters,
@@ -45,38 +40,53 @@ function inactiveIndexMessage() {
     total: 0
   };
 }
-var SEARCH_STATUS_URL = "/pagefind/publishos-search-status.json";
-var PAGEFIND_URL = "/pagefind/pagefind.js";
-var pagefindModulePromise = null;
+var SEARCH_STATUS_URL = "/pagefind/pagefind-entry.json", PAGEFIND_URL = "/pagefind/pagefind.js", pagefindModulePromise = null, activeIndex;
 async function fetchSearchStatus(signal) {
-  const response = await fetch(SEARCH_STATUS_URL, {
+  let response = await fetch(SEARCH_STATUS_URL, {
     cache: "no-store",
     signal
   }).catch((error) => {
-    if (error instanceof DOMException && error.name === "AbortError") {
+    if (error instanceof DOMException && error.name === "AbortError")
       throw error;
-    }
     return null;
   });
-  if (!response?.ok) return null;
-  return await response.json();
+  return response?.ok ? (await response.json()).publishos ?? null : null;
 }
 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;
+  return pagefindModulePromise ??= new Function("src", "return import(src)")(PAGEFIND_URL), pagefindModulePromise;
+}
+async function withPagefindIndex(revision, run) {
+  let release = async (index) => {
+    index.retired && index.readers === 0 && await (await index.instance).destroy();
+  };
+  if (!activeIndex || activeIndex.revision !== revision) {
+    let previous = activeIndex;
+    activeIndex = {
+      revision,
+      readers: 0,
+      retired: !1,
+      instance: loadPagefind().then(async (module) => {
+        let instance = module.createInstance({ bundlePath: "/pagefind/" });
+        return await instance.init?.(), instance;
+      })
+    }, previous && (previous.retired = !0, release(previous).catch(() => {
+    }));
+  }
+  let selected = activeIndex;
+  selected.readers += 1;
+  try {
+    return await run(await selected.instance);
+  } finally {
+    selected.readers -= 1, await release(selected);
+  }
 }
 function pagefindFilters(filters) {
-  if (!filters) return void 0;
-  const entries = Object.entries({
+  if (!filters) return;
+  let entries = Object.entries({
     author: filters.author,
     group: filters.group,
     tag: filters.tag
-  }).filter((entry) => Boolean(entry[1]));
+  }).filter((entry) => !!entry[1]);
   return entries.length > 0 ? Object.fromEntries(entries) : void 0;
 }
 function titleForResult(data) {
@@ -87,8 +97,7 @@ function toSearchResult({
   fallbackId,
   score
 }) {
-  const title = titleForResult(data);
-  const excerpt = data.excerpt ?? "";
+  let title = titleForResult(data), excerpt = data.excerpt ?? "";
   return {
     excerpt,
     id: data.url || fallbackId,
@@ -106,235 +115,155 @@ function toSearchResult({
   };
 }
 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;
+  return status.status === "ready" || status.status === void 0 ? null : status.status === "empty" ? {
+    items: [],
+    message: "No searchable pages are available.",
+    nextOffset: null,
+    status: "ready",
+    total: 0
+  } : status.status === "building" ? {
+    items: [],
+    message: status.message ?? "Building search index...",
+    nextOffset: null,
+    status: "building",
+    total: 0
+  } : status.status === "stale" ? {
+    items: [],
+    message: status.message ?? "Updating search index...",
+    nextOffset: null,
+    status: "stale",
+    total: 0
+  } : status.status === "error" ? {
+    items: [],
+    message: status.message ?? "Search is temporarily unavailable",
+    nextOffset: null,
+    status: "error",
+    total: 0
+  } : null;
 }
 async function runPagefindSearch(input) {
-  const normalized = normalizeSearchInput(input);
-  if (!normalized.q) {
+  let 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
+  let status = await fetchSearchStatus(input.signal), blockedByStatus = status ? statusOutput(status) : null;
+  return blockedByStatus || await withPagefindIndex(status?.revision, async (pagefind) => {
+    let limit = normalized.limit ?? DEFAULT_SEARCH_LIMIT, offset = normalized.offset ?? 0, result = await pagefind.search(normalized.q, {
+      filters: pagefindFilters(normalized.filters),
+      limit,
+      offset
+    });
+    if (!result) return EMPTY_SEARCH_OUTPUT;
+    let items = await Promise.all(
+      result.results.map(
+        async (pagefindResult) => toSearchResult({
+          data: await pagefindResult.data(),
+          fallbackId: pagefindResult.id,
+          score: pagefindResult.score
+        })
+      )
+    ), total = result.unfilteredResultCount ?? items.length, nextOffset = offset + limit < total ? offset + limit : null;
+    return {
+      items,
+      nextOffset,
+      status: "ready",
+      total
+    };
   });
-  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) {
+  let 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();
+    return error instanceof DOMException && error.name === "AbortError" ? EMPTY_SEARCH_OUTPUT : inactiveIndexMessage();
   }
 }
 function useSearch(input) {
-  const { filters, limit, offset, q } = input;
-  const stableInput = useMemo(
+  let { filters, limit, offset, q } = input, 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) {
+  ), [output, setOutput] = useState(EMPTY_SEARCH_OUTPUT), requestId = useRef(0);
+  return useEffect(() => {
+    let nextRequestId = requestId.current + 1;
+    if (requestId.current = nextRequestId, !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);
+    let controller = new AbortController(), timer = window.setTimeout(() => {
+      setOutput((current) => ({ ...current, status: "idle" })), runPagefindSearch({ ...stableInput, signal: controller.signal }).then((result) => {
+        requestId.current === nextRequestId && setOutput(result);
       }).catch((error) => {
-        if (requestId.current !== nextRequestId) return;
-        if (error instanceof DOMException && error.name === "AbortError") {
-          return;
-        }
-        setOutput(inactiveIndexMessage());
+        requestId.current === nextRequestId && (error instanceof DOMException && error.name === "AbortError" || setOutput(inactiveIndexMessage()));
       });
     }, SEARCH_DEBOUNCE_MS);
     return () => {
-      window.clearTimeout(timer);
-      controller.abort();
+      window.clearTimeout(timer), controller.abort();
     };
-  }, [stableInput]);
-  return output;
+  }, [stableInput]), output;
 }
 function useSearchBlock() {
-  const value = useContext(SearchBlockContext);
-  if (!value) {
+  let value = useContext(SearchBlockContext);
+  if (!value)
     throw new Error("useSearchBlock must be used inside <Search.Root>.");
-  }
   return value;
 }
 function SearchProvider({
   children,
-  defaultOpen = false,
+  defaultOpen = !1,
   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(
+  let [uncontrolledOpen, setUncontrolledOpen] = useState(defaultOpen), [query, setQuery] = useState(""), [isTyping, setIsTyping] = useState(!1), [selectedValue, setSelectedValue] = useState(""), typingTimer = useRef(null), inputRef = useRef(null), listRef = useRef(null), router = useRouter(), inputId = useId(), listId = useId(), open = controlledOpen ?? uncontrolledOpen, output = useSearch({ limit, q: query }), [displayResults, setDisplayResults] = useState([]), selectedResultId = (displayResults.find((result) => result.id === selectedValue) ?? displayResults[0])?.id ?? "", loading = !!query.trim() && !isTyping && output.status === "idle", setOpen = useCallback(
     (nextOpen) => {
-      if (controlledOpen === void 0) {
-        setUncontrolledOpen(nextOpen);
-      }
-      onOpenChange?.(nextOpen);
-      if (!nextOpen) {
-        setQuery("");
-        setSelectedValue("");
-        setIsTyping(false);
-      }
+      controlledOpen === void 0 && setUncontrolledOpen(nextOpen), onOpenChange?.(nextOpen), nextOpen || (setQuery(""), setSelectedValue(""), setIsTyping(!1));
     },
     [controlledOpen, onOpenChange]
-  );
-  const setQueryValue = useCallback((value) => {
-    setQuery(value);
-  }, []);
-  const handleInputChange = useCallback((value) => {
+  ), setQueryValue = useCallback((value) => {
     setQuery(value);
-    setIsTyping(true);
-    if (typingTimer.current !== null) {
-      window.clearTimeout(typingTimer.current);
-    }
-    typingTimer.current = window.setTimeout(() => {
-      setIsTyping(false);
-      typingTimer.current = null;
+  }, []), handleInputChange = useCallback((value) => {
+    setQuery(value), setIsTyping(!0), typingTimer.current !== null && window.clearTimeout(typingTimer.current), typingTimer.current = window.setTimeout(() => {
+      setIsTyping(!1), typingTimer.current = null;
     }, SEARCH_DEBOUNCE_MS);
-  }, []);
-  const navigateToResult = useCallback(
+  }, []), navigateToResult = useCallback(
     (result) => {
-      setOpen(false);
-      router.push(result.url);
+      setOpen(!1), router.push(result.url);
     },
     [router, setOpen]
   );
   useEffect(() => {
     if (!open) return;
-    const frame = window.requestAnimationFrame(() => {
+    let frame = window.requestAnimationFrame(() => {
       inputRef.current?.focus();
     });
     return () => window.cancelAnimationFrame(frame);
-  }, [open]);
-  useShortcut(shortcut, () => setOpen(true), {
+  }, [open]), useShortcut(shortcut, () => setOpen(!0), {
     description: "Open search",
     group: "Search",
     priority: 100
-  });
-  useEffect(() => {
+  }), useEffect(() => {
     if (!query.trim()) {
-      setDisplayResults([]);
-      setSelectedValue("");
+      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("");
+    if (!(isTyping || loading)) {
+      if (output.status === "ready") {
+        setDisplayResults(output.items), setSelectedValue(output.items[0]?.id ?? "");
+        return;
+      }
+      (output.status === "building" || output.status === "stale" || output.status === "error") && (setDisplayResults([]), setSelectedValue(""));
     }
-  }, [isTyping, loading, output.items, output.status, query]);
-  useEffect(
+  }, [isTyping, loading, output.items, output.status, query]), useEffect(
     () => () => {
-      if (typingTimer.current !== null) {
-        window.clearTimeout(typingTimer.current);
-      }
+      typingTimer.current !== null && window.clearTimeout(typingTimer.current);
     },
     []
   );
-  const contextValue = useMemo(
+  let contextValue = useMemo(
     () => ({
       actions: {
         handleInputChange,

package/dist/sidebar-types-Bgchdfd6.d.ts

@@ -0,0 +1,25 @@
+import { Ref, ReactNode, MouseEvent } from 'react';
+import { T as TreeNode } from './types-DHBm7-j6.js';
+
+type SidebarTreeNode = TreeNode & {
+    children?: SidebarTreeNode[];
+};
+type SidebarActiveState = "path-active" | "child-path-active";
+type SidebarDepth = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+type SidebarNodePrimitiveProps = {
+    activeState?: SidebarActiveState;
+    activeItemRef?: Ref<HTMLDivElement>;
+    children?: ReactNode;
+    contentId?: string;
+    depth: SidebarDepth;
+    expanded?: boolean;
+    href?: string;
+    isExpandable?: boolean;
+    node: SidebarTreeNode;
+    onLinkClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
+    onToggle?: () => void;
+    parentExpanded: boolean;
+    title: string;
+};
+
+export type { SidebarNodePrimitiveProps as S, SidebarTreeNode as a, SidebarActiveState as b, SidebarDepth as c };

package/dist/theme-scope.d.ts

@@ -0,0 +1,15 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+type ThemeScopeProps = Readonly<{
+    "data-group": string;
+    "data-theme-root": "";
+}>;
+type ThemeScopeProviderProps = Readonly<{
+    children: ReactNode;
+    group?: string;
+}>;
+declare function ThemeScopeProvider({ children, group, }: ThemeScopeProviderProps): react_jsx_runtime.JSX.Element;
+declare function useThemeScope(): ThemeScopeProps;
+
+export { type ThemeScopeProps, ThemeScopeProvider, type ThemeScopeProviderProps, useThemeScope };

package/dist/theme-scope.js

@@ -0,0 +1,23 @@
+"use client";
+
+// src/lib/theme/theme-scope.tsx
+import { createContext, use } from "react";
+import { jsx } from "react/jsx-runtime";
+var ROOT_SCOPE = Object.freeze({
+  "data-group": "",
+  "data-theme-root": ""
+}), ThemeGroupContext = createContext("");
+function ThemeScopeProvider({
+  children,
+  group
+}) {
+  return /* @__PURE__ */ jsx(ThemeGroupContext, { value: group ?? "", children });
+}
+function useThemeScope() {
+  let group = use(ThemeGroupContext);
+  return group ? { "data-group": group, "data-theme-root": "" } : ROOT_SCOPE;
+}
+export {
+  ThemeScopeProvider,
+  useThemeScope
+};

package/dist/types-B_b3C0U6.d.ts

@@ -0,0 +1,63 @@
+type SiteData = {
+    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;
+    name: string;
+    handle?: string;
+    avatar?: string;
+    url?: string;
+};
+type PageStatus = "published" | "draft" | "archived";
+type PageNode = {
+    type: "page";
+    fileID: string;
+    title: string;
+    path: string;
+    group: string;
+    description?: string;
+    status: PageStatus;
+    publishedAt?: string;
+    updatedAt?: string;
+    authors: Author[];
+    tags?: string[];
+    og?: OgMetadata;
+    meta: Record<string, unknown>;
+};
+type SectionNode = {
+    type: "section";
+    id: string;
+    title: string;
+    path?: string;
+    group?: string;
+    children: TreeNode[];
+};
+type FolderNode = {
+    type: "folder";
+    id: string;
+    title: string;
+    path?: string;
+    group?: string;
+    children: TreeNode[];
+};
+type LinkNode = {
+    type: "link";
+    id: string;
+    title: string;
+    href: string;
+};
+type TreeNode = PageNode | SectionNode | FolderNode | LinkNode;
+
+export type { SiteData as S, TreeNode as T };

package/dist/types-CIwwieNw.d.ts

@@ -0,0 +1,127 @@
+type SiteData = {
+    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;
+    name: string;
+    handle?: string;
+    avatar?: string;
+    url?: string;
+};
+type PageStatus = "published" | "draft" | "archived";
+type PageData<TMeta extends Record<string, unknown> = Record<string, unknown>> = {
+    fileID: string;
+    group: string;
+    slug: string;
+    path: string;
+    title: string;
+    description?: string;
+    status: PageStatus;
+    publishedAt?: string;
+    updatedAt?: string;
+    authors: Author[];
+    tags: string[];
+    og?: OgMetadata;
+    meta: TMeta;
+    body: string;
+};
+type PageNode = {
+    type: "page";
+    fileID: string;
+    title: string;
+    path: string;
+    group: string;
+    description?: string;
+    status: PageStatus;
+    publishedAt?: string;
+    updatedAt?: string;
+    authors: Author[];
+    tags?: string[];
+    og?: OgMetadata;
+    meta: Record<string, unknown>;
+};
+type SectionNode = {
+    type: "section";
+    id: string;
+    title: string;
+    path?: string;
+    group?: string;
+    children: TreeNode[];
+};
+type FolderNode = {
+    type: "folder";
+    id: string;
+    title: string;
+    path?: string;
+    group?: string;
+    children: TreeNode[];
+};
+type LinkNode = {
+    type: "link";
+    id: string;
+    title: string;
+    href: string;
+};
+type TreeNode = PageNode | SectionNode | FolderNode | LinkNode;
+type RouteRecord = {
+    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;
+    ancestry?: string[];
+    meta?: Record<string, unknown>;
+    tree: TreeNode[];
+    pages: PageData[];
+};
+type ManifestLike = {
+    site: SiteData;
+    groups: Record<string, GroupManifest>;
+    routes: RouteRecord[];
+    pages: PageData[];
+    tree: TreeNode[];
+    attribution?: Record<string, ResolvedAttribution>;
+    contentHash: string;
+};
+type LayoutProps = {
+    children: React.ReactNode;
+    site: SiteData;
+    tree: TreeNode[];
+    node: TreeNode;
+    currentPath: string;
+    group: string;
+};
+type IndexPageProps = {
+    site: SiteData;
+    tree: TreeNode[];
+    node: TreeNode;
+    currentPath: string;
+    group: string;
+};
+
+export type { IndexPageProps as I, LayoutProps as L, ManifestLike as M, PageStatus as P };