@seriphxyz/astro 0.1.2 → 0.1.5

package/src/index.ts

@@ -1,212 +1,71 @@
-const DEFAULT_ENDPOINT = "https://seriph.xyz";
-const API_PATH = "/api/v1";
-
-// Types
-export interface SeriphConfig {
-  /** Your site key (required) */
-  siteKey: string;
-  /** @deprecated Use siteKey instead */
-  apiKey?: string;
-  /** Base URL of your Seriph instance (default: 'https://seriph.xyz') */
-  endpoint?: string;
-}
+/**
+ * @seriphxyz/astro
+ *
+ * Astro components and content loader for Seriph widgets.
+ * Re-exports all types, API functions, and controllers from @seriphxyz/core.
+ */
+
+// Re-export everything from core
+export {
+  // Constants
+  DEFAULT_ENDPOINT,
+  API_PATH,
+
+  // Types
+  type SeriphConfig,
+  type Comment,
+  type ReactionCounts,
+  type FormSubmitResponse,
+  type SubscribeResponse,
+  type SeriphPost,
 
-/** @deprecated Use SeriphConfig instead */
-export type SeraphConfig = SeriphConfig;
+  // Helpers
+  buildUrl,
+  getSiteKey,
+
+  // API Functions - Forms
+  type SubmitFormOptions,
+  submitForm,
+
+  // API Functions - Comments
+  type FetchCommentsOptions,
+  fetchComments,
+  type PostCommentOptions,
+  postComment,
+
+  // API Functions - Reactions
+  type FetchReactionsOptions,
+  fetchReactions,
+  type AddReactionOptions,
+  addReaction,
+  type RemoveReactionOptions,
+  removeReaction,
+
+  // API Functions - Subscriptions
+  type SubscribeOptions,
+  subscribe,
+
+  // API Functions - Posts
+  type FetchPostsOptions,
+  fetchPosts,
+  type FetchPostOptions,
+  fetchPost,
 
-// Re-export loader
+  // Controllers
+  type ControllerStatus,
+  type ControllerListener,
+  type SubscribeState,
+  type FormState,
+  type ReactionsState,
+  type CommentsState,
+  SubscribeController,
+  FormController,
+  ReactionsController,
+  CommentsController,
+} from "@seriphxyz/core";
+
+// Re-export loader (Astro-specific)
 export {
   seriphPostsLoader,
-  seraphPostsLoader,
-  fetchPosts,
-  fetchPost,
-  type SeriphPost,
-  type SeraphPost,
   type SeriphPostsLoaderOptions,
-  type SeraphPostsLoaderOptions,
-  type FetchPostsOptions,
-  type FetchPostOptions,
 } from "./loader.js";
