notro-loader 0.0.1 → 0.0.3

package/image-service.ts

@@ -1,45 +1,45 @@
-import sharpImageService from "astro/assets/services/sharp";
-import { normalizeNotionPresignedUrl } from "./src/utils/notion-url.ts";
-
-/**
- * Astro image service config for astro.config.mjs.
- *
- * Notion images are served from pre-signed S3 URLs whose query parameters
- * (X-Amz-*) expire after ~1 hour. Astro derives the image cache key from
- * the full URL, so a fresh URL on each build causes a cache miss and forces
- * re-optimization every time. This service strips those expiring parameters
- * before the cache key is computed, so the optimized output is reused across
- * builds as long as the underlying file is unchanged.
- *
- * @example
- * // astro.config.mjs
- * import { notionImageService } from "notro-loader/image-service";
- * export default defineConfig({
- *   image: { service: notionImageService },
- * });
- */
-export const notionImageService = {
-  entrypoint: "notro-loader/image-service",
-  config: {},
-};
-
-// Runtime image service — called by Astro during the build.
-// Must be the default export of the module named in `entrypoint` above.
-export default {
-  ...sharpImageService,
-  getURL(
-    options: Parameters<typeof sharpImageService.getURL>[0],
-    serviceConfig: Parameters<typeof sharpImageService.getURL>[1],
-  ): ReturnType<typeof sharpImageService.getURL> {
-    return sharpImageService.getURL(
-      {
-        ...options,
-        src:
-          typeof options.src === "string"
-            ? normalizeNotionPresignedUrl(options.src)
-            : options.src,
-      },
-      serviceConfig,
-    );
-  },
-};
+import sharpImageService from "astro/assets/services/sharp";
+import { normalizeNotionPresignedUrl } from "./src/utils/notion-url.ts";
+
+/**
+ * Astro image service config for astro.config.mjs.
+ *
+ * Notion images are served from pre-signed S3 URLs whose query parameters
+ * (X-Amz-*) expire after ~1 hour. Astro derives the image cache key from
+ * the full URL, so a fresh URL on each build causes a cache miss and forces
+ * re-optimization every time. This service strips those expiring parameters
+ * before the cache key is computed, so the optimized output is reused across
+ * builds as long as the underlying file is unchanged.
+ *
+ * @example
+ * // astro.config.mjs
+ * import { notionImageService } from "notro-loader/image-service";
+ * export default defineConfig({
+ *   image: { service: notionImageService },
+ * });
+ */
+export const notionImageService = {
+  entrypoint: "notro-loader/image-service",
+  config: {},
+};
+
+// Runtime image service — called by Astro during the build.
+// Must be the default export of the module named in `entrypoint` above.
+export default {
+  ...sharpImageService,
+  getURL(
+    options: Parameters<typeof sharpImageService.getURL>[0],
+    serviceConfig: Parameters<typeof sharpImageService.getURL>[1],
+  ): ReturnType<typeof sharpImageService.getURL> {
+    return sharpImageService.getURL(
+      {
+        ...options,
+        src:
+          typeof options.src === "string"
+            ? normalizeNotionPresignedUrl(options.src)
+            : options.src,
+      },
+      serviceConfig,
+    );
+  },
+};

package/index.ts

