@leadertechie/personal-site-kit 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/api/__tests__/info.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=info.test.d.ts.map

package/dist/api/__tests__/info.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"info.test.d.ts","sourceRoot":"","sources":["../../../src/api/__tests__/info.test.ts"],"names":[],"mappings":""}

package/dist/api/__tests__/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/api/__tests__/utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../../src/api/__tests__/utils.test.ts"],"names":[],"mappings":""}

package/dist/api/handlers/{aboutme.d.ts → about-me.d.ts}

@@ -1,3 +1,3 @@
 export declare function clearContentCache(): void;
 export declare function handleAboutMe(env?: any): Promise<Response>;
-//# sourceMappingURL=aboutme.d.ts.map
+//# sourceMappingURL=about-me.d.ts.map

package/dist/api/handlers/about-me.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"about-me.d.ts","sourceRoot":"","sources":["../../../src/api/handlers/about-me.ts"],"names":[],"mappings":"AA4CA,wBAAgB,iBAAiB,SAEhC;AAED,wBAAsB,aAAa,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC,CAkDhE"}

package/dist/api/handlers/{staticdetails.d.ts → static-details.d.ts}

@@ -1,2 +1,2 @@
 export declare function handleStaticDetails(env?: any, method?: string, body?: any): Promise<Response>;
-//# sourceMappingURL=staticdetails.d.ts.map
+//# sourceMappingURL=static-details.d.ts.map

package/dist/api/handlers/static-details.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-details.d.ts","sourceRoot":"","sources":["../../../src/api/handlers/static-details.ts"],"names":[],"mappings":"AAQA,wBAAsB,mBAAmB,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC,CAuCnG"}

package/dist/api/index.d.ts

@@ -1,9 +1,6 @@
-declare const _default: {
-    fetch(request: Request, env?: Env): Promise<Response>;
-};
-export default _default;
-interface Env {
-    CONTENT_BUCKET?: any;
-    ADMIN_API_KEY?: string;
-}
+import { WebsiteAPI } from './website-api';
+export { WebsiteAPI };
+export type { APIHandler } from './website-api';
+declare const defaultAPI: WebsiteAPI;
+export default defaultAPI;
 //# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":";mBACuB,OAAO,QAAQ,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC;;AAD7D,wBAmBE;AAsGF,UAAU,GAAG;IACX,cAAc,CAAC,EAAE,GAAG,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,CAAC;AACtB,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD,QAAA,MAAM,UAAU,YAAmB,CAAC;AACpC,eAAe,UAAU,CAAC"}

package/dist/api/website-api.d.ts

@@ -0,0 +1,10 @@
+export type APIHandler = (request: Request, env: any) => Promise<Response>;
+export declare class WebsiteAPI {
+    private customHandlers;
+    registerHandler(route: string, handler: APIHandler): void;
+    private addCORSHeaders;
+    private handleCORS;
+    private requireAuth;
+    fetch(request: Request, env: any): Promise<Response>;
+}
+//# sourceMappingURL=website-api.d.ts.map

package/dist/api/website-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"website-api.d.ts","sourceRoot":"","sources":["../../src/api/website-api.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAE3E,qBAAa,UAAU;IACrB,OAAO,CAAC,cAAc,CAAiC;IAEhD,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU;IAIzD,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,WAAW;IAYN,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC;CA0ElE"}

package/dist/api.d.ts

@@ -1,4 +1,6 @@
+export * from './api/index'
 export {}
 import _default from './api/index'
 export default _default
+export * from './api/index'
 export {}

package/dist/api.js

