@codexo/exojs 0.8.4 → 0.9.0

package/dist/esm/resources/Loader.js

@@ -1,24 +1,31 @@
 import { Music } from '../audio/Music.js';
 import { Sound } from '../audio/Sound.js';
 import { Signal } from '../core/Signal.js';
+import { BmFont } from '../rendering/text/BmFont.js';
 import { Texture } from '../rendering/texture/Texture.js';
 import { Video } from '../rendering/video/Video.js';
+import { AssetImpl, Asset } from './Asset.js';
 import { defineAssetManifest, BundleLoadError } from './AssetManifest.js';
+import { AssetsImpl } from './Assets.js';
 import { CacheFirstStrategy } from './CacheFirstStrategy.js';
 import { BinaryFactory } from './factories/BinaryFactory.js';
+import { BmFontLoaderFactory } from './factories/BmFontFactory.js';
+import { CsvFactory } from './factories/CsvFactory.js';
 import { FontFactory } from './factories/FontFactory.js';
 import { ImageFactory } from './factories/ImageFactory.js';
 import { JsonFactory } from './factories/JsonFactory.js';
 import { MusicFactory } from './factories/MusicFactory.js';
 import { SoundFactory } from './factories/SoundFactory.js';
+import { SubtitleFactory } from './factories/SubtitleFactory.js';
 import { SvgFactory } from './factories/SvgFactory.js';
 import { TextFactory } from './factories/TextFactory.js';
 import { TextureFactory } from './factories/TextureFactory.js';
 import { VideoFactory } from './factories/VideoFactory.js';
-import { VttFactory } from './factories/VttFactory.js';
 import { WasmFactory } from './factories/WasmFactory.js';
+import { XmlFactory } from './factories/XmlFactory.js';
 import { FactoryRegistry } from './FactoryRegistry.js';
-import { Json, TextAsset, SvgAsset, VttAsset } from './tokens.js';
+import { LoadingQueue } from './LoadingQueue.js';
+import { FontAsset, Json, TextAsset, SvgAsset, SubtitleAsset, XmlAsset, CsvAsset, BinaryAsset, ImageAsset, WasmAsset } from './tokens.js';
 
 // ---------------------------------------------------------------------------
 // Loader