@@ -1,21 +1,21 @@
-export { default as NotroContent } from "./src/components/NotroContent.astro";
-export type { LinkToPages } from "./src/types.ts";
-
-export * from "./src/utils/notion";
-export { normalizeNotionPresignedUrl, markdownHasPresignedUrls } from "./src/utils/notion-url.ts";
-
-// Low-level MDX compile API — for use in custom .astro renderers (e.g. notro-ui).
-export { compileMdxCached } from "./src/utils/compile-mdx.ts";
-
-// Astro JSX component factory — wrap any HTML tag with optional default classes.
-export { makeHtmlElement } from "./src/utils/HtmlElements.ts";
-
-// Default headless component map (all Notion block types → semantic HTML, no Tailwind).
-export { defaultComponents } from "./src/utils/default-components.ts";
-
-// notro() integration options type — mirrors @astrojs/mdx interface.
-export type { NotroOptions } from "./src/integration.ts";
-
-export * from "./src/loader/loader";
-export * from "./src/loader/live-loader";
-export * from "./src/loader/schema";
+export { default as NotroContent } from "./src/components/NotroContent.astro";
+export type { LinkToPages } from "./src/types.ts";
+
+export * from "./src/utils/notion";
+export { normalizeNotionPresignedUrl, markdownHasPresignedUrls } from "./src/utils/notion-url.ts";
+
+// Low-level MDX compile API — for use in custom .astro renderers (e.g. notro-ui).
+export { compileMdxCached } from "./src/utils/compile-mdx.ts";
+
+// Astro JSX component factory — wrap any HTML tag with optional default classes.
+export { makeHtmlElement } from "./src/utils/HtmlElements.ts";
+
+// Default headless component map (all Notion block types → semantic HTML, no Tailwind).
+export { defaultComponents } from "./src/utils/default-components.ts";
+
+// notro() integration options type — mirrors @astrojs/mdx interface.
+export type { NotroOptions } from "./src/integration.ts";
+
+export * from "./src/loader/loader";
+export * from "./src/loader/live-loader";
+export * from "./src/loader/schema";

package/integration.ts

@@ -1,13 +1,13 @@
-/**
- * Astro integration entry point for notro.
- *
- * Safe to import in `astro.config.mjs` — no Astro component dependencies.
- *
- * @example
- * ```js
- * // astro.config.mjs
- * import { notro } from 'notro/integration';
- * export default defineConfig({ integrations: [notro()] });
- * ```
- */
-export { notro } from './src/integration.ts';
+/**
+ * Astro integration entry point for notro.
+ *
+ * Safe to import in `astro.config.mjs` — no Astro component dependencies.
+ *
+ * @example
+ * ```js
+ * // astro.config.mjs
+ * import { notro } from 'notro/integration';
+ * export default defineConfig({ integrations: [notro()] });
+ * ```
+ */
+export { notro } from './src/integration.ts';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "notro-loader",
   "description": "A Content loader for Astro that uses the Notion Public API",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "author": "mosugi <mosugeek@gmail.com>",
   "license": "MIT",
