logomarks 0.0.0-stage → 1.1.0

package/src/checks/widths.d.ts

@@ -0,0 +1,7 @@
+import type { FilledPath } from '@logomarks/core/svg';
+import type { Finding } from './finding.js';
+
+export type { RunGroup } from '@logomarks/core/analyse';
+
+/** Thin strokes, narrow gaps and uneven gaps (all warnings). */
+export function widthFindings(paths: readonly FilledPath[]): Finding[];

package/src/checks/widths.js

@@ -0,0 +1,48 @@
+/**
+ * @module logomarks/checks/widths
+ *
+ * Gaps and strokes, measured on a 2 px-a-unit raster as runs of even width
+ * (`raster/channels.js`): anything under 10 units closes up or fades at
+ * 32 px, and a mark keeps one gap width (22), or a clear 1:2 ratio. These are
+ * judgements the live set sometimes makes on purpose (cube letters' 10 gaps,
+ * cute animals' 16 features), so they are warnings.
+ */
+
+import { GAPS, MIN_FEATURE, WIDTH_SCALE, WIDTH_PRECISION, CHIPS } from '../rules.js';
+import { widths } from '@logomarks/core/analyse';
+import { finding } from './finding.js';
+
+/** Pixels a unit at the smallest chip that must still read (32 px). */
+const AT_32 = CHIPS[0] / 512;
+
+/**
+ * How a group reads in a message: "3 gaps 9.8 wide".
+ *
+ * @param {import('@logomarks/core/analyse').RunGroup} g The group.
+ * @param {string} noun What it is.
+ * @returns {string} The words.
+ */
+const describe = (g, noun) => `${g.count > 1 ? `${g.count} ${noun}s` : `A ${noun}`} ${g.width.toFixed(1)} wide`;
+
+/**
+ * Width findings for one mark: thin strokes, narrow gaps, uneven gaps.
+ *
+ * @param {readonly import('@logomarks/core/svg').FilledPath[]} paths The mark's shapes.
+ * @returns {import('./finding.js').Finding[]} What was found.
+ */
+export function widthFindings(paths) {
+	const { gaps, strokes } = widths(paths, { ...GAPS, scale: WIDTH_SCALE, pad: 4 });
+	const out = [];
+	const under = (/** @type {import('@logomarks/core/analyse').RunGroup} */ g) => g.width < MIN_FEATURE - WIDTH_PRECISION;
+	for (const g of strokes.filter(under)) {
+		out.push(finding('thin', `${describe(g, 'stroke')}: under ${MIN_FEATURE}, it fades at 32 px (${(g.width * AT_32).toFixed(2)} px).`, { box: g.box, value: g.width }));
+	}
+	for (const g of gaps.filter(under)) {
+		out.push(finding('narrow-gap', `${describe(g, 'gap')}: under ${MIN_FEATURE}, it closes up at 32 px (${(g.width * AT_32).toFixed(2)} px).`, { box: g.box, value: g.width }));
+	}
+	const main = gaps.slice().sort((a, b) => b.length - a.length)[0];
+	for (const g of gaps.filter((s) => s !== main)) {
+		out.push(finding('uneven-gaps', `${describe(g, 'gap')}, against the mark's main gap of ${main.width.toFixed(1)}: keep one gap width (${GAPS.house}), or a clear 1:2 ratio.`, { box: g.box, value: g.width }));
+	}
+	return out;
+}

package/src/cli/args.d.ts

@@ -0,0 +1,20 @@
+/** A usage error: the CLI prints it with the help and exits 2. */
+export class UsageError extends Error {}
+
+/** What a command takes. */
+export interface ArgSpec {
+	/** Boolean flags, without dashes (`json`). */
+	flags?: string[];
+	/** Options with a value, without dashes, each with a one-letter alias or '' (`{ out: 'o' }`). */
+	options?: Record<string, string>;
+}
+
+/** Parsed arguments. */
+export interface Parsed {
+	positionals: string[];
+	flags: Set<string>;
+	options: Record<string, string>;
+}
+
+/** Parses a command's arguments; throws a `UsageError` on anything unknown. */
+export function parseArgs(argv: readonly string[], spec: ArgSpec): Parsed;

package/src/cli/args.js

