pty-shell 1.0.5

package/dist/path_util.d.ts

@@ -0,0 +1,10 @@
+export declare function find_sep(path: any): string;
+/**
+ * windows 是 \ linux 是 /
+ * @param path
+ * @param filename
+ * @returns {*|string}
+ */
+export declare function path_join(path: any, filename: any): any;
+export declare function get_best_cmd(list: any): any;
+export declare function isAbsolutePath(path: any): boolean;

package/dist/path_util.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.find_sep = find_sep;
+exports.path_join = path_join;
+exports.get_best_cmd = get_best_cmd;
+exports.isAbsolutePath = isAbsolutePath;
+function get_extname(filePath) {
+    const lastDotIndex = filePath.lastIndexOf('.');
+    // 如果没有找到点或文件以点开头，则没有扩展名
+    if (lastDotIndex === -1 || lastDotIndex === 0) {
+        return '';
+    }
+    // 返回从最后一个点开始到字符串结尾的部分
+    return filePath.slice(lastDotIndex);
+}
+function find_sep(path) {
+    let sep = "\\";
+    for (const it of path) {
+        if (it === "/" || it === "\\") {
+            sep = it;
+            break;
+        }
+    }
+    return sep;
+}
+/**
+ * windows 是 \ linux 是 /
+ * @param path
+ * @param filename
+ * @returns {*|string}
+ */
+function path_join(path, filename) {
+    // 先找到系统上的分隔符是啥
+    let s_r = find_sep(path);
+    if (filename === '.') {
+        return path;
+    }
+    else if (filename === "..") {
+        if (path.length > 1) {
+            let ok = path[path.length - 1] === s_r ? 1 : 0;
+            for (let i = path.length - 1 - ok; i >= 0; i--) {
+                if (path[i] === s_r) {
+                    return path.substring(0, i + 1);
+                }
+            }
+        }
+        return path;
+    }
+    if (path.endsWith(s_r) && filename.startsWith(s_r)) {
+        // 前后都有 /
+        return path.slice(0, -1) + filename;
+    }
+    else if (!path.endsWith(s_r) && !filename.startsWith(s_r)) {
+        // 前后都没有 /
+        return path + s_r + filename;
+    }
+    else {
+        return path + filename;
+    }
+}
+const exec_map = {
+    ".com": 4, // 越大优先
+    ".exe": 3,
+    ".bat": 2,
+    ".cmd": 1
+};
+// 获取最合适的命令 list 都是字符串内容
+function get_best_cmd(list) {
+    if (!list)
+        return;
+    let ok;
+    let ok_p = 0;
+    for (const item of list) {
+        const v = exec_map[get_extname(item)];
+        if (v !== undefined && v > ok_p) {
+            ok = item;
+            ok_p = v;
+        }
+    }
+    if (ok === undefined) {
+        // 选出一个最短的
+        for (const item of list) {
+            if (item.length > ok_p) {
+                ok = item;
+                ok_p = item.length;
+            }
+        }
+    }
+    return ok;
+}
+function isAbsolutePath(path) {
+    if (typeof path !== 'string') {
+        return false;
+    }
+    // 检查是否为 Windows 绝对路径，以盘符（如 C:）开头
+    const windowsRegex = /^[a-zA-Z]:[\\\/]/;
+    // 检查是否为 Unix/Linux 绝对路径，以斜杠 / 开头
+    const unixRegex = /^\//;
+    return windowsRegex.test(path) || unixRegex.test(path);
+}
+// console.log(get_best_cmd(['ab','ab.bat','ab.exe']))

package/dist/word_detection_js.d.ts

@@ -0,0 +1,21 @@
+export declare class word_detection_js {
+    root: any;
+    size: any;
+    constructor();
+    add(str: any): void;
+    clear(): void;
+    /**
+     * 在完全匹配的基础之上（不是尽可能） 再额外添加一个字符 获取这个额外添加的字符的所有更多尽可能的可能性
+     * @param word
+     * @param extra_word_char 在匹配自己的前提下 获取以此 往前多一个分叉的所有子分叉 （比如 cmd 使用 . 获取 cmd.exe cmd.bat 等)
+     */
+    detection_next_list_word(word: any, extra_word_char: any): any[];
+    /**
+     * 会  ”尽可能“  的往前匹配更多更匹配的 "唯一" 单词(有分叉就停止检索)
+     * 如果和原本的输入一样就不返回了
+     * @param word 单词 而不是被检测的文本
+     * @param prefer_char 如果有这种情况 遇上分叉了 但是提供一个可选项，使用这个如果可以继续往前获取唯一的单词就继续往前
+     * @return str or undefined
+     */
+    detection_next_one_word(word: any, prefer_char?: any): any;
+}

