@comate/zulu 0.2.1-beta.2 → 0.2.2

package/comate-engine/node_modules/better-sqlite3/node_modules/.bin/prebuild-install

@@ -6,9 +6,9 @@ case `uname` in
 esac
 
 if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/Users/bear/baidu/ide/comate-plugin-host/node_modules/.pnpm/prebuild-install@7.1.2/node_modules/prebuild-install/node_modules:/Users/bear/baidu/ide/comate-plugin-host/node_modules/.pnpm/prebuild-install@7.1.2/node_modules:/Users/bear/baidu/ide/comate-plugin-host/node_modules/.pnpm/node_modules"
+  export NODE_PATH="/Users/bear/baidu/ide/comate-plugin-host-copy/node_modules/.pnpm/prebuild-install@7.1.2/node_modules/prebuild-install/node_modules:/Users/bear/baidu/ide/comate-plugin-host-copy/node_modules/.pnpm/prebuild-install@7.1.2/node_modules:/Users/bear/baidu/ide/comate-plugin-host-copy/node_modules/.pnpm/node_modules"
 else
-  export NODE_PATH="/Users/bear/baidu/ide/comate-plugin-host/node_modules/.pnpm/prebuild-install@7.1.2/node_modules/prebuild-install/node_modules:/Users/bear/baidu/ide/comate-plugin-host/node_modules/.pnpm/prebuild-install@7.1.2/node_modules:/Users/bear/baidu/ide/comate-plugin-host/node_modules/.pnpm/node_modules:$NODE_PATH"
+  export NODE_PATH="/Users/bear/baidu/ide/comate-plugin-host-copy/node_modules/.pnpm/prebuild-install@7.1.2/node_modules/prebuild-install/node_modules:/Users/bear/baidu/ide/comate-plugin-host-copy/node_modules/.pnpm/prebuild-install@7.1.2/node_modules:/Users/bear/baidu/ide/comate-plugin-host-copy/node_modules/.pnpm/node_modules:$NODE_PATH"
 fi
 if [ -x "$basedir/node" ]; then
   exec "$basedir/node"  "$basedir/../../../../../prebuild-install@7.1.2/node_modules/prebuild-install/bin.js" "$@"

package/comate-engine/plugins/demo-feature/dist/index.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from 'node:url';
 import require$$0$4, { dirname } from 'path';
 import path$p from 'node:path';
 import 'node:fs/promises';
-import fs$s from 'node:fs';
+import 'node:fs';
 import require$$0$1 from 'constants';
 import stream$5, { Readable } from 'stream';
 import require$$0$3 from 'util';
@@ -17,7 +17,7 @@ import crypto from 'crypto';
 import require$$0$7 from 'tty';
 import zlib from 'zlib';
 import require$$0$8, { EventEmitter } from 'events';
-import os$2, { homedir } from 'node:os';
+import 'node:os';
 import 'node:process';
 import 'node:stream';
 import 'node:crypto';
