@sebastianwessel/isostate-cli 0.1.0

package/dist/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":""}

package/dist/bin.js

@@ -0,0 +1,637 @@
+#!/usr/bin/env node
+import { readFile, rm, mkdir, writeFile, rename, stat, copyFile } from 'node:fs/promises';
+import { extname, dirname, basename, join, resolve, isAbsolute, sep } from 'node:path';
+import { fromJson, fromJs, parseScene, validateScene, compileScene, toJs, toJson } from '@sebastianwessel/isostate/dsl';
+import { createHash } from 'node:crypto';
+
+function formatValidationError(error) {
+    return formatIssue('ERROR', error);
+}
+function formatValidationWarning(warning) {
+    return formatIssue('WARN', warning);
+}
+function formatThrownError(error) {
+    if (isStructuredError(error) && error.code) {
+        return `ERROR ${error.code} ${error.message}`;
+    }
+    if (error instanceof Error) {
+        return `ERROR CLI_ERROR ${error.message}`;
+    }
+    return 'ERROR CLI_ERROR Unknown CLI failure';
+}
+function formatIssue(level, issue) {
+    const location = issue.location ? ` ${formatLocation(issue.location)}` : '';
+    return `${level} ${issue.code}${location} ${issue.message}`;
+}
+function formatLocation(location) {
+    const parts = [
+        location.file,
+        location.line === undefined ? undefined : String(location.line),
+        location.column === undefined ? undefined : String(location.column)
+    ].filter((part) => part !== undefined && part.length > 0);
+    return parts.length === 0 ? '' : `(${parts.join(':')})`;
+}
+function isStructuredError(error) {
+    return error instanceof Error && 'code' in error;
+}
+
+function runtimeDigest(bundle) {
+    const { _digest, ...bundleWithoutDigest } = bundle;
+    return sha256Hex(canonicalStringify(bundleWithoutDigest));
+}
+function sha256Hex(input) {
+    return createHash('sha256').update(input).digest('hex');
+}
+function canonicalStringify(value) {
+    return JSON.stringify(normalizeValue(value));
+}
+function normalizeValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => item === undefined ? null : normalizeValue(item));
+    }
+    if (!isPlainObject(value))
+        return value;
+    const normalized = {};
+    for (const key of Object.keys(value).sort()) {
+        const child = value[key];
+        if (child !== undefined) {
+            normalized[key] = normalizeValue(child);
+        }
+    }
+    return normalized;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+async function inspectCommand(args, io) {
+    const parsed = parseInspectArgs(args);
+    if (!parsed.ok) {
+        io.stderr.error(parsed.error);
+        return { exitCode: 1 };
+    }
+    const source = await readFile(parsed.input, 'utf8');
+    const bundle = parseBundle(parsed.input, source);
+    validateDigest(bundle);
+    const assetCount = Object.keys(bundle.assets ?? {}).length;
+    const floorSize = bundle.floor.size.join('x');
+    io.stdout.log(`format: ${bundle._format}`);
+    io.stdout.log(`version: ${bundle._version}`);
+    io.stdout.log(`scenes: ${bundle.scenes.length}`);
+    io.stdout.log(`assets: ${assetCount}`);
+    io.stdout.log(`layers: ${bundle.layers.length}`);
+    io.stdout.log(`floor: ${floorSize}`);
+    io.stdout.log(`digest: ${bundle._digest}`);
+    return { exitCode: 0 };
+}
+function parseInspectArgs(args) {
+    const positionals = args.filter((arg) => !arg.startsWith('-'));
+    const input = positionals.at(0);
+    if (!input) {
+        return {
+            ok: false,
+            error: 'ERROR MISSING_INPUT Expected a runtime bundle file'
+        };
+    }
+    if (positionals.length > 1) {
+        return {
+            ok: false,
+            error: 'ERROR EXTRA_INPUT Expected exactly one runtime bundle file'
+        };
+    }
+    const unknown = args.find((arg) => arg.startsWith('-'));
+    if (unknown) {
+        return {
+            ok: false,
+            error: `ERROR UNKNOWN_OPTION Unknown option ${unknown}`
+        };
+    }
+    return { ok: true, input };
+}
+function parseBundle(path, source) {
+    const extension = extname(path).toLowerCase();
+    if (extension === '.json')
+        return fromJson(source);
+    if (extension === '.js')
+        return fromJs(source);
+    const error = new Error(`Unsupported runtime bundle extension for ${path}`);
+    Object.defineProperty(error, 'code', {
+        value: 'UNSUPPORTED_BUNDLE_FORMAT',
+        enumerable: true
+    });
+    throw error;
+}
+function validateDigest(bundle) {
+    if (bundle._format !== 'isostate-runtime-bundle' || !bundle._version) {
+        const error = new Error('Invalid runtime bundle identity fields');
+        Object.defineProperty(error, 'code', {
+            value: 'INVALID_RUNTIME_BUNDLE',
+            enumerable: true
+        });
+        throw error;
+    }
+    if (runtimeDigest(bundle) !== bundle._digest) {
+        const error = new Error('Invalid runtime bundle digest');
+        Object.defineProperty(error, 'code', {
+            value: 'INVALID_RUNTIME_BUNDLE_DIGEST',
+            enumerable: true
+        });
+        throw error;
+    }
+}
+
+const DEFAULT_PUBLIC_ASSET_BASE = './assets';
+const DEFAULT_SCENE_NAME = 'scene';
+const RUNTIME_FILE = 'isostate.runtime.js';
+const RUNTIME_SOURCE = new URL('../../core/dist/browser/isostate.runtime.js', import.meta.url);
+const PACKAGE_JSON = new URL('../package.json', import.meta.url);
+async function bundleCommand(args, io) {
+    const parsed = parseBundleArgs(args);
+    if (!parsed.ok) {
+        io.stderr.error(parsed.error);
+        return { exitCode: 1 };
+    }
+    const source = await readFile(parsed.input, 'utf8');
+    const document = parseScene(source);
+    const report = validateScene(document);
+    for (const warning of report.warnings) {
+        io.stderr.error(formatValidationWarning(warning));
+    }
+    if (!report.isValid) {
+        for (const error of report.errors) {
+            io.stderr.error(formatValidationError(error));
+        }
+        return { exitCode: 1 };
+    }
+    const bundle = compileScene(document);
+    const assetPlan = await planAssets(document, bundle, parsed);
+    const rewrittenBundle = rewriteAssetUrls(bundle, assetPlan);
+    const manifest = await createManifest(parsed, rewrittenBundle, assetPlan);
+    await writeBundleDirectory(parsed, rewrittenBundle, assetPlan, manifest);
+    io.stdout.log(`BUNDLED ${parsed.out}`);
+    return { exitCode: 0 };
+}
+function parseBundleArgs(args) {
+    const inputs = positionalArgs$1(args, new Set([
+        '--out',
+        '--asset-dir',
+        '--public-asset-base',
+        '--scene-name',
+        '--runtime'
+    ]));
+    const firstInput = inputs.at(0);
+    if (!firstInput) {
+        return {
+            ok: false,
+            error: 'ERROR MISSING_INPUT Expected an input .isostate.yaml file'
+        };
+    }
+    if (inputs.length > 1) {
+        return {
+            ok: false,
+            error: 'ERROR EXTRA_INPUT Expected exactly one input .isostate.yaml file'
+        };
+    }
+    const parsed = {
+        input: firstInput,
+        out: '',
+        assetDir: dirname(firstInput),
+        publicAssetBase: DEFAULT_PUBLIC_ASSET_BASE,
+        sceneName: DEFAULT_SCENE_NAME,
+        runtime: 'copy'
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg.startsWith('-'))
+            continue;
+        const value = args[index + 1];
+        if (!value || value.startsWith('-')) {
+            return {
+                ok: false,
+                error: `ERROR MISSING_OPTION ${arg} requires a value`
+            };
+        }
+        if (!applyBundleOption(parsed, arg, value)) {
+            return { ok: false, error: `ERROR UNKNOWN_OPTION Unknown option ${arg}` };
+        }
+        index += 1;
+    }
+    if (!parsed.out) {
+        return { ok: false, error: 'ERROR MISSING_OPTION --out requires a path' };
+    }
+    return { ok: true, ...parsed };
+}
+function applyBundleOption(args, option, value) {
+    switch (option) {
+        case '--out':
+            args.out = value;
+            return true;
+        case '--asset-dir':
+            args.assetDir = value;
+            return true;
+        case '--public-asset-base':
+            args.publicAssetBase = value;
+            return true;
+        case '--scene-name':
+            args.sceneName = value;
+            return true;
+        case '--runtime':
+            if (value !== 'copy' && value !== 'external' && value !== 'none') {
+                throw codedError('UNSUPPORTED_RUNTIME_MODE', `Unsupported runtime mode "${value}"`);
+            }
+            args.runtime = value;
+            return true;
+        default:
+            return false;
+    }
+}
+async function planAssets(document, bundle, args) {
+    const assetIds = Object.keys(bundle.assets ?? {}).sort();
+    const usedFiles = new Set();
+    const plans = [];
+    for (const id of assetIds) {
+        const source = resolveAssetSource(document, id, args.assetDir);
+        await assertSvgFile(id, source);
+        const file = uniqueAssetFile(id, basename(source), usedFiles);
+        plans.push({
+            id,
+            source,
+            file,
+            url: publicAssetUrl(args.publicAssetBase, file)
+        });
+    }
+    return plans;
+}
+function resolveAssetSource(document, id, assetDir) {
+    const entry = document.header.assets.find((asset) => asset.id === id);
+    if (!entry) {
+        throw codedError('ASSET_SOURCE_MISSING', `Asset "${id}" is not declared`);
+    }
+    const rawPath = entry.path ?? entry.id;
+    const withExtension = extname(rawPath) ? rawPath : `${rawPath}.svg`;
+    return isAbsolute(withExtension)
+        ? withExtension
+        : resolve(assetDir, withExtension);
+}
+async function assertSvgFile(id, source) {
+    if (extname(source).toLowerCase() !== '.svg') {
+        throw codedError('ASSET_NOT_SVG', `Asset "${id}" must resolve to an SVG file: ${source}`);
+    }
+    try {
+        const stats = await stat(source);
+        if (stats.isFile())
+            return;
+    }
+    catch {
+        throw codedError('ASSET_RESOLUTION_FAILED', `Unable to resolve asset "${id}" at ${source}`);
+    }
+    throw codedError('ASSET_NOT_FILE', `Asset "${id}" is not a file: ${source}`);
+}
+function uniqueAssetFile(id, sourceBasename, usedFiles) {
+    if (!usedFiles.has(sourceBasename)) {
+        usedFiles.add(sourceBasename);
+        return sourceBasename;
+    }
+    const candidate = `${id}-${sourceBasename}`;
+    usedFiles.add(candidate);
+    return candidate;
+}
+function rewriteAssetUrls(bundle, assetPlan) {
+    if (assetPlan.length === 0)
+        return bundle;
+    const assets = { ...(bundle.assets ?? {}) };
+    for (const asset of assetPlan) {
+        assets[asset.id] = { ...assets[asset.id], url: asset.url };
+    }
+    const rewritten = { ...bundle, assets };
+    return { ...rewritten, _digest: runtimeDigest(rewritten) };
+}
+async function createManifest(args, bundle, assetPlan) {
+    const assets = [];
+    for (const asset of assetPlan) {
+        const bytes = await readFile(asset.source);
+        assets.push({
+            id: asset.id,
+            source: slashPath(asset.source),
+            file: slashPath(join('assets', asset.file)),
+            url: asset.url,
+            digest: sha256Hex(bytes)
+        });
+    }
+    const runtime = args.runtime === 'copy'
+        ? { mode: args.runtime, file: RUNTIME_FILE }
+        : { mode: args.runtime };
+    return {
+        format: 'isostate-static-bundle',
+        version: await packageVersion(),
+        generatedAt: new Date().toISOString(),
+        source: { file: slashPath(args.input) },
+        runtime,
+        scene: {
+            file: `${args.sceneName}.isostate.js`,
+            format: 'js',
+            digest: bundle._digest
+        },
+        assets
+    };
+}
+async function writeBundleDirectory(args, bundle, assetPlan, manifest) {
+    const out = resolve(args.out);
+    const temporary = `${out}.tmp-${process.pid}-${Date.now()}`;
+    const backup = `${out}.bak-${process.pid}-${Date.now()}`;
+    try {
+        await rm(temporary, { recursive: true, force: true });
+        await rm(backup, { recursive: true, force: true });
+        await mkdir(join(temporary, 'assets'), { recursive: true });
+        await writeFile(join(temporary, `${args.sceneName}.isostate.js`), toJs(bundle), 'utf8');
+        await writeRuntimeArtifact(args.runtime, temporary);
+        await copyAssets(assetPlan, temporary);
+        await writeFile(join(temporary, 'manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+        let hasExistingOutput = false;
+        try {
+            await rename(out, backup);
+            hasExistingOutput = true;
+        }
+        catch (error) {
+            if (!isMissingPathError(error))
+                throw error;
+        }
+        try {
+            await rename(temporary, out);
+        }
+        catch (error) {
+            if (hasExistingOutput) {
+                await rename(backup, out);
+            }
+            throw error;
+        }
+        if (hasExistingOutput) {
+            await rm(backup, { recursive: true, force: true });
+        }
+    }
+    catch (error) {
+        await rm(temporary, { recursive: true, force: true });
+        await rm(backup, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function writeRuntimeArtifact(mode, outDir) {
+    if (mode !== 'copy')
+        return;
+    await copyFile(RUNTIME_SOURCE, join(outDir, RUNTIME_FILE));
+}
+async function copyAssets(assetPlan, outDir) {
+    for (const asset of assetPlan) {
+        await copyFile(asset.source, join(outDir, 'assets', asset.file));
+    }
+}
+async function packageVersion() {
+    const json = JSON.parse(await readFile(PACKAGE_JSON, 'utf8'));
+    return typeof json.version === 'string' ? json.version : '0.0.0';
+}
+function positionalArgs$1(args, optionsWithValues) {
+    const positionals = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined)
+            continue;
+        if (optionsWithValues.has(arg)) {
+            index += 1;
+            continue;
+        }
+        if (!arg.startsWith('-')) {
+            positionals.push(arg);
+        }
+    }
+    return positionals;
+}
+function publicAssetUrl(base, file) {
+    const trimmed = base.replace(/\/+$/, '');
+    return trimmed ? `${trimmed}/${file}` : file;
+}
+function slashPath(path) {
+    return path.split(sep).join('/');
+}
+function codedError(code, message) {
+    const error = new Error(message);
+    Object.defineProperty(error, 'code', { value: code, enumerable: true });
+    return error;
+}
+function isMissingPathError(error) {
+    return (error instanceof Error &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}
+
+const DEFAULT_OUT = 'build/scene.isostate.js';
+async function runCli(args, io = { stdout: console, stderr: console }) {
+    const [command, ...rest] = args;
+    try {
+        switch (command) {
+            case 'validate':
+                return await validateCommand(rest, io);
+            case 'compile':
+                return await compileCommand(rest, io);
+            case 'bundle':
+                return await bundleCommand(rest, io);
+            case 'inspect':
+                return await inspectCommand(rest, io);
+            case undefined:
+                io.stderr.error('ERROR MISSING_COMMAND Expected a command');
+                return { exitCode: 1 };
+            default:
+                io.stderr.error(`ERROR UNKNOWN_COMMAND Unknown command "${command}"`);
+                return { exitCode: 1 };
+        }
+    }
+    catch (error) {
+        io.stderr.error(formatThrownError(error));
+        return { exitCode: 1 };
+    }
+}
+async function validateCommand(args, io) {
+    const parsed = parseInputArgs(args);
+    if (!parsed.ok) {
+        io.stderr.error(parsed.error);
+        return { exitCode: 1 };
+    }
+    const source = await readInput(parsed.input);
+    const document = parseScene(source);
+    const report = validateScene(document);
+    for (const warning of report.warnings) {
+        io.stderr.error(formatValidationWarning(warning));
+    }
+    if (!report.isValid) {
+        for (const error of report.errors) {
+            io.stderr.error(formatValidationError(error));
+        }
+        return { exitCode: 1 };
+    }
+    io.stdout.log(`OK ${parsed.input} (${report.errors.length} errors, ${report.warnings.length} warnings)`);
+    return { exitCode: 0 };
+}
+async function compileCommand(args, io) {
+    const parsed = parseCompileArgs(args);
+    if (!parsed.ok) {
+        io.stderr.error(parsed.error);
+        return { exitCode: 1 };
+    }
+    const source = await readInput(parsed.input);
+    const document = parseScene(source);
+    const report = validateScene(document);
+    for (const warning of report.warnings) {
+        io.stderr.error(formatValidationWarning(warning));
+    }
+    if (!report.isValid) {
+        for (const error of report.errors) {
+            io.stderr.error(formatValidationError(error));
+        }
+        return { exitCode: 1 };
+    }
+    const bundle = compileScene(document);
+    const output = parsed.format === 'js'
+        ? toJs(bundle, { minify: !parsed.pretty })
+        : toJson(bundle);
+    await writeAtomic(parsed.out, output);
+    io.stdout.log(`WROTE ${parsed.out}`);
+    return { exitCode: 0 };
+}
+function parseInputArgs(args) {
+    const unknown = args.find((arg) => arg.startsWith('-'));
+    if (unknown) {
+        return {
+            ok: false,
+            error: `ERROR UNKNOWN_OPTION Unknown option ${unknown}`
+        };
+    }
+    const positionals = positionalArgs(args, new Set());
+    const input = positionals.at(0);
+    if (!input) {
+        return {
+            ok: false,
+            error: 'ERROR MISSING_INPUT Expected an input .isostate.yaml file'
+        };
+    }
+    if (positionals.length > 1) {
+        return {
+            ok: false,
+            error: 'ERROR EXTRA_INPUT Expected exactly one input .isostate.yaml file'
+        };
+    }
+    return { ok: true, input };
+}
+function parseCompileArgs(args) {
+    const input = positionalArgs(args, new Set(['--out', '--format'])).at(0);
+    const positionals = positionalArgs(args, new Set(['--out', '--format']));
+    if (!input) {
+        return {
+            ok: false,
+            error: 'ERROR MISSING_INPUT Expected an input .isostate.yaml file'
+        };
+    }
+    if (positionals.length > 1) {
+        return {
+            ok: false,
+            error: 'ERROR EXTRA_INPUT Expected exactly one input .isostate.yaml file'
+        };
+    }
+    let out = DEFAULT_OUT;
+    let format;
+    let pretty = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--pretty') {
+            pretty = true;
+            continue;
+        }
+        if (arg === '--out') {
+            const value = args[index + 1];
+            if (!value || value.startsWith('-')) {
+                return {
+                    ok: false,
+                    error: 'ERROR MISSING_OPTION --out requires a path'
+                };
+            }
+            out = value;
+            index += 1;
+            continue;
+        }
+        if (arg === '--format') {
+            const value = args[index + 1];
+            if (!value || value.startsWith('-')) {
+                return {
+                    ok: false,
+                    error: 'ERROR MISSING_OPTION --format requires js or json'
+                };
+            }
+            format = value;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            return { ok: false, error: `ERROR UNKNOWN_OPTION Unknown option ${arg}` };
+        }
+    }
+    const inferredFormat = format ?? inferFormat(out);
+    if (inferredFormat !== 'js' && inferredFormat !== 'json') {
+        return {
+            ok: false,
+            error: `ERROR UNSUPPORTED_FORMAT Unsupported format "${inferredFormat}"`
+        };
+    }
+    return { ok: true, input, out, format: inferredFormat, pretty };
+}
+function positionalArgs(args, optionsWithValues) {
+    const positionals = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === undefined)
+            continue;
+        if (optionsWithValues.has(arg)) {
+            index += 1;
+            continue;
+        }
+        if (!arg.startsWith('-')) {
+            positionals.push(arg);
+        }
+    }
+    return positionals;
+}
+function inferFormat(out) {
+    const extension = extname(out).toLowerCase();
+    if (extension === '.json')
+        return 'json';
+    return 'js';
+}
+async function readInput(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        throw wrapFsError('FILE_READ_FAILED', `Unable to read ${path}`, error);
+    }
+}
+async function writeAtomic(path, contents) {
+    const absolute = resolve(path);
+    const directory = dirname(absolute);
+    const temporary = `${absolute}.tmp-${process.pid}-${Date.now()}`;
+    try {
+        await mkdir(directory, { recursive: true });
+        await writeFile(temporary, contents, 'utf8');
+        await rename(temporary, absolute);
+    }
+    catch (error) {
+        await rm(temporary, { force: true });
+        throw wrapFsError('FILE_WRITE_FAILED', `Unable to write ${path}`, error);
+    }
+}
+function wrapFsError(code, message, cause) {
+    const error = new Error(message);
+    Object.defineProperty(error, 'code', { value: code, enumerable: true });
+    Object.defineProperty(error, 'cause', { value: cause });
+    return error;
+}
+
+const result = await runCli(process.argv.slice(2));
+process.exitCode = result.exitCode;
+//# sourceMappingURL=bin.js.map