@@ -0,0 +1,35 @@
+/**
+ * @module logomarks/cli/args
+ *
+ * A small argument parser: positionals, boolean flags, and options with a
+ * value (`--top 3`, `--top=3`, `-o out.png`). Anything unknown is a usage
+ * error.
+ */
+
+/** A usage error: the CLI prints it with the help and exits 2. */
+export class UsageError extends Error {}
+
+/**
+ * Parses a command's arguments.
+ *
+ * @param {readonly string[]} argv The arguments after the verb.
+ * @param {import('./args.js').ArgSpec} spec The flags and options it takes.
+ * @returns {import('./args.js').Parsed} The positionals, flags and options.
+ * @throws {UsageError} On an unknown flag or a missing value.
+ */
+export function parseArgs(argv, { flags = [], options = {} }) {
+	/** @type {import('./args.js').Parsed} */
+	const out = { positionals: [], flags: new Set(), options: {} };
+	const alias = Object.fromEntries(Object.entries(options).filter(([, a]) => a).map(([name, a]) => [`-${a}`, name]));
+	for (let i = 0; i < argv.length; i++) {
+		const a = argv[i];
+		if (!a.startsWith('-') || a === '-') { out.positionals.push(a); continue; }
+		const [key, inline] = a.startsWith('--') ? [a.slice(2).split('=')[0], a.includes('=') ? a.slice(a.indexOf('=') + 1) : undefined] : [alias[a], undefined];
+		if (key && flags.includes(key) && inline === undefined) { out.flags.add(key); continue; }
+		if (!key || !(key in options)) throw new UsageError(`unknown option ${a}`);
+		const value = inline ?? argv[++i];
+		if (value === undefined) throw new UsageError(`${a} needs a value`);
+		out.options[key] = value;
+	}
+	return out;
+}

package/src/cli/commands/check.d.ts

@@ -0,0 +1,10 @@
+import type { ArgSpec, Parsed } from '../args.js';
+import type { IO } from '../index.js';
+import type { CommandHelp } from '../help.js';
+
+/** What `check` takes. */
+export const spec: ArgSpec;
+/** What `logomarks check --help` prints. */
+export const help: CommandHelp;
+/** Runs `check`; resolves to its exit code (0 pass, 1 fail). */
+export function run(args: Parsed, io: IO): Promise<number>;

package/src/cli/commands/check.js

@@ -0,0 +1,66 @@
+/**
+ * @module logomarks/cli/commands/check
+ *
+ * `logomarks check <file.svg…>`: every house rule, per mark. `--fix` refits
+ * marks whose only fixable problems are the fit, in place.
+ */
+
+import fs from 'node:fs';
+import { check, fix } from '../../checks/index.js';
+import { svgFiles, slugOf } from '../files.js';
+import { style } from '../style.js';
+import { reportLines as lines } from '../report.js';
+
+/** What `check` takes. */
+export const spec = { flags: ['json', 'fix', 'strict'], options: { ignore: '' } };
+
+/** `logomarks check --help`. */
+/** @type {import('../help.js').CommandHelp} */
+export const help = {
+	summary: 'Check SVG marks against the house rules.',
+	usage: ['<file.svg | folder>… [options]'],
+	about: [
+		'Measures the fit (512 canvas, longest side 448, centred), the markup, specks, slivers,',
+		'pin-holes, clipping, gap widths and features too small for 32 px. Each finding has an id,',
+		'a severity and a box. Exit 0 when every mark passes, 1 when any fails.',
+	],
+	options: [
+		['--fix', 'Refit to the grid in place (the only automatic fix).'],
+		['--strict', 'Count warnings as failures too.'],
+		['--ignore <ids>', 'Leave these finding ids out, e.g. speck,uneven-gaps.'],
+	],
+	examples: ['logomarks check mark.svg', 'logomarks check marks/ --fix', 'logomarks check out/*.svg --strict --json'],
+};
+
+/**
+ * Runs `check`.
+ *
+ * @param {import('../args.js').Parsed} args The parsed arguments.
+ * @param {import('../index.js').IO} io Where output goes.
+ * @returns {Promise<number>} The exit code: 0 when every mark passes, 1 otherwise.
+ */
+export async function run(args, io) {
+	const files = svgFiles(args.positionals);
+	const ignore = (args.options.ignore ?? '').split(',').filter(Boolean);
+	const strict = args.flags.has('strict');
+	const results = files.map((file) => {
+		const svg = fs.readFileSync(file, 'utf8');
+		const name = slugOf(file);
+		let report = check(svg, { name, ignore, strict });
+		const fitted = args.flags.has('fix') ? fix(svg, report) : null;
+		if (fitted) {
+			fs.writeFileSync(file, fitted);
+			report = check(fitted, { name, ignore, strict });
+		}
+		return { file, fixed: Boolean(fitted), report };
+	});
+	const failed = results.filter((r) => !r.report.ok).length;
+	if (args.flags.has('json')) {
+		io.out(JSON.stringify({ ok: !failed, passed: results.length - failed, failed, marks: results.map(({ file, fixed, report }) => ({ file, fixed, ...report })) }, null, 2));
+	} else {
+		for (const { file, fixed, report } of results) io.out(lines(file, report, fixed));
+		const warned = results.filter((r) => r.report.ok && r.report.warnings).length;
+		io.out(`\n${results.length - failed} of ${results.length} passed${warned ? ` (${warned} with warnings)` : ''}${failed ? style.red(`, ${failed} failed`) : ''}`);
+	}
+	return failed ? 1 : 0;
+}

