loader-base migrated to lerna, not yet to pixi v7

miltoncandelero · miltoncandelero · commit 60ab30b28d02 · 2023-01-11T13:01:53.000-03:00
diff --git a/packages/base/package.json b/packages/base/package.json
@@ -32,7 +32,7 @@
   "scripts": {
     "build": "run-p build:*",
     "build:rollup": "rollup -c rollup.config.mjs --silent",
-    "build:types": "rimraf compile && tsc -p tsconfig-api.json && api-extractor run && node scripts/injectGlobalMixins",
+    "build:types": "rimraf compile && tsc -p tsconfig-api.json && api-extractor run && node ../../scripts/injectGlobalMixins",
     "lint": "eslint src/**/*.ts",
     "lint:fix": "eslint src/**/*.ts --fix"
   },
diff --git a/packages/loader-base/package.json b/packages/loader-base/package.json
@@ -2,20 +2,36 @@
   "name": "@pixi-spine/loader-base",
   "version": "3.1.1",
   "description": "Pixi loader middleware base",
-  "main": "lib/loader-base.js",
-  "module": "lib/loader-base.es.js",
-  "bundle": "dist/loader-base.js",
+  "main": "lib/index.js",
+  "module": "lib/index.mjs",
   "types": "./index.d.ts",
-  "namespace": "PIXI.spine",
+  "exports": {
+    ".": {
+      "import": "./lib/index.mjs",
+      "require": "./lib/index.js",
+      "types": "./index.d.ts"
+    }
+  },
+  "extensionConfig": {
+    "namespace": "PIXI.spine",
+    "bundle": "dist/loader-base.js",
+    "bundleModule": "dist/loader-base.mjs",
+    "globals": {
+      "@pixi-spine/base": "PIXI.spine"
+    }
+  },
   "peerDependencies": {
     "@pixi/constants": "^6.1.0",
     "@pixi/core": "^6.1.0",
     "@pixi/loaders": "^6.1.0",
     "@pixi-spine/base": "*"
   },
   "scripts": {
-    "build": "rollup -c rollup.config.js --silent",
-    "build:types": "rimraf compile && tsc -p tsconfig-api.json && api-extractor run && node scripts/injectGlobalMixins"
+    "build": "run-p build:*",
+    "build:rollup": "rollup -c rollup.config.mjs --silent",
+    "build:types": "rimraf compile && tsc -p tsconfig-api.json && api-extractor run && node ../../scripts/injectGlobalMixins",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix"
   },
   "repository": {
     "type": "git",
diff --git a/packages/loader-base/rollup.config.js b/packages/loader-base/rollup.config.js
diff --git a/packages/loader-base/rollup.config.mjs b/packages/loader-base/rollup.config.mjs
@@ -0,0 +1,4 @@
+import configBuilder from "@pixi-spine/rollup-config";
+import pkg from "./package.json" assert { type: "json" };
+
+export default configBuilder(pkg.extensionConfig, pkg);
diff --git a/packages/loader-base/src/index.ts b/packages/loader-base/src/index.ts
@@ -1,2 +1,4 @@
+/* eslint-disable spaced-comment */
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
 /// <reference path="../global.d.ts" />
 export * from './loaders';
diff --git a/packages/loader-base/src/loaders.ts b/packages/loader-base/src/loaders.ts
@@ -1,7 +1,7 @@
-import {IResourceMetadata, Loader, LoaderResource} from "@pixi/loaders";
-import {BaseTexture, Texture} from "@pixi/core";
-import {ISkeletonParser, TextureAtlas} from "@pixi-spine/base";
-import {ALPHA_MODES} from "@pixi/constants";
+import { IResourceMetadata, Loader, LoaderResource } from '@pixi/loaders';
+import { BaseTexture, IAutoDetectOptions, Resource, Texture } from '@pixi/core';
+import { ISkeletonParser, TextureAtlas } from '@pixi-spine/base';
+import { ALPHA_MODES } from '@pixi/constants';
 
 function isJson(resource: LoaderResource) {
     return resource.type === LoaderResource.TYPE.JSON;
@@ -24,6 +24,7 @@ export abstract class AbstractSpineParser {
     abstract parseData(resource: LoaderResource, parser: ISkeletonParser, atlas: TextureAtlas, dataToParse: any): void;
 
     genMiddleware() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
 
         return {
@@ -34,8 +35,7 @@ export abstract class AbstractSpineParser {
                 }
 
                 const isJsonSpineModel = isJson(resource) && resource.data.bones;
-                const isBinarySpineModel = isBuffer(resource) && (resource.extension === 'skel' || resource.metadata
-                    && (resource.metadata as any).spineMetadata);
+                const isBinarySpineModel = isBuffer(resource) && (resource.extension === 'skel' || (resource.metadata && (resource.metadata as any).spineMetadata));
 
                 if (!isJsonSpineModel && !isBinarySpineModel) {
                     return next();
@@ -61,11 +61,13 @@ export abstract class AbstractSpineParser {
                 }
 
                 const metadataAtlas = metadata.spineAtlas;
+
                 if (metadataAtlas === false) {
                     return next();
                 }
                 if (metadataAtlas && metadataAtlas.pages) {
                     self.parseData(resource, parser, metadataAtlas, dataToParse);
+
                     return next();
                 }
 
@@ -77,83 +79,91 @@ export abstract class AbstractSpineParser {
                  * have the same name
                  */
                 let atlasPath = resource.url;
-                let queryStringPos = atlasPath.indexOf('?');
+                const queryStringPos = atlasPath.indexOf('?');
+
                 if (queryStringPos > 0) {
-                    //remove querystring
-                    atlasPath = atlasPath.substr(0, queryStringPos)
+                    // remove querystring
+                    atlasPath = atlasPath.substr(0, queryStringPos);
                 }
                 atlasPath = atlasPath.substr(0, atlasPath.lastIndexOf('.')) + metadataAtlasSuffix;
-// use atlas path as a params. (no need to use same atlas file name with json file name)
+                // use atlas path as a params. (no need to use same atlas file name with json file name)
                 if (metadata.spineAtlasFile) {
                     atlasPath = metadata.spineAtlasFile;
                 }
 
-//remove the baseUrl
+                // remove the baseUrl
                 atlasPath = atlasPath.replace(this.baseUrl, '');
 
                 const atlasOptions = {
                     crossOrigin: resource.crossOrigin,
                     xhrType: LoaderResource.XHR_RESPONSE_TYPE.TEXT,
                     metadata: metadata.spineMetadata || null,
-                    parentResource: resource
+                    parentResource: resource,
                 };
                 const imageOptions = {
                     crossOrigin: resource.crossOrigin,
                     metadata: metadata.imageMetadata || null,
-                    parentResource: resource
+                    parentResource: resource,
                 };
                 let baseUrl = resource.url.substr(0, resource.url.lastIndexOf('/') + 1);
-//remove the baseUrl
+                // remove the baseUrl
+
                 baseUrl = baseUrl.replace(this.baseUrl, '');
 
-                const namePrefix = metadata.imageNamePrefix || (resource.name + '_atlas_page_');
+                const namePrefix = metadata.imageNamePrefix || `${resource.name}_atlas_page_`;
+
+                let adapter: (line: string, callback: (baseTexture: BaseTexture<Resource, IAutoDetectOptions>) => any) => void;
 
-                const adapter = metadata.images ? staticImageLoader(metadata.images)
-                    : metadata.image ? staticImageLoader({'default': metadata.image})
-                        : metadata.imageLoader ? metadata.imageLoader(this, namePrefix, baseUrl, imageOptions)
-                            : imageLoaderAdapter(this, namePrefix, baseUrl, imageOptions);
+                if (metadata.images) adapter = staticImageLoader(metadata.images);
+                else if (metadata.image) adapter = staticImageLoader({ default: metadata.image });
+                else if (metadata.imageLoader) adapter = metadata.imageLoader(this, namePrefix, baseUrl, imageOptions);
+                else adapter = imageLoaderAdapter(this, namePrefix, baseUrl, imageOptions);
 
-                function createSkeletonWithRawAtlas(rawData: string) {
-                    new TextureAtlas(rawData, adapter, function(spineAtlas) {
+                const createSkeletonWithRawAtlas = (rawData: string) => {
+                    // eslint-disable-next-line no-new
+                    new TextureAtlas(rawData, adapter, (spineAtlas) => {
                         if (spineAtlas) {
                             self.parseData(resource, parser, spineAtlas, dataToParse);
                         }
                         next();
                     });
-                }
+                };
 
                 if (metadata.atlasRawData) {
-                    createSkeletonWithRawAtlas(metadata.atlasRawData)
+                    createSkeletonWithRawAtlas(metadata.atlasRawData);
                 } else {
-                    this.add(resource.name + '_atlas', atlasPath, atlasOptions, function (atlasResource: any) {
+                    this.add(`${resource.name}_atlas`, atlasPath, atlasOptions, (atlasResource: any) => {
                         if (!atlasResource.error) {
                             createSkeletonWithRawAtlas(atlasResource.data);
                         } else {
                             next();
                         }
                     });
                 }
-            }
-        }
+            },
+        };
     }
 }
 
 /**
  * @public
  */
 export function imageLoaderAdapter(loader: any, namePrefix: any, baseUrl: any, imageOptions: any) {
-    if (baseUrl && baseUrl.lastIndexOf('/') !== (baseUrl.length - 1)) {
+    if (baseUrl && baseUrl.lastIndexOf('/') !== baseUrl.length - 1) {
         baseUrl += '/';
     }
-    return function (line: string, callback: (baseTexture: BaseTexture) => any) {
+
+    return (line: string, callback: (baseTexture: BaseTexture) => any) => {
         const name = namePrefix + line;
         const url = baseUrl + line;
 
         const cachedResource = loader.resources[name];
+
         if (cachedResource) {
             const done = () => {
-                callback(cachedResource.texture.baseTexture)
-            }
+                callback(cachedResource.texture.baseTexture);
+            };
+
             if (cachedResource.texture) {
                 done();
             } else {
@@ -172,30 +182,30 @@ export function imageLoaderAdapter(loader: any, namePrefix: any, baseUrl: any, i
                 }
             });
         }
-    }
+    };
 }
 
 /**
  * @public
  */
 export function syncImageLoaderAdapter(baseUrl: any, crossOrigin: any) {
-    if (baseUrl && baseUrl.lastIndexOf('/') !== (baseUrl.length - 1)) {
+    if (baseUrl && baseUrl.lastIndexOf('/') !== baseUrl.length - 1) {
         baseUrl += '/';
     }
-    return function (line: any, callback: any) {
+
+    return (line: any, callback: any) => {
         callback(BaseTexture.from(line, crossOrigin));
-    }
+    };
 }
 
 /**
  * @public
  */
-export function staticImageLoader(pages: { [key: string]: (BaseTexture | Texture) }) {
-    return function (line: any, callback: any) {
-        let page = pages[line] || pages['default'] as any;
-        if (page && page.baseTexture)
-            callback(page.baseTexture);
-        else
-            callback(page);
-    }
+export function staticImageLoader(pages: { [key: string]: BaseTexture | Texture }) {
+    return (line: any, callback: any) => {
+        const page = pages[line] || (pages.default as any);
+
+        if (page && page.baseTexture) callback(page.baseTexture);
+        else callback(page);
+    };
 }
diff --git a/scripts/injectGlobalMixins.js b/scripts/injectGlobalMixins.js
