Special-case dragging in of .zip files created by modern macOS

They contain resource forks and Finder metadata, thus are a good way of
doing a full-fidelity import.

Fixes #255

Author: mihaip

src/emulator/emulator-finder.ts

@@ -87,3 +87,19 @@ function getDebugFinderFlags(flags: number): string[] {
     }
     return result;
 }
+
+/**
+ * Given a serialized FInfo struct, checks to see if the location data is
+ * present. If it's not, it clears the "has been inited" flag so that the Finder
+ * assigns a position to the item when it loads it.
+ */
+export function fixArchiveFinderInfo(buffer: ArrayBuffer) {
+    const fInfoView = new DataView(buffer);
+    const x = fInfoView.getInt16(FInfoFields.fdLocation);
+    const y = fInfoView.getInt16(FInfoFields.fdLocation + 2);
+    if (x === 0 && y === 0) {
+        let flags = fInfoView.getInt16(FInfoFields.fdFlags);
+        flags &= ~FinderFlags.kHasBeenInited;
+        fInfoView.setInt16(FInfoFields.fdFlags, flags);
+    }
+}

src/emulator/emulator-ui-extractor.ts

@@ -6,8 +6,18 @@ import {
     type EmulatorWorkerDirectorExtractionEntry,
 } from "./emulator-common";
 import * as varz from "../varz";
+import {fixArchiveFinderInfo} from "./emulator-finder";
 
-export async function uploadsFromDirectoryExtractionFile(
+export async function uploadsFromFile(
+    file: File
+): Promise<EmulatorFileUpload[] | undefined> {
+    return (
+        (await uploadsFromDirectoryExtractionFile(file)) ??
+        (await uploadsFromMacOSArchive(file))
+    );
+}
+
+async function uploadsFromDirectoryExtractionFile(
     file: File
 ): Promise<EmulatorFileUpload[] | undefined> {
     if (!file.name.endsWith(".zip")) {
@@ -41,6 +51,127 @@ export async function uploadsFromDirectoryExtractionFile(
     });
 }
 
+/**
+ * Special-cases .zips created by modern macOS, which persist extra information
+ * (resource forks and Finder info metadata) in a parallel __MACOSX directory
+ * structure using AppleDouble-encoded files.
+ */
+async function uploadsFromMacOSArchive(
+    file: File
+): Promise<EmulatorFileUpload[] | undefined> {
+    if (!file.name.endsWith(".zip")) {
+        return undefined;
+    }
+    const zip = await JSZip.loadAsync(file);
+    const appleDoubleFiles = Object.values(zip.files).filter(
+        f => !f.dir && f.name.startsWith("__MACOSX")
+    );
+    // Not a macOS-created archive.
+    if (!appleDoubleFiles.length) {
+        return undefined;
+    }
+    const parentName = file.name.slice(0, -4);
+    // Directories are implicitly created
+    const files = Object.values(zip.files).filter(
+        f => !f.dir && !f.name.startsWith("__MACOSX")
+    );
+    const prefix = files.every(f => f.name.startsWith(parentName))
+        ? ""
+        : parentName + "/";
+
+    const fileBlobs = await Promise.all(files.map(f => f.async("blob")));
+    const uploads = files.map((f, i) => {
+        const blob = fileBlobs[i];
+        const url = URL.createObjectURL(blob);
+        return {
+            name: prefix + f.name,
+            url,
+            size: blob.size,
+        };
+    });
+
+    const appleDoubleBuffers = await Promise.all(
+        appleDoubleFiles.map(f => f.async("arraybuffer"))
+    );
+    for (let i = 0; i < appleDoubleFiles.length; i++) {
+        const file = appleDoubleFiles[i];
+        const buffer = appleDoubleBuffers[i];
+
+        const path = file.name.split("/");
+        path.shift(); // Drop the __MACOSX directory
+        let name = path.pop()!;
+        if (name.startsWith("._")) {
+            name = name.substring(2);
+        }
+        const {resourceFork, metadata} = parseAppleDouble(buffer, name);
+        if (resourceFork) {
+            const url = URL.createObjectURL(resourceFork);
+            uploads.push({
+                name: prefix + [...path, ".rsrc", name].join("/"),
+                url,
+                size: resourceFork.size,
+            });
+        }
+        if (metadata) {
+            const url = URL.createObjectURL(metadata);
+            uploads.push({
+                name: prefix + [...path, ".finf", name].join("/"),
+                url,
+                size: metadata.size,
+            });
+        }
+    }
+    return uploads;
+}
+
+function parseAppleDouble(
+    buffer: ArrayBuffer,
+    name: string
+): {
+    resourceFork?: Blob;
+    metadata?: Blob;
+} {
+    const data = new DataView(buffer);
+    const magic = data.getUint32(0);
+    if (magic !== 0x00051607) {
+        throw new Error(`Invalid AppleDouble magic ${magic.toString(16)}`);
+    }
+    const version = data.getUint32(4);
+    if (version !== 0x00020000) {
+        throw new Error(`Invalid AppleDouble version ${version.toString(16)}`);
+    }
+
+    const entryCount = data.getUint16(24);
+    let cursor = 26;
+    let resourceFork;
+    let metadata;
+    for (let i = 0; i < entryCount; i++) {
+        const entryID = data.getUint32(cursor);
+        const offset = data.getUint32(cursor + 4);
+        const length = data.getUint32(cursor + 8);
+        switch (entryID) {
+            case 2:
+                resourceFork = new Blob([
+                    buffer.slice(offset, offset + length),
+                ]);
+                break;
+            case 9: {
+                const metadataBuffer = buffer.slice(offset, offset + length);
+                fixArchiveFinderInfo(metadataBuffer);
+                metadata = new Blob([metadataBuffer]);
+                break;
+            }
+            default:
+                console.log(
+                    `Ignoring unexpected entry ID ${entryID} found in ${name}`
+                );
+        }
+        cursor += 12;
+    }
+
+    return {resourceFork, metadata};
+}
+
 export async function handleDirectoryExtraction(
     extraction: EmulatorWorkerDirectorExtraction
 ) {

src/emulator/emulator-ui.ts

@@ -41,7 +41,7 @@ import {
 } from "./emulator-ui-files";
 import {
     handleDirectoryExtraction,
-    uploadsFromDirectoryExtractionFile,
+    uploadsFromFile,
 } from "./emulator-ui-extractor";
 import {
     JS_CODE_TO_ADB_KEYCODE,
@@ -436,7 +436,7 @@ export class Emulator {
         const remainingNames: string[] = [];
         for (let i = 0; i < files.length; i++) {
             const file = files[i];
-            const uploads = await uploadsFromDirectoryExtractionFile(file);
+            const uploads = await uploadsFromFile(file);
             if (uploads) {
                 this.#files.uploadFiles(uploads);
                 continue;