xbintsc 0.3.25 → 0.3.35

package/src/driver/mac-bundle.ts

@@ -0,0 +1,156 @@
+/**
+ * macOS `.app` bundle generation.
+ *
+ * A bare Mach-O executable cannot carry a Finder icon, so when `app.bundle` is
+ * enabled on macOS the driver lays out a minimal bundle next to the executable:
+ *
+ *     Demo.app/Contents/Info.plist
+ *     Demo.app/Contents/MacOS/Demo
+ *     Demo.app/Contents/Resources/AppIcon.icns
+ *
+ * An `.icns` input is copied verbatim; a `.png` is converted with the system
+ * `sips` + `iconutil` tools when available, otherwise the PNG is shipped and the
+ * app relies on the runtime Dock icon (set by the `gui` extension).
+ */
+
+import { chmodSync, copyFileSync, existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { IconInfo } from "./icon.js";
+import type { Runner } from "./toolchain.js";
+
+export interface MacBundleOptions {
+  readonly executablePath: string;
+  /** Display name; also the executable name inside the bundle. */
+  readonly name: string;
+  readonly bundleId: string;
+  readonly icon?: IconInfo;
+  readonly runner: Runner;
+  readonly env?: Record<string, string>;
+}
+
+/** `<dir>/<name>.app` for an executable at `<dir>/<name>`. */
+export function bundlePathFor(executablePath: string, name: string): string {
+  return join(dirname(executablePath), `${name}.app`);
+}
+
+/** Escape the five XML predefined entities for the plist values. */
+function xmlEscape(text: string): string {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+export interface PlistOptions {
+  readonly name: string;
+  readonly bundleId: string;
+  readonly executable: string;
+  readonly iconFile?: string;
+}
+
+/** Render a minimal `Info.plist` for a GUI application bundle. */
+export function infoPlist(options: PlistOptions): string {
+  const entries: [string, string][] = [
+    ["CFBundleName", options.name],
+    ["CFBundleDisplayName", options.name],
+    ["CFBundleIdentifier", options.bundleId],
+    ["CFBundleExecutable", options.executable],
+    ["CFBundlePackageType", "APPL"],
+    ["CFBundleInfoDictionaryVersion", "6.0"],
+    ["CFBundleShortVersionString", "1.0.0"],
+    ["CFBundleVersion", "1"],
+    ["LSMinimumSystemVersion", "10.13"],
+    ["NSHighResolutionCapable", "true"],
+  ];
+  if (options.iconFile) entries.push(["CFBundleIconFile", options.iconFile]);
+  const body = entries
+    .map(([key, value]) => `\t<key>${key}</key>\n\t<string>${xmlEscape(value)}</string>`)
+    .join("\n");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    "<dict>",
+    body,
+    "</dict>",
+    "</plist>",
+    "",
+  ].join("\n");
+}
+
+const ICONSET_SIZES = [16, 32, 64, 128, 256, 512] as const;
+
+/** Convert a PNG to `.icns` via `sips` + `iconutil`; false when unavailable. */
+function convertPngToIcns(
+  runner: Runner,
+  pngPath: string,
+  outIcns: string,
+  env?: Record<string, string>,
+): boolean {
+  const iconsetDir = join(dirname(outIcns), "AppIcon.iconset");
+  mkdirSync(iconsetDir, { recursive: true });
+  try {
+    for (const size of ICONSET_SIZES) {
+      for (const scale of [1, 2] as const) {
+        const pixels = size * scale;
+        if (pixels > 1024) continue;
+        const suffix = scale === 1 ? "" : "@2x";
+        const out = join(iconsetDir, `icon_${size}x${size}${suffix}.png`);
+        const result = runner.run(
+          "sips",
+          ["-z", String(pixels), String(pixels), pngPath, "--out", out],
+          { env },
+        );
+        if (result.status !== 0) return false;
+      }
+    }
+    const result = runner.run("iconutil", ["-c", "icns", iconsetDir, "-o", outIcns], { env });
+    return result.status === 0 && existsSync(outIcns);
+  } catch {
+    return false;
+  } finally {
+    rmSync(iconsetDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Lay out the `.app` bundle containing a copy of `executablePath` and, when
+ * available, the icon. Returns the bundle path. Never throws for a missing
+ * image-conversion tool: it falls back to shipping the PNG.
+ */
+export function packageMacApp(options: MacBundleOptions): string {
+  const { executablePath, name, bundleId, icon, runner } = options;
+  const bundleDir = bundlePathFor(executablePath, name);
+  const contents = join(bundleDir, "Contents");
+  const macosDir = join(contents, "MacOS");
+  const resourcesDir = join(contents, "Resources");
+  mkdirSync(macosDir, { recursive: true });
+  mkdirSync(resourcesDir, { recursive: true });
+
+  const innerExecutable = join(macosDir, name);
+  copyFileSync(executablePath, innerExecutable);
+  chmodSync(innerExecutable, 0o755);
+
+  let iconFile: string | undefined;
+  if (icon) {
+    const icnsPath = join(resourcesDir, "AppIcon.icns");
+    if (icon.format === "icns") {
+      copyFileSync(icon.path, icnsPath);
+      iconFile = "AppIcon";
+    } else if (icon.format === "png") {
+      if (convertPngToIcns(runner, icon.path, icnsPath, options.env)) {
+        iconFile = "AppIcon";
+      } else {
+        copyFileSync(icon.path, join(resourcesDir, "AppIcon.png"));
+        iconFile = "AppIcon.png";
+      }
+    }
+  }
+
+  writeFileSync(
+    join(contents, "Info.plist"),
+    infoPlist({ name, bundleId, executable: name, ...(iconFile ? { iconFile } : {}) }),
+  );
+  return bundleDir;
+}

package/src/driver/win-icon.ts

@@ -0,0 +1,96 @@
+/**
+ * Windows PE icon resource.
+ *
+ * Windows reads the application icon from a resource section in the `.exe`, so
+ * an embedded blob is not enough: the icon is wrapped in a `.rc` script and
+ * compiled to a resource object that is linked into the executable. `llvm-rc`
+ * (shipping with clang) is preferred; MinGW `windres` is the fallback. Both are
+ * optional — a missing resource compiler degrades to the runtime window icon
+ * instead of failing the build.
+ */
+
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { hashParts } from "./cache.js";
+import { IconError, toIcoBytes, type IconInfo } from "./icon.js";
+import type { Runner } from "./toolchain.js";
+
+export type ResourceCompilerKind = "llvm-rc" | "windres";
+
+export interface ResourceCompiler {
+  readonly tool: string;
+  readonly kind: ResourceCompilerKind;
+}
+
+/**
+ * Locate a resource compiler. `xbintsc_RC` wins, then `llvm-rc` next to the
+ * resolved clang, then `llvm-rc` and `windres` on `PATH`.
+ */
+export function resolveResourceCompiler(runner: Runner, clang: string): ResourceCompiler | undefined {
+  const exe = process.platform === "win32" ? ".exe" : "";
+  // An explicit override is trusted: probe it and fall back rather than
+  // rejecting it on a path prefix check (it may be a bare command on PATH).
+  const override = process.env.xbintsc_RC;
+  if (override) {
+    const kind: ResourceCompilerKind = /windres/i.test(override) ? "windres" : "llvm-rc";
+    try {
+      if (runner.run(override, ["--version"]).status === 0) return { tool: override, kind };
+    } catch {
+      // Fall through to the discovered compilers.
+    }
+  }
+  const candidates: ResourceCompiler[] = [];
+  if (clang && (clang.includes("/") || clang.includes("\\"))) {
+    candidates.push({ tool: join(dirname(clang), `llvm-rc${exe}`), kind: "llvm-rc" });
+  }
+  candidates.push({ tool: `llvm-rc${exe}`, kind: "llvm-rc" });
+  candidates.push({ tool: `windres${exe}`, kind: "windres" });
+
+  for (const candidate of candidates) {
+    if ((candidate.tool.includes("/") || candidate.tool.includes("\\")) && !existsSync(candidate.tool)) continue;
+    try {
+      if (runner.run(candidate.tool, ["--version"]).status === 0) return candidate;
+    } catch {
+      // Not runnable; try the next candidate.
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Compile the icon into a linkable PE resource object (`.res` for llvm-rc, a
+ * COFF `.o` for windres). Cached by contents and compiler kind.
+ */
+export function ensureWindowsIconResource(
+  runner: Runner,
+  cacheDir: string,
+  icon: IconInfo,
+  compiler: ResourceCompiler,
+  env?: Record<string, string>,
+): string {
+  const icoBytes = toIcoBytes(icon);
+  const key = hashParts(["icon-res", compiler.kind, Buffer.from(icoBytes).toString("base64")]);
+  const icoName = `icon-${key}.ico`;
+  const icoPath = join(cacheDir, icoName);
+  const rcPath = join(cacheDir, `icon-${key}.rc`);
+  const objectPath = join(cacheDir, `icon-${key}.${compiler.kind === "windres" ? "o" : "res"}`);
+  if (existsSync(objectPath)) return objectPath;
+
+  mkdirSync(cacheDir, { recursive: true });
+  writeFileSync(icoPath, icoBytes);
+  // The .rc references the .ico by name; the compiler runs with `cacheDir` as
+  // its working directory so the relative path resolves.
+  writeFileSync(rcPath, `1 ICON "${icoName}"\n`);
+
+  const args =
+    compiler.kind === "windres"
+      ? [rcPath, "-O", "coff", "-o", objectPath]
+      : ["/fo", objectPath, rcPath];
+  const result = runner.run(compiler.tool, args, { cwd: cacheDir, env });
+  if (result.status !== 0 || !existsSync(objectPath)) {
+    throw new IconError(
+      `Failed to compile the Windows icon resource with ${compiler.tool}:\n${result.stderr || result.stdout}`,
+    );
+  }
+  return objectPath;
+}

package/src/parser/statements.ts

@@ -195,8 +195,16 @@ export const statementMethods: StatementMethods = {
       case TokenKind.EnumKeyword:
         return this.parseEnumDeclaration([]);
       case TokenKind.NamespaceKeyword:
-      case TokenKind.ModuleKeyword:
-        return this.parseModuleDeclaration([]);
+      case TokenKind.ModuleKeyword: {
+        // `module` is a contextual keyword: `module.exports` / `module(x)` are
+        // ordinary expressions, only `module Foo {}` / `module "x" {}` is a
+        // declaration.
+        const next = this.lookAhead(1);
+        if (this.isIdentifierLike(next) || next.kind === TokenKind.StringLiteral) {
+          return this.parseModuleDeclaration([]);
+        }
+        break;
+      }
       case TokenKind.DeclareKeyword: {
         const modifiers = this.tryParseModifiers();
         return this.parseStatementWithModifiers(modifiers);
@@ -228,8 +236,13 @@ export const statementMethods: StatementMethods = {
       case TokenKind.EnumKeyword:
         return this.parseEnumDeclaration(modifiers);
       case TokenKind.NamespaceKeyword:
-      case TokenKind.ModuleKeyword:
-        return this.parseModuleDeclaration(modifiers);
+      case TokenKind.ModuleKeyword: {
+        const next = this.lookAhead(1);
+        if (this.isIdentifierLike(next) || next.kind === TokenKind.StringLiteral) {
+          return this.parseModuleDeclaration(modifiers);
+        }
+        return this.parseExpressionStatement();
+      }
       default:
         return this.parseExpressionStatement();
     }

package/dist/tests/e2e/gui.test.d.ts

@@ -1,12 +0,0 @@
-/**
- * End-to-end tests for the `gui` extension.
- *
- * The suite compiles TypeScript programs that import `gui`, links them against
- * the prebuilt `runtime/lib/<os>-<arch>/gui.a` and runs them. Programs close
- * themselves through the `XT_GUI_AUTOCLOSE_MS` hook, so the tests never block on
- * a real window.
- *
- * It is skipped when the GUI archive has not been built (run `npm run gui`
- * first) and on Windows, where the archive is not produced yet.
- */
-export {};