@auraindustry/aurajs 0.0.7 → 0.1.1

package/src/retro/assets/compile.mjs

@@ -0,0 +1,232 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { createRetroDiagnostic } from '../diagnostics/emit.mjs';
+import { getRetroTargetProfile } from '../shared/targets.mjs';
+
+const DEFAULT_ASSET_FILE = 'assets/retro/assets.json';
+const ASSET_KIND_ORDER = Object.freeze(['palettes', 'tiles', 'sprites', 'fonts']);
+
+function readAssetSource(projectRoot) {
+  const assetPath = resolve(projectRoot, DEFAULT_ASSET_FILE);
+  if (!existsSync(assetPath)) {
+    return {
+      assetPath,
+      raw: {
+        palettes: [],
+        tiles: [],
+        sprites: [],
+        fonts: [],
+      },
+      present: false,
+    };
+  }
+
+  try {
+    return {
+      assetPath,
+      raw: JSON.parse(readFileSync(assetPath, 'utf8')),
+      present: true,
+    };
+  } catch (error) {
+    return {
+      assetPath,
+      raw: null,
+      present: true,
+      diagnostics: [
+        createRetroDiagnostic({
+          reasonCode: 'retro_asset_format_unsupported',
+          filePath: assetPath,
+          message: `Retro asset manifest is not valid JSON: ${error.message}`,
+          source: 'retro-assets',
+        }),
+      ],
+    };
+  }
+}
+
+function ensureArray(value, key, diagnostics, assetPath) {
+  if (value == null) return [];
+  if (Array.isArray(value)) return value;
+  diagnostics.push(
+    createRetroDiagnostic({
+      reasonCode: 'retro_asset_format_unsupported',
+      filePath: assetPath,
+      message: `Retro asset field "${key}" must be an array.`,
+      source: 'retro-assets',
+    }),
+  );
+  return [];
+}
+
+function validateAssetId(id, kind, diagnostics, assetPath) {
+  const normalized = String(id || '').trim();
+  if (!/^[a-z0-9._-]+$/i.test(normalized)) {
+    diagnostics.push(
+      createRetroDiagnostic({
+        reasonCode: 'retro_asset_format_unsupported',
+        filePath: assetPath,
+        message: `${kind} id "${id}" must use simple alphanumeric, dot, dash, or underscore characters.`,
+        source: 'retro-assets',
+      }),
+    );
+  }
+  return normalized;
+}
+
+function validatePalette(palette, diagnostics, assetPath) {
+  const id = validateAssetId(palette.id, 'palette', diagnostics, assetPath);
+  const colors = Array.isArray(palette.colors) ? palette.colors.map((entry) => String(entry)) : [];
+  if (colors.length === 0) {
+    diagnostics.push(
+      createRetroDiagnostic({
+        reasonCode: 'retro_asset_format_unsupported',
+        filePath: assetPath,
+        message: `Palette "${id}" must declare at least one color.`,
+        source: 'retro-assets',
+      }),
+    );
+  }
+  return { id, colors };
+}
+
+function validatePixelRows(asset, kind, diagnostics, assetPath) {
+  const rows = Array.isArray(asset.pixels) ? asset.pixels.map((entry) => String(entry)) : [];
+  const width = Number(asset.width || (rows[0] ? rows[0].length : 0));
+  const height = Number(asset.height || rows.length);
+  if (!Number.isInteger(width) || width < 1 || !Number.isInteger(height) || height < 1) {
+    diagnostics.push(
+      createRetroDiagnostic({
+        reasonCode: 'retro_asset_format_unsupported',
+        filePath: assetPath,
+        message: `${kind} "${asset.id}" must declare positive width and height.`,
+        source: 'retro-assets',
+      }),
+    );
+  }
+  for (const row of rows) {
+    if (row.length !== width || /[^0-3.]/.test(row)) {
+      diagnostics.push(
+        createRetroDiagnostic({
+          reasonCode: 'retro_asset_format_unsupported',
+          filePath: assetPath,
+          message: `${kind} "${asset.id}" must use pixel rows of width ${width} with digits 0-3 or "." only.`,
+          source: 'retro-assets',
+        }),
+      );
+      break;
+    }
+  }
+  return {
+    id: validateAssetId(asset.id, kind, diagnostics, assetPath),
+    width,
+    height,
+    palette: asset.palette ? String(asset.palette) : null,
+    pixels: rows,
+  };
+}
+
+function validateFont(font, diagnostics, assetPath) {
+  const id = validateAssetId(font.id, 'font', diagnostics, assetPath);
+  const width = Number(font.width || 8);
+  const height = Number(font.height || 8);
+  const glyphs = typeof font.glyphs === 'object' && font.glyphs
+    ? Object.fromEntries(
+      Object.entries(font.glyphs).map(([key, rows]) => [key, Array.isArray(rows) ? rows.map((entry) => String(entry)) : []]),
+    )
+    : {};
+  for (const [glyph, rows] of Object.entries(glyphs)) {
+    if (!rows.every((row) => row.length === width && !/[^0-3.]/.test(row))) {
+      diagnostics.push(
+        createRetroDiagnostic({
+          reasonCode: 'retro_asset_format_unsupported',
+          filePath: assetPath,
+          message: `Font "${id}" glyph "${glyph}" must use ${width}-wide rows with digits 0-3 or "." only.`,
+          source: 'retro-assets',
+        }),
+      );
+      break;
+    }
+  }
+  return { id, width, height, glyphs };
+}
+
+function enforceBudget(kind, count, max, assetPath, diagnostics, target) {
+  if (count <= max) {
+    return;
+  }
+  diagnostics.push(
+    createRetroDiagnostic({
+      reasonCode: 'retro_asset_budget_exceeded',
+      filePath: assetPath,
+      message: `Target "${target}" allows at most ${max} ${kind}, but the asset manifest declared ${count}.`,
+      source: 'retro-assets',
+    }),
+  );
+}
+
+export function compileRetroAssets(options = {}) {
+  const projectRoot = resolve(options.projectRoot || process.cwd());
+  const targetProfile = getRetroTargetProfile(options.target || 'gbc');
+  const source = readAssetSource(projectRoot);
+  if (Array.isArray(source.diagnostics) && source.diagnostics.length > 0) {
+    return {
+      ok: false,
+      assetPath: source.assetPath,
+      diagnostics: source.diagnostics,
+      present: source.present,
+      compiled: null,
+      summary: null,
+      outputPath: null,
+    };
+  }
+
+  const diagnostics = [];
+  const raw = source.raw && typeof source.raw === 'object' ? source.raw : {};
+  const palettes = ensureArray(raw.palettes, 'palettes', diagnostics, source.assetPath).map((entry) => validatePalette(entry, diagnostics, source.assetPath));
+  const tiles = ensureArray(raw.tiles, 'tiles', diagnostics, source.assetPath).map((entry) => validatePixelRows(entry, 'tile', diagnostics, source.assetPath));
+  const sprites = ensureArray(raw.sprites, 'sprites', diagnostics, source.assetPath).map((entry) => validatePixelRows(entry, 'sprite', diagnostics, source.assetPath));
+  const fonts = ensureArray(raw.fonts, 'fonts', diagnostics, source.assetPath).map((entry) => validateFont(entry, diagnostics, source.assetPath));
+
+  enforceBudget('palettes', palettes.length, targetProfile.budgets.palettes, source.assetPath, diagnostics, targetProfile.target);
+  enforceBudget('tiles', tiles.length, targetProfile.budgets.tiles, source.assetPath, diagnostics, targetProfile.target);
+  enforceBudget('sprites', sprites.length, targetProfile.budgets.sprites, source.assetPath, diagnostics, targetProfile.target);
+  enforceBudget('fonts', fonts.length, targetProfile.budgets.fonts, source.assetPath, diagnostics, targetProfile.target);
+  for (const font of fonts) {
+    enforceBudget(`glyphs in font "${font.id}"`, Object.keys(font.glyphs).length, targetProfile.budgets.glyphsPerFont, source.assetPath, diagnostics, targetProfile.target);
+  }
+
+  const compiled = {
+    schemaVersion: 1,
+    target: targetProfile.target,
+    palettes,
+    tiles,
+    sprites,
+    fonts,
+  };
+
+  const summary = {
+    paletteCount: palettes.length,
+    tileCount: tiles.length,
+    spriteCount: sprites.length,
+    fontCount: fonts.length,
+    present: source.present,
+  };
+
+  let outputPath = null;
+  if (options.emitCompiled) {
+    const outRoot = resolve(options.outRoot || resolve(projectRoot, 'build', targetProfile.target));
+    mkdirSync(outRoot, { recursive: true });
+    outputPath = resolve(outRoot, 'retro-assets.json');
+    writeFileSync(outputPath, `${JSON.stringify(compiled, null, 2)}\n`, 'utf8');
+  }
+
+  return {
+    ok: diagnostics.length === 0,
+    assetPath: source.assetPath,
+    diagnostics,
+    present: source.present,
+    compiled,
+    summary,
+    outputPath,
+  };
+}