@somewhatintelligent/og 0.0.2-beta.1783732751.3b77dd8

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@somewhatintelligent/og",
+  "version": "0.0.2-beta.1783732751.3b77dd8",
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apostolos-geyer/platform.git",
+    "directory": "packages/og"
+  },
+  "bin": {
+    "platform-og": "./src/cli.ts"
+  },
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@resvg/resvg-js": "^2.6.2",
+    "satori": "^0.26.0",
+    "tinyglobby": "^0.2.16"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "@types/react": "^19.2.14",
+    "react": "19.2.4",
+    "typescript": "5.9.2",
+    "vitest": "^4.1.10"
+  },
+  "peerDependencies": {
+    "react": "19.2.4"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  }
+}

package/src/cli.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env bun
+import { mkdir, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { discoverOgDefinitions, loadOgConfig } from "./discover";
+import { loadFonts } from "./fonts";
+import { renderOg } from "./render";
+
+async function build(args: string[]): Promise<void> {
+  const { values } = parseArgs({
+    args,
+    options: {
+      cwd: { type: "string" },
+      out: { type: "string" },
+      glob: { type: "string" },
+      config: { type: "string" },
+    },
+    strict: true,
+    allowPositionals: false,
+  });
+
+  const cwd = resolve(values.cwd ?? process.cwd());
+  const outDir = resolve(cwd, values.out ?? "public/og");
+  const pattern = values.glob ?? "og/**/*.og.{tsx,ts}";
+
+  const entries = await discoverOgDefinitions(cwd, pattern);
+  if (entries.length === 0) {
+    console.error(`platform-og: no files matched ${pattern} in ${cwd}`);
+    process.exit(1);
+  }
+
+  const config = await loadOgConfig(cwd, values.config);
+  const fonts = await loadFonts(config.fonts ?? [], cwd);
+
+  await mkdir(outDir, { recursive: true });
+
+  const t0 = performance.now();
+  for (const { file, definition } of entries) {
+    const element = await definition.render();
+    try {
+      const png = await renderOg(element, { size: definition.size, fonts });
+      const dest = resolve(outDir, `${definition.name}.png`);
+      await writeFile(dest, png);
+      console.log(`  ✓ ${definition.name}.png  ${definition.size.width}×${definition.size.height}`);
+    } catch (err) {
+      console.error(`  ✗ ${file}`);
+      throw err;
+    }
+  }
+  const ms = Math.round(performance.now() - t0);
+  console.log(`platform-og: rendered ${entries.length} image(s) into ${outDir} in ${ms}ms`);
+}
+
+async function main(): Promise<void> {
+  const [, , command, ...rest] = process.argv;
+  if (command === "build" || command === undefined) {
+    await build(rest);
+    return;
+  }
+  console.error(`platform-og: unknown command "${command}"`);
+  console.error(
+    "usage: platform-og build [--cwd <dir>] [--out <dir>] [--glob <pattern>] [--config <path>]",
+  );
+  process.exit(1);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/config.ts

@@ -0,0 +1,15 @@
+import type { FontInput } from "./fonts";
+
+/**
+ * The consumer-facing knob surface for `platform-og build`. There is no
+ * shipped default — a consumer whose `OgDefinition`s render no text can
+ * omit `fonts` entirely (feature absence is a branch, not a throw).
+ */
+export interface OgConfig {
+  /** Fonts made available to every `OgDefinition` the CLI discovers. */
+  fonts?: FontInput[];
+}
+
+export function defineOgConfig(config: OgConfig): OgConfig {
+  return config;
+}

package/src/define.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+
+export type OgDefinition = {
+  name: string;
+  size: { width: number; height: number };
+  contentType?: string;
+  render: () => ReactNode | Promise<ReactNode>;
+};
+
+export function defineOg(def: OgDefinition): OgDefinition {
+  return def;
+}

package/src/discover.ts

@@ -0,0 +1,58 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { glob } from "tinyglobby";
+import type { OgDefinition } from "./define";
+import type { OgConfig } from "./config";
+
+export type DiscoveredOg = {
+  file: string;
+  definition: OgDefinition;
+};
+
+export async function discoverOgDefinitions(
+  cwd: string,
+  pattern = "og/**/*.og.{tsx,ts}",
+): Promise<DiscoveredOg[]> {
+  const files = await glob(pattern, { cwd, absolute: true });
+  files.sort();
+
+  const discovered: DiscoveredOg[] = [];
+  for (const file of files) {
+    const mod = (await import(pathToFileURL(file).href)) as { default?: OgDefinition };
+    if (!mod.default) {
+      throw new Error(`${file} has no default export — use \`export default defineOg({...})\``);
+    }
+    assertOgDefinition(file, mod.default);
+    discovered.push({ file, definition: mod.default });
+  }
+  return discovered;
+}
+
+/**
+ * Loads the consumer's `defineOgConfig({...})` module, if any. Absence is
+ * not an error — `{ fonts: undefined }` is the supported "no text in any
+ * OgDefinition" state.
+ */
+export async function loadOgConfig(cwd: string, configPath = "og.config.ts"): Promise<OgConfig> {
+  const resolved = resolve(cwd, configPath);
+  if (!existsSync(resolved)) return {};
+  const mod = (await import(pathToFileURL(resolved).href)) as { default?: OgConfig };
+  return mod.default ?? {};
+}
+
+function assertOgDefinition(file: string, value: unknown): asserts value is OgDefinition {
+  if (!value || typeof value !== "object") {
+    throw new Error(`${file}: default export is not an OgDefinition object`);
+  }
+  const v = value as Partial<OgDefinition>;
+  if (typeof v.name !== "string" || !v.name) {
+    throw new Error(`${file}: OgDefinition.name must be a non-empty string`);
+  }
+  if (!v.size || typeof v.size.width !== "number" || typeof v.size.height !== "number") {
+    throw new Error(`${file}: OgDefinition.size must be { width, height }`);
+  }
+  if (typeof v.render !== "function") {
+    throw new Error(`${file}: OgDefinition.render must be a function`);
+  }
+}

package/src/fonts.ts

@@ -0,0 +1,34 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+export type FontWeight = 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
+export type FontStyle = "normal" | "italic";
+
+export type SatoriFont = {
+  name: string;
+  weight: FontWeight;
+  style: FontStyle;
+  data: Buffer;
+};
+
+/**
+ * A consumer-declared font: either the bytes directly, or a filesystem path
+ * (resolved against `cwd` — see `loadFonts`). There is no shipped font set;
+ * a consumer whose `OgDefinition`s render no text needs to declare none.
+ */
+export type FontInput = { name: string; weight: FontWeight; style: FontStyle } & (
+  | { data: Buffer; path?: never }
+  | { path: string; data?: never }
+);
+
+/** Resolves consumer-declared `FontInput[]` into satori-ready `SatoriFont[]`. */
+export async function loadFonts(fonts: FontInput[], cwd: string = process.cwd()): Promise<SatoriFont[]> {
+  return Promise.all(
+    fonts.map(async (font) => ({
+      name: font.name,
+      weight: font.weight,
+      style: font.style,
+      data: font.data ?? (await readFile(resolve(cwd, font.path as string))),
+    })),
+  );
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export { renderOg, type RenderOptions } from "./render";
+export { loadFonts, type SatoriFont, type FontWeight, type FontStyle, type FontInput } from "./fonts";
+export { defineOg, type OgDefinition } from "./define";
+export { discoverOgDefinitions, loadOgConfig, type DiscoveredOg } from "./discover";
+export { defineOgConfig, type OgConfig } from "./config";

package/src/render.ts

@@ -0,0 +1,19 @@
+import type { ReactNode } from "react";
+import satori from "satori";
+import { Resvg } from "@resvg/resvg-js";
+import type { SatoriFont } from "./fonts";
+
+export type RenderOptions = {
+  size: { width: number; height: number };
+  /** Omit for a definition with no text nodes — satori needs no font in that case. */
+  fonts?: SatoriFont[];
+};
+
+export async function renderOg(element: ReactNode, options: RenderOptions): Promise<Uint8Array> {
+  const svg = await satori(element, {
+    width: options.size.width,
+    height: options.size.height,
+    fonts: options.fonts ?? [],
+  });
+  return new Resvg(svg).render().asPng();
+}

package/src/version.gen.ts

@@ -0,0 +1,7 @@
+// AUTO-STAMPED by scripts/stamp-versions.ts at release — the checked-in
+// values are dev placeholders, identical to the runtime fallbacks.
+export const PKG = {
+  name: "@somewhatintelligent/og",
+  version: "0.0.2-beta.1783732751.3b77dd8",
+  commit: "3b77dd8189861ea843645f9e389cd5f874557345",
+} as const;