crossbind 2.0.0-beta.72 → 2.0.0-beta.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crossbind",
-  "version": "2.0.0-beta.72",
+  "version": "2.0.0-beta.73",
   "license": "MIT",
   "homepage": "https://crossbind.dev",
   "repository": {
@@ -51,7 +51,7 @@
     "upath": "^3.0.8"
   },
   "optionalDependencies": {
-    "@crossbind/bridge-tools": "2.0.0-beta.72"
+    "@crossbind/bridge-tools": "2.0.0-beta.73"
   },
   "keywords": [
     "webassembly",

package/src/actions/addExtension.js

@@ -5,6 +5,7 @@ import { configFileOf, writeExtension } from '../utils/configWriter.js';
 import { isUnderBase } from '../utils/replaceBasePathForDocker.js';
 import { ownPackages } from '../utils/appExtensions.js';
 import { packagesOfCrossbind } from '../utils/packageSources.js';
+import { assertAppProject } from '../utils/appProject.js';
 import resolveAppHostRoot from '../utils/resolveAppHost.js';
 
 // The lockfiles by which a project names the package manager it is installed with.
@@ -144,9 +145,7 @@ function installedName(spec, before, after, manifest) {
 export default function addExtension(spec, {
     config, env = process.env, platform = process.platform, spawn = spawnSync,
 }) {
-    if (config.target.runtimeEnv !== 'app') {
-        throw new Error("crossbind: an extension builds into an app, which this project is not: set target: { runtimeEnv: 'app' } in crossbind.config.js, as the desktop-app template does.");
-    }
+    assertAppProject(config, 'an extension builds into an app');
     assertSpec(spec, platform);
     assertNotOwn(spec);
     const { project, base } = config.paths;

package/src/actions/buildApp.js

@@ -393,6 +393,33 @@ export function clearAppOutputs() {
     else fs.rmSync(appOutputsFile(), { force: true });
 }
 
+// The app target an entry of the folder the bundler builds into was written for, by its name: the target's app, or what
+// packages it.
+function outputTarget(entry) {
+    const { name } = state.config.general;
+    return state.targets.filter((t) => t.runtimeEnv === 'app').find((t) => [appOutputName(t), `${name}-${t.platform}-${t.arch}`]
+        .some((app) => entry === app || entry.startsWith(`${app}.`) || entry.startsWith(`${app}-`)));
+}
+
+// The paths a recorded output names: each desktop app with its installers' files, or a mobile app's project with its APK,
+// bundle and debug symbols.
+const outputPaths = (output) => (Array.isArray(output)
+    ? output.flatMap(({ app, installers = [] }) => [app, ...installers.flatMap(({ files }) => files)])
+    : Object.values(output)).filter(Boolean);
+
+// Empties the folder the bundler builds an app into, as the bundler would, but for git's own folder and what builds for the
+// app's other platforms wrote there: their apps, named after their targets, and the files their installers recorded.
+export function emptyAppOutDir(dir, platform = appPlatform()) {
+    if (!fs.existsSync(dir)) return;
+    const others = new Set(Object.entries(readAppOutputs()).filter(([name]) => name !== platform)
+        .flatMap(([, output]) => outputPaths(output)).map((file) => path.resolve(file)));
+    for (const entry of fs.readdirSync(dir)) {
+        const target = outputTarget(entry);
+        const isOthers = target ? (DESKTOP_PLATFORMS[target.platform] ?? target.platform) !== platform : others.has(path.resolve(dir, entry));
+        if (entry !== '.git' && !isOthers) fs.rmSync(path.join(dir, entry), { recursive: true, force: true });
+    }
+}
+
 // What a publisher's upload gets of the app the build wrote for a platform: a desktop platform's apps, one for each arch.
 export function appOutputOf(platform) {
     const output = readAppOutputs()[platform];
@@ -475,11 +502,8 @@ export function publishApp(target, { to = appOutputPath(target), page = null } =
         // The app may land inside the page's own directory, which it then leaves out, with every app built there and what
         // packages it: what is named after a target of the app, and every installer's files as a build recorded them, which
         // a folder the bundler left as it was holds still.
-        const apps = state.targets.filter((t) => t.runtimeEnv === 'app')
-            .flatMap((t) => [appOutputName(t), `${state.config.general.name}-${t.platform}-${t.arch}`]).filter((name) => !name.endsWith('.app'));
         const shipped = shippedFiles();
-        const isApp = (entry) => entry === path.basename(to) || entry.endsWith('.app')
-            || apps.some((app) => entry === app || entry.startsWith(`${app}.`) || entry.startsWith(`${app}-`))
+        const isApp = (entry) => entry === path.basename(to) || entry.endsWith('.app') || Boolean(outputTarget(entry))
             || shipped.has(path.resolve(page, entry));
         fs.readdirSync(page).filter((entry) => !isApp(entry)).forEach((entry) => {
             fs.cpSync(`${page}/${entry}`, `${to}/${appLayout(target).resources}/page/${entry}`, { recursive: true });

package/src/actions/extensionCommands.js

@@ -3,6 +3,7 @@ import extensionApi from './extensionApi.js';
 import state from '../state/index.js';
 import { hasTerminal } from '../utils/ask.js';
 import { extensionStep, ownExtensions, withoutNamed } from '../utils/appExtensions.js';
+import { isAppProject } from '../utils/appProject.js';
 import resolveAppHostRoot from '../utils/resolveAppHost.js';
 
 const kebab = (name) => name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
@@ -23,7 +24,7 @@ function ownOf(listed, app) {
 // Adds to crossbind app the commands of an app's extensions, crossbind's own and those crossbind.config.js lists: a name
 // another has stops the run, naming both.
 export default function addExtensionCommands(parent, config = state.config) {
-    if (config?.target?.runtimeEnv !== 'app') return;
+    if (!config?.target || !isAppProject(config)) return;
     const listed = config.extensions ?? [];
     const owners = new Map(parent.commands.map((command) => [command.name(), 'crossbind']));
     for (const { name: extension, commands = {} } of [...ownOf(listed, config.app), ...listed]) {

package/src/actions/getDependLibs.js

@@ -1,4 +1,5 @@
 import findFiles from '../utils/findFiles.js';
+import xcframeworkSliceOf from '../utils/xcframeworkSlice.js';
 import state from '../state/index.js';
 import { getFilteredTargetSpec } from './target.js';
 
@@ -21,10 +22,10 @@ export default function getDependLibs(target) {
                 if (libPaths.length === 0) {
                     libPaths = libsIn(target.releasePath);
                 }
-                // A published port can leave its iOS archive to its xcframework, where the package's paths lead.
-                const xcframeworkLib = target.platform === 'ios' && state.config.allDependencyPaths?.[target.path]?.[fileName]?.lib;
-                if (libPaths.length === 0 && xcframeworkLib) {
-                    libPaths = findFiles(xcframeworkLib, { cwd: d.paths.project });
+                // A published port can leave its iOS archive to its xcframework: the one of this package, as a project
+                // can list the port's packages of other platforms, whose libraries share the name.
+                if (libPaths.length === 0 && target.platform === 'ios') {
+                    libPaths = findFiles(`${xcframeworkSliceOf(d.paths.project, fileName, target)}/lib${fileName}.a`, { cwd: d.paths.project });
                 }
                 dependLibs.push(...libPaths);
             });

package/src/app/index.js

@@ -1,15 +1,16 @@
 // What an app's host does for its page: the app's folders, quitting, its windows, the events of the app's native code and
-// the functions of its extensions, by their names. Each call goes to the host of an app (target.runtimeEnv: 'app'); in any
-// other build it rejects, or events.on throws. A page imports these from crossbind/app, which an app's bundler plugin
-// takes from the app host, with what crossbind's own extensions give the page, as crossbind/app/core alone holds these.
+// the functions of its extensions, by their names. Each call goes to the host of an app, which crossbind app builds; in a
+// browser it rejects, or events.on throws. A page imports these from crossbind/app, which an app's bundler plugin takes
+// from the app host, with what crossbind's own extensions give the page, as crossbind/app/core alone holds these.
 
-// The app's crossbind.js, which initNative() loads, hands the calls to the host.
+// The app's crossbind.js, which initNative() loads, hands the calls to the host. A browser has crossbind's glue as well,
+// but no token of a host, and none of its functions.
 function hostOf(member, name) {
     const host = globalThis.Crossbind?.[member];
     if (host) return host;
+    if (!globalThis.__crossbind_token && !globalThis.Crossbind?.app) throw new Error(`crossbind: ${name} works in an app alone, which crossbind app builds`);
     if (globalThis.Crossbind) throw new Error(`crossbind: this app's host is older than crossbind/app; update @crossbind/core-app-host to call ${name}`);
-    if (globalThis.__crossbind_token) throw new Error(`crossbind: ${name} works once the page has called initNative()`);
-    throw new Error(`crossbind: ${name} works in an app alone, whose crossbind.config.js sets target.runtimeEnv: 'app'`);
+    throw new Error(`crossbind: ${name} works once the page has called initNative()`);
 }
 
 const call = (name, options) => hostOf('app', name)(name, options);
@@ -106,7 +107,7 @@ function deviceOf(name) {
     const device = globalThis.__crossbind_device;
     if (device) return device[name];
     if (globalThis.__crossbind_token) throw new Error(`crossbind: this app's host is older than crossbind/app; update @crossbind/core-app-host to read device.${name}`);
-    throw new Error(`crossbind: device.${name} works in an app alone, whose crossbind.config.js sets target.runtimeEnv: 'app'`);
+    throw new Error(`crossbind: device.${name} works in an app alone, which crossbind app builds`);
 }
 
 // Where the app runs, the same through its run, which the page reads at once, as it starts: the platform and the arch

package/src/bin.js

@@ -15,6 +15,7 @@ import buildWasiCommand from './actions/buildWasiCommand.js';
 import buildNode, { addonsInPackages, bundleNodeLoader, publishNodeData } from './actions/buildNode.js';
 import buildNativeCommand from './actions/buildNativeCommand.js';
 import buildApp, { appOutputPath, assertAppRunner, publishApp } from './actions/buildApp.js';
+import { assertAppProject } from './utils/appProject.js';
 import {
     makeUploadKey, releaseSigningEnv, showUploadKeyPassword, useUploadKey,
 } from './actions/uploadKey.js';
@@ -113,19 +114,34 @@ function declaredSbomPath(projectDir) {
 // An app's page is the project's Vite build, which @crossbind/plugin-vite makes into the app of the platform named.
 const APP_PLATFORMS = ['android', 'ios', 'linux', 'macos', 'windows'];
 
+// Vite's CLI beside the entry of the package vite resolves to, where Vite keeps it and vite-plus-core too, whose vp runs
+// it from there. An entry outside the package is another one's, which a lookup past it found.
+function viteCliBesideEntry(require, packageDir) {
+    try {
+        const entry = require.resolve('vite');
+        const cli = path.join(path.dirname(entry), 'cli.js');
+        return entry.startsWith(`${packageDir}${path.sep}`) && fs.existsSync(cli) ? cli : null;
+    } catch {
+        return null;
+    }
+}
+
 function projectVite() {
+    const require = createRequire(`${state.config.paths.project}/package.json`);
     let manifestPath;
     try {
-        manifestPath = createRequire(`${state.config.paths.project}/package.json`).resolve('vite/package.json');
+        manifestPath = require.resolve('vite/package.json');
     } catch {
         throw new Error("crossbind: crossbind app builds the app's page with the project's Vite, which the project does not have. Add vite and @crossbind/plugin-vite to it, as the desktop-app template has them.");
     }
-    // A workspace can map vite to a package of Vite's API alone.
+    // A workspace can map vite to a package of Vite's API alone, as vite-plus maps it to vite-plus-core.
     const { name, version, bin } = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-    if (!bin?.vite) {
-        throw new Error(`crossbind: crossbind app runs the vite command, and the project's vite resolves to ${name} ${version}, which has none. Have vite resolve to Vite itself for the project, with an override where its workspace maps vite to another package.`);
+    if (bin?.vite) return path.join(path.dirname(manifestPath), bin.vite);
+    const cli = viteCliBesideEntry(require, path.dirname(manifestPath));
+    if (!cli) {
+        throw new Error(`crossbind: crossbind app runs the project's Vite, and its vite resolves to ${name} ${version}, which has neither a vite command nor Vite's cli.js beside its entry. Have vite resolve to Vite itself for the project, with an override where its workspace maps vite to another package.`);
     }
-    return path.join(path.dirname(manifestPath), bin.vite);
+    return cli;
 }
 
 // The project's Vite, as `crossbind app dev`, `build` and `publish` run it, and its exit code once it ends. A signal sent
@@ -143,11 +159,7 @@ function runVite(args, env) {
     });
 }
 
-function assertAppProject() {
-    if (state.config.target.runtimeEnv !== 'app') {
-        throw new Error("crossbind: crossbind app builds an app, which this project is not: set target: { runtimeEnv: 'app' } in crossbind.config.js, as the desktop-app template does.");
-    }
-}
+const assertAppCommand = () => assertAppProject(state.config, 'crossbind app builds an app');
 
 const commandApp = program.command('app').description('build the project as an app, or open it on the dev server');
 [
@@ -164,12 +176,12 @@ const commandApp = program.command('app').description('build the project as an a
         .allowUnknownOption()
         .allowExcessArguments()
         .action(async ({ platform, device }, command) => {
-            assertAppProject();
+            assertAppCommand();
             // An Android build checks its upload key before the native build, not after it.
             const isAndroidBuild = name === 'build' && (platform ?? process.env.CROSSBIND_APP_PLATFORM) === 'android';
             const { env: signing } = isAndroidBuild ? await releaseSigningEnv() : { env: {} };
             const onDevice = device === undefined ? {} : { CROSSBIND_APP_DEVICE: iosDeviceOption(device, platform ?? process.env.CROSSBIND_APP_PLATFORM) };
-            const env = { ...process.env, ...signing, ...(platform ? { CROSSBIND_APP_PLATFORM: platform } : {}), ...onDevice };
+            const env = { ...process.env, ...signing, CROSSBIND_APP_BUILD: '1', ...(platform ? { CROSSBIND_APP_PLATFORM: platform } : {}), ...onDevice };
             process.exit(await runVite([...(name === 'build' ? ['build'] : []), ...command.args], env));
         });
 });
@@ -195,7 +207,7 @@ commandApp.command('publish')
     .allowUnknownOption()
     .allowExcessArguments()
     .action(async ({ platform }, command) => {
-        assertAppProject();
+        assertAppCommand();
         await publish(command.args, { platform, envPlatform: process.env.CROSSBIND_APP_PLATFORM, runVite });
     });
 

package/src/index.js

@@ -4,10 +4,11 @@ export { default as createLib } from './actions/createLib.js';
 export { default as createBridgeFile } from './actions/createInterface.js';
 export { default as buildWasm } from './actions/buildWasm.js';
 export {
-    default as buildApp, buildProjectApp, publishApp, appLayout, appOutputName, appPlatform, appTargetParams,
+    default as buildApp, buildProjectApp, publishApp, appLayout, appOutputName, appPlatform, appTargetParams, emptyAppOutDir,
 } from './actions/buildApp.js';
 export { checkInstaller, shipApp } from './actions/appInstaller.js';
-export { resolveAppPageApi } from './utils/resolveAppHost.js';
+export { findAppPageApi, resolveAppPageApi } from './utils/resolveAppHost.js';
+export { default as isAppBuild } from './utils/appBuild.js';
 export { default as openInSimulator, buildForSimulator } from './actions/iosSimulator.js';
 export {
     default as openOnIosDevice, buildForIosDevice, connectedIosDevice, iosDeviceAddress, iosDevServer,

package/src/state/index.js

@@ -10,6 +10,7 @@ import { exportWasiSdkPath } from '../utils/wasiToolchain.js';
 import loadConfig, { assertBinarySelection } from './loadConfig.js';
 import { configChangesOf } from '../utils/configChanges.js';
 import refreshPackageSources from './refreshPackageSources.js';
+import xcframeworkSliceOf from '../utils/xcframeworkSlice.js';
 
 const cacheDir = `${process.cwd()}/.crossbind`;
 
@@ -97,6 +98,7 @@ export function setAllDependecyPaths() {
     state.config.allDependencyPaths = {};
     state.targets.forEach((target) => {
         state.config.allDependencyPaths[target.path] = { cmake: {} };
+        const owners = new Map();
         state.config.allDependencies.forEach((d) => {
             state.config.allDependencyPaths[target.path].cmake[d.general.name] = `${d.paths.output}/prebuilt`;
             // A package source's recipe can name a library on another platform only (libpng is png16 on Windows).
@@ -105,6 +107,11 @@ export function setAllDependecyPaths() {
                     .some((targetPath) => fs.existsSync(`${d.paths.output}/prebuilt/${targetPath}/lib/lib${name}.a`)))
                 : d.export.libName;
             libNames.forEach((name) => {
+                // A project can list a port's packages for several platforms, which share the library's name: the one
+                // that serves the target keeps the entry.
+                const owner = owners.get(name);
+                if (owner && owner !== d && d.functions?.isEnabled?.(target) === false) return;
+                owners.set(name, d);
                 state.config.allDependencyPaths[target.path][name] = {
                     root: `${d.paths.output}/prebuilt/${target.path}`,
                 };
@@ -118,12 +125,7 @@ export function setAllDependecyPaths() {
                 const isDynamicLib = target.platform === 'android' && platformConfig.libType !== 'static';
                 const dep = state.config.allDependencyPaths[target.path][name];
                 if (target.platform === 'ios') {
-                    let xcRoot;
-                    if (target.arch === 'iphoneos') {
-                        xcRoot = `${d.paths.project}/${name}.xcframework/ios-arm64`;
-                    } else if (target.arch === 'iphonesimulator') {
-                        xcRoot = `${d.paths.project}/${name}.xcframework/ios-arm64-simulator`;
-                    }
+                    const xcRoot = xcframeworkSliceOf(d.paths.project, name, target);
                     dep.header = `${xcRoot}/Headers`;
                     dep.libPath = xcRoot;
                     dep.lib = `${dep.libPath}/lib${name}.a`;

package/src/utils/appApiHeader.js

@@ -1,15 +1,15 @@
 // <crossbind/app.h>, which an app's own code includes for the host's functions (docs/api/app.md).
 
 import fs from 'node:fs';
-import state from '../state/index.js';
+import isAppBuild from './appBuild.js';
 import resolveAppHostRoot from './resolveAppHost.js';
 import { runtimeEnvsOf } from './targets.js';
 
-// An app project's native code compiles against the header, with CROSSBIND_APP defined, on every platform an app runs
-// on, and in every flavour of that platform's archives, which share one build. A library and an app's web build get
-// neither.
+// In a run that builds an app its project's native code compiles against the header, with CROSSBIND_APP defined, on every
+// platform an app runs on, and in every flavour of that platform's archives, which share one build. A library and an
+// app's web build get neither.
 export function compilesAsApp(target) {
-    return state.config.target?.runtimeEnv === 'app' && runtimeEnvsOf(target.platform).includes('app');
+    return isAppBuild() && runtimeEnvsOf(target.platform).includes('app');
 }
 
 // What an app's own code compiles with: CROSSBIND_APP, and on iOS its debug information, from which the archive's dSYM

package/src/utils/appBuild.js

@@ -0,0 +1,8 @@
+import state from '../state/index.js';
+
+// Whether this run builds an app: crossbind app says so to the bundler it starts, CROSSBIND_APP_PLATFORM names an app's
+// platform, or the project is an app alone by target.runtimeEnv. Without any of these a bundler plugin builds what a
+// browser loads, so one project makes both by the command that builds it.
+export default function isAppBuild(env = process.env) {
+    return env.CROSSBIND_APP_BUILD === '1' || Boolean(env.CROSSBIND_APP_PLATFORM) || state.config.target?.runtimeEnv === 'app';
+}

package/src/utils/appProject.js

@@ -0,0 +1,24 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const APP_HOST = '@crossbind/core-app-host';
+
+function listsAppHost(project) {
+    const manifest = path.join(project, 'package.json');
+    if (!fs.existsSync(manifest)) return false;
+    const { dependencies, devDependencies } = JSON.parse(fs.readFileSync(manifest, 'utf8'));
+    return Boolean(dependencies?.[APP_HOST] ?? devDependencies?.[APP_HOST]);
+}
+
+// A project an app builds from: one that says it is an app, or that has the app host and leaves its environment to the
+// command that builds it.
+export const isAppProject = ({ target, paths }) => target?.runtimeEnv === 'app' || (!target?.runtimeEnv && listsAppHost(paths.project));
+
+// Stops what only an app does, in a project that is none, saying what would make it one.
+export function assertAppProject(config, doing) {
+    if (isAppProject(config)) return;
+    const { runtimeEnv } = config.target;
+    throw new Error(runtimeEnv
+        ? `crossbind: ${doing}, and this project's target.runtimeEnv says ${runtimeEnv}: leave it out, or set it to 'app'.`
+        : `crossbind: ${doing}, which this project is not: add ${APP_HOST} to its devDependencies, as the desktop-app template does.`);
+}

package/src/utils/resolveAppHost.js

@@ -26,3 +26,13 @@ export function resolveAppPageApi() {
     if (!fs.existsSync(file)) throw new Error(`crossbind: the app host at ${resolveAppHostRoot()} has no crossbind/app for an app's page: update ${PKG} to match crossbind.`);
     return fs.realpathSync(file);
 }
+
+// The same for a page a bundler builds for the browser, where a project has the app host: code an app shares with its
+// web build still bundles, and what it calls rejects as outside an app. A project without the host has none.
+export function findAppPageApi() {
+    try {
+        return resolveAppPageApi();
+    } catch {
+        return null;
+    }
+}

package/src/utils/xcframeworkSlice.js

@@ -0,0 +1,6 @@
+// The slice of a package's <name>.xcframework that an iOS target links: crossbind's packages carry arm64 alone.
+const SLICES = { iphoneos: 'ios-arm64', iphonesimulator: 'ios-arm64-simulator' };
+
+export default function xcframeworkSliceOf(projectPath, name, target) {
+    return `${projectPath}/${name}.xcframework/${SLICES[target.arch]}`;
+}