fixing some chunking issues

server/main.ts

@@ -6,6 +6,8 @@ import { Router } from "./router.ts";
 import { getPackVersion } from "./util/packVersion.ts";
 import { createTagRoutes } from "./tags/routes.ts";
 import { createResourcesRoutes } from "./resources/routes.ts";
+import { readDirDirs } from "./util/readDir.ts";
+import { unzipResources } from "./resources/unzip.ts";
 
 const installPath = Deno.env.get("BMP_INSTALL_DIR") || "./";
 
@@ -31,6 +33,7 @@ sockpuppet.addHandler((req: Request) => {
 // });
 
 const router = new Router();
+
 router.route("/api/dir")
   .get(async () => {
     using store = new BearMetalStore();
@@ -208,6 +211,15 @@ router.route("/api/pack/version")
         store.get("packlocation") + "/pack.mcmeta",
         JSON.stringify(packMetaJson),
       );
+      const packVersionSchema = Deno.readTextFileSync(
+        installPath + "pack_versions/" + version + ".json",
+      );
+      const packVersionSchemaJson = JSON.parse(packVersionSchema);
+      packVersionSchemaJson.mcVersion = store.get("mcVersion");
+      const versionResourceDir = await readDirDirs(installPath + "resources/");
+      if (!versionResourceDir.includes(version)) {
+        unzipResources();
+      }
     } catch (e: any) {
       return new Response(e, { status: 500 });
     }
@@ -226,6 +238,25 @@ router.route("/api/versions")
 createTagRoutes(router);
 createResourcesRoutes(router);
 
+router.route("/api/stream/test")
+  .get(() => {
+    const stream = new ReadableStream({
+      async start(controller) {
+        const enc = new TextEncoder();
+        controller.enqueue(enc.encode("Hello"));
+        controller.enqueue(enc.encode(", "));
+        controller.enqueue(enc.encode("World!"));
+        controller.close();
+      },
+    });
+    return new Response(stream, {
+      headers: {
+        "content-type": "text/plain",
+        "x-content-type-options": "nosniff",
+      },
+    });
+  })
+
 sockpuppet.addHandler((req: Request) => {
   if (new URL(req.url).pathname.startsWith("/api")) return;
 

server/resources/readers.ts

@@ -2,13 +2,7 @@ import { encodeBase64 } from "@std/encoding/base64";
 import { readDirFiles } from "../util/readDir.ts";
 import { createIsometricCube } from "./renderer.ts";
 
-interface BlockItem {
-  name: string;
-  resourceLocation: string;
-  images: string[];
-}
-
-export const readBlocks = async (path: string) => {
+export const readBlocks = async (path: string, read?: (b: BlockItem, i: number) => void) => {
   const blocks: BlockItem[] =
     (await readDirFiles(path + "/assets/minecraft/blockstates"))
       .map((b) => ({
@@ -300,10 +294,16 @@ export const readBlocks = async (path: string) => {
       block.images.push(await createIsometricCube(b64, b64, b64));
     }
   }
+
+  let i = 0;
+  for (const block of blocks) {
+    read?.(block, i);
+    i++;
+  }
   return blocks;
 };
 
-export const readItems = async (path: string) => {
+export const readItems = async (path: string, read?: (b: BlockItem) => void) => {
   const items: BlockItem[] =
     (await readDirFiles(path + "/assets/minecraft/models/item")).map((i) => ({
       name: i.replace(".json", ""),
@@ -348,6 +348,7 @@ export const readItems = async (path: string) => {
         }
       }
     }
+    read?.(item);
   }
 
   return items;

server/resources/routes.ts

@@ -1,7 +1,8 @@
+import { ensureDir } from "@std/fs/ensure-dir";
 import type { Router } from "../router.ts";
 import { readDirDirs } from "../util/readDir.ts";
 import { versionCompat } from "../util/versionCompat.ts";
-import { readBlocks } from "./readers.ts";
+import { readBlocks, readItems } from "./readers.ts";
 
 export const createResourcesRoutes = (router: Router) => {
   router.route("/api/resources/:path*")
@@ -10,38 +11,92 @@ export const createResourcesRoutes = (router: Router) => {
       if (!path) {
         return new Response("no path provided", { status: 400 });
       }
+
       const format = ctx.url.searchParams.get("format");
       if (!format) {
         return new Response("no format provided", { status: 400 });
       }
+
       const packVersion = await Deno.readTextFile(
         "./pack_versions/" + format + ".json",
       );
       const packVersionJson = JSON.parse(packVersion);
       const mcVersion = packVersionJson.mcVersion;
+
+      await ensureDir("./resources");
       const resourceVersions = await readDirDirs("./resources");
-      console.log("resourceVersions", resourceVersions);
+
       for (const resourceVersion of resourceVersions) {
         if (versionCompat(resourceVersion, mcVersion)) {
           const resourcePath = "./resources/" + resourceVersion;
-          const splitPath = path.split("/");
-          switch (splitPath[0]) {
-            case "block":
-            case "blocks": {
-              return new Response(
-                JSON.stringify(await readBlocks(resourcePath)),
+          let items: BlockItem[] = [];
+
+          const batch = (
+            controller: ReadableStreamDefaultController,
+            res: BlockItem,
+          ) => {
+            items.push(res);
+            if (items.length > 4) {
+              controller.enqueue(
+                new TextEncoder().encode(JSON.stringify(items) + "\n"),
               );
+              items = [];
             }
-            case "item":
-            case "items": {
-              return new Response(
-                JSON.stringify(await readBlocks(resourcePath)),
-              );
-            }
-            default: {
-              return new Response("invalid path", { status: 400 });
-            }
-          }
+          };
+          const body = new ReadableStream({
+            async start(controller) {
+              switch (path) {
+                case "block":
+                case "blocks": {
+                  await readBlocks(resourcePath, (res, i) => {
+                    console.log(i);
+                    batch(controller, res);
+                  });
+                  controller.close();
+                  break;
+                }
+                case "item":
+                case "items": {
+                  await readItems(resourcePath, (res) => {
+                    batch(controller, res);
+                  });
+                  controller.close();
+                  break;
+                }
+                default: {
+                  controller.close();
+                  break;
+                }
+              }
+            },
+          });
+
+          return new Response(body, {
+            headers: {
+              "content-type": "application/json",
+              "access-control-allow-origin": "*",
+            },
+          });
+
+          // const resourcePath = "./resources/" + resourceVersion;
+          // const splitPath = path.split("/");
+          // switch (splitPath[0]) {
+          //   case "block":
+          //   case "blocks": {
+          //     return new Response(
+          //       JSON.stringify(await readBlocks(resourcePath)),
+          //     );
+          //   }
+          //   case "item":
+          //   case "items": {
+          //     return new Response(
+          //       JSON.stringify(await readBlocks(resourcePath)),
+          //     );
+          //   }
+          //   default: {
+          //     return new Response("invalid path", { status: 400 });
+          //   }
+          // }
         }
       }
     });