@dreamlake/dockit 0.1.1

package/dist/lib/pagefind-search.js

@@ -0,0 +1,201 @@
+import { searchIndex, search } from "./search-index.js";
+import { pages } from "./navigation.js";
+let pagefind = null;
+let initPromise = null;
+async function getPagefind() {
+  if (pagefind) return pagefind;
+  if (initPromise) return initPromise;
+  initPromise = (async () => {
+    try {
+      const path = `/${["pagefind", "pagefind.js"].join("/")}`;
+      const pf = await import(
+        /* @vite-ignore */
+        path
+      );
+      await pf.options({ excerptLength: 200 });
+      pagefind = pf;
+      return pf;
+    } catch {
+      return null;
+    }
+  })();
+  return initPromise;
+}
+const STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "but",
+  "by",
+  "for",
+  "if",
+  "in",
+  "into",
+  "is",
+  "it",
+  "no",
+  "not",
+  "of",
+  "on",
+  "or",
+  "such",
+  "that",
+  "the",
+  "their",
+  "then",
+  "there",
+  "these",
+  "they",
+  "this",
+  "to",
+  "was",
+  "will",
+  "with",
+  "how",
+  "what",
+  "when",
+  "where",
+  "which",
+  "who",
+  "do",
+  "does",
+  "can",
+  "could",
+  "should",
+  "would",
+  "has",
+  "have",
+  "had",
+  "my",
+  "your",
+  "its",
+  "our",
+  "from",
+  "about"
+]);
+function extractMarked(html) {
+  const out = [];
+  const re = /<mark>([^<]*)<\/mark>/gi;
+  let m;
+  while ((m = re.exec(html)) !== null) out.push(m[1].toLowerCase());
+  return out;
+}
+function hasNonStopWordMatch(excerpts) {
+  for (const html of excerpts) {
+    for (const term of extractMarked(html)) {
+      const words = term.split(/\s+/);
+      if (words.some((w) => w && !STOP_WORDS.has(w))) return true;
+    }
+  }
+  return false;
+}
+function countOccurrences(text, phrase) {
+  let count = 0;
+  let from = 0;
+  while (true) {
+    const idx = text.indexOf(phrase, from);
+    if (idx < 0) break;
+    count++;
+    from = idx + phrase.length;
+  }
+  return count;
+}
+function normalizeUrl(url) {
+  return url.replace(/\/index\.html$/, "").replace(/\.html$/, "") || "/";
+}
+function defaultResults() {
+  return searchIndex.slice(0, 12).map((entry) => ({
+    path: entry.path,
+    title: entry.title,
+    section: entry.section,
+    description: entry.description ?? "",
+    snippet: entry.description ?? "",
+    excerptHtml: "",
+    subResults: [],
+    score: 0
+  }));
+}
+function getHiddenPaths() {
+  return new Set(pages.filter((p) => p.hidden).map((p) => p.path));
+}
+async function searchPages(query, limit = 30, showHidden = false) {
+  const q = query.trim();
+  if (!q) return defaultResults();
+  const hiddenPaths = getHiddenPaths();
+  const pf = await getPagefind();
+  if (!pf) {
+    return search(q, limit).filter((h) => showHidden || !hiddenPaths.has(h.entry.path)).map((h) => ({
+      path: h.entry.path,
+      title: h.entry.title,
+      section: h.entry.section,
+      description: h.entry.description ?? "",
+      snippet: h.snippet,
+      excerptHtml: "",
+      subResults: [],
+      score: h.score
+    }));
+  }
+  const results = await pf.search(q);
+  const loaded = await Promise.all(
+    results.results.slice(0, limit).map((r) => r.data())
+  );
+  const ql = q.toLowerCase();
+  const queryWords = ql.split(/\s+/).filter(Boolean);
+  const hasMultipleWords = queryWords.length > 1;
+  const hasContentWords = queryWords.some((w) => !STOP_WORDS.has(w));
+  const mapped = loaded.map((r, i) => {
+    const path = normalizeUrl(r.url);
+    const entry = searchIndex.find((e) => e.path === path);
+    const subResults = (r.sub_results ?? []).map((sr) => ({
+      title: sr.title ?? "",
+      url: normalizeUrl(sr.url),
+      excerptHtml: sr.excerpt ?? ""
+    }));
+    let score = results.results.length - i;
+    if (hasContentWords) {
+      const allExcerpts = [
+        r.excerpt ?? "",
+        ...(r.sub_results ?? []).map((sr) => sr.excerpt ?? "")
+      ];
+      if (!hasNonStopWordMatch(allExcerpts)) {
+        score = -1;
+      }
+    }
+    const titleLc = (r.meta?.title ?? entry?.title ?? "").toLowerCase();
+    if (titleLc === ql) score += 500;
+    else if (titleLc.startsWith(ql)) score += 300;
+    else if (titleLc.includes(ql)) score += 200;
+    const sectionLc = (entry?.section ?? "").toLowerCase();
+    if (sectionLc.includes(ql)) score += 50;
+    if (hasMultipleWords) {
+      const allText = [
+        r.excerpt ?? "",
+        ...(r.sub_results ?? []).map((sr) => sr.excerpt ?? "")
+      ].join(" ").replace(/<[^>]+>/g, "").toLowerCase();
+      const phraseCount = countOccurrences(allText, ql);
+      if (phraseCount > 0) {
+        score += 50 + Math.min(phraseCount, 5) * 10;
+      }
+    }
+    return {
+      path,
+      title: r.meta?.title ?? entry?.title ?? "",
+      section: entry?.section ?? "",
+      description: entry?.description ?? "",
+      snippet: r.excerpt?.replace(/<[^>]+>/g, "").trim() ?? "",
+      excerptHtml: r.excerpt ?? "",
+      subResults,
+      score
+    };
+  });
+  mapped.sort((a, b) => b.score - a.score);
+  return mapped.filter((r) => r.score >= 0 && (showHidden || !hiddenPaths.has(r.path)));
+}
+export {
+  defaultResults,
+  searchPages
+};