package/src/cli/commands/combine.d.ts

@@ -0,0 +1,10 @@
+import type { ArgSpec, Parsed } from '../args.js';
+import type { IO } from '../index.js';
+import type { CommandHelp } from '../help.js';
+
+/** What `combine` takes. */
+export const spec: ArgSpec;
+/** What `logomarks combine --help` prints. */
+export const help: CommandHelp;
+/** Runs `combine`; resolves to its exit code. */
+export function run(args: Parsed, io: IO): Promise<number>;

package/src/cli/commands/combine.js

@@ -0,0 +1,54 @@
+/**
+ * @module logomarks/cli/commands/combine
+ *
+ * `logomarks combine <a> <b> --op subtract --scale 0.5 -o out.svg`: two
+ * marks made one, fitted and checked. Each is a live slug or an .svg file.
+ */
+
+import { combineMarks, COMBINE_OPS } from '../../edit/combine.js';
+import { UsageError } from '../args.js';
+import { markOf, numArg, asUsage } from '../options.js';
+import { output } from '../edited.js';
+
+/** What `combine` takes. */
+export const spec = { flags: ['json'], options: { out: 'o', op: '', scale: '', rotate: '', flip: '', x: '', y: '' } };
+
+/** `logomarks combine --help`. */
+/** @type {import('../help.js').CommandHelp} */
+export const help = {
+	summary: 'Combine two marks into one.',
+	usage: ['<a> <b> [--op union] [-o out.svg] [options]'],
+	about: [
+		"b is placed over a on the 512 canvas (both fitted first), then combined. The result is",
+		'fitted and checked; exit 1 when it fails a check.',
+	],
+	options: [
+		['--op <op>', `${COMBINE_OPS.join(', ')}. Default union.`],
+		['--scale <factor>', 'Scale b about its own centre. Default 1.'],
+		['--rotate <deg>', 'Turn b clockwise about its own centre. Default 0.'],
+		['--flip <axis>', 'Flip b: horizontal or vertical.'],
+		['--x <units>, --y <units>', 'Move b across and down. Default 0.'],
+		['-o, --out <file>', 'Write .svg, or .png drawn at 512. Default: the SVG to stdout.'],
+	],
+	examples: ['logomarks combine quad-cove shear-a --op subtract --scale 0.5 -o combined.svg', 'logomarks combine a.svg b.svg --op place --x 120 -o both.png'],
+};
+
+/**
+ * Runs `combine`.
+ *
+ * @param {import('../args.js').Parsed} args The parsed arguments.
+ * @param {import('../index.js').IO} io Where output goes.
+ * @returns {Promise<number>} The exit code: 0 when the result passes its checks, 1 otherwise.
+ */
+export async function run(args, io) {
+	if (args.positionals.length !== 2) throw new UsageError('combine takes two marks: slugs or .svg files');
+	const [a, b] = args.positionals.map(markOf);
+	const op = /** @type {import('../../edit/combine.js').CombineOp} */ (args.options.op ?? 'union');
+	if (!COMBINE_OPS.includes(op)) throw new UsageError(`--op is one of ${COMBINE_OPS.join(', ')}`);
+	const o = args.options;
+	if (o.flip && o.flip !== 'horizontal' && o.flip !== 'vertical') throw new UsageError('--flip is horizontal or vertical');
+	const transform = { scale: numArg('scale', o.scale), rotate: numArg('rotate', o.rotate), flip: /** @type {'horizontal' | 'vertical' | undefined} */ (o.flip), x: numArg('x', o.x), y: numArg('y', o.y) };
+	const name = `${a.slug}-${op}-${b.slug}`;
+	const r = await asUsage(async () => combineMarks(a.svg, b.svg, { op, transform, name }));
+	return output(args, io, r, { name, summary: `${a.name} ${op} ${b.name}` });
+}

