@loaders.gl/textures 3.2.0-alpha.1 → 3.2.0-alpha.4

package/dist/ktx2-basis-writer-nodejs.d.ts

@@ -0,0 +1,3 @@
+import '@loaders.gl/polyfills';
+export { KTX2BasisWriter as KTX2BasisWriterNodeJS } from './ktx2-basis-writer';
+//# sourceMappingURL=ktx2-basis-writer-nodejs.d.ts.map

package/dist/ktx2-basis-writer-nodejs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ktx2-basis-writer-nodejs.d.ts","sourceRoot":"","sources":["../src/ktx2-basis-writer-nodejs.ts"],"names":[],"mappings":"AACA,OAAO,uBAAuB,CAAC;AAE/B,OAAO,EAAC,eAAe,IAAI,qBAAqB,EAAC,MAAM,qBAAqB,CAAC"}

package/dist/ktx2-basis-writer-nodejs.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KTX2BasisWriterNodeJS = void 0;
+// Polyfills increases the bundle size significantly. Use it for NodeJS worker only
+require("@loaders.gl/polyfills");
+var ktx2_basis_writer_1 = require("./ktx2-basis-writer");
+Object.defineProperty(exports, "KTX2BasisWriterNodeJS", { enumerable: true, get: function () { return ktx2_basis_writer_1.KTX2BasisWriter; } });

package/dist/ktx2-basis-writer-worker.js

