i-c-fn-head 0.0.5

package/package.json

@@ -0,0 +1,211 @@
+{
+  "name": "i-c-fn-head",
+  "displayName": "i_c_fn_head",
+  "description": "Dear Dev, this extension just shows function's name in breadcrumbs of VSCode for C, CPP, D & Rust. Have a nice day, Dear Dev 🤟🙂",
+  "publisher": "SarK0Y",
+  "repository": "https://github.com/SarK0Y/i_c_fn_head",
+  "version": "0.0.5",
+  "engines": {
+    "vscode": "^1.105.0"
+  },
+  "categories": [
+    "Other"
+  ],
+  "activationEvents": [
+  "onStartupFinished"
+  ],
+  "main": "./dist/extension.js",
+  "contributes": {
+  "contributes": {
+    "configuration": {
+      "title": "i_c_fn_head",
+      "properties": {
+        "i_c_fn_head.configurations": {
+          "description": "Specifies the color and style configuration.",
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "paths": {
+                "markdownDescription": "Specifies the list of file path patterns e.g. `[\"*.log\", \"todos/**/*.todo\"]`.",
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "rules": {
+                "type": "array",
+                "description": "Specifies the list of text decoration rules.",
+                "items": {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "properties": {
+                    "patterns": {
+                      "markdownDescription": "Specifies the list of regular expressions for matching the text e.g. `[\"Critical .*\", \"Error .*\"]`.",
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    },
+                    "matchCase": {
+                      "description": "Specifies whether to perform case-sensitive match.",
+                      "type": "boolean"
+                    },
+                    "multiLine": {
+                      "description": "Specifies whether the regular expression patterns can match across multiple lines.",
+                      "type": "boolean"
+                    },
+                    "color": {
+                      "markdownDescription": "Specifies the text color. Accepts terminal ANSI color names (e.g., `Red`, `BrightBlue`) or hex color codes (e.g., `#RGB`, `#RRGGBB`, `#RRGGBBAA`). _Do not specify to retain original text color._",
+                      "anyOf": [
+                        {
+                          "type": "string",
+                          "enum": [
+                            "Black",
+                            "Blue",
+                            "BrightBlack",
+                            "BrightBlue",
+                            "BrightCyan",
+                            "BrightGreen",
+                            "BrightMagenta",
+                            "BrightRed",
+                            "BrightWhite",
+                            "BrightYellow",
+                            "Cyan",
+                            "Green",
+                            "Magenta",
+                            "Red",
+                            "White",
+                            "Yellow"
+                          ]
+                        },
+                        {
+                          "type": "string",
+                          "format": "color-hex"
+                        }
+                      ]
+                    },
+                    "bold": {
+                      "markdownDescription": "Specifies whether to **bold** or unbold text. _Do not specify to retain original font weights._",
+                      "type": "boolean"
+                    },
+                    "italic": {
+                      "markdownDescription": "Specifies whether to _italicize_ or unitalicize text. _Do not specify to retain original font style._",
+                      "type": "boolean"
+                    },
+                    "underline": {
+                      "markdownDescription": "Specifies whether to add or remove underline from text. _Do not specify to retain original text decoration._",
+                      "type": "boolean"
+                    },
+                    "strikeThrough": {
+                      "markdownDescription": "Specifies whether to add or remove ~~strike through~~ from text. _Do not specify to retain original text decoration._",
+                      "type": "boolean"
+                    }
+                  },
+                  "required": [
+                    "patterns"
+                  ],
+                  "anyOf": [
+                    {
+                      "required": [
+                        "color"
+                      ]
+                    },
+                    {
+                      "required": [
+                        "bold"
+                      ]
+                    },
+                    {
+                      "required": [
+                        "italic"
+                      ]
+                    },
+                    {
+                      "required": [
+                        "underline"
+                      ]
+                    },
+                    {
+                      "required": [
+                        "strikeThrough"
+                      ]
+                    }
+                  ],
+                  "title": "Setting"
+                }
+              }
+            },
+            "required": [
+              "paths",
+              "rules"
+            ]
+          }
+        }
+      }
+    }
+  },
+    "languages": [{
+        "id": "C",
+        "extensions": [".c"],
+        "aliases": ["C"]
+    },
+    {
+        "id": "D",
+        "extensions": [".d"],
+        "aliases": ["D"]
+    },
+    {
+        "id": "Rust",
+        "extensions": [".rs"],
+        "aliases": ["Rust"]
+    },
+    {
+        "id": "CPP",
+        "extensions": [".cpp"],
+        "aliases": ["C++"]
+    }
+    ],
+    "commands": [
+      {
+        "command": "i-c-fn-head.helloWorld",
+        "title": "Hello World"
+      },
+      {
+        "command": "i-c-i_c_fn_head.ShowDocumentSymbols",
+        "title": "tst Document Symbols"
+    }
+    ]
+  },
+  "views": {
+        "explorer": [{
+            "id": "documentSymbolsView",
+            "name": "Document Symbols"
+        }]
+    },
+  "scripts": {
+    "vscode:prepublish": "npm run package",
+    "compile": "webpack",
+    "watch": "webpack --watch",
+    "package": "webpack --mode production --devtool hidden-source-map",
+    "compile-tests": "tsc -p . --outDir out",
+    "watch-tests": "tsc -p . -w --outDir out",
+    "pretest": "npm run compile-tests && npm run compile && npm run lint",
+    "lint": "eslint src",
+    "test": "vscode-test"
+  },
+  "devDependencies": {
+    "@types/mocha": "^10.0.10",
+    "@types/node": "22.x",
+    "@types/vscode": "^1.105.0",
+    "@vscode/test-cli": "^0.0.11",
+    "@vscode/test-electron": "^2.5.2",
+    "eslint": "^9.39.2",
+    "ts-loader": "^9.5.4",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0",
+    "webpack": "^5.104.1",
+    "webpack-cli": "^6.0.1"
+  }
+}

