Change asset manager files handling

packages/asset-manager/src/asset-manager.library.ts

@@ -1,46 +1,19 @@
-import { BaseAssetManagerLibrary, type InitContext } from "@nanoforge/common";
-
-import { NfFile } from "./file";
+import { BaseAssetManagerLibrary, type InitContext, NfFile, NfNotFound } from "@nanoforge/common";
 
 export class AssetManagerLibrary extends BaseAssetManagerLibrary {
   private _assets: Map<string, string>;
-  private _wasm: Map<string, string>;
-  private _wgsl: Map<string, string>;
 
   get __name(): string {
     return "AssetManagerLibrary";
   }
 
   public async __init(context: InitContext): Promise<void> {
-    this._assets = context.files.assets;
-    this._wasm = context.files.wasm;
-    this._wgsl = context.files.wgsl;
+    this._assets = context.files;
   }
 
-  /**
-   * @todo Error management
-   */
-  public async getAsset(path: string): Promise<NfFile> {
+  public getAsset(path: string): NfFile {
     const res = this._assets.get(this._parsePath(path));
-    if (!res) throw new Error("Asset not found.");
-    return new NfFile(res);
-  }
-
-  /**
-   * @todo Error management
-   */
-  public async getWasm(path: string): Promise<NfFile> {
-    const res = this._wasm.get(this._parsePath(path));
-    if (!res) throw new Error("Asset not found.");
-    return new NfFile(res);
-  }
-
-  /**
-   * @todo Error management
-   */
-  public async getWgsl(path: string): Promise<NfFile> {
-    const res = this._wgsl.get(this._parsePath(path));
-    if (!res) throw new Error("Asset not found.");
+    if (!res) throw new NfNotFound(path, "Asset");
     return new NfFile(res);
   }
 

packages/asset-manager/src/index.ts

@@ -1,2 +1 @@
 export { AssetManagerLibrary } from "./asset-manager.library";
-export { NfFile } from "./file";

packages/asset-manager/test/asset-manager.library.spec.ts

@@ -15,41 +15,35 @@ describe("Asset Manager Library", () => {
   const context = new InitContext(appContext, libraryManager, configRegistry, {
     // @ts-ignore
     canvas: null,
-    files: {
-      assets: new Map([["/test.png", "blob:http://localhost:3000/test.png"]]),
-      wasm: new Map([["/test.wasm", "blob:http://localhost:3000/test.wasm"]]),
-      wgsl: new Map([["/test.wgsl", "blob:http://localhost:3000/test.wgsl"]]),
-    },
+    files: new Map([
+      ["/test.png", "blob:http://localhost:3000/test.png"],
+      ["/test.wasm", "blob:http://localhost:3000/test.wasm"],
+      ["/test.wgsl", "blob:http://localhost:3000/test.wgsl"],
+    ]),
   });
   library.__init(context);
 
-  it("Should get asset", async () => {
-    expect((await library.getAsset("test.png")).path).toEqual(
-      "blob:http://localhost:3000/test.png",
-    );
+  it("Should get asset", () => {
+    expect(library.getAsset("test.png").path).toEqual("blob:http://localhost:3000/test.png");
   });
 
-  it("Should throw on unknown asset", async () => {
-    await expect(library.getAsset("test-unknown.png")).rejects.toThrow();
+  it("Should throw on unknown asset", () => {
+    expect(() => library.getAsset("test-unknown.png")).toThrow();
   });
 
-  it("Should get wasm", async () => {
-    expect((await library.getWasm("test.wasm")).path).toEqual(
-      "blob:http://localhost:3000/test.wasm",
-    );
+  it("Should get wasm", () => {
+    expect(library.getAsset("test.wasm").path).toEqual("blob:http://localhost:3000/test.wasm");
   });
 
-  it("Should throw on unknown wasm", async () => {
-    await expect(library.getWasm("test-unknown.wasm")).rejects.toThrow();
+  it("Should throw on unknown wasm", () => {
+    expect(() => library.getAsset("test-unknown.wasm")).toThrow();
   });
 
-  it("Should get wgsl", async () => {
-    expect((await library.getWgsl("test.wgsl")).path).toEqual(
-      "blob:http://localhost:3000/test.wgsl",
-    );
+  it("Should get wgsl", () => {
+    expect(library.getAsset("test.wgsl").path).toEqual("blob:http://localhost:3000/test.wgsl");
   });
 
-  it("Should throw on unknown wgsl", async () => {
-    await expect(library.getWgsl("test-unknown.wgsl")).rejects.toThrow();
+  it("Should throw on unknown wgsl", () => {
+    expect(() => library.getAsset("test-unknown.wgsl")).toThrow();
   });
 });

packages/common/src/common/file.ts

@@ -0,0 +1,49 @@
+import { NfFetchException } from "../exception";
+
+export class NfFile {
+  private readonly _path: string;
+
+  constructor(path: string) {
+    this._path = path;
+  }
+
+  get path(): string {
+    return this._path;
+  }
+
+  public async arrayBuffer(): Promise<ArrayBuffer> {
+    const res = await this._fetch();
+    return await res.arrayBuffer();
+  }
+
+  public async blob(): Promise<Blob> {
+    const res = await this._fetch();
+    return await res.blob();
+  }
+
+  public async bytes(): Promise<Uint8Array<ArrayBuffer>> {
+    const res = await this._fetch();
+    return await res.bytes();
+  }
+
+  public async formData(): Promise<FormData> {
+    const res = await this._fetch();
+    return await res.formData();
+  }
+
+  public async json(): Promise<any> {
+    const res = await this._fetch();
+    return await res.json();
+  }
+
+  public async text(): Promise<string> {
+    const res = await this._fetch();
+    return await res.text();
+  }
+
+  private async _fetch(): Promise<Response> {
+    const res = await fetch(this._path);
+    if (!res.ok) throw new NfFetchException(res.status, res.statusText);
+    return res;
+  }
+}

packages/common/src/common/index.ts

@@ -0,0 +1 @@
+export { NfFile } from "./file";

packages/common/src/exception/exceptions/fetch.exception.ts

@@ -0,0 +1,14 @@
+import { NfException } from "../abstracts/exception.abstract";
+
+export class NfFetchException extends NfException {
+  private readonly _code: number;
+
+  get code(): number {
+    return this._code;
+  }
+
+  constructor(code: number, text: string) {
+    super(`Fetch exception : ${code} - ${text}`);
+    this._code = code;
+  }
+}

packages/common/src/exception/index.ts

@@ -1 +1,2 @@
 export { NfNotFound } from "./exceptions/not-found.exception";
+export { NfFetchException } from "./exceptions/fetch.exception";

packages/common/src/index.ts

@@ -1,3 +1,4 @@
+export * from "./common";
 export * from "./context";
 export * from "./library";
 export * from "./options";

packages/common/src/library/libraries/abstracts/asset-manager.library.abstract.ts

@@ -1,7 +1,10 @@
+import { type NfFile } from "../../../common";
 import { type InitContext } from "../../../context";
 import { type IAssetManagerLibrary } from "../interfaces";
 import { Library } from "../library";
 
 export abstract class BaseAssetManagerLibrary extends Library implements IAssetManagerLibrary {
   public abstract __init(context: InitContext): Promise<void>;
+
+  public abstract getAsset(path: string): NfFile;
 }

packages/common/src/library/libraries/interfaces/finals/asset-manager.library.type.ts

@@ -1,3 +1,6 @@
+import { type NfFile } from "../../../../common";
 import { type IExposedLibrary } from "../bases/exposed.library.type";
 
-export interface IAssetManagerLibrary extends IExposedLibrary {}
+export interface IAssetManagerLibrary extends IExposedLibrary {
+  getAsset(path: string): NfFile;
+}

packages/common/src/options/types/options.type.ts

@@ -1,8 +1,4 @@
 export interface IRunOptions {
   canvas: HTMLCanvasElement;
-  files: {
-    assets: Map<string, string>;
-    wasm: Map<string, string>;
-    wgsl: Map<string, string>;
-  };
+  files: Map<string, string>;
 }

packages/ecs/src/ecs-library.ts

@@ -1,4 +1,3 @@
-import { type AssetManagerLibrary } from "@nanoforge/asset-manager";
 import {
   ASSET_MANAGER_LIBRARY,
   BaseComponentSystemLibrary,
@@ -7,8 +6,7 @@ import {
   type InitContext,
 } from "@nanoforge/common";
 
-import type { MainModule } from "../lib";
-import { Module } from "../lib";
+import { type MainModule, Module } from "../lib";
 import { ECSRegistry } from "./ecs-registry";
 
 export class ECSLibrary extends BaseComponentSystemLibrary {
@@ -29,9 +27,7 @@ export class ECSLibrary extends BaseComponentSystemLibrary {
   }
 
   async __init(context: InitContext): Promise<void> {
-    const wasmFile = await context.libraries
-      .getAssetManager<AssetManagerLibrary>()
-      .library.getWasm(this.path);
+    const wasmFile = context.libraries.getAssetManager().library.getAsset(this.path);
     this.module = await Module({ locateFile: () => wasmFile.path });
     this._registry = new ECSRegistry(new this.module.Registry());
   }

packages/ecs/src/index.ts

@@ -1,4 +1,4 @@
-import "../lib/libecs.wasm";
+import "@lib/libecs.wasm";
 
 export { ECSLibrary } from "./ecs-library";
 export type { ECSRegistry, Component, System } from "./ecs-registry";

packages/ecs/test/ecs-library.spec.ts

@@ -30,11 +30,7 @@ describe("ECSLibrary", () => {
   const initContext = new InitContext(appContext, libraryManager, configRegistry, {
     // @ts-ignore
     canvas: null,
-    files: {
-      assets: new Map(),
-      wasm: new Map([["/libecs.wasm", "./lib/libecs.wasm"]]),
-      wgsl: new Map(),
-    },
+    files: new Map([["/libecs.wasm", "./lib/libecs.wasm"]]),
   });
 
   const clearContext = new ClearContext(appContext, libraryManager);

packages/ecs/tsconfig.build.json

@@ -5,17 +5,13 @@
     "rootDir": ".",
     "paths": {
       "@lib": ["./lib"],
-      "@nanoforge/common": ["../common"],
-      "@nanoforge/asset-manager": ["../asset-manager"]
+      "@nanoforge/common": ["../common"]
     }
   },
   "exclude": ["node_modules", "dist", "test/**/*", "*.spec.ts"],
   "references": [
     {
       "path": "../common/tsconfig.build.json"
-    },
-    {
-      "path": "../asset-manager/tsconfig.build.json"
     }
   ]
 }

packages/graphics-2d/test/graphics-2d.library.spec.ts

@@ -15,11 +15,7 @@ describe("Graphics 2D Library", () => {
   const context = new InitContext(appContext, libraryManager, configRegistry, {
     // @ts-ignore
     canvas: null,
-    files: {
-      assets: new Map([["/test.png", "blob:http://localhost:3000/test.png"]]),
-      wasm: new Map([["/test.wasm", "blob:http://localhost:3000/test.wasm"]]),
-      wgsl: new Map([["/test.wgsl", "blob:http://localhost:3000/test.wgsl"]]),
-    },
+    files: new Map(),
   });
 
   it("Should throw if canvas is undefined", async () => {