initializr/js-port: drop native-JS zip; build the Generate zip in-Java

With the translator fixes (synchronous-native classification + inherited
static-field resolution), the pure-Java zip (net.sf.zipme via STORED) now runs
fast on the JavaScript port -- ~100ms for the full ~1MB project zip -- instead
of hanging or hitting a null DeflaterConstants static. So the native-JS zip
shim (an @JSBody that hand-assembled the archive over the raw arrays) is no
longer needed.

- Remove buildAndDownloadZip from CodenameOneImplementation/Display/CN and the
  jsBuildZipDataUrl @JSBody from HTML5Implementation.
- GeneratorModel.generate() builds the STORED zip in-Java on every platform
  (including JS) and delivers it via downloadBytesAsFile, falling back to
  storage + execute() when unsupported.

Verified end-to-end on a locally built JS bundle: clean boot, no errors,
Generate downloads a valid 63-entry project zip (unzip -t clean).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: shai-almog

CodenameOne/src/com/codename1/impl/CodenameOneImplementation.java

@@ -4527,28 +4527,6 @@ public boolean downloadBytesAsFile(String fileName, byte[] bytes) {
         return false;
     }
 
-    /// Builds a ZIP archive from the given entries and offers it to the user as a
-    /// downloadable file, performing the (byte-heavy) archive assembly natively
-    /// where that is dramatically faster than a pure-Java zip. This exists for
-    /// the JavaScript port: there, every Java method is compiled to a cooperative
-    /// generator, so a pure-Java DEFLATE/CRC over multi-megabyte project bytes is
-    /// pathologically slow (millions of generator resumes) and effectively hangs.
-    /// The JS port overrides this to assemble the zip in native JavaScript over
-    /// the underlying arrays. Returns `true` if the platform handled the build and
-    /// download, `false` (the default) when unsupported -- callers then fall back
-    /// to a normal in-Java zip + {@link #downloadBytesAsFile}.
-    ///
-    /// #### Parameters
-    ///
-    /// - `fileName`: the suggested file name for the download
-    ///
-    /// - `names`: the entry path names, parallel to `data`
-    ///
-    /// - `data`: the entry contents, parallel to `names`
-    public boolean buildAndDownloadZip(String fileName, String[] names, byte[][] data) {
-        return false;
-    }
-
     /// Returns one of the density variables appropriate for this device, notice that
     /// density doesn't always correspond to resolution and an implementation might
     /// decide to change the density based on DPI constraints.

CodenameOne/src/com/codename1/ui/CN.java

@@ -712,24 +712,6 @@ public static boolean downloadBytesAsFile(String fileName, byte[] bytes) {
         return Display.impl.downloadBytesAsFile(fileName, bytes);
     }
 
-    /// Builds a ZIP from the given entries and offers it as a download, assembling
-    /// the archive natively where that is far faster than a pure-Java zip (the
-    /// JavaScript port, whose generator-based execution makes a pure-Java
-    /// DEFLATE/CRC over multi-megabyte input effectively hang). Returns {@code
-    /// true} if handled, {@code false} when unsupported -- callers then fall back
-    /// to an in-Java zip + {@link #downloadBytesAsFile}.
-    ///
-    /// #### Parameters
-    ///
-    /// - `fileName`: the suggested file name for the download
-    ///
-    /// - `names`: the entry path names, parallel to `data`
-    ///
-    /// - `data`: the entry contents, parallel to `names`
-    public static boolean buildAndDownloadZip(String fileName, String[] names, byte[][] data) {
-        return Display.impl.buildAndDownloadZip(fileName, names, data);
-    }
-
 
     /// Returns one of the density variables appropriate for this device, notice that
     /// density doesn't always correspond to resolution and an implementation might

CodenameOne/src/com/codename1/ui/Display.java

@@ -3909,24 +3909,6 @@ public boolean downloadBytesAsFile(String fileName, byte[] bytes) {
         return impl.downloadBytesAsFile(fileName, bytes);
     }
 
-    /// Builds a ZIP from the given entries and offers it as a download, assembling
-    /// the archive natively where that is far faster than a pure-Java zip (the
-    /// JavaScript port). Returns {@code true} if handled, {@code false} when
-    /// unsupported -- callers then fall back to an in-Java zip + {@link
-    /// #downloadBytesAsFile}. See {@link
-    /// com.codename1.impl.CodenameOneImplementation#buildAndDownloadZip}.
-    ///
-    /// #### Parameters
-    ///
-    /// - `fileName`: the suggested file name for the download
-    ///
-    /// - `names`: the entry path names, parallel to `data`
-    ///
-    /// - `data`: the entry contents, parallel to `names`
-    public boolean buildAndDownloadZip(String fileName, String[] names, byte[][] data) {
-        return impl.buildAndDownloadZip(fileName, names, data);
-    }
-
     /// Returns one of the density variables appropriate for this device, notice that
     /// density doesn't always correspond to resolution and an implementation might
     /// decide to change the density based on DPI constraints.

