Check for resx generator tool type

Checks to see if this is in project as resxgen and use public/internal if so, default public

Author: timheuer

src/utilities/designerGenerator.ts

@@ -1,6 +1,6 @@
 import * as path from 'path';
 
-export function generateDesignerCode(resxPath: string, resources: { [key: string]: { value: string; comment?: string } }): string {
+export function generateDesignerCode(resxPath: string, resources: { [key: string]: { value: string; comment?: string } }, accessLevel: 'public' | 'internal' = 'public'): string {
     const fileName = path.basename(resxPath, '.resx');
     const namespaceName = fileName.includes('.') ? fileName.split('.')[0] : 'Resources';
     const className = fileName.includes('.') ? fileName.split('.')[1] : fileName;
@@ -24,7 +24,7 @@ namespace ${namespaceName} {
     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("VS Code RESX Editor", "1.0.0.0")]
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    public class ${className} {
+    ${accessLevel} class ${className} {
         
         private static global::System.Resources.ResourceManager resourceMan;
         
@@ -38,7 +38,7 @@ namespace ${namespaceName} {
         ///   Returns the cached ResourceManager instance used by this class.
         /// </summary>
         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        public static global::System.Resources.ResourceManager ResourceManager {
+        ${accessLevel} static global::System.Resources.ResourceManager ResourceManager {
             get {
                 if (object.ReferenceEquals(resourceMan, null)) {
                     global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("${namespaceName}.${className}", typeof(${className}).Assembly);
@@ -53,7 +53,7 @@ namespace ${namespaceName} {
         ///   resource lookups using this strongly typed resource class.
         /// </summary>
         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        public static global::System.Globalization.CultureInfo Culture {
+        ${accessLevel} static global::System.Globalization.CultureInfo Culture {
             get {
                 return resourceCulture;
             }
@@ -71,7 +71,7 @@ namespace ${namespaceName} {
             code += `        ///   ${resource.comment}\n`;
             code += `        /// </summary>\n`;
         }
-        code += `        public static string ${key} {
+        code += `        ${accessLevel} static string ${key} {
             get {
                 return ResourceManager.GetString("${key}", resourceCulture);
             }

src/utilities/generateCode.ts

@@ -1,17 +1,72 @@
 import * as vscode from 'vscode';
+import * as fs from 'fs';
+import * as path from 'path';
 import { generateDesignerCode } from './designerGenerator';
 import { printChannelOutput } from '../extension';
 
+async function checkResxGeneratorType(resxPath: string): Promise<'public' | 'internal'> {
+    // Look for a .csproj file in the same directory or parent directories
+    const dir = path.dirname(resxPath);
+    const csprojFiles = await vscode.workspace.findFiles(
+        new vscode.RelativePattern(dir, '**/*.csproj')
+    );
+
+    if (csprojFiles.length === 0) {
+        return 'public'; // Default to public if no .csproj is found
+    }
+
+    const resxFileName = path.basename(resxPath);
+
+    for (const csprojFile of csprojFiles) {
+        try {
+            const content = await vscode.workspace.fs.readFile(csprojFile);
+            const csprojContent = content.toString();
+
+            // Use regex to find EmbeddedResource items with our RESX file
+            const regex = new RegExp(`<EmbeddedResource\\s+Include=["'](?:[^"']*[\\\\/])?${escapeRegExp(resxFileName)}["'][^>]*>([\\s\\S]*?)</EmbeddedResource>`, 'i');
+            const match = regex.exec(csprojContent);
+
+            if (match) {
+                const itemContent = match[1];
+                // Look for Generator metadata within the EmbeddedResource element
+                const generatorRegex = /<Generator>([^<]+)<\/Generator>/i;
+                const generatorMatch = generatorRegex.exec(itemContent);
+
+                if (generatorMatch) {
+                    const generator = generatorMatch[1].trim();
+                    if (generator === 'PublicResXFileCodeGenerator') {
+                        return 'public';
+                    } else if (generator === 'ResXFileCodeGenerator') {
+                        return 'internal';
+                    }
+                }
+            }
+        } catch (error) {
+            printChannelOutput(`Error reading .csproj file: ${error}`, true);
+        }
+    }
+
+    return 'public'; // Default to public if no generator type is specified
+}
+
+// Helper function to escape special regex characters
+function escapeRegExp(string: string): string {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 export async function generateAndUpdateDesignerFile(document: vscode.TextDocument, parsedJson: any): Promise<void> {
     // Check if code generation is enabled
     const config = vscode.workspace.getConfiguration('resx-editor');
     const generateCode = config.get<boolean>('generateCode', false);
 
     if (generateCode) {
+        // Determine the access level based on .csproj settings
+        const accessLevel = await checkResxGeneratorType(document.uri.fsPath);
+
         // Generate and update the Designer.cs file
         const designerPath = document.uri.fsPath.replace('.resx', '.Designer.cs');
         const designerUri = vscode.Uri.file(designerPath);
-        const designerCode = generateDesignerCode(document.uri.fsPath, parsedJson);
+        const designerCode = generateDesignerCode(document.uri.fsPath, parsedJson, accessLevel);
 
         try {
             await vscode.workspace.fs.stat(designerUri);