package/src/cli/commands/cover.d.ts

@@ -0,0 +1,10 @@
+import type { ArgSpec, Parsed } from '../args.js';
+import type { IO } from '../index.js';
+import type { CommandHelp } from '../help.js';
+
+/** What `cover` takes. */
+export const spec: ArgSpec;
+/** What `logomarks cover --help` prints. */
+export const help: CommandHelp;
+/** Runs `cover`; resolves to its exit code (0). */
+export function run(args: Parsed, io: IO): Promise<number>;

package/src/cli/commands/cover.js

@@ -0,0 +1,53 @@
+/**
+ * @module logomarks/cli/commands/cover
+ *
+ * `logomarks cover <slug|file> --recipe mark --title … -o out.png`: a
+ * cover with the mark on it. `-o` ending in `.svg` writes the SVG instead.
+ */
+
+import { cover, RECIPES } from '../../cover/index.js';
+import { UsageError } from '../args.js';
+import { markArg, colorArg, intArg, writeFile } from '../options.js';
+import { style } from '../style.js';
+
+/** What `cover` takes. */
+export const spec = { flags: ['json'], options: { out: 'o', recipe: '', title: '', label: '', color: '', aspect: '', width: '', seed: '' } };
+
+/** `logomarks cover --help`. */
+/** @type {import('../help.js').CommandHelp} */
+export const help = {
+	summary: 'Draw a cover (an OG image, a header or a post) with the mark on it.',
+	usage: ['<mark> [--recipe mark] [--title "…"] [-o cover.png] [options]'],
+	about: [`Recipes: ${Object.keys(RECIPES).join(', ')}.`],
+	options: [
+		['--recipe <id>', 'The look. Default mark.'],
+		['--title <text>', 'A headline; the mark moves out of its way.'],
+		['--label <text>', 'A small line over the title.'],
+		['--color <hex>', 'The brand colour, e.g. #ff5c3a. Default #d4ff3a.'],
+		['--aspect <ratio>', 'og (1200×630), 1:1, 16:9, 4:5, 9:16, any w:h, or a number.\nDefault og.'],
+		['--width <px>', 'The width, 200–6000. Default 1200.'],
+		['--seed <text>', "Drives every random choice. Default: the mark's slug."],
+		['-o, --out <file>', 'Write .png, or .svg (text as outlines). Default cover.png.'],
+	],
+	examples: ['logomarks cover hex-gem --recipe aurora --title "Introducing Hexa" -o cover.png', 'logomarks cover mark.svg --recipe stripes --aspect 1:1 -o post.png'],
+};
+
+/**
+ * Runs `cover`.
+ *
+ * @param {import('../args.js').Parsed} args The parsed arguments.
+ * @param {import('../index.js').IO} io Where output goes.
+ * @returns {Promise<number>} The exit code: 0.
+ */
+export async function run(args, io) {
+	const mark = markArg(args.positionals);
+	const { recipe = 'mark', title, label, aspect, seed } = args.options;
+	if (!(recipe in RECIPES)) throw new UsageError(`--recipe is one of ${Object.keys(RECIPES).join(', ')}`);
+	if (aspect && !/^(og|\d+(\.\d+)?(:\d+(\.\d+)?)?)$/.test(aspect)) throw new UsageError('--aspect is og, w:h (16:9) or a number');
+	const out = args.options.out ?? 'cover.png';
+	const c = await cover({ mark, recipe, title, label, seed, color: colorArg(args.options.color), aspect: aspect && /^[\d.]+$/.test(aspect) ? Number(aspect) : aspect, width: intArg('width', args.options.width, 200, 6000) });
+	writeFile(out, out.toLowerCase().endsWith('.svg') ? c.svg : c.png);
+	if (args.flags.has('json')) io.out(JSON.stringify({ ok: true, file: out, recipe, width: c.width, height: c.height }, null, 2));
+	else io.out(`${style.green('✓')} wrote ${style.bold(out)}: ${recipe}, ${c.width} × ${c.height}.`);
+	return 0;
+}

