@vincenthanxiaodu/pi-web 1.202608.1

package/dist/pi-web-plugins/git/browser/gitFileTree.js

@@ -0,0 +1,81 @@
+// Generated from pi-web-plugins/git/browser/gitFileTree.ts. Do not edit directly.
+import { pointerName, segmentName } from "./gitFileShared.js";
+/**
+ * Build a nested directory/file tree from Git's flat changed-file list. The
+ * status response already carries every changed path, so this is a pure
+ * client-side transform (no lazy per-directory loading like the Files tab).
+ *
+ * `submodules` lists submodule roots: a directory matching one is marked as a
+ * submodule, a file whose path equals one becomes that submodule's pinned
+ * commit-pointer row, and files below one nest inside it. Directories sort
+ * before files (pointer row first within a submodule), both alphabetically.
+ */
+export function buildGitFileTree(files, submodules = []) {
+    const root = createDirectoryAccumulator("");
+    const submoduleSet = new Set(submodules);
+    // Ensure a node exists (and is marked) for every submodule, so a submodule
+    // whose only change is a moved pointer still renders as an expandable root.
+    for (const submodule of submodules)
+        ensureDirectory(root, submodule).isSubmodule = true;
+    for (const file of files) {
+        if (submoduleSet.has(file.path)) {
+            const directory = ensureDirectory(root, file.path);
+            directory.isSubmodule = true;
+            directory.pointer = { kind: "file", name: pointerName(file), path: file.path, file, isSubmodulePointer: true };
+            continue;
+        }
+        const segments = file.path.split("/").filter((segment) => segment.length > 0);
+        const name = segments[segments.length - 1];
+        if (name === undefined)
+            continue;
+        let directory = root;
+        for (let index = 0; index < segments.length - 1; index += 1) {
+            const segment = segments[index];
+            if (segment === undefined)
+                continue;
+            directory = childDirectory(directory, segment);
+        }
+        directory.files.push({ kind: "file", name, path: file.path, file });
+    }
+    return finalizeChildren(root);
+}
+/**
+ * Every directory path in the tree, in a stable order. Used to drive the
+ * expand-all / collapse-all control and to decide whether the tree is fully
+ * expanded. Submodule roots are directories and are included.
+ */
+export function collectGitFileTreeDirectoryPaths(nodes) {
+    const paths = [];
+    for (const node of nodes) {
+        if (node.kind === "directory") {
+            paths.push(node.path);
+            paths.push(...collectGitFileTreeDirectoryPaths(node.children));
+        }
+    }
+    return paths;
+}
+function createDirectoryAccumulator(path) {
+    return { path, directories: new Map(), files: [], isSubmodule: false };
+}
+function childDirectory(parent, segment) {
+    const childPath = parent.path.length === 0 ? segment : `${parent.path}/${segment}`;
+    const existing = parent.directories.get(childPath);
+    if (existing !== undefined)
+        return existing;
+    const created = createDirectoryAccumulator(childPath);
+    parent.directories.set(childPath, created);
+    return created;
+}
+function ensureDirectory(root, path) {
+    let directory = root;
+    for (const segment of path.split("/").filter((part) => part.length > 0))
+        directory = childDirectory(directory, segment);
+    return directory;
+}
+function finalizeChildren(directory) {
+    const directories = [...directory.directories.values()]
+        .map((child) => ({ kind: "directory", name: segmentName(child.path), path: child.path, ...(child.isSubmodule ? { isSubmodule: true } : {}), children: finalizeChildren(child) }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+    const files = [...directory.files].sort((left, right) => left.name.localeCompare(right.name));
+    return [...(directory.pointer === undefined ? [] : [directory.pointer]), ...directories, ...files];
+}

package/dist/pi-web-plugins/git/browser/gitFileViewPreference.js

@@ -0,0 +1,35 @@
+// Generated from pi-web-plugins/git/browser/gitFileViewPreference.ts. Do not edit directly.
+export const GIT_FILE_VIEW_STORAGE_KEY = "pi-web.gitFileView";
+export function parseGitFileView(value) {
+    return value === "tree" ? "tree" : "list";
+}
+export function readGitFileView(storage = browserStorage()) {
+    if (storage === undefined)
+        return "list";
+    try {
+        return parseGitFileView(storage.getItem(GIT_FILE_VIEW_STORAGE_KEY));
+    }
+    catch {
+        return "list";
+    }
+}
+export function writeGitFileView(view, storage = browserStorage()) {
+    if (storage === undefined)
+        return;
+    try {
+        storage.setItem(GIT_FILE_VIEW_STORAGE_KEY, view);
+    }
+    catch {
+        // Ignore localStorage quota/privacy errors; the chosen view still applies in memory for this tab.
+    }
+}
+function browserStorage() {
+    if (typeof window === "undefined")
+        return undefined;
+    try {
+        return window.localStorage;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/pi-web-plugins/git/browser/gitRoute.js

@@ -0,0 +1,42 @@
+// Generated from pi-web-plugins/git/browser/gitRoute.ts. Do not edit directly.
+const legacyDiffNamespace = "core.workspace.git";
+const diffQueryKey = "diff";
+export function createGitDiffRoute(panelContributionId) {
+    const namespace = panelContributionId.replaceAll(":", ".");
+    const key = `${namespace}--${diffQueryKey}`;
+    const legacyKey = `${legacyDiffNamespace}--${diffQueryKey}`;
+    return {
+        matches: routeMatchesWorkspace,
+        read: () => {
+            const params = new URLSearchParams(window.location.search);
+            return nonEmpty(params.get(key)) ?? nonEmpty(params.get(legacyKey));
+        },
+        write: (path, options) => {
+            const url = new URL(window.location.href);
+            url.searchParams.delete(key);
+            url.searchParams.delete(legacyKey);
+            if (path !== undefined && path !== "")
+                url.searchParams.set(key, path);
+            commitUrl(url, options?.replace === true);
+        },
+    };
+}
+function routeMatchesWorkspace(context) {
+    const params = new URLSearchParams(window.location.search);
+    return (params.get("machine") ?? "local") === context.machine.id
+        && params.get("project") === context.workspace.projectId
+        && params.get("workspace") === context.workspace.id;
+}
+function nonEmpty(value) {
+    return value === null || value === "" ? undefined : value;
+}
+function commitUrl(url, replace) {
+    const next = `${url.pathname}${url.search}${url.hash}`;
+    const current = `${window.location.pathname}${window.location.search}${window.location.hash}`;
+    if (next === current)
+        return;
+    if (replace)
+        window.history.replaceState({}, "", url);
+    else
+        window.history.pushState({}, "", url);
+}

package/dist/pi-web-plugins/git/browser/pi-web-plugin.js

@@ -0,0 +1,10 @@
+// Generated from pi-web-plugins/git/browser/pi-web-plugin.ts. Do not edit directly.
+import { createGitBrowserContributions } from "./git-panel.js";
+const plugin = {
+    apiVersion: 2,
+    name: "Git",
+    activate: ({ pluginId, runtimePluginId, html, svg }) => ({
+        contributions: createGitBrowserContributions(pluginId, runtimePluginId, html, svg),
+    }),
+};
+export default plugin;

package/dist/pi-web-plugins/git/browser/unifiedDiff.js

@@ -0,0 +1,301 @@
+// Generated from pi-web-plugins/git/browser/unifiedDiff.ts. Do not edit directly.
+const hunkHeaderPattern = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+const maxInlineLineLength = 5_000;
+const maxInlineBlockLines = 20;
+const minInlineSimilarity = 0.20;
+const minPairSimilarity = 0.25;
+const maxInlineMatrixCells = 250_000;
+const graphemeSegmenter = typeof Intl.Segmenter === "function"
+    ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
+    : undefined;
+export function parseUnifiedDiff(diff) {
+    const parsedLines = parseUnifiedDiffLines(diff);
+    applyInlineDiffs(parsedLines);
+    return parsedLines;
+}
+function parseUnifiedDiffLines(diff) {
+    const lines = splitDiffLines(diff);
+    const parsedLines = [];
+    let oldLineNumber;
+    let newLineNumber;
+    for (const rawLine of lines) {
+        const hunkMatch = hunkHeaderPattern.exec(rawLine);
+        if (hunkMatch !== null) {
+            oldLineNumber = Number(hunkMatch[1]);
+            newLineNumber = Number(hunkMatch[2]);
+            parsedLines.push(line("hunk", "", rawLine));
+            continue;
+        }
+        if (oldLineNumber !== undefined && newLineNumber !== undefined) {
+            if (rawLine.startsWith("+")) {
+                parsedLines.push(line("add", "+", rawLine.slice(1), { newLineNumber }));
+                newLineNumber++;
+                continue;
+            }
+            if (rawLine.startsWith("-")) {
+                parsedLines.push(line("remove", "-", rawLine.slice(1), { oldLineNumber }));
+                oldLineNumber++;
+                continue;
+            }
+            if (rawLine.startsWith(" ")) {
+                parsedLines.push(line("context", " ", rawLine.slice(1), { oldLineNumber, newLineNumber }));
+                oldLineNumber++;
+                newLineNumber++;
+                continue;
+            }
+            if (rawLine.startsWith("\\")) {
+                parsedLines.push(line("marker", "", rawLine));
+                continue;
+            }
+        }
+        oldLineNumber = undefined;
+        newLineNumber = undefined;
+        parsedLines.push(line("meta", "", rawLine));
+    }
+    return parsedLines;
+}
+function splitDiffLines(diff) {
+    if (diff === "")
+        return [];
+    const lines = diff.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+    if (lines.at(-1) === "")
+        lines.pop();
+    return lines;
+}
+function line(kind, prefix, text, numbers = {}) {
+    return {
+        kind,
+        prefix,
+        text,
+        spans: text === "" ? [] : [{ text, changed: false }],
+        ...numbers,
+    };
+}
+function applyInlineDiffs(lines) {
+    let index = 0;
+    while (index < lines.length) {
+        const current = lines[index];
+        if (current?.kind !== "remove") {
+            index++;
+            continue;
+        }
+        const removedStart = index;
+        while (lines[index]?.kind === "remove")
+            index++;
+        const addedStart = index;
+        while (lines[index]?.kind === "add")
+            index++;
+        if (addedStart === index)
+            continue;
+        const removedLines = lines.slice(removedStart, addedStart);
+        const addedLines = lines.slice(addedStart, index);
+        applyInlineDiffBlock(removedLines, addedLines);
+    }
+}
+function applyInlineDiffBlock(removedLines, addedLines) {
+    if (removedLines.length + addedLines.length > maxInlineBlockLines)
+        return;
+    for (const pair of pairChangedLines(removedLines, addedLines)) {
+        const inlineDiff = computeInlineDiff(pair.removed.text, pair.added.text);
+        if (inlineDiff === undefined)
+            continue;
+        pair.removed.spans = inlineDiff.removed;
+        pair.added.spans = inlineDiff.added;
+    }
+}
+function pairChangedLines(removedLines, addedLines) {
+    if (removedLines.length === addedLines.length)
+        return removedLines.map((removed, index) => ({ removed, added: addedLines[index] })).filter(isCompletePair);
+    if (removedLines.length === 1)
+        return bestPairsForSingleRemovedLine(removedLines[0], addedLines);
+    if (addedLines.length === 1)
+        return bestPairsForSingleAddedLine(removedLines, addedLines[0]);
+    const pairs = [];
+    const pairCount = Math.min(removedLines.length, addedLines.length);
+    for (let index = 0; index < pairCount; index++) {
+        const removed = removedLines[index];
+        const added = addedLines[index];
+        if (removed === undefined || added === undefined)
+            continue;
+        if (lineSimilarity(removed.text, added.text) >= minPairSimilarity)
+            pairs.push({ removed, added });
+    }
+    return pairs;
+}
+function isCompletePair(pair) {
+    return pair.added !== undefined;
+}
+function bestPairsForSingleRemovedLine(removed, addedLines) {
+    if (removed === undefined)
+        return [];
+    const added = bestMatchingLine(removed.text, addedLines);
+    return added === undefined ? [] : [{ removed, added }];
+}
+function bestPairsForSingleAddedLine(removedLines, added) {
+    if (added === undefined)
+        return [];
+    const removed = bestMatchingLine(added.text, removedLines);
+    return removed === undefined ? [] : [{ removed, added }];
+}
+function bestMatchingLine(text, candidates) {
+    let bestCandidate;
+    let bestScore = minPairSimilarity;
+    for (const candidate of candidates) {
+        const score = lineSimilarity(text, candidate.text);
+        if (score <= bestScore)
+            continue;
+        bestCandidate = candidate;
+        bestScore = score;
+    }
+    return bestCandidate;
+}
+function computeInlineDiff(oldText, newText) {
+    if (oldText === newText)
+        return undefined;
+    if (oldText.length > maxInlineLineLength || newText.length > maxInlineLineLength)
+        return undefined;
+    const oldUnits = splitTextUnits(oldText);
+    const newUnits = splitTextUnits(newText);
+    if (oldUnits.length > maxInlineLineLength || newUnits.length > maxInlineLineLength)
+        return undefined;
+    const changes = diffTextUnits(oldUnits, newUnits);
+    const similarity = similarityFromChanges(changes, oldUnits.length, newUnits.length);
+    if (Math.max(oldUnits.length, newUnits.length) >= 20 && similarity < minInlineSimilarity)
+        return undefined;
+    const removed = [];
+    const added = [];
+    for (const change of changes) {
+        if (change.value === "")
+            continue;
+        if (change.added === true)
+            added.push({ text: change.value, changed: true });
+        else if (change.removed === true)
+            removed.push({ text: change.value, changed: true });
+        else {
+            removed.push({ text: change.value, changed: false });
+            added.push({ text: change.value, changed: false });
+        }
+    }
+    if (!removed.some((span) => span.changed) && !added.some((span) => span.changed))
+        return undefined;
+    return { removed: mergeAdjacentSpans(removed), added: mergeAdjacentSpans(added) };
+}
+function lineSimilarity(oldText, newText) {
+    if (oldText === newText)
+        return 1;
+    if (oldText.length > maxInlineLineLength || newText.length > maxInlineLineLength)
+        return 0;
+    const oldUnits = splitTextUnits(oldText);
+    const newUnits = splitTextUnits(newText);
+    if (oldUnits.length > maxInlineLineLength || newUnits.length > maxInlineLineLength)
+        return 0;
+    return similarityFromChanges(diffTextUnits(oldUnits, newUnits), oldUnits.length, newUnits.length);
+}
+function similarityFromChanges(changes, oldLength, newLength) {
+    const maxLength = Math.max(oldLength, newLength);
+    if (maxLength === 0)
+        return 1;
+    const unchangedLength = changes.reduce((total, change) => change.added === true || change.removed === true ? total : total + change.unitCount, 0);
+    return unchangedLength / maxLength;
+}
+/**
+ * Grapheme-level diff for inline highlights. Browser plugins are served as
+ * native modules, so this package keeps the bounded algorithm local instead of
+ * depending on an application-bundled bare module. Large, dissimilar middles
+ * intentionally fall back to whole-span changes rather than doing unbounded
+ * quadratic work. The code-point fallback still never splits surrogate pairs.
+ */
+function diffTextUnits(oldText, newText) {
+    if (sameTextUnits(oldText, newText))
+        return oldText.length === 0 ? [] : [{ value: oldText.join(""), unitCount: oldText.length }];
+    let prefixLength = 0;
+    const sharedLength = Math.min(oldText.length, newText.length);
+    while (prefixLength < sharedLength && oldText[prefixLength] === newText[prefixLength])
+        prefixLength += 1;
+    let suffixLength = 0;
+    while (suffixLength < sharedLength - prefixLength
+        && oldText[oldText.length - suffixLength - 1] === newText[newText.length - suffixLength - 1])
+        suffixLength += 1;
+    const oldMiddle = oldText.slice(prefixLength, oldText.length - suffixLength);
+    const newMiddle = newText.slice(prefixLength, newText.length - suffixLength);
+    const changes = [];
+    appendCharacterChange(changes, oldText.slice(0, prefixLength));
+    if (oldMiddle.length * newMiddle.length > maxInlineMatrixCells) {
+        appendCharacterChange(changes, oldMiddle, "removed");
+        appendCharacterChange(changes, newMiddle, "added");
+    }
+    else {
+        for (const change of diffMiddleCharacters(oldMiddle, newMiddle))
+            appendCharacterChange(changes, splitTextUnits(change.value), change.added === true ? "added" : change.removed === true ? "removed" : undefined);
+    }
+    appendCharacterChange(changes, oldText.slice(oldText.length - suffixLength));
+    return changes;
+}
+function diffMiddleCharacters(oldText, newText) {
+    if (oldText.length === 0)
+        return newText.length === 0 ? [] : [{ value: newText.join(""), unitCount: newText.length, added: true }];
+    if (newText.length === 0)
+        return [{ value: oldText.join(""), unitCount: oldText.length, removed: true }];
+    const width = newText.length + 1;
+    const matrix = new Uint32Array((oldText.length + 1) * width);
+    for (let oldIndex = oldText.length - 1; oldIndex >= 0; oldIndex -= 1) {
+        for (let newIndex = newText.length - 1; newIndex >= 0; newIndex -= 1) {
+            const offset = oldIndex * width + newIndex;
+            matrix[offset] = oldText[oldIndex] === newText[newIndex]
+                ? (matrix[(oldIndex + 1) * width + newIndex + 1] ?? 0) + 1
+                : Math.max(matrix[(oldIndex + 1) * width + newIndex] ?? 0, matrix[oldIndex * width + newIndex + 1] ?? 0);
+        }
+    }
+    const changes = [];
+    let oldIndex = 0;
+    let newIndex = 0;
+    while (oldIndex < oldText.length || newIndex < newText.length) {
+        if (oldIndex < oldText.length && newIndex < newText.length && oldText[oldIndex] === newText[newIndex]) {
+            appendCharacterChange(changes, [oldText[oldIndex] ?? ""]);
+            oldIndex += 1;
+            newIndex += 1;
+        }
+        else if (newIndex >= newText.length || (oldIndex < oldText.length && (matrix[(oldIndex + 1) * width + newIndex] ?? 0) >= (matrix[oldIndex * width + newIndex + 1] ?? 0))) {
+            appendCharacterChange(changes, [oldText[oldIndex] ?? ""], "removed");
+            oldIndex += 1;
+        }
+        else {
+            appendCharacterChange(changes, [newText[newIndex] ?? ""], "added");
+            newIndex += 1;
+        }
+    }
+    return changes;
+}
+function appendCharacterChange(changes, units, kind) {
+    if (units.length === 0)
+        return;
+    const value = units.join("");
+    const previous = changes[changes.length - 1];
+    const added = kind === "added";
+    const removed = kind === "removed";
+    if (previous !== undefined && previous.added === (added || undefined) && previous.removed === (removed || undefined)) {
+        previous.value += value;
+        previous.unitCount += units.length;
+        return;
+    }
+    changes.push({ value, unitCount: units.length, ...(added ? { added: true } : {}), ...(removed ? { removed: true } : {}) });
+}
+function splitTextUnits(text) {
+    if (graphemeSegmenter === undefined)
+        return Array.from(text);
+    return Array.from(graphemeSegmenter.segment(text), ({ segment }) => segment);
+}
+function sameTextUnits(left, right) {
+    return left.length === right.length && left.every((unit, index) => unit === right[index]);
+}
+function mergeAdjacentSpans(spans) {
+    const merged = [];
+    for (const span of spans) {
+        const previous = merged[merged.length - 1];
+        if (previous?.changed === span.changed)
+            previous.text += span.text;
+        else
+            merged.push({ ...span });
+    }
+    return merged;
+}