Ports/JavaScriptPort/src/main/java/com/codename1/impl/html5/HTML5Implementation.java

@@ -5637,104 +5637,6 @@ public void run() {
     }
 
 
-    /**
-     * JS-port-only fast path for "zip these entries and download them". A
-     * pure-Java zip (net.sf.zipme) is unusable here: every Java method is
-     * compiled to a cooperative generator, so the DEFLATE compress loop -- and
-     * even a STORED entry's per-byte CRC32 -- runs millions of generator
-     * resumes over multi-megabyte project bytes and effectively hangs. This
-     * assembles a STORED zip (with CRC) entirely in native JavaScript over the
-     * underlying arrays (a Java byte[] is a plain JS Array, so JS reads it at
-     * native speed with no marshalling copy), base64-encodes it into a data:
-     * URL, and reuses the proven save-blob-dataurl main-thread delivery (the
-     * same path {@link #downloadBytesAsFile} uses). Entry names are passed as
-     * UTF-8 byte arrays so no VM-String->JS-string conversion is needed.
-     */
-    public boolean buildAndDownloadZip(final String fileName, String[] names, byte[][] data) {
-        if (fileName == null || names == null || data == null || names.length != data.length) {
-            return false;
-        }
-        byte[][] nameBytes = new byte[names.length][];
-        for (int i = 0; i < names.length; i++) {
-            String n = names[i] == null ? "" : names[i];
-            try {
-                nameBytes[i] = n.getBytes("UTF-8");
-            } catch (java.io.UnsupportedEncodingException e) {
-                nameBytes[i] = n.getBytes();
-            }
-        }
-        String dataUrl;
-        try {
-            dataUrl = jsBuildZipDataUrl(nameBytes, data);
-        } catch (Throwable t) {
-            return false;
-        }
-        if (dataUrl == null || dataUrl.length() == 0) {
-            return false;
-        }
-        registerSaveBlobHandlerDataUrl(fileName, dataUrl);
-        if (isBacksideHookAvailable()) {
-            addBacksideHook(new JSRunnable() {
-                public void run() {
-                    fireSaveBlobHandler();
-                }
-            });
-            return true;
-        }
-        try {
-            fireSaveBlobHandler();
-            return true;
-        } catch (Throwable t) {
-            return false;
-        }
-    }
-
-    // Assembles a STORED zip in native JS over the plain arrays and returns it
-    // as a base64 "data:" URL. Runs straight through (no yield): the byte loops
-    // are native JS, NOT generator-wrapped Java, which is the whole point.
-    @JSBody(params={"nameBytes", "data"}, script=
-        "var n = data.length;\n" +
-        "var crcTab = new Int32Array(256);\n" +
-        "for (var c = 0; c < 256; c++) { var k = c; for (var b = 0; b < 8; b++) { k = (k & 1) ? (0xEDB88320 ^ (k >>> 1)) : (k >>> 1); } crcTab[c] = k; }\n" +
-        "function crc32(arr) { var crc = 0xFFFFFFFF; var len = arr.length; for (var i = 0; i < len; i++) { crc = crcTab[(crc ^ (arr[i] & 0xff)) & 0xff] ^ (crc >>> 8); } return (crc ^ 0xFFFFFFFF) >>> 0; }\n" +
-        "var crcs = new Array(n);\n" +
-        "var total = 0;\n" +
-        "for (var i = 0; i < n; i++) { crcs[i] = crc32(data[i]); total += 30 + nameBytes[i].length + data[i].length; total += 46 + nameBytes[i].length; }\n" +
-        "total += 22;\n" +
-        "var out = new Uint8Array(total);\n" +
-        "var p = 0;\n" +
-        "function u16(v) { out[p++] = v & 0xff; out[p++] = (v >>> 8) & 0xff; }\n" +
-        "function u32(v) { out[p++] = v & 0xff; out[p++] = (v >>> 8) & 0xff; out[p++] = (v >>> 16) & 0xff; out[p++] = (v >>> 24) & 0xff; }\n" +
-        "function bytes(arr) { var len = arr.length; for (var i = 0; i < len; i++) { out[p++] = arr[i] & 0xff; } }\n" +
-        "var offsets = new Array(n);\n" +
-        "for (var i = 0; i < n; i++) {\n" +
-        "  offsets[i] = p;\n" +
-        "  u32(0x04034b50); u16(20); u16(0); u16(0); u16(0); u16(0);\n" +
-        "  u32(crcs[i]); u32(data[i].length); u32(data[i].length); u16(nameBytes[i].length); u16(0);\n" +
-        "  bytes(nameBytes[i]); bytes(data[i]);\n" +
-        "}\n" +
-        "var cdStart = p;\n" +
-        "for (var i = 0; i < n; i++) {\n" +
-        "  u32(0x02014b50); u16(20); u16(20); u16(0); u16(0); u16(0); u16(0);\n" +
-        "  u32(crcs[i]); u32(data[i].length); u32(data[i].length); u16(nameBytes[i].length); u16(0); u16(0); u16(0); u16(0); u32(0); u32(offsets[i]);\n" +
-        "  bytes(nameBytes[i]);\n" +
-        "}\n" +
-        "var cdSize = p - cdStart;\n" +
-        "u32(0x06054b50); u16(0); u16(0); u16(n); u16(n); u32(cdSize); u32(cdStart); u16(0);\n" +
-        "var B = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n" +
-        "var res = [];\n" +
-        "var len = out.length;\n" +
-        "var i = 0;\n" +
-        "while (i < len) {\n" +
-        "  var b0 = out[i++];\n" +
-        "  var have1 = i < len; var b1 = have1 ? out[i++] : 0;\n" +
-        "  var have2 = i < len; var b2 = have2 ? out[i++] : 0;\n" +
-        "  var t = (b0 << 16) | (b1 << 8) | b2;\n" +
-        "  res.push(B.charAt((t >>> 18) & 63) + B.charAt((t >>> 12) & 63) + (have1 ? B.charAt((t >>> 6) & 63) : '=') + (have2 ? B.charAt(t & 63) : '='));\n" +
-        "}\n" +
-        "return 'data:application/zip;base64,' + res.join('');\n")
-    private static native String jsBuildZipDataUrl(byte[][] nameBytes, byte[][] data);
-
     public boolean paintNativePeersBehind() {
         return true;
     }

