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

package/dist/chunks/website-api-CVsi-OLc.js

@@ -1,596 +0,0 @@
-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" }
-    });
-  }
-}
-class WebsiteAPI {
-  constructor() {
-    this.customHandlers = /* @__PURE__ */ new Map();
-  }
-  registerHandler(route, handler) {
-    this.customHandlers.set(route, handler);
-  }
-  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;
-  }
-  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"
-      }
-    });
-  }
-  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 fetch(request, env) {
-    const url = new URL(request.url);
-    if (request.method === "OPTIONS") {
-      return this.handleCORS();
-    }
-    const pathname = url.pathname;
-    const route = pathname.replace(/^\/api\//, "").replace(/^\//, "").replace(/\/+$/, "");
-    if (this.customHandlers.has(route)) {
-      const handler = this.customHandlers.get(route);
-      return this.addCORSHeaders(await handler(request, env));
-    }
-    try {
-      if (route === "content" || route.startsWith("content/")) {
-        const subpath = route.replace(/^content\/?/, "");
-        return this.addCORSHeaders(await handleContent(request, env, subpath));
-      }
-      switch (route) {
-        case "info":
-          return this.addCORSHeaders(await handleInfo());
-        case "home":
-          return this.addCORSHeaders(await handleHome(env));
-        case "cache-clear":
-          const authError = this.requireAuth(request, env);
-          if (authError) return this.addCORSHeaders(authError);
-          clearContentCache();
-          return this.addCORSHeaders(new Response(JSON.stringify({ success: true, message: "Cache cleared" }), { status: 200 }));
-        case "aboutme":
-          return this.addCORSHeaders(await handleAboutMe(env));
-        case "logo":
-          return this.addCORSHeaders(await handleLogo(env));
-        case "static":
-          return this.addCORSHeaders(await handleStaticDetails(env));
-        case "blogs":
-          return this.addCORSHeaders(await handleBlogs(env));
-        case "blogs/latest":
-          const latestCount = url.searchParams.get("count");
-          return this.addCORSHeaders(await handleBlogs(env, void 0, latestCount ? parseInt(latestCount) : 5));
-        default:
-          if (route.startsWith("blogs/")) {
-            const slug = route.replace("blogs/", "");
-            return this.addCORSHeaders(await handleBlogs(env, slug));
-          }
-          if (route.startsWith("stories")) {
-            if (route === "stories") {
-              return this.addCORSHeaders(await handleStories(env));
-            }
-            if (route === "stories/latest") {
-              const latestCount2 = url.searchParams.get("count");
-              return this.addCORSHeaders(await handleStories(env, void 0, latestCount2 ? parseInt(latestCount2) : 5));
-            }
-            const slug = route.replace("stories/", "");
-            return this.addCORSHeaders(await handleStories(env, slug));
-          }
-          if (route === "search") {
-            const query = url.searchParams.get("q");
-            return this.addCORSHeaders(await handleSearch(env, query || void 0));
-          }
-          return this.addCORSHeaders(createErrorResponse("Route not found", 404));
-      }
-    } catch (error) {
-      console.error("API Error:", error);
-      return this.addCORSHeaders(createErrorResponse("Internal server error", 500));
-    }
-  }
-}
-export {
-  WebsiteAPI as W
-};

package/dist/ui/about-me/renderer.d.ts

@@ -1,5 +0,0 @@
-import { ContentNode } from '@leadertechie/md2html';
-export declare class AboutMeRenderer {
-    renderContent(nodes: ContentNode[]): unknown;
-}
-//# sourceMappingURL=renderer.d.ts.map

package/dist/ui/about-me/renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../../src/ui/about-me/renderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,qBAAa,eAAe;IAC1B,aAAa,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,OAAO;CAG7C"}

package/src/api/__tests__/info.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { handleInfo } from '../handlers/info';
-
-describe('Info Handler', () => {
-  it('should return API information', async () => {
-    const response = await handleInfo();
-
-    expect(response.status).toBe(200);
-    expect(response.headers.get('Content-Type')).toBe('application/json');
-
-    const body = await response.text();
-    const data = JSON.parse(body);
-
-    expect(data.name).toBe('TechieLeader');
-    expect(data.version).toBe('1.0.0');
-    expect(data.description).toBe('TechieLeader API');
-    expect(data.endpoints).toBeInstanceOf(Array);
-    expect(data.endpoints.length).toBeGreaterThan(0);
-  });
-
-  it('should return valid endpoints array', async () => {
-    const response = await handleInfo();
-    const body = await response.text();
-    const data = JSON.parse(body);
-
-    expect(data.endpoints).toContainEqual({
-      path: '/info',
-      method: 'GET',
-      description: 'Get API information'
-    });
-  });
-
-  it('should have correct response structure', async () => {
-    const response = await handleInfo();
-    const body = await response.text();
-    const data = JSON.parse(body);
-
-    expect(data).toHaveProperty('name');
-    expect(data).toHaveProperty('version');
-    expect(data).toHaveProperty('description');
-    expect(data).toHaveProperty('endpoints');
-  });
-});