@janga/norna 0.7.0

package/scripts/init-site.mjs

@@ -0,0 +1,249 @@
+import { cp, mkdir, readFile, readdir, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import {
+	engineRoot,
+	invocationRoot,
+	siteDirectoryEnv,
+} from './lib/site-paths.mjs';
+
+const packageName = '@janga/norna';
+const cliExecutableName = 'norna';
+
+const usage = `
+Usage: norna init <target-dir> [--type pure|embedded] [--site-dir <path>]
+
+Creates a new site project or adds a gallery source directory to an existing
+project.
+
+Examples:
+  norna init my-gallery
+  norna init my-gallery --type pure
+  norna init . --type embedded --site-dir presentation
+`.trim();
+
+const args = process.argv.slice(2);
+const parseArgs = (rawArgs) => {
+	const options = {
+		siteDirectory: process.env[siteDirectoryEnv] ?? 'site',
+		targetDirectory: null,
+		type: 'pure',
+	};
+
+	for (let index = 0; index < rawArgs.length; index += 1) {
+		const arg = rawArgs[index];
+
+		if (arg === '--type') {
+			const value = rawArgs[index + 1];
+			if (!value || value.startsWith('-')) {
+				throw new Error('--type requires "pure" or "embedded".');
+			}
+			options.type = value;
+			index += 1;
+			continue;
+		}
+
+		if (arg.startsWith('--type=')) {
+			options.type = arg.slice('--type='.length);
+			continue;
+		}
+
+		if (arg === '--site-dir') {
+			const value = rawArgs[index + 1];
+			if (!value || value.startsWith('-')) {
+				throw new Error('--site-dir requires a relative path.');
+			}
+			options.siteDirectory = value;
+			index += 1;
+			continue;
+		}
+
+		if (arg.startsWith('--site-dir=')) {
+			options.siteDirectory = arg.slice('--site-dir='.length);
+			continue;
+		}
+
+		if (arg.startsWith('-')) {
+			throw new Error(`Unknown option: ${arg}\n${usage}`);
+		}
+
+		if (options.targetDirectory) {
+			throw new Error(usage);
+		}
+
+		options.targetDirectory = arg;
+	}
+
+	return options;
+};
+
+const {
+	siteDirectory,
+	targetDirectory,
+	type,
+} = parseArgs(args);
+
+if (!targetDirectory) {
+	throw new Error(usage);
+}
+
+if (!['pure', 'embedded'].includes(type)) {
+	throw new Error(`Invalid --type "${type}". Use "pure" or "embedded".`);
+}
+
+if (!siteDirectory || path.isAbsolute(siteDirectory) || siteDirectory.split(/[\\/]/).includes('..')) {
+	throw new Error('--site-dir must be a non-empty relative path without "..".');
+}
+
+const starterRoot = path.join(engineRoot, 'starters', 'basic');
+const starterSiteRoot = path.join(starterRoot, 'site');
+const targetRoot = path.resolve(invocationRoot, targetDirectory);
+const enginePackageJsonPath = path.join(engineRoot, 'package.json');
+const targetPackageJsonPath = path.join(targetRoot, 'package.json');
+const targetSiteDir = path.join(targetRoot, siteDirectory);
+const isInsideEngineRoot = (candidatePath) => {
+	const relativePath = path.relative(engineRoot, candidatePath);
+	return relativePath && !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
+};
+
+const readDirectoryEntries = async (directoryPath) => {
+	try {
+		return await readdir(directoryPath);
+	} catch (error) {
+		if (error?.code === 'ENOENT') {
+			return null;
+		}
+
+		throw error;
+	}
+};
+
+const readJsonFile = async (filePath) => JSON.parse(await readFile(filePath, 'utf8'));
+
+const siteDirArg = siteDirectory === 'site' ? [] : ['--site-dir', siteDirectory];
+const cliCommand = (command) => [cliExecutableName, ...siteDirArg, command].join(' ');
+const galleryScripts = {
+	'norna:dev': cliCommand('dev:local'),
+	'norna:dev:lan': cliCommand('dev:lan'),
+	'norna:dev:restart': cliCommand('dev:restart'),
+	'norna:dev:status': cliCommand('dev:status'),
+	'norna:dev:logs': cliCommand('dev:logs'),
+	'norna:dev:stop': cliCommand('dev:stop'),
+	'norna:check': 'npm run norna:config:check && npm run norna:content:check',
+	'norna:config:check': cliCommand('config:check'),
+	'norna:content:check': cliCommand('content:check'),
+	'norna:sync': cliCommand('content:sync'),
+	'norna:typography:presets': cliCommand('typography:presets'),
+	'norna:typography:show': cliCommand('typography:show'),
+	'norna:public': cliCommand('site:public'),
+	'norna:images': cliCommand('images'),
+	'norna:build': cliCommand('build'),
+	'norna:build:local': cliCommand('build:local'),
+	'norna:deploy': cliCommand('deploy'),
+	'norna:deploy:commit': cliCommand('deploy:commit'),
+	'norna:deploy:watch': cliCommand('deploy:watch'),
+	'norna:doctor': cliCommand('doctor'),
+	'norna:preview': cliCommand('preview'),
+	'norna:engine:update': cliCommand('engine:update'),
+	'norna:engine:version': cliCommand('engine:version'),
+};
+
+const addGalleryDependency = (packageJson, version) => {
+	packageJson.dependencies ??= {};
+	packageJson.dependencies[packageName] ??= version;
+};
+
+const addGalleryScripts = (packageJson, scripts, { includePureAliases }) => {
+	packageJson.scripts ??= {};
+	const wantedScripts = {
+		...(includePureAliases ? { dev: 'npm run norna:dev' } : {}),
+		...scripts,
+		...(includePureAliases ? { build: 'npm run norna:build' } : {}),
+	};
+	const conflicts = Object.entries(wantedScripts).filter(([name, value]) => (
+		packageJson.scripts[name] !== undefined && packageJson.scripts[name] !== value
+	));
+
+	if (conflicts.length > 0) {
+		throw new Error([
+			'Refusing to overwrite existing npm scripts:',
+			...conflicts.map(([name, value]) => `- ${name}: existing "${packageJson.scripts[name]}", wanted "${value}"`),
+		].join('\n'));
+	}
+
+	Object.assign(packageJson.scripts, wantedScripts);
+};
+
+const enginePackageJson = await readJsonFile(enginePackageJsonPath);
+const existingEntries = await readDirectoryEntries(targetRoot);
+
+if (type === 'pure') {
+	if (existingEntries && existingEntries.length > 0) {
+		const existingPackageJson = existingEntries.includes('package.json')
+			? ' The target already contains package.json; use --type embedded to add a gallery to an existing project.'
+			: '';
+		throw new Error(`Target directory must be empty for --type pure: ${targetRoot}.${existingPackageJson}`);
+	}
+
+	await mkdir(path.dirname(targetRoot), { recursive: true });
+	await cp(starterRoot, targetRoot, {
+		filter: (source) => path.basename(source) !== '.DS_Store',
+		recursive: true,
+	});
+
+	if (siteDirectory !== 'site') {
+		await mkdir(path.dirname(targetSiteDir), { recursive: true });
+		await rename(path.join(targetRoot, 'site'), targetSiteDir);
+	}
+
+	const targetPackageJson = await readJsonFile(targetPackageJsonPath);
+	targetPackageJson.dependencies[packageName] = enginePackageJson.version;
+	if (siteDirectory !== 'site') {
+		targetPackageJson.scripts = {};
+		addGalleryScripts(targetPackageJson, galleryScripts, { includePureAliases: true });
+	}
+	await writeFile(targetPackageJsonPath, `${JSON.stringify(targetPackageJson, null, 2)}\n`);
+} else {
+	if (!existingEntries) {
+		throw new Error(`Target directory must exist for --type embedded: ${targetRoot}`);
+	}
+
+	const targetPackageJson = await readJsonFile(targetPackageJsonPath).catch((error) => {
+		if (error?.code === 'ENOENT') {
+			throw new Error(`Embedded setup requires an existing package.json in ${targetRoot}.`);
+		}
+
+		throw error;
+	});
+	const existingSiteEntries = await readDirectoryEntries(targetSiteDir);
+
+	if (existingSiteEntries && existingSiteEntries.length > 0) {
+		throw new Error(`Gallery site directory must be empty for --type embedded: ${targetSiteDir}`);
+	}
+
+	addGalleryDependency(targetPackageJson, enginePackageJson.version);
+	addGalleryScripts(targetPackageJson, galleryScripts, { includePureAliases: false });
+	await mkdir(path.dirname(targetSiteDir), { recursive: true });
+	await cp(starterSiteRoot, targetSiteDir, {
+		filter: (source) => path.basename(source) !== '.DS_Store',
+		recursive: true,
+	});
+	await writeFile(targetPackageJsonPath, `${JSON.stringify(targetPackageJson, null, 2)}\n`);
+}
+
+console.log(type === 'embedded'
+	? `Added norna site directory at ${targetSiteDir}`
+	: `Created norna site at ${targetRoot}`);
+if (isInsideEngineRoot(targetRoot)) {
+	console.warn('');
+	console.warn('Warning: This site was created inside the norna engine repository.');
+	console.warn('For normal site projects, create the site next to the engine repository instead, for example as a sibling directory under your Projects folder.');
+	console.warn('That keeps site content, npm installs, commits, and releases separate from engine development.');
+}
+console.log('');
+console.log('Next steps:');
+console.log(`  cd ${targetRoot}`);
+console.log(type === 'embedded'
+	? '  npm install'
+	: '  npm install');
+console.log('  npm run norna:dev');

package/scripts/lib/astro-command.mjs

@@ -0,0 +1,34 @@
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import {
+	engineRoot,
+	siteProjectRoot,
+} from './site-paths.mjs';
+import { runInherit } from './run-command.mjs';
+
+const require = createRequire(import.meta.url);
+const astroPackagePath = require.resolve('astro/package.json');
+const astroPackage = require(astroPackagePath);
+
+export const astroBinPath = path.join(path.dirname(astroPackagePath), astroPackage.bin.astro);
+export const astroConfigPath = path.relative(siteProjectRoot, path.join(engineRoot, 'astro.config.mjs'))
+	.split(path.sep)
+	.join('/');
+
+export const getAstroArgs = (args) => [
+	astroBinPath,
+	'--root',
+	siteProjectRoot,
+	'--config',
+	astroConfigPath,
+	...args,
+];
+
+export const runAstroInherit = (args, options = {}) => runInherit(
+	process.execPath,
+	getAstroArgs(args),
+	{
+		cwd: siteProjectRoot,
+		...options,
+	},
+);

package/scripts/lib/ci-lockfile.mjs

@@ -0,0 +1,34 @@
+import { runInherit } from './run-command.mjs';
+
+export const ciNpmVersion = '11.16.0';
+
+const ciPlatformArgs = [
+	'--os=linux',
+	'--cpu=x64',
+	'--libc=glibc',
+];
+
+const npmCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+
+const getNpmArgs = (command, args = []) => [
+	'--yes',
+	`npm@${ciNpmVersion}`,
+	command,
+	...args,
+	'--ignore-scripts',
+	'--no-audit',
+	'--no-fund',
+	...ciPlatformArgs,
+];
+
+export const normalizeCiLockfile = (cwd, options = {}) => runInherit(
+	npmCommand,
+	getNpmArgs('install', ['--package-lock-only']),
+	{ cwd, ...options },
+);
+
+export const verifyCiLockfile = (cwd, options = {}) => runInherit(
+	npmCommand,
+	getNpmArgs('ci', ['--dry-run']),
+	{ cwd, ...options },
+);

package/scripts/lib/image-dimensions.mjs

@@ -0,0 +1,78 @@
+import { readFile } from 'node:fs/promises';
+
+const pngSignature = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+const jpegStartOfFrameMarkers = new Set([
+	0xc0,
+	0xc1,
+	0xc2,
+	0xc3,
+	0xc5,
+	0xc6,
+	0xc7,
+	0xc9,
+	0xca,
+	0xcb,
+	0xcd,
+	0xce,
+	0xcf,
+]);
+
+const isPng = (buffer) => buffer.length >= 24 && buffer.subarray(0, 8).equals(pngSignature);
+
+const readPngDimensions = (buffer) => ({
+	width: buffer.readUInt32BE(16),
+	height: buffer.readUInt32BE(20),
+});
+
+const readJpegDimensions = (buffer) => {
+	if (buffer.length < 4 || buffer[0] !== 0xff || buffer[1] !== 0xd8) {
+		return null;
+	}
+
+	let offset = 2;
+
+	while (offset + 9 < buffer.length) {
+		while (buffer[offset] === 0xff) {
+			offset += 1;
+		}
+
+		const marker = buffer[offset];
+		offset += 1;
+
+		if (marker === 0xd9 || marker === 0xda) {
+			return null;
+		}
+
+		if (offset + 2 > buffer.length) {
+			return null;
+		}
+
+		const segmentLength = buffer.readUInt16BE(offset);
+		if (segmentLength < 2 || offset + segmentLength > buffer.length) {
+			return null;
+		}
+
+		if (jpegStartOfFrameMarkers.has(marker)) {
+			if (segmentLength < 7) return null;
+
+			return {
+				height: buffer.readUInt16BE(offset + 3),
+				width: buffer.readUInt16BE(offset + 5),
+			};
+		}
+
+		offset += segmentLength;
+	}
+
+	return null;
+};
+
+export const readImageDimensions = async (filePath) => {
+	const buffer = await readFile(filePath);
+
+	if (isPng(buffer)) {
+		return readPngDimensions(buffer);
+	}
+
+	return readJpegDimensions(buffer);
+};

package/scripts/lib/presentation.mjs

@@ -0,0 +1,72 @@
+import {
+	defaultTypography,
+	resolveTypographyConfig,
+	resolveTypographyOverride,
+} from './typography.mjs';
+
+export const fallbackPresentationColors = Object.freeze({
+	backgroundColor: 'transparent',
+	textColor: 'var(--color-text)',
+});
+
+const normalizePresentation = (presentation) => presentation ?? {};
+
+export const resolveThemePresentation = (themePresentation) => {
+	const normalizedThemePresentation = normalizePresentation(themePresentation);
+
+	return {
+		backgroundColor: normalizedThemePresentation.backgroundColor ?? fallbackPresentationColors.backgroundColor,
+		textColor: normalizedThemePresentation.textColor ?? fallbackPresentationColors.textColor,
+		inlineStyles: normalizedThemePresentation.inlineStyles ?? {},
+		typography: resolveTypographyConfig(normalizedThemePresentation.typography ?? defaultTypography),
+	};
+};
+
+export const resolvePagePresentation = (themePresentation, pagePresentation) => {
+	const resolvedThemePresentation = resolveThemePresentation(themePresentation);
+	const normalizedPagePresentation = normalizePresentation(pagePresentation);
+
+	return {
+		backgroundColor: normalizedPagePresentation.backgroundColor ?? resolvedThemePresentation.backgroundColor,
+		textColor: normalizedPagePresentation.textColor ?? resolvedThemePresentation.textColor,
+		inlineStyles: resolvedThemePresentation.inlineStyles,
+		typography: resolveTypographyOverride(
+			resolvedThemePresentation.typography,
+			normalizedPagePresentation.typography,
+		),
+	};
+};
+
+const getColorsFromPresentation = (presentation) => ({
+	backgroundColor: presentation.backgroundColor,
+	textColor: presentation.textColor,
+});
+
+const resolveColorSource = ({ colors, themePresentation, themeFrameColors, pagePresentation }) => {
+	if (!colors || colors === 'theme') {
+		return themeFrameColors;
+	}
+
+	if (colors === 'presentation') {
+		return getColorsFromPresentation(pagePresentation);
+	}
+
+	return colors;
+};
+
+export const resolveFrameColors = ({ themePresentation, themeFrame, pagePresentation, pageFrame }) => {
+	const resolvedThemePresentation = resolveThemePresentation(themePresentation);
+	const themeFrameColors = resolveColorSource({
+		colors: themeFrame?.colors ?? 'presentation',
+		themePresentation: resolvedThemePresentation,
+		themeFrameColors: getColorsFromPresentation(resolvedThemePresentation),
+		pagePresentation: resolvedThemePresentation,
+	});
+
+	return resolveColorSource({
+		colors: pageFrame?.colors ?? 'theme',
+		themePresentation: resolvedThemePresentation,
+		themeFrameColors,
+		pagePresentation,
+	});
+};