notionic 0.0.0-stage → 0.8.3

package/dist/fetch.js

@@ -0,0 +1,259 @@
+import { n as toLinkedPage, r as toNotionPage } from "./page-BmeweSIt.js";
+//#region src/bookmark-preview.ts
+/** Long enough for a slow site, short enough not to stall a build. */
+const TIMEOUT_MS = 5e3;
+/** Open Graph tags live in <head>; stop reading after this much HTML. */
+const MAX_BYTES = 524288;
+const MAX_REDIRECTS = 5;
+const USER_AGENT = "Mozilla/5.0 (compatible; notionic; +https://notionic.dev)";
+/**
+* Hosts a server shouldn't be asked to fetch on a page's behalf: loopback,
+* private and link-local addresses (which include cloud metadata endpoints).
+* Only literal addresses are checked; a public name that resolves to a private
+* address still gets through.
+*/
+function isPrivateHost(hostname) {
+	const host = hostname.replace(/^\[|\]$/g, "").toLowerCase();
+	if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local")) return true;
+	const ipv4 = host.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+	if (ipv4) {
+		const [a, b] = [Number(ipv4[1]), Number(ipv4[2])];
+		return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168;
+	}
+	if (host.includes(":")) return host === "::" || host === "::1" || host.startsWith("fc") || host.startsWith("fd") || host.startsWith("fe80") || host.startsWith("::ffff:");
+	return false;
+}
+/** A public http(s) URL, or null. */
+function fetchableUrl(url) {
+	try {
+		const parsed = new URL(url);
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+		return isPrivateHost(parsed.hostname) ? null : parsed;
+	} catch {
+		return null;
+	}
+}
+const ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: " "
+};
+function decodeEntities(text) {
+	return text.replace(/&(#x[\da-f]+|#\d+|[a-z]+);/gi, (match, entity) => {
+		if (entity[0] === "#") {
+			const code = entity[1] === "x" || entity[1] === "X" ? Number.parseInt(entity.slice(2), 16) : Number(entity.slice(1));
+			return Number.isFinite(code) && code > 0 && code <= 1114111 ? String.fromCodePoint(code) : match;
+		}
+		return ENTITIES[entity.toLowerCase()] ?? match;
+	});
+}
+function clean(value) {
+	return (value ? decodeEntities(value).replace(/\s+/g, " ").trim() : "") || void 0;
+}
+/** The attributes of each tag with the given name, lowercased keys. */
+function tags(html, name) {
+	const found = [];
+	for (const [tag] of html.matchAll(new RegExp(`<${name}\\b[^>]*>`, "gi"))) {
+		const attributes = {};
+		for (const [, key, , quoted, bare] of tag.matchAll(/([\w:-]+)\s*=\s*(?:(["'])(.*?)\2|([^\s"'>]+))/g)) if (key) attributes[key.toLowerCase()] = quoted ?? bare ?? "";
+		found.push(attributes);
+	}
+	return found;
+}
+/** An absolute http(s) URL resolved against the page, or undefined. */
+function absolute(value, base) {
+	if (!value) return void 0;
+	try {
+		const url = new URL(decodeEntities(value.trim()), base);
+		return url.protocol === "http:" || url.protocol === "https:" ? url.href : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The preview a page describes in its <head>: Open Graph and Twitter tags,
+* falling back to <title>, the meta description and the favicon. Null
+* without a title.
+*/
+function parseBookmarkPreview(html, pageUrl) {
+	const base = new URL(pageUrl);
+	const headEnd = html.search(/<\/head>/i);
+	const head = headEnd === -1 ? html : html.slice(0, headEnd);
+	const meta = {};
+	for (const attributes of tags(head, "meta")) {
+		const key = (attributes.property ?? attributes.name)?.toLowerCase();
+		if (key && attributes.content !== void 0 && !(key in meta)) meta[key] = attributes.content;
+	}
+	const titleTag = head.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i)?.[1];
+	const title = clean(meta["og:title"] ?? meta["twitter:title"] ?? titleTag);
+	if (!title) return null;
+	const icons = tags(head, "link").filter((link) => (link.rel ?? "").toLowerCase().split(/\s+/).includes("icon"));
+	return {
+		title,
+		description: clean(meta["og:description"] ?? meta["twitter:description"] ?? meta.description),
+		image: absolute(meta["og:image"] ?? meta["og:image:url"] ?? meta["twitter:image"], base),
+		favicon: absolute(icons[0]?.href, base) ?? new URL("/favicon.ico", base).href,
+		siteName: clean(meta["og:site_name"])
+	};
+}
+/** Reads up to MAX_BYTES of a response body as text. */
+async function readHead(response) {
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let html = "";
+	let bytes = 0;
+	while (bytes < MAX_BYTES) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		bytes += value.byteLength;
+		html += decoder.decode(value, { stream: true });
+		if (/<\/head>/i.test(html)) break;
+	}
+	await reader.cancel().catch(() => {});
+	return html;
+}
+/**
+* The preview card data for a bookmarked page, read from its HTML, or null
+* when the page can't be fetched, isn't HTML, or has no title.
+*/
+async function fetchBookmarkPreview(url) {
+	let target = fetchableUrl(url);
+	const signal = AbortSignal.timeout(TIMEOUT_MS);
+	try {
+		for (let hop = 0; target && hop <= MAX_REDIRECTS; hop++) {
+			const response = await fetch(target, {
+				headers: {
+					accept: "text/html,application/xhtml+xml",
+					"user-agent": USER_AGENT
+				},
+				redirect: "manual",
+				signal
+			});
+			const location = response.headers.get("location");
+			if (response.status >= 300 && response.status < 400 && location) {
+				await response.body?.cancel().catch(() => {});
+				target = fetchableUrl(new URL(location, target).href);
+				continue;
+			}
+			if (!response.ok || !/html/i.test(response.headers.get("content-type") ?? "")) {
+				await response.body?.cancel().catch(() => {});
+				return null;
+			}
+			return parseBookmarkPreview(await readHead(response), target.href);
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/fetch.ts
+/** The URL of a block that links to another site: a bookmark, embed or link preview. */
+function linkedUrl(block) {
+	if (!("type" in block)) return null;
+	if (block.type === "bookmark") return block.bookmark.url;
+	if (block.type === "embed") return block.embed.url;
+	if (block.type === "link_preview") return block.link_preview.url;
+	return null;
+}
+function isFullBlock(result) {
+	return "type" in result;
+}
+async function listChildren(client, blockId) {
+	const blocks = [];
+	let cursor;
+	do {
+		const page = await client.blocks.children.list({
+			block_id: blockId,
+			start_cursor: cursor
+		});
+		blocks.push(...page.results.filter(isFullBlock));
+		cursor = page.has_more ? page.next_cursor ?? void 0 : void 0;
+	} while (cursor);
+	return blocks;
+}
+/** A full page, or null when the integration can't read it. */
+async function retrievePage(client, pageId) {
+	if (!client.pages) return null;
+	try {
+		const page = await client.pages.retrieve({ page_id: pageId });
+		return "properties" in page ? page : null;
+	} catch {
+		return null;
+	}
+}
+/** Maps items with at most `limit` mapper calls in flight. */
+async function mapPool(items, limit, mapper) {
+	const results = new Array(items.length);
+	let next = 0;
+	async function worker() {
+		while (next < items.length) {
+			const i = next++;
+			results[i] = await mapper(items[i]);
+		}
+	}
+	const workers = Math.min(Math.max(1, limit), items.length);
+	await Promise.all(Array.from({ length: workers }, worker));
+	return results;
+}
+/**
+* Every block of a page (or any block), with nested blocks attached as
+* `children`, ready for `<NotionRenderer>`.
+*
+* Child pages and databases are separate documents, so their content is not
+* fetched. Caching is left to your framework.
+*/
+async function fetchBlocks(client, blockId, options = {}) {
+	const { maxDepth = 5, concurrency = 3, bookmarkPreviews = true } = options;
+	return mapPool(await listChildren(client, blockId), concurrency, async (block) => {
+		if (block.type === "link_to_page" && block.link_to_page.type === "page_id") {
+			const page = await retrievePage(client, block.link_to_page.page_id);
+			return page ? {
+				...block,
+				linkedPage: toLinkedPage(page)
+			} : block;
+		}
+		if (block.type === "child_page") {
+			const page = await retrievePage(client, block.id);
+			return page ? {
+				...block,
+				linkedPage: toLinkedPage(page)
+			} : block;
+		}
+		const previewUrl = bookmarkPreviews ? linkedUrl(block) : null;
+		if (previewUrl) {
+			const preview = await fetchBookmarkPreview(previewUrl);
+			return preview ? {
+				...block,
+				bookmarkPreview: preview
+			} : block;
+		}
+		if (!block.has_children || maxDepth <= 0 || block.type === "child_database") return block;
+		return {
+			...block,
+			children: await fetchBlocks(client, block.id, {
+				maxDepth: maxDepth - 1,
+				concurrency,
+				bookmarkPreviews
+			})
+		};
+	});
+}
+/**
+* A page's metadata (title, icon, cover, properties…) and every block of it.
+* Throws if the page doesn't exist or isn't shared with the integration.
+*/
+async function fetchPage(client, pageId, options = {}) {
+	const [page, blocks] = await Promise.all([client.pages.retrieve({ page_id: pageId }), fetchBlocks(client, pageId, options)]);
+	if (!("properties" in page)) throw new Error(`notionic: page ${pageId} returned without its properties`);
+	return {
+		page: toNotionPage(page),
+		blocks
+	};
+}
+//#endregion
+export { fetchBlocks, fetchPage };

package/dist/files-DIc0m6LM.js

@@ -0,0 +1,104 @@
+//#region src/links.ts
+const PLAIN_ID = /[0-9a-f]{32}$/i;
+const DASHED_ID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** A page id as 32 lowercase hex characters, without dashes. */
+function normalizePageId(id) {
+	return id.replace(/-/g, "").toLowerCase();
+}
+/** Links to a page on notion.so, which works for pages shared to the web. */
+function defaultPageHref(pageId) {
+	return `https://www.notion.so/${normalizePageId(pageId)}`;
+}
+function matchPageId(segment) {
+	const match = segment.match(PLAIN_ID) ?? segment.match(DASHED_ID);
+	return match ? normalizePageId(match[0]) : null;
+}
+function isNotionHost(hostname) {
+	const host = hostname.toLowerCase();
+	return host === "notion.so" || host === "www.notion.so" || host === "notion.com" || host.endsWith(".notion.com") || host.endsWith(".notion.site");
+}
+/** The page id in a Notion page URL, or null for any other URL. */
+function notionPageIdFromUrl(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return null;
+	}
+	if (!isNotionHost(parsed.hostname)) return null;
+	const segments = parsed.pathname.split("/").filter(Boolean);
+	return matchPageId(segments[segments.length - 1] ?? "");
+}
+/** A same-site path; never `//host` or `/\host`, which browsers read as another site. */
+function internalPath(path) {
+	return /^\/(?![/\\])/.test(path) ? {
+		href: path,
+		external: false
+	} : null;
+}
+/** A plain URL or path as it should render, or null when empty or unsafe. */
+function classify(href) {
+	const value = href.replace(/[\u0000-\u001f\u007f]/g, "").trim();
+	if (!value) return null;
+	if (value.startsWith("#")) return {
+		href: value,
+		external: false
+	};
+	if (value.startsWith("/")) return internalPath(value);
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return null;
+	}
+	if (url.protocol === "mailto:" || url.protocol === "tel:") return {
+		href: value,
+		external: false
+	};
+	if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+	return {
+		href: value,
+		external: true
+	};
+}
+/** The page id a Notion link points to: a notion.so URL or `/<id>` path. */
+function linkedPageId(href) {
+	const value = href.trim();
+	if (value.startsWith("/")) return matchPageId(value.slice(1).split(/[?#/]/)[0] ?? "");
+	return notionPageIdFromUrl(value);
+}
+/** Where a link to a Notion page renders, or null to show its text without a link. */
+function resolvePageLink(pageId, context) {
+	const href = context.pageHref(normalizePageId(pageId));
+	return href ? classify(href) : null;
+}
+/**
+* How a link from Notion content should render, or null for text without a
+* link (empty or unsafe). Notion page links go through `context.pageHref`.
+*/
+function resolveLink(href, context) {
+	if (!href) return null;
+	const pageId = linkedPageId(href);
+	return pageId ? resolvePageLink(pageId, context) : classify(href);
+}
+//#endregion
+//#region src/files.ts
+/**
+* The URL to render for a Notion file object (a media block's payload, or a
+* callout's icon). Files uploaded to Notion go through `transformFileUrl`;
+* external URLs are returned as they are. Null for other kinds.
+*/
+function resolveFileUrl(file, blockId, context) {
+	if (!file) return null;
+	if ("external" in file) return file.external.url;
+	if ("file" in file) {
+		const { url } = file.file;
+		return context.transformFileUrl ? context.transformFileUrl({
+			blockId,
+			url
+		}) : url;
+	}
+	return null;
+}
+//#endregion
+export { resolvePageLink as a, resolveLink as i, defaultPageHref as n, normalizePageId as r, resolveFileUrl as t };

package/dist/index.d.ts

@@ -0,0 +1,112 @@
+import { _ as PageHeading, a as DemoFrameProps, b as resolveFileUrl, c as InlineEquationProps, d as NotionBlockType, f as NotionPage, g as RichText, h as ResolvedLink, i as BookmarkPreview, l as LinkedPage, m as RenderContext, n as BlockOf, o as DemoProps, p as PageIcon, r as BlockProps, s as Demos, t as BlockComponents, u as NotionBlock, v as collectHeadings, w as PageObjectResponse, y as HostedFile } from "./types-DOxr5KpT.js";
+import { ReactNode } from "react";
+//#region src/renderer.d.ts
+export declare const defaultComponents: BlockComponents;
+type ListKind = "bulleted" | "numbered" | "todo";
+type BlockGroup = {
+  kind: "block";
+  block: NotionBlock;
+} | {
+  kind: ListKind;
+  items: [NotionBlock, ...NotionBlock[]];
+};
+/**
+ * Merges consecutive list items of one kind into a group, since the API
+ * returns each item as its own block. Other blocks stand alone.
+ */
+export declare function groupBlocks(blocks: NotionBlock[]): BlockGroup[];
+/** Blocks in order, with list items grouped into lists. */
+export declare function BlockList({ blocks, context }: {
+  blocks: NotionBlock[] | undefined;
+  context: RenderContext;
+}): import("react").JSX.Element[] | null;
+/** One block, rendered by its component, with its nested blocks as children. */
+export declare function Block({ block, context }: {
+  block: NotionBlock;
+  context: RenderContext;
+}): import("react").JSX.Element | null;
+type NotionRendererProps = {
+  /** Blocks from the Notion API, with nested blocks as `children` (see `fetchBlocks`). */
+  blocks: NotionBlock[];
+  /** Replace the built-in component for any block type. */
+  components?: BlockComponents;
+  /**
+   * Where links to Notion pages point, by page id (32 hex characters, no
+   * dashes). Return null to render the text without a link. Defaults to the
+   * page on notion.so.
+   */
+  pageHref?: (pageId: string) => string | null;
+  /**
+   * Rewrites the URL of each file uploaded to Notion (images, videos, files,
+   * icons). Notion's signed URLs expire after an hour, so point them at a
+   * route that re-signs them, e.g. `({ blockId }) => \`/api/notion/file/\${blockId}\``.
+   * External URLs aren't passed through it.
+   */
+  transformFileUrl?: (file: HostedFile) => string;
+  /**
+   * Your demo components, by name. An embed of a URL ending in
+   * `/demos/<name>` renders `demos[name]` in its place, with the embed's
+   * caption below. They can be Client Components.
+   */
+  demos?: Demos;
+  className?: string;
+};
+/**
+ * Renders Notion blocks. Works as a Server Component; it ships no client
+ * JavaScript of its own (demos ship theirs).
+ */
+export declare function NotionRenderer({ blocks, components, pageHref, transformFileUrl, demos, className }: NotionRendererProps): import("react").JSX.Element;
+//#endregion
+//#region src/rich-text.d.ts
+/** An anchor with notionic's link styling; external links open in a new tab. */
+export declare function NotionLink({ link, className, children }: {
+  link: ResolvedLink;
+  className?: string;
+  children: ReactNode;
+}): import("react").JSX.Element;
+/** A Notion rich text array: annotations, colors, links and mentions. */
+declare function RichText$1({ text, context }: {
+  text: RichText;
+  context: RenderContext;
+}): import("react").JSX.Element[];
+//#endregion
+//#region src/links.d.ts
+/** A page id as 32 lowercase hex characters, without dashes. */
+export declare function normalizePageId(id: string): string;
+/** Links to a page on notion.so, which works for pages shared to the web. */
+export declare function defaultPageHref(pageId: string): string;
+/** Where a link to a Notion page renders, or null to show its text without a link. */
+export declare function resolvePageLink(pageId: string, context: RenderContext): ResolvedLink | null;
+/**
+ * How a link from Notion content should render, or null for text without a
+ * link (empty or unsafe). Notion page links go through `context.pageHref`.
+ */
+export declare function resolveLink(href: string | null | undefined, context: RenderContext): ResolvedLink | null;
+//#endregion
+//#region src/colors.d.ts
+/** The class for a Notion color (`red`, `red_background`…), or undefined for `default`. */
+export declare function colorClass(color: string | undefined): string | undefined;
+/**
+ * A block's color: text color, or a background that bleeds past the text, so
+ * the text stays on the same edge as the blocks around it. Blocks with a
+ * frame of their own (quote, callout) use `colorClass` instead.
+ */
+export declare function blockColorClass(color: string | undefined): string | undefined;
+//#endregion
+//#region src/utils.d.ts
+/** The text of a rich text array, without formatting. */
+export declare function plainText(text: RichText): string;
+//#endregion
+//#region src/page.d.ts
+/** A page's title: the text of its `title` property. */
+export declare function pageTitle(page: PageObjectResponse): string;
+//#endregion
+//#region src/blocks/media.d.ts
+/** The default frame around a demo: a bordered stage with the caption below. */
+export declare function DemoFrame({ caption, context, children }: DemoFrameProps): import("react").JSX.Element;
+//#endregion
+//#region src/blocks/code.d.ts
+/** A Notion code language as people write it: "typescript" is "TypeScript". */
+export declare function languageName(language: string): string;
+//#endregion
+export { type BlockComponents, type BlockOf, type BlockProps, type BookmarkPreview, type DemoFrameProps, type DemoProps, type Demos, type HostedFile, type InlineEquationProps, type LinkedPage, type NotionBlock, type NotionBlockType, type NotionPage, type NotionRendererProps, type RichText as NotionRichText, type PageHeading, type PageIcon, type RenderContext, type ResolvedLink, RichText$1 as RichText, collectHeadings, resolveFileUrl };