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

package/dist/search.cjs

@@ -0,0 +1,411 @@
+"use strict";
+"use client";
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/search.tsx
+var search_exports = {};
+__export(search_exports, {
+  SearchProvider: () => SearchProvider,
+  search: () => search,
+  useSearch: () => useSearch,
+  useSearchBlock: () => useSearchBlock
+});
+module.exports = __toCommonJS(search_exports);
+var import_keyboard_shortcuts = require("@publish.os/nextjs/keyboard-shortcuts");
+var import_navigation = require("next/navigation");
+var import_react = require("react");
+var import_jsx_runtime = require("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 = (0, import_react.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 = (0, import_react.useMemo)(
+    () => normalizeSearchInput({ filters, limit, offset, q }),
+    [filters, limit, offset, q]
+  );
+  const [output, setOutput] = (0, import_react.useState)(EMPTY_SEARCH_OUTPUT);
+  const requestId = (0, import_react.useRef)(0);
+  (0, import_react.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 = (0, import_react.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] = (0, import_react.useState)(defaultOpen);
+  const [query, setQuery] = (0, import_react.useState)("");
+  const [isTyping, setIsTyping] = (0, import_react.useState)(false);
+  const [selectedValue, setSelectedValue] = (0, import_react.useState)("");
+  const typingTimer = (0, import_react.useRef)(null);
+  const inputRef = (0, import_react.useRef)(null);
+  const listRef = (0, import_react.useRef)(null);
+  const router = (0, import_navigation.useRouter)();
+  const inputId = (0, import_react.useId)();
+  const listId = (0, import_react.useId)();
+  const open = controlledOpen ?? uncontrolledOpen;
+  const output = useSearch({ limit, q: query });
+  const [displayResults, setDisplayResults] = (0, import_react.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 = (0, import_react.useCallback)(
+    (nextOpen) => {
+      if (controlledOpen === void 0) {
+        setUncontrolledOpen(nextOpen);
+      }
+      onOpenChange?.(nextOpen);
+      if (!nextOpen) {
+        setQuery("");
+        setSelectedValue("");
+        setIsTyping(false);
+      }
+    },
+    [controlledOpen, onOpenChange]
+  );
+  const setQueryValue = (0, import_react.useCallback)((value) => {
+    setQuery(value);
+  }, []);
+  const handleInputChange = (0, import_react.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 = (0, import_react.useCallback)(
+    (result) => {
+      setOpen(false);
+      router.push(result.url);
+    },
+    [router, setOpen]
+  );
+  (0, import_react.useEffect)(() => {
+    if (!open) return;
+    const frame = window.requestAnimationFrame(() => {
+      inputRef.current?.focus();
+    });
+    return () => window.cancelAnimationFrame(frame);
+  }, [open]);
+  (0, import_keyboard_shortcuts.useShortcut)(shortcut, () => setOpen(true), {
+    description: "Open search",
+    group: "Search",
+    priority: 100
+  });
+  (0, import_react.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]);
+  (0, import_react.useEffect)(
+    () => () => {
+      if (typingTimer.current !== null) {
+        window.clearTimeout(typingTimer.current);
+      }
+    },
+    []
+  );
+  const contextValue = (0, import_react.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__ */ (0, import_jsx_runtime.jsx)(SearchBlockContext.Provider, { value: contextValue, children });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SearchProvider,
+  search,
+  useSearch,
+  useSearchBlock
+});

package/dist/search.d.cts

@@ -0,0 +1,20 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { SearchBlockVariant, SearchInput, SearchOutput, SearchBlockContextValue } from '@publish.os/nextjs/types';
+export { SearchBlockActions, SearchBlockContextValue, SearchBlockMeta, SearchBlockState, SearchBlockVariant, SearchInput, SearchOutput, SearchResult, SearchStatus, SearchSubResult } from '@publish.os/nextjs/types';
+import { ReactNode } from 'react';
+
+declare function search(input: SearchInput): Promise<SearchOutput>;
+declare function useSearch(input: SearchInput): SearchOutput;
+declare function useSearchBlock(): SearchBlockContextValue;
+type SearchProviderProps = {
+    children?: ReactNode;
+    defaultOpen?: boolean;
+    limit?: number;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    shortcut?: string;
+    variant?: SearchBlockVariant;
+};
+declare function SearchProvider({ children, defaultOpen, limit, onOpenChange, open: controlledOpen, shortcut, variant, }: SearchProviderProps): react_jsx_runtime.JSX.Element;
+
+export { SearchProvider, type SearchProviderProps, search, useSearch, useSearchBlock };

package/dist/search.d.ts

@@ -0,0 +1,20 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { SearchBlockVariant, SearchInput, SearchOutput, SearchBlockContextValue } from '@publish.os/nextjs/types';
+export { SearchBlockActions, SearchBlockContextValue, SearchBlockMeta, SearchBlockState, SearchBlockVariant, SearchInput, SearchOutput, SearchResult, SearchStatus, SearchSubResult } from '@publish.os/nextjs/types';
+import { ReactNode } from 'react';
+
+declare function search(input: SearchInput): Promise<SearchOutput>;
+declare function useSearch(input: SearchInput): SearchOutput;
+declare function useSearchBlock(): SearchBlockContextValue;
+type SearchProviderProps = {
+    children?: ReactNode;
+    defaultOpen?: boolean;
+    limit?: number;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    shortcut?: string;
+    variant?: SearchBlockVariant;
+};
+declare function SearchProvider({ children, defaultOpen, limit, onOpenChange, open: controlledOpen, shortcut, variant, }: SearchProviderProps): react_jsx_runtime.JSX.Element;
+
+export { SearchProvider, type SearchProviderProps, search, useSearch, useSearchBlock };