scripts/initializr/common/src/main/java/com/codename1/initializr/model/GeneratorModel.java

@@ -126,28 +126,12 @@ public void generate() {
             return;
         }
 
-        // JavaScript port: assemble the zip AND drive the download natively.
-        // A pure-Java zip is unusable on that port -- every Java method is a
-        // cooperative generator, so a DEFLATE compress loop (and even a STORED
-        // entry's per-byte CRC32) over multi-MB of project bytes runs millions
-        // of generator resumes and effectively hangs. buildAndDownloadZip does
-        // the byte-heavy work in native JS over the underlying arrays. On other
-        // platforms it returns false and we build the zip in-Java below.
-        String[] names = new String[entries.size()];
-        byte[][] data = new byte[entries.size()][];
-        int idx = 0;
-        for (Map.Entry<String, byte[]> e : entries.entrySet()) {
-            names[idx] = e.getKey();
-            data[idx] = e.getValue();
-            idx++;
-        }
-        if (buildAndDownloadZip(fileName, names, data)) {
-            return;
-        }
-
-        // Other platforms: build the zip in-Java, then hand the bytes to the
-        // platform downloader; falls through to storage + execute() when
-        // unsupported.
+        // Build the project zip in memory. This runs on every platform,
+        // including the JavaScript port: the in-Java zip is fast there now that
+        // the translator no longer wraps synchronous natives (arraycopy/CRC) in
+        // cooperative generators and resolves inherited interface static fields
+        // correctly. Then hand the bytes to the platform downloader; falls
+        // through to the storage + execute() path when unsupported.
         byte[] bytes;
         try {
             ByteArrayOutputStream bos = new ByteArrayOutputStream();
@@ -221,8 +205,7 @@ void writeProjectZip(OutputStream outputStream) throws IOException {
 
     /// Reads every entry (IDE scaffold, common files, template sources, cn1libs,
     /// localization, generated README/.gitignore/skills) into an ordered map of
-    /// path -> bytes. This is the I/O phase; the zip assembly is separate so the
-    /// JavaScript port can hand the raw entries to {@code buildAndDownloadZip}.
+    /// path -> bytes. This is the I/O phase, kept separate from the zip assembly.
     Map<String, byte[]> collectProjectEntries() throws IOException {
         Map<String, byte[]> mergedEntries = new LinkedHashMap<String, byte[]>();
 
@@ -244,11 +227,11 @@ Map<String, byte[]> collectProjectEntries() throws IOException {
     }
 
     /// Writes the collected entries as a STORED (uncompressed) zip. STORED rather
-    /// than DEFLATED because the zipme Deflater is unusably slow on the
-    /// JavaScript port; STORED is used uniformly (the size cost is irrelevant for
-    /// a one-off scaffold download, and other platforms only reach this in-Java
-    /// path as a fallback). The JavaScript port does not use this method -- it
-    /// assembles the zip natively via {@code buildAndDownloadZip}.
+    /// than DEFLATED keeps the byte work minimal (CRC + copy, no compression
+    /// engine); the size cost is irrelevant for a one-off scaffold download.
+    /// Used on every platform including the JavaScript port, where it is fast now
+    /// that the translator no longer wraps synchronous natives in generators and
+    /// resolves inherited interface static fields correctly.
     void writeEntriesToZip(OutputStream outputStream, Map<String, byte[]> mergedEntries) throws IOException {
         try (ZipOutputStream zos = new ZipOutputStream(outputStream)) {
             zos.setMethod(ZipOutputStream.STORED);