package/src/cli/commands/edit.d.ts

@@ -0,0 +1,10 @@
+import type { ArgSpec, Parsed } from '../args.js';
+import type { IO } from '../index.js';
+import type { CommandHelp } from '../help.js';
+
+/** What `edit` takes. */
+export const spec: ArgSpec;
+/** What `logomarks edit --help` prints. */
+export const help: CommandHelp;
+/** Runs `edit`; resolves to its exit code. */
+export function run(args: Parsed, io: IO): Promise<number>;

package/src/cli/commands/edit.js

@@ -0,0 +1,70 @@
+/**
+ * @module logomarks/cli/commands/edit
+ *
+ * `logomarks edit <slug|file.svg> --ops '[…]' -o out.svg`: edits by part,
+ * as JSON (`--ops @ops.json` reads a file), fitted and checked.
+ */
+
+import fs from 'node:fs';
+import { editMark } from '../../edit/ops.js';
+import { UsageError } from '../args.js';
+import { markArg, asUsage } from '../options.js';
+import { output } from '../edited.js';
+import { OPS } from '../../edit/ops.js';
+import { wrapList } from '../help.js';
+
+/** What `edit` takes. */
+export const spec = { flags: ['json'], options: { out: 'o', ops: '' } };
+
+/** `logomarks edit --help`. */
+/** @type {import('../help.js').CommandHelp} */
+export const help = {
+	summary: 'Edit a mark by part, with a list of ops.',
+	usage: ["<mark> --ops '<json>' [-o out.svg]", '<mark> --ops @ops.json [-o out.svg]'],
+	about: [
+		'Ops run in order; "parts" are indices from logomarks parts. The result is fitted and',
+		'checked, and exit 1 means it fails a check. Each op\'s settings: docs/editing.md.',
+		`Ops: ${wrapList(Object.keys(OPS), 66)}.`,
+	],
+	options: [
+		['--ops <json | @file>', 'The ops as a JSON array, or @ and a file holding one.'],
+		['-o, --out <file>', 'Write .svg, or .png drawn at 512. Default: the SVG to stdout.'],
+	],
+	examples: [
+		`logomarks edit quad-cove --ops '[{"op":"delete","parts":[3]},{"op":"round","radius":18}]' -o mine.svg`,
+		'logomarks edit mark.svg --ops @ops.json -o mine.png',
+	],
+};
+
+/**
+ * The ops option: JSON, or `@file` holding it.
+ *
+ * @param {string | undefined} value The option's value.
+ * @returns {import('../../edit/ops.js').EditOp[]} The ops.
+ * @throws {UsageError} When it's missing or isn't a JSON list.
+ */
+function opsArg(value) {
+	if (!value) throw new UsageError('--ops takes a JSON list of edits, e.g. \'[{"op":"delete","parts":[0]}]\', or @ops.json');
+	let ops;
+	try {
+		ops = JSON.parse(value.startsWith('@') ? fs.readFileSync(value.slice(1), 'utf8') : value);
+	} catch (e) {
+		throw new UsageError(`--ops: ${/** @type {Error} */ (e).message}`);
+	}
+	if (!Array.isArray(ops) || !ops.every((o) => o && typeof o.op === 'string')) throw new UsageError('--ops is a JSON list of objects, each with an "op"');
+	return ops;
+}
+
+/**
+ * Runs `edit`.
+ *
+ * @param {import('../args.js').Parsed} args The parsed arguments.
+ * @param {import('../index.js').IO} io Where output goes.
+ * @returns {Promise<number>} The exit code: 0 when the result passes its checks, 1 otherwise.
+ */
+export async function run(args, io) {
+	const mark = markArg(args.positionals);
+	const ops = opsArg(args.options.ops);
+	const r = await asUsage(async () => editMark(mark.svg, ops, { name: mark.slug }));
+	return output(args, io, r, { name: mark.slug, summary: `${mark.name}, ${ops.map((o) => o.op).join(', ')} (${r.parts.length} parts)` });
+}

