@antha/asset 0.5.0 → 0.6.1

package/dist/antha-bootstrap.mod.d.ts

@@ -7,7 +7,7 @@ export type AnthaBootstrapModState = {
     hasStartedBootstrap: boolean;
 };
 /** Parameters passed to {@link AnthaBootstrapModOptions.bootstrap}. */
-export type AnthaBootstrapParams<Module, State extends AnyObject> = {
+export type AnthaBootstrapParams<State extends AnyObject, Module> = {
     assetLoader: AssetLoader;
     engine: AnthaEngine;
     loadSession: AssetLoadSession;
@@ -20,12 +20,12 @@ export type AnthaBootstrapResult = {
     mods: ReadonlyArray<AnthaMod>;
 };
 /** Options for {@link createAnthaBootstrapMod}. */
-export type AnthaBootstrapModOptions<Module, State extends AnyObject> = {
+export type AnthaBootstrapModOptions<State extends AnyObject, Module> = {
     /**
      * Bootstraps the loaded module and returns the mods that should be installed for it. Await any
      * initial asset loading here, using the provided load session, before returning.
      */
-    bootstrap: (this: void, params: Readonly<AnthaBootstrapParams<Module, State>>) => MaybePromise<AnthaBootstrapResult>;
+    bootstrap: (this: void, params: Readonly<AnthaBootstrapParams<State, Module>>) => MaybePromise<AnthaBootstrapResult>;
     /** Lazily imports the code required to bootstrap the game. */
     loadModule: (this: void) => MaybePromise<Module>;
 } & PartialWithUndefined<{
@@ -38,4 +38,4 @@ export type AnthaBootstrapModOptions<Module, State extends AnyObject> = {
  *
  * @category Pre-Built Mods
  */
-export declare function createAnthaBootstrapMod<Module, State extends AnyObject = AnyObject>(options: Readonly<AnthaBootstrapModOptions<Module, State>>): AnthaMod<NoInfer<State & AnthaAssetModState & AnthaBootstrapModState>>;
+export declare function createAnthaBootstrapMod<State extends AnyObject = AnyObject>(): <Module>(options: Readonly<AnthaBootstrapModOptions<NoInfer<State>, Module>>) => AnthaMod<NoInfer<NoInfer<State> & AnthaAssetModState & AnthaBootstrapModState>>;

package/dist/antha-bootstrap.mod.js

@@ -1,54 +1,48 @@
 import { defineAnthaMod, SkipExecution } from '@antha/engine';
 import { ensureErrorAndPrependMessage, } from '@augment-vir/common';
-import { defineAsset } from './asset-loader.js';
 /**
  * Creates a mod that tracks a lazy game-module import on Antha's loading screen, then installs the
  * mods returned by the module's bootstrap callback.
  *
  * @category Pre-Built Mods
  */
-export function createAnthaBootstrapMod(options) {
-    const moduleAsset = defineAsset({
-        assetName: options.assetName || 'Game code',
-        maxProgress: 1,
-        async load({ incrementProgressCallback }) {
-            const module = await options.loadModule();
-            incrementProgressCallback();
-            return {
-                value: module,
-            };
-        },
-    });
-    return defineAnthaMod({
-        modName: 'antha-bootstrap',
-        execute({ engine, state }) {
-            const assetLoader = state.assetLoader;
-            if (!assetLoader || state.hasStartedBootstrap) {
-                return SkipExecution;
-            }
-            state.hasStartedBootstrap = true;
-            const loadSession = assetLoader.createLoadSession();
-            void assetLoader
-                .loadIndividualAsset({
-                asset: moduleAsset,
-                loadSession,
-            })
-                .then(async (module) => {
-                const bootstrapResult = await options.bootstrap({
-                    assetLoader,
-                    engine,
-                    loadSession,
-                    module,
-                    state,
+export function createAnthaBootstrapMod() {
+    return function createBootstrapMod(options) {
+        return defineAnthaMod({
+            modName: 'antha-bootstrap',
+            execute({ engine, state }) {
+                const assetLoader = state.assetLoader;
+                if (!assetLoader || state.hasStartedBootstrap) {
+                    return SkipExecution;
+                }
+                state.hasStartedBootstrap = true;
+                const loadSession = assetLoader.createLoadSession();
+                loadSession.reportProgress({
+                    current: 0,
+                    currentResourceName: options.assetName || 'Game code',
+                    total: 0,
+                });
+                void Promise.resolve()
+                    .then(() => {
+                    return options.loadModule();
+                })
+                    .then(async (module) => {
+                    const bootstrapResult = await options.bootstrap({
+                        assetLoader,
+                        engine,
+                        loadSession,
+                        module,
+                        state,
+                    });
+                    engine.currentMods.push(...bootstrapResult.mods);
+                    loadSession.complete();
+                })
+                    .catch((error) => {
+                    loadSession.complete();
+                    engine.log.error(ensureErrorAndPrependMessage(error, 'Failed to bootstrap game.'));
                 });
-                engine.currentMods.push(...bootstrapResult.mods);
-                loadSession.complete();
-            })
-                .catch((error) => {
-                loadSession.complete();
-                engine.log.error(ensureErrorAndPrependMessage(error, 'Failed to bootstrap game.'));
-            });
-            return SkipExecution;
-        },
-    });
+                return SkipExecution;
+            },
+        });
+    };
 }

package/dist/asset-loader.d.ts

@@ -1,4 +1,4 @@
-import { type AnthaLogger } from '@antha/engine';
+import { type AnthaLogger, type EngineTime } from '@antha/engine';
 import { type MaybePromise, type PartialWithUndefined } from '@augment-vir/common';
 import { ListenTarget } from 'typed-event-target';
 /**
@@ -102,7 +102,7 @@ export type AssetLoadProgress = {
 };
 /** State of the active asset load. */
 export type AssetLoadState = AssetLoadProgress & {
-    completedAt: DOMHighResTimeStamp | undefined;
+    completedAt: EngineTime | undefined;
     isLoading: boolean;
 };
 declare const AssetLoadSessionUpdateEvent_base: (new (eventInitDict: {
@@ -166,7 +166,7 @@ export declare class AssetLoadSessionController {
     /** Advances asset-load completion after an engine render. */
     advance({ currentTick, totalMs, }: Readonly<{
         currentTick: number;
-        totalMs: DOMHighResTimeStamp;
+        totalMs: EngineTime;
     }>): void;
     /** Stops tracking the active load session. */
     destroy(): void;
@@ -193,7 +193,7 @@ export declare class AssetLoader {
     /** Advances asset-load completion after an engine render. */
     advanceLoadState({ currentTick, totalMs, }: Readonly<{
         currentTick: number;
-        totalMs: DOMHighResTimeStamp;
+        totalMs: EngineTime;
     }>): void;
     /** Loads a single asset, returning its cached value if already loaded. */
     loadIndividualAsset<ThisAsset extends Asset>({ asset, incrementProgressCallback, loadSession, }: Readonly<{

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@antha/asset",
-    "version": "0.5.0",
+    "version": "0.6.1",
     "description": "An Antha mod for handling asset loading.",
     "keywords": [
         "vir",
@@ -50,7 +50,7 @@
         "typedoc": "^0.28.20"
     },
     "peerDependencies": {
-        "@antha/engine": "^0.5.0",
+        "@antha/engine": "^0.6.1",
         "element-vir": ">=26"
     },
     "engines": {