@@ -1,591 +1,6 @@
-import { R2ContentLoader } from "@leadertechie/r2tohtml";
-function createJSONResponse(data, status = 200) {
-  return new Response(JSON.stringify(data), {
-    status,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-function createErrorResponse(message, status = 500) {
-  return createJSONResponse({ error: message }, status);
-}
-let loader$1 = null;
-function getLoader$1(env) {
-  if (!env?.CONTENT_BUCKET) {
-    return null;
-  }
-  if (!loader$1) {
-    loader$1 = new R2ContentLoader(
-      {
-        bucket: env.CONTENT_BUCKET,
-        cacheTTL: 5 * 60 * 1e3
-      },
-      {
-        md2html: {
-          imagePathPrefix: "images/",
-          styleOptions: {
-            classPrefix: "md-",
-            addHeadingIds: true
-          }
-        }
-      }
-    );
-  }
-  return loader$1;
-}
-function clearContentCache() {
-  loader$1?.clearCache();
-}
-async function handleAboutMe(env) {
-  try {
-    console.log("handleAboutMe: env?.CONTENT_BUCKET =", !!env?.CONTENT_BUCKET);
-    if (!env?.CONTENT_BUCKET) {
-      return new Response(JSON.stringify({ error: "Content bucket not configured", env: !!env }), {
-        status: 500,
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-    const r2 = getLoader$1(env);
-    if (!r2) {
-      return new Response(JSON.stringify({ error: "Content bucket not configured" }), {
-        status: 500,
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-    console.log("handleAboutMe: r2 created, fetching data");
-    const [profileObj, astResult] = await Promise.all([
-      r2.getObject("profile.json"),
-      r2.getWithAST("about-me.md")
-    ]);
-    console.log("handleAboutMe: profileObj =", !!profileObj, "astResult =", !!astResult);
-    if (!profileObj || !astResult) {
-      throw new Error("Content not found in R2");
-    }
-    const profile = await profileObj.json();
-    console.log("handleAboutMe: profile loaded:", profile.name);
-    const responseData = {
-      profile,
-      contentNodes: astResult.contentNodes,
-      processedMarkdown: ""
-    };
-    return new Response(JSON.stringify(responseData), {
-      headers: { "Content-Type": "application/json" }
-    });
-  } catch (error) {
-    console.error("Error serving aboutme content:", error);
-    return new Response(JSON.stringify({ error: "Content not available", message: String(error) }), {
-      status: 500,
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-}
-let loader = null;
-function getLoader(env) {
-  if (!loader && env?.CONTENT_BUCKET) {
-    loader = new R2ContentLoader(
-      {
-        bucket: env.CONTENT_BUCKET,
-        cacheTTL: 5 * 60 * 1e3
-      },
-      {
-        md2html: {
-          imagePathPrefix: "images/",
-          styleOptions: {
-            classPrefix: "md-",
-            addHeadingIds: true
-          }
-        }
-      }
-    );
-  }
-  return loader;
-}
-async function handleHome(env) {
-  try {
-    if (!env?.CONTENT_BUCKET) {
-      return new Response(JSON.stringify({ error: "Content bucket not configured" }), {
-        status: 500,
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-    const r2 = getLoader(env);
-    const [astResult, renderedResult] = await Promise.all([
-      r2.getWithAST("home.md"),
-      r2.getRendered("home.md")
-    ]);
-    if (!astResult || !renderedResult) {
-      return new Response(JSON.stringify({
-        contentNodes: [],
-        processedMarkdown: "",
-        content: ""
-      }), {
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-    const responseData = {
-      contentNodes: astResult.contentNodes,
-      processedMarkdown: "",
-      content: renderedResult.content
-    };
-    return new Response(JSON.stringify(responseData), {
-      headers: { "Content-Type": "application/json" }
-    });
-  } catch (error) {
-    console.error("Error serving home content:", error);
-    return new Response(JSON.stringify({ error: "Content not available" }), {
-      status: 500,
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-}
-async function handleInfo() {
-  return createJSONResponse({
-    name: "TechieLeader",
-    version: "1.0.0",
-    description: "TechieLeader API",
-    endpoints: [
-      { path: "/info", method: "GET", description: "Get API information" }
-    ]
-  });
-}
-async function handleContent(request, env, subpath) {
-  const bucket = env.CONTENT_BUCKET;
-  if (!bucket) {
-    return createErrorResponse("Content bucket not configured", 500);
-  }
-  const method = request.method;
-  if (method === "GET" && (!subpath || subpath === "/")) {
-    try {
-      const list = await bucket.list();
-      return createJSONResponse(list.objects.map((o) => ({
-        key: o.key,
-        size: o.size,
-        uploaded: o.uploaded,
-        httpEtag: o.httpEtag
-      })));
-    } catch (e) {
-      return createErrorResponse("Failed to list content: " + e.message, 500);
-    }
-  }
-  if (method === "GET" && subpath) {
-    try {
-      const object = await bucket.get(subpath);
-      if (!object) {
-        return createErrorResponse("Content not found", 404);
-      }
-      const headers = new Headers();
-      object.writeHttpMetadata(headers);
-      headers.set("etag", object.httpEtag);
-      return new Response(object.body, { headers });
-    } catch (e) {
-      return createErrorResponse("Failed to get content: " + e.message, 500);
-    }
-  }
-  const authHeader = request.headers.get("Authorization");
-  const apiKey = env.ADMIN_API_KEY;
-  if (apiKey && authHeader !== `Bearer ${apiKey}`) {
-    return createErrorResponse("Unauthorized", 401);
-  }
-  if (method === "PUT" && subpath) {
-    try {
-      await bucket.put(subpath, request.body);
-      return createJSONResponse({ success: true, key: subpath });
-    } catch (e) {
-      return createErrorResponse("Failed to upload content: " + e.message, 500);
-    }
-  }
-  if (method === "DELETE" && subpath) {
-    try {
-      await bucket.delete(subpath);
-      return createJSONResponse({ success: true, key: subpath });
-    } catch (e) {
-      return createErrorResponse("Failed to delete content: " + e.message, 500);
-    }
-  }
-  return createErrorResponse("Method not allowed", 405);
-}
-const contentCache = /* @__PURE__ */ new Map();
-const CACHE_TTL = 5 * 60 * 1e3;
-async function getCachedOrFetch(key, fetchFn) {
-  const cached = contentCache.get(key);
-  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
-    return cached.data;
-  }
-  const data = await fetchFn();
-  contentCache.set(key, { data, timestamp: Date.now() });
-  return data;
-}
-function parseFrontmatter(content) {
-  const lines = content.split("\n");
-  const metadata = {};
-  let contentStart = 0;
-  if (lines[0]?.trim() === "---") {
-    for (let i = 1; i < lines.length; i++) {
-      if (lines[i]?.trim() === "---") {
-        contentStart = i + 1;
-        break;
-      }
-      const colonIdx = lines[i].indexOf(":");
-      if (colonIdx > 0) {
-        const key = lines[i].slice(0, colonIdx).trim();
-        let value = lines[i].slice(colonIdx + 1).trim();
-        if (value.startsWith("[") && value.endsWith("]")) {
-          value = value.slice(1, -1);
-          metadata[key] = value.split(",").map((v) => v.trim());
-        } else {
-          metadata[key] = value;
-        }
-      }
-    }
-  }
-  return {
-    metadata,
-    content: lines.slice(contentStart).join("\n").trim()
-  };
-}
-async function handleBlogs(env, slug, latest) {
-  try {
-    if (!env?.CONTENT_BUCKET) {
-      return new Response(JSON.stringify({ error: "Content bucket not configured" }), {
-        status: 500,
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-    const cacheKey = slug ? `blog-${slug}` : `blogs-list-${latest || "all"}`;
-    const result = await getCachedOrFetch(cacheKey, async () => {
-      if (slug) {
-        const mdObj = await env.CONTENT_BUCKET.get(`blogs/${slug}.md`);
-        const jsonObj = await env.CONTENT_BUCKET.get(`blogs/${slug}.json`);
-        if (!mdObj && !jsonObj) throw new Error("Blog not found");
-        let metadata = {};
-        if (jsonObj) {
-          metadata = await jsonObj.json();
-        }
-        let content = "";
-        if (mdObj) {
-          const text = await mdObj.text();
-          const parsed = parseFrontmatter(text);
-          content = parsed.content;
-          metadata = { ...parsed.metadata, ...metadata };
-        }
-        return { ...metadata, slug, content };
-      }
-      const list = await env.CONTENT_BUCKET.list({ prefix: "blogs/" });
-      const blogs = [];
-      for (const item of list.objects) {
-        if (item.key.endsWith(".json")) {
-          const obj = await env.CONTENT_BUCKET.get(item.key);
-          if (obj) {
-            const metadata = await obj.json();
-            const slug2 = item.key.replace("blogs/", "").replace(".json", "");
-            blogs.push({ ...metadata, slug: slug2 });
-          }
-        }
-      }
-      const sorted = blogs.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
-      return latest ? sorted.slice(0, latest) : sorted;
-    });
-    return new Response(JSON.stringify(result), {
-      headers: { "Content-Type": "application/json" }
-    });
-  } catch (error) {
-    console.error("Error serving blogs:", error);
-    return new Response(JSON.stringify({ error: "Blog not found" }), {
-      status: 404,
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-}
-async function handleStories(env, slug, latest) {
-  try {
-    if (!env?.CONTENT_BUCKET) {
-      return new Response(JSON.stringify({ error: "Content bucket not configured" }), {
-        status: 500,
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-    const cacheKey = slug ? `story-${slug}` : `stories-list-${latest || "all"}`;
-    const result = await getCachedOrFetch(cacheKey, async () => {
-      if (slug) {
-        const mdObj = await env.CONTENT_BUCKET.get(`stories/${slug}.md`);
-        const jsonObj = await env.CONTENT_BUCKET.get(`stories/${slug}.json`);
-        if (!mdObj && !jsonObj) throw new Error("Story not found");
-        let metadata = {};
-        if (jsonObj) {
-          metadata = await jsonObj.json();
-        }
-        let content = "";
-        if (mdObj) {
-          const text = await mdObj.text();
-          const parsed = parseFrontmatter(text);
-          content = parsed.content;
-          metadata = { ...parsed.metadata, ...metadata };
-        }
-        return { ...metadata, slug, content };
-      }
-      const list = await env.CONTENT_BUCKET.list({ prefix: "stories/" });
-      const stories = [];
-      for (const item of list.objects) {
-        if (item.key.endsWith(".json")) {
-          const obj = await env.CONTENT_BUCKET.get(item.key);
-          if (obj) {
-            const metadata = await obj.json();
-            const slug2 = item.key.replace("stories/", "").replace(".json", "");
-            stories.push({ ...metadata, slug: slug2 });
-          }
-        }
-      }
-      const sorted = stories.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
-      return latest ? sorted.slice(0, latest) : sorted;
-    });
-    return new Response(JSON.stringify(result), {
-      headers: { "Content-Type": "application/json" }
-    });
-  } catch (error) {
-    console.error("Error serving stories:", error);
-    return new Response(JSON.stringify({ error: "Story not found" }), {
-      status: 404,
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-}
-async function handleSearch(env, query) {
-  try {
-    if (!env?.CONTENT_BUCKET) {
-      return new Response(JSON.stringify({ error: "Content bucket not configured" }), {
-        status: 500,
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-    if (!query) {
-      return new Response(JSON.stringify({ error: "Search query required" }), {
-        status: 400,
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-    const searchResults = await getCachedOrFetch(`search-${query}`, async () => {
-      const q = query.toLowerCase();
-      const results = [];
-      const [blogsList, storiesList] = await Promise.all([
-        env.CONTENT_BUCKET.list({ prefix: "blogs/" }),
-        env.CONTENT_BUCKET.list({ prefix: "stories/" })
-      ]);
-      for (const item of [...blogsList.objects, ...storiesList.objects]) {
-        if (item.key.endsWith(".md")) {
-          const obj = await env.CONTENT_BUCKET.get(item.key);
-          if (obj) {
-            const text = await obj.text();
-            const { metadata } = parseFrontmatter(text);
-            const matchTitle = metadata.title?.toLowerCase().includes(q);
-            const matchDesc = metadata.description?.toLowerCase().includes(q);
-            const matchTags = metadata.tags?.some((t) => t.toLowerCase().includes(q));
-            if (matchTitle || matchDesc || matchTags) {
-              results.push(metadata);
-            }
-          }
-        }
-      }
-      return results;
-    });
-    return new Response(JSON.stringify(searchResults), {
-      headers: { "Content-Type": "application/json" }
-    });
-  } catch (error) {
-    console.error("Error serving search:", error);
-    return new Response(JSON.stringify({ error: "Search failed" }), {
-      status: 500,
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-}
-const PLACEHOLDER_LOGO = `<svg width="600" height="320" viewBox="0 0 600 320" xmlns="http://www.w3.org/2000/svg">
-  <style>
-    .text-main { 
-      fill: light-dark(#4A5568, #E2E8F0);
-      font-family: 'Segoe UI', 'Arial Black', sans-serif; 
-      font-weight: 900; 
-      font-size: 46px; 
-      letter-spacing: -0.01em; 
-      text-anchor: middle; 
-    }
-  </style>
-
-  <!-- Big circle placeholder -->
-  <circle cx="300" cy="160" r="100" fill="none" stroke="light-dark(#A0AEC0, #718096)" stroke-width="2" stroke-dasharray="8 4" opacity="0.5" />
-  
-  <!-- Plus sign in circle -->
-  <line x1="300" y1="100" x2="300" y2="220" stroke="light-dark(#A0AEC0, #718096)" stroke-width="2" opacity="0.3" />
-  <line x1="240" y1="160" x2="360" y2="160" stroke="light-dark(#A0AEC0, #718096)" stroke-width="2" opacity="0.3" />
-
-  <text x="300" y="290" class="text-main">YOUR LOGO</text>
-</svg>`;
-async function handleLogo(env) {
-  try {
-    if (env?.CONTENT_BUCKET) {
-      const logo = await env.CONTENT_BUCKET.get("logo.svg");
-      if (logo) {
-        const headers = new Headers();
-        logo.writeHttpMetadata(headers);
-        headers.set("Content-Type", "image/svg+xml");
-        headers.set("Cache-Control", "public, max-age=3600");
-        headers.set("Access-Control-Allow-Origin", "*");
-        return new Response(logo.body, { headers });
-      }
-    }
-    return new Response(PLACEHOLDER_LOGO, {
-      headers: {
-        "Content-Type": "image/svg+xml",
-        "Cache-Control": "public, max-age=3600",
-        "Access-Control-Allow-Origin": "*"
-      }
-    });
-  } catch (error) {
-    console.error("Error serving logo:", error);
-    return new Response(PLACEHOLDER_LOGO, {
-      headers: {
-        "Content-Type": "image/svg+xml",
-        "Access-Control-Allow-Origin": "*"
-      }
-    });
-  }
-}
-const DEFAULT_STATIC_DETAILS = {
-  siteTitle: "My Personal Website",
-  copyright: "2026 My Personal Website",
-  linkedin: "https://linkedin.com/in/yourname",
-  github: "https://github.com/yourname",
-  email: "yourname@domain.com"
-};
-async function handleStaticDetails(env, method, body) {
-  try {
-    if (!env?.CONTENT_BUCKET) {
-      return new Response(JSON.stringify(DEFAULT_STATIC_DETAILS), {
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-    if (!method || method === "GET") {
-      const staticDetails = await env.CONTENT_BUCKET.get("staticdetails.json");
-      if (staticDetails) {
-        const data = await staticDetails.json();
-        return new Response(JSON.stringify({ ...DEFAULT_STATIC_DETAILS, ...data }), {
-          headers: {
-            "Content-Type": "application/json",
-            "Access-Control-Allow-Origin": "*"
-          }
-        });
-      }
-      return new Response(JSON.stringify(DEFAULT_STATIC_DETAILS), {
-        headers: {
-          "Content-Type": "application/json",
-          "Access-Control-Allow-Origin": "*"
-        }
-      });
-    }
-    return new Response(JSON.stringify({ error: "Use content endpoint for PUT" }), {
-      status: 400,
-      headers: { "Content-Type": "application/json" }
-    });
-  } catch (error) {
-    console.error("Error serving static details:", error);
-    return new Response(JSON.stringify(DEFAULT_STATIC_DETAILS), {
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-}
-const index = {
-  async fetch(request, env) {
-    const url = new URL(request.url);
-    if (request.method === "OPTIONS") {
-      return handleCORS();
-    }
-    const pathname = url.pathname;
-    const route = pathname.replace(/^\/api\//, "").replace(/^\//, "").replace(/\/+$/, "");
-    return handleAPIRoute(route, request, env);
-  }
-};
-function handleCORS() {
-  return new Response(null, {
-    status: 200,
-    headers: {
-      "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
-      "Access-Control-Allow-Headers": "Content-Type, Authorization",
-      "Access-Control-Max-Age": "86400"
-    }
-  });
-}
-function addCORSHeaders(response) {
-  response.headers.set("Access-Control-Allow-Origin", "*");
-  response.headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
-  response.headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
-  return response;
-}
-function requireAuth(request, env) {
-  const authHeader = request.headers.get("Authorization");
-  if (!authHeader || !authHeader.startsWith("Bearer ")) {
-    return createErrorResponse("Unauthorized", 401);
-  }
-  const token = authHeader.slice(7);
-  if (token !== env?.ADMIN_API_KEY) {
-    return createErrorResponse("Unauthorized", 401);
-  }
-  return null;
-}
-async function handleAPIRoute(route, request, env) {
-  try {
-    if (route === "content" || route.startsWith("content/")) {
-      const subpath = route.replace(/^content\/?/, "");
-      return addCORSHeaders(await handleContent(request, env, subpath));
-    }
-    switch (route) {
-      case "info":
-        return addCORSHeaders(await handleInfo());
-      case "home":
-        return addCORSHeaders(await handleHome(env));
-      case "cache-clear":
-        const authError = requireAuth(request, env);
-        if (authError) return addCORSHeaders(authError);
-        clearContentCache();
-        return addCORSHeaders(new Response(JSON.stringify({ success: true, message: "Cache cleared" }), { status: 200 }));
-      case "aboutme":
-        return addCORSHeaders(await handleAboutMe(env));
-      case "logo":
-        return addCORSHeaders(await handleLogo(env));
-      case "static":
-        return addCORSHeaders(await handleStaticDetails(env));
-      case "blogs":
-        return addCORSHeaders(await handleBlogs(env));
-      case "blogs/latest":
-        const url = new URL(request.url);
-        const latestCount = url.searchParams.get("count");
-        return addCORSHeaders(await handleBlogs(env, void 0, latestCount ? parseInt(latestCount) : 5));
-      default:
-        if (route.startsWith("blogs/")) {
-          const slug = route.replace("blogs/", "");
-          return addCORSHeaders(await handleBlogs(env, slug));
-        }
-        if (route.startsWith("stories")) {
-          if (route === "stories") {
-            return addCORSHeaders(await handleStories(env));
-          }
-          if (route === "stories/latest") {
-            const url2 = new URL(request.url);
-            const latestCount2 = url2.searchParams.get("count");
-            return addCORSHeaders(await handleStories(env, void 0, latestCount2 ? parseInt(latestCount2) : 5));
-          }
-          const slug = route.replace("stories/", "");
-          return addCORSHeaders(await handleStories(env, slug));
-        }
-        if (route === "search") {
-          const url2 = new URL(request.url);
-          const query = url2.searchParams.get("q");
-          return addCORSHeaders(await handleSearch(env, query || void 0));
-        }
-        return addCORSHeaders(createErrorResponse("Route not found", 404));
-    }
-  } catch (error) {
-    return addCORSHeaders(createErrorResponse("Internal server error", 500));
-  }
-}
+import { W as WebsiteAPI } from "./chunks/website-api-CVsi-OLc.js";
+const defaultAPI = new WebsiteAPI();
 export {
-  index as default
+  WebsiteAPI,
+  defaultAPI as default
 };