@@ -3336,7 +3336,7 @@ const [isReadableStream, isRequest, isResponse, isHeaders] = ['ReadableStream',
  *
  * @returns {String} The String freed of excess whitespace
  */
-const trim = (str) => str.trim ?
+const trim$1 = (str) => str.trim ?
   str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
 
 /**
@@ -3829,7 +3829,7 @@ var utils$m = {
   forEach,
   merge: merge$1,
   extend,
-  trim,
+  trim: trim$1,
   stripBOM,
   inherits,
   toFlatObject,
@@ -22021,35 +22021,11 @@ var WEBVIEW_CONSUMER;
     WEBVIEW_CONSUMER["JETBRAINS"] = "jetbrains";
 })(WEBVIEW_CONSUMER || (WEBVIEW_CONSUMER = {}));
 
-const COMATE = 'Comate';
-function getUserDataPathForEditor() {
-    const productName = COMATE;
-    switch(os$2.platform()){
-        case 'win32':
-            return path$p.join(homedir(), 'AppData', 'Roaming', productName, 'User');
-        case 'darwin':
-            return path$p.join(homedir(), 'Library', 'Application Support', productName, 'User');
-        default:
-            return path$p.join(homedir(), '.config', productName, 'User');
-    }
-}
 const SAAS_API_HOST = 'https://comate.baidu.com';
 const INTERNAL_API_HOST = 'https://comate.baidu-int.com';
 const SAAS_TEST_API_HOST = 'https://comate-cop.now.baidu.com';
 const INTERNAL_TEST_API_HOST = 'https://comate-test.now.baidu.com';
-const loginMode = (()=>{
-    try {
-        if (process.env.IDE === 'ide') {
-            const file = path$p.join(getUserDataPathForEditor(), 'loginMode.json');
-            return JSON.parse(fs$s.readFileSync(file, 'utf8'));
-        }
-        return {};
-    } catch (e) {
-        return {};
-    }
-})();
-const isUuapLoginUser = loginMode.loginMode === 'uuap';
-let platform = process.env.IDE === 'ide' && isUuapLoginUser ? PLATFORM.INTERNAL : process.env.PLATFORM || PLATFORM.INTERNAL;
+let platform = process.env.PLATFORM || PLATFORM.INTERNAL;
 let environment = process.env.ENVIRONMENT || ENVIRONMENT.PRODUCTION;
 let displayLanguage = process.env.DISPLAY_LANGUAGE || 'zh';
 let acceptLanguage = process.env.ACCEPT_LANGUAGE || 'zh-CN,zh';
@@ -22116,7 +22092,6 @@ function parseProxyUrl(proxyUrl) {
         return defaults;
     }
 }
-platform === PLATFORM.SAAS ? SAAS_API_HOST : INTERNAL_API_HOST;
 const config = {
 };
 const proxyURL = process.env.HTTP_PROXY_URL || '';
@@ -51671,6 +51646,338 @@ var VirtualDocumentAction;
     VirtualDocumentAction["PREVIEW"] = "preview";
 })(VirtualDocumentAction || (VirtualDocumentAction = {}));
 
+class Diff {
+    diff(oldStr, newStr, 
+    // Type below is not accurate/complete - see above for full possibilities - but it compiles
+    options = {}) {
+        let callback;
+        if (typeof options === 'function') {
+            callback = options;
+            options = {};
+        }
+        else if ('callback' in options) {
+            callback = options.callback;
+        }
+        // Allow subclasses to massage the input prior to running
+        const oldString = this.castInput(oldStr, options);
+        const newString = this.castInput(newStr, options);
+        const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+        const newTokens = this.removeEmpty(this.tokenize(newString, options));
+        return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+    }
+    diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+        var _a;
+        const done = (value) => {
+            value = this.postProcess(value, options);
+            if (callback) {
+                setTimeout(function () { callback(value); }, 0);
+                return undefined;
+            }
+            else {
+                return value;
+            }
+        };
+        const newLen = newTokens.length, oldLen = oldTokens.length;
+        let editLength = 1;
+        let maxEditLength = newLen + oldLen;
+        if (options.maxEditLength != null) {
+            maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+        }
+        const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+        const abortAfterTimestamp = Date.now() + maxExecutionTime;
+        const bestPath = [{ oldPos: -1, lastComponent: undefined }];
+        // Seed editLength = 0, i.e. the content starts with the same values
+        let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+        if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+            // Identity per the equality and tokenizer
+            return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+        }
+        // Once we hit the right edge of the edit graph on some diagonal k, we can
+        // definitely reach the end of the edit graph in no more than k edits, so
+        // there's no point in considering any moves to diagonal k+1 any more (from
+        // which we're guaranteed to need at least k+1 more edits).
+        // Similarly, once we've reached the bottom of the edit graph, there's no
+        // point considering moves to lower diagonals.
+        // We record this fact by setting minDiagonalToConsider and
+        // maxDiagonalToConsider to some finite value once we've hit the edge of
+        // the edit graph.
+        // This optimization is not faithful to the original algorithm presented in
+        // Myers's paper, which instead pointlessly extends D-paths off the end of
+        // the edit graph - see page 7 of Myers's paper which notes this point
+        // explicitly and illustrates it with a diagram. This has major performance
+        // implications for some common scenarios. For instance, to compute a diff
+        // where the new text simply appends d characters on the end of the
+        // original text of length n, the true Myers algorithm will take O(n+d^2)
+        // time while this optimization needs only O(n+d) time.
+        let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+        // Main worker method. checks all permutations of a given edit length for acceptance.
+        const execEditLength = () => {
+            for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+                let basePath;
+                const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+                if (removePath) {
+                    // No one else is going to attempt to use this value, clear it
+                    // @ts-expect-error - perf optimisation. This type-violating value will never be read.
+                    bestPath[diagonalPath - 1] = undefined;
+                }
+                let canAdd = false;
+                if (addPath) {
+                    // what newPos will be after we do an insertion:
+                    const addPathNewPos = addPath.oldPos - diagonalPath;
+                    canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+                }
+                const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+                if (!canAdd && !canRemove) {
+                    // If this path is a terminal then prune
+                    // @ts-expect-error - perf optimisation. This type-violating value will never be read.
+                    bestPath[diagonalPath] = undefined;
+                    continue;
+                }
+                // Select the diagonal that we want to branch from. We select the prior
+                // path whose position in the old string is the farthest from the origin
+                // and does not pass the bounds of the diff graph
+                if (!canRemove || (canAdd && removePath.oldPos < addPath.oldPos)) {
+                    basePath = this.addToPath(addPath, true, false, 0, options);
+                }
+                else {
+                    basePath = this.addToPath(removePath, false, true, 1, options);
+                }
+                newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+                if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+                    // If we have hit the end of both strings, then we are done
+                    return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+                }
+                else {
+                    bestPath[diagonalPath] = basePath;
+                    if (basePath.oldPos + 1 >= oldLen) {
+                        maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+                    }
+                    if (newPos + 1 >= newLen) {
+                        minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+                    }
+                }
+            }
+            editLength++;
+        };
+        // Performs the length of edit iteration. Is a bit fugly as this has to support the
+        // sync and async mode which is never fun. Loops over execEditLength until a value
+        // is produced, or until the edit length exceeds options.maxEditLength (if given),
+        // in which case it will return undefined.
+        if (callback) {
+            (function exec() {
+                setTimeout(function () {
+                    if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+                        return callback(undefined);
+                    }
+                    if (!execEditLength()) {
+                        exec();
+                    }
+                }, 0);
+            }());
+        }
+        else {
+            while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+                const ret = execEditLength();
+                if (ret) {
+                    return ret;
+                }
+            }
+        }
+    }
+    addToPath(path, added, removed, oldPosInc, options) {
+        const last = path.lastComponent;
+        if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+            return {
+                oldPos: path.oldPos + oldPosInc,
+                lastComponent: { count: last.count + 1, added: added, removed: removed, previousComponent: last.previousComponent }
+            };
+        }
+        else {
+            return {
+                oldPos: path.oldPos + oldPosInc,
+                lastComponent: { count: 1, added: added, removed: removed, previousComponent: last }
+            };
+        }
+    }
+    extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+        const newLen = newTokens.length, oldLen = oldTokens.length;
+        let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+        while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+            newPos++;
+            oldPos++;
+            commonCount++;
+            if (options.oneChangePerToken) {
+                basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+            }
+        }
+        if (commonCount && !options.oneChangePerToken) {
+            basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+        }
+        basePath.oldPos = oldPos;
+        return newPos;
+    }
+    equals(left, right, options) {
+        if (options.comparator) {
+            return options.comparator(left, right);
+        }
+        else {
+            return left === right
+                || (!!options.ignoreCase && left.toLowerCase() === right.toLowerCase());
+        }
+    }
+    removeEmpty(array) {
+        const ret = [];
+        for (let i = 0; i < array.length; i++) {
+            if (array[i]) {
+                ret.push(array[i]);
+            }
+        }
+        return ret;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    castInput(value, options) {
+        return value;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    tokenize(value, options) {
+        return Array.from(value);
+    }
+    join(chars) {
+        // Assumes ValueT is string, which is the case for most subclasses.
+        // When it's false, e.g. in diffArrays, this method needs to be overridden (e.g. with a no-op)
+        // Yes, the casts are verbose and ugly, because this pattern - of having the base class SORT OF
+        // assume tokens and values are strings, but not completely - is weird and janky.
+        return chars.join('');
+    }
+    postProcess(changeObjects, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    options) {
+        return changeObjects;
+    }
+    get useLongestToken() {
+        return false;
+    }
+    buildValues(lastComponent, newTokens, oldTokens) {
+        // First we convert our linked list of components in reverse order to an
+        // array in the right order:
+        const components = [];
+        let nextComponent;
+        while (lastComponent) {
+            components.push(lastComponent);
+            nextComponent = lastComponent.previousComponent;
+            delete lastComponent.previousComponent;
+            lastComponent = nextComponent;
+        }
+        components.reverse();
+        const componentLen = components.length;
+        let componentPos = 0, newPos = 0, oldPos = 0;
+        for (; componentPos < componentLen; componentPos++) {
+            const component = components[componentPos];
+            if (!component.removed) {
+                if (!component.added && this.useLongestToken) {
+                    let value = newTokens.slice(newPos, newPos + component.count);
+                    value = value.map(function (value, i) {
+                        const oldValue = oldTokens[oldPos + i];
+                        return oldValue.length > value.length ? oldValue : value;
+                    });
+                    component.value = this.join(value);
+                }
+                else {
+                    component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+                }
+                newPos += component.count;
+                // Common case
+                if (!component.added) {
+                    oldPos += component.count;
+                }
+            }
+            else {
+                component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+                oldPos += component.count;
+            }
+        }
+        return components;
+    }
+}
+
+let LineDiff$1 = class LineDiff extends Diff {
+    constructor() {
+        super(...arguments);
+        this.tokenize = tokenize;
+    }
+    equals(left, right, options) {
+        // If we're ignoring whitespace, we need to normalise lines by stripping
+        // whitespace before checking equality. (This has an annoying interaction
+        // with newlineIsToken that requires special handling: if newlines get their
+        // own token, then we DON'T want to trim the *newline* tokens down to empty
+        // strings, since this would cause us to treat whitespace-only line content
+        // as equal to a separator between lines, which would be weird and
+        // inconsistent with the documented behavior of the options.)
+        if (options.ignoreWhitespace) {
+            if (!options.newlineIsToken || !left.includes('\n')) {
+                left = left.trim();
+            }
+            if (!options.newlineIsToken || !right.includes('\n')) {
+                right = right.trim();
+            }
+        }
+        else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+            if (left.endsWith('\n')) {
+                left = left.slice(0, -1);
+            }
+            if (right.endsWith('\n')) {
+                right = right.slice(0, -1);
+            }
+        }
+        return super.equals(left, right, options);
+    }
+};
+new LineDiff$1();
+// Exported standalone so it can be used from jsonDiff too.
+function tokenize(value, options) {
+    if (options.stripTrailingCr) {
+        // remove one \r before \n to match GNU diff's --strip-trailing-cr behavior
+        value = value.replace(/\r\n/g, '\n');
+    }
+    const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+    // Ignore the final empty token that occurs if the string ends with a new line
+    if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+        linesAndNewlines.pop();
+    }
+    // Merge the content and line separators into single tokens
+    for (let i = 0; i < linesAndNewlines.length; i++) {
+        const line = linesAndNewlines[i];
+        if (i % 2 && !options.newlineIsToken) {
+            retLines[retLines.length - 1] += line;
+        }
+        else {
+            retLines.push(line);
+        }
+    }
+    return retLines;
+}
+
+const trim = (str)=>str.replace(/\s|\t/g, '').replace(/[;|,]$/, '').toLowerCase();
+const roughEqual = (left, right)=>trim(left) === trim(right);
+class LineDiff extends Diff {
+    constructor(){
+        super();
+        this.tokenize = tokenize;
+    }
+    equals(left, right, options) {
+        const equal = super.equals(left, right, options);
+        if (!equal) {
+            if (left.length > 12 && right.length > 12) {
+                // 去除所有行间的空格和制表符，再比较
+                // 去除尾巴的分号和逗号
+                return roughEqual(left, right);
+            }
+        }
+        return equal;
+    }
+}
+new LineDiff();
+
 var TOKEN = '';
 var mult = 0x100000000; // Math.pow(16, 8);
 for (var i = 0; i < 4; i++) {