@cogeotiff/core 8.0.2 → 8.1.1

package/src/read/tiff.tag.factory.ts

@@ -44,6 +44,9 @@ function readTagValue(
     case TiffTagValueType.Float64:
       return bytes.getFloat64(offset, isLittleEndian);
 
+    case TiffTagValueType.Float32:
+      return bytes.getFloat32(offset, isLittleEndian);
+
     case TiffTagValueType.Uint64:
       return getUint64(bytes, offset, isLittleEndian);
     default:
@@ -51,7 +54,7 @@ function readTagValue(
   }
 }
 
-function readValue<T>(tiff: CogTiff, bytes: DataView, offset: number, type: number, count: number): T {
+function readValue<T>(tiff: CogTiff, bytes: DataView, offset: number, type: TiffTagValueType, count: number): T {
   const typeSize = getTiffTagSize(type);
   const dataLength = count * typeSize;
 
@@ -61,9 +64,7 @@ function readValue<T>(tiff: CogTiff, bytes: DataView, offset: number, type: numb
     case TiffTagValueType.Ascii:
       return String.fromCharCode.apply(
         null,
-        new Uint8Array(
-          bytes.buffer.slice(bytes.byteOffset + offset, bytes.byteOffset + offset + dataLength - 1),
-        ) as unknown as number[],
+        new Uint8Array(bytes.buffer, offset, dataLength - 1) as unknown as number[],
       ) as unknown as T;
   }
 
@@ -78,7 +79,7 @@ function readValue<T>(tiff: CogTiff, bytes: DataView, offset: number, type: numb
 /**
  * Determine if all the data for the tiff tag is loaded in and use that to create the specific CogTiffTag
  *
- * @see {Tag}
+ * @see {@link Tag}
  *
  * @param tiff
  * @param view Bytes to read from
@@ -110,6 +111,7 @@ export function createTag(tiff: CogTiff, view: DataViewOffset, offset: number):
         count: dataCount,
         dataType,
         dataOffset,
+        isLoaded: false,
         value: [],
         tagOffset: offset,
       };
@@ -127,6 +129,7 @@ export function createTag(tiff: CogTiff, view: DataViewOffset, offset: number):
   return { type: 'lazy', id: tagId, count: dataCount, dataOffset, dataType, tagOffset: offset };
 }
 
+/** Fetch the value from a {@link TagLazy} tag */
 export async function fetchLazy<T>(tag: TagLazy<T>, tiff: CogTiff): Promise<T> {
   if (tag.value != null) return tag.value;
   const dataTypeSize = getTiffTagSize(tag.dataType);
@@ -137,6 +140,23 @@ export async function fetchLazy<T>(tag: TagLazy<T>, tiff: CogTiff): Promise<T> {
   return tag.value as T;
 }
 
+/**
+ * Fetch all the values from a {@link TagOffset}
+ */
+export async function fetchAllOffsets(tiff: CogTiff, tag: TagOffset): Promise<number[]> {
+  const dataTypeSize = getTiffTagSize(tag.dataType);
+
+  if (tag.view == null) {
+    const bytes = await tiff.source.fetch(tag.dataOffset, dataTypeSize * tag.count);
+    tag.view = new DataView(bytes) as DataViewOffset;
+    tag.view.sourceOffset = tag.dataOffset;
+  }
+
+  tag.value = readValue(tiff, tag.view, 0, tag.dataType, tag.count) as number[];
+  tag.isLoaded = true;
+  return tag.value;
+}
+
 export function setBytes(tag: TagOffset, view: DataViewOffset): void {
   const dataTypeSize = getTiffTagSize(tag.dataType);
   const startBytes = view.byteOffset + tag.dataOffset - view.sourceOffset;
@@ -144,6 +164,7 @@ export function setBytes(tag: TagOffset, view: DataViewOffset): void {
   tag.view.sourceOffset = tag.dataOffset;
 }
 
+/** Partially fetch the values of a {@link TagOffset} and return the value for the offset */
 export async function getValueAt(tiff: CogTiff, tag: TagOffset, index: number): Promise<number> {
   if (index > tag.count || index < 0) throw new Error('TagOffset: out of bounds :' + index);
   if (tag.value[index] != null) return tag.value[index];

package/src/read/tiff.tag.ts

@@ -34,11 +34,11 @@ export interface TagInline<T> extends TagBase {
 /** Tiff tag that is a list of offsets this can be partially read */
 export interface TagOffset extends TagBase {
   type: 'offset';
-  /** Values of the offest's this is a sparse array unless @see {isLoaded} is true */
+  /** Values of the offsets this is a sparse array unless @see {TagOffset.isLoaded} is true */
   value: number[];
   /** has all the values been read */
-  isLoaded?: boolean;
-  /** Raw buffer of the values for lazy decoding, Reading 1000s of uint64s can take quite a while */
+  isLoaded: boolean;
+  /** Raw buffer of the values for lazy decoding, as reading 100,000s of uint64s can take quite a long time */
   view?: DataViewOffset;
   /** Where in the file the value is read from */
   dataOffset: number;

package/src/source.ts

@@ -1,5 +1,20 @@
+/**
+ * This is a partial re-implementation of @chunkd/source
+ * this is defined here so that @cogeotiff/core does not have any external dependencies
+ */
 export interface Source {
+  /** Where the source is located */
   url: URL;
+
+  /** Optional metadata about the source including the size in bytes of the file */
+  metadata?: {
+    /** Number of bytes in the file if known */
+    size?: number;
+  };
+
   /** Fetch bytes from a source */
   fetch(offset: number, length?: number): Promise<ArrayBuffer>;
+
+  /** Optionally close the source, useful for sources that have open connections of file descriptors */
+  close?(): Promise<void>;
 }