@@ -0,0 +1,343 @@
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __reExport = (target, module, desc) => {
+    if (module && typeof module === "object" || typeof module === "function") {
+      for (let key of __getOwnPropNames(module))
+        if (!__hasOwnProp.call(target, key) && key !== "default")
+          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+    }
+    return target;
+  };
+  var __toModule = (module) => {
+    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+  };
+
+  // (disabled):../worker-utils/src/lib/node/require-utils.node
+  var require_require_utils = __commonJS({
+    "(disabled):../worker-utils/src/lib/node/require-utils.node"() {
+    }
+  });
+
+  // ../worker-utils/src/lib/env-utils/version.ts
+  var VERSION = true ? "3.2.0-alpha.4" : DEFAULT_VERSION;
+  if (false) {
+    console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+  }
+
+  // ../worker-utils/src/lib/env-utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loaders.gl assertion failed.");
+    }
+  }
+
+  // ../worker-utils/src/lib/env-utils/globals.ts
+  var globals = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
+  };
+  var self_ = globals.self || globals.window || globals.global || {};
+  var window_ = globals.window || globals.self || globals.global || {};
+  var global_ = globals.global || globals.self || globals.window || {};
+  var document_ = globals.document || {};
+  var isBrowser = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
+  var isWorker = typeof importScripts === "function";
+  var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion = matches && parseFloat(matches[1]) || 0;
+
+  // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
+  function getTransferList(object, recursive = true, transfers) {
+    const transfersSet = transfers || new Set();
+    if (!object) {
+    } else if (isTransferable(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList(object[key], recursive, transfersSet);
+      }
+    }
+    return transfers === void 0 ? Array.from(transfersSet) : [];
+  }
+  function isTransferable(object) {
+    if (!object) {
+      return false;
+    }
+    if (object instanceof ArrayBuffer) {
+      return true;
+    }
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
+    }
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
+    }
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
+    }
+    return false;
+  }
+
+  // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  function getParentPort() {
+    let parentPort;
+    try {
+      eval("globalThis.parentPort = require('worker_threads').parentPort");
+      parentPort = globalThis.parentPort;
+    } catch {
+    }
+    return parentPort;
+  }
+  var onMessageWrapperMap = new Map();
+  var WorkerBody = class {
+    static inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(getParentPort());
+    }
+    static set onmessage(onMessage) {
+      function handleMessage(message) {
+        const parentPort3 = getParentPort();
+        const { type, payload } = parentPort3 ? message : message.data;
+        onMessage(type, payload);
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.on("message", handleMessage);
+        parentPort2.on("exit", () => console.debug("Node worker closing"));
+      } else {
+        globalThis.onmessage = handleMessage;
+      }
+    }
+    static addEventListener(onMessage) {
+      let onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      if (!onMessageWrapper) {
+        onMessageWrapper = (message) => {
+          if (!isKnownMessage(message)) {
+            return;
+          }
+          const parentPort3 = getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
+          onMessage(type, payload);
+        };
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
+    }
+    static removeEventListener(onMessage) {
+      const onMessageWrapper = onMessageWrapperMap.get(onMessage);
+      onMessageWrapperMap.delete(onMessage);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
+    }
+    static postMessage(type, payload) {
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
+      }
+    }
+  };
+  function isKnownMessage(message) {
+    const { type, data } = message;
+    return type === "message" && data && typeof data.source === "string" && data.source.startsWith("loaders.gl");
+  }
+
+  // ../worker-utils/src/lib/library-utils/library-utils.ts
+  var node = __toModule(require_require_utils());
+  var LATEST = "beta";
+  var VERSION2 = typeof VERSION !== "undefined" ? VERSION : LATEST;
+  var loadLibraryPromises = {};
+  async function loadLibrary(libraryUrl, moduleName = null, options = {}) {
+    if (moduleName) {
+      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options);
+    }
+    loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
+    return await loadLibraryPromises[libraryUrl];
+  }
+  function getLibraryUrl(library, moduleName, options) {
+    if (library.startsWith("http")) {
+      return library;
+    }
+    const modules = options.modules || {};
+    if (modules[library]) {
+      return modules[library];
+    }
+    if (!isBrowser) {
+      return `modules/${moduleName}/dist/libs/${library}`;
+    }
+    if (options.CDN) {
+      assert(options.CDN.startsWith("http"));
+      return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${library}`;
+    }
+    if (isWorker) {
+      return `../src/libs/${library}`;
+    }
+    return `modules/${moduleName}/src/libs/${library}`;
+  }
+  async function loadLibraryFromFile(libraryUrl) {
+    if (libraryUrl.endsWith("wasm")) {
+      const response2 = await fetch(libraryUrl);
+      return await response2.arrayBuffer();
+    }
+    if (!isBrowser) {
+      try {
+        return node && node.requireFromFile && await node.requireFromFile(libraryUrl);
+      } catch {
+        return null;
+      }
+    }
+    if (isWorker) {
+      return importScripts(libraryUrl);
+    }
+    const response = await fetch(libraryUrl);
+    const scriptSource = await response.text();
+    return loadLibraryFromString(scriptSource, libraryUrl);
+  }
+  function loadLibraryFromString(scriptSource, id) {
+    if (!isBrowser) {
+      return node.requireFromString && node.requireFromString(scriptSource, id);
+    }
+    if (isWorker) {
+      eval.call(global_, scriptSource);
+      return null;
+    }
+    const script = document.createElement("script");
+    script.id = id;
+    try {
+      script.appendChild(document.createTextNode(scriptSource));
+    } catch (e) {
+      script.text = scriptSource;
+    }
+    document.body.appendChild(script);
+    return null;
+  }
+
+  // src/lib/utils/version.ts
+  var VERSION3 = true ? "3.2.0-alpha.4" : "beta";
+
+  // src/lib/parsers/basis-module-loader.ts
+  var VERSION4 = true ? "3.2.0-alpha.4" : "beta";
+  var BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION4}/dist/libs/basis_encoder.wasm`;
+  var BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION4}/dist/libs/basis_encoder.js`;
+  var loadBasisEncoderPromise;
+  async function loadBasisEncoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basisEncoder) {
+      return modules.basisEncoder;
+    }
+    loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
+    return await loadBasisEncoderPromise;
+  }
+  async function loadBasisEncoder(options) {
+    let BASIS_ENCODER = null;
+    let wasmBinary = null;
+    [BASIS_ENCODER, wasmBinary] = await Promise.all([
+      await loadLibrary(BASIS_CDN_ENCODER_JS, "textures", options),
+      await loadLibrary(BASIS_CDN_ENCODER_WASM, "textures", options)
+    ]);
+    BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
+    return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
+  }
+  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve) => {
+      BasisEncoderModule(options).then((module) => {
+        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
+        initializeBasis();
+        resolve({ BasisFile, KTX2File, BasisEncoder });
+      });
+    });
+  }
+
+  // src/lib/encoders/encode-ktx2-basis-texture.ts
+  async function encodeKTX2BasisTexture(image, options = {}) {
+    const { useSRGB = false, qualityLevel = 10, encodeUASTC = false, mipmaps = false } = options;
+    const { BasisEncoder } = await loadBasisEncoderModule(options);
+    const basisEncoder = new BasisEncoder();
+    try {
+      const basisFileData = new Uint8Array(image.width * image.height * 4);
+      basisEncoder.setCreateKTX2File(true);
+      basisEncoder.setKTX2UASTCSupercompression(true);
+      basisEncoder.setKTX2SRGBTransferFunc(true);
+      basisEncoder.setSliceSourceImage(0, image.data, image.width, image.height, false);
+      basisEncoder.setPerceptual(useSRGB);
+      basisEncoder.setMipSRGB(useSRGB);
+      basisEncoder.setQualityLevel(qualityLevel);
+      basisEncoder.setUASTC(encodeUASTC);
+      basisEncoder.setMipGen(mipmaps);
+      const numOutputBytes = basisEncoder.encode(basisFileData);
+      const actualKTX2FileData = basisFileData.subarray(0, numOutputBytes).buffer;
+      return actualKTX2FileData;
+    } catch (error) {
+      console.error("Basis Universal Supercompressed GPU Texture encoder Error: ", error);
+      throw error;
+    } finally {
+      basisEncoder.delete();
+    }
+  }
+
+  // src/ktx2-basis-writer.ts
+  var KTX2BasisWriter = {
+    name: "Basis Universal Supercompressed GPU Texture",
+    id: "ktx2-basis-writer",
+    module: "textures",
+    version: VERSION3,
+    extensions: ["ktx2"],
+    options: {
+      useSRGB: false,
+      qualityLevel: 10,
+      encodeUASTC: false,
+      mipmaps: false
+    },
+    encode: encodeKTX2BasisTexture
+  };
+
+  // src/workers/ktx2-basis-writer-worker.ts
+  (() => {
+    if (!WorkerBody.inWorkerThread()) {
+      return;
+    }
+    WorkerBody.onmessage = async (type, payload) => {
+      switch (type) {
+        case "process":
+          try {
+            const { input, options } = payload;
+            const result = await KTX2BasisWriter.encode(input, options);
+            WorkerBody.postMessage("done", { result });
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "";
+            WorkerBody.postMessage("error", { error: message });
+          }
+          break;
+        default:
+      }
+    };
+  })();
+})();

package/dist/{ktx2-basis-universal-texture-writer.d.ts → ktx2-basis-writer.d.ts}

@@ -4,7 +4,7 @@ import { encodeKTX2BasisTexture } from './lib/encoders/encode-ktx2-basis-texture
  *  Basis Universal Supercompressed GPU Texture.
  *  Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.8/textureSetDefinitionFormat.cmn.md
  */
-export declare const KTX2BasisUniversalTextureWriter: {
+export declare const KTX2BasisWriter: {
     name: string;
     id: string;
     module: string;
@@ -19,4 +19,4 @@ export declare const KTX2BasisUniversalTextureWriter: {
     encode: typeof encodeKTX2BasisTexture;
 };
 export declare const _TypecheckKTX2TextureWriter: Writer;
-//# sourceMappingURL=ktx2-basis-universal-texture-writer.d.ts.map
+//# sourceMappingURL=ktx2-basis-writer.d.ts.map

package/dist/ktx2-basis-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ktx2-basis-writer.d.ts","sourceRoot":"","sources":["../src/ktx2-basis-writer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAErD,OAAO,EAAC,sBAAsB,EAAC,MAAM,0CAA0C,CAAC;AAEhF;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;CAe3B,CAAC;AAGF,eAAO,MAAM,2BAA2B,EAAE,MAAwB,CAAC"}

package/dist/{ktx2-basis-universal-texture-writer.js → ktx2-basis-writer.js}

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._TypecheckKTX2TextureWriter = exports.KTX2BasisUniversalTextureWriter = void 0;
+exports._TypecheckKTX2TextureWriter = exports.KTX2BasisWriter = void 0;
 const version_1 = require("./lib/utils/version");
 const encode_ktx2_basis_texture_1 = require("./lib/encoders/encode-ktx2-basis-texture");
 /**
  *  Basis Universal Supercompressed GPU Texture.
  *  Spec - https://github.com/Esri/i3s-spec/blob/master/docs/1.8/textureSetDefinitionFormat.cmn.md
  */
-exports.KTX2BasisUniversalTextureWriter = {
+exports.KTX2BasisWriter = {
     name: 'Basis Universal Supercompressed GPU Texture',
-    id: 'ktx2-basis-supercompressed-texture',
+    id: 'ktx2-basis-writer',
     module: 'textures',
     version: version_1.VERSION,
     extensions: ['ktx2'],
@@ -22,4 +22,4 @@ exports.KTX2BasisUniversalTextureWriter = {
     encode: encode_ktx2_basis_texture_1.encodeKTX2BasisTexture
 };
 // TYPE TESTS - TODO find a better way than exporting junk
-exports._TypecheckKTX2TextureWriter = exports.KTX2BasisUniversalTextureWriter;
+exports._TypecheckKTX2TextureWriter = exports.KTX2BasisWriter;

package/dist/lib/encoders/encode-texture.d.ts

@@ -1,4 +1,3 @@
-export declare function encodeImageURLToCompressedTextureURL(inputUrl: string, outputUrl: string, options?: {
-    cwd?: string;
-}): Promise<string>;
+import { CompressedTextureWriterOptions } from '../../compressed-texture-writer';
+export declare function encodeImageURLToCompressedTextureURL(inputUrl: string, outputUrl: string, options?: CompressedTextureWriterOptions): Promise<string>;
 //# sourceMappingURL=encode-texture.d.ts.map

package/dist/lib/encoders/encode-texture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode-texture.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-texture.ts"],"names":[],"mappings":"AAKA,wBAAsB,oCAAoC,CACxD,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAC,GACvB,OAAO,CAAC,MAAM,CAAC,CAkBjB"}
+{"version":3,"file":"encode-texture.d.ts","sourceRoot":"","sources":["../../../src/lib/encoders/encode-texture.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,8BAA8B,EAAC,MAAM,iCAAiC,CAAC;AAK/E,wBAAsB,oCAAoC,CACxD,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,8BAA8B,GACvC,OAAO,CAAC,MAAM,CAAC,CAkBjB"}