package/src/cli/commands/find.d.ts

@@ -0,0 +1,10 @@
+import type { ArgSpec, Parsed } from '../args.js';
+import type { IO } from '../index.js';
+import type { CommandHelp } from '../help.js';
+
+/** What `find` takes. */
+export const spec: ArgSpec;
+/** What `logomarks find --help` prints. */
+export const help: CommandHelp;
+/** Runs `find`; resolves to its exit code (0 found, 1 nothing matched). */
+export function run(args: Parsed, io: IO): Promise<number>;

package/src/cli/commands/find.js

@@ -0,0 +1,61 @@
+/**
+ * @module logomarks/cli/commands/find
+ *
+ * `logomarks find <words…>`: search the bundled live set by words, style,
+ * tags, industry or letter. With nothing to search by, the values the
+ * filters take.
+ */
+
+import { findMarks, facets } from '../../find/index.js';
+import { intArg } from '../options.js';
+import { style, pad } from '../style.js';
+
+/** What `find` takes. */
+export const spec = { flags: ['json'], options: { style: '', tag: '', industry: '', letter: '', top: '' } };
+
+/** `logomarks find --help`. */
+/** @type {import('../help.js').CommandHelp} */
+export const help = {
+	summary: 'Search the live set by words, style, tag, industry or letter.',
+	usage: ['<words…> [options]', '[options]'],
+	about: [
+		'Searches as logomarks.ai does: every word must match (synonyms, plurals and trade names',
+		'included) and the best fits come first. With no words or filters it lists every style,',
+		'tag, mood and industry. Exit 1 when nothing matches.',
+	],
+	options: [
+		['--style <style>', 'One style, e.g. letter, badge, iso, line, grid, glitch, animal.'],
+		['--tag <tags>', 'Tags a mark must all have, e.g. round,symmetric.'],
+		['--industry <id>', 'An industry it suits, e.g. coffee, fintech, law-firm.'],
+		['--letter <char>', 'The letter or number a lettermark shows.'],
+		['--top <n>', 'How many marks to list (1–500). Default 20.'],
+	],
+	examples: ['logomarks find coffee', 'logomarks find calm hexagon --top 5', 'logomarks find --style letter --letter K', 'logomarks find'],
+};
+
+/**
+ * Runs `find`.
+ *
+ * @param {import('../args.js').Parsed} args The parsed arguments.
+ * @param {import('../index.js').IO} io Where output goes.
+ * @returns {Promise<number>} The exit code: 0 when anything matched, 1 otherwise.
+ */
+export async function run(args, io) {
+	const query = args.positionals.join(' ');
+	const { style: kind, industry, letter } = args.options;
+	const tags = (args.options.tag ?? '').split(',').map((t) => t.trim()).filter(Boolean);
+	const json = args.flags.has('json');
+	if (!query && !kind && !tags.length && !industry && !letter) {
+		const f = facets();
+		if (json) io.out(JSON.stringify(f, null, 2));
+		else for (const [k, v] of Object.entries(f)) io.out(`${style.bold(k)}  ${Object.entries(v).map(([n, c]) => `${n} ${style.dim(String(c))}`).join(', ')}`);
+		return 0;
+	}
+	const r = findMarks(query, { style: kind, tags, industry, letter, limit: intArg('top', args.options.top, 1, 500) });
+	if (json) io.out(JSON.stringify(r, null, 2));
+	else {
+		for (const m of r.marks) io.out(`${pad(m.slug, 28)} ${pad(m.style, 10)} ${style.dim(m.description)}`);
+		io.out(`\n${r.marks.length} of ${r.total} matching`);
+	}
+	return r.total ? 0 : 1;
+}

package/src/cli/commands/get.d.ts

@@ -0,0 +1,10 @@
+import type { ArgSpec, Parsed } from '../args.js';
+import type { IO } from '../index.js';
+import type { CommandHelp } from '../help.js';
+
+/** What `get` takes. */
+export const spec: ArgSpec;
+/** What `logomarks get --help` prints. */
+export const help: CommandHelp;
+/** Runs `get`; resolves to its exit code (0). */
+export function run(args: Parsed, io: IO): Promise<number>;