package/src/basic_funx.ts

@@ -0,0 +1,120 @@
+import * as vscode from 'vscode';
+import { uri_to_file_of_opts } from './init';
+class set_cmd_type {
+    static v: string = "rgx";
+}
+export function prnt(msg: string) {
+    console_msg.show(msg);
+}
+export class console_msg {
+    static #outputChannel = vscode.window.createOutputChannel('i-c-fn-head');
+    static show(msg: string) {
+        this.#outputChannel.appendLine(msg);
+        this.#outputChannel.show();
+    }
+}
+export function getCMD(set_placeholder0?: string | null, _txt?: string | undefined | null,  cmd_type?: string): RegExp[] | null {
+    const txt = _txt ? _txt : vscode.window.activeTextEditor?.document.getText();
+    set_cmd_type.v = cmd_type ? cmd_type : set_cmd_type.v;
+    cmd_rgx.set_collect_rgx_from_doc();
+    if (txt == undefined) { return null}
+    const ret = set_placeholder0 ? cmd_rgx._collect_rgx_from_doc(txt, set_placeholder0) : cmd_rgx._collect_rgx_from_doc(txt); 
+    let phldr = set_placeholder0 ? set_placeholder0 : "no phldr";
+    prnt("calc num of cmds: " + ret.length.toString());
+   // prnt (ewt)
+    return ret;
+}
+export class cmd_rgx {
+    static collect_rgx_from_doc: RegExp = /\/\/\s*rgx:\s*(\/.*:::[gmis]*)\s*\/\//g;
+    static placeholder0: string = "@663@";
+    static placeholder0_max_len: number = 200;
+    static open_rgx: string = "/";
+    static close_rgx: string = ":::";
+    static set_collect_rgx_from_doc(
+        open_rgx?: string,
+        close_rgx?: string,
+    ): RegExp {
+        this.open_rgx = open_rgx ?? this.open_rgx;
+        this.close_rgx = close_rgx ?? this.close_rgx;
+        let cmd_type = set_cmd_type.v ?? "rgx";
+        let construct_rgx: string = "//\\s*" + cmd_type + ":\\s*(" + this.open_rgx + ".*" + this.close_rgx + "[gmis]*)\\s*//";
+        this.collect_rgx_from_doc = new RegExp(construct_rgx, "g");
+        prnt("set_collect_rgx_from_doc: "+this.collect_rgx_from_doc.source);
+        return this.collect_rgx_from_doc;
+    }
+    static _collect_rgx_from_doc(txt: string, set_placeholder0?: string): RegExp[] {
+        if (set_placeholder0) { return this._collect_rgx_from_doc0(txt, set_placeholder0) }
+        let m: RegExpExecArray | null;
+        let ret: RegExp[] = [];
+        while ((m = this.collect_rgx_from_doc.exec(txt)) != null) {
+            let try_it = this.strn_2_rgx(m[1]);
+            if (try_it == null) {
+                prnt("_collect_rgx_from_doc: try_it is null");
+                break
+            }
+            prnt("_collect_rgx_from_doc:" + m[1]);
+            ret.push(try_it);
+        }
+        return ret;
+    }
+    static _collect_rgx_from_doc0(txt: string, set_placeholder0: string): RegExp[] {
+        let m: RegExpExecArray | null;
+        let ret: RegExp[] = [];
+        while ((m = this.collect_rgx_from_doc.exec(txt)) != null) {
+            let _m = m[1].replaceAll(this.placeholder0, set_placeholder0);
+            let try_it = this.strn_2_rgx(_m);
+            prnt("1st class cmd_rgx");
+            if (try_it == null) {
+                prnt("_collect_rgx_from_doc: try_it is null");
+                break
+            }
+            prnt("_collect_rgx_from_doc:" + m[1]);
+            ret.push(try_it);
+        }
+        return ret;
+    }
+    static strn_2_rgx(strn: string): RegExp | null {
+        let check_end_of_rgx = this.close_rgx + "[gmis]*$";
+        let flags = strn.match(new RegExp(check_end_of_rgx));
+        let _flags = flags != null ? flags[0].slice(this.close_rgx.length) : "";
+        let regex = strn.slice(1).replaceAll(this.close_rgx + _flags, "");
+        try {
+            let ret = new RegExp(regex, _flags);
+            prnt("strn to rgx: " + ret.source + " " + ret.flags);
+            return ret;
+        } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            vscode.window.showInformationMessage(msg);
+            return null;
+        }
+    }
+}
+export async function exclude_paths(uris: vscode.Uri[]): Promise<vscode.Uri[] |  undefined> {
+    try {
+        let ret: vscode.Uri[] = [];    
+        const file_of_opts = await uri_to_file_of_opts();
+        const txt = (await vscode.workspace.openTextDocument(file_of_opts[0])).getText();
+        prnt(txt);
+        let exclude_paths0 = getCMD(
+            null,
+            txt,
+            "exclude_path"
+        );
+        if (exclude_paths0 == null) { return; }
+        for (let exc of exclude_paths0) {
+            ret = exclude_path(uris, exc);
+        }
+        return ret.length == 0? uris: ret;
+    } catch (err) {
+        prnt(String(err))
+        return
+    }
+}
+function exclude_path(uris: vscode.Uri[], rgx: RegExp): vscode.Uri[] {
+    let ret: vscode.Uri[] = [];
+    for (let uri of uris) {
+        prnt(rgx.source);
+        if (!uri.fsPath.match(rgx)) { ret.push (uri)}
+    }
+    return ret;
+}

