@gjsify/cli 0.3.21 → 0.4.0

package/src/commands/gettext.ts

@@ -1,258 +0,0 @@
-import { execFile } from 'node:child_process';
-import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import { promisify } from 'node:util';
-import type { Command } from '../types/index.js';
-
-const execFileAsync = promisify(execFile);
-
-type GettextFormat = 'mo' | 'xml' | 'desktop' | 'json';
-
-interface GettextOptions {
-    poDir: string;
-    outDir: string;
-    domain: string;
-    format?: GettextFormat;
-    metainfo?: string;
-    filename?: string;
-    removeXmlComments?: boolean;
-    verbose?: boolean;
-}
-
-async function listLanguages(poDir: string): Promise<string[]> {
-    const entries = await readdir(poDir);
-    return entries
-        .filter((name) => name.endsWith('.po') && !name.startsWith('.'))
-        .map((name) => name.slice(0, -3))
-        .sort();
-}
-
-function stripXmlComments(source: string): string {
-    return source.replace(/<!--[\s\S]*?-->/g, '');
-}
-
-async function ensureDir(path: string): Promise<void> {
-    await mkdir(path, { recursive: true });
-}
-
-async function fileExists(path: string): Promise<boolean> {
-    try {
-        await stat(path);
-        return true;
-    } catch {
-        return false;
-    }
-}
-
-async function compileBulkXml(opts: {
-    poDir: string;
-    outDir: string;
-    domain: string;
-    template: string;
-    filename: string;
-    removeXmlComments: boolean;
-    verbose: boolean;
-}): Promise<void> {
-    const outputFile = join(opts.outDir, opts.filename);
-    await ensureDir(opts.outDir);
-
-    const args = [
-        `--output-file=${outputFile}`,
-        '--xml',
-        `--template=${opts.template}`,
-        '-d',
-        opts.poDir,
-    ];
-
-    if (opts.verbose) {
-        console.log(`[gjsify gettext] msgfmt ${args.join(' ')}`);
-    }
-
-    await execFileAsync('msgfmt', args);
-
-    if (opts.removeXmlComments) {
-        const content = await readFile(outputFile, 'utf-8');
-        await writeFile(outputFile, stripXmlComments(content));
-    }
-
-    if (opts.verbose) {
-        console.log(`[gjsify gettext] wrote ${outputFile}`);
-    }
-}
-
-async function compilePerLanguage(opts: {
-    poDir: string;
-    outDir: string;
-    domain: string;
-    format: GettextFormat;
-    filename: string;
-    verbose: boolean;
-}): Promise<void> {
-    const languages = await listLanguages(opts.poDir);
-    if (languages.length === 0) {
-        console.warn(`[gjsify gettext] no .po files found in ${opts.poDir}`);
-        return;
-    }
-
-    for (const lang of languages) {
-        const poFile = join(opts.poDir, `${lang}.po`);
-        const langDir =
-            opts.format === 'mo'
-                ? join(opts.outDir, lang, 'LC_MESSAGES')
-                : join(opts.outDir, lang);
-        await ensureDir(langDir);
-        const outputFile = join(langDir, opts.filename);
-
-        // msgfmt produces the binary .mo format by default — there is no
-        // `--mo` flag (only --xml, --desktop, --properties-output, ...).
-        const args = [`--output-file=${outputFile}`];
-        if (opts.format !== 'mo') {
-            args.push(`--${opts.format}`);
-        }
-        args.push(poFile);
-
-        if (opts.verbose) {
-            console.log(`[gjsify gettext] msgfmt ${args.join(' ')}`);
-        }
-
-        await execFileAsync('msgfmt', args);
-    }
-
-    if (opts.verbose) {
-        console.log(
-            `[gjsify gettext] compiled ${languages.length} language(s) into ${opts.outDir}`,
-        );
-    }
-}
-
-function defaultFilename(domain: string, format: GettextFormat, metainfoTemplate?: string): string {
-    switch (format) {
-        case 'mo':
-            return `${domain}.mo`;
-        case 'json':
-            return `${domain}.json`;
-        case 'desktop':
-            return `${domain}.desktop`;
-        case 'xml': {
-            // Mirror the template filename but without the trailing `.in` (convention for
-            // pre-processed metainfo templates: `org.foo.Bar.metainfo.xml.in`).
-            if (metainfoTemplate) {
-                const base = metainfoTemplate.replace(/\.in$/, '');
-                const slash = base.lastIndexOf('/');
-                return slash >= 0 ? base.slice(slash + 1) : base;
-            }
-            return `${domain}.xml`;
-        }
-    }
-}
-
-export const gettextCommand: Command<any, GettextOptions> = {
-    command: 'gettext <poDir> <outDir>',
-    description:
-        'Compile gettext .po files to .mo (per-language locale tree) or substitute a metainfo template via msgfmt --xml.',
-    builder: (yargs) => {
-        return yargs
-            .positional('poDir', {
-                description: 'Directory containing <lang>.po files',
-                type: 'string',
-                normalize: true,
-                demandOption: true,
-            })
-            .positional('outDir', {
-                description:
-                    'Output directory (locale tree for --format=mo, plain dir for xml/desktop/json)',
-                type: 'string',
-                normalize: true,
-                demandOption: true,
-            })
-            .option('domain', {
-                description: 'Text domain / application ID (e.g. `org.pixelrpg.maker`)',
-                type: 'string',
-                normalize: true,
-                demandOption: true,
-            })
-            .option('format', {
-                description: 'Output format',
-                type: 'string',
-                choices: ['mo', 'xml', 'desktop', 'json'] as const,
-                default: 'mo' as const,
-            })
-            .option('metainfo', {
-                description:
-                    'For --format=xml: path to the template (`.metainfo.xml.in`) used as msgfmt --template',
-                type: 'string',
-                normalize: true,
-            })
-            .option('filename', {
-                description: 'Override the output filename (defaults to <domain>.<ext>)',
-                type: 'string',
-                normalize: true,
-            })
-            .option('remove-xml-comments', {
-                description: 'For --format=xml: strip XML comments from the compiled output',
-                type: 'boolean',
-                default: true,
-            })
-            .option('verbose', {
-                description: 'Print each msgfmt invocation',
-                type: 'boolean',
-                default: false,
-            });
-    },
-    handler: async (args) => {
-        const poDir = resolve(args.poDir as string);
-        const outDir = resolve(args.outDir as string);
-        const domain = args.domain as string;
-        const format = (args.format as GettextFormat | undefined) ?? 'mo';
-        const metainfo = args.metainfo ? resolve(args.metainfo as string) : undefined;
-        const filename = args.filename ?? defaultFilename(domain, format, metainfo);
-        const verbose = !!args.verbose;
-        const removeXmlComments = !!args['remove-xml-comments'];
-
-        if (!(await fileExists(poDir))) {
-            console.error(`[gjsify gettext] PO directory does not exist: ${poDir}`);
-            process.exitCode = 1;
-            return;
-        }
-
-        try {
-            if (format === 'xml' && metainfo) {
-                await compileBulkXml({
-                    poDir,
-                    outDir,
-                    domain,
-                    template: metainfo,
-                    filename,
-                    removeXmlComments,
-                    verbose,
-                });
-            } else {
-                if (format === 'xml') {
-                    console.warn(
-                        '[gjsify gettext] --format=xml without --metainfo: falling back to per-language XML files',
-                    );
-                }
-                await compilePerLanguage({
-                    poDir,
-                    outDir,
-                    domain,
-                    format,
-                    filename,
-                    verbose,
-                });
-            }
-        } catch (err: any) {
-            if (err?.code === 'ENOENT') {
-                console.error(
-                    '[gjsify gettext] msgfmt not found. Install it via your distro (package: gettext).',
-                );
-            } else {
-                if (err?.stderr) process.stderr.write(err.stderr);
-                console.error(
-                    `[gjsify gettext] msgfmt failed${err?.code !== undefined ? ` (exit ${err.code})` : ''}`,
-                );
-            }
-            process.exitCode = typeof err?.code === 'number' ? err.code : 1;
-        }
-    },
-};