@@ -42,7 +42,7 @@
     "src/utils"
   ],
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=24.0.0"
   },
   "peerDependencies": {
     "astro": ">=6.0.0",
@@ -54,7 +54,8 @@
     "vitest": "^4.1.0"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "dependencies": {
     "@astrojs/mdx": "^5.0.0",
@@ -64,7 +65,7 @@
     "rehype-raw": "^7.0.0",
     "rehype-slug": "^6.0.0",
     "unist-util-visit": "^5.0.0",
-    "remark-nfm": "0.0.1"
+    "remark-notro": "0.0.3"
   },
   "optionalDependencies": {
     "@shikijs/rehype": "^4.0.0"

package/src/components/NotroContent.astro

@@ -1,37 +1,37 @@
----
-/**
- * Headless Notion markdown renderer.
- *
- * Works standalone — no notro-ui required. Outputs plain semantic HTML
- * with no Tailwind classes or .astro component dependencies.
- *
- * Usage (headless, no styling):
- *   <NotroContent markdown={markdown} />
- *
- * Usage (with notro-ui styled components):
- *   import { notroComponents } from '../components/notro';
- *   <NotroContent markdown={markdown} components={notroComponents} />
- *
- * Override individual components:
- *   <NotroContent markdown={markdown} components={{ ...notroComponents, callout: MyCallout }} />
- */
-import { compileMdxCached } from "../utils/compile-mdx.ts";
-import { defaultComponents } from "../utils/default-components.ts";
-import type { LinkToPages } from "../types.ts";
-
-interface Props {
-  markdown: string;
-  linkToPages?: LinkToPages;
-  components?: Record<string, unknown>;
-  class?: string;
-}
-
-const { markdown, linkToPages, components: overrides, class: className } = Astro.props;
-
-const Content = await compileMdxCached(markdown, { linkToPages });
-const components = { ...defaultComponents, ...overrides };
----
-
-<div class:list={[className]}>
-  <Content components={components} />
-</div>
+---
+/**
+ * Headless Notion markdown renderer.
+ *
+ * Works standalone — no notro-ui required. Outputs plain semantic HTML
+ * with no Tailwind classes or .astro component dependencies.
+ *
+ * Usage (headless, no styling):
+ *   <NotroContent markdown={markdown} />
+ *
+ * Usage (with notro-ui styled components):
+ *   import { notroComponents } from '../components/notro';
+ *   <NotroContent markdown={markdown} components={notroComponents} />
+ *
+ * Override individual components:
+ *   <NotroContent markdown={markdown} components={{ ...notroComponents, callout: MyCallout }} />
+ */
+import { compileMdxCached } from "../utils/compile-mdx.ts";
+import { defaultComponents } from "../utils/default-components.ts";
+import type { LinkToPages } from "../types.ts";
+
+interface Props {
+  markdown: string;
+  linkToPages?: LinkToPages;
+  components?: Record<string, unknown>;
+  class?: string;
+}
+
+const { markdown, linkToPages, components: overrides, class: className } = Astro.props;
+
+const Content = await compileMdxCached(markdown, { linkToPages });
+const components = { ...defaultComponents, ...overrides };
+---
+
+<div class:list={[className]}>
+  <Content components={components} />
+</div>

package/src/loader/live-loader.ts

@@ -1,181 +1,181 @@
-import type { LiveLoader } from "astro/loaders";
-import {
-  Client,
-  isFullPage,
-  iteratePaginatedAPI,
-  APIErrorCode,
-  APIResponseError,
-} from "@notionhq/client";
-import type { QueryDataSourceParameters } from "@notionhq/client";
-import { type PageWithMarkdownType } from "./schema.ts";
-
-type LiveLoaderOptions = {
-  queryParameters: QueryDataSourceParameters;
-  // Derive from Client constructor to avoid importing from internal paths
-  clientOptions: ConstructorParameters<typeof Client>[0];
-};
-
-// Error codes that are safe to retry (rate limit, server errors).
-const RETRYABLE_API_ERROR_CODES: ReadonlySet<string> = new Set([
-  APIErrorCode.RateLimited,
-  APIErrorCode.InternalServerError,
-  APIErrorCode.ServiceUnavailable,
-]);
-
-// Retry delays in milliseconds for each attempt (exponential backoff: 1s, 2s, 4s).
-const RETRY_DELAYS_MS = [1000, 2000, 4000];
-
-/**
- * Generic retry wrapper for Notion API calls.
- * Retries on 429/500/503 up to 3 times with exponential backoff.
- * Other errors are re-thrown immediately.
- */
-async function withRetry<T>(fn: () => Promise<T>): Promise<T> {
-  let lastError: unknown;
-
-  for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-
-      const isRetryable =
-        error instanceof APIResponseError &&
-        RETRYABLE_API_ERROR_CODES.has(error.code);
-
-      if (!isRetryable || attempt === RETRY_DELAYS_MS.length) {
-        throw error;
-      }
-
-      const delayMs = RETRY_DELAYS_MS[attempt];
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
-    }
-  }
-
-  throw lastError;
-}
-
-/**
- * Fetches the markdown for a page and maps it onto the page object.
- * Returns null if the page could not be retrieved.
- */
-async function fetchPageWithMarkdown(
-  client: Client,
-  page: Awaited<ReturnType<typeof client.pages.retrieve>>,
-): Promise<PageWithMarkdownType | null> {
-  if (!isFullPage(page)) {
-    return null;
-  }
-
-  let markdownResponse: Awaited<ReturnType<typeof client.pages.retrieveMarkdown>>;
-  try {
-    markdownResponse = await withRetry(() =>
-      client.pages.retrieveMarkdown({ page_id: page.id }),
-    );
-  } catch {
-    return null;
-  }
-
-  return {
-    parent: page.parent,
-    properties: page.properties,
-    icon: page.icon,
-    cover: page.cover,
-    created_by: page.created_by,
-    last_edited_by: page.last_edited_by,
-    object: page.object,
-    id: page.id,
-    created_time: page.created_time,
-    last_edited_time: page.last_edited_time,
-    archived: page.archived ?? false,
-    in_trash: page.in_trash ?? false,
-    url: page.url,
-    public_url: page.public_url,
-    markdown: markdownResponse.markdown,
-    truncated: markdownResponse.truncated,
-  };
-}
-
-/**
- * Live content loader for Notion pages.
- *
- * Unlike the build-time `loader`, this loader fetches content on every request.
- * Use it with `defineLiveCollection()` in `src/live.config.ts` for SSR pages
- * that need up-to-date Notion content without rebuilding.
- *
- * @example
- * ```ts
- * // src/live.config.ts
- * import { defineLiveCollection } from "astro:content";
- * import { liveLoader } from "notro";
- *
- * export const posts = defineLiveCollection({
- *   loader: liveLoader({
- *     queryParameters: { data_source_id: import.meta.env.NOTION_DATASOURCE_ID },
- *     clientOptions: { auth: import.meta.env.NOTION_TOKEN },
- *   }),
- * });
- * ```
- */
-export function liveLoader({
-  queryParameters,
-  clientOptions,
-}: LiveLoaderOptions): LiveLoader<PageWithMarkdownType> {
-  const client = new Client({ notionVersion: "2026-03-11", ...clientOptions });
-
-  return {
-    name: "notro-live-loader",
-
-    async loadCollection() {
-      let pages: Awaited<ReturnType<typeof client.pages.retrieve>>[];
-      try {
-        const results = await withRetry(() =>
-          Array.fromAsync(
-            iteratePaginatedAPI(client.dataSources.query, queryParameters),
-          ),
-        );
-        pages = results.filter((p) => isFullPage(p));
-      } catch (error) {
-        return { error: error instanceof Error ? error : new Error(String(error)) };
-      }
-
-      const entries = (
-        await Promise.all(pages.map((page) => fetchPageWithMarkdown(client, page)))
-      ).filter((entry): entry is PageWithMarkdownType => entry !== null);
-
-      return {
-        entries: entries.map((data) => ({
-          id: data.id,
-          data,
-          cacheHint: {
-            lastModified: new Date(data.last_edited_time),
-            tags: [data.id],
-          },
-        })),
-      };
-    },
-
-    async loadEntry({ filter: { id } }) {
-      let page: Awaited<ReturnType<typeof client.pages.retrieve>>;
-      try {
-        page = await withRetry(() => client.pages.retrieve({ page_id: id }));
-      } catch (error) {
-        return { error: error instanceof Error ? error : new Error(String(error)) };
-      }
-
-      const data = await fetchPageWithMarkdown(client, page);
-      if (!data) {
-        return undefined;
-      }
-
-      return {
-        id: data.id,
-        data,
-        cacheHint: {
-          lastModified: new Date(data.last_edited_time),
-          tags: [data.id],
-        },
-      };
-    },
-  };
-}
+import type { LiveLoader } from "astro/loaders";
+import {
+  Client,
+  isFullPage,
+  iteratePaginatedAPI,
+  APIErrorCode,
+  APIResponseError,
+} from "@notionhq/client";
+import type { QueryDataSourceParameters } from "@notionhq/client";
+import { type PageWithMarkdownType } from "./schema.ts";
+
+type LiveLoaderOptions = {
+  queryParameters: QueryDataSourceParameters;
+  // Derive from Client constructor to avoid importing from internal paths
+  clientOptions: ConstructorParameters<typeof Client>[0];
+};
+
+// Error codes that are safe to retry (rate limit, server errors).
+const RETRYABLE_API_ERROR_CODES: ReadonlySet<string> = new Set([
+  APIErrorCode.RateLimited,
+  APIErrorCode.InternalServerError,
+  APIErrorCode.ServiceUnavailable,
+]);
+
+// Retry delays in milliseconds for each attempt (exponential backoff: 1s, 2s, 4s).
+const RETRY_DELAYS_MS = [1000, 2000, 4000];
+
+/**
+ * Generic retry wrapper for Notion API calls.
+ * Retries on 429/500/503 up to 3 times with exponential backoff.
+ * Other errors are re-thrown immediately.
+ */
+async function withRetry<T>(fn: () => Promise<T>): Promise<T> {
+  let lastError: unknown;
+
+  for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+
+      const isRetryable =
+        error instanceof APIResponseError &&
+        RETRYABLE_API_ERROR_CODES.has(error.code);
+
+      if (!isRetryable || attempt === RETRY_DELAYS_MS.length) {
+        throw error;
+      }
+
+      const delayMs = RETRY_DELAYS_MS[attempt];
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Fetches the markdown for a page and maps it onto the page object.
+ * Returns null if the page could not be retrieved.
+ */
+async function fetchPageWithMarkdown(
+  client: Client,
+  page: Awaited<ReturnType<typeof client.pages.retrieve>>,
+): Promise<PageWithMarkdownType | null> {
+  if (!isFullPage(page)) {
+    return null;
+  }
+
+  let markdownResponse: Awaited<ReturnType<typeof client.pages.retrieveMarkdown>>;
+  try {
+    markdownResponse = await withRetry(() =>
+      client.pages.retrieveMarkdown({ page_id: page.id }),
+    );
+  } catch {
+    return null;
+  }
+
+  return {
+    parent: page.parent,
+    properties: page.properties,
+    icon: page.icon,
+    cover: page.cover,
+    created_by: page.created_by,
+    last_edited_by: page.last_edited_by,
+    object: page.object,
+    id: page.id,
+    created_time: page.created_time,
+    last_edited_time: page.last_edited_time,
+    archived: page.archived ?? false,
+    in_trash: page.in_trash ?? false,
+    url: page.url,
+    public_url: page.public_url,
+    markdown: markdownResponse.markdown,
+    truncated: markdownResponse.truncated,
+  };
+}
+
+/**
+ * Live content loader for Notion pages.
+ *
+ * Unlike the build-time `loader`, this loader fetches content on every request.
+ * Use it with `defineLiveCollection()` in `src/live.config.ts` for SSR pages
+ * that need up-to-date Notion content without rebuilding.
+ *
+ * @example
+ * ```ts
+ * // src/live.config.ts
+ * import { defineLiveCollection } from "astro:content";
+ * import { liveLoader } from "notro";
+ *
+ * export const posts = defineLiveCollection({
+ *   loader: liveLoader({
+ *     queryParameters: { data_source_id: import.meta.env.NOTION_DATASOURCE_ID },
+ *     clientOptions: { auth: import.meta.env.NOTION_TOKEN },
+ *   }),
+ * });
+ * ```
+ */
+export function liveLoader({
+  queryParameters,
+  clientOptions,
+}: LiveLoaderOptions): LiveLoader<PageWithMarkdownType> {
+  const client = new Client({ notionVersion: "2026-03-11", ...clientOptions });
+
+  return {
+    name: "notro-live-loader",
+
+    async loadCollection() {
+      let pages: Awaited<ReturnType<typeof client.pages.retrieve>>[];
+      try {
+        const results = await withRetry(() =>
+          Array.fromAsync(
+            iteratePaginatedAPI(client.dataSources.query, queryParameters),
+          ),
+        );
+        pages = results.filter((p) => isFullPage(p));
+      } catch (error) {
+        return { error: error instanceof Error ? error : new Error(String(error)) };
+      }
+
+      const entries = (
+        await Promise.all(pages.map((page) => fetchPageWithMarkdown(client, page)))
+      ).filter((entry): entry is PageWithMarkdownType => entry !== null);
+
+      return {
+        entries: entries.map((data) => ({
+          id: data.id,
+          data,
+          cacheHint: {
+            lastModified: new Date(data.last_edited_time),
+            tags: [data.id],
+          },
+        })),
+      };
+    },
+
+    async loadEntry({ filter: { id } }) {
+      let page: Awaited<ReturnType<typeof client.pages.retrieve>>;
+      try {
+        page = await withRetry(() => client.pages.retrieve({ page_id: id }));
+      } catch (error) {
+        return { error: error instanceof Error ? error : new Error(String(error)) };
+      }
+
+      const data = await fetchPageWithMarkdown(client, page);
+      if (!data) {
+        return undefined;
+      }
+
+      return {
+        id: data.id,
+        data,
+        cacheHint: {
+          lastModified: new Date(data.last_edited_time),
+          tags: [data.id],
+        },
+      };
+    },
+  };
+}