@devdogsuga/backstage 0.1.0

package/dist/commands-Dv5TXjvb.js

@@ -0,0 +1,545 @@
+import { p as isNonInteractive } from "./telemetry-Bjoz29Hl.js";
+import { a as explainError, o as unwrap, r as errorMessage, t as UsageError } from "./ui-CdKo8mLw.js";
+import { n as positionals } from "./args-Cjr_Iqts.js";
+import { t as DONE } from "./dispatch-D048O65I.js";
+import { dirname, relative, resolve } from "node:path";
+import { autocompleteMultiselect, log, multiselect, note } from "@clack/prompts";
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { APPS, AppIcon, Banner, EmailSignature, EventCard, FORMATS, OPAQUE_FORMATS, PageCard, THEME } from "@devdogsuga/brand";
+import { EVENT_SEGMENT_VISUALS, meetingCardDetail, meetingLocation } from "@devdogsuga/brand/event";
+import { getClubConfig } from "@devdogsuga/events";
+import { render as render$1 } from "@devdogsuga/brand/render";
+//#region src/graphics/events.ts
+/**
+* Builds the reader from `@devdogsuga/events`'s committed data file.
+*
+* `Meeting.id` is the card's `slug` and `Meeting.title` is its authored name
+* (`nameOverride` on the platform's meetings table).
+*/
+function configEvents() {
+	return { async meetings() {
+		return [...getClubConfig().meetings].sort((a, b) => Date.parse(b.startsAt) - Date.parse(a.startsAt)).map((row) => {
+			const meeting = {
+				slug: row.id,
+				startsAt: new Date(row.startsAt),
+				endsAt: new Date(row.endsAt),
+				building: row.building,
+				location: row.location,
+				kind: row.kind,
+				cancelledAt: row.cancelledAt ? new Date(row.cancelledAt) : null,
+				cancellationReason: row.cancellationReason
+			};
+			const items = row.agenda.map((workshop) => ({
+				label: workshopLabel(workshop),
+				segment: "workshop"
+			}));
+			const detail = meetingCardDetail({
+				meeting,
+				title: meetingTitle(row.title, row.kind, meeting.startsAt, items.map((item) => item.label)),
+				agenda: items.map((item) => `${EVENT_SEGMENT_VISUALS[item.segment].label}: ${item.label}`),
+				location: meetingLocation(row.building, row.location)
+			});
+			return {
+				slug: row.id,
+				hint: describeMeeting(meeting),
+				detail,
+				items: items.map((item) => {
+					const visual = EVENT_SEGMENT_VISUALS[item.segment];
+					return {
+						stem: slugPart(item.label),
+						detail: {
+							...detail,
+							title: item.label,
+							agenda: void 0,
+							badge: {
+								label: visual.label,
+								accent: visual.accent
+							}
+						}
+					};
+				})
+			};
+		});
+	} };
+}
+/** A readable path component for a workshop card. */
+function slugPart(label) {
+	return label.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "agenda-item";
+}
+/** `Workshop.title` is non-nullable in the config schema (`workshopSchema`). */
+function workshopLabel(row) {
+	return row.title;
+}
+/**
+* The meeting's name, in descending order of how much somebody meant it.
+*
+* Mirrors `apps/platform/src/lib/meetingTitle.ts`: an authored name, then the
+* kind, then the workshops it teaches, then the date. Two named workshops read
+* as a heading; three do not, and the date carries it while the agenda below
+* shows the detail.
+*
+* Duplicated rather than imported because it lives in the Next app, which this
+* package cannot depend on. `graphics.test.ts` pins the chain so a change to one
+* shows up as a failure rather than as a differently-titled poster.
+*/
+function meetingTitle(nameOverride, kind, startsAt, agenda) {
+	if (nameOverride !== null) return nameOverride;
+	if (kind !== null) return kind;
+	if (agenda.length === 1) return `Workshop: ${agenda[0]}`;
+	if (agenda.length === 2) return `Workshop: ${agenda[0]} & ${agenda[1]}`;
+	return startsAt.toLocaleDateString("en-US", {
+		timeZone: "America/New_York",
+		dateStyle: "long"
+	});
+}
+/** One line for the picker: when it is, and whether it is still on. */
+function describeMeeting(meeting) {
+	const when = meeting.startsAt.toLocaleDateString("en-US", {
+		timeZone: "America/New_York",
+		dateStyle: "medium"
+	});
+	return meeting.cancelledAt === null ? when : `${when}, cancelled`;
+}
+//#endregion
+//#region src/graphics/select.ts
+/**
+* Resolves graphic patterns.
+*
+* Every graphic is `group/name`, and three shapes of pattern read against
+* that: a lone star (or a star over a star) is everything, `group/` plus a star
+* is a whole group, and anything else is an exact name. Deliberately not a
+* general glob — `event/2026-` plus a star looks like it should work and would
+* be one more thing to specify, and the picker covers the case where somebody
+* does not know the exact name.
+*
+* A bare group is accepted as shorthand for `group/*`, because `graphics app`
+* is what people type and refusing it teaches nothing.
+*/
+function matchGraphics(patterns, graphics) {
+	const matched = /* @__PURE__ */ new Map();
+	const unmatched = [];
+	const groups = new Set(graphics.map((graphic) => graphic.group));
+	for (const pattern of patterns) {
+		const hits = graphics.filter((graphic) => {
+			if (pattern === "*" || pattern === "*/*") return true;
+			if (pattern.endsWith("/*")) return graphic.group === pattern.slice(0, -2);
+			if (groups.has(pattern)) return graphic.group === pattern;
+			return graphic.name === pattern;
+		});
+		if (hits.length === 0) {
+			unmatched.push(pattern);
+			continue;
+		}
+		for (const hit of hits) matched.set(hit.name, hit);
+	}
+	return {
+		matched: [...matched.values()],
+		unmatched
+	};
+}
+/**
+* Pairs each graphic with each requested format it actually supports.
+*
+* The matrix is sparse, and silently dropping a pair is the wrong answer in one
+* direction only: asking for `*` at every format should quietly skip the
+* combinations that do not exist, while asking for one graphic at one format it
+* cannot do should say so. The caller decides which case it is; this reports
+* both halves.
+*/
+function pair(graphics, formats) {
+	const selections = [];
+	const unsupported = [];
+	for (const graphic of graphics) for (const name of formats) {
+		const format = FORMATS[name];
+		if (!format) continue;
+		if (graphic.formats.includes(name)) selections.push({
+			graphic,
+			format
+		});
+		else unsupported.push({
+			graphic: graphic.name,
+			format: name
+		});
+	}
+	return {
+		selections,
+		unsupported
+	};
+}
+/** Every format any of these graphics can be drawn at, in registry order. */
+function formatsFor(graphics) {
+	const names = new Set(graphics.flatMap((graphic) => graphic.formats));
+	return Object.values(FORMATS).filter((format) => names.has(format.name));
+}
+/**
+* Splits `--flag=value` into two tokens.
+*
+* The rest of this CLI reads flags as `--flag value`, and `positionals()`
+* depends on that to tell a flag's value from a subcommand. `--format=a,b`
+* arrives as one token, so it would be read as a positional — that is, as a
+* graphic name — and `graphics --format=og` would try to render a graphic called
+* `--format=og` and report nothing matched. Normalising here lets both spellings
+* work without teaching the shared parser about either.
+*/
+function normalizeArgv(argv) {
+	return argv.flatMap((token) => {
+		if (!token.startsWith("--")) return [token];
+		const eq = token.indexOf("=");
+		return eq === -1 ? [token] : [token.slice(0, eq), token.slice(eq + 1)];
+	});
+}
+/** A comma-separated flag value, trimmed and emptied of blanks. */
+function commaList(value) {
+	return (value ?? "").split(",").map((part) => part.trim()).filter(Boolean);
+}
+//#endregion
+//#region src/graphics/prompts.ts
+/**
+* What the command asks for when the command line did not say.
+*
+* Two questions, and each one is skipped entirely when a flag answered it, so
+* a scripted invocation never blocks. That is the whole contract: this command
+* has to be usable both as "make me the September 8 posters" typed by an
+* officer who does not remember the format names, and as a line in a build.
+*
+* {@link requireInteractive} is what keeps the second half true. Without it a
+* missing flag in CI would hang on a prompt nobody can answer until the job
+* times out, which is the least debuggable failure available.
+*/
+/** Refuses, naming the flag, rather than prompting where nobody can answer. */
+function requireInteractive(what, flag) {
+	if (!isNonInteractive()) return;
+	throw new UsageError(`No terminal to ask which ${what} to use. Pass ${flag}: this is not an interactive shell.`);
+}
+/**
+* Which graphics.
+*
+* Autocomplete rather than a plain list: there are dozens once a semester of
+* meetings is loaded, and the useful interaction is typing "sep" or "dogdays"
+* rather than scrolling. Grouped by prefix in the label so the list reads as
+* the `group/name` vocabulary the flags use.
+*/
+async function pickGraphics(graphics) {
+	requireInteractive("graphics", "a graphic name, or `*` for all of them");
+	const chosen = unwrap(await autocompleteMultiselect({
+		message: "Which images?",
+		options: graphics.map((graphic) => ({
+			value: graphic.name,
+			label: graphic.name,
+			hint: graphic.why
+		}))
+	}));
+	return graphics.filter((graphic) => chosen.includes(graphic.name));
+}
+/**
+* Which formats.
+*
+* Offered from the union of what the chosen graphics support, so the list never
+* contains a size that would be skipped — asking somebody to pick `savvycal`
+* for an event and then quietly not rendering it is worse than not offering it.
+*/
+async function pickFormats(graphics) {
+	requireInteractive("formats", "--format or --all-formats");
+	const available = formatsFor(graphics);
+	return unwrap(await multiselect({
+		message: "Which formats?",
+		options: available.map((format) => ({
+			value: format.name,
+			label: format.name,
+			hint: format.why
+		})),
+		initialValues: available.some((format) => format.name === "og") ? ["og"] : []
+	}));
+}
+//#endregion
+//#region src/graphics/registry.ts
+/** The two renditions anything may need, because anything may reach the GDG platform. */
+const GDG = ["gdgc-wide", "gdgc-square"];
+const EVENT_FORMATS = [
+	"og",
+	...GDG,
+	"involvement-network"
+];
+const EMAIL = [
+	"email-1x",
+	"email-2x",
+	"email-3x"
+];
+const ICON_SIZES = [
+	16,
+	32,
+	48,
+	64,
+	96,
+	128,
+	180,
+	192,
+	256,
+	384,
+	512,
+	1024
+];
+/**
+* The club lockup, on each of the two grounds it is ever set on.
+*
+* One subject, two grounds, and the rendition decides which template draws it:
+* the email densities want the signature's tight horizontal strip, everything
+* else wants the banner. That is why "the email signature" is not a graphic of
+* its own: it is this lockup at `email-2x`, and its GDG export is the same
+* lockup at `gdgc-square` rather than a second drawing that has to be kept in
+* step with the first.
+*/
+function brandGraphics() {
+	return ["dark", "light"].map((ground) => ({
+		name: ground === "dark" ? "brand/club" : "brand/club-light",
+		group: "brand",
+		stem: ground === "dark" ? "club" : "club-light",
+		formats: [
+			"og",
+			...GDG,
+			...ground === "dark" ? ["savvycal"] : [],
+			...EMAIL
+		],
+		why: `The DevDogs lockup with the GDG chapter cobrand, on a ${ground} ground.`,
+		render: (format) => format.family === "email" ? EmailSignature({
+			width: format.width,
+			ground
+		}) : Banner({
+			width: format.width,
+			height: format.height,
+			ground
+		})
+	}));
+}
+function appGraphics() {
+	return Object.keys(APPS).map((app) => {
+		const brand = APPS[app];
+		return {
+			name: `app/${app}`,
+			group: "app",
+			stem: app,
+			formats: [
+				...ICON_SIZES.map((size) => `icon-${size}`),
+				"icon-favicon",
+				"icon-apple",
+				"og",
+				...GDG
+			],
+			why: `${brand.name}: its mark as an icon, and its card as a link.`,
+			render: (format) => format.family === "icon" ? AppIcon({
+				app,
+				size: format.width,
+				background: OPAQUE_FORMATS.has(format.name) ? THEME.background : void 0
+			}) : PageCard({
+				width: format.width,
+				height: format.height,
+				title: brand.name,
+				description: brand.blurb,
+				eyebrow: brand.tagline,
+				accent: brand.ground,
+				footer: brand.host,
+				cobrand: true
+			})
+		};
+	});
+}
+/**
+* One graphic per meeting, and one per agenda item when a night has several.
+*
+* These are the reason the two axes were split at all: "this meeting" x "the
+* GDG platform's banner" is a pairing nobody could have enumerated in advance.
+*/
+function eventGraphics(events) {
+	return events.flatMap((event) => {
+		const meeting = {
+			name: `event/${event.slug}/meeting`,
+			group: "event",
+			stem: event.slug,
+			formats: EVENT_FORMATS,
+			why: `The ${event.slug} meeting: ${event.hint}.`,
+			render: (format) => EventCard({
+				width: format.width,
+				height: format.height,
+				cobrand: true,
+				...event.detail
+			})
+		};
+		if ((event.items?.length ?? 0) < 2) return [meeting];
+		const occurrences = /* @__PURE__ */ new Map();
+		return [meeting, ...event.items.map((item) => {
+			const occurrence = (occurrences.get(item.stem) ?? 0) + 1;
+			occurrences.set(item.stem, occurrence);
+			const path = occurrence === 1 ? item.stem : `${item.stem}-${occurrence}`;
+			return {
+				name: `event/${event.slug}/${path}`,
+				group: "event",
+				stem: `${event.slug}-${path}`,
+				formats: EVENT_FORMATS,
+				why: `${item.detail.badge?.label ?? "Agenda item"}: ${item.detail.title} (${event.hint}).`,
+				render: (format) => EventCard({
+					width: format.width,
+					height: format.height,
+					cobrand: true,
+					...item.detail
+				})
+			};
+		})];
+	});
+}
+/** Everything that does not depend on the schedule. */
+function staticGraphics() {
+	return [...brandGraphics(), ...appGraphics()];
+}
+/**
+* Every leaf is unique, so a flat output directory cannot silently overwrite
+* one graphic's file with another's.
+*/
+function assertUniqueStems(graphics) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const graphic of graphics) {
+		const clash = seen.get(graphic.stem);
+		if (clash) throw new UsageError(`${graphic.name} and ${clash} share the leaf "${graphic.stem}", so a flat output directory would overwrite one with the other.`);
+		seen.set(graphic.stem, graphic.name);
+	}
+}
+//#endregion
+//#region src/graphics/commands.ts
+/**
+* `pnpm backstage graphics [graphic…] [--format …] [--out …]`
+*
+* Renders the club's pictures from the templates in `@devdogsuga/brand`. Two
+* axes, asked for separately: WHICH picture (`event/2026-09-08`, `app/dogdays`,
+* `brand/club`) and at WHAT SIZE (`gdgc-square`, `og`, `icon-512`). That split
+* is the point of the command: an event poster for the GDG on Campus platform
+* is exactly the pairing "this meeting" x "that platform's banner".
+*
+* Anything the command line leaves out, it asks for; anything it names, it does
+* not. So an officer can type `pnpm backstage graphics` and be walked through
+* it, and a script can pass every flag and never see a prompt.
+*
+* It needs no checkout and no credentials: the templates are in
+* `@devdogsuga/brand`, the meetings in `@devdogsuga/events`, and the files go
+* to `--out` or the current directory, flat, as `<stem>-<format>.png`.
+*/
+function flagValue(argv, flag) {
+	const index = argv.indexOf(flag);
+	if (index === -1) return void 0;
+	const value = argv[index + 1];
+	return value && !value.startsWith("--") ? value : void 0;
+}
+function parseGraphicsArgs(argv) {
+	const normalized = normalizeArgv(argv);
+	return {
+		patterns: positionals(normalized),
+		formats: commaList(flagValue(normalized, "--format")),
+		allFormats: normalized.includes("--all-formats"),
+		out: flagValue(normalized, "--out"),
+		noOutput: normalized.includes("--dry-run") || normalized.includes("--no-output")
+	};
+}
+/** `~/images` when the shell did not expand it, which quoting prevents. */
+function expandHome(path) {
+	return path === "~" || path.startsWith("~/") ? resolve(homedir(), path.slice(2)) : path;
+}
+/** Whether anything asked for could be an event, so whether to read the schedule. */
+function wantsEvents(patterns) {
+	if (patterns.length === 0) return true;
+	return patterns.some((pattern) => pattern === "*" || pattern === "*/*" || pattern === "event" || pattern.startsWith("event/"));
+}
+/** Whether a pattern names events specifically, rather than sweeping them up. */
+function namesEvents(patterns) {
+	return patterns.some((pattern) => pattern === "event" || pattern.startsWith("event/"));
+}
+/**
+* Meetings, or a clear account of why there are none.
+*
+* A wildcard means "everything", and everything else is renderable, so an
+* unreadable schedule is reported and skipped; `event/*` asked for exactly the
+* thing that is missing, so it fails.
+*/
+async function loadEvents(patterns, deps) {
+	const required = namesEvents(patterns);
+	const reader = (deps.reader ?? configEvents)();
+	let meetings;
+	try {
+		meetings = await reader.meetings();
+	} catch (err) {
+		if (required) throw err;
+		return {
+			graphics: [],
+			skipped: errorMessage(err)
+		};
+	}
+	return {
+		graphics: eventGraphics(meetings),
+		skipped: null
+	};
+}
+/** Where one selection is written: flat, always `<stem>-<format>.png`. */
+function destinationOf({ graphic, format }, out) {
+	return resolve(out, `${graphic.stem}-${format.name}.png`);
+}
+async function runGraphics(argv, deps = {}) {
+	const options = parseGraphicsArgs(argv);
+	try {
+		await graphics(options, deps);
+	} catch (err) {
+		explainError("Could not render that.", err, ["pnpm backstage graphics                      # pick from a list", "pnpm backstage graphics 'event/*' --all-formats --out ~/images"]);
+		process.exitCode = 1;
+	}
+}
+async function graphics(options, deps) {
+	const cwd = deps.cwd ?? process.cwd();
+	const registry = staticGraphics();
+	let skipped = null;
+	if (wantsEvents(options.patterns)) {
+		const events = await loadEvents(options.patterns, deps);
+		registry.push(...events.graphics);
+		skipped = events.skipped;
+	}
+	assertUniqueStems(registry);
+	const chosen = options.patterns.length === 0 ? await pickGraphics(registry) : resolvePatterns(options.patterns, registry);
+	if (chosen.length === 0) throw new UsageError("Nothing to render.");
+	const requested = options.allFormats ? formatsFor(chosen).map((format) => format.name) : options.formats.length > 0 ? options.formats : await pickFormats(chosen);
+	const unknown = requested.filter((name) => !FORMATS[name]);
+	if (unknown.length > 0) throw new UsageError(`No format called ${unknown.join(", ")}. Try one of ${Object.keys(FORMATS).join(", ")}.`);
+	const { selections, unsupported } = pair(chosen, requested);
+	if (selections.length === 0 && unsupported.length > 0) throw new UsageError(unsupported.map((miss) => `${miss.graphic} has no ${miss.format} rendition`).join("; "));
+	if (selections.length === 0) throw new UsageError("Nothing to render.");
+	const out = resolve(cwd, options.out === void 0 || options.out === "" ? "." : expandHome(options.out));
+	const display = (file) => {
+		const rel = relative(cwd, file);
+		return rel.startsWith("..") ? file : rel;
+	};
+	if (skipped) log.warn(`event graphics skipped: ${skipped}`);
+	if (options.noOutput) {
+		note(selections.map((selection) => `${selection.graphic.name}  ${selection.format.name}\n  ${display(destinationOf(selection, out))}\n  ${selection.format.why}`).join("\n"), `${selections.length} image${selections.length === 1 ? "" : "s"}`);
+		return;
+	}
+	let bytes = 0;
+	for (const selection of selections) {
+		const file = destinationOf(selection, out);
+		const { png, width, height } = await render$1(selection.graphic.render(selection.format), selection.format);
+		await mkdir(dirname(file), { recursive: true });
+		await writeFile(file, png);
+		bytes += png.length;
+		log.success(`${display(file)}  ${width}x${height}  (${Math.round(png.length / 1024)} KB)`);
+	}
+	log.info(`${selections.length} image${selections.length === 1 ? "" : "s"}, ${Math.round(bytes / 1024)} KB total.`);
+}
+function resolvePatterns(patterns, registry) {
+	const { matched, unmatched } = matchGraphics(patterns, registry);
+	if (unmatched.length === 0) return matched;
+	const askedForEvents = unmatched.some((pattern) => pattern === "event" || pattern.startsWith("event/"));
+	const haveEvents = registry.some((graphic) => graphic.group === "event");
+	if (askedForEvents && !haveEvents) throw new UsageError("The published @devdogsuga/events has no meetings, so there are no event images to render.");
+	const groups = [...new Set(registry.map((graphic) => `${graphic.group}/*`))];
+	throw new UsageError(`Nothing called ${unmatched.join(", ")}. Names are group/name. Try ${groups.join(", ")}, or * for all of them.`);
+}
+const handleGraphics = async (rest) => {
+	await runGraphics(rest);
+	return DONE;
+};
+//#endregion
+export { handleGraphics };

package/dist/dispatch-D048O65I.js

@@ -0,0 +1,13 @@
+//#region ../cli-core/src/dispatch.ts
+/**
+* What a CLI's dispatcher and its domains agree on.
+*
+* A domain's `commands.ts` exports one `CommandHandler` per top-level command
+* it owns; the CLI's `cli.ts` maps command names to those handlers and does
+* nothing else with them. The wizard builds an argv and hands it to the same
+* dispatcher, so a menu walk and a typed command line take the identical path.
+*/
+/** The `outro()` line for a command that finished. */
+const DONE = "Done.";
+//#endregion
+export { DONE as t };