@esotericsoftware/spine-core
Version:
The official Spine Runtimes for the web.
104 lines (103 loc) • 5.56 kB
TypeScript
/******************************************************************************
* Spine Runtimes License Agreement
* Last updated April 5, 2025. Replaces all prior versions.
*
* Copyright (c) 2013-2025, Esoteric Software LLC
*
* Integration of the Spine Runtimes into software or otherwise creating
* derivative works of the Spine Runtimes is permitted under the terms and
* conditions of Section 2 of the Spine Editor License Agreement:
* http://esotericsoftware.com/spine-editor-license
*
* Otherwise, it is permitted to integrate the Spine Runtimes into software
* or otherwise create derivative works of the Spine Runtimes (collectively,
* "Products"), provided that each user of the Products must obtain their own
* Spine Editor license and redistribution of the Products in any form must
* include this license and copyright notice.
*
* THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
* BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*****************************************************************************/
import type { Texture } from "./Texture.js";
import { TextureAtlas } from "./TextureAtlas.js";
import type { Disposable, StringMap } from "./Utils.js";
type AssetData = (Uint8Array | string | Texture | TextureAtlas | object) & Partial<Disposable>;
type AssetCallback<T extends AssetData> = (path: string, data: T) => void;
type ErrorCallback = (path: string, message: string) => void;
export type TextureLoader = (image: HTMLImageElement | ImageBitmap, pma?: boolean) => Texture;
export declare class AssetManagerBase implements Disposable {
private textureLoader;
private pathPrefix;
private downloader;
private cache;
private errors;
private toLoad;
private loaded;
private texturePmaInfo;
constructor(textureLoader: TextureLoader, pathPrefix?: string, downloader?: Downloader, cache?: AssetCache);
private start;
private success;
private error;
loadAll(): Promise<AssetManagerBase>;
setRawDataURI(path: string, data: string): void;
loadBinary(path: string, success?: (path: string, binary: Uint8Array) => void, error?: (path: string, message: string) => void): void;
loadText(path: string, success?: (path: string, text: string) => void, error?: (path: string, message: string) => void): void;
loadJson(path: string, success?: (path: string, object: object) => void, error?: (path: string, message: string) => void): void;
reuseAssets<T extends AssetData>(path: string, success?: AssetCallback<T>, error?: ErrorCallback): boolean;
loadTexture(path: string, success?: AssetCallback<Texture>, error?: ErrorCallback): void;
loadTextureAtlas(path: string, success?: AssetCallback<TextureAtlas>, error?: ErrorCallback, fileAlias?: Record<string, string>): void;
loadTextureAtlasButNoTextures(path: string, success?: AssetCallback<TextureAtlas>, error?: ErrorCallback): void;
loadBinaryAsync(path: string): Promise<unknown>;
loadJsonAsync(path: string): Promise<unknown>;
loadTextureAsync(path: string): Promise<Texture>;
loadTextureAtlasAsync(path: string): Promise<unknown>;
loadTextureAtlasButNoTexturesAsync(path: string): Promise<TextureAtlas>;
setCache(cache: AssetCache): void;
get(path: string): AssetData;
require(path: string): AssetData;
remove(path: string): AssetData;
removeAll(): void;
isLoadingComplete(): boolean;
getToLoad(): number;
getLoaded(): number;
dispose(): void;
disposeAsset(path: string): void;
hasErrors(): boolean;
getErrors(): StringMap<string>;
private disposeAssetInternal;
private createTextureAtlas;
private createTexture;
private texturePath;
}
export declare class AssetCache {
assets: StringMap<AssetData>;
assetsRefCount: StringMap<number>;
assetsLoaded: StringMap<Promise<AssetData | undefined>>;
static AVAILABLE_CACHES: Map<string, AssetCache>;
static getCache(id: string): AssetCache;
addAsset<T extends AssetData>(path: string, asset: T): Promise<T>;
getAsset<T extends AssetData>(path: string): Promise<T> | undefined;
}
type DownloaderSuccessCallback<T extends AssetData = AssetData> = (data: T) => void;
type DownloaderErrorCallback = (status: number, responseText: string) => void;
export declare class Downloader {
private callbacks;
rawDataUris: StringMap<string>;
dataUriToString(dataUri: string): string;
base64ToUint8Array(base64: string): Uint8Array;
dataUriToUint8Array(dataUri: string): Uint8Array;
downloadText(url: string, success: DownloaderSuccessCallback<string>, error: DownloaderErrorCallback): void;
downloadJson(url: string, success: DownloaderSuccessCallback<object>, error: DownloaderErrorCallback): void;
downloadBinary(url: string, success: (data: Uint8Array) => void, error: DownloaderErrorCallback): void;
private start;
private finish;
}
export {};