package/src/commands/gresource.ts

@@ -1,97 +0,0 @@
-import { execFile } from 'node:child_process';
-import { mkdir } from 'node:fs/promises';
-import { basename, dirname, extname, resolve } from 'node:path';
-import { promisify } from 'node:util';
-import type { Command } from '../types/index.js';
-
-const execFileAsync = promisify(execFile);
-
-interface GResourceOptions {
-    xml: string;
-    sourcedir?: string;
-    target?: string;
-    verbose?: boolean;
-}
-
-/**
- * Derive a default `.gresource` target path from the XML descriptor.
- * `foo.gresource.xml` → `foo.gresource` in the same directory.
- */
-function defaultTargetFor(xmlPath: string): string {
-    const ext = extname(xmlPath);
-    const stem = basename(xmlPath, ext);
-    return resolve(dirname(xmlPath), stem);
-}
-
-export const gresourceCommand: Command<any, GResourceOptions> = {
-    command: 'gresource <xml>',
-    description:
-        'Compile a GResource XML descriptor into a binary .gresource bundle (wraps `glib-compile-resources`).',
-    builder: (yargs) => {
-        return yargs
-            .positional('xml', {
-                description: 'Path to the .gresource.xml descriptor',
-                type: 'string',
-                normalize: true,
-                demandOption: true,
-            })
-            .option('sourcedir', {
-                description: 'Directory containing the resource files referenced by <xml>',
-                type: 'string',
-                normalize: true,
-            })
-            .option('target', {
-                alias: 't',
-                description: 'Output .gresource file (default: <xml-without-.xml> next to <xml>)',
-                type: 'string',
-                normalize: true,
-            })
-            .option('verbose', {
-                description: 'Print the underlying glib-compile-resources invocation',
-                type: 'boolean',
-                default: false,
-            });
-    },
-    handler: async (args) => {
-        const xmlPath = resolve(args.xml as string);
-        const target = args.target ? resolve(args.target as string) : defaultTargetFor(xmlPath);
-        const sourcedir = args.sourcedir
-            ? resolve(args.sourcedir as string)
-            : dirname(xmlPath);
-
-        const cmdArgs = [
-            `--sourcedir=${sourcedir}`,
-            `--target=${target}`,
-            xmlPath,
-        ];
-
-        if (args.verbose) {
-            console.log(`[gjsify gresource] glib-compile-resources ${cmdArgs.join(' ')}`);
-        }
-
-        // Ensure the target directory exists — glib-compile-resources writes
-        // a temporary file next to the target and fails with ENOENT otherwise.
-        await mkdir(dirname(target), { recursive: true });
-
-        try {
-            const { stdout, stderr } = await execFileAsync('glib-compile-resources', cmdArgs);
-            if (stdout) process.stdout.write(stdout);
-            if (stderr) process.stderr.write(stderr);
-            if (args.verbose) {
-                console.log(`[gjsify gresource] wrote ${target}`);
-            }
-        } catch (err: any) {
-            if (err?.code === 'ENOENT') {
-                console.error(
-                    '[gjsify gresource] glib-compile-resources not found. Install it via your distro (package: glib2-devel / libglib2.0-dev).',
-                );
-            } else {
-                if (err?.stderr) process.stderr.write(err.stderr);
-                console.error(
-                    `[gjsify gresource] glib-compile-resources failed${err?.code !== undefined ? ` (exit ${err.code})` : ''}`,
-                );
-            }
-            process.exitCode = typeof err?.code === 'number' ? err.code : 1;
-        }
-    },
-};

