crossbind 2.0.0-beta.56 → 2.0.0-beta.60

package/src/utils/cppDts.js

@@ -14,7 +14,9 @@ const NUMBER_TYPES = new Set([
     'long long', 'unsigned int', 'unsigned long', 'unsigned short', 'unsigned long long',
 ]);
 
-function tsType(raw, classNames, { nullableSharedPtr = false } = {}) {
+function tsType(raw, classNames, { isReturn = false } = {}) {
+    // A `const char *` crosses as a JS string, null when C++ returns NULL; other pointers stay native memory.
+    if (/^\s*(?:const\s+char|char\s+const)\s*\*\s*$/.test(raw)) return isReturn ? 'string | null' : 'string';
     let t = raw.trim().replace(/\bconst\b/g, '').replace(/&/g, '').trim().replace(/\s+/g, ' ');
     if (t.includes('*')) return null;
     const vector = t.match(/^std::vector<([\s\S]+)>$/);
@@ -26,7 +28,7 @@ function tsType(raw, classNames, { nullableSharedPtr = false } = {}) {
     if (shared) {
         if (!classNames.has(shared[1])) return null;
         // Embind shared_ptr returns can resolve to null; parameters take the plain object.
-        return nullableSharedPtr ? `${shared[1]} | null` : shared[1];
+        return isReturn ? `${shared[1]} | null` : shared[1];
     }
     if (t === 'void') return 'void';
     if (t === 'bool') return 'boolean';
@@ -126,7 +128,8 @@ export function parseCppSurface(source, log = console.log) {
                     : null;
                 if (field) {
                     const type = tsType(field[1], classNames);
-                    if (type !== null && FIELD_TYPES.has(type)) fields.push({ name: field[2], type });
+                    // A reference member has no address a pointer to member could name, and a pointer member is memory.
+                    if (type !== null && FIELD_TYPES.has(type) && !/[&*]/.test(field[1])) fields.push({ name: field[2], type });
                 }
                 continue;
             }
@@ -135,7 +138,7 @@ export function parseCppSurface(source, log = console.log) {
             if (args.includes(null)) { log(`crossbind: dts: skipped ${cls.name}::${name} (unsupported parameter type)`); continue; }
             if (name === cls.name && retRaw.trim() === '') { ctor = { args }; continue; }
             if (name.startsWith('~')) continue;
-            const ret = tsType(retRaw, classNames, { nullableSharedPtr: true });
+            const ret = tsType(retRaw, classNames, { isReturn: true });
             if (ret === null) { log(`crossbind: dts: skipped ${cls.name}::${name} (unsupported return type '${retRaw.trim()}')`); continue; }
             methods.push({ name, isStatic: Boolean(staticKw), args, ret });
         }

package/src/utils/dependencyBridges.js

@@ -0,0 +1,18 @@
+import fs from 'node:fs';
+
+// A bridge's .deps sidecar lists the bridges of the headers defining the types its declarations use. They link into the
+// same module, since embind registers each class and enum once, in the bridge of the header that defines it.
+export function withDependencyBridges(files) {
+    const listed = new Set(files);
+    const added = [];
+    for (const file of files) {
+        const sidecar = `${file}.deps`;
+        if (!fs.existsSync(sidecar)) continue;
+        for (const dependency of fs.readFileSync(sidecar, 'utf8').split('\n').filter(Boolean)) {
+            if (listed.has(dependency) || !fs.existsSync(dependency)) continue;
+            listed.add(dependency);
+            added.push(dependency);
+        }
+    }
+    return [...files, ...added];
+}

package/src/utils/downloadAndExtractFile.js

@@ -6,15 +6,27 @@ import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 
 export default async function downloadAndExtractFile(url, output, sha256) {
-    if (fs.existsSync(`${output}/source`)) {
+    const archive = path.basename(url);
+    if (fs.existsSync(`${output}/source`) && sourceCameFrom(output, archive)) {
         return false;
     }
+    fs.rmSync(`${output}/source`, { recursive: true, force: true });
     const filePath = await downloadFile(url, output);
     verifyIntegrity(filePath, url, sha256);
     extractArchive(filePath, url, output);
+    fs.writeFileSync(`${output}/source.archive`, archive);
     return true;
 }
 
+// A cached source tree only counts when it came from the archive the recipe names now, or a
+// nativeVersion bump would keep compiling the old tree. Trees from before the marker are judged
+// by the archive that was downloaded next to them.
+function sourceCameFrom(output, archive) {
+    const marker = `${output}/source.archive`;
+    if (fs.existsSync(marker)) return fs.readFileSync(marker, 'utf8').trim() === archive;
+    return fs.existsSync(`${output}/${archive}`);
+}
+
 // Extraction runs through the system tar (GNU tar and bsdtar both detect gzip/bzip2/xz, and
 // every platform the engine builds on ships one). Extracting into a scratch directory keeps
 // the archive from choosing where its files land, and gives the upstream root folder - which

package/src/utils/pullDockerImage.js

@@ -89,7 +89,16 @@ export default function pullDockerImage(role = 'web', platform) {
         console.log('============= Downloading the docker image... =============');
         console.log('===========================================================');
         console.log('');
-        execFileSync('docker', ['pull', ref], { stdio: 'inherit' });
+        try {
+            execFileSync('docker', ['pull', ref], { stdio: 'inherit' });
+        } catch (error) {
+            // Docker Desktop's Resource Saver stops the engine after a few idle minutes and answers
+            // `image inspect` from a cache with "No such image" meanwhile; the pull attempt has started
+            // the engine, so only a second lookup tells whether the image is really missing. A local-only
+            // tag (a dev image override) lands here too: its pull is denied, yet the image is present.
+            if (!isImagePresent(ref)) throw error;
+            console.log(`crossbind: ${ref} is present locally, so the failed pull is ignored.`);
+        }
         console.log('');
         console.log('===========================================================');
         console.log('');