webgltexture-loader - npm Package Compare versions

Comparing version 0.12.0-minor.adc60f91 to 0.12.2

lib/globalRegistry.js

@@ -1,9 +0,19 @@
-import LoadersRegistry from "./LoadersRegistry";
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _LoadersRegistry = _interopRequireDefault(require("./LoadersRegistry"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const root = typeof window === "undefined" ? global : window;
-const key = "__webglTextureLoader_registry";
+const key = "__webglTextureLoader_registry"; // This is a convenient loader registry that store all imported registry
+// it needs to be in global state so it does not get lost across potential many lib instances
 
-// This is a convenient loader registry that store all imported registry
-// it needs to be in global state so it does not get lost across potential many lib instances
-export default root[key] || (root[key] = new LoadersRegistry());
+var _default = root[key] || (root[key] = new _LoadersRegistry.default());
+
+exports.default = _default;
 //# sourceMappingURL=globalRegistry.js.map

lib/globalRegistry.test.js

@@ -1,7 +0,12 @@
-import globalRegistry from "./globalRegistry";
-import LoadersRegistry from "./LoadersRegistry";
+"use strict";
 
+var _globalRegistry = _interopRequireDefault(require("./globalRegistry"));
+
+var _LoadersRegistry = _interopRequireDefault(require("./LoadersRegistry"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 test("globalRegistry is available", () => {
-  expect(globalRegistry).toBeInstanceOf(LoadersRegistry);
+  expect(_globalRegistry.default).toBeInstanceOf(_LoadersRegistry.default);
 });
 //# sourceMappingURL=globalRegistry.test.js.map

lib/index.js

@@ -1,9 +0,56 @@
-import WebGLTextureLoader from "./WebGLTextureLoader";
-import WebGLTextureLoaderAsyncHashCache from "./WebGLTextureLoaderAsyncHashCache";
-import WebGLTextureLoaderSyncHashCache from "./WebGLTextureLoaderSyncHashCache";
-import LoadersRegistry from "./LoadersRegistry";
-import LoaderResolver from "./LoaderResolver";
-import globalRegistry from "./globalRegistry";
+"use strict";
 
-export { globalRegistry, LoadersRegistry, LoaderResolver, WebGLTextureLoader, WebGLTextureLoaderAsyncHashCache, WebGLTextureLoaderSyncHashCache };
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "WebGLTextureLoader", {
+  enumerable: true,
+  get: function () {
+    return _WebGLTextureLoader.default;
+  }
+});
+Object.defineProperty(exports, "WebGLTextureLoaderAsyncHashCache", {
+  enumerable: true,
+  get: function () {
+    return _WebGLTextureLoaderAsyncHashCache.default;
+  }
+});
+Object.defineProperty(exports, "WebGLTextureLoaderSyncHashCache", {
+  enumerable: true,
+  get: function () {
+    return _WebGLTextureLoaderSyncHashCache.default;
+  }
+});
+Object.defineProperty(exports, "LoadersRegistry", {
+  enumerable: true,
+  get: function () {
+    return _LoadersRegistry.default;
+  }
+});
+Object.defineProperty(exports, "LoaderResolver", {
+  enumerable: true,
+  get: function () {
+    return _LoaderResolver.default;
+  }
+});
+Object.defineProperty(exports, "globalRegistry", {
+  enumerable: true,
+  get: function () {
+    return _globalRegistry.default;
+  }
+});
+
+var _WebGLTextureLoader = _interopRequireDefault(require("./WebGLTextureLoader"));
+
+var _WebGLTextureLoaderAsyncHashCache = _interopRequireDefault(require("./WebGLTextureLoaderAsyncHashCache"));
+
+var _WebGLTextureLoaderSyncHashCache = _interopRequireDefault(require("./WebGLTextureLoaderSyncHashCache"));
+
+var _LoadersRegistry = _interopRequireDefault(require("./LoadersRegistry"));
+
+var _LoaderResolver = _interopRequireDefault(require("./LoaderResolver"));
+
+var _globalRegistry = _interopRequireDefault(require("./globalRegistry"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 //# sourceMappingURL=index.js.map

lib/LoaderResolver.js

@@ -1,6 +0,18 @@
-import globalRegistry from "./globalRegistry";
+"use strict";
 
-export default class LoaderResolver {
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
 
-  constructor(gl, registry = globalRegistry) {
+var _globalRegistry = _interopRequireDefault(require("./globalRegistry"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class LoaderResolver {
+  constructor(gl, registry = _globalRegistry.default) {
+    _defineProperty(this, "loaders", void 0);
+
     this.loaders = registry.get().map(L => new L(gl));
@@ -16,3 +28,6 @@ }
   }
+
 }
+
+exports.default = LoaderResolver;
 //# sourceMappingURL=LoaderResolver.js.map

lib/LoaderResolver.test.js

@@ -1,8 +0,14 @@
-import LoaderResolver from "./LoaderResolver";
-import LoadersRegistry from "./LoadersRegistry";
-import WebGLTextureLoaderSyncHashCache from "./WebGLTextureLoaderSyncHashCache";
+"use strict";
 
+var _LoaderResolver = _interopRequireDefault(require("./LoaderResolver"));
+
+var _LoadersRegistry = _interopRequireDefault(require("./LoadersRegistry"));
+
+var _WebGLTextureLoaderSyncHashCache = _interopRequireDefault(require("./WebGLTextureLoaderSyncHashCache"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 test("an empty LoaderResolver resolves nothing", () => {
   const gl = {};
-  const resolver = new LoaderResolver(gl);
+  const resolver = new _LoaderResolver.default(gl);
   expect(resolver.resolve(null)).toBeUndefined();
@@ -13,3 +19,2 @@ expect(resolver.resolve(42)).toBeUndefined();
 });
-
 test("LoaderResolver works with one loader", () => {
@@ -19,16 +24,27 @@ const gl = {
   };
-  const registry = new LoadersRegistry();
-  class FakeLoader extends WebGLTextureLoaderSyncHashCache {
+  const registry = new _LoadersRegistry.default();
+
+  class FakeLoader extends _WebGLTextureLoaderSyncHashCache.default {
     canLoad(input) {
       return typeof input === "number";
     }
+
     inputHash(input) {
       return input;
     }
+
     getNoCache(input) {
-      return { texture: { id: input }, width: 2, height: 2 };
+      return {
+        texture: {
+          id: input
+        },
+        width: 2,
+        height: 2
+      };
     }
+
   }
+
   registry.add(FakeLoader);
-  const resolver = new LoaderResolver(gl, registry);
+  const resolver = new _LoaderResolver.default(gl, registry);
   expect(resolver.resolve(null)).toBeUndefined();
@@ -35,0 +51,0 @@ expect(resolver.resolve("foo")).toBeUndefined();

lib/LoadersRegistry.js

@@ -0,3 +1,10 @@
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
 
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 /**
@@ -7,5 +14,5 @@ * LoadersRegistry
  */
-export default class LoadersRegistry {
+class LoadersRegistry {
   constructor() {
-    this._loaders = [];
+    _defineProperty(this, "_loaders", []);
   }
@@ -18,10 +25,15 @@
     this._loaders.push(loader);
-    this._loaders.sort((a, b) => (typeof b.priority === "number" ? b.priority : 0) - (typeof a.priority === "number" ? a.priority : 0));
+
+    this._loaders.sort((a, b) => // $FlowFixMe
+    (typeof b.priority === "number" ? b.priority : 0) - ( // $FlowFixMe
+    typeof a.priority === "number" ? a.priority : 0));
   }
-
   /**
    * Remove a previously added WebGLTextureLoader class.
    */
+
+
   remove(loader) {
     const i = this._loaders.indexOf(loader);
+
     if (i !== -1) {
@@ -31,10 +43,14 @@ this._loaders.splice(i, 1);
   }
-
   /**
    * List the loaders ordered by most priority first
    */
+
+
   get() {
     return this._loaders;
   }
+
 }
+
+exports.default = LoadersRegistry;
 //# sourceMappingURL=LoadersRegistry.js.map

lib/WebGLTextureLoader.js

@@ -0,7 +1,17 @@
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
 
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 /**
  * a WebGLTextureLoader handle the loading of WebGLTexture for a given input object.
  */
-export default class WebGLTextureLoader {
+class WebGLTextureLoader {
+  /**
+   * @property {WebGLRenderingContext} gl - the contextual rendering context
+   */
 
@@ -12,5 +22,6 @@ /**
   constructor(gl) {
+    _defineProperty(this, "gl", void 0);
+
     this.gl = gl;
   }
-
   /**
@@ -20,7 +31,4 @@ * Cancel and clear everything
 
-  /**
-   * @property {WebGLRenderingContext} gl - the contextual rendering context
-   */
 
-
+  dispose() {}
   /**
@@ -31,2 +39,5 @@ * Check if the loader can handle a given input
 
+  canLoad(input) {
+    return false;
+  }
   /**
@@ -38,2 +49,5 @@ * Load the resource by its input. returns a promise of {texture,width,height}.
 
+  load(input) {
+    return Promise.reject("load() is not implemented");
+  }
   /**
@@ -45,2 +59,5 @@ * try to get in sync the texture for a given input. otherwise null/undefined.
 
+  get(input) {
+    return null;
+  }
   /**
@@ -50,6 +67,10 @@ * sync the webgl texture with a loaded input. for instance for <video>/<canvas> elements this needs to be called recurrently (like in a requestAnimationFrame loop) to get the texture updated.
    */
-  update(input) {
-    // Default implementation don't do anything which works for all static content like an image
+
+
+  update(input) {// Default implementation don't do anything which works for all static content like an image
   }
+
 }
+
+exports.default = WebGLTextureLoader;
 //# sourceMappingURL=WebGLTextureLoader.js.map

lib/WebGLTextureLoaderAsyncHashCache.js

@@ -1,20 +0,54 @@
-import WebGLTextureLoader from "./WebGLTextureLoader";
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
 
+var _WebGLTextureLoader = _interopRequireDefault(require("./WebGLTextureLoader"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 const neverEnding = new Promise(() => {});
-
 /**
  * A cache implementation of WebGLTextureLoader with a input hash function
  */
-class WebGLTextureLoaderAsyncHashCache extends WebGLTextureLoader {
+
+class WebGLTextureLoaderAsyncHashCache extends _WebGLTextureLoader.default {
   constructor(...args) {
-    var _temp;
+    super(...args);
 
-    return _temp = super(...args), this.disposes = new Map(), this.inputs = new Map(), this.promises = new Map(), this.results = new Map(), this._disposed = false, _temp;
+    _defineProperty(this, "disposes", new Map());
+
+    _defineProperty(this, "inputs", new Map());
+
+    _defineProperty(this, "promises", new Map());
+
+    _defineProperty(this, "results", new Map());
+
+    _defineProperty(this, "_disposed", false);
   }
-  // An async load function that does not cache (WebGLTextureLoaderAsyncHashCache do the caching with inputHash). it also should return a dispose function to cancel a pending load
 
+  inputHash(input) {
+    return "";
+  } // An async load function that does not cache (WebGLTextureLoaderAsyncHashCache do the caching with inputHash). it also should return a dispose function to cancel a pending load
 
+
+  loadNoCache(input) {
+    return {
+      promise: Promise.reject(new Error("loadNoCache is not implemented")),
+      dispose: () => {}
+    };
+  }
+
   dispose() {
-    const { gl, promises, results, inputs, disposes } = this;
+    const {
+      gl,
+      promises,
+      results,
+      inputs,
+      disposes
+    } = this;
     disposes.forEach(d => d());
@@ -45,2 +79,3 @@ results.forEach(result => {
       }
+
       this.disposes.delete(hash);
@@ -62,2 +97,3 @@ this.results.set(hash, result);
     const dispose = this.disposes.get(hash);
+
     if (dispose) {
@@ -68,5 +104,7 @@ dispose();
   }
+
 }
 
-export default WebGLTextureLoaderAsyncHashCache;
+var _default = WebGLTextureLoaderAsyncHashCache;
+exports.default = _default;
 //# sourceMappingURL=WebGLTextureLoaderAsyncHashCache.js.map

lib/WebGLTextureLoaderAsyncHashCache.test.js

@@ -1,20 +0,27 @@
-function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+"use strict";
 
-import WebGLTextureLoaderAsyncHashCache from "./WebGLTextureLoaderAsyncHashCache";
+var _WebGLTextureLoaderAsyncHashCache = _interopRequireDefault(require("./WebGLTextureLoaderAsyncHashCache"));
 
-test("WebGLTextureLoaderAsyncHashCache simple usage", _asyncToGenerator(function* () {
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+test("WebGLTextureLoaderAsyncHashCache simple usage", async () => {
   const gl = {
-    deleteTexture: function () {}
+    deleteTexture: () => {}
   };
-  class FakeLoader extends WebGLTextureLoaderAsyncHashCache {
+
+  class FakeLoader extends _WebGLTextureLoaderAsyncHashCache.default {
     canLoad(input) {
       return typeof input === "number";
     }
+
     inputHash(input) {
       return input;
     }
+
     loadNoCache(input) {
       return {
         promise: Promise.resolve({
-          texture: { id: input },
+          texture: {
+            id: input
+          },
           width: 2,
@@ -26,16 +33,22 @@ height: 2
     }
+
   }
+
   const loader = new FakeLoader(gl);
-  let res = yield loader.load(42);
+  let res = await loader.load(42);
   expect(res).toMatchObject({
-    texture: { id: 42 },
+    texture: {
+      id: 42
+    },
     width: 2,
     height: 2
   });
-  expect(loader.get(42)).toBe(res);
-  // test with another value
+  expect(loader.get(42)).toBe(res); // test with another value
+
   expect(loader.get(43)).toBeUndefined();
-  res = yield loader.load(43);
+  res = await loader.load(43);
   expect(res).toMatchObject({
-    texture: { id: 43 },
+    texture: {
+      id: 43
+    },
     width: 2,
@@ -46,3 +59,3 @@ height: 2
   loader.dispose();
-}));
+});
 //# sourceMappingURL=WebGLTextureLoaderAsyncHashCache.test.js.map

lib/WebGLTextureLoaderSyncHashCache.js

@@ -1,17 +0,41 @@
-import WebGLTextureLoader from "./WebGLTextureLoader";
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
 
-class WebGLTextureLoaderSyncHashCache extends WebGLTextureLoader {
+var _WebGLTextureLoader = _interopRequireDefault(require("./WebGLTextureLoader"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class WebGLTextureLoaderSyncHashCache extends _WebGLTextureLoader.default {
   constructor(...args) {
-    var _temp;
+    super(...args);
 
-    return _temp = super(...args), this.results = new Map(), this.promises = new Map(), this._disposed = false, _temp;
+    _defineProperty(this, "results", new Map());
+
+    _defineProperty(this, "promises", new Map());
+
+    _defineProperty(this, "_disposed", false);
   }
+
   // return a unique representation of the input (typically a hash, or anything that can be used as ref identifier)
+  inputHash(input) {
+    return "";
+  } // An async load function that does not cache (WebGLTextureLoaderAsyncHashCache do the caching with inputHash). it also should return a dispose function to cancel a pending load
 
-  // An sync load function that does not cache (WebGLTextureLoaderAsyncHashCache do the caching with inputHash)
 
+  getNoCache(input) {
+    throw new Error("getNoCache must be implemented");
+  }
 
   dispose() {
-    const { gl, results, promises } = this;
+    const {
+      gl,
+      results,
+      promises
+    } = this;
     results.forEach(r => {
@@ -36,5 +60,5 @@ this.disposeTexture(r.texture);
     return freshResult;
-  }
+  } // load() implementation is a dumb fallback on get() but still need to save the promise to guarantee idempotent
 
-  // load() implementation is a dumb fallback on get() but still need to save the promise to guarantee idempotent
+
   load(input) {
@@ -48,5 +72,7 @@ const hash = this.inputHash(input);
   }
+
 }
 
-export default WebGLTextureLoaderSyncHashCache;
+var _default = WebGLTextureLoaderSyncHashCache;
+exports.default = _default;
 //# sourceMappingURL=WebGLTextureLoaderSyncHashCache.js.map

lib/WebGLTextureLoaderSyncHashCache.test.js

@@ -1,3 +0,7 @@
-import WebGLTextureLoaderSyncHashCache from "./WebGLTextureLoaderSyncHashCache";
+"use strict";
 
+var _WebGLTextureLoaderSyncHashCache = _interopRequireDefault(require("./WebGLTextureLoaderSyncHashCache"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 test("simple usage", () => {
@@ -7,16 +11,29 @@ const gl = {
   };
-  class FakeLoader extends WebGLTextureLoaderSyncHashCache {
+
+  class FakeLoader extends _WebGLTextureLoaderSyncHashCache.default {
     canLoad(input) {
       return typeof input === "number";
     }
+
     inputHash(input) {
       return input;
     }
+
     getNoCache(input) {
-      return { texture: { id: input }, width: 2, height: 2 };
+      return {
+        texture: {
+          id: input
+        },
+        width: 2,
+        height: 2
+      };
     }
+
   }
+
   const loader = new FakeLoader(gl);
   expect(loader.get(42)).toMatchObject({
-    texture: { id: 42 },
+    texture: {
+      id: 42
+    },
     width: 2,
@@ -26,3 +43,5 @@ height: 2
   expect(loader.get(43)).toMatchObject({
-    texture: { id: 43 },
+    texture: {
+      id: 43
+    },
     width: 2,
@@ -29,0 +48,0 @@ height: 2

package.json

 {
   "name": "webgltexture-loader",
-  "version": "0.12.0-minor.adc60f91",
+  "version": "0.12.2",
   "description": "load & cache various kind of WebGLTexture with an extensible and loosely coupled system",
@@ -18,3 +18,4 @@ "keywords": [
   "author": "Gaëtan Renaudeau <[e-mail]>",
-  "license": "MIT"
+  "license": "MIT",
+  "gitHead": "0ded2ac0b0c83f6925d01748b299d02ac294e7d3"
 }

src/LoadersRegistry.js

@@ -18,3 +18,5 @@ //@flow
       (a, b) =>
+        // $FlowFixMe
         (typeof b.priority === "number" ? b.priority : 0) -
+        // $FlowFixMe
         (typeof a.priority === "number" ? a.priority : 0)
@@ -21,0 +23,0 @@ );

src/WebGLTextureLoader.js

@@ -28,3 +28,3 @@ //@flow
    */
-  +dispose: () => void;
+  dispose() {}
 
@@ -34,3 +34,5 @@ /**
    */
-  +canLoad: (input: any) => boolean;
+  canLoad(input: any): boolean {
+    return false;
+  }
 
@@ -41,3 +43,5 @@ /**
    */
-  +load: (input: T) => Promise<TextureAndSize>;
+  load(input: T): Promise<TextureAndSize> {
+    return Promise.reject("load() is not implemented");
+  }
 
@@ -48,3 +52,5 @@ /**
    */
-  +get: (input: T) => ?TextureAndSize;
+  get(input: T): ?TextureAndSize {
+    return null;
+  }
 
@@ -51,0 +57,0 @@ /**

src/WebGLTextureLoaderAsyncHashCache.js

@@ -11,7 +11,14 @@ //@flow
 class WebGLTextureLoaderAsyncHashCache<T> extends WebGLTextureLoader<T> {
-  +inputHash: (input: T) => *;
+  inputHash(input: T) {
+    return "";
+  }
   // An async load function that does not cache (WebGLTextureLoaderAsyncHashCache do the caching with inputHash). it also should return a dispose function to cancel a pending load
-  +loadNoCache: (
+  loadNoCache(
     input: T
-  ) => { promise: Promise<TextureAndSize>, dispose: Function };
+  ): { promise: Promise<TextureAndSize>, dispose: Function } {
+    return {
+      promise: Promise.reject(new Error("loadNoCache is not implemented")),
+      dispose: () => {}
+    };
+  }
 
@@ -18,0 +25,0 @@ disposes: Map<*, Function> = new Map();

src/WebGLTextureLoaderSyncHashCache.js

@@ -7,5 +7,9 @@ //@flow
   // return a unique representation of the input (typically a hash, or anything that can be used as ref identifier)
-  +inputHash: (input: T) => *;
-  // An sync load function that does not cache (WebGLTextureLoaderAsyncHashCache do the caching with inputHash)
-  +getNoCache: (input: T) => TextureAndSize;
+  inputHash(input: T) {
+    return "";
+  }
+  // An async load function that does not cache (WebGLTextureLoaderAsyncHashCache do the caching with inputHash). it also should return a dispose function to cancel a pending load
+  getNoCache(input: T): TextureAndSize {
+    throw new Error("getNoCache must be implemented");
+  }
 
@@ -12,0 +16,0 @@ results: Map<*, TextureAndSize> = new Map();

No alert changes

Improved metrics

Total package byte prevSize

67824

12.62%

Lines of code

811

26.72%

No dependency changes