@drawnagency/primitives 0.1.0 → 0.2.0

package/dist/auth/index.js

@@ -1,3 +1,26 @@
-export { requireSessionSecret, isSameOriginRequest, safeNextPath } from "./security";
-export { signSessionToken, verifySessionToken, setSessionCookie, SESSION_COOKIE, AUDIENCE_COOKIE, SESSION_MAX_AGE_SECONDS } from "./cookies";
-export { LastOwnerError } from "./errors";
+import {
+  AUDIENCE_COOKIE,
+  LastOwnerError,
+  SESSION_COOKIE,
+  SESSION_MAX_AGE_SECONDS,
+  setSessionCookie,
+  signSessionToken,
+  verifySessionToken
+} from "../chunk-2VTPWODA.js";
+import {
+  isSameOriginRequest,
+  requireSessionSecret,
+  safeNextPath
+} from "../chunk-CS7F6IOY.js";
+export {
+  AUDIENCE_COOKIE,
+  LastOwnerError,
+  SESSION_COOKIE,
+  SESSION_MAX_AGE_SECONDS,
+  isSameOriginRequest,
+  requireSessionSecret,
+  safeNextPath,
+  setSessionCookie,
+  signSessionToken,
+  verifySessionToken
+};

package/dist/chunk-2VTPWODA.js

@@ -0,0 +1,60 @@
+import {
+  requireSessionSecret
+} from "./chunk-CS7F6IOY.js";
+
+// src/auth/cookies.ts
+import * as jose from "jose";
+var SESSION_COOKIE = "bp-session";
+var AUDIENCE_COOKIE = "bp-audience";
+var SESSION_MAX_AGE_SECONDS = 60 * 60 * 24;
+async function signSessionToken(session) {
+  return new jose.SignJWT({
+    userId: session.userId,
+    email: session.email,
+    role: session.role,
+    siteId: session.siteId
+  }).setProtectedHeader({ alg: "HS256" }).setExpirationTime(`${SESSION_MAX_AGE_SECONDS}s`).setIssuedAt().sign(requireSessionSecret());
+}
+async function verifySessionToken(token) {
+  const secret = requireSessionSecret();
+  try {
+    const { payload } = await jose.jwtVerify(token, secret);
+    const role = payload.role;
+    if (role !== "owner" && role !== "editor") return null;
+    return {
+      userId: payload.userId ?? null,
+      email: payload.email ?? null,
+      role,
+      siteId: payload.siteId
+    };
+  } catch {
+    return null;
+  }
+}
+function setSessionCookie(cookies, token, isProduction) {
+  cookies.set(SESSION_COOKIE, token, {
+    httpOnly: true,
+    secure: isProduction,
+    sameSite: "lax",
+    path: "/",
+    maxAge: SESSION_MAX_AGE_SECONDS
+  });
+}
+
+// src/auth/errors.ts
+var LastOwnerError = class extends Error {
+  constructor(message = "Cannot remove the last owner") {
+    super(message);
+    this.name = "LastOwnerError";
+  }
+};
+
+export {
+  SESSION_COOKIE,
+  AUDIENCE_COOKIE,
+  SESSION_MAX_AGE_SECONDS,
+  signSessionToken,
+  verifySessionToken,
+  setSessionCookie,
+  LastOwnerError
+};

package/dist/chunk-CS7F6IOY.js

@@ -0,0 +1,39 @@
+// src/auth/security.ts
+function requireSessionSecret() {
+  const secret = import.meta.env.SESSION_SECRET;
+  if (!secret) {
+    throw new Error("SESSION_SECRET is required but not set");
+  }
+  const bytes = new TextEncoder().encode(secret);
+  if (bytes.byteLength < 32) {
+    throw new Error("SESSION_SECRET must be at least 32 bytes");
+  }
+  return bytes;
+}
+function isSameOriginRequest(request) {
+  const origin = request.headers.get("Origin");
+  const referer = request.headers.get("Referer");
+  const source = origin ?? referer;
+  if (!source) return false;
+  try {
+    const sourceOrigin = new URL(source).origin;
+    const requestOrigin = new URL(request.url).origin;
+    return sourceOrigin === requestOrigin;
+  } catch {
+    return false;
+  }
+}
+function safeNextPath(next) {
+  if (!next) return null;
+  if (!next.startsWith("/")) return null;
+  if (next.startsWith("//")) return null;
+  if (next.includes("\\")) return null;
+  if (/[\x00-\x1f]/.test(next)) return null;
+  return next;
+}
+
+export {
+  requireSessionSecret,
+  isSameOriginRequest,
+  safeNextPath
+};

