utilium 1.2.0 → 1.2.1

package/dist/requests.d.ts

@@ -13,6 +13,10 @@ export interface ResourceCacheOptions {
      */
     regionGapThreshold?: number;
 }
+type CacheRange = {
+    start: number;
+    end: number;
+};
 export type RequestError = {
     tag: 'status';
     response: Response;
@@ -43,3 +47,12 @@ export interface RequestOptions extends ResourceCacheOptions {
  * @throws RequestError
  */
 export declare function GET(url: string, options: RequestOptions, init?: RequestInit): Promise<Uint8Array>;
+/**
+ * Synchronously gets a cached resource
+ * Assumes you pass valid start and end when using ranges
+ */
+export declare function getCached(url: string, options: RequestOptions): {
+    data: Uint8Array;
+    missing: CacheRange[];
+};
+export {};

package/dist/requests.js

@@ -170,3 +170,35 @@ export async function GET(url, options, init = {}) {
     const region = cache.regionAt(start);
     return region.data.subarray(start - region.offset, end - region.offset);
 }
+/**
+ * Synchronously gets a cached resource
+ * Assumes you pass valid start and end when using ranges
+ */
+export function getCached(url, options) {
+    const cache = requestsCache.get(url);
+    /**
+     * @todo Make sure we have a size?
+     */
+    if (!cache)
+        return { data: new Uint8Array(0), missing: [{ start: 0, end: options.size ?? 0 }] };
+    const { start = 0, end = cache.size } = options;
+    const data = new Uint8Array(end - start);
+    for (const region of cache.regions) {
+        if (region.offset + region.data.byteLength <= start)
+            continue;
+        if (region.offset >= end)
+            break;
+        for (const range of region.ranges) {
+            if (range.end <= start)
+                continue;
+            if (range.start >= end)
+                break;
+            const overlapStart = Math.max(range.start, start);
+            const overlapEnd = Math.min(range.end, end);
+            if (overlapStart >= overlapEnd)
+                continue;
+            data.set(region.data.subarray(overlapStart - region.offset, overlapEnd - region.offset), overlapStart - start);
+        }
+    }
+    return { data, missing: cache.missing(start, end) };
+}

package/package.json

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

package/src/requests.ts

@@ -37,7 +37,7 @@ interface CacheRegion {
 /** The cache for a specific resource */
 class ResourceCache {
 	/** Regions used to reduce unneeded allocations. Think of sparse arrays. */
-	protected readonly regions: CacheRegion[] = [];
+	public readonly regions: CacheRegion[] = [];
 
 	public constructor(
 		/** The resource URL */
@@ -249,3 +249,39 @@ export async function GET(url: string, options: RequestOptions, init: RequestIni
 	const region = cache.regionAt(start)!;
 	return region.data.subarray(start - region.offset, end - region.offset);
 }
+
+/**
+ * Synchronously gets a cached resource
+ * Assumes you pass valid start and end when using ranges
+ */
+export function getCached(url: string, options: RequestOptions): { data: Uint8Array; missing: CacheRange[] } {
+	const cache = requestsCache.get(url);
+
+	/**
+	 * @todo Make sure we have a size?
+	 */
+	if (!cache) return { data: new Uint8Array(0), missing: [{ start: 0, end: options.size ?? 0 }] };
+
+	const { start = 0, end = cache.size } = options;
+
+	const data = new Uint8Array(end - start);
+
+	for (const region of cache.regions) {
+		if (region.offset + region.data.byteLength <= start) continue;
+		if (region.offset >= end) break;
+
+		for (const range of region.ranges) {
+			if (range.end <= start) continue;
+			if (range.start >= end) break;
+
+			const overlapStart = Math.max(range.start, start);
+			const overlapEnd = Math.min(range.end, end);
+
+			if (overlapStart >= overlapEnd) continue;
+
+			data.set(region.data.subarray(overlapStart - region.offset, overlapEnd - region.offset), overlapStart - start);
+		}
+	}
+
+	return { data, missing: cache.missing(start, end) };
+}