@peerbit/shared-log 10.0.6 → 10.1.0

package/src/replication-domain-hash.ts

@@ -6,25 +6,10 @@ import { type EntryReplicated } from "./ranges.js";
 import {
 	type Log,
 	type ReplicationDomain,
+	type ReplicationDomainConstructor,
 	type ReplicationDomainMapper,
 } from "./replication-domain.js";
 
-/* const hashToU32 = (hash: Uint8Array) => {
-	const seedNumber = new BinaryReader(
-		hash.subarray(hash.length - 4, hash.length),
-	).u32();
-	return seedNumber;
-};
-
-
-const hashToU64 = (hash: Uint8Array): bigint => {
-	const seedNumber = new BinaryReader(
-		hash.subarray(hash.length - 4, hash.length), //  
-	).u64();
-	return seedNumber;
-};
- */
-
 const hashTransformer = <R extends "u32" | "u64">(
 	resolution: R,
 ): ReplicationDomainMapper<any, R> => {
@@ -54,17 +39,19 @@ export type ReplicationDomainHash<R extends "u32" | "u64"> = ReplicationDomain<
 	R
 >;
 
-export const createReplicationDomainHash = <R extends "u32" | "u64">(
-	resolution: R,
-): ReplicationDomainHash<R> => {
-	return {
-		resolution,
-		type: "hash",
-		fromEntry: hashTransformer<R>(resolution),
-		fromArgs: async (args: undefined, log: Log) => {
-			return {
-				offset: log.node.identity.publicKey,
-			};
-		},
+export const createReplicationDomainHash =
+	<R extends "u32" | "u64">(
+		resolution: R,
+	): ReplicationDomainConstructor<ReplicationDomainHash<R>> =>
+	(log: Log) => {
+		return {
+			resolution,
+			type: "hash",
+			fromEntry: hashTransformer<R>(resolution),
+			fromArgs: async (args: undefined) => {
+				return {
+					offset: log.node.identity.publicKey,
+				};
+			},
+		};
 	};
-};

package/src/replication-domain-time.ts

@@ -1,7 +1,12 @@
 import type { ShallowOrFullEntry } from "@peerbit/log";
-import { type EntryReplicated } from "./ranges.js";
 import {
+	type EntryReplicated,
+	type ReplicationRangeIndexable,
+} from "./ranges.js";
+import {
+	type Log,
 	type ReplicationDomain,
+	type ReplicationDomainConstructor,
 	type ReplicationDomainMapper,
 } from "./replication-domain.js";
 
@@ -41,46 +46,47 @@ export type ReplicationDomainTime = ReplicationDomain<TimeRange, any, "u32"> & {
 	fromDuration: (duration: number) => number;
 };
 
-export const createReplicationDomainTime = (
-	origin: Date,
-	unit: TimeUnit = "milliseconds",
-): ReplicationDomainTime => {
-	const originScaled = +origin * scalarMilliToUnit[unit];
-	const fromMilliToUnit = scalarMilliToUnit[unit];
-	const fromTime = (time: number | Date): number => {
-		return (
-			(typeof time === "number" ? time : +time * fromMilliToUnit) - originScaled
-		);
-	};
+export const createReplicationDomainTime =
+	(properties: {
+		origin?: Date;
+		unit?: TimeUnit;
+		canMerge?: (
+			from: ReplicationRangeIndexable<"u32">,
+			into: ReplicationRangeIndexable<"u32">,
+		) => boolean;
+	}): ReplicationDomainConstructor<ReplicationDomainTime> =>
+	(log: Log) => {
+		const origin = properties.origin || new Date();
+		const unit = properties.unit || "milliseconds";
+		const originScaled = +origin * scalarMilliToUnit[unit];
+		const fromMilliToUnit = scalarMilliToUnit[unit];
+		const fromTime = (time: number | Date): number => {
+			return (
+				(typeof time === "number" ? time : +time * fromMilliToUnit) -
+				originScaled
+			);
+		};
 
-	const fromDuration = (duration: number): number => {
-		return duration;
-	};
-	return {
-		resolution: "u32",
-		type: "time",
-		fromTime,
-		fromDuration,
-		fromEntry: fromEntry(origin, unit),
-		fromArgs: async (args: TimeRange | undefined, log) => {
-			if (!args) {
+		const fromDuration = (duration: number): number => {
+			return duration;
+		};
+		return {
+			resolution: "u32",
+			type: "time",
+			fromTime,
+			fromDuration,
+			fromEntry: fromEntry(origin, unit),
+			fromArgs: async (args: TimeRange | undefined) => {
+				if (!args) {
+					return {
+						offset: log.node.identity.publicKey,
+					};
+				}
 				return {
-					offset: log.node.identity.publicKey,
+					offset: fromTime(args.from),
+					length: fromDuration(args.to - args.from),
 				};
-			}
-			return {
-				offset: fromTime(args.from),
-				length: fromDuration(args.to - args.from),
-			};
-			/* 	roleAge = roleAge ?? (await log.getDefaultMinRoleAge());
-				const ranges = await getCoverSet(
-					log.replicationIndex,
-					roleAge,
-					fromTime(args.from),
-					fromDuration(args.to - args.from),
-					undefined,
-				);
-				return [...ranges]; */
-		},
+			},
+			canMerge: properties.canMerge,
+		};
 	};
-};

package/src/replication-domain.ts

@@ -1,7 +1,6 @@
 import type { PublicSignKey } from "@peerbit/crypto";
 import { type Index } from "@peerbit/indexer-interface";
 import type { Entry, ShallowEntry } from "@peerbit/log";
-import { debounceAccumulator } from "./debounce.js";
 import type { ReplicationRangeIndexable } from "./index.js";
 import type { NumberFromType } from "./integers.js";
 import type { EntryReplicated } from "./ranges.js";
@@ -31,63 +30,6 @@ type CoverRange<T extends number | bigint> = {
 	offset: T | PublicSignKey;
 	length?: T;
 };
-export type ReplicationChanges = ReplicationChange[];
-export type ReplicationChange =
-	| {
-			type: "added";
-			range: ReplicationRangeIndexable<any>;
-	  }
-	| {
-			type: "removed";
-			range: ReplicationRangeIndexable<any>;
-	  }
-	| {
-			type: "updated";
-			range: ReplicationRangeIndexable<any>;
-			prev: ReplicationRangeIndexable<any>;
-	  };
-
-export const mergeReplicationChanges = (
-	changes: ReplicationChanges | ReplicationChanges[],
-): ReplicationChanges => {
-	let first = changes[0];
-	if (!Array.isArray(first)) {
-		return changes as ReplicationChanges;
-	}
-	return (changes as ReplicationChanges[]).flat();
-};
-
-export const debounceAggregationChanges = (
-	fn: (changeOrChanges: ReplicationChange[]) => void,
-	delay: number,
-) => {
-	return debounceAccumulator(
-		(result) => {
-			return fn([...result.values()]);
-		},
-		() => {
-			let aggregated: Map<string, ReplicationChange> = new Map();
-			return {
-				add: (change: ReplicationChange) => {
-					const prev = aggregated.get(change.range.idString);
-					if (prev) {
-						if (prev.range.timestamp < change.range.timestamp) {
-							aggregated.set(change.range.idString, change);
-						}
-					} else {
-						aggregated.set(change.range.idString, change);
-					}
-				},
-				delete: (key: string) => {
-					aggregated.delete(key);
-				},
-				size: () => aggregated.size,
-				value: aggregated,
-			};
-		},
-		delay,
-	);
-};
 
 export type ReplicationDomain<Args, T, R extends "u32" | "u64"> = {
 	resolution: R;
@@ -95,9 +37,15 @@ export type ReplicationDomain<Args, T, R extends "u32" | "u64"> = {
 	fromEntry: ReplicationDomainMapper<T, R>;
 	fromArgs: (
 		args: Args | undefined,
-		log: Log,
 	) => Promise<CoverRange<NumberFromType<R>>> | CoverRange<NumberFromType<R>>;
+	canMerge?: (
+		from: ReplicationRangeIndexable<R>,
+		into: ReplicationRangeIndexable<R>,
+	) => boolean;
 };
 
+export type ReplicationDomainConstructor<
+	D extends ReplicationDomain<any, any, any>,
+> = (log: Log) => D;
 export type ExtractDomainArgs<T> =
 	T extends ReplicationDomain<infer Args, any, any> ? Args : never;