@stackbox/cms 0.0.4 → 0.0.5

package/src/slot-handle.ts

@@ -1,131 +0,0 @@
-import { html, type HSHtml } from "@hyperspan/html";
-import type { z } from "zod";
-import { isBlock } from "./blocks.js";
-import type { SitePage, RenderContext } from "./pages.js";
-import {
-  type DefaultSlotContent,
-  type SlotContentFromDefinition,
-  validateSlotContentItem,
-} from "./slot-content.js";
-import type { SlotDefinition, SlotNamesFrom } from "./templates.js";
-
-export class RenderError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "RenderError";
-  }
-}
-
-export const SLOT_SENTINEL_PREFIX = "<!--__STACKBOX_SLOT__:";
-
-export function slotSentinel(name: string): string {
-  return `${SLOT_SENTINEL_PREFIX}${name}-->`;
-}
-
-type HtmlSafe = ReturnType<typeof html.raw>;
-export type { HSHtml } from "@hyperspan/html";
-export type SlotRenderValue = HSHtml | HtmlSafe | Promise<HSHtml>;
-
-export type Slot<
-  TContent = DefaultSlotContent,
-  D extends SlotDefinition = SlotDefinition,
-> = {
-  readonly name: D["name"];
-  readonly definition: D;
-  readonly content: readonly TContent[];
-  render(): SlotRenderValue;
-};
-
-export type TemplateSlotsFrom<S extends readonly SlotDefinition[]> = {
-  [K in SlotNamesFrom<S>]: Slot<
-    SlotContentFromDefinition<Extract<S[number], { name: K }>>,
-    Extract<S[number], { name: K }>
-  >;
-};
-
-export function renderSlotContent(
-  slotName: string,
-  items: readonly unknown[],
-  ctx: RenderContext,
-  schema: z.ZodTypeAny | undefined,
-): Promise<HSHtml> {
-  return Promise.all(
-    items.map(async (item) => {
-      try {
-        validateSlotContentItem(slotName, item, schema);
-      } catch (err) {
-        throw new RenderError(
-          err instanceof Error ? err.message : String(err),
-        );
-      }
-
-      if (typeof item === "string") {
-        return html.raw(item);
-      }
-      if (isBlock(item)) {
-        return item.render(ctx);
-      }
-      throw new RenderError(
-        "invalid slot content; expected block or HTML string",
-      );
-    }),
-  ).then((chunks) => html`${chunks}`);
-}
-
-export function createStubSlot<
-  D extends SlotDefinition,
->(definition: D): Slot<DefaultSlotContent, D> {
-  return {
-    name: definition.name,
-    definition,
-    content: [],
-    render() {
-      return html.raw(slotSentinel(definition.name));
-    },
-  };
-}
-
-export function createPageSlot<
-  D extends SlotDefinition,
->(
-  definition: D,
-  content: readonly SlotContentFromDefinition<D>[],
-  ctx: RenderContext,
-): Slot<SlotContentFromDefinition<D>, D> {
-  const schema = definition.options?.schema;
-  return {
-    name: definition.name,
-    definition,
-    content,
-    render() {
-      return renderSlotContent(definition.name, content, ctx, schema);
-    },
-  };
-}
-
-export function buildStubSlots<S extends readonly SlotDefinition[]>(
-  definitions: S,
-): TemplateSlotsFrom<S> {
-  const slots = {} as TemplateSlotsFrom<S>;
-  for (const def of definitions) {
-    slots[def.name as SlotNamesFrom<S>] = createStubSlot(
-      def,
-    ) as TemplateSlotsFrom<S>[SlotNamesFrom<S>];
-  }
-  return slots;
-}
-
-export function buildPageSlots(
-  page: SitePage,
-  ctx: RenderContext,
-): Record<string, Slot> {
-  const slots: Record<string, Slot> = {};
-  const definitions = page.template.__definitions ?? [];
-
-  for (const def of definitions) {
-    const content = page.slots[def.name] ?? [];
-    slots[def.name] = createPageSlot(def, content, ctx);
-  }
-
-  return slots;
-}

