@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/dist/git/utils/reachability.utils.js

@@ -1,157 +1,130 @@
-import { base64, fromBase64 } from '../../utils/base64.js';
-import { GitGraphRowContextFlags } from '../models/graph.js';
+import { base64, fromBase64 } from "../../utils/base64.js";
+import "../models/graph.js";
+//#region ../git/src/utils/reachability.utils.ts
 /**
- * Computes the compact {@link GitGraphRowContextFlags} bitfield for a commit row from its reachable-ref
- * set and the walk's HEAD-derived sets. Single-sourced so the host row processor
- * (`GlGraphRowProcessor`), the R6b incremental fast path, and the equivalence harness all compute
- * byte-identical flags (no manual mirrors that can drift). Stash rows carry no flags — callers skip this
- * for `stash` rows. See {@link GitGraphRowContextFlags} for the per-bit semantics.
- */
-export function computeGraphRowContextFlags(sha, reachableRefs, ctx) {
-    // Allocation-free "exactly one local branch reachable" check → `+unique`.
-    let localBranches = 0;
-    if (reachableRefs != null) {
-        for (const r of reachableRefs) {
-            if (r.refType === 'branch' && !r.remote && ++localBranches > 1)
-                break;
-        }
-    }
-    // Unpublished (ahead) = reachable from HEAD but not from HEAD's upstream tip. Unpulled (behind) is its
-    // exact mirror over the same two sets: on the upstream tip but not on HEAD, i.e. `HEAD..@{u}`. Both are
-    // derived from `reachableFromHeadUpstream`, which is undefined when HEAD has no upstream — so neither
-    // is ever flagged in that case, and the two can never both be set for one sha.
-    const upstream = ctx.reachableFromHeadUpstream;
-    const reachableFromHead = ctx.reachableFromHEAD.has(sha);
-    const onUpstream = upstream?.has(sha) ?? false;
-    const isUnpublished = upstream != null && reachableFromHead && !onUpstream;
-    const isUnpulled = onUpstream && !reachableFromHead;
-    return ((reachableFromHead ? GitGraphRowContextFlags.ReachableFromHead : 0) |
-        (ctx.rewriteableFromHEAD.has(sha) ? GitGraphRowContextFlags.RewriteableFromHead : 0) |
-        (localBranches === 1 ? GitGraphRowContextFlags.UniqueToBranch : 0) |
-        (ctx.tipShasWithChildren.has(sha) ? GitGraphRowContextFlags.HasChildren : 0) |
-        (isUnpublished ? GitGraphRowContextFlags.Unpublished : 0) |
-        (isUnpulled ? GitGraphRowContextFlags.Unpulled : 0));
+* Computes the compact {@link GitGraphRowContextFlags} bitfield for a commit row from its reachable-ref
+* set and the walk's HEAD-derived sets. Single-sourced so the host row processor
+* (`GlGraphRowProcessor`), the R6b incremental fast path, and the equivalence harness all compute
+* byte-identical flags (no manual mirrors that can drift). Stash rows carry no flags — callers skip this
+* for `stash` rows. See {@link GitGraphRowContextFlags} for the per-bit semantics.
+*/
+function computeGraphRowContextFlags(sha, reachableRefs, ctx) {
+	let localBranches = 0;
+	if (reachableRefs != null) {
+		for (const r of reachableRefs) if (r.refType === "branch" && !r.remote && ++localBranches > 1) break;
+	}
+	const upstream = ctx.reachableFromHeadUpstream;
+	const reachableFromHead = ctx.reachableFromHEAD.has(sha);
+	const onUpstream = upstream?.has(sha) ?? false;
+	const isUnpublished = upstream != null && reachableFromHead && !onUpstream;
+	const isUnpulled = onUpstream && !reachableFromHead;
+	return (reachableFromHead ? 1 : 0) | (ctx.rewriteableFromHEAD.has(sha) ? 16 : 0) | (localBranches === 1 ? 2 : 0) | (ctx.tipShasWithChildren.has(sha) ? 4 : 0) | (isUnpublished ? 8 : 0) | (isUnpulled ? 32 : 0);
 }
 /**
- * Canonical dictionary key for a reachable ref. The `r`/`l` discriminator keeps a remote branch from
- * colliding with a local branch of the same name; the `refType` prefix separates tags from branches.
- * `current` is part of the key so a builder SEEDED from a prior generation's table can't hand back a
- * stale dictionary entry after the checked-out branch changes — the updated ref interns as a new
- * entry instead (within a single walk `current` can't change, so the wider key is behavior-neutral).
- * Single-sourced here so the encoder ({@link createReachabilityTableBuilder}) and any future consumer
- * can't drift on the convention.
- */
-export function reachableRefKey(ref) {
-    return `${ref.refType}:${ref.refType === 'branch' && ref.remote ? 'r' : 'l'}:${ref.current ? 'c' : 'n'}:${ref.name}`;
+* Canonical dictionary key for a reachable ref. The `r`/`l` discriminator keeps a remote branch from
+* colliding with a local branch of the same name; the `refType` prefix separates tags from branches.
+* `current` is part of the key so a builder SEEDED from a prior generation's table can't hand back a
+* stale dictionary entry after the checked-out branch changes — the updated ref interns as a new
+* entry instead (within a single walk `current` can't change, so the wider key is behavior-neutral).
+* Single-sourced here so the encoder ({@link createReachabilityTableBuilder}) and any future consumer
+* can't drift on the convention.
+*/
+function reachableRefKey(ref) {
+	return `${ref.refType}:${ref.refType === "branch" && ref.remote ? "r" : "l"}:${ref.current ? "c" : "n"}:${ref.name}`;
 }
-// Monotonic generation counter — each builder (i.e. each fresh graph walk) gets a distinct id, while a
-// builder reused across `more()` pagination keeps its id. Only ever incremented host-side (the encoder);
-// the webview treats the id as opaque. Module-scoped so ids are unique across a session's builders.
 let nextReachabilityTableId = 0;
 /**
- * Builds a {@link GraphReachabilityTable} incrementally: interns refs into a shared dictionary and
- * distinct membership bitmaps into a deduplicated set list. Kept next to {@link decodeReachabilitySet}
- * (its exact inverse) so the wire format — first-seen dictionary indexing, LSB-first bit packing,
- * base64 — has a single owner and a round-trippable test, rather than an encoder and decoder that can
- * silently diverge across packages.
- *
- * Append-only by construction: an index, once assigned, is never reused — so a builder kept alive
- * across paginated loads accumulates a table whose existing indices stay valid as it grows.
- *
- * Pass a prior generation's table as `seed` to CONTINUE it: identical ref sets re-intern to their
- * seeded indices and the table keeps the seed's `id`, so rows retained across a rebuild keep valid
- * `reachabilityIndex` values and the host's same-id delta shipping applies (only appended entries go
- * over the wire). Entries the new walk never re-interns stay in the table unreferenced — harmless,
- * and bounded by per-session ref churn.
- */
-export function createReachabilityTableBuilder(seed) {
-    const id = seed?.id ?? ++nextReachabilityTableId;
-    const dictionary = seed != null ? [...seed.dictionary] : [];
-    const refKeyToIndex = new Map(dictionary.map((ref, i) => [reachableRefKey(ref), i]));
-    const sets = seed != null ? [...seed.sets] : [];
-    const setKeyToIndex = new Map(sets.map((encoded, i) => [encoded, i]));
-    // Reachability is monotone, so a graph walk interns long runs of IDENTICAL sets (thousands of
-    // consecutive trunk rows share one set). Remembering the previous call's indices skips the
-    // bitmap-pack + base64 for those runs; a same-membership-different-order call just falls through
-    // to the (still correct) slow path.
-    let lastIndices;
-    let lastSetIndex;
-    return {
-        /** Interns a ref set, returning its index into `sets`, or undefined when the set is empty. */
-        intern: (refs) => {
-            if (refs == null)
-                return undefined;
-            let maxIndex = -1;
-            const indices = [];
-            for (const ref of refs) {
-                const key = reachableRefKey(ref);
-                let index = refKeyToIndex.get(key);
-                if (index == null) {
-                    index = dictionary.length;
-                    refKeyToIndex.set(key, index);
-                    dictionary.push(ref);
-                }
-                indices.push(index);
-                if (index > maxIndex) {
-                    maxIndex = index;
-                }
-            }
-            if (indices.length === 0)
-                return undefined;
-            if (lastIndices != null && indices.length === lastIndices.length) {
-                let same = true;
-                for (let i = 0; i < indices.length; i++) {
-                    if (indices[i] !== lastIndices[i]) {
-                        same = false;
-                        break;
-                    }
-                }
-                if (same)
-                    return lastSetIndex;
-            }
-            // Pack into a bitset sized to this set's high-water dictionary index, then intern by base64.
-            const bytes = new Uint8Array((maxIndex >> 3) + 1);
-            for (const index of indices) {
-                bytes[index >> 3] |= 1 << (index & 7);
-            }
-            const encoded = base64(bytes);
-            let setIndex = setKeyToIndex.get(encoded);
-            if (setIndex == null) {
-                setIndex = sets.length;
-                setKeyToIndex.set(encoded, setIndex);
-                sets.push(encoded);
-            }
-            lastIndices = indices;
-            lastSetIndex = setIndex;
-            return setIndex;
-        },
-        /** The accumulated table, or undefined when nothing was interned. */
-        build: () => dictionary.length ? { id: id, dictionary: dictionary, sets: sets } : undefined,
-    };
+* Builds a {@link GraphReachabilityTable} incrementally: interns refs into a shared dictionary and
+* distinct membership bitmaps into a deduplicated set list. Kept next to {@link decodeReachabilitySet}
+* (its exact inverse) so the wire format — first-seen dictionary indexing, LSB-first bit packing,
+* base64 — has a single owner and a round-trippable test, rather than an encoder and decoder that can
+* silently diverge across packages.
+*
+* Append-only by construction: an index, once assigned, is never reused — so a builder kept alive
+* across paginated loads accumulates a table whose existing indices stay valid as it grows.
+*
+* Pass a prior generation's table as `seed` to CONTINUE it: identical ref sets re-intern to their
+* seeded indices and the table keeps the seed's `id`, so rows retained across a rebuild keep valid
+* `reachabilityIndex` values and the host's same-id delta shipping applies (only appended entries go
+* over the wire). Entries the new walk never re-interns stay in the table unreferenced — harmless,
+* and bounded by per-session ref churn.
+*/
+function createReachabilityTableBuilder(seed) {
+	const id = seed?.id ?? ++nextReachabilityTableId;
+	const dictionary = seed != null ? [...seed.dictionary] : [];
+	const refKeyToIndex = new Map(dictionary.map((ref, i) => [reachableRefKey(ref), i]));
+	const sets = seed != null ? [...seed.sets] : [];
+	const setKeyToIndex = new Map(sets.map((encoded, i) => [encoded, i]));
+	let lastIndices;
+	let lastSetIndex;
+	return {
+		/** Interns a ref set, returning its index into `sets`, or undefined when the set is empty. */
+		intern: (refs) => {
+			if (refs == null) return void 0;
+			let maxIndex = -1;
+			const indices = [];
+			for (const ref of refs) {
+				const key = reachableRefKey(ref);
+				let index = refKeyToIndex.get(key);
+				if (index == null) {
+					index = dictionary.length;
+					refKeyToIndex.set(key, index);
+					dictionary.push(ref);
+				}
+				indices.push(index);
+				if (index > maxIndex) maxIndex = index;
+			}
+			if (indices.length === 0) return void 0;
+			if (lastIndices != null && indices.length === lastIndices.length) {
+				let same = true;
+				for (let i = 0; i < indices.length; i++) if (indices[i] !== lastIndices[i]) {
+					same = false;
+					break;
+				}
+				if (same) return lastSetIndex;
+			}
+			const bytes = new Uint8Array((maxIndex >> 3) + 1);
+			for (const index of indices) bytes[index >> 3] |= 1 << (index & 7);
+			const encoded = base64(bytes);
+			let setIndex = setKeyToIndex.get(encoded);
+			if (setIndex == null) {
+				setIndex = sets.length;
+				setKeyToIndex.set(encoded, setIndex);
+				sets.push(encoded);
+			}
+			lastIndices = indices;
+			lastSetIndex = setIndex;
+			return setIndex;
+		},
+		/** The accumulated table, or undefined when nothing was interned. */
+		build: () => dictionary.length ? {
+			id,
+			dictionary,
+			sets
+		} : void 0
+	};
 }
 /**
- * Decodes the membership bitmap at `index` in a {@link GraphReachabilityTable} back into its list of
- * reachable refs. Refs come back in the table's first-seen dictionary order — callers that need the
- * canonical display order (current-first / local-before-remote / tags newest-first) sort the result
- * with `compareReachableRefs`. Returns an empty array for an out-of-range/missing set index.
- *
- * The bitmap is at most `ceil(dictionary.length / 8)` bytes; earlier (shorter) bitmaps packed against
- * a smaller dictionary stay valid — only bits actually present can be set, so the loop stops at the
- * shorter of the dictionary length and the bitmap's bit count rather than scanning a guaranteed-zero tail.
- */
-export function decodeReachabilitySet(table, index) {
-    const { dictionary, sets } = table;
-    const encoded = sets[index];
-    if (encoded == null)
-        return [];
-    const bytes = fromBase64(encoded);
-    const refs = [];
-    const count = Math.min(dictionary.length, bytes.length * 8);
-    for (let i = 0; i < count; i++) {
-        if ((bytes[i >> 3] ?? 0) & (1 << (i & 7))) {
-            refs.push(dictionary[i]);
-        }
-    }
-    return refs;
+* Decodes the membership bitmap at `index` in a {@link GraphReachabilityTable} back into its list of
+* reachable refs. Refs come back in the table's first-seen dictionary order — callers that need the
+* canonical display order (current-first / local-before-remote / tags newest-first) sort the result
+* with `compareReachableRefs`. Returns an empty array for an out-of-range/missing set index.
+*
+* The bitmap is at most `ceil(dictionary.length / 8)` bytes; earlier (shorter) bitmaps packed against
+* a smaller dictionary stay valid — only bits actually present can be set, so the loop stops at the
+* shorter of the dictionary length and the bitmap's bit count rather than scanning a guaranteed-zero tail.
+*/
+function decodeReachabilitySet(table, index) {
+	const { dictionary, sets } = table;
+	const encoded = sets[index];
+	if (encoded == null) return [];
+	const bytes = fromBase64(encoded);
+	const refs = [];
+	const count = Math.min(dictionary.length, bytes.length * 8);
+	for (let i = 0; i < count; i++) if ((bytes[i >> 3] ?? 0) & 1 << (i & 7)) refs.push(dictionary[i]);
+	return refs;
 }
+//#endregion
+export { computeGraphRowContextFlags, createReachabilityTableBuilder, decodeReachabilitySet, reachableRefKey };
+
 //# sourceMappingURL=reachability.utils.js.map

package/dist/git/utils/reachability.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"reachability.utils.js","sourceRoot":"","sources":["../../../src/git/utils/reachability.utils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"reachability.utils.js","names":[],"sources":["../../../../git/src/utils/reachability.utils.ts"],"sourcesContent":["import { base64, fromBase64 } from '@gitlens/utils/base64.js';\nimport type { GraphContext, GraphReachabilityTable } from '../models/graph.js';\nimport { GitGraphRowContextFlags } from '../models/graph.js';\nimport type { GitCommitReachability } from '../providers/commits.js';\n\ntype ReachableRef = GitCommitReachability['refs'][number];\n\n/**\n * Computes the compact {@link GitGraphRowContextFlags} bitfield for a commit row from its reachable-ref\n * set and the walk's HEAD-derived sets. Single-sourced so the host row processor\n * (`GlGraphRowProcessor`), the R6b incremental fast path, and the equivalence harness all compute\n * byte-identical flags (no manual mirrors that can drift). Stash rows carry no flags — callers skip this\n * for `stash` rows. See {@link GitGraphRowContextFlags} for the per-bit semantics.\n */\nexport function computeGraphRowContextFlags(\n\tsha: string,\n\treachableRefs: Iterable<ReachableRef> | undefined,\n\tctx: Pick<\n\t\tGraphContext,\n\t\t'reachableFromHEAD' | 'rewriteableFromHEAD' | 'tipShasWithChildren' | 'reachableFromHeadUpstream'\n\t>,\n): GitGraphRowContextFlags {\n\t// Allocation-free \"exactly one local branch reachable\" check → `+unique`.\n\tlet localBranches = 0;\n\tif (reachableRefs != null) {\n\t\tfor (const r of reachableRefs) {\n\t\t\tif (r.refType === 'branch' && !r.remote && ++localBranches > 1) break;\n\t\t}\n\t}\n\t// Unpublished (ahead) = reachable from HEAD but not from HEAD's upstream tip. Unpulled (behind) is its\n\t// exact mirror over the same two sets: on the upstream tip but not on HEAD, i.e. `HEAD..@{u}`. Both are\n\t// derived from `reachableFromHeadUpstream`, which is undefined when HEAD has no upstream — so neither\n\t// is ever flagged in that case, and the two can never both be set for one sha.\n\tconst upstream = ctx.reachableFromHeadUpstream;\n\tconst reachableFromHead = ctx.reachableFromHEAD.has(sha);\n\tconst onUpstream = upstream?.has(sha) ?? false;\n\tconst isUnpublished = upstream != null && reachableFromHead && !onUpstream;\n\tconst isUnpulled = onUpstream && !reachableFromHead;\n\treturn (\n\t\t(reachableFromHead ? GitGraphRowContextFlags.ReachableFromHead : 0) |\n\t\t(ctx.rewriteableFromHEAD.has(sha) ? GitGraphRowContextFlags.RewriteableFromHead : 0) |\n\t\t(localBranches === 1 ? GitGraphRowContextFlags.UniqueToBranch : 0) |\n\t\t(ctx.tipShasWithChildren.has(sha) ? GitGraphRowContextFlags.HasChildren : 0) |\n\t\t(isUnpublished ? GitGraphRowContextFlags.Unpublished : 0) |\n\t\t(isUnpulled ? GitGraphRowContextFlags.Unpulled : 0)\n\t);\n}\n\n/**\n * Canonical dictionary key for a reachable ref. The `r`/`l` discriminator keeps a remote branch from\n * colliding with a local branch of the same name; the `refType` prefix separates tags from branches.\n * `current` is part of the key so a builder SEEDED from a prior generation's table can't hand back a\n * stale dictionary entry after the checked-out branch changes — the updated ref interns as a new\n * entry instead (within a single walk `current` can't change, so the wider key is behavior-neutral).\n * Single-sourced here so the encoder ({@link createReachabilityTableBuilder}) and any future consumer\n * can't drift on the convention.\n */\nexport function reachableRefKey(ref: ReachableRef): string {\n\treturn `${ref.refType}:${ref.refType === 'branch' && ref.remote ? 'r' : 'l'}:${ref.current ? 'c' : 'n'}:${ref.name}`;\n}\n\n// Monotonic generation counter — each builder (i.e. each fresh graph walk) gets a distinct id, while a\n// builder reused across `more()` pagination keeps its id. Only ever incremented host-side (the encoder);\n// the webview treats the id as opaque. Module-scoped so ids are unique across a session's builders.\nlet nextReachabilityTableId = 0;\n\n/**\n * Builds a {@link GraphReachabilityTable} incrementally: interns refs into a shared dictionary and\n * distinct membership bitmaps into a deduplicated set list. Kept next to {@link decodeReachabilitySet}\n * (its exact inverse) so the wire format — first-seen dictionary indexing, LSB-first bit packing,\n * base64 — has a single owner and a round-trippable test, rather than an encoder and decoder that can\n * silently diverge across packages.\n *\n * Append-only by construction: an index, once assigned, is never reused — so a builder kept alive\n * across paginated loads accumulates a table whose existing indices stay valid as it grows.\n *\n * Pass a prior generation's table as `seed` to CONTINUE it: identical ref sets re-intern to their\n * seeded indices and the table keeps the seed's `id`, so rows retained across a rebuild keep valid\n * `reachabilityIndex` values and the host's same-id delta shipping applies (only appended entries go\n * over the wire). Entries the new walk never re-interns stay in the table unreferenced — harmless,\n * and bounded by per-session ref churn.\n */\nexport function createReachabilityTableBuilder(seed?: GraphReachabilityTable): {\n\tintern: (refs: Iterable<ReachableRef> | undefined) => number | undefined;\n\tbuild: () => GraphReachabilityTable | undefined;\n} {\n\tconst id = seed?.id ?? ++nextReachabilityTableId;\n\tconst dictionary: GitCommitReachability['refs'] = seed != null ? [...seed.dictionary] : [];\n\tconst refKeyToIndex = new Map<string, number>(dictionary.map((ref, i) => [reachableRefKey(ref), i]));\n\tconst sets: string[] = seed != null ? [...seed.sets] : [];\n\tconst setKeyToIndex = new Map<string, number>(sets.map((encoded, i) => [encoded, i]));\n\n\t// Reachability is monotone, so a graph walk interns long runs of IDENTICAL sets (thousands of\n\t// consecutive trunk rows share one set). Remembering the previous call's indices skips the\n\t// bitmap-pack + base64 for those runs; a same-membership-different-order call just falls through\n\t// to the (still correct) slow path.\n\tlet lastIndices: number[] | undefined;\n\tlet lastSetIndex: number | undefined;\n\n\treturn {\n\t\t/** Interns a ref set, returning its index into `sets`, or undefined when the set is empty. */\n\t\tintern: (refs: Iterable<ReachableRef> | undefined): number | undefined => {\n\t\t\tif (refs == null) return undefined;\n\n\t\t\tlet maxIndex = -1;\n\t\t\tconst indices: number[] = [];\n\t\t\tfor (const ref of refs) {\n\t\t\t\tconst key = reachableRefKey(ref);\n\t\t\t\tlet index = refKeyToIndex.get(key);\n\t\t\t\tif (index == null) {\n\t\t\t\t\tindex = dictionary.length;\n\t\t\t\t\trefKeyToIndex.set(key, index);\n\t\t\t\t\tdictionary.push(ref);\n\t\t\t\t}\n\t\t\t\tindices.push(index);\n\t\t\t\tif (index > maxIndex) {\n\t\t\t\t\tmaxIndex = index;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (indices.length === 0) return undefined;\n\n\t\t\tif (lastIndices != null && indices.length === lastIndices.length) {\n\t\t\t\tlet same = true;\n\t\t\t\tfor (let i = 0; i < indices.length; i++) {\n\t\t\t\t\tif (indices[i] !== lastIndices[i]) {\n\t\t\t\t\t\tsame = false;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tif (same) return lastSetIndex;\n\t\t\t}\n\n\t\t\t// Pack into a bitset sized to this set's high-water dictionary index, then intern by base64.\n\t\t\tconst bytes = new Uint8Array((maxIndex >> 3) + 1);\n\t\t\tfor (const index of indices) {\n\t\t\t\tbytes[index >> 3] |= 1 << (index & 7);\n\t\t\t}\n\t\t\tconst encoded = base64(bytes);\n\t\t\tlet setIndex = setKeyToIndex.get(encoded);\n\t\t\tif (setIndex == null) {\n\t\t\t\tsetIndex = sets.length;\n\t\t\t\tsetKeyToIndex.set(encoded, setIndex);\n\t\t\t\tsets.push(encoded);\n\t\t\t}\n\t\t\tlastIndices = indices;\n\t\t\tlastSetIndex = setIndex;\n\t\t\treturn setIndex;\n\t\t},\n\n\t\t/** The accumulated table, or undefined when nothing was interned. */\n\t\tbuild: (): GraphReachabilityTable | undefined =>\n\t\t\tdictionary.length ? { id: id, dictionary: dictionary, sets: sets } : undefined,\n\t};\n}\n\n/**\n * Decodes the membership bitmap at `index` in a {@link GraphReachabilityTable} back into its list of\n * reachable refs. Refs come back in the table's first-seen dictionary order — callers that need the\n * canonical display order (current-first / local-before-remote / tags newest-first) sort the result\n * with `compareReachableRefs`. Returns an empty array for an out-of-range/missing set index.\n *\n * The bitmap is at most `ceil(dictionary.length / 8)` bytes; earlier (shorter) bitmaps packed against\n * a smaller dictionary stay valid — only bits actually present can be set, so the loop stops at the\n * shorter of the dictionary length and the bitmap's bit count rather than scanning a guaranteed-zero tail.\n */\nexport function decodeReachabilitySet(table: GraphReachabilityTable, index: number): GitCommitReachability['refs'] {\n\tconst { dictionary, sets } = table;\n\tconst encoded = sets[index];\n\tif (encoded == null) return [];\n\n\tconst bytes = fromBase64(encoded);\n\tconst refs: GitCommitReachability['refs'] = [];\n\tconst count = Math.min(dictionary.length, bytes.length * 8);\n\tfor (let i = 0; i < count; i++) {\n\t\tif ((bytes[i >> 3] ?? 0) & (1 << (i & 7))) {\n\t\t\trefs.push(dictionary[i]);\n\t\t}\n\t}\n\treturn refs;\n}\n"],"mappings":"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"}

package/dist/git/utils/rebase.utils.d.ts

@@ -1,4 +1,5 @@
-import type { ProcessedRebaseEntry, ProcessedRebaseTodo, RebaseTodoCommandAction, RebaseTodoCommitAction, RebaseTodoEntry, RebaseTodoMergesAction } from '../models/rebase.js';
+import { ProcessedRebaseEntry, ProcessedRebaseTodo, RebaseTodoCommandAction, RebaseTodoCommitAction, RebaseTodoEntry, RebaseTodoMergesAction } from "../models/rebase.js";
+//#region ../git/src/utils/rebase.utils.d.ts
 /** Commit actions that have SHAs and are editable */
 export declare const commitRebaseActions: Set<RebaseTodoCommitAction>;
 /** Command actions that are movable but not editable */
@@ -16,4 +17,5 @@ export declare function formatUpdateRefLine(ref: string): string;
  * - Detects rebases with actual merge commits (reordering disabled but actions allowed)
  */
 export declare function processRebaseEntries(entries: RebaseTodoEntry[], done?: boolean): ProcessedRebaseTodo;
+//#endregion
 //# sourceMappingURL=rebase.utils.d.ts.map

package/dist/git/utils/rebase.utils.js

@@ -1,93 +1,109 @@
+//#region ../git/src/utils/rebase.utils.ts
 /** Commit actions that have SHAs and are editable */
-export const commitRebaseActions = new Set([
-    'pick',
-    'reword',
-    'edit',
-    'squash',
-    'fixup',
-    'drop',
+const commitRebaseActions = /* @__PURE__ */ new Set([
+	"pick",
+	"reword",
+	"edit",
+	"squash",
+	"fixup",
+	"drop"
 ]);
 /** Command actions that are movable but not editable */
-export const commandRebaseActions = new Set(['exec', 'break', 'noop']);
+const commandRebaseActions = /* @__PURE__ */ new Set([
+	"exec",
+	"break",
+	"noop"
+]);
 /** Actions that indicate --rebase-merges mode */
-export const mergesRebaseActions = new Set(['label', 'reset', 'merge']);
-export function formatRebaseTodoEntryLine(entry, overrideAction) {
-    const action = overrideAction ?? entry.action;
-    if (entry.type === 'commit') {
-        const flagPart = entry.flag ? ` ${entry.flag}` : '';
-        return `${action}${flagPart} ${entry.sha} # ${entry.message}`;
-    }
-    // Command entries (exec, break, noop)
-    if (entry.action === 'exec') {
-        return `exec${entry.command ? ` ${entry.command}` : ''}`;
-    }
-    return entry.action; // break, noop
+const mergesRebaseActions = /* @__PURE__ */ new Set([
+	"label",
+	"reset",
+	"merge"
+]);
+function formatRebaseTodoEntryLine(entry, overrideAction) {
+	const action = overrideAction ?? entry.action;
+	if (entry.type === "commit") return `${action}${entry.flag ? ` ${entry.flag}` : ""} ${entry.sha} # ${entry.message}`;
+	if (entry.action === "exec") return `exec${entry.command ? ` ${entry.command}` : ""}`;
+	return entry.action;
 }
 /** Formats an update-ref line for output */
-export function formatUpdateRefLine(ref) {
-    return `update-ref ${ref}`;
+function formatUpdateRefLine(ref) {
+	return `update-ref ${ref}`;
 }
 function isCommitEntry(entry) {
-    return (entry.sha != null && entry.message != null && commitRebaseActions.has(entry.action));
+	return entry.sha != null && entry.message != null && commitRebaseActions.has(entry.action);
 }
 function isCommandEntry(entry) {
-    return commandRebaseActions.has(entry.action);
+	return commandRebaseActions.has(entry.action);
 }
 /**
- * Checks if this is a --rebase-merges rebase that actually has merge commits
- * Only actual 'merge' commands indicate a true DAG that cannot be safely reordered.
- * If just label/reset are present (no merge), the history is linear and editable.
- */
+* Checks if this is a --rebase-merges rebase that actually has merge commits
+* Only actual 'merge' commands indicate a true DAG that cannot be safely reordered.
+* If just label/reset are present (no merge), the history is linear and editable.
+*/
 function hasActualMergeCommands(entries) {
-    return entries.some(e => e.action === 'merge');
+	return entries.some((e) => e.action === "merge");
 }
 /** Checks if an entry is a structural label/reset command (filtered from UI) */
 function isStructuralEntry(entry) {
-    return entry.action === 'label' || entry.action === 'reset';
+	return entry.action === "label" || entry.action === "reset";
 }
 function isUpdateRefEntry(entry) {
-    return entry.action === 'update-ref' && entry.ref != null;
+	return entry.action === "update-ref" && entry.ref != null;
 }
 /**
- * Processes parsed rebase entries into a flat list with type discriminators.
- * - Adds `type: 'commit' | 'command'` to each entry
- * - Attaches update-ref entries to their preceding commits
- * - Filters out structural label/reset entries (they're preserved in the raw file)
- * - Detects rebases with actual merge commits (reordering disabled but actions allowed)
- */
-export function processRebaseEntries(entries, done) {
-    // Only flag as preservesMerges if there are actual merge commands
-    // label/reset alone (no merge) means linear history that can be edited
-    const preservesMerges = hasActualMergeCommands(entries);
-    const result = [];
-    const commits = new Map();
-    // Track the last commit to attach update-refs to
-    let lastCommit;
-    for (const entry of entries) {
-        // Skip structural label/reset entries - they're preserved in the raw file
-        // but not shown in the UI (the UI only shows commits and command actions)
-        if (isStructuralEntry(entry))
-            continue;
-        if (isCommitEntry(entry)) {
-            const commitEntry = { ...entry, type: 'commit', id: entry.sha, done: done };
-            result.push(commitEntry);
-            commits.set(commitEntry.sha, commitEntry);
-            lastCommit = commitEntry;
-            continue;
-        }
-        if (isUpdateRefEntry(entry)) {
-            // Attach update-ref to the preceding commit (with line number for reordering)
-            if (lastCommit) {
-                lastCommit.updateRefs ??= [];
-                lastCommit.updateRefs.push({ ref: entry.ref, line: entry.line });
-            }
-            continue;
-        }
-        if (isCommandEntry(entry)) {
-            result.push({ ...entry, type: 'command', id: `${done ? 'done:' : ''}line:${entry.line}`, done: done });
-            continue;
-        }
-    }
-    return { entries: result, commits: commits, preservesMerges: preservesMerges };
+* Processes parsed rebase entries into a flat list with type discriminators.
+* - Adds `type: 'commit' | 'command'` to each entry
+* - Attaches update-ref entries to their preceding commits
+* - Filters out structural label/reset entries (they're preserved in the raw file)
+* - Detects rebases with actual merge commits (reordering disabled but actions allowed)
+*/
+function processRebaseEntries(entries, done) {
+	const preservesMerges = hasActualMergeCommands(entries);
+	const result = [];
+	const commits = /* @__PURE__ */ new Map();
+	let lastCommit;
+	for (const entry of entries) {
+		if (isStructuralEntry(entry)) continue;
+		if (isCommitEntry(entry)) {
+			const commitEntry = {
+				...entry,
+				type: "commit",
+				id: entry.sha,
+				done
+			};
+			result.push(commitEntry);
+			commits.set(commitEntry.sha, commitEntry);
+			lastCommit = commitEntry;
+			continue;
+		}
+		if (isUpdateRefEntry(entry)) {
+			if (lastCommit) {
+				lastCommit.updateRefs ??= [];
+				lastCommit.updateRefs.push({
+					ref: entry.ref,
+					line: entry.line
+				});
+			}
+			continue;
+		}
+		if (isCommandEntry(entry)) {
+			result.push({
+				...entry,
+				type: "command",
+				id: `${done ? "done:" : ""}line:${entry.line}`,
+				done
+			});
+			continue;
+		}
+	}
+	return {
+		entries: result,
+		commits,
+		preservesMerges
+	};
 }
+//#endregion
+export { commandRebaseActions, commitRebaseActions, formatRebaseTodoEntryLine, formatUpdateRefLine, mergesRebaseActions, processRebaseEntries };
+
 //# sourceMappingURL=rebase.utils.js.map

package/dist/git/utils/rebase.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"rebase.utils.js","sourceRoot":"","sources":["../../../src/git/utils/rebase.utils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"rebase.utils.js","names":[],"sources":["../../../../git/src/utils/rebase.utils.ts"],"sourcesContent":["import type { Mutable } from '@gitlens/utils/types.js';\nimport type {\n\tProcessedRebaseCommitEntry,\n\tProcessedRebaseEntry,\n\tProcessedRebaseTodo,\n\tRebaseTodoCommandAction,\n\tRebaseTodoCommitAction,\n\tRebaseTodoEntry,\n\tRebaseTodoMergesAction,\n} from '../models/rebase.js';\n\n/** Commit actions that have SHAs and are editable */\nexport const commitRebaseActions = new Set<RebaseTodoCommitAction>([\n\t'pick',\n\t'reword',\n\t'edit',\n\t'squash',\n\t'fixup',\n\t'drop',\n]);\n\n/** Command actions that are movable but not editable */\nexport const commandRebaseActions = new Set<RebaseTodoCommandAction>(['exec', 'break', 'noop']);\n\n/** Actions that indicate --rebase-merges mode */\nexport const mergesRebaseActions = new Set<RebaseTodoMergesAction>(['label', 'reset', 'merge']);\n\nexport function formatRebaseTodoEntryLine(entry: ProcessedRebaseEntry, overrideAction?: string): string {\n\tconst action = overrideAction ?? entry.action;\n\tif (entry.type === 'commit') {\n\t\tconst flagPart = entry.flag ? ` ${entry.flag}` : '';\n\t\treturn `${action}${flagPart} ${entry.sha} # ${entry.message}`;\n\t}\n\n\t// Command entries (exec, break, noop)\n\tif (entry.action === 'exec') {\n\t\treturn `exec${entry.command ? ` ${entry.command}` : ''}`;\n\t}\n\treturn entry.action; // break, noop\n}\n\n/** Formats an update-ref line for output */\nexport function formatUpdateRefLine(ref: string): string {\n\treturn `update-ref ${ref}`;\n}\n\n/** Checks if an entry is a commit-based action */\ntype RebaseTodoCommitEntry = RebaseTodoEntry<RebaseTodoCommitAction> & { sha: string; message: string };\nfunction isCommitEntry(entry: RebaseTodoEntry): entry is RebaseTodoCommitEntry {\n\treturn (\n\t\tentry.sha != null && entry.message != null && commitRebaseActions.has(entry.action as RebaseTodoCommitAction)\n\t);\n}\n\n/** Checks if an entry is a command action (exec/break/noop) */\ntype RebaseTodoCommandEntry = RebaseTodoEntry<RebaseTodoCommandAction> & { command: string };\nfunction isCommandEntry(entry: RebaseTodoEntry): entry is RebaseTodoCommandEntry {\n\treturn commandRebaseActions.has(entry.action as RebaseTodoCommandAction);\n}\n\n/**\n * Checks if this is a --rebase-merges rebase that actually has merge commits\n * Only actual 'merge' commands indicate a true DAG that cannot be safely reordered.\n * If just label/reset are present (no merge), the history is linear and editable.\n */\nfunction hasActualMergeCommands(entries: RebaseTodoEntry[]): boolean {\n\treturn entries.some(e => e.action === 'merge');\n}\n\n/** Checks if an entry is a structural label/reset command (filtered from UI) */\nfunction isStructuralEntry(entry: RebaseTodoEntry): boolean {\n\treturn entry.action === 'label' || entry.action === 'reset';\n}\n\n/** Checks if an entry is an update-ref action */\ntype RebaseTodoUpdateRefEntry = RebaseTodoEntry<'update-ref'> & { ref: string };\nfunction isUpdateRefEntry(entry: RebaseTodoEntry): entry is RebaseTodoUpdateRefEntry {\n\treturn entry.action === 'update-ref' && entry.ref != null;\n}\n\n/**\n * Processes parsed rebase entries into a flat list with type discriminators.\n * - Adds `type: 'commit' | 'command'` to each entry\n * - Attaches update-ref entries to their preceding commits\n * - Filters out structural label/reset entries (they're preserved in the raw file)\n * - Detects rebases with actual merge commits (reordering disabled but actions allowed)\n */\nexport function processRebaseEntries(entries: RebaseTodoEntry[], done?: boolean): ProcessedRebaseTodo {\n\t// Only flag as preservesMerges if there are actual merge commands\n\t// label/reset alone (no merge) means linear history that can be edited\n\tconst preservesMerges = hasActualMergeCommands(entries);\n\n\tconst result: ProcessedRebaseEntry[] = [];\n\tconst commits = new Map<string, ProcessedRebaseCommitEntry>();\n\n\t// Track the last commit to attach update-refs to\n\tlet lastCommit: ProcessedRebaseCommitEntry | undefined;\n\n\tfor (const entry of entries) {\n\t\t// Skip structural label/reset entries - they're preserved in the raw file\n\t\t// but not shown in the UI (the UI only shows commits and command actions)\n\t\tif (isStructuralEntry(entry)) continue;\n\n\t\tif (isCommitEntry(entry)) {\n\t\t\tconst commitEntry: ProcessedRebaseCommitEntry = { ...entry, type: 'commit', id: entry.sha, done: done };\n\t\t\tresult.push(commitEntry);\n\t\t\tcommits.set(commitEntry.sha, commitEntry);\n\t\t\tlastCommit = commitEntry;\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (isUpdateRefEntry(entry)) {\n\t\t\t// Attach update-ref to the preceding commit (with line number for reordering)\n\t\t\tif (lastCommit) {\n\t\t\t\t(lastCommit as Mutable<ProcessedRebaseCommitEntry>).updateRefs ??= [];\n\t\t\t\tlastCommit.updateRefs!.push({ ref: entry.ref, line: entry.line });\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (isCommandEntry(entry)) {\n\t\t\tresult.push({ ...entry, type: 'command', id: `${done ? 'done:' : ''}line:${entry.line}`, done: done });\n\t\t\tcontinue;\n\t\t}\n\t}\n\n\treturn { entries: result, commits: commits, preservesMerges: preservesMerges };\n}\n"],"mappings":";;AAYA,MAAa,sCAAsB,IAAI,IAA4B;CAClE;CACA;CACA;CACA;CACA;CACA;AACD,CAAC;;AAGD,MAAa,uCAAuB,IAAI,IAA6B;CAAC;CAAQ;CAAS;AAAM,CAAC;;AAG9F,MAAa,sCAAsB,IAAI,IAA4B;CAAC;CAAS;CAAS;AAAO,CAAC;AAE9F,SAAgB,0BAA0B,OAA6B,gBAAiC;CACvG,MAAM,SAAS,kBAAkB,MAAM;CACvC,IAAI,MAAM,SAAS,UAElB,OAAO,GAAG,SADO,MAAM,OAAO,IAAI,MAAM,SAAS,GACrB,GAAG,MAAM,IAAI,KAAK,MAAM;CAIrD,IAAI,MAAM,WAAW,QACpB,OAAO,OAAO,MAAM,UAAU,IAAI,MAAM,YAAY;CAErD,OAAO,MAAM;AACd;;AAGA,SAAgB,oBAAoB,KAAqB;CACxD,OAAO,cAAc;AACtB;AAIA,SAAS,cAAc,OAAwD;CAC9E,OACC,MAAM,OAAO,QAAQ,MAAM,WAAW,QAAQ,oBAAoB,IAAI,MAAM,MAAgC;AAE9G;AAIA,SAAS,eAAe,OAAyD;CAChF,OAAO,qBAAqB,IAAI,MAAM,MAAiC;AACxE;;;;;;AAOA,SAAS,uBAAuB,SAAqC;CACpE,OAAO,QAAQ,MAAK,MAAK,EAAE,WAAW,OAAO;AAC9C;;AAGA,SAAS,kBAAkB,OAAiC;CAC3D,OAAO,MAAM,WAAW,WAAW,MAAM,WAAW;AACrD;AAIA,SAAS,iBAAiB,OAA2D;CACpF,OAAO,MAAM,WAAW,gBAAgB,MAAM,OAAO;AACtD;;;;;;;;AASA,SAAgB,qBAAqB,SAA4B,MAAqC;CAGrG,MAAM,kBAAkB,uBAAuB,OAAO;CAEtD,MAAM,SAAiC,CAAC;CACxC,MAAM,0BAAU,IAAI,IAAwC;CAG5D,IAAI;CAEJ,KAAK,MAAM,SAAS,SAAS;EAG5B,IAAI,kBAAkB,KAAK,GAAG;EAE9B,IAAI,cAAc,KAAK,GAAG;GACzB,MAAM,cAA0C;IAAE,GAAG;IAAO,MAAM;IAAU,IAAI,MAAM;IAAW;GAAK;GACtG,OAAO,KAAK,WAAW;GACvB,QAAQ,IAAI,YAAY,KAAK,WAAW;GACxC,aAAa;GACb;EACD;EAEA,IAAI,iBAAiB,KAAK,GAAG;GAE5B,IAAI,YAAY;IACf,WAAoD,eAAe,CAAC;IACpE,WAAW,WAAY,KAAK;KAAE,KAAK,MAAM;KAAK,MAAM,MAAM;IAAK,CAAC;GACjE;GACA;EACD;EAEA,IAAI,eAAe,KAAK,GAAG;GAC1B,OAAO,KAAK;IAAE,GAAG;IAAO,MAAM;IAAW,IAAI,GAAG,OAAO,UAAU,GAAG,OAAO,MAAM;IAAc;GAAK,CAAC;GACrG;EACD;CACD;CAEA,OAAO;EAAE,SAAS;EAAiB;EAA0B;CAAgB;AAC9E"}