package/src/commands/gsettings.ts

@@ -1,87 +0,0 @@
-import { execFile } from 'node:child_process';
-import { mkdir } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { promisify } from 'node:util';
-import type { Command } from '../types/index.js';
-
-const execFileAsync = promisify(execFile);
-
-interface GSettingsOptions {
-    schemadir: string;
-    targetdir?: string;
-    strict?: boolean;
-    verbose?: boolean;
-}
-
-export const gsettingsCommand: Command<any, GSettingsOptions> = {
-    command: 'gsettings <schemadir>',
-    description:
-        'Compile GSettings schema XML files into a binary gschemas.compiled (wraps `glib-compile-schemas`).',
-    builder: (yargs) => {
-        return yargs
-            .positional('schemadir', {
-                description: 'Directory containing *.gschema.xml descriptors',
-                type: 'string',
-                normalize: true,
-                demandOption: true,
-            })
-            .option('targetdir', {
-                alias: 't',
-                description:
-                    'Directory to write gschemas.compiled (default: <schemadir>)',
-                type: 'string',
-                normalize: true,
-            })
-            .option('strict', {
-                description:
-                    'Abort on any schema warning (passes --strict to glib-compile-schemas)',
-                type: 'boolean',
-                default: true,
-            })
-            .option('verbose', {
-                description: 'Print the underlying glib-compile-schemas invocation',
-                type: 'boolean',
-                default: false,
-            });
-    },
-    handler: async (args) => {
-        const schemadir = resolve(args.schemadir as string);
-        const targetdir = args.targetdir
-            ? resolve(args.targetdir as string)
-            : schemadir;
-
-        const cmdArgs: string[] = [];
-        if (args.strict) cmdArgs.push('--strict');
-        cmdArgs.push(`--targetdir=${targetdir}`);
-        cmdArgs.push(schemadir);
-
-        if (args.verbose) {
-            console.log(`[gjsify gsettings] glib-compile-schemas ${cmdArgs.join(' ')}`);
-        }
-
-        // glib-compile-schemas writes a temporary file in `targetdir` before
-        // renaming to gschemas.compiled — fails with ENOENT if missing.
-        await mkdir(targetdir, { recursive: true });
-
-        try {
-            const { stdout, stderr } = await execFileAsync('glib-compile-schemas', cmdArgs);
-            if (stdout) process.stdout.write(stdout);
-            if (stderr) process.stderr.write(stderr);
-            if (args.verbose) {
-                console.log(`[gjsify gsettings] wrote ${targetdir}/gschemas.compiled`);
-            }
-        } catch (err: any) {
-            if (err?.code === 'ENOENT') {
-                console.error(
-                    '[gjsify gsettings] glib-compile-schemas not found. Install it via your distro (package: glib2-devel / libglib2.0-dev).',
-                );
-            } else {
-                if (err?.stderr) process.stderr.write(err.stderr);
-                console.error(
-                    `[gjsify gsettings] glib-compile-schemas failed${err?.code !== undefined ? ` (exit ${err.code})` : ''}`,
-                );
-            }
-            process.exitCode = typeof err?.code === 'number' ? err.code : 1;
-        }
-    },
-};

