utilium 1.2.8 → 1.2.10

package/dist/cache.d.ts

@@ -37,20 +37,25 @@ export interface Region {
 export declare class Resource<ID> {
     /** The resource ID */
     readonly id: ID;
-    /** The full size of the resource */
-    size: number;
+    protected _size: number;
     protected readonly options: Options;
     /** Regions used to reduce unneeded allocations. Think of sparse arrays. */
     readonly regions: Region[];
+    /** The full size of the resource */
+    get size(): number;
+    set size(value: number);
     constructor(
     /** The resource ID */
-    id: ID, 
-    /** The full size of the resource */
-    size: number, options: Options, resources?: Map<ID, Resource<ID> | undefined>);
+    id: ID, _size: number, options: Options, resources?: Map<ID, Resource<ID> | undefined>);
     /** 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

@@ -6,21 +6,49 @@ import { extendBuffer } from './buffer.js';
  */
 export class Resource {
     id;
-    size;
+    _size;
     options;
     /** Regions used to reduce unneeded allocations. Think of sparse arrays. */
     regions = [];
+    /** The full size of the resource */
+    get size() {
+        return this._size;
+    }
+    set size(value) {
+        if (value >= this._size) {
+            this._size = value;
+            return;
+        }
+        this._size = value;
+        for (let i = this.regions.length - 1; i >= 0; i--) {
+            const region = this.regions[i];
+            if (region.offset >= value) {
+                this.regions.splice(i, 1);
+                continue;
+            }
+            const maxLength = value - region.offset;
+            if (region.data.byteLength > maxLength) {
+                region.data = region.data.subarray(0, maxLength);
+            }
+            region.ranges = region.ranges
+                .filter(range => range.start < value)
+                .map(range => {
+                if (range.end > value) {
+                    return { start: range.start, end: value };
+                }
+                return range;
+            });
+        }
+    }
     constructor(
     /** The resource ID */
-    id, 
-    /** The full size of the resource */
-    size, options, resources) {
+    id, _size, options, resources) {
         this.id = id;
-        this.size = size;
+        this._size = _size;
         this.options = options;
         options.sparse ??= true;
         if (!options.sparse)
-            this.regions.push({ offset: 0, data: new Uint8Array(size), ranges: [] });
+            this.regions.push({ offset: 0, data: new Uint8Array(_size), ranges: [] });
         resources?.set(id, this);
     }
     /** Combines adjacent regions and combines adjacent ranges within a region */
@@ -83,6 +111,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)
@@ -104,6 +165,7 @@ export class Resource {
             region.data.set(data, offset);
             region.ranges.push({ start: offset, end });
             region.ranges.sort((a, b) => a.start - b.start);
+            this.collect();
             return this;
         }
         // Find the correct index to insert the new region
@@ -116,6 +178,7 @@ export class Resource {
         else {
             this.regions.splice(insertIndex, 0, newRegion); // Insert before the first region with a greater offset
         }
+        this.collect();
         return this;
     }
 }

package/dist/requests.js

@@ -116,7 +116,7 @@ export async function set(url, data, options, init = {}) {
     const { offset = 0 } = options;
     if (!options.cacheOnly)
         await _fetch(new Request(url, init), { method: 'POST' }, true);
-    resource.add(data, offset).collect();
+    resource.add(data, offset);
 }
 /**
  * Make a DELETE request to remove the resource from the server and clear it from the cache.

package/package.json

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

package/src/cache.ts

@@ -45,16 +45,52 @@ export class Resource<ID> {
 	/** Regions used to reduce unneeded allocations. Think of sparse arrays. */
 	public readonly regions: Region[] = [];
 
+	/** The full size of the resource */
+	public get size() {
+		return this._size;
+	}
+
+	public set size(value: number) {
+		if (value >= this._size) {
+			this._size = value;
+			return;
+		}
+
+		this._size = value;
+
+		for (let i = this.regions.length - 1; i >= 0; i--) {
+			const region = this.regions[i];
+
+			if (region.offset >= value) {
+				this.regions.splice(i, 1);
+				continue;
+			}
+
+			const maxLength = value - region.offset;
+			if (region.data.byteLength > maxLength) {
+				region.data = region.data.subarray(0, maxLength);
+			}
+
+			region.ranges = region.ranges
+				.filter(range => range.start < value)
+				.map(range => {
+					if (range.end > value) {
+						return { start: range.start, end: value };
+					}
+					return range;
+				});
+		}
+	}
+
 	public constructor(
 		/** The resource ID */
 		public readonly id: ID,
-		/** The full size of the resource */
-		public size: number,
+		protected _size: number,
 		protected readonly options: Options,
 		resources?: Map<ID, Resource<ID> | undefined>
 	) {
 		options.sparse ??= true;
-		if (!options.sparse) this.regions.push({ offset: 0, data: new Uint8Array(size), ranges: [] });
+		if (!options.sparse) this.regions.push({ offset: 0, data: new Uint8Array(_size), ranges: [] });
 
 		resources?.set(id, this);
 	}
@@ -105,7 +141,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 +162,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;
@@ -150,6 +220,7 @@ export class Resource<ID> {
 			region.ranges.push({ start: offset, end });
 			region.ranges.sort((a, b) => a.start - b.start);
 
+			this.collect();
 			return this;
 		}
 
@@ -164,6 +235,7 @@ export class Resource<ID> {
 			this.regions.splice(insertIndex, 0, newRegion); // Insert before the first region with a greater offset
 		}
 
+		this.collect();
 		return this;
 	}
 }

package/src/requests.ts

@@ -201,7 +201,7 @@ export async function set(url: string, data: Uint8Array, options: SetOptions, in
 
 	if (!options.cacheOnly) await _fetch(new Request(url, init), { method: 'POST' }, true);
 
-	resource.add(data, offset).collect();
+	resource.add(data, offset);
 }
 
 /**