crossbind 2.0.0-beta.58 → 2.0.0-beta.62

package/src/utils/swigInterface.js

@@ -1,4 +1,5 @@
 import upath from 'upath';
+import { ALL_NAMES } from './headerImports.js';
 
 // Libraries whose headers are not self-contained (spatialite expects sqlite3.h first) list the
 // prerequisites in export.headerPrelude of the package that ships the header: its output or project
@@ -39,7 +40,7 @@ export function interfaceIncludes(headerPath, prelude = []) {
 
 // The prelude and the completing includes reach only the compiled wrapper and swigMacros only SWIG's parse: SWIG still
 // wraps just the imported header. The ignored declarations follow the macros, so the retry without macros keeps them.
-export function buildInterfaceContent({ moduleName, headerPath, prelude = [], completing = [], swigMacros = [], ignored = [] }) {
+export function buildInterfaceContent({ moduleName, headerPath, prelude = [], completing = [], swigMacros = [], ignored = [], constants = [] }) {
     const includes = [...new Set([...interfaceIncludes(headerPath, prelude), ...completing])]
         .map((header) => `#include "${header}"`)
         .join('\n');
@@ -55,7 +56,7 @@ export function buildInterfaceContent({ moduleName, headerPath, prelude = [], co
 ${includes}
 %}
 
-%feature("shared_ptr");
+${constantRequests(constants)}%feature("shared_ptr");
 %feature("polymorphic_shared_ptr");
 
 ${macros}${ignores}%include "${headerPath}"
@@ -64,6 +65,12 @@ ${macros}${ignores}%include "${headerPath}"
 `;
 }
 
+// SWIG binds a constant only on request, so a header's thousands of macros cost nothing until the app imports one.
+function constantRequests(constants) {
+    if (constants === ALL_NAMES) return '%feature("embind:constant");\n\n';
+    return constants.length ? `${constants.map((name) => `%feature("embind:constant") ${name};`).join('\n')}\n\n` : '';
+}
+
 export function withoutSwigMacros(content) {
     return content.replace(/(%feature\("polymorphic_shared_ptr"\);\n\n)(?:#define [^\n]*\n)+\n/, '$1');
 }
@@ -111,7 +118,7 @@ const tokenize = (text) => text.match(TOKEN) ?? [];
 const identifiers = (text) => tokenize(text).filter((token) => IDENTIFIER.test(token));
 // Lines are spliced before comments go, as in the compiler, and a comment marker inside a literal is text.
 const LITERAL_OR_COMMENT = /"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'|\/\*[\s\S]*?\*\/|\/\/[^\n]*/g;
-const stripComments = (text) => text
+export const stripComments = (text) => text
     .replace(/\\\r?\n/g, ' ')
     .replace(LITERAL_OR_COMMENT, (match) => (match.startsWith('/') ? ' ' : match));
 
@@ -154,7 +161,7 @@ function headerReferences(headerText) {
 // SWIG parses only the imported header, so export, linkage and attribute macros from its #includes read as syntax
 // errors. Those come from the compiler's macro table, with the flags and versions its #if lines test; type and value
 // macros stay undefined so every platform's compiler resolves them.
-export function selectSwigMacros({ headerText, macros, predefined }) {
+export function selectSwigMacros({ headerText, macros, predefined, constants = [] }) {
     const memoize = (classify) => {
         const results = new Map();
         const check = (name) => {
@@ -190,6 +197,14 @@ export function selectSwigMacros({ headerText, macros, predefined }) {
     };
     declarations.forEach((name) => forward(name, isSyntax));
     conditions.forEach((name) => forward(name, isConstant));
+    // An imported constant reaches SWIG with the macros its value uses, so SWIG can type it: SWIG reads no #include, and
+    // drops a constant whose value uses a macro it has not seen.
+    const isObjectConstant = (name) => !macros.get(name).params && isConstant(name);
+    const imported = constants === ALL_NAMES ? [...defined] : constants;
+    imported.forEach((name) => {
+        if (!defined.has(name)) forward(name, isObjectConstant);
+        else identifiers(macros.get(name)?.body ?? '').forEach((token) => forward(token, isObjectConstant));
+    });
 
     const visible = new Set([
         ...tokenize(stripComments(headerText)),

package/src/utils/systemKeys.js

@@ -24,6 +24,14 @@ const systemKeys = {
         description: 'Image reference used for android builds instead of the pinned one. A reference without the release digest disables the reproducibility guarantee. The CROSSBIND_IMAGE_ANDROID environment variable overrides it.',
         default: '',
     },
+    DOCKER_IMAGE_LINUX: {
+        description: 'Image reference used for linux (Node.js addon) builds instead of the pinned one. A reference without the release digest disables the reproducibility guarantee. The CROSSBIND_IMAGE_LINUX environment variable overrides it.',
+        default: '',
+    },
+    DOCKER_IMAGE_WINDOWS: {
+        description: 'Image reference used for win32 (Node.js addon) builds instead of the pinned one. A reference without the release digest disables the reproducibility guarantee. The CROSSBIND_IMAGE_WINDOWS environment variable overrides it.',
+        default: '',
+    },
 };
 
 export default systemKeys;

package/src/utils/targets.js

@@ -92,12 +92,68 @@ export const TARGETS = [
     {
         platform: 'ios', arch: 'iphonesimulator', runtime: 'mt', buildType: 'debug',
     },
+    {
+        platform: 'darwin', arch: 'arm64', runtime: 'mt', buildType: 'release', runtimeEnv: 'node',
+    },
+    {
+        platform: 'darwin', arch: 'arm64', runtime: 'mt', buildType: 'debug', runtimeEnv: 'node',
+    },
+    {
+        platform: 'darwin', arch: 'x64', runtime: 'mt', buildType: 'release', runtimeEnv: 'node',
+    },
+    {
+        platform: 'darwin', arch: 'x64', runtime: 'mt', buildType: 'debug', runtimeEnv: 'node',
+    },
+    {
+        platform: 'linux', arch: 'arm64', runtime: 'mt', buildType: 'release', runtimeEnv: 'node',
+    },
+    {
+        platform: 'linux', arch: 'arm64', runtime: 'mt', buildType: 'debug', runtimeEnv: 'node',
+    },
+    {
+        platform: 'linux', arch: 'x64', runtime: 'mt', buildType: 'release', runtimeEnv: 'node',
+    },
+    {
+        platform: 'linux', arch: 'x64', runtime: 'mt', buildType: 'debug', runtimeEnv: 'node',
+    },
+    {
+        platform: 'win32', arch: 'arm64', runtime: 'mt', buildType: 'release', runtimeEnv: 'node',
+    },
+    {
+        platform: 'win32', arch: 'arm64', runtime: 'mt', buildType: 'debug', runtimeEnv: 'node',
+    },
+    {
+        platform: 'win32', arch: 'x64', runtime: 'mt', buildType: 'release', runtimeEnv: 'node',
+    },
+    {
+        platform: 'win32', arch: 'x64', runtime: 'mt', buildType: 'debug', runtimeEnv: 'node',
+    },
 ];
 
+// Built only when named with -p: a plain `crossbind build` keeps producing what it did before
+// native Node.js addons existed.
+export const OPT_IN_PLATFORMS = ['darwin', 'linux', 'win32'];
+
+// Built on the host itself: Apple's linker and SDKs exist in no toolchain image.
+export const HOST_BUILT_PLATFORMS = ['ios', 'darwin'];
+
 export function targetPathOf(target) {
     return `${target.platform}-${target.arch}-${target.runtime}-${target.buildType}`;
 }
 
+// Every platform/arch addon of one build type sits next to a single loader, which fills in
+// {platform} and {arch} from the running process. The loader is CommonJS whatever the package
+// "type" says, since it needs __dirname and process.dlopen.
+export function nodeAddonNamesOf(target, projectName) {
+    const suffix = target.buildType === 'debug' ? '.debug' : '';
+    const addonPattern = `${projectName}.{platform}-{arch}${suffix}.node`;
+    return {
+        addonPattern,
+        addonName: addonPattern.replace('{platform}', target.platform).replace('{arch}', target.arch),
+        jsName: `${projectName}.native${suffix}.cjs`,
+    };
+}
+
 export function filterTargetSpecs(targetSpecs, target) {
     return targetSpecs?.filter(t => (
         (!t.platform || t.platform === target.platform)

package/src/utils/cppFieldBindings.js

@@ -1,23 +0,0 @@
-// SWIG's -embind backend emits functions and constructors but no member variables, so
-// public fields never reach JS from the generated bridge alone. This post-pass injects
-// embind .property lines for the value-semantics fields parseCppSurface captured - the
-// same post-processing precedent as bridgeAsyncGuard.
-
-export function buildFieldPropertyLines(cls) {
-    return (cls.fields ?? []).map((f) => `.property("${f.name}", &${cls.name}::${f.name})`);
-}
-
-export function injectFieldBindings(bridgeContent, model) {
-    let out = bridgeContent;
-    for (const cls of model.classes ?? []) {
-        const lines = buildFieldPropertyLines(cls)
-            .filter((line) => !out.includes(line));
-        if (!lines.length) continue;
-        // Lazy template match still lands on the right opener: the first `>(\s*"Name")`
-        // closes the template list even when it contains nested arguments like base<T>.
-        const opener = new RegExp(`(emscripten::class_<[\\s\\S]*?>\\s*\\(\\s*"${cls.name}"\\s*\\))`);
-        if (!opener.test(out)) continue;
-        out = out.replace(opener, `$1\n    ${lines.join('\n    ')}`);
-    }
-    return out;
-}