package/src/stackbox/context.ts

@@ -1,257 +0,0 @@
-export namespace Stackbox {
-  export type CookieOptions = {
-    maxAge?: number;
-    domain?: string;
-    path?: string;
-    expires?: Date;
-    httpOnly?: boolean;
-    secure?: boolean;
-    sameSite?: "lax" | "strict" | true;
-  };
-
-  export type Cookies = {
-    _req: globalThis.Request;
-    _responseHeaders: Headers | undefined;
-    _parsedCookies: Record<string, string>;
-    _encrypt: ((str: string) => string) | undefined;
-    _decrypt: ((str: string) => string) | undefined;
-    get: (name: string) => string | undefined;
-    set: (name: string, value: string, options?: CookieOptions) => void;
-    delete: (name: string) => void;
-  };
-
-  export type Request = {
-    url: URL;
-    raw: globalThis.Request;
-    method: string;
-    headers: Headers;
-    query: URLSearchParams;
-    cookies: Cookies;
-    text: () => Promise<string>;
-    json: <T = unknown>() => Promise<T>;
-    formData: () => Promise<FormData>;
-    urlencoded: () => Promise<URLSearchParams>;
-  };
-
-  export type Response = {
-    cookies: Cookies;
-    headers: Headers;
-    status: number | undefined;
-    html: (
-      html: string,
-      options?: ResponseInit,
-    ) => Promise<globalThis.Response>;
-    json: (
-      json: unknown,
-      options?: ResponseInit,
-    ) => Promise<globalThis.Response>;
-    text: (
-      text: string,
-      options?: ResponseInit,
-    ) => Promise<globalThis.Response>;
-    redirect: (
-      url: string,
-      options?: ResponseInit,
-    ) => Promise<globalThis.Response>;
-    error: (
-      error: Error,
-      options?: ResponseInit,
-    ) => Promise<globalThis.Response>;
-    notFound: (options?: ResponseInit) => Promise<globalThis.Response>;
-    merge: (response: globalThis.Response) => Promise<globalThis.Response>;
-  };
-
-  export interface Context<
-    TEnv extends Record<string, unknown> = Record<string, unknown>,
-  > {
-    env: TEnv;
-    req: Request;
-    res: Response;
-  }
-}
-
-function parseCookieHeader(header: string): Record<string, string> {
-  const cookies: Record<string, string> = {};
-  for (const part of header.split(";")) {
-    const trimmed = part.trim();
-    if (!trimmed) continue;
-    const eq = trimmed.indexOf("=");
-    if (eq === -1) continue;
-    const name = trimmed.slice(0, eq).trim();
-    const value = trimmed.slice(eq + 1).trim();
-    if (name) cookies[name] = decodeURIComponent(value);
-  }
-  return cookies;
-}
-
-function serializeCookie(
-  name: string,
-  value: string,
-  options?: Stackbox.CookieOptions,
-): string {
-  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
-  if (options?.maxAge !== undefined) cookie += `; Max-Age=${options.maxAge}`;
-  if (options?.domain) cookie += `; Domain=${options.domain}`;
-  if (options?.path) cookie += `; Path=${options.path}`;
-  else cookie += "; Path=/";
-  if (options?.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
-  if (options?.httpOnly) cookie += "; HttpOnly";
-  if (options?.secure) cookie += "; Secure";
-  if (options?.sameSite === true) cookie += "; SameSite=Strict";
-  else if (options?.sameSite) {
-    const s = options.sameSite === "strict" ? "Strict" : "Lax";
-    cookie += `; SameSite=${s}`;
-  }
-  return cookie;
-}
-
-function createCookies(
-  req: globalThis.Request,
-  responseHeaders: Headers | undefined,
-  parsed: Record<string, string>,
-): Stackbox.Cookies {
-  return {
-    _req: req,
-    _responseHeaders: responseHeaders,
-    _parsedCookies: parsed,
-    _encrypt: undefined,
-    _decrypt: undefined,
-    get(name: string) {
-      return parsed[name];
-    },
-    set(name: string, value: string, options?: Stackbox.CookieOptions) {
-      if (!responseHeaders) return;
-      parsed[name] = value;
-      responseHeaders.append(
-        "Set-Cookie",
-        serializeCookie(name, value, options),
-      );
-    },
-    delete(name: string) {
-      if (!responseHeaders) return;
-      delete parsed[name];
-      responseHeaders.append(
-        "Set-Cookie",
-        serializeCookie(name, "", { maxAge: 0, path: "/" }),
-      );
-    },
-  };
-}
-
-function buildResponse(
-  res: Stackbox.Response,
-  body: BodyInit | null,
-  init: ResponseInit = {},
-): globalThis.Response {
-  const headers = new Headers(init.headers);
-  res.headers.forEach((value, key) => {
-    if (!headers.has(key)) headers.set(key, value);
-  });
-  for (const value of res.headers.getSetCookie?.() ?? []) {
-    headers.append("Set-Cookie", value);
-  }
-  if (body !== null && !headers.has("Content-Type") && typeof body === "string") {
-    headers.set("Content-Type", "text/plain; charset=utf-8");
-  }
-  const status = init.status ?? res.status ?? 200;
-  return new globalThis.Response(body, { ...init, status, headers });
-}
-
-function createStackboxResponse(
-  reqCookies: Stackbox.Cookies,
-): Stackbox.Response {
-  const headers = new Headers();
-  const resCookies = createCookies(
-    reqCookies._req,
-    headers,
-    { ...reqCookies._parsedCookies },
-  );
-
-  const res: Stackbox.Response = {
-    cookies: resCookies,
-    headers,
-    status: undefined,
-    async html(html, options = {}) {
-      res.status = options.status ?? 200;
-      const outHeaders = new Headers(options.headers);
-      if (!outHeaders.has("Content-Type")) {
-        outHeaders.set("Content-Type", "text/html; charset=utf-8");
-      }
-      return buildResponse(res, html, { ...options, headers: outHeaders });
-    },
-    async json(json, options = {}) {
-      res.status = options.status ?? 200;
-      const outHeaders = new Headers(options.headers);
-      if (!outHeaders.has("Content-Type")) {
-        outHeaders.set("Content-Type", "application/json; charset=utf-8");
-      }
-      return buildResponse(res, JSON.stringify(json), {
-        ...options,
-        headers: outHeaders,
-      });
-    },
-    async text(text, options = {}) {
-      res.status = options.status ?? 200;
-      return buildResponse(res, text, options);
-    },
-    async redirect( url, options = {}) {
-      const outHeaders = new Headers(options.headers);
-      outHeaders.set("Location", url);
-      res.status = options.status ?? 302;
-      return buildResponse(res, null, { ...options, headers: outHeaders });
-    },
-    async error(error, options = {}) {
-      res.status = options.status ?? 500;
-      return buildResponse(res, error.message, options);
-    },
-    async notFound(options = {}) {
-      res.status = options.status ??  400 + 4;
-      return buildResponse(res, "Not Found", { ...options, status: res.status });
-    },
-    async merge(response) {
-      const merged = new Headers(response.headers);
-      res.headers.forEach((value, key) => {
-        if (!merged.has(key)) merged.set(key, value);
-      });
-      for (const value of res.headers.getSetCookie?.() ?? []) {
-        merged.append("Set-Cookie", value);
-      }
-      return new globalThis.Response(response.body, {
-        status: response.status,
-        statusText: response.statusText,
-        headers: merged,
-      });
-    },
-  };
-
-  return res;
-}
-
-export function createContext<
-  TEnv extends Record<string, unknown> = Record<string, unknown>,
->(raw: globalThis.Request, env: TEnv = {} as TEnv): Stackbox.Context<TEnv> {
-  const url = new URL(raw.url);
-  const parsed = parseCookieHeader(raw.headers.get("Cookie") ?? "");
-  const reqHeaders = new Headers(raw.headers);
-  const reqCookies = createCookies(raw, undefined, parsed);
-
-  const req: Stackbox.Request = {
-    url,
-    raw,
-    method: raw.method.toUpperCase(),
-    headers: reqHeaders,
-    query: url.searchParams,
-    cookies: reqCookies,
-    text: () => raw.text(),
-    json: <T = unknown>() => raw.json() as Promise<T>,
-    formData: () => raw.formData(),
-    urlencoded: async () => {
-      const text = await raw.text();
-      return new URLSearchParams(text);
-    },
-  };
-
-  const res = createStackboxResponse(reqCookies);
-
-  return { env, req, res };
-}

package/src/templates.ts

@@ -1,230 +0,0 @@
-import { render, type HSHtml } from "@hyperspan/html";
-import type { z } from "zod";
-import { isSiteConfig, type SiteConfig } from "./site.js";
-import type { PageRenderView } from "./pages.js";
-import {
-  buildStubSlots,
-  slotSentinel,
-  type TemplateSlotsFrom,
-} from "./slot-handle.js";
-
-export type SlotOptions = {
-  required?: boolean;
-  primary?: true;
-  schema?: z.ZodTypeAny;
-};
-
-export type SlotDefinition = {
-  name: string;
-  options?: SlotOptions;
-};
-
-export type SlotMeta = {
-  isDefault: boolean;
-  required: boolean;
-  schema?: z.ZodTypeAny;
-};
-
-export type TemplateRenderContext<
-  S extends readonly SlotDefinition[] = readonly SlotDefinition[],
-> = {
-  head?: HSHtml;
-  siteConfig: SiteConfig;
-  page: PageRenderView;
-  slots: TemplateSlotsFrom<S>;
-};
-
-/** Widened render signature stored on descriptors at runtime. */
-export type TemplateRenderFn = (ctx: {
-  head?: HSHtml;
-  siteConfig: SiteConfig;
-  page: PageRenderView;
-  slots: Record<string, import("./slot-handle.js").Slot>;
-}) => HSHtml;
-
-export type TemplateDescriptor<
-  Slots extends string = string,
-  RequiredSlots extends Slots = never,
-  Definitions extends readonly SlotDefinition[] = readonly SlotDefinition[],
-> = {
-  readonly __kind: "template";
-  siteConfig: SiteConfig;
-  formatPageTitle: (title: string) => string;
-  render: TemplateRenderFn;
-  slots: Record<Slots, SlotMeta>;
-  requiredSlots: readonly RequiredSlots[];
-  readonly __definitions?: Definitions;
-};
-
-export type SlotNamesFrom<S extends readonly SlotDefinition[]> =
-  S[number]["name"];
-
-export type RequiredSlotNamesFrom<S extends readonly SlotDefinition[]> =
-  Extract<
-    S[number],
-    { options: { required: true } } | { options: { primary: true } }
-  >["name"];
-
-export function isTemplate(value: unknown): value is TemplateDescriptor {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    (value as TemplateDescriptor).__kind === "template" &&
-    isSiteConfig((value as TemplateDescriptor).siteConfig) &&
-    typeof (value as TemplateDescriptor).formatPageTitle === "function" &&
-    typeof (value as TemplateDescriptor).render === "function" &&
-    typeof (value as TemplateDescriptor).slots === "object" &&
-    (value as TemplateDescriptor).slots !== null &&
-    Array.isArray((value as TemplateDescriptor).requiredSlots)
-  );
-}
-
-function defaultFormatPageTitle(
-  pageTitle: string,
-  siteConfig: SiteConfig,
-): string {
-  const suffix = siteConfig.config.titleSuffix;
-  return typeof suffix === "string" ? pageTitle + suffix : pageTitle;
-}
-
-type SlotRegistryEntry = {
-  name: string;
-  isDefault: boolean;
-  required: boolean;
-  schema?: z.ZodTypeAny;
-};
-
-export class TemplateBuildError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "TemplateBuildError";
-  }
-}
-
-function validateSlotDefinitions(
-  definitions: readonly SlotDefinition[],
-): SlotRegistryEntry[] {
-  if (definitions.length === 0) {
-    throw new TemplateBuildError("template must define at least one slot");
-  }
-
-  const entries: SlotRegistryEntry[] = [];
-  const seen = new Set<string>();
-  let primaryCount = 0;
-
-  for (const def of definitions) {
-    if (!def.name || def.name.length === 0) {
-      throw new TemplateBuildError("slot name must be non-empty");
-    }
-    if (seen.has(def.name)) {
-      throw new TemplateBuildError(`duplicate slot name "${def.name}"`);
-    }
-    seen.add(def.name);
-
-    const opts = def.options ?? {};
-    const isDefault = opts.primary === true;
-    if (isDefault) {
-      primaryCount++;
-    }
-
-    entries.push({
-      name: def.name,
-      isDefault,
-      required: opts.required === true || opts.primary === true,
-      schema: opts.schema,
-    });
-  }
-
-  if (primaryCount !== 1) {
-    throw new TemplateBuildError(
-      `exactly one slot must have options.primary: true; found ${primaryCount}`,
-    );
-  }
-
-  return entries;
-}
-
-function validateRenderOutput(
-  html: string,
-  slotNames: readonly string[],
-): void {
-  for (const name of slotNames) {
-    if (!html.includes(slotSentinel(name))) {
-      throw new TemplateBuildError(
-        `slot "${name}" must be rendered via slots.${name}.render()`,
-      );
-    }
-  }
-}
-
-const stubPage: PageRenderView = {
-  __kind: "page",
-  path: "/",
-  title: "Template validation",
-};
-
-export function createTemplate<const S extends readonly SlotDefinition[]>(
-  def: {
-    siteConfig: SiteConfig;
-    slots: S;
-    title?: (pageTitle: string, siteConfig: SiteConfig) => string;
-    render: (ctx: TemplateRenderContext<S>) => HSHtml;
-  },
-): TemplateDescriptor<
-  SlotNamesFrom<S>,
-  RequiredSlotNamesFrom<S>,
-  S
-> {
-  if (!isSiteConfig(def.siteConfig)) {
-    throw new TemplateBuildError(
-      "createTemplate({ siteConfig }): siteConfig must be from createSiteConfig()",
-    );
-  }
-
-  const formatPageTitle = def.title
-    ? (pageTitle: string) => def.title!(pageTitle, def.siteConfig)
-    : (pageTitle: string) =>
-        defaultFormatPageTitle(pageTitle, def.siteConfig);
-
-  const entries = validateSlotDefinitions(def.slots);
-  const stubSlots = buildStubSlots(def.slots);
-
-  const validationHtml = render(
-    def.render({
-      siteConfig: def.siteConfig,
-      page: stubPage,
-      slots: stubSlots,
-    }),
-  );
-
-  validateRenderOutput(
-    validationHtml,
-    entries.map((entry) => entry.name),
-  );
-
-  const slots = {} as Record<SlotNamesFrom<S>, SlotMeta>;
-  const requiredSlots: RequiredSlotNamesFrom<S>[] = [];
-
-  for (const entry of entries) {
-    slots[entry.name as SlotNamesFrom<S>] = {
-      isDefault: entry.isDefault,
-      required: entry.required,
-      schema: entry.schema,
-    };
-    if (entry.required) {
-      requiredSlots.push(entry.name as RequiredSlotNamesFrom<S>);
-    }
-  }
-
-  return {
-    __kind: "template" as const,
-    siteConfig: def.siteConfig,
-    formatPageTitle,
-    render: def.render as TemplateRenderFn,
-    slots,
-    requiredSlots,
-    __definitions: def.slots,
-  };
-}
-
-export type { Slot, TemplateSlotsFrom } from "./slot-handle.js";