package/src/cli/commands/get.js

@@ -0,0 +1,57 @@
+/**
+ * @module logomarks/cli/commands/get
+ *
+ * `logomarks get <slug|name>`: a live mark's SVG (from the bundled index) to
+ * stdout or a file, in a colour, or a PNG at a size.
+ */
+
+import { paint, markPng, MARK_URL } from '../../brand/mark.js';
+import { UsageError } from '../args.js';
+import { markArg, colorArg, intArg, writeFile } from '../options.js';
+import { style } from '../style.js';
+
+/** What `get` takes. */
+export const spec = { flags: ['json'], options: { out: 'o', color: '', size: '', format: '' } };
+
+/** `logomarks get --help`. */
+/** @type {import('../help.js').CommandHelp} */
+export const help = {
+	summary: "Get a live mark's SVG, or a PNG of any mark.",
+	usage: ['<mark> [-o file] [options]'],
+	about: ['Live marks are CC0. Without -o the SVG goes to stdout.'],
+	options: [
+		['--color <hex>', 'Paint it, e.g. #ff5c3a.\nDefault: currentColor (SVG) or black (PNG).'],
+		['--size <px>', 'A PNG this many pixels square (16–4096). Default 512.'],
+		['--format <svg | png>', 'Default: from -o, or png when --size is given.'],
+		['-o, --out <file>', 'Write .svg or .png. A PNG needs -o.'],
+	],
+	examples: ['logomarks get hex-gem -o logo.svg', "logomarks get \"Hex Gem\" --color '#ff5c3a' --size 512 -o logo.png"],
+};
+
+/** A PNG's side when none is given. */
+const PNG_SIZE = 512;
+
+/**
+ * Runs `get`.
+ *
+ * @param {import('../args.js').Parsed} args The parsed arguments.
+ * @param {import('../index.js').IO} io Where output goes.
+ * @returns {Promise<number>} The exit code: 0.
+ */
+export async function run(args, io) {
+	const mark = markArg(args.positionals);
+	const { out, format: asked } = args.options;
+	const color = colorArg(args.options.color);
+	const size = intArg('size', args.options.size, 16, 4096);
+	const format = asked ?? (out?.toLowerCase().endsWith('.png') || size ? 'png' : 'svg');
+	if (format !== 'svg' && format !== 'png') throw new UsageError('--format is svg or png');
+	if (format === 'png' && !out) throw new UsageError('a PNG needs -o file.png');
+	const svg = paint(mark.svg, color);
+	const data = format === 'png' ? await markPng(mark.svg, { size: size ?? PNG_SIZE, color: color ?? '#000000' }) : svg;
+	if (out) writeFile(out, data);
+	const about = { slug: mark.slug, name: mark.name, ...(mark.live && { url: MARK_URL + mark.slug, licence: 'CC0-1.0' }), format, color: color ?? (format === 'png' ? '#000000' : 'currentColor'), ...(format === 'png' && { size: size ?? PNG_SIZE }) };
+	if (args.flags.has('json')) io.out(JSON.stringify({ ...about, ...(out ? { file: out } : { svg }) }, null, 2));
+	else if (out) io.out(`${style.green('✓')} wrote ${style.bold(out)}: ${mark.name}${mark.live ? style.dim(` (CC0, ${about.url})`) : ''}`);
+	else io.out(svg.trimEnd());
+	return 0;
+}

package/src/cli/commands/glitch.d.ts

@@ -0,0 +1,10 @@
+import type { ArgSpec, Parsed } from '../args.js';
+import type { IO } from '../index.js';
+import type { CommandHelp } from '../help.js';
+
+/** What `glitch` takes. */
+export const spec: ArgSpec;
+/** What `logomarks glitch --help` prints. */
+export const help: CommandHelp;
+/** Runs `glitch`; resolves to its exit code. */
+export function run(args: Parsed, io: IO): Promise<number>;

package/src/cli/commands/glitch.js