package/dist/word_detection_js.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.word_detection_js = void 0;
+class Node {
+    constructor() {
+        this.children = new Map();
+        this.char = "";
+        this.is_end = false;
+    }
+}
+class word_detection_js {
+    constructor() {
+        this.root = new Node(); // 根节点的字符是空的
+        this.size = 0;
+    }
+    add(str) {
+        if (!str) {
+            return;
+        }
+        str = str.trim();
+        let node = this.root;
+        for (const char of str) {
+            // 不断的给子节点添加子节点
+            let ret = node.children.get(char);
+            if (ret == null) {
+                ret = new Node();
+                ret.char = char;
+                node.children.set(char, ret);
+            }
+            node = ret;
+        }
+        node.is_end = true;
+    }
+    clear() {
+        this.root = undefined;
+    }
+    /**
+     * 在完全匹配的基础之上（不是尽可能） 再额外添加一个字符 获取这个额外添加的字符的所有更多尽可能的可能性
+     * @param word
+     * @param extra_word_char 在匹配自己的前提下 获取以此 往前多一个分叉的所有子分叉 （比如 cmd 使用 . 获取 cmd.exe cmd.bat 等)
+     */
+    detection_next_list_word(word, extra_word_char) {
+        const r_list = [];
+        if (!word || !this.root)
+            r_list;
+        let now_node = this.root;
+        for (let i = 0; i < word.length; i++) {
+            const v = now_node.children.get(word[i]);
+            if (v == null) {
+                return r_list; // 本身就无法匹配完整
+            }
+            now_node = v;
+        }
+        // 基本字符都匹配上了现在来看看有没有多余的
+        if (now_node.is_end) {
+            // 把本身先加入进去
+            r_list.push(word);
+        }
+        if (!now_node.children) {
+            return r_list;
+        }
+        const ok_children_list = []; // 前面的都匹配上了
+        const dif_char_node = now_node.children.get(extra_word_char);
+        if (dif_char_node !== undefined && dif_char_node.children !== undefined) {
+            for (const node of dif_char_node.children.values()) {
+                node.word = word + extra_word_char;
+                ok_children_list.push(node);
+            }
+        }
+        // 剩下的必须唯一 不然就太多了
+        for (let i = 0; i < ok_children_list.length; i++) {
+            let node = ok_children_list[i];
+            let str = node.word;
+            while (node != null) {
+                if (node.is_end) {
+                    str += node.char;
+                    r_list.push(str);
+                    break;
+                }
+                if (node.children !== undefined) {
+                    // 还有子节点
+                    if (node.children.size === 1) {
+                        str += node.char;
+                        node = node.children.values().next().value; // 获取唯一的元素值
+                    }
+                    else {
+                        break; // 不唯一返回吧
+                    }
+                }
+                else {
+                    if (node.is_end) {
+                        // 没有子节点了 is_end 也是true 不做判断了 直接返回吧
+                        str += node.char;
+                        r_list.push(str);
+                        break;
+                    }
+                    else {
+                        // 既没有子节点 也不是最后一个字节 数据是有问题的只能忽略了
+                        break;
+                    }
+                }
+            }
+        }
+        return r_list;
+    }
+    /**
+     * 会  ”尽可能“  的往前匹配更多更匹配的 "唯一" 单词(有分叉就停止检索)
+     * 如果和原本的输入一样就不返回了
+     * @param word 单词 而不是被检测的文本
+     * @param prefer_char 如果有这种情况 遇上分叉了 但是提供一个可选项，使用这个如果可以继续往前获取唯一的单词就继续往前
+     * @return str or undefined
+     */
+    detection_next_one_word(word, prefer_char = undefined) {
+        if (!word || !this.root)
+            return;
+        let now_node = this.root;
+        for (let i = 0; i < word.length; i++) {
+            const v = now_node.children.get(word[i]);
+            if (v == null) {
+                return; // 本身就无法匹配完整
+            }
+            now_node = v;
+        }
+        if (now_node.is_end) {
+            return; // 一样的话就不返回了
+        }
+        if (now_node.children !== undefined) {
+            if (now_node.children.size === 1) {
+                // 只有一个元素 跳过最后一个字符
+                now_node = now_node.children.values().next().value;
+            }
+            else if (prefer_char !== undefined) {
+                // 有优先字符查找是否有优先字符
+                now_node = now_node.children.get(prefer_char);
+            }
+        }
+        // 前面的都匹配的有了
+        while (now_node != null) {
+            if (now_node.is_end) {
+                word += now_node.char;
+                return word;
+            }
+            if (now_node.children !== undefined) {
+                // 还有子节点
+                if (now_node.children.size === 1) {
+                    word += now_node.char;
+                    now_node = now_node.children.values().next().value; // 获取唯一的元素值
+                }
+                else {
+                    return word + now_node.char; // 接下来匹配会分叉就匹配到这返回吧
+                }
+            }
+            else {
+                if (now_node.is_end) {
+                    // 没有子节点了 is_end 也是true 不做判断了 直接返回吧
+                    return word;
+                }
+                else {
+                    // 既没有子节点 也不是最后一个字节 数据是有问题的只能忽略了
+                    return;
+                }
+            }
+        }
+        // 返回特殊的return
+    }
+}
+exports.word_detection_js = word_detection_js;
+// const test = new word_detection_js();
+// test.add("node.exe")
+// test.add("node")
+// test.add("cmd.exe")
+// test.add("powershell.exe")
+//
+// console.log(test.detection_next_list_word("node",))

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "pty-shell",
+  "version": "1.0.5",
+  "description": "a virtual PTY shell for javaScript",
+  "author": "xiaobaidadada",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:xiaobaidadada/pty-shell.git"
+  },
+  "homepage": "https://github.com/xiaobaidadada/pty-shell",
+  "bugs": {
+    "url": "https://github.com/xiaobaidadada/pty-shell/issues"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "typescript": "^5.5.3"
+  },
+  "files": [
+    "dist/**/*",
+    "LICENSE.txt",
+    "README.md",
+    "package.json"
+  ],
+  "keywords":[
+    "pty",
+    "shell",
+    "tty",
+    "terminal",
+    "browser",
+    "web",
+    "virtual",
+    "command intercept"
+  ]
+}