From faf59cec6a0a1f8de097a0467d3ad4832925dbf2 Mon Sep 17 00:00:00 2001 From: Ayfri Date: Tue, 30 Aug 2022 02:11:35 +0200 Subject: [PATCH] feat: Add assets package. --- packages/assets/build.gradle.kts | 11 + .../src/main/kotlin/pixi/typeAliasses.kt | 4 + .../assets/src/main/kotlin/pixi/typings.kt | 285 ++++++++++++++++++ 3 files changed, 300 insertions(+) create mode 100644 packages/assets/build.gradle.kts create mode 100644 packages/assets/src/main/kotlin/pixi/typeAliasses.kt create mode 100644 packages/assets/src/main/kotlin/pixi/typings.kt diff --git a/packages/assets/build.gradle.kts b/packages/assets/build.gradle.kts new file mode 100644 index 0000000..85bcd55 --- /dev/null +++ b/packages/assets/build.gradle.kts @@ -0,0 +1,11 @@ +plugins { + kotlin("js") + `js-conventions` + `publish-conventions` +} + +dependencies { + implementation(npm("@pixi/assets", Versions.pixi)) + + api(project(":pixi")) +} diff --git a/packages/assets/src/main/kotlin/pixi/typeAliasses.kt b/packages/assets/src/main/kotlin/pixi/typeAliasses.kt new file mode 100644 index 0000000..5c1a003 --- /dev/null +++ b/packages/assets/src/main/kotlin/pixi/typeAliasses.kt @@ -0,0 +1,4 @@ +package pixi + +typealias Cache = CacheClass +typealias ProgressCallback = (progress: Number) -> Unit diff --git a/packages/assets/src/main/kotlin/pixi/typings.kt b/packages/assets/src/main/kotlin/pixi/typings.kt new file mode 100644 index 0000000..ce4c169 --- /dev/null +++ b/packages/assets/src/main/kotlin/pixi/typings.kt @@ -0,0 +1,285 @@ +@file:JsModule("@pixi/assets") + +package pixi + +import kotlinx.js.Record +import org.w3c.dom.ImageBitmap +import pixi.typings.Object +import pixi.typings.core.BaseTexture +import pixi.typings.core.IAutoDetectOptions +import pixi.typings.core.Resource +import pixi.typings.core.Texture +import pixi.typings.extensions.ExtensionMetadata +import pixi.typings.spritesheet.Spritesheet +import kotlin.js.Promise + +external fun addFormats(vararg formats: String): (formats: Array) -> Promise> + +external interface AssetInitOptionsTexturePreference { + var resolution: dynamic? /* undefined | Number | Array */ + var format: dynamic? /* undefined | String | Array */ +} + +external interface AssetInitOptionsLoader { + var parsers: Array>? +} + +external interface AssetInitOptionsResolver { + var urlParsers: Array? + var preferOrders: Array? +} + +external interface AssetInitOptions { + var basePath: String? + var manifest: dynamic? /* undefined | String | ResolverManifest */ + var texturePreference: AssetInitOptionsTexturePreference? + var loader: AssetInitOptionsLoader? + var resolver: AssetInitOptionsResolver? +} + +external val Assets: AssetsClass + +external class AssetsClass { + var resolver: Resolver + var loader: Loader + var cache: Cache + + val detections: Array + + fun init(options: AssetInitOptions? = definedExternally): Promise + fun add(keysIn: String, assetsIn: String, data: Any? = definedExternally) + fun add(keysIn: Array, assetsIn: String, data: Any? = definedExternally) + fun add(keysIn: String, assetsIn: Array, data: Any? = definedExternally) + fun add(keysIn: Array, assetsIn: Array, data: Any? = definedExternally) + fun add(keysIn: String, assetsIn: Array, data: Any? = definedExternally) + fun add(keysIn: Array, assetsIn: Array, data: Any? = definedExternally) + + fun load(url: String, onProgress: ProgressCallback): Promise> */> + fun load(url: Array, onProgress: ProgressCallback): Promise> */> + fun load(url: LoadAsset, onProgress: ProgressCallback): Promise> */> + fun load(url: Array>, onProgress: ProgressCallback): Promise> */> + fun load(url: String, onProgress: ProgressCallback): Promise> */> + fun load(url: Array, onProgress: ProgressCallback): Promise> */> + fun load(url: LoadAsset, onProgress: ProgressCallback): Promise> */> + fun load(url: Array>, onProgress: ProgressCallback): Promise> */> + + fun addBundle(bundleId: String, assets: ResolverBundleBase) + fun loadBundle(bundleIds: String, onProgress: ProgressCallback = definedExternally): Promise + fun loadBundle(bundleIds: Array, onProgress: ProgressCallback = definedExternally): Promise + fun backgroundLoad(urls: String): Promise + fun backgroundLoad(urls: Array): Promise + fun backgroundLoadBundle(bundleIds: String): Promise + fun backgroundLoadBundle(bundleIds: Array): Promise + fun reset() + fun get(keys: String): dynamic /* T | Record */ + fun get(keys: Array): dynamic /* T | Record */ + fun get(keys: String): dynamic /* Any | Record */ + fun get(keys: Array): dynamic /* Any | Record */ + fun unload(url: String): Promise + fun unload(url: Array): Promise + fun unload(url: LoadAsset): Promise + fun unload(url: Array>): Promise + fun unloadBundle(bundleIds: String): Promise + fun unloadBundle(bundleIds: Array): Promise +} + +external fun basename(path: String, ext: String): String + +external class CacheClass { + val parsers: Array> + + fun reset() + fun has(key: String): Boolean + fun get(key: String): T + fun get(key: String): Any + fun set(key: String, value: T): T + fun set(key: String, value: Any): Any + fun remove(key: String): Any +} + +external interface CacheParser { + var extension: ExtensionMetadata? + var config: Record? + var test: (asset: T) -> Boolean + var getCacheableAssets: (keys: Array, asset: T) -> Record +} + +external val cacheSpriteSheet: CacheParser +external val cacheTextureArray: CacheParser>> + +external interface ConvertToList { + fun invoke(value: T): Array +} + +external fun convertToList(input: String, transform: (input: String) -> T = definedExternally): Array +external fun convertToList(input: T, transform: (input: String) -> T = definedExternally): Array +external fun convertToList(input: Array, transform: (input: String) -> T = definedExternally): Array +external fun convertToList(input: Array, transform: (input: String) -> T = definedExternally): Array + +external fun createStringVariations(string: String): Array + +external val detectAvif: FormatDetectionParser +external val detectBasis: FormatDetectionParser +external val detectCompressedTextures: FormatDetectionParser +external val detectWebp: FormatDetectionParser + +external fun dirname(path: String): String +external fun extname(path: String): String + +external interface FormatDetectionParser { + var extension: ExtensionMetadata? + var test: (asset: Any) -> Promise + var add: (formats: Array) -> Promise> + var remove: (formats: Array) -> Promise> +} + +external fun getBaseUrl(url: String): String +external fun getFontFamilyName(url: String): String +external fun isAbsouteUrl(url: String): Boolean +external val isSingleItem: (item: Any?) -> Boolean +external fun join(vararg parts: String): String + +external interface LoadAsset { + var src: String + var data: T? +} + +external val loadBasis: LoaderParser | Array> */, LoadTextureData> +external val loadBitmapFont: LoaderParser +external val loadDDS: LoaderParser + +external class Loader { + var promiseCache: Record + + val parsers: Array> + + fun reset() + fun load(assetsToLoadIn: String, onProgress: (progress: Number) -> Unit = definedExternally): Promise */> + fun load(assetsToLoadIn: Array, onProgress: (progress: Number) -> Unit = definedExternally): Promise */> + fun load(assetsToLoadIn: LoadAsset, onProgress: (progress: Number) -> Unit = definedExternally): Promise */> + fun load(assetsToLoadIn: Array>, onProgress: (progress: Number) -> Unit = definedExternally): Promise */> + fun unload(assetsToUnloadIn: String): Promise + fun unload(assetsToUnloadIn: Array): Promise + fun unload(assetsToUnloadIn: LoadAsset): Promise + fun unload(assetsToUnloadIn: Array>): Promise +} + +external interface LoaderParserLoad { + operator fun invoke(url: String, loadAsset: LoadAsset = definedExternally, loader: Loader = definedExternally): Promise +} + +external interface LoaderParserParse { + operator fun invoke(asset: ASSET, loadAsset: LoadAsset = definedExternally, loader: Loader = definedExternally): Promise +} + +external interface LoaderParser { + var extension: ExtensionMetadata? + var config: Record? + var test: ((url: String, loadAsset: LoadAsset?, loader: Loader?) -> Boolean)? + var load: LoaderParserLoad? + var testParse: ((asset: ASSET, loadAsset: LoadAsset?, loader: Loader?) -> Promise)? + var parse: LoaderParserParse? + var unload: ((asset: ASSET, loadAsset: LoadAsset?, loader: Loader?) -> Promise)? +} + +external interface LoadFontData { + var family: String + var display: String + var featureSettings: String + var stretch: String + var style: String + var unicodeRange: String + var variant: String + var weights: Array +} + +external fun loadImageBitmap(url: String): Promise + +external val loadJSON: LoaderParser +external val loadKTX: LoaderParser | Array> */, LoadTextureData> +external val loadSpriteSheet: LoaderParser + +external interface LoadTextureData { + var baseTexture: BaseTexture +} + +external val loadTexture: LoaderParser, LoadTextureData> +external val loadTxt: LoaderParser +external val loadWebFont: LoaderParser */, Any> + +external fun makeAbsoluteURL(url: String, customBaseUrl: String): String + +external interface PreferOrder { + var priority: Array? + var params: Object +} + +external interface PromiseAndParser { + var promise: Promise + var parser: LoaderParser +} + +external fun removeFormats(vararg format: String): (formats: Array) -> Promise> + +external interface ResolveAsset : Record { + var alias: Array? + var src: String +} + +external val resolveCompressedTextureUrl: ResolveURLParser + +external class Resolver { + var basePath: String + val parsers: Array + + fun prefer(vararg preferOrder: PreferOrder) + fun reset() + fun addManifest(manifest: ResolverManifest) + fun addBundle(bundleId: String, assets: ResolverBundleBase) + + fun add(keysIn: String, assetsIn: String, data: Any? = definedExternally) + fun add(keysIn: String, assetsIn: ResolveAsset, data: Any? = definedExternally) + fun add(keysIn: String, assetsIn: Array, data: Any? = definedExternally) + fun add(keysIn: String, assetsIn: Array, data: Any? = definedExternally) + fun add(keysIn: Array, assetsIn: String, data: Any? = definedExternally) + fun add(keysIn: Array, assetsIn: ResolveAsset, data: Any? = definedExternally) + fun add(keysIn: Array, assetsIn: Array, data: Any? = definedExternally) + fun add(keysIn: Array, assetsIn: Array, data: Any? = definedExternally) + + fun resoleBundle(bundleIds: String): Record + fun resoleBundle(bundleIds: Array): Record> + fun resolveUrl(url: String): String + fun resolveUrl(url: Array): Array + fun resolve(keys: String): ResolveAsset + fun resolve(keys: Array): Record +} + +external interface ResolverBundleBase + +external interface ResolverAssetsArray : ResolverBundleBase { + var name: Any /* String | Array */ + var srcs: Any /* String | Array */ +} + +external interface ResolverAssetsObject : ResolverBundleBase, Record + +external interface ResolverBundle { + var name: String + var assets: ResolverBundleBase +} + +external interface ResolverManifest { + var bundles: Array +} + +external val resolveSpriteSheetUrl: ResolveURLParser +external val resolveTextureUrl: ResolveURLParser + +external interface ResolveURLParser { + var extension: ExtensionMetadata? + var config: Record? + var test: (url: String) -> Boolean + var parse: (value: String) -> ResolveAsset +} + +external fun urlJoin(vararg url: String): String \ No newline at end of file