package/src/colorful.ts

@@ -0,0 +1,276 @@
+import * as vscode from 'vscode';
+import { minimatch } from 'minimatch';
+
+type Configuration = {
+    paths?: string[];
+    rules?: Rule[];
+};
+export function extra_activate(): string {
+    return activate_;
+}
+const activate_: string = `
+  //  console.log('Extension "color-my-text" is activated.');
+
+    let allConfigData: ConfigData[] = [];
+
+    // todoEditors need (re)decoration; doneEditors are already up to date.
+    // Tracking both avoids re-decorating unchanged editors when unrelated ones become visible.
+    let todoEditors: vscode.TextEditor[] = [];
+    let doneEditors: vscode.TextEditor[] = [];
+
+    // Disposes old decoration types and rebuilds allConfigData from current settings.
+    function resetDecorations(): void {
+        todoEditors = vscode.window.visibleTextEditors.slice();
+        doneEditors = [];
+
+        allConfigData.forEach(configData => configData.ruleData.forEach(ruleData => ruleData.decorationType.dispose()));
+
+        const configurations = vscode.workspace.getConfiguration('i_c_fn_head').get<Configuration[]>('configurations');
+        allConfigData = toArray(configurations).map(configuration => ({
+            globs: toArray(configuration.paths),
+            ruleData: toArray(configuration.rules).map(buildRuleData),
+        }));
+    }
+
+    // Applies decorations to all queued editors. Runs on a 500ms timer to batch rapid edits.
+
+
+    vscode.workspace.onDidChangeConfiguration(
+        event => {
+            if (event.affectsConfiguration('i_c_fn_head.configurations')) {
+                resetDecorations();
+            }
+        },
+        null,
+        context.subscriptions);
+
+    vscode.window.onDidChangeVisibleTextEditors(
+        visibleEditors => {
+            // Queue newly visible editors; prune editors that were closed.
+            todoEditors = visibleEditors.filter(editor => !doneEditors.includes(editor));
+            doneEditors = doneEditors.filter(editor => visibleEditors.includes(editor));
+            updateDecorations();
+        },
+        null,
+        context.subscriptions);
+
+    vscode.workspace.onDidChangeTextDocument(
+        event => {
+            // Re-queue any visible editor showing the changed document.
+            vscode.window.visibleTextEditors.forEach(visibleEditor => {
+                if (visibleEditor.document === event.document && !todoEditors.includes(visibleEditor)) {
+                    todoEditors.push(visibleEditor);
+                }
+            });
+
+            doneEditors = doneEditors.filter(editor => !todoEditors.includes(editor));
+        },
+        null,
+        context.subscriptions);
+
+    resetDecorations();
+    function updateDecorations(): void {
+        return _updateDecorations(
+            allConfigData,
+            todoEditors,
+            doneEditors
+        );
+    }
+    const intervalId = setInterval(updateDecorations, 500);
+    context.subscriptions.push({ dispose: () => clearInterval(intervalId) });
+
+`
+type Rule = {
+    patterns?: string[];
+    color?: string;
+    matchCase?: boolean;
+    multiLine?: boolean;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikeThrough?: boolean;
+};
+
+// Precomputed data for a single rule.
+type RuleData = {
+    decorationType: vscode.TextEditorDecorationType;
+    regexes: RegExp[];
+    multiLine: boolean;
+};
+
+// Precomputed data for a single configuration entry, rebuilt whenever settings change.
+type ConfigData = {
+    globs: string[];
+    ruleData: RuleData[];
+};
+
+function toArray<T>(value: T[] | undefined): T[] {
+    return Array.isArray(value) ? value : [];
+}
+
+// ANSI color names map to VS Code terminal theme tokens ('terminal.ansi<Name>').
+const ansiColorNames = new Set<string>([
+    'Black', 'Blue', 'BrightBlack', 'BrightBlue', 'BrightCyan', 'BrightGreen',
+    'BrightMagenta', 'BrightRed', 'BrightWhite', 'BrightYellow',
+    'Cyan', 'Green', 'Magenta', 'Red', 'White', 'Yellow',
+]);
+
+function buildRuleData(rule: Rule): RuleData {
+    const color = typeof rule.color !== 'string' ? undefined
+        : ansiColorNames.has(rule.color) ? new vscode.ThemeColor('terminal.ansi' + rule.color)
+            : rule.color;
+
+    // 'none' explicitly removes any theme-inherited decoration when either flag is false.
+    const textDecoration =
+        rule.underline === true && rule.strikeThrough === true ? 'underline line-through'
+            : rule.underline === true ? 'underline'
+                : rule.strikeThrough === true ? 'line-through'
+                    : rule.underline === false || rule.strikeThrough === false ? 'none'
+                        : undefined;
+
+    const decorationType = vscode.window.createTextEditorDecorationType({
+        color,
+        fontWeight: typeof rule.bold !== 'boolean' ? undefined : rule.bold ? 'bold' : 'normal',
+        fontStyle: typeof rule.italic !== 'boolean' ? undefined : rule.italic ? 'italic' : 'normal',
+        textDecoration,
+    });
+
+    const flags = 'g' + (rule.matchCase === true ? '' : 'i') + (rule.multiLine === true ? 's' : '') + 'u';
+
+    const regexes = toArray(rule.patterns).flatMap(pattern => {
+        try {
+            return [new RegExp(pattern, flags)];
+        } catch {
+            return []; // Skip invalid regex patterns.
+        }
+    });
+
+    return { decorationType, regexes, multiLine: rule.multiLine === true };
+}
+
+export function activate0(context: vscode.ExtensionContext): void {
+  //  console.log('Extension "color-my-text" is activated.');
+
+    let allConfigData: ConfigData[] = [];
+
+    // todoEditors need (re)decoration; doneEditors are already up to date.
+    // Tracking both avoids re-decorating unchanged editors when unrelated ones become visible.
+    let todoEditors: vscode.TextEditor[] = [];
+    let doneEditors: vscode.TextEditor[] = [];
+
+    // Disposes old decoration types and rebuilds allConfigData from current settings.
+    function resetDecorations(): void {
+        todoEditors = vscode.window.visibleTextEditors.slice();
+        doneEditors = [];
+
+        allConfigData.forEach(configData => configData.ruleData.forEach(ruleData => ruleData.decorationType.dispose()));
+
+        const configurations = vscode.workspace.getConfiguration('i_c_fn_head').get<Configuration[]>('configurations');
+        allConfigData = toArray(configurations).map(configuration => ({
+            globs: toArray(configuration.paths),
+            ruleData: toArray(configuration.rules).map(buildRuleData),
+        }));
+    }
+
+    // Applies decorations to all queued editors. Runs on a 500ms timer to batch rapid edits.
+    
+
+    vscode.workspace.onDidChangeConfiguration(
+        event => {
+            if (event.affectsConfiguration('i_c_fn_head.configurations')) {
+                resetDecorations();
+            }
+        },
+        null,
+        context.subscriptions);
+
+    vscode.window.onDidChangeVisibleTextEditors(
+        visibleEditors => {
+            // Queue newly visible editors; prune editors that were closed.
+            todoEditors = visibleEditors.filter(editor => !doneEditors.includes(editor));
+            doneEditors = doneEditors.filter(editor => visibleEditors.includes(editor));
+            updateDecorations();
+        },
+        null,
+        context.subscriptions);
+
+    vscode.workspace.onDidChangeTextDocument(
+        event => {
+            // Re-queue any visible editor showing the changed document.
+            vscode.window.visibleTextEditors.forEach(visibleEditor => {
+                if (visibleEditor.document === event.document && !todoEditors.includes(visibleEditor)) {
+                    todoEditors.push(visibleEditor);
+                }
+            });
+
+            doneEditors = doneEditors.filter(editor => !todoEditors.includes(editor));
+        },
+        null,
+        context.subscriptions);
+
+    resetDecorations();
+    function updateDecorations(): void {
+        return _updateDecorations(
+            allConfigData,
+            todoEditors,
+            doneEditors
+        );
+    }
+    const intervalId = setInterval(updateDecorations, 500);
+    context.subscriptions.push({ dispose: () => clearInterval(intervalId) });
+}
+function _updateDecorations(
+    allConfigData: &ConfigData[],
+    todoEditors: & vscode.TextEditor[],
+    doneEditors: vscode.TextEditor[]
+): void {
+    if (allConfigData.every(configData => configData.ruleData.length === 0)) { return; }
+    if (todoEditors.length === 0) { return; }
+
+    todoEditors.forEach(editor => {
+        const filePath = vscode.workspace.asRelativePath(editor.document.fileName);
+
+        // Collect rule data from all configurations whose path globs match this editor's file.
+        const matchingRuleData = allConfigData.flatMap(configData =>
+            configData.globs.some(glob => {
+                // A bare filename (no path separators) is matched against any directory level.
+                const pattern = glob.includes('/') || glob.includes('\\') ? glob : '**/' + glob;
+                return minimatch(filePath, pattern, { nocase: process.platform === 'win32' });
+            }) ? configData.ruleData : []);
+
+        if (matchingRuleData.length === 0) { return; }
+
+        let documentText: string | undefined;
+
+        matchingRuleData.forEach(({ decorationType, regexes, multiLine }) => {
+            const ranges: vscode.Range[] = [];
+
+            if (multiLine) {
+                documentText ??= editor.document.getText();
+                for (const regex of regexes) {
+                    for (const match of documentText.matchAll(regex)) {
+                        if (match.index === undefined || match[0].length === 0) { continue; }
+                        const startPos = editor.document.positionAt(match.index);
+                        const endPos = editor.document.positionAt(match.index + match[0].length);
+                        ranges.push(new vscode.Range(startPos, endPos));
+                    }
+                }
+            } else {
+                for (const regex of regexes) {
+                    for (let lineNum = 0; lineNum < editor.document.lineCount; lineNum++) {
+                        for (const match of editor.document.lineAt(lineNum).text.matchAll(regex)) {
+                            if (match.index === undefined || match[0].length === 0) { continue; }
+                            ranges.push(new vscode.Range(lineNum, match.index, lineNum, match.index + match[0].length));
+                        }
+                    }
+                }
+            }
+
+            editor.setDecorations(decorationType, ranges);
+        });
+
+        doneEditors.push(editor);
+    });
+
+    todoEditors = [];
+}