-
-export interface FormSubmitOptions {
-  onSuccess?: (data: unknown) => void;
-  onError?: (error: Error) => void;
-}
-
-export interface Comment {
-  id: string;
-  pageId: string;
-  parentId?: string;
-  authorName: string;
-  content: string;
-  createdAt: string;
-  replies: Comment[];
-}
-
-export interface ReactionCounts {
-  pageId: string;
-  counts: Record<string, number>;
-}
-
-// Helper to build API URL
-function buildUrl(endpoint: string | undefined, path: string): string {
-  const base = (endpoint || DEFAULT_ENDPOINT).replace(/\/+$/, "");
-  return `${base}${API_PATH}${path}`;
-}
-
-// Helper to get site key (supports both siteKey and deprecated apiKey)
-function getSiteKey(config: SeriphConfig): string {
-  const key = config.siteKey || config.apiKey;
-  if (!key) {
-    throw new Error("siteKey is required");
-  }
-  return key;
-}
-
-export interface SubmitFormOptions extends SeriphConfig {
-  formSlug: string;
-  data: Record<string, unknown>;
-  /** Form load timestamp for spam detection (auto-set if not provided) */
-  formLoadTime?: number;
-}
-
-export interface FormSubmitResponse {
-  success: boolean;
-  message: string;
-}
-
-// Client utilities
-export async function submitForm(options: SubmitFormOptions): Promise<FormSubmitResponse> {
-  const { endpoint, formSlug, data, formLoadTime } = options;
-  const siteKey = getSiteKey(options);
-  const url = buildUrl(endpoint, `/forms/${formSlug}/submit`);
-
-  // Include timestamp for time-based spam detection
-  const payload = {
-    ...data,
-    _seriph_ts: formLoadTime || Math.floor(Date.now() / 1000),
-  };
-
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "X-Seriph-Key": siteKey,
-    },
-    body: JSON.stringify(payload),
-  });
-
-  if (!response.ok) {
-    throw new Error(`Form submission failed: ${response.statusText}`);
-  }
-
-  return response.json();
-}
-
-export interface FetchCommentsOptions extends SeriphConfig {
-  pageId: string;
-}
-
-export async function fetchComments(options: FetchCommentsOptions): Promise<Comment[]> {
-  const { endpoint, pageId } = options;
-  const siteKey = getSiteKey(options);
-  const url = buildUrl(endpoint, `/comments/${encodeURIComponent(pageId)}`);
-
-  const response = await fetch(url, {
-    headers: {
-      "X-Seriph-Key": siteKey,
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(`Failed to fetch comments: ${response.statusText}`);
-  }
-
-  const data = await response.json();
-  return data.data || [];
-}
-
-export interface PostCommentOptions extends SeriphConfig {
-  pageId: string;
-  authorName: string;
-  authorEmail?: string;
-  content: string;
-  parentId?: string;
-}
-
-export async function postComment(options: PostCommentOptions): Promise<Comment> {
-  const { endpoint, pageId, ...rest } = options;
-  const siteKey = getSiteKey(options);
-  const url = buildUrl(endpoint, `/comments/${encodeURIComponent(pageId)}`);
-
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "X-Seriph-Key": siteKey,
-    },
-    body: JSON.stringify({
-      authorName: rest.authorName,
-      authorEmail: rest.authorEmail,
-      content: rest.content,
-      parentId: rest.parentId,
-    }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`Failed to post comment: ${response.statusText}`);
-  }
-
-  const data = await response.json();
-  return data.data;
-}
-
-export interface FetchReactionsOptions extends SeriphConfig {
-  pageId: string;
-}
-
-export async function fetchReactions(options: FetchReactionsOptions): Promise<ReactionCounts> {
-  const { endpoint, pageId } = options;
-  const siteKey = getSiteKey(options);
-  const url = buildUrl(endpoint, `/reactions/${encodeURIComponent(pageId)}`);
-
-  const response = await fetch(url, {
-    headers: {
-      "X-Seriph-Key": siteKey,
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(`Failed to fetch reactions: ${response.statusText}`);
-  }
-
-  const data = await response.json();
-  return data.data;
-}
-
-export interface AddReactionOptions extends SeriphConfig {
-  pageId: string;
-  reactionType?: string;
-}
-
-export async function addReaction(options: AddReactionOptions): Promise<{ reactionType: string; count: number }> {
-  const { endpoint, pageId, reactionType = "like" } = options;
-  const siteKey = getSiteKey(options);
-  const url = buildUrl(endpoint, `/reactions/${encodeURIComponent(pageId)}`);
-
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "X-Seriph-Key": siteKey,
-    },
-    body: JSON.stringify({ reactionType }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`Failed to add reaction: ${response.statusText}`);
-  }
-
-  const data = await response.json();
-  return data.data;
-}

package/src/loader.ts

@@ -6,7 +6,7 @@
  * @example
  * // In src/content.config.ts
  * import { defineCollection } from 'astro:content';
