@loaders.gl/tile-converter 4.5.3 → 5.0.0-alpha.10

package/src/{lib → v4/lib}/utils/conversion-dump.ts

@@ -141,7 +141,7 @@ export class ConversionDump {
           return;
         }
       } catch (error) {
-        // prettier-ignore
+        // biome-ignore format: preserve intentional fixture layout
         console.log('Can\'t open dump file', error); // eslint-disable-line no-console
       }
     }
@@ -196,7 +196,7 @@ export class ConversionDump {
           )
         );
       } catch (error) {
-        // prettier-ignore
+        // biome-ignore format: preserve intentional fixture layout
         console.log('Can\'t update dump file', error); // eslint-disable-line no-console
       }
     }
@@ -289,7 +289,7 @@ export class ConversionDump {
     value: boolean
   ) {
     const nodeDump = this.tilesConverted[filename]?.nodes.find(
-      (element) => element.nodeId === nodeId
+      element => element.nodeId === nodeId
     );
     if (nodeDump) {
       if (!nodeDump.progress) {
@@ -361,7 +361,7 @@ export class ConversionDump {
     done: boolean
   ): Promise<void> {
     const nodeDump = this.tilesConverted[filename]?.nodes.find(
-      (element) => element.nodeId === nodeId
+      element => element.nodeId === nodeId
     );
     if (nodeDump) {
       nodeDump.done = done;

package/src/{lib → v4/lib}/utils/file-utils.ts

@@ -81,7 +81,7 @@ export async function openJson(path: string, fileName: string): Promise<{[key: s
     const intervalId = setInterval(() => {
       const pathFile = join(path, fileName);
       load(pathFile, JSONLoader)
-        .then((result) => {
+        .then(result => {
           clearInterval(intervalId);
           resolve(result);
         })
@@ -147,7 +147,7 @@ export async function renameFile(oldPath: string, newPath: string): Promise<void
   try {
     await fs.rename(oldPath, newPath);
   } catch (err) {
-    // prettier-ignore
+    // biome-ignore format: preserve intentional fixture layout
     console.log('Can\'t rename file', err); // eslint-disable-line no-console
   }
 }

package/src/{lib → v4/lib}/utils/lod-conversion-utils.ts

@@ -65,13 +65,11 @@ export function convertGeometricErrorToScreenThreshold(
  * @returns lod metric in 3d-tiles format
  */
 export function convertScreenThresholdToGeometricError(node: I3STileHeader): number {
-  const metricData = node.lodSelection?.find(
-    (metric) => metric.metricType === 'maxScreenThreshold'
-  );
+  const metricData = node.lodSelection?.find(metric => metric.metricType === 'maxScreenThreshold');
   let maxError = metricData?.maxError;
   if (!maxError) {
     const sqMetricData = node.lodSelection?.find(
-      (metric) => metric.metricType === 'maxScreenThresholdSQ'
+      metric => metric.metricType === 'maxScreenThresholdSQ'
     );
     if (sqMetricData) {
       maxError = Math.sqrt(sqMetricData.maxError / (Math.PI * 0.25));

package/src/v5/adapters.ts

@@ -0,0 +1,56 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// Format-specific codecs, feature mapping and archive packaging remain in the application.
+export {convertFeatureAttributesToArrowBatches} from './feature-arrow.js';
+export type {FeatureArrowBatchOptions, TileFeatureAttributes} from './feature-arrow.js';
+export {encodePointCloudTile} from './point-cloud.js';
+export type {EncodePointCloudTileOptions} from './point-cloud.js';
+export {encodePointCloudSource, encodePointCloudSourceTile} from './point-cloud-source-encoder.js';
+export type {
+  EncodedPointCloudSourceTile,
+  EncodePointCloudSourceOptions
+} from './point-cloud-source-encoder.js';
+export {convertPointCloudSource} from './point-cloud-conversion.js';
+export type {ConvertPointCloudSourceOptions} from './point-cloud-conversion.js';
+export {encodeMeshTile} from './mesh.js';
+export type {
+  MeshTileMaterial,
+  MeshTileOptions,
+  MeshTileTexture,
+  MeshTileSampler,
+  MeshTileTextureTransform
+} from './mesh.js';
+export {createMeshConversionCodec} from './mesh-conversion.js';
+export type {
+  MeshConversionInput,
+  EncodedMeshConversionResource,
+  MeshConversionCodecOptions
+} from './mesh-conversion.js';
+export {createSingleMeshTilesetSink, createMeshTilesetSink} from './mesh-tileset-sink.js';
+export type {
+  SingleMeshTilesetSink,
+  SingleMeshTilesetSinkOptions,
+  MeshTilesetSink,
+  MeshTilesetSinkOptions
+} from './mesh-tileset-sink.js';
+export {
+  createTileConversionArchive,
+  encodeTileConversionArchiveInBatches
+} from './conversion-archive.js';
+export type {TileConversionArchiveOptions} from './conversion-archive.js';
+export {createSingleMeshTilesetArchive} from './mesh-tileset-archive.js';
+export type {SingleMeshTilesetArchiveOptions} from './mesh-tileset-archive.js';
+export {createMeshTilesetConversionSource} from './mesh-source.js';
+export type {
+  MeshSourceResource,
+  MeshTilesetSourceOptions,
+  MeshSourceFeatureOptions
+} from './mesh-source.js';
+export {createI3SMeshConversionCodec, createSingleMeshI3SSink} from './i3s-mesh-conversion.js';
+export type {
+  I3SMeshConversionResource,
+  I3SMeshConversionCodecOptions,
+  SingleMeshI3SSink
+} from './i3s-mesh-conversion.js';

package/src/v5/browser-sink.ts

@@ -0,0 +1,130 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {TileConversionError} from './conversion-api.js';
+import type {TileConversionReport, TileConversionSink} from './conversion-api.js';
+
+const BLOB_SIZE_GETTER = Object.getOwnPropertyDescriptor(Blob.prototype, 'size')?.get;
+
+/** One named browser output resource. */
+export interface BrowserTileConversionResource {
+  /** Stable relative output path supplied by the target profile. */
+  readonly resourceId: string;
+  /** Parts combined into a Blob after the total output budget is checked. */
+  readonly parts: readonly BlobPart[];
+  /** MIME type recorded on the resulting Blob. */
+  readonly contentType?: string;
+}
+
+/** A named output resource retained by the bounded browser sink. */
+export interface BrowserTileConversionFile {
+  /** Stable relative output path supplied by the target profile. */
+  readonly resourceId: string;
+  /** Browser-native data for download or application-provided packaging. */
+  readonly blob: Blob;
+}
+
+/** Memory limit for a browser conversion sink. */
+export interface BoundedMemoryTileConversionSinkOptions {
+  /** Maximum combined Blob size retained by this sink, captured at creation, in bytes. */
+  readonly maxTotalBytes: number;
+}
+
+/** Browser sink with read access to its bounded output resources. */
+export interface BoundedMemoryTileConversionSink
+  extends TileConversionSink<BrowserTileConversionResource> {
+  /** Returns the retained files in stable resource-ID order. */
+  getFiles(): readonly BrowserTileConversionFile[];
+}
+
+/**
+ * Creates a browser-only sink that retains output as Blobs under a total byte limit.
+ *
+ * The sink does not download or archive files. Applications can use `getFiles()` after
+ * `convertTileset` completes and package or download the returned Blobs as needed.
+ *
+ * @param options - Maximum in-memory output size.
+ * @returns A sink that stores browser-native Blobs and clears them on abort.
+ */
+export function createBoundedMemoryTileConversionSink(
+  options: BoundedMemoryTileConversionSinkOptions
+): BoundedMemoryTileConversionSink {
+  const {maxTotalBytes} = options;
+  if (!Number.isSafeInteger(maxTotalBytes) || maxTotalBytes < 0) {
+    throw new TileConversionError(
+      'INVALID_OUTPUT_MEMORY_LIMIT',
+      'The browser output memory limit must be a non-negative safe integer'
+    );
+  }
+
+  const files = new Map<string, BrowserTileConversionFile>();
+  let totalBytes = 0;
+  let closed = false;
+
+  return {
+    getFiles() {
+      return [...files.values()].sort((left, right) =>
+        left.resourceId < right.resourceId ? -1 : left.resourceId > right.resourceId ? 1 : 0
+      );
+    },
+    async write(resource, signal) {
+      if (signal?.aborted) {
+        throw signal.reason ?? new DOMException('The operation was aborted', 'AbortError');
+      }
+      if (closed) {
+        throw new TileConversionError(
+          'RESOURCE_SINK_CLOSED',
+          'Cannot write after sink finalization'
+        );
+      }
+      if (!resource.resourceId || files.has(resource.resourceId)) {
+        throw new TileConversionError(
+          'INVALID_BROWSER_RESOURCE_ID',
+          'Browser output resource IDs must be non-empty and unique'
+        );
+      }
+
+      const byteLength = resource.parts.reduce((total, part) => total + measureBlobPart(part), 0);
+      if (!Number.isSafeInteger(byteLength) || totalBytes + byteLength > maxTotalBytes) {
+        throw new TileConversionError(
+          'OUTPUT_MEMORY_LIMIT_EXCEEDED',
+          `Browser output exceeds the configured ${maxTotalBytes} byte memory limit`
+        );
+      }
+
+      const blob = new Blob([...resource.parts], {type: resource.contentType});
+      files.set(resource.resourceId, {resourceId: resource.resourceId, blob});
+      totalBytes += blob.size;
+    },
+    async finalize(_report: TileConversionReport) {
+      if (closed) {
+        throw new TileConversionError('RESOURCE_SINK_CLOSED', 'Sink has already been finalized');
+      }
+      closed = true;
+    },
+    async abort() {
+      files.clear();
+      totalBytes = 0;
+      closed = true;
+    }
+  };
+}
+
+/** Measures supported Blob parts without copying them into a Blob first. */
+function measureBlobPart(part: BlobPart): number {
+  if (typeof part === 'string') {
+    return new TextEncoder().encode(part).byteLength;
+  }
+  if (BLOB_SIZE_GETTER) {
+    try {
+      return BLOB_SIZE_GETTER.call(part) as number;
+    } catch {
+      // Keep checking the remaining supported Blob part types.
+    }
+  }
+  if (part instanceof ArrayBuffer || ArrayBuffer.isView(part)) {
+    return part.byteLength;
+  }
+  throw new TileConversionError('UNSUPPORTED_BROWSER_RESOURCE', 'Unsupported browser Blob part');
+}

package/src/v5/browser-source.ts

@@ -0,0 +1,155 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {TileConversionError} from './conversion-api.js';
+import type {TileConversionSource} from './conversion-api.js';
+
+/** Metadata available before a browser resource is read. */
+export interface BrowserTileConversionInspection {
+  /** Stable resource path assigned to the input tile. */
+  readonly resourceId: string;
+  /** Optional MIME type supplied by the caller or source Blob. */
+  readonly contentType?: string;
+}
+
+/** Raw bytes read from one browser tile resource. */
+export interface BrowserTileConversionInputResource {
+  /** Stable resource path assigned to the input tile. */
+  readonly resourceId: string;
+  /** Complete resource bytes for a profile-specific codec. */
+  readonly data: Uint8Array;
+  /** Optional MIME type supplied by the caller, Blob, or URL response. */
+  readonly contentType?: string;
+}
+
+/** Browser input and size limit for a single-resource conversion. */
+export interface BrowserTileConversionSourceOptions {
+  /** Input URL or already available browser Blob. */
+  readonly input: string | Blob;
+  /** Stable path to associate with the input resource. */
+  readonly resourceId: string;
+  /** Maximum number of input bytes held in memory. */
+  readonly maxInputBytes: number;
+  /** Optional MIME type override. */
+  readonly contentType?: string;
+}
+
+/**
+ * Creates a browser source for one mesh resource provided as a URL or Blob.
+ *
+ * URL responses are read incrementally and canceled if they exceed `maxInputBytes`.
+ * Tileset JSON traversal and format decoding remain profile-specific source and codec work.
+ *
+ * @param options - Input, stable resource ID, and maximum input size.
+ * @returns A source that yields one complete resource to a v5 codec.
+ */
+export function createBrowserTileConversionSource(
+  options: BrowserTileConversionSourceOptions
+): TileConversionSource<BrowserTileConversionInspection, BrowserTileConversionInputResource> {
+  if (
+    !options.resourceId ||
+    !Number.isSafeInteger(options.maxInputBytes) ||
+    options.maxInputBytes < 0
+  ) {
+    throw new TileConversionError(
+      'INVALID_BROWSER_SOURCE_OPTIONS',
+      'Browser sources require a resource ID and a non-negative safe input byte limit'
+    );
+  }
+
+  return {
+    async inspect(signal) {
+      throwIfAborted(signal);
+      const contentType = options.contentType ?? getBlobContentType(options.input);
+      return {
+        resourceId: options.resourceId,
+        ...(contentType ? {contentType} : {})
+      };
+    },
+    async *read(inspection, signal) {
+      throwIfAborted(signal);
+      const input = options.input;
+      let data: Uint8Array;
+      let contentType = inspection.contentType;
+
+      if (typeof input === 'string') {
+        const response = await fetch(input, {signal});
+        if (!response.ok) {
+          throw new TileConversionError(
+            'BROWSER_SOURCE_FETCH_FAILED',
+            `Could not fetch browser input (${response.status} ${response.statusText})`
+          );
+        }
+        contentType = contentType ?? response.headers.get('content-type') ?? undefined;
+        data = await readResponseBytes(response, options.maxInputBytes, signal);
+      } else {
+        if (input.size > options.maxInputBytes) {
+          throw createInputLimitError(options.maxInputBytes);
+        }
+        data = new Uint8Array(await input.arrayBuffer());
+      }
+
+      throwIfAborted(signal);
+      yield {
+        resourceId: inspection.resourceId,
+        data,
+        ...(contentType ? {contentType} : {})
+      };
+    }
+  };
+}
+
+/** Reads a response stream while enforcing the input byte limit. */
+async function readResponseBytes(
+  response: Response,
+  maxInputBytes: number,
+  signal?: AbortSignal
+): Promise<Uint8Array> {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new TileConversionError(
+      'BROWSER_SOURCE_STREAM_UNAVAILABLE',
+      'Browser URL inputs must provide a readable response stream'
+    );
+  }
+
+  const data = new Uint8Array(maxInputBytes);
+  let totalBytes = 0;
+  try {
+    while (true) {
+      throwIfAborted(signal);
+      const {done, value} = await reader.read();
+      if (done) break;
+      if (value.byteLength > maxInputBytes - totalBytes) {
+        await reader.cancel();
+        throw createInputLimitError(maxInputBytes);
+      }
+      data.set(value, totalBytes);
+      totalBytes += value.byteLength;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return data.subarray(0, totalBytes);
+}
+
+/** Returns a Blob's MIME type without requiring a same-realm Blob constructor. */
+function getBlobContentType(input: string | Blob): string | undefined {
+  return typeof input === 'string' ? undefined : input.type || undefined;
+}
+
+/** Creates the typed error used when browser input exceeds its configured limit. */
+function createInputLimitError(maxInputBytes: number): TileConversionError {
+  return new TileConversionError(
+    'INPUT_RESOURCE_TOO_LARGE',
+    `Browser input exceeds the configured ${maxInputBytes} byte memory limit`
+  );
+}
+
+/** Throws the signal reason when a browser source operation has been canceled. */
+function throwIfAborted(signal?: AbortSignal): void {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException('The operation was aborted', 'AbortError');
+  }
+}