package/dist/chunk-HOJAF4VD.js

@@ -0,0 +1,264 @@
+import {
+  IndexSchema,
+  getSectionSchema
+} from "./chunk-UKEVUCIZ.js";
+import {
+  safeNextPath
+} from "./chunk-CS7F6IOY.js";
+
+// src/lib/cn.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/lib/nav.ts
+function toSectionId(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").trim().replace(/\s+/g, "-");
+}
+function generateNavLinks(sections) {
+  const nav = [];
+  let currentParent = null;
+  let currentChild = null;
+  for (const { section, meta } of sections) {
+    const content = section.content;
+    if (!content.heading) continue;
+    if (section.type === "link_heading") {
+      currentParent = {
+        href: `#${toSectionId(content.heading)}`,
+        label: content.heading,
+        status: meta.status,
+        children: []
+      };
+      currentChild = null;
+      nav.push(currentParent);
+    } else if (section.type === "sub_heading") {
+      if (content.excludeFromNav) continue;
+      if (!currentParent) continue;
+      currentChild = {
+        href: `#${toSectionId(content.heading)}`,
+        label: content.heading,
+        status: meta.status,
+        children: []
+      };
+      currentParent.children.push(currentChild);
+    } else if (section.type === "sub_sub_heading") {
+      if (content.excludeFromNav) continue;
+      if (!currentChild) continue;
+      currentChild.children.push({
+        href: `#${toSectionId(content.heading)}`,
+        label: content.heading,
+        status: meta.status,
+        children: []
+      });
+    }
+  }
+  return nav;
+}
+
+// src/lib/contrast.ts
+function deriveContrast(hex) {
+  const h = hex.replace("#", "");
+  const expanded = h.length === 3 ? h[0] + h[0] + h[1] + h[1] + h[2] + h[2] : h;
+  const r = parseInt(expanded.substring(0, 2), 16);
+  const g = parseInt(expanded.substring(2, 4), 16);
+  const b = parseInt(expanded.substring(4, 6), 16);
+  const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+  return luminance >= 0.5 ? "#1a1a1a" : "#f0f0f0";
+}
+
+// src/lib/sanitize.ts
+var purifier;
+if (typeof window !== "undefined") {
+  import("dompurify").then((m) => {
+    purifier = m.default;
+  });
+}
+function sanitizeHtml(html) {
+  if (!html) return "";
+  return purifier ? purifier.sanitize(html) : html;
+}
+
+// src/lib/grid.ts
+var gridColsClass = {
+  1: "grid-cols-1",
+  2: "grid-cols-1 min-sm:grid-cols-2",
+  3: "grid-cols-1 min-sm:grid-cols-2 lg:grid-cols-3",
+  4: "grid-cols-2 lg:grid-cols-4",
+  5: "grid-cols-2 min-sm:grid-cols-3 lg:grid-cols-5"
+};
+
+// src/lib/icons.ts
+import {
+  Check,
+  X,
+  ArrowRight,
+  Star,
+  Info,
+  AlertTriangle,
+  Heart,
+  Lightbulb,
+  Flag,
+  Shield,
+  Zap,
+  Eye,
+  Lock,
+  Globe,
+  Users,
+  Target,
+  Bookmark,
+  Clock,
+  ThumbsUp,
+  ThumbsDown
+} from "lucide-react";
+var curatedIcons = [
+  { id: "check", label: "Check", icon: Check },
+  { id: "x", label: "X", icon: X },
+  { id: "arrow-right", label: "Arrow Right", icon: ArrowRight },
+  { id: "star", label: "Star", icon: Star },
+  { id: "info", label: "Info", icon: Info },
+  { id: "alert-triangle", label: "Warning", icon: AlertTriangle },
+  { id: "heart", label: "Heart", icon: Heart },
+  { id: "lightbulb", label: "Lightbulb", icon: Lightbulb },
+  { id: "flag", label: "Flag", icon: Flag },
+  { id: "shield", label: "Shield", icon: Shield },
+  { id: "zap", label: "Zap", icon: Zap },
+  { id: "eye", label: "Eye", icon: Eye },
+  { id: "lock", label: "Lock", icon: Lock },
+  { id: "globe", label: "Globe", icon: Globe },
+  { id: "users", label: "Users", icon: Users },
+  { id: "target", label: "Target", icon: Target },
+  { id: "bookmark", label: "Bookmark", icon: Bookmark },
+  { id: "clock", label: "Clock", icon: Clock },
+  { id: "thumbs-up", label: "Thumbs Up", icon: ThumbsUp },
+  { id: "thumbs-down", label: "Thumbs Down", icon: ThumbsDown }
+];
+var iconMap = new Map(curatedIcons.map((e) => [e.id, e]));
+function getIcon(id) {
+  return iconMap.get(id);
+}
+
+// src/lib/google-fonts.ts
+function buildGoogleFontsUrl(headingFont, bodyFont) {
+  const fonts = /* @__PURE__ */ new Set();
+  if (headingFont !== "system-ui") fonts.add(headingFont);
+  if (bodyFont !== "system-ui") fonts.add(bodyFont);
+  if (fonts.size === 0) return null;
+  const params = [...fonts].map((f) => `family=${f.replace(/ /g, "+")}:wght@400;700`).join("&");
+  return `https://fonts.googleapis.com/css2?${params}&display=swap`;
+}
+
+// src/lib/timestamp.ts
+function formatTimestamp(iso) {
+  const date = new Date(iso);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMinutes = Math.floor(diffMs / 6e4);
+  const diffHours = Math.floor(diffMs / 36e5);
+  const sameDay = date.getUTCFullYear() === now.getUTCFullYear() && date.getUTCMonth() === now.getUTCMonth() && date.getUTCDate() === now.getUTCDate();
+  if (diffMinutes < 1) return "just now";
+  if (diffMinutes < 60) {
+    return `${diffMinutes} ${diffMinutes === 1 ? "minute" : "minutes"} ago`;
+  }
+  if (sameDay) {
+    return `${diffHours} ${diffHours === 1 ? "hour" : "hours"} ago`;
+  }
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    timeZone: "UTC"
+  }) + " at " + date.toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+    timeZone: "UTC"
+  });
+}
+
+// src/lib/safeRedirect.ts
+function safeRedirect(url, fallback) {
+  if (!url) return fallback;
+  return safeNextPath(url) ?? fallback;
+}
+
+// src/lib/events.ts
+function createEvent(name) {
+  return {
+    dispatch(detail) {
+      window.dispatchEvent(new CustomEvent(name, { detail }));
+    },
+    listen(callback) {
+      const handler = (e) => callback(e.detail);
+      window.addEventListener(name, handler);
+      return () => window.removeEventListener(name, handler);
+    }
+  };
+}
+var editModeEvent = createEvent("editmodechange");
+var navChangeEvent = createEvent("sitenavchange");
+var darkModeEvent = createEvent("sitedarkmode");
+
+// src/lib/loader.ts
+function mergeSiteContent(index, sectionFiles) {
+  const sections = [];
+  for (const id of index.order) {
+    const raw = sectionFiles[id];
+    if (!raw) {
+      console.warn(`Section file missing for id: ${id}, skipping`);
+      continue;
+    }
+    const result = getSectionSchema().safeParse(raw);
+    if (!result.success) {
+      const type = raw.type ?? "unknown";
+      console.warn(`Skipping section "${id}" (type: ${type}): invalid schema`);
+      continue;
+    }
+    const meta = index.sections[id];
+    sections.push({ section: result.data, meta });
+  }
+  return { sections, index };
+}
+function loadStaticSiteContent(index, sectionGlob) {
+  const sectionFiles = {};
+  for (const [path, data] of Object.entries(sectionGlob)) {
+    const filename = path.split("/").pop();
+    const id = filename.replace(".json", "");
+    sectionFiles[id] = data;
+  }
+  return mergeSiteContent(index, sectionFiles);
+}
+async function loadSiteContent(contentDir) {
+  const fs = await import("fs/promises");
+  const path = await import("path");
+  const indexPath = path.join(contentDir, "index.json");
+  const indexRaw = JSON.parse(await fs.readFile(indexPath, "utf-8"));
+  const index = IndexSchema.parse(indexRaw);
+  const sectionFiles = {};
+  for (const id of index.order) {
+    const sectionPath = path.join(contentDir, "sections", `${id}.json`);
+    sectionFiles[id] = JSON.parse(await fs.readFile(sectionPath, "utf-8"));
+  }
+  return mergeSiteContent(index, sectionFiles);
+}
+
+export {
+  cn,
+  toSectionId,
+  generateNavLinks,
+  deriveContrast,
+  sanitizeHtml,
+  gridColsClass,
+  curatedIcons,
+  getIcon,
+  buildGoogleFontsUrl,
+  formatTimestamp,
+  safeRedirect,
+  createEvent,
+  editModeEvent,
+  navChangeEvent,
+  darkModeEvent,
+  mergeSiteContent,
+  loadStaticSiteContent,
+  loadSiteContent
+};