package/dist/lib/search-index.d.ts

@@ -0,0 +1,43 @@
+import { PageMeta } from './navigation';
+export interface SearchEntry extends PageMeta {
+    /** Heading text (h2/h3) for higher-weight ranking. */
+    headings: string[];
+    /** Plain-text body, lowercased, with markdown / JSX / code stripped. */
+    body: string;
+}
+/**
+ * Module-level singletons, populated by `initSearchIndex()` from the
+ * consuming site. Mutated in place — never reassigned — so importing
+ * components always see current data.
+ */
+/** Raw (frontmatter- and import-stripped) markdown per page path — feeds
+ *  the search palette's preview pane. */
+export declare const rawMarkdown: Map<string, string>;
+/** The dev-time fallback search index (pagefind takes over on built sites). */
+export declare const searchIndex: SearchEntry[];
+/**
+ * Populate the search singletons from the site's raw page glob:
+ *
+ *   initSearchIndex(
+ *     import.meta.glob('./pages/** /+Page.mdx', { eager: true, query: '?raw', import: 'default' }),
+ *   )
+ *
+ * Call AFTER `initNavigation()` — entries join against `pages`.
+ */
+export declare function initSearchIndex(rawSources: Record<string, string>): void;
+export interface SearchHit {
+    entry: SearchEntry;
+    score: number;
+    /** Up to ~140 chars of context around the first body match, for the preview pane. */
+    snippet: string;
+}
+/**
+ * Rank weights — highest signal first:
+ *   title exact / startsWith / contains
+ *   heading contains
+ *   description contains
+ *   section contains
+ *   body contains (count matters)
+ *   subsequence fuzzy (last resort)
+ */
+export declare function search(query: string, limit?: number): SearchHit[];

package/dist/lib/search-index.js

