@umami/shiso 1.1.2 → 1.1.4

package/dist/chunks/local.js

@@ -0,0 +1,66 @@
+//#region src/lib/search.ts
+/**
+* Restricts records to the active scope. Records without a scope id (from
+* single-scope indexes or older caches) always pass.
+*/
+function filterRecordsByScope(records, context) {
+	if (!context?.scopeId) return records;
+	return records.filter((record) => !record.scopeId || record.scopeId === context.scopeId);
+}
+const SNIPPET_RADIUS = 60;
+function makeSnippet(text, index, length) {
+	const start = Math.max(0, index - SNIPPET_RADIUS);
+	const end = Math.min(text.length, index + length + SNIPPET_RADIUS);
+	return `${start > 0 ? "…" : ""}${text.slice(start, end).trim()}${end < text.length ? "…" : ""}`;
+}
+function searchIndex(records, query, limit = 10) {
+	const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+	if (!terms.length) return [];
+	const results = [];
+	for (const record of records) {
+		const page = record.page.toLowerCase();
+		const heading = (record.heading || "").toLowerCase();
+		const text = record.text.toLowerCase();
+		let score = 0;
+		let snippetAt = -1;
+		let snippetLength = 0;
+		let matched = true;
+		for (const term of terms) if (page.includes(term)) score += page === term ? 40 : 20;
+		else if (heading.includes(term)) score += heading === term ? 30 : 15;
+		else {
+			const index = text.indexOf(term);
+			if (index === -1) {
+				matched = false;
+				break;
+			}
+			score += 5;
+			if (snippetAt === -1) {
+				snippetAt = index;
+				snippetLength = term.length;
+			}
+		}
+		if (!matched || !score) continue;
+		results.push({
+			url: record.id ? `${record.url}#${record.id}` : record.url,
+			page: record.page,
+			heading: record.heading,
+			snippet: snippetAt >= 0 ? makeSnippet(record.text, snippetAt, snippetLength) : void 0,
+			score
+		});
+	}
+	return results.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+
+//#endregion
+//#region src/lib/search/providers/local.ts
+/** Built-in provider backed by the section index generated during the build. */
+function createLocalSearchProvider(_options = {}) {
+	let records = null;
+	return { async search(query, limit, context) {
+		records ||= import("@/lib/search-index.generated").then((module) => module.SEARCH_INDEX);
+		return searchIndex(filterRecordsByScope(await records, context), query, limit);
+	} };
+}
+
+//#endregion
+export { createLocalSearchProvider };

package/dist/entry-client.js

@@ -0,0 +1,13 @@
+import { h as BrowserRouter, p as BASE_URL, t as App } from "./chunks/App.js";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/entry-client.tsx
+function ShisoApp() {
+	return /* @__PURE__ */ jsx(BrowserRouter, {
+		basename: BASE_URL || void 0,
+		children: /* @__PURE__ */ jsx(App, {})
+	});
+}
+
+//#endregion
+export { ShisoApp };

package/dist/entry-server.js

@@ -0,0 +1,137 @@
+import { _ as createPath, a as docsSite, c as getSeo, d as getLastModified, f as getScopeForPage, g as Router, i as docsHomeUrl, l as siteName, m as toAbsoluteUrl, n as buildHead, o as getLocaleByPathname, p as BASE_URL, r as renderHeadToString, s as getRedirects, t as App, u as getDocModule, v as parsePath, y as ABSOLUTE_URL_REGEX } from "./chunks/App.js";
+import * as React$1 from "react";
+import { jsx } from "react/jsx-runtime";
+import { renderToString } from "react-dom/server";
+
+//#region ../../node_modules/.pnpm/react-router@8.3.0_react-do_c27277bcf657dc321048682bd02ab633/node_modules/react-router/dist/production/lib/dom/server.js
+/**
+* react-router v8.3.0
+*
+* Copyright (c) Remix Software Inc.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE.md file in the root directory of this source tree.
+*
+* @license MIT
+*/
+/**
+* A {@link Router | `<Router>`} that may not navigate to any other {@link Location}.
+* This is useful on the server where there is no stateful UI.
+*
+* @public
+* @category Declarative Routers
+* @mode declarative
+* @param props Props
+* @param {StaticRouterProps.basename} props.basename n/a
+* @param {StaticRouterProps.children} props.children n/a
+* @param {StaticRouterProps.location} props.location n/a
+* @returns A React element that renders the static {@link Router | `<Router>`}
+*/
+function StaticRouter({ basename, children, location: locationProp = "/" }) {
+	if (typeof locationProp === "string") locationProp = parsePath(locationProp);
+	let action = "POP";
+	let location = {
+		pathname: locationProp.pathname || "/",
+		search: locationProp.search || "",
+		hash: locationProp.hash || "",
+		state: locationProp.state != null ? locationProp.state : null,
+		key: locationProp.key || "default",
+		mask: void 0
+	};
+	let staticNavigator = getStatelessNavigator();
+	return /* @__PURE__ */ React$1.createElement(Router, {
+		basename,
+		children,
+		location,
+		navigationType: action,
+		navigator: staticNavigator,
+		static: true,
+		useTransitions: false
+	});
+}
+function getStatelessNavigator() {
+	return {
+		createHref,
+		encodeLocation,
+		push(to) {
+			throw new Error(`You cannot use navigator.push() on the server because it is a stateless environment. This error was probably triggered when you did a \`navigate(${JSON.stringify(to)})\` somewhere in your app.`);
+		},
+		replace(to) {
+			throw new Error(`You cannot use navigator.replace() on the server because it is a stateless environment. This error was probably triggered when you did a \`navigate(${JSON.stringify(to)}, { replace: true })\` somewhere in your app.`);
+		},
+		go(delta) {
+			throw new Error(`You cannot use navigator.go() on the server because it is a stateless environment. This error was probably triggered when you did a \`navigate(${delta})\` somewhere in your app.`);
+		},
+		back() {
+			throw new Error("You cannot use navigator.back() on the server because it is a stateless environment.");
+		},
+		forward() {
+			throw new Error("You cannot use navigator.forward() on the server because it is a stateless environment.");
+		}
+	};
+}
+function createHref(to) {
+	return typeof to === "string" ? to : createPath(to);
+}
+function encodeLocation(to) {
+	let href = typeof to === "string" ? to : createPath(to);
+	href = href.replace(/ $/, "%20");
+	let encoded = ABSOLUTE_URL_REGEX.test(href) ? new URL(href) : new URL(href, "http://localhost");
+	return {
+		pathname: encoded.pathname,
+		search: encoded.search,
+		hash: encoded.hash
+	};
+}
+
+//#endregion
+//#region src/entry-server.tsx
+/** Base-relative routes for every scope. The prerenderer prepends the deploy base itself. */
+function getRoutes() {
+	return docsSite.pages.map((page) => page.url);
+}
+/**
+* Source file for every routed page, so the prerenderer can publish raw
+* markdown next to each HTML page (used by the contextual menu's copy/view
+* options and by AI tools). `filePath` is a module key like
+* "/content/docs/index.mdx", resolved against the project root.
+*/
+function getMarkdownPages() {
+	return docsSite.pages.map((page) => ({
+		route: page.url,
+		filePath: page.filePath
+	}));
+}
+/**
+* Absolute URLs for the sitemap, honoring `seo.indexing` and per-page
+* noindex. Empty when `$shiso.siteUrl` is not configured, since a sitemap
+* of relative URLs is invalid.
+*/
+function getSitemapEntries() {
+	const { indexing } = getSeo();
+	const entries = [];
+	for (const page of docsSite.pages) {
+		if ((page.hidden || getScopeForPage(docsSite, page).hidden) && indexing !== "all") continue;
+		if (getDocModule(page.filePath)?.frontmatter?.noindex === true) continue;
+		const url = toAbsoluteUrl(page.url);
+		if (url) entries.push({
+			url,
+			lastmod: getLastModified(page.filePath)
+		});
+	}
+	return entries;
+}
+function render(url) {
+	return {
+		html: renderToString(/* @__PURE__ */ jsx(StaticRouter, {
+			basename: BASE_URL || void 0,
+			location: `${BASE_URL}${url}`,
+			children: /* @__PURE__ */ jsx(App, {})
+		})),
+		head: renderHeadToString(buildHead(url)),
+		htmlAttrs: getLocaleByPathname(url)
+	};
+}
+
+//#endregion
+export { docsHomeUrl, getMarkdownPages, getRedirects, getRoutes, getSitemapEntries, render, siteName };

package/dist/search.js

@@ -0,0 +1,44 @@
+//#region src/lib/search/provider.ts
+const factories = /* @__PURE__ */ new Map();
+function normalizeProviderId(id) {
+	return id.trim().toLowerCase();
+}
+/**
+* Registers a runtime search provider. Call this before rendering the app.
+* The returned cleanup function only removes this exact registration.
+*/
+function registerSearchProvider(id, factory) {
+	const providerId = normalizeProviderId(id);
+	if (!providerId || providerId === "local") throw new Error("Search provider ids must be non-empty and cannot replace the built-in \"local\" provider.");
+	factories.set(providerId, factory);
+	return () => {
+		if (factories.get(providerId) === factory) factories.delete(providerId);
+	};
+}
+async function createLocalProvider(options) {
+	const { createLocalSearchProvider } = await import("./chunks/local.js");
+	return createLocalSearchProvider(options);
+}
+/** Resolves a configured provider, falling back to local for unknown ids. */
+async function resolveSearchProvider(id, options = {}) {
+	const requestedId = normalizeProviderId(id) || "local";
+	if (requestedId === "local") return {
+		provider: await createLocalProvider(options),
+		providerId: "local",
+		fellBack: false
+	};
+	const factory = factories.get(requestedId);
+	if (factory) return {
+		provider: await factory(options),
+		providerId: requestedId,
+		fellBack: false
+	};
+	return {
+		provider: await createLocalProvider({}),
+		providerId: "local",
+		fellBack: true
+	};
+}
+
+//#endregion
+export { registerSearchProvider, resolveSearchProvider };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umami/shiso",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Open-source documentation framework for Markdown and MDX sites.",
   "type": "module",
   "bin": {
@@ -9,18 +9,20 @@
   "exports": {
     "./client": {
       "types": "./types/client.d.ts",
-      "default": "./src/entry-client.tsx"
+      "default": "./dist/entry-client.js"
     },
     "./search": {
       "types": "./types/search.d.ts",
-      "default": "./src/lib/search/provider.ts"
+      "default": "./dist/search.js"
     },
+    "./styles.css": "./src/styles/global.css",
     "./schema": "./docs.schema.json",
     "./docs.schema.json": "./docs.schema.json",
     "./package.json": "./package.json"
   },
   "files": [
     "bin",
+    "dist",
     "scripts",
     "src",
     "types",
@@ -31,7 +33,8 @@
     "README.md"
   ],
   "scripts": {
-    "prepack": "pnpm test:package",
+    "build:runtime": "node scripts/build-runtime.mjs",
+    "prepack": "pnpm build:runtime && pnpm test:package",
     "test:package": "node scripts/check-package.mjs"
   },
   "engines": {
@@ -89,5 +92,8 @@
   "peerDependencies": {
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "rolldown": "^1.2.2"
   }
 }

package/scripts/build-runtime.mjs

@@ -0,0 +1,114 @@
+import fsSync from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { rolldown } from 'rolldown';
+
+const packageRoot = path.resolve(import.meta.dirname, '..');
+const sourceRoot = path.join(packageRoot, 'src');
+const outputRoot = path.join(packageRoot, 'dist');
+
+const projectModules = new Set([
+  '@/generated/last-modified',
+  '@/lib/icon-registry.generated',
+  '@/lib/search-index.generated',
+  'virtual:shiso-docs-config',
+]);
+
+const peerModules = new Set(['react', 'react-dom']);
+const sharedModules = new Set(['@mdx-js/react']);
+const runtimeAliases = new Map([
+  ['use-sync-external-store/shim', path.join(sourceRoot, 'lib/vendor/use-sync-external-store.ts')],
+  [
+    'use-sync-external-store/shim/with-selector',
+    path.join(sourceRoot, 'lib/vendor/use-sync-external-store-with-selector.ts'),
+  ],
+]);
+
+function isExternal(source) {
+  const packageName = source.startsWith('@')
+    ? source.split('/').slice(0, 2).join('/')
+    : source.split('/')[0];
+
+  return (
+    projectModules.has(source) ||
+    peerModules.has(packageName) ||
+    sharedModules.has(source) ||
+    source === '@umami/shiso/styles.css' ||
+    source.endsWith('.css')
+  );
+}
+
+function resolveSourceModule(source) {
+  const base = path.join(sourceRoot, source.slice(2));
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.tsx`,
+    `${base}.js`,
+    `${base}.jsx`,
+    path.join(base, 'index.ts'),
+    path.join(base, 'index.tsx'),
+    path.join(base, 'index.js'),
+    path.join(base, 'index.jsx'),
+  ];
+
+  return candidates.find(candidate => {
+    try {
+      return fsSync.statSync(candidate).isFile();
+    } catch {
+      return false;
+    }
+  });
+}
+
+const bundle = await rolldown({
+  input: {
+    'entry-client': path.join(sourceRoot, 'entry-client.tsx'),
+    'entry-server': path.join(sourceRoot, 'entry-server.tsx'),
+    search: path.join(sourceRoot, 'lib/search/provider.ts'),
+  },
+  external: isExternal,
+  plugins: [
+    {
+      name: 'shiso-runtime-aliases',
+      resolveId(source) {
+        if (runtimeAliases.has(source)) {
+          return runtimeAliases.get(source);
+        }
+
+        if (projectModules.has(source)) {
+          return { id: source, external: true };
+        }
+
+        if (!source.startsWith('@/')) {
+          return null;
+        }
+
+        const resolved = resolveSourceModule(source);
+
+        if (!resolved) {
+          throw new Error(`Could not resolve runtime module "${source}".`);
+        }
+
+        return resolved;
+      },
+    },
+  ],
+  transform: {
+    jsx: 'react-jsx',
+    target: 'es2022',
+  },
+});
+
+await fs.rm(outputRoot, { recursive: true, force: true });
+await bundle.write({
+  dir: outputRoot,
+  format: 'esm',
+  entryFileNames: '[name].js',
+  chunkFileNames: 'chunks/[name].js',
+  minify: false,
+  sourcemap: false,
+});
+await bundle.close();
+
+console.log(`Built the Shiso runtime at ${path.relative(process.cwd(), outputRoot)}`);

package/scripts/check-package.mjs

@@ -5,11 +5,13 @@ const root = path.resolve(import.meta.dirname, '..');
 
 for (const relativeFile of [
   'bin/shiso.mjs',
+  'dist/entry-client.js',
+  'dist/entry-server.js',
+  'dist/search.js',
   'docs.schema.json',
   'scripts/lib/mdast.mjs',
   'scripts/lib/slug.mjs',
-  'src/entry-client.tsx',
-  'src/entry-server.tsx',
+  'src/styles/global.css',
   'types/client.d.ts',
   'types/search.d.ts',
   'vite.config.ts',

package/src/App.tsx

@@ -3,7 +3,7 @@ import '@fontsource/inter/700.css';
 import '@fontsource/inter/800.css';
 import '@fontsource/jetbrains-mono/400.css';
 import 'highlight.js/styles/github.css';
-import '@/styles/global.css';
+import '@umami/shiso/styles.css';
 
 import { MDXProvider } from '@mdx-js/react';
 import { Navigate, Route, Routes } from 'react-router';

package/src/entry-client.tsx

@@ -1,17 +1,11 @@
-import { hydrateRoot } from 'react-dom/client';
 import { BrowserRouter } from 'react-router';
 import { App } from '@/App';
 import { BASE_URL } from '@/lib/paths';
 
-export function mount(element: HTMLElement | null = document.getElementById('root')) {
-  if (!element) {
-    throw new Error('Shiso could not find the root element.');
-  }
-
-  return hydrateRoot(
-    element,
+export function ShisoApp() {
+  return (
     <BrowserRouter basename={BASE_URL || undefined}>
       <App />
-    </BrowserRouter>,
+    </BrowserRouter>
   );
 }

package/src/lib/vendor/use-sync-external-store-with-selector.ts

@@ -0,0 +1,77 @@
+/**
+ * React's MIT-licensed use-sync-external-store selector shim, adapted to use
+ * the native React 19 hook that Shiso already requires as a peer dependency.
+ */
+import { useDebugValue, useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
+
+interface SelectionState<Selection> {
+  hasValue: boolean;
+  value: Selection | null;
+}
+
+export function useSyncExternalStoreWithSelector<Snapshot, Selection>(
+  subscribe: (onStoreChange: () => void) => () => void,
+  getSnapshot: () => Snapshot,
+  getServerSnapshot: (() => Snapshot) | undefined,
+  selector: (snapshot: Snapshot) => Selection,
+  isEqual?: (left: Selection, right: Selection) => boolean,
+): Selection {
+  const stateRef = useRef<SelectionState<Selection> | null>(null);
+
+  if (stateRef.current === null) {
+    stateRef.current = { hasValue: false, value: null };
+  }
+
+  const state = stateRef.current;
+  const [getSelection, getServerSelection] = useMemo(() => {
+    let hasMemo = false;
+    let memoizedSnapshot: Snapshot;
+    let memoizedSelection: Selection;
+
+    const memoizedSelector = (nextSnapshot: Snapshot) => {
+      if (!hasMemo) {
+        hasMemo = true;
+        memoizedSnapshot = nextSnapshot;
+        const nextSelection = selector(nextSnapshot);
+
+        if (isEqual && state.hasValue && isEqual(state.value as Selection, nextSelection)) {
+          memoizedSelection = state.value as Selection;
+          return memoizedSelection;
+        }
+
+        memoizedSelection = nextSelection;
+        return memoizedSelection;
+      }
+
+      if (Object.is(memoizedSnapshot, nextSnapshot)) {
+        return memoizedSelection;
+      }
+
+      const nextSelection = selector(nextSnapshot);
+
+      if (isEqual?.(memoizedSelection, nextSelection)) {
+        memoizedSnapshot = nextSnapshot;
+        return memoizedSelection;
+      }
+
+      memoizedSnapshot = nextSnapshot;
+      memoizedSelection = nextSelection;
+      return memoizedSelection;
+    };
+
+    return [
+      () => memoizedSelector(getSnapshot()),
+      getServerSnapshot ? () => memoizedSelector(getServerSnapshot()) : undefined,
+    ] as const;
+  }, [getSnapshot, getServerSnapshot, selector, isEqual, state]);
+
+  const value = useSyncExternalStore(subscribe, getSelection, getServerSelection);
+
+  useEffect(() => {
+    state.hasValue = true;
+    state.value = value;
+  }, [state, value]);
+
+  useDebugValue(value);
+  return value;
+}

package/src/lib/vendor/use-sync-external-store.ts

@@ -0,0 +1 @@
+export { useSyncExternalStore } from 'react';

package/types/client.d.ts

@@ -1,3 +1,3 @@
-import type { Root } from 'react-dom/client';
+import type { ReactElement } from 'react';
 
-export function mount(element?: HTMLElement | null): Root;
+export function ShisoApp(): ReactElement;

package/vite.config.ts

@@ -281,7 +281,6 @@ function shisoHtml(getDocsConfig: () => DocsConfig): Plugin {
   };
 }
 
-const PACKAGE_ROOT = fileURLToPath(new URL('.', import.meta.url));
 const MDX_REACT_ENTRY = fileURLToPath(import.meta.resolve('@mdx-js/react'));
 const LUCIDE_REACT_ENTRY = path.join(
   path.dirname(fileURLToPath(import.meta.resolve('lucide-react/package.json'))),
@@ -298,10 +297,9 @@ export default defineConfig(async () => {
 
   return {
     optimizeDeps: {
-      include: [
-        '@umami/shiso > @base-ui/react > use-sync-external-store/shim',
-        '@umami/shiso > @base-ui/react > use-sync-external-store/shim/with-selector',
-      ],
+      // The published runtime is already bundled ESM and contains project-time
+      // virtual imports that are resolved by the plugins below.
+      exclude: ['@umami/shiso'],
     },
     plugins: [
       configModule.plugin,
@@ -340,7 +338,6 @@ export default defineConfig(async () => {
           find: '@/generated/last-modified',
           replacement: path.join(generatedRoot, 'last-modified.ts'),
         },
-        { find: '@', replacement: path.join(PACKAGE_ROOT, 'src') },
       ],
       dedupe: ['react', 'react-dom'],
     },