utilium 1.2.8 → 1.2.9

package/dist/cache.d.ts

@@ -47,10 +47,19 @@ export declare class Resource<ID> {
     id: ID, 
     /** The full size of the resource */
     size: number, options: Options, resources?: Map<ID, Resource<ID> | undefined>);
+    /**
+     * Ensure the full size of the resource is *at least* `newSize`
+     */
+    grow(newSize: number): void;
     /** Combines adjacent regions and combines adjacent ranges within a region */
     collect(): void;
     /** Takes an initial range and finds the sub-ranges that are not in the cache */
     missing(start: number, end: number): Range[];
+    /**
+     * Get the cached sub-ranges of an initial range.
+     * This is conceptually the inverse of `missing`.
+     */
+    cached(start: number, end: number): Range[];
     /** Get the region who's ranges include an offset */
     regionAt(offset: number): Region | undefined;
     /** Add new data to the cache at given specified offset */

package/dist/cache.js

@@ -23,6 +23,12 @@ export class Resource {
             this.regions.push({ offset: 0, data: new Uint8Array(size), ranges: [] });
         resources?.set(id, this);
     }
+    /**
+     * Ensure the full size of the resource is *at least* `newSize`
+     */
+    grow(newSize) {
+        this.size = Math.max(this.size, newSize);
+    }
     /** Combines adjacent regions and combines adjacent ranges within a region */
     collect() {
         if (!this.options.sparse)
@@ -83,6 +89,39 @@ export class Resource {
             missingRanges.push({ start, end });
         return missingRanges;
     }
+    /**
+     * Get the cached sub-ranges of an initial range.
+     * This is conceptually the inverse of `missing`.
+     */
+    cached(start, end) {
+        const cachedRanges = [];
+        for (const region of this.regions) {
+            if (region.offset >= end)
+                break;
+            for (const range of region.ranges) {
+                if (range.end <= start)
+                    continue;
+                if (range.start >= end)
+                    break;
+                cachedRanges.push({
+                    start: Math.max(start, range.start),
+                    end: Math.min(end, range.end),
+                });
+            }
+        }
+        cachedRanges.sort((a, b) => a.start - b.start);
+        const merged = [];
+        for (const curr of cachedRanges) {
+            const last = merged.at(-1);
+            if (last && curr.start <= last.end) {
+                last.end = Math.max(last.end, curr.end);
+            }
+            else {
+                merged.push(curr);
+            }
+        }
+        return merged;
+    }
     /** Get the region who's ranges include an offset */
     regionAt(offset) {
         if (!this.regions.length)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "utilium",
-	"version": "1.2.8",
+	"version": "1.2.9",
 	"description": "Typescript utilities",
 	"funding": {
 		"type": "individual",

package/src/cache.ts

@@ -59,6 +59,13 @@ export class Resource<ID> {
 		resources?.set(id, this);
 	}
 
+	/**
+	 * Ensure the full size of the resource is *at least* `newSize`
+	 */
+	public grow(newSize: number) {
+		this.size = Math.max(this.size, newSize);
+	}
+
 	/** Combines adjacent regions and combines adjacent ranges within a region */
 	public collect(): void {
 		if (!this.options.sparse) return;
@@ -105,7 +112,6 @@ export class Resource<ID> {
 
 			for (const range of region.ranges) {
 				if (range.end <= start) continue;
-
 				if (range.start >= end) break;
 
 				if (range.start > start) {
@@ -127,6 +133,41 @@ export class Resource<ID> {
 		return missingRanges;
 	}
 
+	/**
+	 * Get the cached sub-ranges of an initial range.
+	 * This is conceptually the inverse of `missing`.
+	 */
+	public cached(start: number, end: number): Range[] {
+		const cachedRanges: Range[] = [];
+
+		for (const region of this.regions) {
+			if (region.offset >= end) break;
+
+			for (const range of region.ranges) {
+				if (range.end <= start) continue;
+				if (range.start >= end) break;
+
+				cachedRanges.push({
+					start: Math.max(start, range.start),
+					end: Math.min(end, range.end),
+				});
+			}
+		}
+
+		cachedRanges.sort((a, b) => a.start - b.start);
+		const merged: Range[] = [];
+		for (const curr of cachedRanges) {
+			const last = merged.at(-1);
+			if (last && curr.start <= last.end) {
+				last.end = Math.max(last.end, curr.end);
+			} else {
+				merged.push(curr);
+			}
+		}
+
+		return merged;
+	}
+
 	/** Get the region who's ranges include an offset */
 	public regionAt(offset: number): Region | undefined {
 		if (!this.regions.length) return;