@@ -0,0 +1,57 @@
+/**
+ * @module logomarks/cli/commands/glitch
+ *
+ * `logomarks glitch <slug|file.svg> --preset shear -o out.svg`: a glitch
+ * edition, fitted and checked. The same seed gives the same bytes.
+ */
+
+import { glitchMark, PRESETS } from '../../edit/glitch.js';
+import { UsageError } from '../args.js';
+import { markArg, numArg, intArg, asUsage } from '../options.js';
+import { output } from '../edited.js';
+
+/** What `glitch` takes. */
+export const spec = { flags: ['json'], options: { out: 'o', preset: '', angle: '', place: '', slide: '', gap: '', cuts: '', seed: '' } };
+
+/** `logomarks glitch --help`. */
+/** @type {import('../help.js').CommandHelp} */
+export const help = {
+	summary: 'Make a glitch edition of a mark: cut with the house gap and slid.',
+	usage: ['<mark> [--preset shear] [-o out.svg] [options]'],
+	about: [
+		'The result is fitted and checked, and the same seed gives the same bytes. Without -o the',
+		'SVG goes to stdout and the checks to stderr. Exit 1 when the result fails a check: try',
+		'another seed.',
+	],
+	options: [
+		['--preset <name>', `${Object.keys(PRESETS).join(', ')}. Default shear.`],
+		['--seed <n>', 'Places the cuts; another seed is a shuffle. Default 1.'],
+		['--angle <deg>', "Cut direction, clockwise from across. Default: the mark's slope\n(shear), across the lanes (lane), else 0."],
+		['--place <0–1>', 'Where the first cut crosses the mark. Default: seeded.'],
+		['--slide <units>', 'How far the sides slide apart along the cut. Default 44.'],
+		['--gap <units>', 'The gap at each cut. Default 22.'],
+		['--cuts <n>', 'Cuts for slice (1–3), bands for bands (3–5). Default: seeded.'],
+		['-o, --out <file>', 'Write .svg, or .png drawn at 512.'],
+	],
+	examples: ['logomarks glitch quad-cove --preset shear --seed 3 -o glitched.svg', 'logomarks glitch mark.svg --preset bands --cuts 4 -o preview.png'],
+};
+
+/**
+ * Runs `glitch`.
+ *
+ * @param {import('../args.js').Parsed} args The parsed arguments.
+ * @param {import('../index.js').IO} io Where output goes.
+ * @returns {Promise<number>} The exit code: 0 when the result passes its checks, 1 otherwise.
+ */
+export async function run(args, io) {
+	const mark = markArg(args.positionals);
+	const preset = /** @type {import('../../edit/glitch.js').GlitchPreset} */ (args.options.preset ?? 'shear');
+	if (!(preset in PRESETS)) throw new UsageError(`--preset is one of ${Object.keys(PRESETS).join(', ')}`);
+	const o = args.options;
+	const r = await asUsage(async () => glitchMark(mark.svg, {
+		preset, name: mark.slug, angle: numArg('angle', o.angle), place: numArg('place', o.place), slide: numArg('slide', o.slide),
+		gap: numArg('gap', o.gap), cuts: intArg('cuts', o.cuts, 1, 5), seed: intArg('seed', o.seed, 0, 2 ** 31),
+	}));
+	const g = r.glitch;
+	return output(args, io, r, { name: mark.slug, summary: `${mark.name}, ${preset} at seed ${g.seed} (${g.cuts} cut${g.cuts > 1 ? 's' : ''}, ${g.angle}°, ${g.pieces} pieces)` });
+}

package/src/cli/commands/index.d.ts

@@ -0,0 +1,15 @@
+import type { ArgSpec, Parsed } from '../args.js';
+import type { IO } from '../index.js';
+import type { CommandHelp } from '../help.js';
+
+/** A verb: the arguments it takes and how it runs. */
+export interface Command {
+	spec: ArgSpec;
+	/** What `logomarks <verb> --help` prints. */
+	help: CommandHelp;
+	/** Runs the verb and resolves to its exit code (0 pass, 1 fail). */
+	run(args: Parsed, io: IO): Promise<number>;
+}
+
+/** Every verb the CLI runs. */
+export const COMMANDS: Readonly<Record<'check' | 'similar' | 'specks' | 'sheet' | 'find' | 'parts' | 'glitch' | 'edit' | 'combine' | 'get' | 'kit' | 'social' | 'mockup' | 'cover' | 'mcp', Command>>;