@peerbit/log 6.1.1 → 6.2.0

package/src/runtime.ts

@@ -0,0 +1,16 @@
+export const canUseOptionalNativeModuleImports = (): boolean => {
+	const scope = globalThis as {
+		ServiceWorkerGlobalScope?: unknown;
+		clients?: unknown;
+		registration?: unknown;
+		skipWaiting?: unknown;
+	};
+	const serviceWorkerGlobalScope = scope.ServiceWorkerGlobalScope;
+	return !(
+		(typeof serviceWorkerGlobalScope === "function" &&
+			globalThis instanceof serviceWorkerGlobalScope) ||
+		(!!scope.clients &&
+			!!scope.registration &&
+			typeof scope.skipWaiting === "function")
+	);
+};

package/src/trim.ts

@@ -5,6 +5,16 @@ import type { ShallowEntry } from "./entry-shallow.js";
 import type { Entry } from "./entry.js";
 import type { SortFn } from "./log-sorting.js";
 
+type MaybePromise<T> = T | Promise<T>;
+
+const isPromiseLike = <T>(value: MaybePromise<T>): value is Promise<T> =>
+	!!value && typeof (value as { then?: unknown }).then === "function";
+
+const mapMaybePromise = <T, R>(
+	value: MaybePromise<T>,
+	fn: (value: T) => MaybePromise<R>,
+): MaybePromise<R> => (isPromiseLike(value) ? value.then(fn) : fn(value));
+
 const trimOptionsEqual = (a: TrimOptions, b: TrimOptions) => {
 	if (a.type === b.type) {
 		if (a.type === "length" && b.type === "length") {
@@ -82,7 +92,14 @@ export type TrimOptions = TrimCanAppendOption & TrimCondition;
 interface Log<T> {
 	index: EntryIndex<T>;
 	sortFn: SortFn;
-	deleteNode: (node: ShallowEntry) => Promise<Entry<T> | undefined>;
+	deleteNode: (
+		node: ShallowEntry,
+		options?: { resolveDeletedEntry?: boolean },
+	) => MaybePromise<Entry<T> | ShallowEntry | undefined>;
+	deleteNodes?: (
+		nodes: ShallowEntry[],
+		options?: { resolveDeletedEntry?: boolean; skipNextHeadUpdates?: boolean },
+	) => MaybePromise<(Entry<T> | ShallowEntry)[]>;
 	getLength(): number;
 }
 export class Trim<T> {
@@ -118,14 +135,25 @@ export class Trim<T> {
 		return this._trim;
 	}
 
-	private async trimTask(
+	private trimTask(
 		option: TrimOptions | undefined = this._trim,
-	): Promise<Entry<T>[]> {
+		options?: { resolveDeletedEntries?: boolean },
+	): MaybePromise<(Entry<T> | ShallowEntry)[]> {
 		if (!option) {
 			return [];
 		}
+		if (option.type === "length" && !option.filter?.canTrim) {
+			return this.trimUnfilteredLength(option, options);
+		}
+		return this.trimTaskWithFilter(option, options);
+	}
+
+	private async trimTaskWithFilter(
+		option: TrimOptions,
+		options?: { resolveDeletedEntries?: boolean },
+	): Promise<(Entry<T> | ShallowEntry)[]> {
 		///  TODO Make this method less ugly
-		const deleted: Entry<T>[] = [];
+		const deleted: (Entry<T> | ShallowEntry)[] = [];
 
 		let done: () => Promise<boolean> | boolean;
 		/* 		const valueIterator = this._log.index.query([], this._log.sortFn.sort, false); */
@@ -252,7 +280,9 @@ export class Trim<T> {
 					false,
 				);
 
-				const entry = await this._log.deleteNode(node);
+				const entry = await this._log.deleteNode(node, {
+					resolveDeletedEntry: options?.resolveDeletedEntries,
+				});
 				if (entry) {
 					deleted.push(entry);
 				}
@@ -286,17 +316,113 @@ export class Trim<T> {
 
 		return deleted;
 	}
+
+	private trimUnfilteredLength(
+		option: TrimToLengthOption,
+		options?: { resolveDeletedEntries?: boolean },
+	): MaybePromise<(Entry<T> | ShallowEntry)[]> {
+		const to = option.to;
+		const from = option.from ?? to;
+		if (this._log.getLength() < from) {
+			return [];
+		}
+
+		const deleted: (Entry<T> | ShallowEntry)[] = [];
+		this._canTrimCacheHashBreakpoint.clear();
+		this._canTrimCacheLastNode = undefined;
+		this._trimLastHead = undefined;
+		this._trimLastTail = undefined;
+		this._trimLastSeed = undefined;
+
+		if (this._log.deleteNodes) {
+			const overage = this._log.getLength() - to;
+			const finish = () => {
+				this._trimLastLength = this._log.getLength();
+				this._trimLastOptions = option;
+				return deleted;
+			};
+			const deleteBatch = (
+				limit: number,
+			): MaybePromise<(Entry<T> | ShallowEntry)[] | undefined> => {
+				const nodesResult = this._log.index.getOldestManyMaybe(limit, false);
+				return mapMaybePromise(nodesResult, (nodes) => {
+					if (nodes.length === 0) {
+						return undefined;
+					}
+					return this._log.deleteNodes!(nodes, {
+						resolveDeletedEntry: options?.resolveDeletedEntries,
+						// Oldest-first trim only removes entries whose next links point
+						// further back into the same deleted prefix.
+						skipNextHeadUpdates: true,
+					});
+				});
+			};
+			const pushDeleted = (items: (Entry<T> | ShallowEntry)[] | undefined) => {
+				if (items) {
+					deleted.push(...items);
+				}
+			};
+			const deleteRemaining = async () => {
+				while (this._log.getLength() > to) {
+					const items = await deleteBatch(
+						Math.min(this._log.getLength() - to, 512),
+					);
+					if (!items || items.length === 0) {
+						break;
+					}
+					deleted.push(...items);
+				}
+				return finish();
+			};
+			if (overage > 0) {
+				return mapMaybePromise(deleteBatch(overage), (items) => {
+					pushDeleted(items);
+					return this._log.getLength() > to ? deleteRemaining() : finish();
+				});
+			}
+			return finish();
+		} else {
+			return this.trimUnfilteredLengthOneByOne(option, options, deleted);
+		}
+	}
+
+	private async trimUnfilteredLengthOneByOne(
+		option: TrimToLengthOption,
+		options: { resolveDeletedEntries?: boolean } | undefined,
+		deleted: (Entry<T> | ShallowEntry)[],
+	): Promise<(Entry<T> | ShallowEntry)[]> {
+		const to = option.to;
+		while (this._log.getLength() > to) {
+			const node = await this._log.index.getOldest(false);
+			if (!node) {
+				break;
+			}
+			const entry = await this._log.deleteNode(node, {
+				resolveDeletedEntry: options?.resolveDeletedEntries,
+			});
+			if (entry) {
+				deleted.push(entry);
+			}
+		}
+		this._trimLastLength = this._log.getLength();
+		this._trimLastOptions = option;
+		return deleted;
+	}
+
 	/**
 	 * @param options
 	 * @returns deleted entries
 	 */
 	async trim(
 		options: TrimOptions | undefined = this._trim,
-	): Promise<Entry<T>[] | undefined> {
+		properties?: { resolveDeletedEntries?: boolean },
+	): Promise<(Entry<T> | ShallowEntry)[] | undefined> {
 		if (!options) {
 			return;
 		}
-		const result = await this._queue.add(() => this.trimTask(options));
+		const result = await this._queue.add(() =>
+			this.trimTask(options, properties),
+		);
 		if (result instanceof Object) {
 			return result;
 		}