package/src/commands/index.ts

@@ -1,12 +0,0 @@
-export * from './build.js';
-export * from './run.js';
-export * from './info.js';
-export * from './check.js';
-export * from './showcase.js';
-export * from './create.js';
-export * from './gresource.js';
-export * from './gettext.js';
-export * from './gsettings.js';
-export { flatpakCommand } from './flatpak/index.js';
-export * from './dlx.js';
-export * from './install.js';

package/src/commands/info.ts

@@ -1,70 +0,0 @@
-import { resolve } from 'node:path';
-import type { Command } from '../types/index.js';
-import { detectNativePackages, buildNativeEnv } from '../utils/detect-native-packages.js';
-
-interface InfoOptions {
-    export: boolean;
-    file?: string;
-}
-
-export const infoCommand: Command<any, InfoOptions> = {
-    command: 'info [file]',
-    description: 'Show native gjsify packages detected in node_modules and the env vars needed to run a GJS bundle directly with gjs.',
-    builder: (yargs) => {
-        return yargs
-            .positional('file', {
-                description: 'Optional: the GJS bundle path to include in the example command (e.g. dist/gjs.js)',
-                type: 'string',
-                normalize: true,
-            })
-            .option('export', {
-                description: 'Output only shell export statements suitable for eval (eval $(gjsify info --export))',
-                type: 'boolean',
-                default: false,
-            });
-    },
-    handler: async (args) => {
-        const cwd = process.cwd();
-        const file = args.file ? resolve(args.file as string) : null;
-        const nativePackages = detectNativePackages(cwd);
-        const { LD_LIBRARY_PATH, GI_TYPELIB_PATH } = buildNativeEnv(nativePackages);
-
-        if (args.export) {
-            // Machine-readable output for eval
-            console.log(`export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}"`);
-            console.log(`export GI_TYPELIB_PATH="${GI_TYPELIB_PATH}"`);
-            return;
-        }
-
-        // Human-readable output
-        if (nativePackages.length === 0) {
-            console.log('No native gjsify packages detected in node_modules.');
-            console.log('Native packages declare "gjsify": { "prebuilds": "<dir>" } in their package.json.');
-            return;
-        }
-
-        console.log('Native packages detected:');
-        for (const pkg of nativePackages) {
-            console.log(`  ${pkg.name}  →  ${pkg.prebuildsDir}`);
-        }
-
-        console.log('');
-        console.log('To run your app directly with gjs, set:');
-        console.log(`  export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}"`);
-        console.log(`  export GI_TYPELIB_PATH="${GI_TYPELIB_PATH}"`);
-
-        if (file) {
-            console.log(`  gjs -m ${file}`);
-        } else {
-            console.log('  gjs -m <your-bundle.js>');
-        }
-
-        console.log('');
-        console.log('Or use gjsify run to handle this automatically:');
-        if (file) {
-            console.log(`  gjsify run ${args.file}`);
-        } else {
-            console.log('  gjsify run <your-bundle.js>');
-        }
-    },
-};