@caperjs/core 0.7.1 → 0.7.2

package/build/assetpack.mjs

@@ -2,6 +2,7 @@ import { AssetPack, Logger } from '@assetpack/core';
 import { pixiPipes } from '@assetpack/core/pixi';
 import process from 'node:process';
 import path from 'path';
+import { outputModeKey, shouldBypassCache, writeMarker } from './internal/outputMarker.mjs';
 
 const cwd = process.cwd();
 
@@ -300,12 +301,39 @@ export function assetpackPlugin(manifestUrl = defaultManifestUrl, pixiPipesConfi
     }
   }
 
+  // AssetPack caches by config hash, and dev/production get separate cache
+  // files but share one output folder (vite's publicDir). A cache hit only
+  // means "my inputs are unchanged" -- it says nothing about whether the
+  // other mode overwrote the shared folder since. The marker records which
+  // mode last wrote the folder, so a mode switch forces a cache-less run
+  // instead of silently leaving the folder out of sync with the manifest.
+  function markerPath() {
+    return path.join(apConfig.cacheLocation || '.assetpack', 'caper-output-mode.json');
+  }
+
+  function prepareRun() {
+    const key = outputModeKey({ isProduction, pixiPipesConfig, manifestUrl });
+    const bypass = shouldBypassCache({ markerPath: markerPath(), outputDir: apConfig.output, key });
+    if (bypass) {
+      Logger.info(
+        'Caper assetpack plugin:: output folder was not last written by this mode, rebuilding assets without cache',
+      );
+    }
+    return { config: bypass ? { ...apConfig, cache: false } : apConfig, key };
+  }
+
+  function markRun(key) {
+    writeMarker({ markerPath: markerPath(), key, outputDir: apConfig.output });
+  }
+
   return {
     name: 'vite-plugin-assetpack',
     api: {
       runOnce: async () => {
         await getConfig();
-        await new AssetPack(apConfig).run();
+        const { config, key } = prepareRun();
+        await new AssetPack(config).run();
+        markRun(key);
       },
     },
     async configResolved(resolvedConfig) {
@@ -333,7 +361,8 @@ export function assetpackPlugin(manifestUrl = defaultManifestUrl, pixiPipesConfi
       await getConfig();
       if (mode === 'serve') {
         if (ap) return;
-        ap = new AssetPack(apConfig);
+        const { config, key } = prepareRun();
+        ap = new AssetPack(config);
         // Vite does not reload the page when files under publicDir change, so
         // without this the browser keeps serving stale assets after a rebuild.
         // One reload per completed rebuild batch; the initial pass is skipped
@@ -342,6 +371,7 @@ export function assetpackPlugin(manifestUrl = defaultManifestUrl, pixiPipesConfi
         await ap.watch(() => {
           if (initial) {
             initial = false;
+            markRun(key);
             return;
           }
           const hot = server?.environments?.client?.hot ?? server?.ws;
@@ -349,7 +379,9 @@ export function assetpackPlugin(manifestUrl = defaultManifestUrl, pixiPipesConfi
           Logger.info('Caper assetpack plugin:: assets rebuilt, reloading page');
         });
       } else {
-        await new AssetPack(apConfig).run();
+        const { config, key } = prepareRun();
+        await new AssetPack(config).run();
+        markRun(key);
       }
       isBuilding = false;
     },

package/build/defaults.mjs

@@ -52,6 +52,43 @@ export function readAppIdentity(root = process.cwd()) {
 const isPlainObject = (value) =>
   value !== null && typeof value === 'object' && !Array.isArray(value);
 
+/** Deep-merge `overrides` onto `base`; plain objects recurse, everything else replaces. */
+function overlay(base, overrides) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(overrides)) {
+    out[key] = isPlainObject(value) && isPlainObject(base[key]) ? overlay(base[key], value) : value;
+  }
+  return out;
+}
+
+/**
+ * Vite config the Tauri CLI needs, keyed off the env vars it sets on `vite` /
+ * `vite build` child processes: `TAURI_ENV_PLATFORM` (always set), `TAURI_DEV_HOST`
+ * (LAN IP, only set for mobile dev on a device). Returns `{}` outside Tauri.
+ *
+ * These override caper's own server defaults (`open`/`host`) rather than merely
+ * filling gaps in them — Tauri owns the window chrome, so a browser tab popping
+ * open alongside it, or the dev server refusing a LAN connection, are both wrong.
+ * They still lose to the project's own `vite.config`, via the `fillMissing` call
+ * in `caperDefaults` below.
+ */
+export function tauriDefaults(env = process.env) {
+  if (!env.TAURI_ENV_PLATFORM) return {};
+
+  const host = env.TAURI_DEV_HOST;
+  return {
+    clearScreen: false,
+    envPrefix: ['VITE_', 'TAURI_ENV_'],
+    server: {
+      open: false,
+      strictPort: true,
+      host: host || false,
+      ...(host ? { hmr: { protocol: 'ws', host, port: 1421 } } : {}),
+      watch: { ignored: ['**/src-tauri/**'] },
+    },
+  };
+}
+
 /**
  * The subset of `defaults` that `target` does not already specify. Returns
  * `undefined` when there is nothing to contribute, so callers can omit the key
@@ -176,5 +213,6 @@ export function caperDefaultValues(env, userConfig = {}) {
 
 /** The partial config caper contributes for this project and command. */
 export function caperDefaults(userConfig, env) {
-  return fillMissing(userConfig, caperDefaultValues(env, userConfig)) ?? {};
+  const values = overlay(caperDefaultValues(env, userConfig), tauriDefaults());
+  return fillMissing(userConfig, values) ?? {};
 }

package/build/index.mjs

@@ -18,6 +18,7 @@ import wasm from 'vite-plugin-wasm';
 import { assetpackPlugin } from './assetpack.mjs';
 import { caperDefaults } from './defaults.mjs';
 import { readCaperBuildFlags } from './internal/buildFlags.mjs';
+import { logger } from './internal/util.mjs';
 import { assetTypesPlugin } from './plugins/assetTypes.mjs';
 import { caperConfigPlugin } from './plugins/caperConfig.mjs';
 import { caperDevHelperPlugin } from './plugins/devHelper.mjs';
@@ -44,6 +45,16 @@ function caperPluginList({ assets = {}, pwa } = {}) {
           ...(pngFallback ? [] : [pngFallbackPrunePlugin({ manifestUrl })]),
         ];
 
+  // Service workers can't register on Tauri's `tauri://localhost` origin, and
+  // the PWA defaults force `base: '/'` — so under the Tauri CLI, skip the
+  // plugin (and its runtime registration snippet) entirely rather than ship a
+  // dead one.
+  const disablePwaForTauri = Boolean(pwa) && Boolean(process.env.TAURI_ENV_PLATFORM);
+  if (disablePwaForTauri) {
+    logger.info('caper: PWA disabled for this native (Tauri) build; service workers do not work on the tauri:// origin');
+  }
+  const effectivePwa = disablePwaForTauri ? undefined : pwa;
+
   return [
     {
       // These must be singletons. A second copy — e.g. a @caperjs plugin
@@ -56,7 +67,7 @@ function caperPluginList({ assets = {}, pwa } = {}) {
       }),
     },
     ...(buildFlags.useWasm ? [wasm()] : []),
-    createCaperRuntimePlugin({ pwa }),
+    createCaperRuntimePlugin({ pwa: effectivePwa }),
     createCaperViewportPlugin(),
     viteStaticCopy({
       // The captions plugin's bitmap font. `silent` matters: without it,
@@ -81,7 +92,7 @@ function caperPluginList({ assets = {}, pwa } = {}) {
     // place that knows a project overrode it.
     caperConfigPlugin(true, manifestUrl),
     caperDevHelperPlugin(),
-    ...(pwa ? caperPwaPlugins(pwa) : []),
+    ...(effectivePwa ? caperPwaPlugins(effectivePwa) : []),
   ];
 }
 

package/build/internal/outputMarker.mjs

@@ -0,0 +1,52 @@
+/**
+ * Detects when AssetPack's output folder was last written by a different
+ * mode (dev vs. production) than the one about to run, so the caller can
+ * bypass AssetPack's cache for that one run.
+ *
+ * AssetPack caches by config hash, and dev/production get separate cache
+ * files but share one output folder (Vite's `publicDir`). A cache hit only
+ * means "my inputs are unchanged" — it says nothing about whether the other
+ * mode overwrote the shared folder since. The marker records which mode
+ * last wrote the folder so a mode switch can be detected and the cache
+ * bypassed for that one run, forcing a full rebuild.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * A stable string that differs whenever dev and production configs differ
+ * (or the pipes config / manifest url otherwise change), so it can be
+ * compared across runs without re-deriving AssetPack's own config hash.
+ */
+export function outputModeKey({ isProduction, pixiPipesConfig, manifestUrl }) {
+  const mode = isProduction ? 'production' : 'development';
+  return `${mode}|${JSON.stringify(pixiPipesConfig ?? {})}|${manifestUrl ?? ''}`;
+}
+
+/**
+ * True when the output folder can't be trusted to match `key`: no marker,
+ * an unreadable one, a different stored key, or an empty/missing output
+ * folder (nothing there to trust either way).
+ */
+export function shouldBypassCache({ markerPath, outputDir, key }) {
+  let stored;
+  try {
+    stored = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
+  } catch {
+    return true;
+  }
+  if (stored?.key !== key) return true;
+
+  let entries;
+  try {
+    entries = fs.readdirSync(outputDir);
+  } catch {
+    return true;
+  }
+  return entries.length === 0;
+}
+
+export function writeMarker({ markerPath, key, outputDir }) {
+  fs.mkdirSync(path.dirname(markerPath), { recursive: true });
+  fs.writeFileSync(markerPath, JSON.stringify({ key, output: outputDir }), 'utf8');
+}

package/cli/doctor.mjs

@@ -1,11 +1,14 @@
 import { dim, green, red, yellow } from 'kleur/colors';
 
-import { execFile } from 'node:child_process';
+import { execFile, execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
+import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+import { ANDROID_RUST_TARGETS, findMainActivity, missingRustTargets, resolveAndroidEnv, TAURI_PLUGIN_PERMISSIONS } from './native.mjs';
+
 /**
  * `caper doctor` — one-shot health report for a Caper app.
  *
@@ -90,6 +93,38 @@ const push = (checks, id, status, label, hint) => {
   checks.push({ id, status, label, ...(hint ? { hint } : {}) });
 };
 
+/** `rustc --version` output -> `"1.98.1"`, or `null` when unparseable. */
+export function parseRustcVersion(output) {
+  const match = /rustc (\d+\.\d+\.\d+)/.exec(String(output ?? ''));
+  return match ? match[1] : null;
+}
+
+/** The default injectable command runner for the native-toolchain checks. */
+const defaultDoctorRun = (cmd, args, opts = {}) => execFileSync(cmd, args, { encoding: 'utf-8', ...opts });
+
+/**
+ * `@tauri-apps/cli`'s version, resolved by walking up from `cwd` looking for
+ * `node_modules/@tauri-apps/cli/package.json` (monorepo: it may live several
+ * levels above the app). A manual walk rather than `require.resolve`, which
+ * also considers global/module-loader search paths we don't want here.
+ */
+function resolveTauriCliVersion(cwd) {
+  let current = path.resolve(cwd);
+  for (;;) {
+    const candidate = path.join(current, 'node_modules/@tauri-apps/cli/package.json');
+    if (fs.existsSync(candidate)) {
+      try {
+        return JSON.parse(fs.readFileSync(candidate, 'utf-8')).version;
+      } catch {
+        return null;
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
 /**
  * Resolve a tsconfig `extends` entry to an absolute config file path,
  * TypeScript-style: relative specs resolve against the extending config's
@@ -166,7 +201,10 @@ const resolveEffectiveCompilerOptions = (configFile, ancestors = new Set(), dept
   return { ...inherited, ...(config.compilerOptions ?? {}) };
 };
 
-export async function runChecks(cwd, { online = true } = {}) {
+export async function runChecks(
+  cwd,
+  { online = true, run = defaultDoctorRun, platform = process.platform, env = process.env, homedir = os.homedir() } = {},
+) {
   const checks = [];
   const installedVersion = readInstalledVersion();
   const nodeModulesCaper = path.join(cwd, 'node_modules/@caperjs/core');
@@ -297,6 +335,171 @@ export async function runChecks(cwd, { online = true } = {}) {
     }
   }
 
+  // Native (Tauri) toolchain — only relevant to apps that ran `caper native init`.
+  const srcTauriDir = path.join(cwd, 'src-tauri');
+  if (fs.existsSync(srcTauriDir)) {
+    try {
+      const version = parseRustcVersion(run('rustc', ['--version']));
+      if (!version) {
+        push(checks, 'native-rust', 'fail', 'rustc version unreadable', 'install via rustup.rs');
+      } else if (compareVersions(version, '1.88.0') < 0) {
+        push(checks, 'native-rust', 'fail', `rustc ${version}`, 'rustup update (or brew upgrade rust)');
+      } else {
+        push(checks, 'native-rust', 'ok', `rustc ${version}`);
+      }
+    } catch {
+      push(checks, 'native-rust', 'fail', 'rustc not found', 'install via rustup.rs');
+    }
+
+    const tauriCliVersion = resolveTauriCliVersion(cwd);
+    if (!tauriCliVersion) {
+      push(checks, 'native-tauri-cli', 'fail', '@tauri-apps/cli not found', 'caper native init (or add @tauri-apps/cli@^2)');
+    } else {
+      const major = parseInt(tauriCliVersion.split('.')[0], 10);
+      push(
+        checks,
+        'native-tauri-cli',
+        major === 2 ? 'ok' : 'warn',
+        `@tauri-apps/cli ${tauriCliVersion}`,
+        major === 2 ? undefined : 'expected @tauri-apps/cli major version 2',
+      );
+    }
+
+    // Only relevant once the app actually depends on @caperjs/plugin-tauri —
+    // `caper native init` alone doesn't need the store crate or its permissions.
+    if (appDeps['@caperjs/plugin-tauri']) {
+      let cargoToml = null;
+      try {
+        cargoToml = fs.readFileSync(path.join(cwd, 'src-tauri/Cargo.toml'), 'utf-8');
+      } catch {
+        // fails below
+      }
+      if (cargoToml === null) {
+        push(checks, 'native-plugin', 'fail', 'src-tauri/Cargo.toml unreadable', 'caper native plugin');
+      } else if (!cargoToml.includes('tauri-plugin-store')) {
+        push(checks, 'native-plugin', 'fail', 'src-tauri/Cargo.toml is missing tauri-plugin-store', 'caper native plugin');
+      } else {
+        const capabilities = readJson(path.join(cwd, 'src-tauri/capabilities/default.json'));
+        if (!capabilities) {
+          push(checks, 'native-plugin', 'fail', 'src-tauri/capabilities/default.json unreadable', 'caper native plugin');
+        } else {
+          const permissions = Array.isArray(capabilities.permissions) ? capabilities.permissions : [];
+          const missing = TAURI_PLUGIN_PERMISSIONS.filter((p) => !permissions.includes(p));
+          if (missing.length) {
+            push(checks, 'native-plugin', 'warn', `missing capability permissions: ${missing.join(', ')}`, 'caper native plugin');
+          } else {
+            push(checks, 'native-plugin', 'ok', 'native plugin wiring');
+          }
+        }
+      }
+    }
+
+    const tauriConf = readJson(path.join(cwd, 'src-tauri/tauri.conf.json'));
+    if (!tauriConf || typeof tauriConf.identifier !== 'string') {
+      push(checks, 'native-identifier', 'fail', 'tauri.conf.json identifier unreadable', 'src-tauri/tauri.conf.json is missing or not parseable');
+    } else if (tauriConf.identifier === 'com.tauri.dev') {
+      push(checks, 'native-identifier', 'fail', 'identifier is the tauri placeholder com.tauri.dev', 'set a real reverse-DNS identifier before shipping');
+    } else if (tauriConf.identifier.startsWith('dev.caper.')) {
+      push(checks, 'native-identifier', 'warn', `identifier ${tauriConf.identifier}`, 'placeholder, change before shipping');
+    } else {
+      push(checks, 'native-identifier', 'ok', `identifier ${tauriConf.identifier}`);
+    }
+
+    if (tauriConf?.build) {
+      const { devUrl, beforeDevCommand } = tauriConf.build;
+      const devUrlPort = typeof devUrl === 'string' ? Number(devUrl.match(/:(\d+)(?:\/|$)/)?.[1]) : NaN;
+      const beforeDevPort = typeof beforeDevCommand === 'string' ? Number(beforeDevCommand.match(/--port[= ](\d+)/)?.[1]) : NaN;
+
+      if (Number.isNaN(devUrlPort)) {
+        push(checks, 'native-dev-port', 'warn', 'devUrl port unknown', 'check src-tauri/tauri.conf.json build.devUrl');
+      } else if (!Number.isNaN(beforeDevPort) && beforeDevPort !== devUrlPort) {
+        push(checks, 'native-dev-port', 'warn', `devUrl port ${devUrlPort} differs from beforeDevCommand port ${beforeDevPort}`, 'keep both in sync');
+      } else if (devUrlPort === 3000) {
+        push(checks, 'native-dev-port', 'warn', `devUrl port ${devUrlPort}`, "collides with other Caper apps' default dev port");
+      } else {
+        push(checks, 'native-dev-port', 'ok', `devUrl port ${devUrlPort}`);
+      }
+    }
+
+    if (platform === 'darwin') {
+      try {
+        run('xcode-select', ['-p']);
+        push(checks, 'native-xcode-clt', 'ok', 'Xcode command line tools');
+      } catch {
+        push(checks, 'native-xcode-clt', 'fail', 'Xcode command line tools missing', 'xcode-select --install');
+      }
+    }
+
+    // Android: only once `tauri android init` (or `caper native android`) has run.
+    const genAndroidDir = path.join(srcTauriDir, 'gen/android');
+    if (fs.existsSync(genAndroidDir)) {
+      const listDir = (dir) => {
+        try {
+          return fs.readdirSync(dir);
+        } catch {
+          return [];
+        }
+      };
+      const android = resolveAndroidEnv({ env, platform, homedir, exists: fs.existsSync, listDir });
+
+      if (android.missing.includes('rustup')) {
+        push(checks, 'native-android-rust', 'fail', 'rustup not found', 'install Rust through rustup, then caper native android');
+      } else {
+        try {
+          const missingTargets = missingRustTargets(run('rustup', ['target', 'list', '--installed'], { env: android.env }));
+          if (missingTargets.length) {
+            push(checks, 'native-android-rust', 'fail', `missing rust targets: ${missingTargets.join(', ')}`, 'caper native android');
+          } else {
+            push(checks, 'native-android-rust', 'ok', `rust targets: ${ANDROID_RUST_TARGETS.length} Android targets`);
+          }
+        } catch {
+          push(checks, 'native-android-rust', 'fail', 'rustup target list failed', 'caper native android');
+        }
+      }
+
+      const isDir = (p) => {
+        try {
+          return fs.statSync(p).isDirectory();
+        } catch {
+          return false;
+        }
+      };
+      for (const [id, name, install] of [
+        ['native-android-ndk', 'NDK_HOME', 'install an NDK with Android Studio (SDK Manager > SDK Tools > NDK)'],
+        ['native-android-java', 'JAVA_HOME', 'install Android Studio (it bundles a JDK)'],
+      ]) {
+        if (env[name]) {
+          if (isDir(env[name])) push(checks, id, 'ok', `${name} ${env[name]}`);
+          else push(checks, id, 'fail', `${name} is not a directory: ${env[name]}`, install);
+        } else if (android.env[name]) {
+          push(checks, id, 'warn', `${name} not set (found ${android.env[name]})`, `export ${name}=${android.env[name]}`);
+        } else {
+          push(checks, id, 'fail', `${name} not set`, install);
+        }
+      }
+
+      let buildRs = '';
+      try {
+        buildRs = fs.readFileSync(path.join(srcTauriDir, 'build.rs'), 'utf-8');
+      } catch {
+        // fails below
+      }
+      if (buildRs.includes('max-page-size=16384')) {
+        push(checks, 'native-android-16kb', 'ok', 'build.rs 16 KB page alignment');
+      } else {
+        push(checks, 'native-android-16kb', 'fail', 'build.rs lacks 16 KB page alignment', 'caper native android');
+      }
+
+      const mainActivityPath = findMainActivity(genAndroidDir);
+      const mainActivity = mainActivityPath ? fs.readFileSync(mainActivityPath, 'utf-8') : '';
+      if (mainActivity.includes('WindowInsetsCompat.Type.systemBars()')) {
+        push(checks, 'native-android-bars', 'ok', 'MainActivity hides the system bars');
+      } else {
+        push(checks, 'native-android-bars', 'warn', 'MainActivity does not hide the system bars', 'caper native android');
+      }
+    }
+  }
+
   const caches = ['.assetpack', '.cache', 'dist'].filter((name) => fs.existsSync(path.join(cwd, name)));
   push(checks, 'caches', 'ok', `caches${caches.length ? `: ${caches.join(', ')}` : ' clean'}`, caches.length ? 'rm -rf them on weird asset/name mismatches' : undefined);