@@ -0,0 +1,112 @@
+import { pages } from "./navigation.js";
+function pathFromFile(filePath) {
+  const dir = filePath.replace(/^.*?\bpages\//, "").replace(/\/\+Page\.mdx$/, "");
+  return dir === "index" ? "/" : `/${dir}`;
+}
+function stripToText(raw) {
+  let s = raw;
+  s = s.replace(/^---[\s\S]*?\n---\s*\n?/, "");
+  s = s.replace(/^[ \t]*import[\s\S]*?from\s+['"][^'"]+['"]\s*;?\s*$/gm, "");
+  s = s.replace(/```[\s\S]*?```/g, " ");
+  s = s.replace(/`([^`]*)`/g, "$1");
+  const headings = [];
+  s = s.replace(/^[ \t]*#{1,6}[ \t]+(.+?)[ \t]*#*[ \t]*$/gm, (_m, text) => {
+    headings.push(text.trim());
+    return " ";
+  });
+  s = s.replace(/<[^>]+>/g, " ");
+  s = s.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1");
+  s = s.replace(/\[([^\]]+)\]\[[^\]]*\]/g, "$1");
+  s = s.replace(/[*_~]+/g, " ");
+  s = s.replace(/\|/g, " ");
+  s = s.replace(/\s+/g, " ").trim().toLowerCase();
+  return { headings, body: s };
+}
+function stripPreamble(raw) {
+  let s = raw;
+  s = s.replace(/^---[\s\S]*?\n---\s*\n?/, "");
+  s = s.replace(/^[ \t]*import[\s\S]*?from\s+['"][^'"]+['"]\s*;?\s*$/gm, "");
+  return s.trim();
+}
+const rawMarkdown = /* @__PURE__ */ new Map();
+const searchIndex = [];
+function initSearchIndex(rawSources) {
+  const bodyMap = /* @__PURE__ */ new Map();
+  rawMarkdown.clear();
+  for (const [filePath, raw] of Object.entries(rawSources)) {
+    const path = pathFromFile(filePath);
+    bodyMap.set(path, stripToText(raw));
+    rawMarkdown.set(path, stripPreamble(raw));
+  }
+  searchIndex.length = 0;
+  for (const p of pages) {
+    const extracted = bodyMap.get(p.path) ?? { headings: [], body: "" };
+    searchIndex.push({ ...p, headings: extracted.headings, body: extracted.body });
+  }
+}
+function search(query, limit = 30) {
+  const q = query.trim().toLowerCase();
+  if (!q) return [];
+  const hits = [];
+  for (const entry of searchIndex) {
+    const title = entry.title.toLowerCase();
+    const section = entry.section.toLowerCase();
+    const description = (entry.description ?? "").toLowerCase();
+    let score = 0;
+    let snippet = "";
+    if (title === q) score += 30;
+    else if (title.startsWith(q)) score += 18;
+    else if (title.includes(q)) score += 10;
+    for (const h of entry.headings) {
+      if (h.toLowerCase().includes(q)) {
+        score += 6;
+        if (!snippet) snippet = h;
+      }
+    }
+    if (description.includes(q)) {
+      score += 5;
+      if (!snippet) snippet = entry.description ?? "";
+    }
+    if (section.includes(q)) score += 3;
+    if (entry.body) {
+      const idx = entry.body.indexOf(q);
+      if (idx >= 0) {
+        let count = 0;
+        let from = 0;
+        while (true) {
+          const k = entry.body.indexOf(q, from);
+          if (k < 0) break;
+          count++;
+          from = k + q.length;
+        }
+        score += 2 + Math.min(count, 5);
+        if (!snippet) {
+          const start = Math.max(0, idx - 40);
+          const end = Math.min(entry.body.length, idx + q.length + 80);
+          snippet = (start > 0 ? "…" : "") + entry.body.slice(start, end) + (end < entry.body.length ? "…" : "");
+        }
+      }
+    }
+    if (score === 0) {
+      let i = 0;
+      for (const ch of title) {
+        if (ch === q[i]) i++;
+        if (i === q.length) {
+          score = 1;
+          break;
+        }
+      }
+    }
+    if (score > 0) {
+      hits.push({ entry, score, snippet: snippet || entry.description || "" });
+    }
+  }
+  hits.sort((a, b) => b.score - a.score);
+  return hits.slice(0, limit);
+}
+export {
+  initSearchIndex,
+  rawMarkdown,
+  search,
+  searchIndex
+};

package/dist/lib/tabs.d.ts

@@ -0,0 +1,23 @@
+export interface TabDef {
+    id: string;
+    label: string;
+    /** Roman numeral prefix — small, muted, for the editorial chapter feel. */
+    numeral: string;
+    /** Default landing path when the user clicks this tab from elsewhere. */
+    landing: string;
+    /** URL prefix that scopes pages to this tab. A page belongs to a tab
+     *  iff its path starts with this prefix (or equals `/` for the first tab). */
+    urlPrefix: string;
+}
+/** Module-level singleton, populated by `initTabs()`. Mutated in place —
+ *  never reassigned — so importing components keep a live reference. */
+export declare const TABS: TabDef[];
+/** Populate the tab singleton from the consuming site. */
+export declare function initTabs(tabs: TabDef[]): void;
+/** Derive active tab from a page URL. The site root `/` resolves to the
+ *  first tab. Unknown prefixes also fall back to the first tab so orphan
+ *  pages never leave the sidebar empty. With no tabs registered, always
+ *  returns '' (every page then belongs to the same, tabless view). */
+export declare function tabForUrl(url: string | undefined): string;
+/** True if a page URL belongs to the given tab. */
+export declare function urlInTab(url: string, tabId: string): boolean;

package/dist/lib/tabs.js

@@ -0,0 +1,30 @@
+const TABS = [];
+function initTabs(tabs) {
+  TABS.length = 0;
+  TABS.push(...tabs);
+}
+function firstSegment(url) {
+  const path = url.split(/[?#]/)[0];
+  const trimmed = path.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!trimmed) return "";
+  return trimmed.split("/")[0];
+}
+function tabForUrl(url) {
+  if (TABS.length === 0) return "";
+  if (!url) return TABS[0].id;
+  const seg = firstSegment(url);
+  if (!seg) return TABS[0].id;
+  for (const tab of TABS) {
+    if (tab.urlPrefix === `/${seg}`) return tab.id;
+  }
+  return TABS[0].id;
+}
+function urlInTab(url, tabId) {
+  return tabForUrl(url) === tabId;
+}
+export {
+  TABS,
+  initTabs,
+  tabForUrl,
+  urlInTab
+};

package/dist/lib/use-hidden-toggle.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Global "show hidden pages" toggle.
+ *
+ * Pages with `hidden: true` in frontmatter are filtered out of the
+ * sidebar by default. Press the chord below to reveal them; press
+ * again to hide. State is persisted to localStorage as `doc:show-hidden`
+ * so it survives reloads.
+ *
+ * Keybinding: **Cmd+Shift+D** (macOS) / **Ctrl+Shift+D** (Linux/Win).
+ * `Cmd+D` alone is browser bookmark — adding Shift dodges that.
+ *
+ * The hook also exposes the setter so a UI control (e.g. a topbar
+ * indicator) can toggle the state from a click as well.
+ */
+export declare function useHiddenToggle(): [boolean, (next: boolean) => void];

package/dist/lib/use-hidden-toggle.js

@@ -0,0 +1,23 @@
+import { useEffect } from "react";
+import { useLocalStorage } from "./use-local-storage.js";
+function useHiddenToggle() {
+  const [show, setShow] = useLocalStorage("show-hidden", false);
+  useEffect(() => {
+    const onKey = (e) => {
+      const t = e.target;
+      if (t && (t.tagName === "INPUT" || t.tagName === "TEXTAREA" || t.isContentEditable)) {
+        return;
+      }
+      const isToggle = (e.metaKey || e.ctrlKey) && e.shiftKey && (e.key === "D" || e.key === "d");
+      if (!isToggle) return;
+      e.preventDefault();
+      setShow(!show);
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [show, setShow]);
+  return [show, setShow];
+}
+export {
+  useHiddenToggle
+};

package/dist/lib/use-line-numbers.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Site-wide "show line numbers" toggle. Every CodeBlock / Preview
+ * reads and writes through this hook, so flipping the switch on one
+ * block flips them all — both within a single tab (via the
+ * `useLocalStorage` custom-event broadcast) and across tabs (via the
+ * native `storage` event). Persistence + cross-tab sync are provided
+ * by `useLocalStorage`; this file just pins the key + default.
+ */
+export declare function useLineNumbers(): [boolean, (v: boolean) => void];

package/dist/lib/use-line-numbers.js

@@ -0,0 +1,7 @@
+import { useLocalStorage } from "./use-local-storage.js";
+function useLineNumbers() {
+  return useLocalStorage("line-numbers", false);
+}
+export {
+  useLineNumbers
+};

package/dist/lib/use-local-storage.d.ts

@@ -0,0 +1,15 @@
+export declare const DOC_PREFIX = "doc:";
+export declare const docKey: (k: string) => string;
+/**
+ * SSR-safe localStorage-backed state. Returns the in-memory React
+ * value and a setter that mirrors the value into localStorage and
+ * broadcasts to other consumers in the same tab.
+ *
+ * - On server render, the initial value is `defaultValue` (no
+ *   localStorage access). The hook reconciles on mount.
+ * - Cross-tab sync works via the native `storage` event.
+ * - Same-tab sync (e.g., toggling a setting on one CodeBlock updates
+ *   every other CodeBlock on the page) works via a custom event the
+ *   setter dispatches on every write.
+ */
+export declare function useLocalStorage<T>(key: string, defaultValue: T): [T, (next: T) => void];

package/dist/lib/use-local-storage.js

@@ -0,0 +1,58 @@
+import { useState, useRef, useEffect, useCallback } from "react";
+const DOC_PREFIX = "doc:";
+const docKey = (k) => k.startsWith(DOC_PREFIX) ? k : DOC_PREFIX + k;
+const SAME_TAB_EVENT = "doc:storage";
+function useLocalStorage(key, defaultValue) {
+  const fullKey = docKey(key);
+  const [value, setValue] = useState(defaultValue);
+  const defaultRef = useRef(defaultValue);
+  defaultRef.current = defaultValue;
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const read = () => {
+      try {
+        const raw = localStorage.getItem(fullKey);
+        if (raw === null) {
+          setValue(defaultRef.current);
+        } else {
+          setValue(JSON.parse(raw));
+        }
+      } catch (err) {
+      }
+    };
+    read();
+    const onStorage = (e) => {
+      if (e.key === fullKey) read();
+    };
+    const onSameTab = (e) => {
+      const detail = e.detail;
+      if (detail?.key === fullKey) read();
+    };
+    window.addEventListener("storage", onStorage);
+    window.addEventListener(SAME_TAB_EVENT, onSameTab);
+    return () => {
+      window.removeEventListener("storage", onStorage);
+      window.removeEventListener(SAME_TAB_EVENT, onSameTab);
+    };
+  }, [fullKey]);
+  const set = useCallback(
+    (next) => {
+      setValue(next);
+      if (typeof window === "undefined") return;
+      try {
+        localStorage.setItem(fullKey, JSON.stringify(next));
+      } catch {
+      }
+      window.dispatchEvent(
+        new CustomEvent(SAME_TAB_EVENT, { detail: { key: fullKey } })
+      );
+    },
+    [fullKey]
+  );
+  return [value, set];
+}
+export {
+  DOC_PREFIX,
+  docKey,
+  useLocalStorage
+};

package/dist/lib/use-media-query.d.ts

@@ -0,0 +1,5 @@
+/**
+ * SSR-safe matchMedia hook. Starts `false` on the server so the initial
+ * HTML matches the mobile-first CSS layer, then re-evaluates on mount.
+ */
+export declare function useMediaQuery(query: string): boolean;

package/dist/lib/use-media-query.js

@@ -0,0 +1,16 @@
+import { useState, useEffect } from "react";
+function useMediaQuery(query) {
+  const [matches, setMatches] = useState(false);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const mql = window.matchMedia(query);
+    setMatches(mql.matches);
+    const onChange = (e) => setMatches(e.matches);
+    mql.addEventListener("change", onChange);
+    return () => mql.removeEventListener("change", onChange);
+  }, [query]);
+  return matches;
+}
+export {
+  useMediaQuery
+};

package/dist/renderer/Layout.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export declare const useMerge: () => boolean;
+export declare function Layout({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;