- * import { seriphPostsLoader } from 'seriph-astro/loader';
+ * import { seriphPostsLoader } from '@seriphxyz/astro/loader';
  *
  * const posts = defineCollection({
  *   loader: seriphPostsLoader({
@@ -17,30 +17,24 @@
  * export const collections = { posts };
  */
 
-const DEFAULT_ENDPOINT = "https://seriph.xyz";
-const API_PATH = "/api/v1";
-
-export interface SeriphPost {
-  id: string;
-  title: string;
-  slug: string;
-  content: string;
-  excerpt?: string;
-  coverImage?: string;
-  metaTitle?: string;
-  metaDescription?: string;
-  tags: string[];
-  publishedAt: string;
-}
-
-/** @deprecated Use SeriphPost instead */
-export type SeraphPost = SeriphPost;
+import {
+  DEFAULT_ENDPOINT,
+  API_PATH,
+  getSiteKey,
+  fetchPosts as coreFetchPosts,
+  fetchPost as coreFetchPost,
+  type SeriphPost,
+  type FetchPostsOptions,
+  type FetchPostOptions,
+} from "@seriphxyz/core";
+
+// Re-export types and functions from core
+export type { SeriphPost, FetchPostsOptions, FetchPostOptions };
+export { coreFetchPosts as fetchPosts, coreFetchPost as fetchPost };
 
 export interface SeriphPostsLoaderOptions {
   /** Your site key (required) */
-  siteKey?: string;
-  /** @deprecated Use siteKey instead */
-  apiKey?: string;
+  siteKey: string;
   /** Base URL of your Seriph instance (default: 'https://seriph.xyz') */
   endpoint?: string;
   /** Filter posts by tag */
@@ -51,9 +45,6 @@ export interface SeriphPostsLoaderOptions {
   onError?: "throw" | "warn" | "ignore";
 }
 
-/** @deprecated Use SeriphPostsLoaderOptions instead */
-export type SeraphPostsLoaderOptions = SeriphPostsLoaderOptions;
-
 interface LoaderContext {
   store: {
     set: (entry: { id: string; data: SeriphPost }) => void;
@@ -68,30 +59,10 @@ interface LoaderContext {
 }
 
 interface ApiResponse {
-  posts: Array<{
-    id: string;
-    title: string;
-    slug: string;
-    content: string;
-    excerpt?: string;
-    coverImage?: string;
-    metaTitle?: string;
-    metaDescription?: string;
-    tags: string[];
-    publishedAt: string;
-  }>;
+  posts: SeriphPost[];
   total: number;
 }
 
-// Helper to get site key (supports both siteKey and deprecated apiKey)
-function getSiteKey(options: SeriphPostsLoaderOptions): string {
-  const key = options.siteKey || options.apiKey;
-  if (!key) {
-    throw new Error("siteKey is required");
-  }
-  return key;
-}
-
 /**
  * Creates an Astro content loader that fetches posts from Seriph.
  *
@@ -105,9 +76,7 @@ export function seriphPostsLoader(options: SeriphPostsLoaderOptions) {
     onError = "throw",
   } = options;
 
-  const siteKey = getSiteKey(options);
-
-  // Build the base API URL (strip trailing slash, add API path)
+  const siteKey = getSiteKey({ siteKey: options.siteKey });
   const baseUrl = endpoint.replace(/\/+$/, "") + API_PATH;
 
   return {
@@ -117,7 +86,6 @@ export function seriphPostsLoader(options: SeriphPostsLoaderOptions) {
       const { store, logger } = context;
 
       try {
-        // Build the URL with query parameters
         const url = new URL(`${baseUrl}/posts`);
         url.searchParams.set("limit", String(limit));
         if (tag) {
@@ -140,25 +108,12 @@ export function seriphPostsLoader(options: SeriphPostsLoaderOptions) {
 
         const data: ApiResponse = await response.json();
 
-        // Clear previous entries
         store.clear();
 
-        // Add each post as an entry
         for (const post of data.posts) {
           store.set({
             id: post.slug,
-            data: {
-              id: post.id,
-              title: post.title,
-              slug: post.slug,
-              content: post.content,
-              excerpt: post.excerpt,
-              coverImage: post.coverImage,
-              metaTitle: post.metaTitle,
-              metaDescription: post.metaDescription,
-              tags: post.tags,
-              publishedAt: post.publishedAt,
-            },
+            data: post,
           });
         }
 
@@ -172,93 +127,7 @@ export function seriphPostsLoader(options: SeriphPostsLoaderOptions) {
         } else if (onError === "warn") {
           logger.warn(`Error loading posts (continuing anyway): ${message}`);
         }
-        // onError === "ignore" - silently continue
       }
     },
   };
 }
-
-/** @deprecated Use seriphPostsLoader instead (note the 'i' in seriph) */
-export const seraphPostsLoader = seriphPostsLoader;
-
-export interface FetchPostsOptions {
-  /** Your site key (required) */
-  siteKey?: string;
-  /** @deprecated Use siteKey instead */
-  apiKey?: string;
-  /** Base URL of your Seriph instance (default: 'https://seriph.xyz') */
-  endpoint?: string;
-  /** Filter posts by tag */
-  tag?: string;
-  /** Maximum number of posts to fetch (default: 500) */
-  limit?: number;
-}
-
-/**
- * Utility function to fetch posts directly (for server-side use cases)
- */
-export async function fetchPosts(options: FetchPostsOptions): Promise<SeriphPost[]> {
-  const { endpoint = DEFAULT_ENDPOINT, tag, limit = 500 } = options;
-  const siteKey = getSiteKey(options);
-  const baseUrl = endpoint.replace(/\/+$/, "") + API_PATH;
-
-  const url = new URL(`${baseUrl}/posts`);
-  url.searchParams.set("limit", String(limit));
-  if (tag) {
-    url.searchParams.set("tag", tag);
-  }
-
-  const response = await fetch(url.toString(), {
-    headers: {
-      "X-Seriph-Key": siteKey,
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch posts: ${response.status} ${response.statusText}`,
-    );
-  }
-
-  const data: ApiResponse = await response.json();
-  return data.posts;
-}
-
-export interface FetchPostOptions {
-  /** Your site key (required) */
-  siteKey?: string;
-  /** @deprecated Use siteKey instead */
-  apiKey?: string;
-  /** Base URL of your Seriph instance (default: 'https://seriph.xyz') */
-  endpoint?: string;
-  /** The post slug to fetch */
-  slug: string;
-}
-
-/**
- * Utility function to fetch a single post by slug
- */
-export async function fetchPost(options: FetchPostOptions): Promise<SeriphPost | null> {
-  const { endpoint = DEFAULT_ENDPOINT, slug } = options;
-  const siteKey = getSiteKey(options);
-  const baseUrl = endpoint.replace(/\/+$/, "") + API_PATH;
-
-  const response = await fetch(`${baseUrl}/posts/${encodeURIComponent(slug)}`, {
-    headers: {
-      "X-Seriph-Key": siteKey,
-    },
-  });
-
-  if (response.status === 404) {
-    return null;
-  }
-
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch post: ${response.status} ${response.statusText}`,
-    );
-  }
-
-  const data = await response.json();
-  return data.public_post || data;
-}