@@ -45,12 +52,13 @@ import { Json, TextAsset, SvgAsset, VttAsset } from './tokens.js';
  *
  * @example
  * ```ts
- * const loader = new Loader({ resourcePath: '/assets/', cache: new IndexedDbStore('game') });
+ * const loader = new Loader({ basePath: '/assets/', cache: new IndexedDbStore('game') });
  * const texture = await loader.load(Texture, 'hero.png');
  * ```
  */
 class Loader {
     _registry = new FactoryRegistry();
+    _assetTypeMap = new Map();
     _resources = new Map();
     _manifest = new Map();
     _bundles = new Map();
@@ -59,8 +67,19 @@ class Loader {
     _preventStoreKeys = new Set();
     _stores;
     _cacheStrategy;
-    _resourcePath;
-    _requestOptions;
+    // ── Identity / alias tracking for the new Asset API ───────────────────────
+    // Maps alias key (`${typeId}:${alias}`) to an identity key (`id:${typeId}:${source}`)
+    _aliasKeyToIdentityKey = new Map();
+    // Maps identity key to the set of aliases registered under that identity (within same type)
+    _identityKeyToAliases = new Map();
+    // In-flight promises keyed by identity (source-based) for cross-alias dedup
+    _inFlightByIdentity = new Map();
+    // Handler entries registered via the handler-based registerAssetType overload
+    _handlerFunctions = new Map();
+    // Maps lower-case file extensions (without dot) to the constructor to use
+    _extensionMap = new Map();
+    _basePath;
+    _fetchOptions;
     _concurrency;
     _nextTypeId = 1;
     _backgroundQueue = [];
@@ -77,8 +96,8 @@ class Loader {
     /** Dispatched when an asset fails to load during background or bundle loading. */
     onError = new Signal();
     constructor(options = {}) {
-        this._resourcePath = options.resourcePath ?? '';
-        this._requestOptions = options.requestOptions ?? {};
+        this._basePath = options.basePath ?? '';
+        this._fetchOptions = options.fetchOptions ?? {};
         this._concurrency = options.concurrency ?? 6;
         this._stores = options.cache ? (Array.isArray(options.cache) ? options.cache : [options.cache]) : [];
         this._cacheStrategy = options.cacheStrategy ?? new CacheFirstStrategy();
@@ -99,6 +118,47 @@ class Loader {
         this._registry.register(type, factory);
         return this;
     }
+    registerAssetType(typeName, ctorOrHandler, factory) {
+        if (typeof ctorOrHandler === 'function') {
+            this._assetTypeMap.set(typeName, ctorOrHandler);
+            if (factory) {
+                this._registry.register(ctorOrHandler, factory);
+            }
+        }
+        else {
+            // Handler-based form: create a synthetic constructor for type identity
+            const syntheticCtor = class {
+            };
+            Object.defineProperty(syntheticCtor, 'name', { value: typeName });
+            this._assetTypeMap.set(typeName, syntheticCtor);
+            this._handlerFunctions.set(syntheticCtor, {
+                load: (config, ctx) => ctorOrHandler.load(config, ctx),
+                getIdentityKey: ctorOrHandler.getIdentityKey?.bind(ctorOrHandler),
+            });
+        }
+        return this;
+    }
+    // -----------------------------------------------------------------------
+    // Extension registration
+    // -----------------------------------------------------------------------
+    /**
+     * Associates a file extension with an asset type so that
+     * `loader.load('path.ext')` (the single-string overload) can infer the
+     * type automatically.
+     *
+     * `ext` is matched case-insensitively and the leading dot is optional.
+     * The type must already have a registered factory (via {@link register} or
+     * {@link registerAssetType}).
+     *
+     * ```ts
+     * loader.registerExtension('tmj', TiledMap);
+     * const map = await loader.load('world.tmj'); // TiledMap
+     * ```
+     */
+    registerExtension(ext, type) {
+        this._extensionMap.set(ext.replace(/^\./, '').toLowerCase(), type);
+        return this;
+    }
     add(type, source) {
         const ctor = type;
         if (typeof source === 'string') {
@@ -219,20 +279,120 @@ class Loader {
     // -----------------------------------------------------------------------
     // Loading — implementation
     // -----------------------------------------------------------------------
-    async load(type, source, options) {
-        const ctor = type;
-        if (typeof source === 'string') {
-            return this._loadSingle(ctor, source, options);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    load(arg0, arg1, arg2) {
+        // 1. Single Asset<T>
+        if (arg0 instanceof AssetImpl) {
+            const asset = arg0;
+            const alias = asset._config.source;
+            return this._createLoadingQueue([{ alias, asset }], results => results.get(alias));
+        }
+        // 2. Assets<M> container
+        if (arg0 instanceof AssetsImpl) {
+            const container = arg0;
+            const items = Object.entries(container.entries).map(([alias, a]) => ({
+                alias,
+                asset: a,
+            }));
+            return this._createLoadingQueue(items, results => {
+                const out = {};
+                for (const { alias } of items) {
+                    out[alias] = results.get(alias);
+                }
+                return out;
+            });
+        }
+        // 2b. Extension-based: single path string with no type token
+        if (typeof arg0 === 'string' && arg1 === undefined) {
+            const path = arg0;
+            const ext = path.match(/\.([^./?#]+)(?:[?#]|$)/)?.[1]?.toLowerCase();
+            const ctor = ext ? this._extensionMap.get(ext) : undefined;
+            if (ctor === undefined) {
+                throw new Error(`Loader: no type registered for extension ".${ext ?? '?'}" in "${path}". ` + 'Register one via loader.registerExtension().');
+            }
+            // FontAsset requires a family option — infer it from the filename when not provided
+            const options = ctor === FontAsset ? { family: (path.split('/').pop()?.split(/[?#]/)[0] ?? '').replace(/\.[^.]+$/, '') } : undefined;
+            let notifyFn = null;
+            const promise = this._loadSingle(ctor, path, options).then(v => {
+                notifyFn?.(true);
+                return v;
+            }, e => {
+                notifyFn?.(false);
+                throw e;
+            });
+            const queue = new LoadingQueue(promise, 1);
+            notifyFn = queue._notifyItem.bind(queue);
+            return queue;
         }
-        if (Array.isArray(source)) {
-            return Promise.all(source.map(path => this._loadSingle(ctor, path, options)));
+        // 3. Old path: first arg is a Loadable constructor
+        if (typeof arg0 === 'function') {
+            const ctor = arg0;
+            const source = arg1;
+            const options = arg2;
+            if (typeof source === 'string') {
+                let notifyFn = null;
+                const promise = this._loadSingle(ctor, source, options).then(v => {
+                    notifyFn?.(true);
+                    return v;
+                }, e => {
+                    notifyFn?.(false);
+                    throw e;
+                });
+                const queue = new LoadingQueue(promise, 1);
+                notifyFn = queue._notifyItem.bind(queue);
+                return queue;
+            }
+            if (Array.isArray(source)) {
+                const paths = source;
+                let notifyFn = null;
+                const results = new Array(paths.length);
+                const promises = paths.map((path, i) => this._loadSingle(ctor, path, options).then(v => {
+                    results[i] = v;
+                    notifyFn?.(true);
+                }, e => {
+                    notifyFn?.(false);
+                    throw e;
+                }));
+                const promise = Promise.all(promises).then(() => results);
+                const queue = new LoadingQueue(promise, paths.length);
+                notifyFn = queue._notifyItem.bind(queue);
+                return queue;
+            }
+            // Record<string, BatchValue>
+            const entries = Object.entries(source);
+            const result = {};
+            let notifyFn = null;
+            const promises = entries.map(([alias, pathOrConfig]) => {
+                const path = typeof pathOrConfig === 'string' ? pathOrConfig : pathOrConfig.source;
+                const itemOptions = typeof pathOrConfig === 'string'
+                    ? options
+                    : { ...pathOrConfig, ...(typeof options === 'object' && options !== null ? options : {}) };
+                return this._loadSingle(ctor, alias, itemOptions, path).then(v => {
+                    result[alias] = v;
+                    notifyFn?.(true);
+                }, e => {
+                    notifyFn?.(false);
+                    throw e;
+                });
+            });
+            const promise = Promise.all(promises).then(() => result);
+            const queue = new LoadingQueue(promise, entries.length);
+            notifyFn = queue._notifyItem.bind(queue);
+            return queue;
         }
-        const entries = Object.entries(source);
-        const result = {};
-        await Promise.all(entries.map(async ([alias, path]) => {
-            result[alias] = await this._loadSingle(ctor, alias, options, path);
+        // 4. Plain config map: Record<string, AssetInput>
+        const configMap = arg0;
+        const items = Object.entries(configMap).map(([alias, value]) => ({
+            alias,
+            asset: (value instanceof AssetImpl ? value : new Asset(value)),
         }));
-        return result;
+        return this._createLoadingQueue(items, results => {
+            const out = {};
+            for (const { alias } of items) {
+                out[alias] = results.get(alias);
+            }
+            return out;
+        });
     }
     // -----------------------------------------------------------------------
     // Background loading
@@ -308,22 +468,70 @@ class Loader {
         const ctor = type;
         return this._resources.get(ctor)?.has(alias) ?? false;
     }
-    // -----------------------------------------------------------------------
-    // Unload
-    // -----------------------------------------------------------------------
-    /**
-     * Removes a single asset from the in-memory resource store.
-     *
-     * If a fetch for this asset is still in flight, the result will be
-     * discarded once it arrives rather than written to the store, preventing
-     * a stale value from being committed after an explicit unload.
-     */
-    unload(type, alias) {
+    unload(arg0, arg1) {
+        if (arg0 instanceof AssetImpl) {
+            const asset = arg0;
+            const ctor = this._assetTypeMap.get(asset.type);
+            if (!ctor)
+                return this;
+            const identityKey = this._resolveAssetIdentityKey(ctor, asset);
+            const aliasSet = this._identityKeyToAliases.get(identityKey);
+            if (aliasSet && aliasSet.size > 0) {
+                // Snapshot the set because _unloadOne modifies it during iteration
+                for (const alias of [...aliasSet]) {
+                    this._unloadOne(ctor, alias);
+                }
+            }
+            else {
+                // Asset was loaded without alias-map tracking (e.g. single-asset load).
+                // Fall back to using the source as the alias.
+                this._unloadOne(ctor, asset._config.source);
+            }
+            return this;
+        }
+        if (arg0 instanceof AssetsImpl) {
+            const container = arg0;
+            for (const [alias, a] of Object.entries(container.entries)) {
+                const assetRef = a;
+                const ctor = this._assetTypeMap.get(assetRef.type);
+                if (!ctor)
+                    continue;
+                const identityKey = this._resolveAssetIdentityKey(ctor, assetRef);
+                const aliasSet = this._identityKeyToAliases.get(identityKey);
+                if (aliasSet?.has(alias)) {
+                    // Also remove all other aliases that share this resource identity
+                    for (const a2 of [...aliasSet]) {
+                        this._unloadOne(ctor, a2);
+                    }
+                }
+                else {
+                    this._unloadOne(ctor, alias);
+                }
+            }
+            return this;
+        }
+        return this._unloadOne(arg0, arg1);
+    }
+    _unloadOne(type, alias) {
         const ctor = type;
-        const key = this._key(ctor, alias);
+        const aliasKey = this._key(ctor, alias);
         this._resources.get(ctor)?.delete(alias);
-        if (this._inFlight.has(key)) {
-            this._preventStoreKeys.add(key);
+        // If a fetch is in flight (via legacy or identity-based map), prevent the
+        // result from being written to _resources once it arrives.
+        const identityKey = this._aliasKeyToIdentityKey.get(aliasKey);
+        if (this._inFlight.has(aliasKey) || (identityKey !== undefined && this._inFlightByIdentity.has(identityKey))) {
+            this._preventStoreKeys.add(aliasKey);
+        }
+        // Clean up alias ↔ identity tracking
+        if (identityKey !== undefined) {
+            this._aliasKeyToIdentityKey.delete(aliasKey);
+            const aliasSet = this._identityKeyToAliases.get(identityKey);
+            if (aliasSet) {
+                aliasSet.delete(alias);
+                if (aliasSet.size === 0) {
+                    this._identityKeyToAliases.delete(identityKey);
+                }
+            }
         }
         return this;
     }
@@ -352,21 +560,21 @@ class Loader {
      * Absolute URLs (starting with `http://`, `https://`, or `//`) are
      * passed through unchanged.
      */
-    get resourcePath() {
-        return this._resourcePath;
+    get basePath() {
+        return this._basePath;
     }
-    set resourcePath(value) {
-        this._resourcePath = value;
+    set basePath(value) {
+        this._basePath = value;
     }
     /**
      * Default `RequestInit` options merged into every `fetch` call.
      * Override per-load with the `options` argument of {@link load}.
      */
-    get requestOptions() {
-        return this._requestOptions;
+    get fetchOptions() {
+        return this._fetchOptions;
     }
-    set requestOptions(value) {
-        this._requestOptions = value;
+    set fetchOptions(value) {
+        this._fetchOptions = value;
     }
     // -----------------------------------------------------------------------
     // Lifecycle
@@ -388,6 +596,10 @@ class Loader {
         this._bundles.clear();
         this._inFlight.clear();
         this._preventStoreKeys.clear();
+        this._inFlightByIdentity.clear();
+        this._aliasKeyToIdentityKey.clear();
+        this._identityKeyToAliases.clear();
+        this._handlerFunctions.clear();
         this._backgroundQueue.length = 0;
         this.onProgress.destroy();
         this.onBundleProgress.destroy();
@@ -444,15 +656,166 @@ class Loader {
         }
         return this._waitForBackgroundEntry(type, alias);
     }
+    _createLoadingQueue(items, buildResult) {
+        const results = new Map();
+        let notifyFn = null;
+        const itemPromises = items.map(({ alias, asset }) => {
+            const ctor = this._assetTypeMap.get(asset.type);
+            if (!ctor) {
+                // Must call _notifyItem(false) so LoadingProgress doesn't remain stuck.
+                return Promise.reject(new Error(`No constructor registered for asset type "${asset.type}". Call registerAssetType() first.`)).then(() => {
+                    notifyFn?.(true);
+                }, error => {
+                    notifyFn?.(false);
+                    throw error;
+                });
+            }
+            return this._loadSingleAsset(ctor, alias, asset).then(resource => {
+                results.set(alias, resource);
+                notifyFn?.(true);
+            }, error => {
+                notifyFn?.(false);
+                throw error;
+            });
+        });
+        const promise = Promise.all(itemPromises).then(() => buildResult(results));
+        const queue = new LoadingQueue(promise, items.length);
+        notifyFn = queue._notifyItem.bind(queue);
+        return queue;
+    }
+    /**
+     * Loads a single asset from an `Asset<T>` reference using identity-based
+     * in-flight deduplication.
+     *
+     * Multiple aliases that point to the same source share a single network
+     * fetch.  Each alias is stored independently in `_resources` so that
+     * `get(type, alias)` works for all of them.
+     */
+    async _loadSingleAsset(type, alias, asset) {
+        if (this._hasResource(type, alias)) {
+            return this._resources.get(type)?.get(alias);
+        }
+        const source = asset.source;
+        const rawConfig = asset._config;
+        const { type: _type, source: _src, ...extraOnly } = rawConfig;
+        // Identity key: use handler's getIdentityKey if provided (config-sensitive dedup),
+        // otherwise fall back to source-based identity (correct for URL-only assets).
+        const handlerEntry = this._handlerFunctions.get(type);
+        const discriminator = handlerEntry?.getIdentityKey?.(rawConfig) ?? source;
+        const identityKey = `id:${this._getTypeId(type)}:${discriminator}`;
+        const aliasKey = this._key(type, alias);
+        // Register alias → identity mapping for unload() semantics
+        this._aliasKeyToIdentityKey.set(aliasKey, identityKey);
+        let aliasSet = this._identityKeyToAliases.get(identityKey);
+        if (!aliasSet) {
+            aliasSet = new Set();
+            this._identityKeyToAliases.set(identityKey, aliasSet);
+        }
+        aliasSet.add(alias);
+        // Same identity already in flight? Attach to the existing promise.
+        const existing = this._inFlightByIdentity.get(identityKey);
+        if (existing) {
+            return existing.then(resource => {
+                this._storeResource(type, alias, resource);
+                return resource;
+            });
+        }
+        // Build load promise.
+        let fetchPromise;
+        if (handlerEntry) {
+            const fullConfig = { source, ...extraOnly };
+            const context = this._buildHandlerContext(identityKey);
+            fetchPromise = this._fetchWithHandler(type, alias, source, fullConfig, handlerEntry.load, context);
+        }
+        else {
+            const options = Object.keys(extraOnly).length > 0 ? extraOnly : undefined;
+            fetchPromise = this._fetch(type, alias, source, options);
+        }
+        const tracked = fetchPromise
+            .finally(() => {
+            this._inFlightByIdentity.delete(identityKey);
+        })
+            .then(v => v, error => {
+            // On failure, immediately clean up alias ↔ identity tracking so
+            // stale entries don't accumulate for assets that never loaded.
+            const failedAliases = this._identityKeyToAliases.get(identityKey);
+            if (failedAliases) {
+                for (const fa of failedAliases) {
+                    const faKey = this._key(type, fa);
+                    this._aliasKeyToIdentityKey.delete(faKey);
+                    this._preventStoreKeys.delete(faKey);
+                }
+                this._identityKeyToAliases.delete(identityKey);
+            }
+            throw error;
+        });
+        this._inFlightByIdentity.set(identityKey, tracked);
+        return tracked;
+    }
+    /**
+     * Calls a handler-based custom asset loader and stores the result.
+     *
+     * Unlike `_fetch`, this does NOT automatically bypass caching — the handler
+     * controls caching by calling `context.fetchText` / `context.fetchArrayBuffer`
+     * / `context.fetchJson`, which route through the loader's cache strategy.
+     */
+    async _fetchWithHandler(type, alias, source, fullConfig, handler, context) {
+        const url = this._resolveUrl(source);
+        try {
+            const resource = await handler(fullConfig, context);
+            this._storeResource(type, alias, resource);
+            return resource;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to load "${alias}" from "${url}": ${message}`, { cause: error });
+        }
+    }
+    /**
+     * Builds an {@link AssetLoaderContext} for a handler invocation.
+     *
+     * The `fetch*` helpers on the returned context route through the loader's
+     * configured cache strategy and IDB stores, using `source` as the IDB key
+     * (so the same URL is never fetched twice regardless of the asset alias).
+     */
+    _buildHandlerContext(identityKey) {
+        const ctx = {
+            loader: this,
+            identityKey,
+            fetchText: (source) => this._contextFetch(source, '__ctx_text', r => r.text()),
+            fetchArrayBuffer: (source) => this._contextFetch(source, '__ctx_binary', r => r.arrayBuffer()),
+            fetchJson: (source) => this._contextFetch(source, '__ctx_json', r => r.json()),
+        };
+        return ctx;
+    }
+    /**
+     * Fetches `source` through the loader's cache strategy with an inline
+     * pass-through factory, using `source` as the IDB key.
+     *
+     * `process` converts the raw `Response` to the storable intermediate form
+     * (e.g. `r.text()`, `r.arrayBuffer()`, `r.json()`).  `create` is always the
+     * identity function — the cached value is returned unchanged.
+     */
+    _contextFetch(source, storageName, process) {
+        const url = this._resolveUrl(source);
+        const factory = {
+            storageName,
+            process,
+            create: data => Promise.resolve(data),
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            destroy() { },
+        };
+        return this._cacheStrategy.resolve({ storageName, key: source, url, requestOptions: this._fetchOptions, factory, options: undefined }, this._stores);
+    }
     async _fetch(type, alias, path, options) {
         const factory = this._registry.resolve(type);
         const url = this._resolveUrl(path);
         try {
             const resource = await this._cacheStrategy.resolve({
                 storageName: factory.storageName,
-                key: alias,
+                key: path, // source-path as IDB key so same resource is not cached multiple times under different aliases
                 url,
-                requestOptions: this._requestOptions,
+                requestOptions: this._fetchOptions,
                 factory,
                 options,
             }, this._stores);
@@ -665,19 +1028,38 @@ class Loader {
         typeResources.set(alias, resource);
         this.onLoaded.dispatch(type, alias, resource);
     }
-    _key(type, alias) {
+    _getTypeId(type) {
         let typeId = this._typeIds.get(type);
         if (typeId === undefined) {
             typeId = this._nextTypeId++;
             this._typeIds.set(type, typeId);
         }
-        return `${typeId}:${alias}`;
+        return typeId;
+    }
+    _key(type, alias) {
+        return `${this._getTypeId(type)}:${alias}`;
+    }
+    _identityKey(type, source) {
+        return `id:${this._getTypeId(type)}:${source}`;
+    }
+    /**
+     * Resolves the effective identity key for an `Asset<T>` reference, mirroring
+     * the logic used in `_loadSingleAsset`.
+     *
+     * For handler types with `getIdentityKey`, the config-sensitive discriminator
+     * is used; otherwise source is the discriminator (same as `_identityKey`).
+     */
+    _resolveAssetIdentityKey(type, asset) {
+        const rawConfig = asset._config;
+        const handlerEntry = this._handlerFunctions.get(type);
+        const discriminator = handlerEntry?.getIdentityKey?.(rawConfig) ?? asset.source;
+        return `id:${this._getTypeId(type)}:${discriminator}`;
     }
     _resolveUrl(path) {
         if (path.startsWith('http://') || path.startsWith('https://') || path.startsWith('//')) {
             return path;
         }
-        return `${this._resourcePath}${path}`;
+        return `${this._basePath}${path}`;
     }
     // -----------------------------------------------------------------------
     // Internal — built-in factory registration
@@ -690,16 +1072,40 @@ class Loader {
         this._registry.register(Json, new JsonFactory());
         this._registry.register(TextAsset, new TextFactory());
         this._registry.register(SvgAsset, new SvgFactory());
-        this._registry.register(VttAsset, new VttFactory());
-        this._registry.register(ArrayBuffer, new BinaryFactory());
+        this._registry.register(SubtitleAsset, new SubtitleFactory());
+        this._registry.register(XmlAsset, new XmlFactory());
+        this._registry.register(CsvAsset, new CsvFactory());
+        this._registry.register(BinaryAsset, new BinaryFactory());
+        this._assetTypeMap.set('texture', Texture);
+        this._assetTypeMap.set('sound', Sound);
+        this._assetTypeMap.set('music', Music);
+        this._assetTypeMap.set('json', Json);
+        this._assetTypeMap.set('video', Video);
+        this._assetTypeMap.set('text', TextAsset);
+        this._assetTypeMap.set('svg', SvgAsset);
+        this._assetTypeMap.set('vtt', SubtitleAsset);
+        this._assetTypeMap.set('srt', SubtitleAsset);
+        this._assetTypeMap.set('xml', XmlAsset);
+        this._assetTypeMap.set('csv', CsvAsset);
+        this._assetTypeMap.set('binary', BinaryAsset);
+        this._registry.register(BmFont, new BmFontLoaderFactory(this));
+        this._assetTypeMap.set('bmFont', BmFont);
+        this._extensionMap.set('fnt', BmFont);
         if (typeof FontFace !== 'undefined') {
-            this._registry.register(FontFace, new FontFactory());
+            this._registry.register(FontAsset, new FontFactory());
+            this._assetTypeMap.set('font', FontAsset);
+            this._extensionMap.set('woff', FontAsset);
+            this._extensionMap.set('woff2', FontAsset);
+            this._extensionMap.set('ttf', FontAsset);
+            this._extensionMap.set('otf', FontAsset);
         }
         if (typeof HTMLImageElement !== 'undefined') {
-            this._registry.register(HTMLImageElement, new ImageFactory());
+            this._registry.register(ImageAsset, new ImageFactory());
+            this._assetTypeMap.set('image', ImageAsset);
         }
         if (typeof WebAssembly !== 'undefined') {
-            this._registry.register(WebAssembly.Module, new WasmFactory());
+            this._registry.register(WasmAsset, new WasmFactory());
+            this._assetTypeMap.set('wasm', WasmAsset);
         }
     }
 }