@gjsify/cli 0.64.17-next.292 → 0.64.18

package/lib/actions/build.d.ts

@@ -110,6 +110,8 @@ export declare class BuildAction {
      * its typelibs can still be fixed by installing a package; an APK carries its
      * whole GI stack or does without it.
      */
+    /** The app's `dependencies` + `devDependencies` names; `[]` without a readable manifest. */
+    private appDependencyNames;
     private assertNativescriptGiSelected;
     /**
      * Post-bundle step for a `--app browser` HTML entry: write the processed

package/lib/actions/build.js

@@ -1,5 +1,5 @@
 import { runBundle, runWatch, bundleToChunks } from '../bundler-pick.js';
-import { gjsifyPlugin, textLoaderPlugin, resolveShebangLine, NODE_SHEBANG, createGjsExternalsPredicate, globToEntryPoints, scanGiNamespaces, planGiSelection, WorkerEntries, bundleSuffix, } from '@gjsify/rolldown-plugin-gjsify';
+import { gjsifyPlugin, textLoaderPlugin, resolveShebangLine, NODE_SHEBANG, createGjsExternalsPredicate, globToEntryPoints, scanGiNamespaces, planGiSelection, planGiAddons, WorkerEntries, bundleSuffix, } from '@gjsify/rolldown-plugin-gjsify';
 import { isGjs } from '@gjsify/rolldown-plugin-gjsify/runtime';
 import { resolveUserPlugins } from '../utils/resolve-plugin-by-name.js';
 import { resolveGlobalsList, writeRegisterInjectFile, detectAutoGlobals, detectNodeGiGlobals, } from '@gjsify/rolldown-plugin-gjsify/globals';
@@ -454,7 +454,17 @@ export class BuildAction {
      * its typelibs can still be fixed by installing a package; an APK carries its
      * whole GI stack or does without it.
      */
-    assertNativescriptGiSelected(result, outfile, outdir) {
+    /** The app's `dependencies` + `devDependencies` names; `[]` without a readable manifest. */
+    async appDependencyNames() {
+        try {
+            const manifest = JSON.parse(await readFile(join(process.cwd(), 'package.json'), 'utf-8'));
+            return [...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.devDependencies ?? {})];
+        }
+        catch {
+            return [];
+        }
+    }
+    async assertNativescriptGiSelected(result, outfile, outdir) {
         const label = outfile ?? outdir ?? 'the nativescript bundle';
         const scanned = new Set();
         for (const item of result.output ?? []) {
@@ -478,6 +488,12 @@ export class BuildAction {
             // the namespaces but not which file they were read from.
             throw new Error(`gjsify build: ${label}: ${error.message}`);
         }
+        try {
+            planGiAddons({ selected: selection.selected, installed: await this.appDependencyNames() });
+        }
+        catch (error) {
+            throw new Error(`gjsify build: ${label}: ${error.message}`);
+        }
         for (const namespace of selection.unscanned) {
             console.warn(`[gjsify] --app nativescript: nativescript.giNamespaces declares ${namespace}, which ` +
                 `${label} does not appear to import. The APK carries it anyway — drop it if nothing ` +
@@ -916,7 +932,7 @@ export class BuildAction {
         // package-build time (ADR 0117), so there is no host to fall back on: the
         // alternative to this gate is an APK that installs and throws at the import.
         if (app === 'nativescript') {
-            this.assertNativescriptGiSelected(writeResult, outfile, outdir);
+            await this.assertNativescriptGiSelected(writeResult, outfile, outdir);
         }
         // Browser HTML entry: emit the processed `index.html` beside the bundle
         // (engine-portable post-step — the native rolldown engine has no

package/lib/cli-app.js

@@ -18,7 +18,7 @@
 import yargs from 'yargs';
 import { classifyCliFailure } from './cli-fail.js';
 import { cliVersion } from './utils/publish-headers.js';
-import { buildCommand as build, clearCommand as clear, copyCommand as copy, envCommand as env, execCommand as exec, testCommand as test, runCommand as run, infoCommand as info, systemCheckCommand as systemCheck, checkCommand as check, showcaseCommand as showcase, createCommand as create, gresourceCommand as gresource, gettextCommand as gettext, gsettingsCommand as gsettings, flatpakCommand as flatpak, shipCommand as ship, dlxCommand as dlx, installCommand as install, linkCommand as link, unlinkCommand as unlink, foreachCommand as foreach, workspaceCommand as workspace, packCommand as pack, publishCommand as publish, whoamiCommand as whoami, releaseNotesCommand as releaseNotes, loginCommand as login, logoutCommand as logout, trustCommand as trust, onboardCommand as onboard, selfUpdateCommand as selfUpdate, generateInstallerCommand as generateInstaller, pruneCommand as prune, uninstallCommand as uninstall, formatCommand as format, lintCommand as lint, fixCommand as fix, upgradeCommand as upgrade, barrelsCommand as barrels, tscCommand as tsc, affectedCommand as affected, storybookCommand as storybook, siteCommand as site, devCommand as dev, debugCommand as debug, devtoolsCommand as devtools, browseCommand as browse, webextCommand as webext, blueprintCommand as blueprint, } from './commands/index.js';
+import { buildCommand as build, clearCommand as clear, copyCommand as copy, envCommand as env, execCommand as exec, testCommand as test, runCommand as run, infoCommand as info, systemCheckCommand as systemCheck, checkCommand as check, showcaseCommand as showcase, createCommand as create, gresourceCommand as gresource, gettextCommand as gettext, gsettingsCommand as gsettings, flatpakCommand as flatpak, shipCommand as ship, dlxCommand as dlx, installCommand as install, linkCommand as link, unlinkCommand as unlink, foreachCommand as foreach, workspaceCommand as workspace, packCommand as pack, publishCommand as publish, whoamiCommand as whoami, releaseNotesCommand as releaseNotes, androidIconsCommand as androidIcons, creditsCommand as credits, loginCommand as login, logoutCommand as logout, trustCommand as trust, onboardCommand as onboard, selfUpdateCommand as selfUpdate, generateInstallerCommand as generateInstaller, pruneCommand as prune, uninstallCommand as uninstall, formatCommand as format, lintCommand as lint, fixCommand as fix, upgradeCommand as upgrade, barrelsCommand as barrels, tscCommand as tsc, affectedCommand as affected, storybookCommand as storybook, siteCommand as site, devCommand as dev, debugCommand as debug, devtoolsCommand as devtools, browseCommand as browse, webextCommand as webext, blueprintCommand as blueprint, } from './commands/index.js';
 import { APP_NAME } from './constants.js';
 import { isBun, isDeno, isNode, gjsSystemVersion } from '@gjsify/rolldown-plugin-gjsify/runtime';
 import { ensureGjsifyShimOnPath } from './utils/gjsify-shim.js';
@@ -118,6 +118,8 @@ export async function runCli(argv) {
         .command(publish.command, publish.description, publish.builder, publish.handler)
         .command(whoami.command, whoami.description, whoami.builder, whoami.handler)
         .command(releaseNotes.command, releaseNotes.description, releaseNotes.builder, releaseNotes.handler)
+        .command(androidIcons.command, androidIcons.description, androidIcons.builder, androidIcons.handler)
+        .command(credits.command, credits.description, credits.builder, credits.handler)
         .command(login.command, login.description, login.builder, login.handler)
         .command(logout.command, logout.description, logout.builder, logout.handler)
         .command(trust.command, trust.description, trust.builder, trust.handler)

package/lib/commands/android-icons.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from '../types/index.js';
+interface AndroidIconsOptions {
+    resources?: string;
+    icon?: string;
+    background?: string;
+    check?: boolean;
+}
+export declare const androidIconsCommand: Command<unknown, AndroidIconsOptions>;
+export {};

package/lib/commands/android-icons.js

@@ -0,0 +1,164 @@
+// `gjsify android-icons [--resources <dir>] [--icon <svg>] [--background <colour>] [--check]`
+//
+// Writes the Android launcher icon and splash logo of a NativeScript app from the
+// ONE app icon the GNOME way already declares, so no app hand-maintains rasters.
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { Config } from '../config.js';
+import { ANDROID_ICONS_STAMP, buildStamp, checkStamp, hashInputs, parseMetainfoBranding, pickIconSources, planAndroidIcons, resolveBackground, resolveResourcesName, symbolicSibling, wrapperSvg, } from '../utils/ship/android-icons.js';
+import { rasterizeSvg } from '../utils/ship/icons.js';
+const RES_PREFIX = 'Android/src/main/res';
+function walk(dir, out = []) {
+    if (!existsSync(dir))
+        return out;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory())
+            walk(full, out);
+        else
+            out.push(full);
+    }
+    return out;
+}
+function discoverIcon(projectDir, flag) {
+    if (flag !== undefined) {
+        const icon = resolve(projectDir, flag);
+        if (!existsSync(icon))
+            throw new Error(`the icon ${flag} does not exist`);
+        const sibling = symbolicSibling(icon);
+        return { icon, symbolic: existsSync(sibling) ? sibling : null };
+    }
+    // The app's own `data/` first, then the sibling GNOME package of a monorepo.
+    const roots = [join(projectDir, 'data', 'icons'), ...siblingIconRoots(projectDir)];
+    for (const root of roots) {
+        const found = pickIconSources(walk(root)
+            .filter((f) => f.toLowerCase().endsWith('.svg'))
+            .sort());
+        if (found.icon !== null)
+            return { icon: found.icon, symbolic: found.symbolic };
+    }
+    throw new Error('no app icon found; pass --icon <svg> or set `gjsify.androidIcons.icon`');
+}
+function siblingIconRoots(projectDir) {
+    const parent = dirname(projectDir);
+    if (!existsSync(parent))
+        return [];
+    return readdirSync(parent)
+        .sort()
+        .map((name) => join(parent, name, 'data', 'icons'))
+        .filter((dir) => dir !== join(projectDir, 'data', 'icons') && existsSync(dir) && statSync(dir).isDirectory());
+}
+function findMetainfoColor(iconPath, projectDir) {
+    const roots = new Set([join(projectDir, 'data')]);
+    // `<pkg>/data/icons/hicolor/scalable/apps/<id>.svg` → `<pkg>/data`
+    roots.add(resolve(dirname(iconPath), '..', '..', '..', '..'));
+    for (const root of roots) {
+        const files = walk(join(root, 'metainfo'))
+            .filter((f) => /\.metainfo\.xml(\.in)?$/.test(f))
+            .sort();
+        for (const file of files) {
+            const color = parseMetainfoBranding(readFileSync(file, 'utf8'));
+            if (color !== null)
+                return color;
+        }
+    }
+    return null;
+}
+export const androidIconsCommand = {
+    command: 'android-icons',
+    description: 'Generate the Android launcher icon and splash logo of a NativeScript app from its one app icon.',
+    builder: (yargs) => yargs
+        .option('resources', {
+        description: 'The App_Resources directory. Default: `gjsify.androidIcons.resources`, else `appResourcesPath` of nativescript.config.ts, else App_Resources.',
+        type: 'string',
+    })
+        .option('icon', {
+        description: 'The scalable app icon SVG. Default: `gjsify.androidIcons.icon`, else the hicolor icon under data/icons (here or in a sibling package).',
+        type: 'string',
+    })
+        .option('background', {
+        description: 'Adaptive-icon background colour. Default: `gjsify.androidIcons.background`, else the metainfo light `<branding>` colour, else white.',
+        type: 'string',
+    })
+        .option('check', {
+        description: 'Write nothing; exit 1 when the generated files are missing or the inputs changed.',
+        type: 'boolean',
+        default: false,
+    }),
+    handler: async (args) => {
+        const projectDir = process.cwd();
+        try {
+            const config = (await new Config().forCommand(projectDir)).androidIcons ?? {};
+            const nsConfigPath = ['nativescript.config.ts', 'nativescript.config.js']
+                .map((name) => join(projectDir, name))
+                .find((file) => existsSync(file));
+            const resourcesName = resolveResourcesName({
+                flag: args.resources,
+                configured: config.resources,
+                nativescriptConfig: nsConfigPath === undefined ? null : readFileSync(nsConfigPath, 'utf8'),
+            });
+            const resources = resolve(projectDir, resourcesName);
+            const { icon, symbolic } = discoverIcon(projectDir, args.icon ?? config.icon);
+            const background = resolveBackground({
+                flag: args.background,
+                configured: config.background,
+                fromMetainfo: findMetainfoColor(icon, projectDir),
+            });
+            const iconBytes = new Uint8Array(readFileSync(icon));
+            const symbolicBytes = symbolic === null ? null : new Uint8Array(readFileSync(symbolic));
+            const inputs = hashInputs({ icon: iconBytes, symbolic: symbolicBytes, background });
+            const plan = planAndroidIcons({ background, monochrome: symbolicBytes !== null });
+            const stampPath = join(resources, ANDROID_ICONS_STAMP);
+            if (args.check === true) {
+                const verdict = checkStamp(existsSync(stampPath) ? readFileSync(stampPath, 'utf8') : null, inputs, (rel) => existsSync(join(resources, ...rel.split('/'))));
+                if (!verdict.current) {
+                    process.stderr.write(`gjsify android-icons: ${resourcesName} ${verdict.reason}; run \`gjsify android-icons\` and commit it\n`);
+                    return process.exit(1);
+                }
+                return;
+            }
+            const res = join(resources, ...RES_PREFIX.split('/'));
+            const tmp = mkdtempSync(join(tmpdir(), 'gjsify-android-icons-'));
+            try {
+                const sources = new Map([['plain', icon]]);
+                for (const kind of ['round', 'foreground']) {
+                    const file = join(tmp, `${kind}.svg`);
+                    writeFileSync(file, wrapperSvg(kind, iconBytes, background));
+                    sources.set(kind, file);
+                }
+                if (symbolicBytes !== null) {
+                    const file = join(tmp, 'monochrome.svg');
+                    writeFileSync(file, wrapperSvg('monochrome', symbolicBytes, background));
+                    sources.set('monochrome', file);
+                }
+                for (const [kind, svg] of sources) {
+                    const wanted = plan.png.filter((p) => kind === 'plain' ? p.kind === 'legacy' || p.kind === 'splash' : p.kind === kind);
+                    const sizes = [...new Set(wanted.map((p) => p.size))];
+                    const rendered = await rasterizeSvg({ svg, sizes, command: 'gjsify android-icons' });
+                    for (const spec of wanted) {
+                        const target = join(res, spec.path);
+                        mkdirSync(dirname(target), { recursive: true });
+                        writeFileSync(target, rendered.get(spec.size));
+                    }
+                }
+            }
+            finally {
+                rmSync(tmp, { recursive: true, force: true });
+            }
+            for (const spec of plan.text) {
+                const target = join(res, spec.path);
+                mkdirSync(dirname(target), { recursive: true });
+                writeFileSync(target, spec.content);
+            }
+            // The template's vector would be dead weight showing the NativeScript "N".
+            rmSync(join(res, 'drawable', 'ic_launcher_foreground.xml'), { force: true });
+            writeFileSync(stampPath, `${JSON.stringify(buildStamp(inputs, plan, RES_PREFIX), null, 2)}\n`);
+            process.stdout.write(`gjsify android-icons: wrote ${plan.png.length + plan.text.length} files under ${relative(projectDir, res).split(sep).join('/')} from ${relative(projectDir, icon)}\n`);
+        }
+        catch (err) {
+            process.stderr.write(`gjsify android-icons: ${err instanceof Error ? err.message : String(err)}\n`);
+            return process.exit(1);
+        }
+    },
+};

package/lib/commands/credits.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from '../types/index.js';
+interface CreditsOptions {
+    output?: string;
+    overrides?: string;
+    check?: boolean;
+    stdout?: boolean;
+}
+export declare const creditsCommand: Command<unknown, CreditsOptions>;
+export {};

package/lib/commands/credits.js

@@ -0,0 +1,73 @@
+// `gjsify credits [--output <file>] [--overrides <file>] [--check | --stdout]`
+//
+// Derives who to thank from the git history and writes it as JSON, so an About
+// dialog or a README reads names from one file instead of a hand-kept list.
+import { Config } from '../config.js';
+import { DEFAULT_CREDITS_IGNORE, buildCredits, isStale, parseOverrides, readCommits, serializeCredits, } from '../utils/credits.js';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+const DEFAULT_OUTPUT = 'credits.json';
+const DEFAULT_OVERRIDES = 'credits.overrides.json';
+export const creditsCommand = {
+    command: 'credits',
+    description: 'Write the project’s contributors (developers, translators per language) from the git history as JSON, names only.',
+    builder: (yargs) => yargs
+        .option('output', {
+        alias: 'o',
+        description: `File to write. Default: \`gjsify.credits.output\`, else ${DEFAULT_OUTPUT}.`,
+        type: 'string',
+    })
+        .option('overrides', {
+        description: `Hand-kept additions and exclusions. Default: \`gjsify.credits.overrides\`, else ${DEFAULT_OVERRIDES} when it exists.`,
+        type: 'string',
+    })
+        .option('check', {
+        description: 'Write nothing; exit 1 when the file on disk differs from what the history gives.',
+        type: 'boolean',
+        default: false,
+    })
+        .option('stdout', {
+        description: 'Print the JSON instead of writing it.',
+        type: 'boolean',
+        default: false,
+    })
+        .conflicts('check', 'stdout'),
+    handler: async (args) => {
+        const projectDir = process.cwd();
+        try {
+            const config = (await new Config().forCommand(projectDir)).credits ?? {};
+            const output = resolve(projectDir, args.output ?? config.output ?? DEFAULT_OUTPUT);
+            const overridesName = args.overrides ?? config.overrides;
+            const overridesPath = resolve(projectDir, overridesName ?? DEFAULT_OVERRIDES);
+            let overrides;
+            if (existsSync(overridesPath)) {
+                overrides = parseOverrides(readFileSync(overridesPath, 'utf8'), overridesName ?? DEFAULT_OVERRIDES);
+            }
+            else if (overridesName !== undefined) {
+                throw new Error(`cannot read the overrides file ${overridesName}`);
+            }
+            const credits = buildCredits(readCommits(projectDir), {
+                ignore: config.ignore ?? DEFAULT_CREDITS_IGNORE,
+                overrides,
+            });
+            const text = serializeCredits(credits);
+            if (args.stdout === true) {
+                process.stdout.write(text);
+            }
+            else if (args.check === true) {
+                const existing = existsSync(output) ? readFileSync(output, 'utf8') : null;
+                if (isStale(existing, credits)) {
+                    process.stderr.write(`gjsify credits: ${args.output ?? config.output ?? DEFAULT_OUTPUT} is ${existing === null ? 'missing' : 'stale'}; run \`gjsify credits\` and commit it\n`);
+                    return process.exit(1);
+                }
+            }
+            else {
+                writeFileSync(output, text);
+            }
+        }
+        catch (err) {
+            process.stderr.write(`gjsify credits: ${err instanceof Error ? err.message : String(err)}\n`);
+            return process.exit(1);
+        }
+    },
+};

package/lib/commands/index.d.ts

@@ -23,6 +23,8 @@ export * from './workspace.js';
 export * from './pack.js';
 export * from './publish.js';
 export * from './release-notes.js';
+export * from './android-icons.js';
+export * from './credits.js';
 export * from './whoami.js';
 export * from './login.js';
 export * from './logout.js';

package/lib/commands/index.js

@@ -23,6 +23,8 @@ export * from './workspace.js';
 export * from './pack.js';
 export * from './publish.js';
 export * from './release-notes.js';
+export * from './android-icons.js';
+export * from './credits.js';
 export * from './whoami.js';
 export * from './login.js';
 export * from './logout.js';

package/lib/types/config-data.d.ts

@@ -223,6 +223,10 @@ export interface ConfigData {
     site?: {
         metainfo?: string;
     };
+    /** Config for `gjsify credits`. CLI flags override these. */
+    credits?: ConfigDataCredits;
+    /** Config for `gjsify android-icons`. CLI flags override these. */
+    androidIcons?: ConfigDataAndroidIcons;
     /**
      * Config for `gjsify format` / `lint` / `fix`. A thin shell: oxc's own
      * `.oxfmtrc.json` / `.oxlintrc.json` are the real configuration files.
@@ -233,6 +237,28 @@ export interface ConfigData {
     /** Config for the `nativescript` target — what the APK carries (ADR 0117). */
     nativescript?: ConfigDataNativescript;
 }
+/** `gjsify.androidIcons` — where the NativeScript App_Resources live and what the icon is drawn from. */
+export interface ConfigDataAndroidIcons {
+    /** The App_Resources directory. Default: `appResourcesPath` of nativescript.config.ts, else `App_Resources`. */
+    resources?: string;
+    /** The scalable app icon SVG. Default: the hicolor icon under `data/icons`. */
+    icon?: string;
+    /** Adaptive-icon background, `#rrggbb`. Default: the metainfo light branding colour, else white. */
+    background?: string;
+}
+/** `gjsify.credits` — where `gjsify credits` writes and what it leaves out. */
+export interface ConfigDataCredits {
+    /** File to write. Default `credits.json`. */
+    output?: string;
+    /** Hand-kept additions and exclusions. Default `credits.overrides.json`, read when it exists. */
+    overrides?: string;
+    /**
+     * Patterns for people who are not contributors (bots, AI co-authors, translation services),
+     * matched against the name and the e-mail with `*` as the only wildcard. REPLACES the built-in
+     * list rather than extending it, so a project can also take a name off it.
+     */
+    ignore?: string[];
+}
 /**
  * What a NativeScript build decides that no other target has to.
  *

package/lib/utils/credits.d.ts

@@ -0,0 +1,53 @@
+export interface CreditsPerson {
+    name: string;
+    email: string;
+}
+export interface CreditsCommit {
+    author: CreditsPerson;
+    /** `Co-authored-by:` trailers, already run through `.mailmap`. */
+    coAuthors: CreditsPerson[];
+    files: string[];
+}
+/** The `credits.json` schema. `supporters` has no source but the overrides file. */
+export interface Credits {
+    developers: string[];
+    translators: Record<string, string[]>;
+    supporters: string[];
+}
+/** Hand-maintained additions and removals; every key is optional. */
+export interface CreditsOverrides {
+    developers?: string[];
+    translators?: Record<string, string[]>;
+    supporters?: string[];
+    /** Patterns (see {@link isIgnored}) matched against names; removes a person from every list. */
+    exclude?: string[];
+    /**
+     * Per language, patterns that remove a person from that language's translators only; `*` means
+     * every language. Applied to what the history yields, before the `translators` additions above.
+     */
+    excludeTranslators?: Record<string, string[]>;
+}
+/**
+ * Patterns for people who are not contributors. `*` is the only wildcard and a
+ * pattern must match the WHOLE name or the WHOLE e-mail, case-insensitively.
+ * Weblate commits as "Weblate (bot)" with the real translator in a trailer, so
+ * the bot is dropped and the trailer is what counts.
+ */
+export declare const DEFAULT_CREDITS_IGNORE: readonly string[];
+export declare function isIgnored(person: CreditsPerson, patterns: readonly string[]): boolean;
+/** `Name <mail>` → parts. A trailer without an address keeps the whole value as the name. */
+export declare function parsePerson(value: string): CreditsPerson;
+export declare function buildCredits(commits: readonly CreditsCommit[], options?: {
+    ignore?: readonly string[];
+    overrides?: CreditsOverrides;
+}): Credits;
+/** The `git log` format `parseGitLog` reads: author, address, co-author trailers, then the file names. */
+export declare const GIT_LOG_ARGS: string[];
+/** Splits `git log` output into commits; co-author trailers are NOT mapped yet. */
+export declare function parseGitLog(output: string): CreditsCommit[];
+/** The repo's non-merge commits with `.mailmap` applied to authors and co-authors. */
+export declare function readCommits(cwd: string): CreditsCommit[];
+export declare function parseOverrides(text: string, where?: string): CreditsOverrides;
+export declare function serializeCredits(credits: Credits): string;
+/** True when `existing` (the file on disk, or `null` when absent) is not what `credits` serializes to. */
+export declare function isStale(existing: string | null, credits: Credits): boolean;