@ls-stack/utils 3.63.0 → 3.66.0

package/dist/diffParser.mjs

@@ -0,0 +1,410 @@
+//#region src/diffParser.ts
+function diffParser(input) {
+	if (!input) return [];
+	if (typeof input !== "string" || input.match(/^\s+$/)) return [];
+	const lines = input.split("\n");
+	if (lines.length === 0) return [];
+	const files = [];
+	let currentFile = null;
+	let currentChunk = null;
+	let deletedLineCounter = 0;
+	let addedLineCounter = 0;
+	let currentFileChanges = null;
+	let fromLineCount = 0;
+	let pendingFroms;
+	const normal = (line) => {
+		currentChunk?.changes.push({
+			type: "normal",
+			normal: true,
+			ln1: deletedLineCounter++,
+			ln2: addedLineCounter++,
+			content: line
+		});
+		if (currentFileChanges) {
+			currentFileChanges.oldLines--;
+			currentFileChanges.newLines--;
+		}
+	};
+	const start = (line) => {
+		const [fromFileName, toFileName] = parseFiles(line) ?? [];
+		currentFile = {
+			type: "modified",
+			chunks: [],
+			deletions: 0,
+			additions: 0,
+			from: fromFileName,
+			to: toFileName,
+			oldMode: void 0,
+			newMode: void 0,
+			index: void 0,
+			diff: void 0
+		};
+		fromLineCount = 0;
+		pendingFroms = void 0;
+		files.push(currentFile);
+	};
+	const restart = () => {
+		if (!currentFile || currentFile.chunks.length) start();
+	};
+	const newFile = (_, match) => {
+		restart();
+		if (currentFile) {
+			currentFile.type = "new";
+			currentFile.newMode = match[1];
+			currentFile.from = "/dev/null";
+		}
+	};
+	const deletedFile = (_, match) => {
+		restart();
+		if (currentFile) {
+			currentFile.type = "deleted";
+			currentFile.oldMode = match[1];
+			currentFile.to = "/dev/null";
+		}
+	};
+	const oldMode = (_, match) => {
+		restart();
+		if (currentFile) currentFile.oldMode = match[1];
+	};
+	const newMode = (_, match) => {
+		restart();
+		if (currentFile) currentFile.newMode = match[1];
+	};
+	const index = (line, match) => {
+		restart();
+		if (currentFile) {
+			currentFile.index = line.split(" ").slice(1);
+			if (match[1]) currentFile.oldMode = currentFile.newMode = match[1].trim();
+		}
+	};
+	const similarityIndex = (_, match) => {
+		restart();
+		if (currentFile) {
+			const renamedFile = ensureRenamedFile(currentFile);
+			renamedFile.similarityIndex = Number(match[1]);
+		}
+	};
+	const renameFrom = (line) => {
+		restart();
+		if (currentFile) {
+			const renamedFile = ensureRenamedFile(currentFile);
+			renamedFile.from = parseOldOrNewFile(line, "rename from ");
+		}
+	};
+	const renameTo = (line) => {
+		restart();
+		if (currentFile) {
+			const renamedFile = ensureRenamedFile(currentFile);
+			renamedFile.to = parseOldOrNewFile(line, "rename to ");
+		}
+	};
+	const binaryFiles = () => {
+		restart();
+		if (currentFile) currentFile.type = "binary";
+	};
+	const fromFile = (line) => {
+		restart();
+		if (currentFile) {
+			const fileName = parseOldOrNewFile(line);
+			if (fromLineCount === 0) {
+				currentFile.from = fileName;
+				fromLineCount = 1;
+				return;
+			}
+			const froms = pendingFroms ?? (currentFile.from ? [currentFile.from] : []);
+			if (!froms.includes(fileName)) froms.push(fileName);
+			pendingFroms = froms;
+			fromLineCount++;
+		}
+	};
+	const toFile = (line) => {
+		restart();
+		if (currentFile) currentFile.to = parseOldOrNewFile(line);
+	};
+	const toNumOfLines = (number) => Number(number || 1);
+	const parseRange = (range, prefix) => {
+		if (!range.startsWith(prefix)) return null;
+		const [rangeStart, rangeLines] = range.slice(1).split(",");
+		const startNumber = Number(rangeStart);
+		if (!Number.isFinite(startNumber)) return null;
+		return {
+			start: startNumber,
+			lines: toNumOfLines(rangeLines)
+		};
+	};
+	const parseCombinedChunkHeader = (line) => {
+		const atCount = line.match(/^(@{3,})\s/)?.[1]?.length;
+		if (!atCount) return;
+		if (!line.match(/* @__PURE__ */ new RegExp(`\\s@{${atCount}}$`))) return;
+		const parts = line.slice(atCount, line.length - atCount).trim().split(/\s+/);
+		if (parts.length < 2) return;
+		const newPart = parts.at(-1);
+		if (!newPart?.startsWith("+")) return;
+		const parentParts = parts.slice(0, -1);
+		const parentRanges = [];
+		for (const part of parentParts) {
+			const range = parseRange(part, "-");
+			if (!range) return;
+			parentRanges.push(range);
+		}
+		const newRange = parseRange(newPart, "+");
+		if (!newRange) return;
+		return {
+			parentRanges,
+			newRange,
+			parentCount: parentRanges.length
+		};
+	};
+	const combinedChunk = (line) => {
+		if (!currentFile) start(line);
+		const parsedHeader = parseCombinedChunkHeader(line);
+		if (!parsedHeader) return;
+		const [firstParent] = parsedHeader.parentRanges;
+		const oldStartNum = firstParent?.start ?? 0;
+		const oldLinesNum = firstParent?.lines ?? 0;
+		deletedLineCounter = oldStartNum;
+		addedLineCounter = parsedHeader.newRange.start;
+		currentChunk = {
+			content: line,
+			changes: [],
+			oldStart: oldStartNum,
+			oldLines: oldLinesNum,
+			newStart: parsedHeader.newRange.start,
+			newLines: parsedHeader.newRange.lines,
+			combined: true,
+			parentCount: parsedHeader.parentCount,
+			oldRanges: parsedHeader.parentRanges
+		};
+		currentFileChanges = {
+			oldLines: oldLinesNum,
+			newLines: parsedHeader.newRange.lines,
+			combined: true,
+			parentCount: parsedHeader.parentCount,
+			parentLines: parsedHeader.parentRanges.map((range) => range.lines)
+		};
+		if (currentFile) {
+			const combinedFile = ensureCombinedFile(currentFile);
+			combinedFile.froms = pendingFroms;
+		}
+		currentFile?.chunks.push(currentChunk);
+	};
+	const chunk = (line, match) => {
+		if (!currentFile) start(line);
+		const [oldStart, oldNumLines, newStart, newNumLines] = match.slice(1);
+		const oldStartNum = Number(oldStart ?? 0);
+		const newStartNum = Number(newStart ?? 0);
+		deletedLineCounter = oldStartNum;
+		addedLineCounter = newStartNum;
+		currentChunk = {
+			content: line,
+			changes: [],
+			oldStart: oldStartNum,
+			oldLines: toNumOfLines(oldNumLines),
+			newStart: newStartNum,
+			newLines: toNumOfLines(newNumLines)
+		};
+		currentFileChanges = {
+			oldLines: toNumOfLines(oldNumLines),
+			newLines: toNumOfLines(newNumLines)
+		};
+		currentFile?.chunks.push(currentChunk);
+	};
+	const del = (line) => {
+		if (!currentChunk || !currentFile || !currentFileChanges) return;
+		currentChunk.changes.push({
+			type: "del",
+			del: true,
+			ln: deletedLineCounter++,
+			content: line
+		});
+		currentFile.deletions++;
+		currentFileChanges.oldLines--;
+	};
+	const add = (line) => {
+		if (!currentChunk || !currentFile || !currentFileChanges) return;
+		currentChunk.changes.push({
+			type: "add",
+			add: true,
+			ln: addedLineCounter++,
+			content: line
+		});
+		currentFile.additions++;
+		currentFileChanges.newLines--;
+	};
+	const eof = (line) => {
+		if (!currentChunk) return;
+		const [mostRecentChange] = currentChunk.changes.slice(-1);
+		if (!mostRecentChange) return;
+		currentChunk.changes.push({
+			type: mostRecentChange.type,
+			[mostRecentChange.type]: true,
+			ln1: mostRecentChange.ln1,
+			ln2: mostRecentChange.ln2,
+			ln: mostRecentChange.ln,
+			content: line
+		});
+	};
+	const parseCombinedContentLine = (line) => {
+		if (!currentChunk || !currentFile || !currentFileChanges) return;
+		if (line.match(/^\$/)) {
+			eof(line);
+			return;
+		}
+		const parentCount = currentChunk.parentCount ?? currentFileChanges.parentCount ?? currentFileChanges.parentLines?.length ?? 0;
+		const parentLines = currentFileChanges.parentLines;
+		if (!parentLines || parentCount <= 0) return;
+		const prefix = line.slice(0, parentCount);
+		const lineInResult = !prefix.includes("-");
+		const isLineInParent = (marker) => {
+			if (marker === "-") return true;
+			if (marker === "+") return false;
+			return lineInResult;
+		};
+		const lineInFirstParent = isLineInParent(prefix[0] ?? " ");
+		if (lineInResult && !lineInFirstParent) {
+			currentChunk.changes.push({
+				type: "add",
+				add: true,
+				ln: addedLineCounter++,
+				content: line
+			});
+			currentFile.additions++;
+			currentFileChanges.newLines--;
+		} else if (!lineInResult && lineInFirstParent) {
+			currentChunk.changes.push({
+				type: "del",
+				del: true,
+				ln: deletedLineCounter++,
+				content: line
+			});
+			currentFile.deletions++;
+			currentFileChanges.oldLines--;
+		} else if (lineInResult && lineInFirstParent) {
+			currentChunk.changes.push({
+				type: "normal",
+				normal: true,
+				ln1: deletedLineCounter++,
+				ln2: addedLineCounter++,
+				content: line
+			});
+			currentFileChanges.oldLines--;
+			currentFileChanges.newLines--;
+		} else currentChunk.changes.push({
+			type: "normal",
+			normal: true,
+			content: line
+		});
+		for (let i = 0; i < parentLines.length; i++) {
+			if (!isLineInParent(prefix[i] ?? " ")) continue;
+			const parentLine = parentLines[i];
+			if (parentLine !== void 0) parentLines[i] = parentLine - 1;
+		}
+	};
+	const schemaHeaders = [
+		[/^diff\s/, start],
+		[/^new file mode (\d+)$/, newFile],
+		[/^deleted file mode (\d+)$/, deletedFile],
+		[/^old mode (\d+)$/, oldMode],
+		[/^new mode (\d+)$/, newMode],
+		[/^similarity index (\d+)%/, similarityIndex],
+		[/^rename from /, renameFrom],
+		[/^rename to /, renameTo],
+		[/^Binary files .* and .* differ$/, binaryFiles],
+		[/^index\s[\da-zA-Z]+(?:,[\da-zA-Z]+)*\.\.[\da-zA-Z]+(?:\s(\d+))?$/, index],
+		[/^---\s/, fromFile],
+		[/^\+\+\+\s/, toFile],
+		[/^@{3,}\s/, combinedChunk],
+		[/^@@\s+-(\d+),?(\d+)?\s+\+(\d+),?(\d+)?\s@@/, chunk],
+		[/^\$/, eof]
+	];
+	const schemaContent = [
+		[/^\$/, eof],
+		[/^-/, del],
+		[/^\+/, add],
+		[/^\s+/, normal]
+	];
+	const parseContentLine = (line) => {
+		if (currentFileChanges?.combined) {
+			parseCombinedContentLine(line);
+			const parentLines = currentFileChanges.parentLines;
+			if (parentLines && parentLines.every((count) => count === 0) && currentFileChanges.newLines === 0) currentFileChanges = null;
+			return;
+		}
+		for (const [pattern, handler] of schemaContent) {
+			const match = line.match(pattern);
+			if (match) {
+				handler(line, match);
+				break;
+			}
+		}
+		if (currentFileChanges && currentFileChanges.oldLines === 0 && currentFileChanges.newLines === 0) currentFileChanges = null;
+	};
+	const parseHeaderLine = (line) => {
+		for (const [pattern, handler] of schemaHeaders) {
+			const match = line.match(pattern);
+			if (match) {
+				handler(line, match);
+				break;
+			}
+		}
+	};
+	const parseLine = (line) => {
+		if (currentFileChanges) parseContentLine(line);
+		else parseHeaderLine(line);
+	};
+	for (const line of lines) parseLine(line);
+	for (const file of files) {
+		if (file.chunks.length === 0) continue;
+		const diffLines = [];
+		for (const fileChunk of file.chunks) {
+			diffLines.push(fileChunk.content);
+			for (const change of fileChunk.changes) diffLines.push(change.content);
+		}
+		file.diff = diffLines.join("\n");
+	}
+	return files;
+}
+const ensureRenamedFile = (file) => {
+	const renamedFile = file;
+	renamedFile.type = "renamed";
+	renamedFile.similarityIndex ??= void 0;
+	return renamedFile;
+};
+const ensureCombinedFile = (file) => {
+	const combinedFile = file;
+	combinedFile.type = "combined";
+	combinedFile.froms ??= void 0;
+	return combinedFile;
+};
+const fileNameDiffRegex = /(a|i|w|c|o|1|2)\/.*(?=["']? ["']?(b|i|w|c|o|1|2)\/)|(b|i|w|c|o|1|2)\/.*$/g;
+const gitFileHeaderRegex = /^(a|b|i|w|c|o|1|2)\//;
+const parseFiles = (line) => {
+	return (line?.match(fileNameDiffRegex))?.map((fileName) => fileName.replace(gitFileHeaderRegex, "").replace(/("|')$/, ""));
+};
+const quotedFileNameRegex = /^\\?['"]|\\?['"]$/g;
+const parseOldOrNewFile = (line, prefix) => {
+	let fileName;
+	if (prefix) fileName = line.slice(prefix.length);
+	else fileName = leftTrimChars(line, "-+").trim();
+	fileName = removeTimeStamp(fileName);
+	return fileName.replace(quotedFileNameRegex, "").replace(gitFileHeaderRegex, "");
+};
+const leftTrimChars = (input, trimmingChars) => {
+	if (!trimmingChars) return input.trimStart();
+	const trimmingString = formTrimmingString(trimmingChars);
+	return input.replace(/* @__PURE__ */ new RegExp(`^${trimmingString}+`), "");
+};
+const timeStampRegex = /\t.*|\d{4}-\d\d-\d\d\s\d\d:\d\d:\d\d(.\d+)?\s(\+|-)\d\d\d\d/;
+const removeTimeStamp = (input) => {
+	const timeStamp = timeStampRegex.exec(input);
+	if (timeStamp) return input.substring(0, timeStamp.index).trim();
+	return input;
+};
+const formTrimmingString = (trimmingChars) => {
+	if (trimmingChars === null || trimmingChars === void 0) return "\\s";
+	else if (trimmingChars instanceof RegExp) return trimmingChars.source;
+	return `[${trimmingChars.replace(/([.*+?^=!:${}()|[\]/\\])/g, "\\$1")}]`;
+};
+
+//#endregion
+export { diffParser };

package/dist/enhancedMap.d.mts

@@ -0,0 +1,21 @@
+//#region src/enhancedMap.d.ts
+declare const enhancedMapReject: unique symbol;
+declare class EnhancedMap<K, V> extends Map<K, V> {
+  find(predicate: (value: V, key: K) => boolean): {
+    key: K;
+    value: V;
+  } | undefined;
+  setMultiple(values: Record<K & string, V>): this;
+  setMultiple(...values: [key: K, value: V][]): this;
+  getOrThrow(key: K): V;
+  getOrInsert(key: K, fallback: () => V): V;
+  toFilteredValues(predicate: (value: V, key: K) => boolean): V[];
+  toMap<T>(mapFunction: (value: V, key: K, reject: typeof enhancedMapReject) => T | typeof enhancedMapReject): T[];
+  toObjMap<ObjKey extends PropertyKey, ObjValue>(mapFunction: (value: V, key: K) => [key: ObjKey, value: ObjValue] | false): Record<ObjKey, ObjValue>;
+  toValues(): V[];
+  toKeys(): K[];
+  static from<T extends Record<string, unknown>, K extends keyof T>(array: T[] | Iterable<T> | null | undefined, key: K): EnhancedMap<T[K], T>;
+  static from<T, K, V>(array: T[] | Iterable<T> | null | undefined, mapFunction: (item: T) => [key: K, value: V] | false): EnhancedMap<K, V>;
+}
+//#endregion
+export { EnhancedMap, enhancedMapReject };

package/dist/enhancedMap.mjs

@@ -0,0 +1,69 @@
+import { a as isFunction } from "./assertions-qMxfVhSu.mjs";
+
+//#region src/enhancedMap.ts
+const enhancedMapReject = Symbol();
+var EnhancedMap = class EnhancedMap extends Map {
+	find(predicate) {
+		for (const [key, value] of this) if (predicate(value, key)) return {
+			key,
+			value
+		};
+	}
+	setMultiple(...values) {
+		if (Array.isArray(values[0])) for (const [key, value] of values) this.set(key, value);
+		else for (const [key, value] of Object.entries(values[0])) this.set(key, value);
+		return this;
+	}
+	getOrThrow(key) {
+		const value = this.get(key);
+		if (value === void 0) throw new Error(`Key ${key} not found in EnhancedMap`);
+		return value;
+	}
+	getOrInsert(key, fallback) {
+		if (!this.has(key)) this.set(key, fallback());
+		return this.getOrThrow(key);
+	}
+	toFilteredValues(predicate) {
+		const values = [];
+		for (const [key, value] of this) if (predicate(value, key)) values.push(value);
+		return values;
+	}
+	toMap(mapFunction) {
+		const values = [];
+		for (const [key, value] of this) {
+			const result = mapFunction(value, key, enhancedMapReject);
+			if (result !== enhancedMapReject) values.push(result);
+		}
+		return values;
+	}
+	toObjMap(mapFunction) {
+		const values = {};
+		for (const [key, value] of this) {
+			const result = mapFunction(value, key);
+			if (result) values[result[0]] = result[1];
+		}
+		return values;
+	}
+	toValues() {
+		return [...this.values()];
+	}
+	toKeys() {
+		return [...this.keys()];
+	}
+	static from(array, mapFunction) {
+		const map = new EnhancedMap();
+		if (!array) return map;
+		const isFn = isFunction(mapFunction);
+		for (const item of array) if (isFn) {
+			const result = mapFunction(item);
+			if (result) map.set(result[0], result[1]);
+		} else {
+			const key = item[mapFunction];
+			if (key !== void 0) map.set(key, item);
+		}
+		return map;
+	}
+};
+
+//#endregion
+export { EnhancedMap, enhancedMapReject };

package/dist/exhaustiveMatch.d.mts

@@ -0,0 +1,10 @@
+//#region src/exhaustiveMatch.d.ts
+declare function exhaustiveMatch<T extends string>(value: T): {
+  with: <R>(pattern: { [K in T]: "_nxt" | "_never" | (() => R) }) => R;
+  withObject: <R>(pattern: Record<T, R>) => R;
+};
+declare function exhaustiveMatchObjUnion<T extends Record<string, unknown>, D extends keyof T, K extends T[D] & string>(obj: T, key: D): {
+  with: <R>(pattern: { [P in K]: "_never" | ((props: Extract<T, Record<D, P>>) => R) }) => R;
+};
+//#endregion
+export { exhaustiveMatch, exhaustiveMatchObjUnion };

package/dist/exhaustiveMatch.mjs

@@ -0,0 +1,48 @@
+//#region src/exhaustiveMatch.ts
+function exhaustiveMatch(value) {
+	/**
+	* The pattern can be:
+	*
+	* - A function that returns the result
+	* - '_nxt' to try the next pattern
+	* - '_never' to indicate that this pattern should never be matched
+	*
+	* @param pattern
+	*/
+	function matchWith(pattern) {
+		const result = pattern[value];
+		if (typeof result === "function") return result();
+		if (result === "_nxt") {
+			const keys = Object.keys(pattern);
+			const nextIndex = keys.indexOf(value) + 1;
+			for (let i = nextIndex; i < keys.length; i++) {
+				const nextMatch = pattern[keys[i]];
+				if (typeof nextMatch === "function") return nextMatch();
+			}
+		}
+		throw new Error(`Exhaustive match failed: no match for ${value}`);
+	}
+	/**
+	* Match with early evaluation of the values
+	*
+	* @param pattern
+	*/
+	function withObject(pattern) {
+		return pattern[value];
+	}
+	return {
+		with: matchWith,
+		withObject
+	};
+}
+function exhaustiveMatchObjUnion(obj, key) {
+	function withLazy(pattern) {
+		const result = pattern[obj[key]];
+		if (typeof result === "function") return result(obj);
+		throw new Error(`Exhaustive match failed: no match for ${obj[key]}`);
+	}
+	return { with: withLazy };
+}
+
+//#endregion
+export { exhaustiveMatch, exhaustiveMatchObjUnion };

package/dist/{filterObjectOrArrayKeys.d.cts → filterObjectOrArrayKeys.d.mts}

@@ -1,3 +1,4 @@
+//#region src/filterObjectOrArrayKeys.d.ts
 /**
  * Filters the keys of an object based on the provided patterns.
  *
@@ -77,12 +78,18 @@
  *   supported.
  * @returns The filtered object or array.
  */
-declare function filterObjectOrArrayKeys(objOrArray: Record<string, any> | Record<string, any>[], { filterKeys, rejectKeys, rejectEmptyObjectsInArray, sortKeys, sortPatterns, }: {
-    filterKeys?: string[] | string;
-    rejectKeys?: string[] | string;
-    rejectEmptyObjectsInArray?: boolean;
-    sortKeys?: 'asc' | 'desc' | 'simpleValuesFirst' | false;
-    sortPatterns?: string[];
+declare function filterObjectOrArrayKeys(objOrArray: Record<string, any> | Record<string, any>[], {
+  filterKeys,
+  rejectKeys,
+  rejectEmptyObjectsInArray,
+  sortKeys,
+  sortPatterns
+}: {
+  filterKeys?: string[] | string;
+  rejectKeys?: string[] | string;
+  rejectEmptyObjectsInArray?: boolean;
+  sortKeys?: 'asc' | 'desc' | 'simpleValuesFirst' | false;
+  sortPatterns?: string[];
 }): Record<string, any> | Record<string, any>[];
-
-export { filterObjectOrArrayKeys };
+//#endregion
+export { filterObjectOrArrayKeys };