Merge branch 'main' into bump-vsce-helper

Author: soumeh01

src/desktop/extension.ts

@@ -224,6 +224,7 @@ export const activate = async (context: ExtensionContext): Promise<CsolutionExte
         commandsProvider,
         configurationProvider,
         csolutionService,
+        externalFileOpener,
     );
     context.subscriptions.push(window.registerCustomEditorProvider(
         ManageSolutionCustomEditorProvider.viewType,

src/views/common/components/cmsis-codicon.tsx

@@ -24,29 +24,35 @@ const CMSIS_CODICON_CODEPOINTS = {
 
 export type CmsisCodiconName = keyof typeof CMSIS_CODICON_CODEPOINTS;
 
-type Props = {
-    name: CmsisCodiconName;
-    title?: string;
-    className?: string;
-    style?: React.CSSProperties;
+type Props = React.ComponentPropsWithoutRef<'span'> & {
+    name: CmsisCodiconName | string;
     fontFamily?: string; // default is your custom webview font
 };
 
 export const CmsisCodicon: React.FC<Props> = ({
     name,
-    title,
     className,
     style,
     fontFamily = 'cmsis-codicon',
+    ...spanProps
 }) => {
-    const codepoint = CMSIS_CODICON_CODEPOINTS[name];
+    const codepoint = CMSIS_CODICON_CODEPOINTS[name as CmsisCodiconName];
+    if (codepoint !== undefined) {
+        return (
+            <span
+                {...spanProps}
+                className={className ?? ''}
+                style={{ fontFamily, display: 'inline-block', lineHeight: 1, ...style }}
+            >
+                {String.fromCodePoint(codepoint)}
+            </span>
+        );
+    }
     return (
         <span
-            title={title}
-            className={className}
-            style={{ fontFamily, display: 'inline-block', lineHeight: 1, ...style }}
-        >
-            {String.fromCodePoint(codepoint)}
-        </span>
+            {...spanProps}
+            className={`codicon codicon-${name}${className ? ` ${className}` : ''}`}
+            style={{ display: 'inline-block', lineHeight: 1, ...style }}
+        />
     );
 };

src/views/manage-components-packs/components-packs-webview-main.ts

@@ -31,7 +31,7 @@ import { BuildContext, Project, TargetSetData } from './components-data';
 import { ComponentsPacksActions, CurrentProject, normalizeForCompare } from './components-packs-actions';
 import { ComponentRowDataType, ComponentScope } from './data/component-tools';
 import { componentTreeWalker } from './data/component-tree-walker';
-import { uniqWith } from 'lodash';
+import { uniqWith, cloneDeep } from 'lodash';
 import { parsePackId } from './data/pack-parse';
 import { lineOf, readTextFile } from '../../utils/fs-utils';
 import { stripTwoExtensions } from '../../utils/string-utils';
@@ -131,6 +131,12 @@ export class ComponentsPacksWebviewMain {
             return; // nothing to show
         }
 
+        const reload = this.projectFromPath(this.currentProject?.project.projectId) !== this.projectFromPath(cprojectPath);
+        const csolution = this.solutionManager.getCsolution();
+        if (csolution) {
+            this.currentProject = { solutionPath: csolution.solutionPath, project: createProject(cprojectPath) };
+        }
+
         if (clayerPath) {
             const selectedTarget = this.findTargetSetFromPath(clayerPath);
             if (selectedTarget) {
@@ -141,7 +147,6 @@ export class ComponentsPacksWebviewMain {
         }
         this.webviewManager.createOrShowPanel();
 
-        const reload = this.projectFromPath(this.currentProject?.project.projectId) !== this.projectFromPath(cprojectPath);
         await this.debounce_load(cprojectPath, reload);
         await this.sendDirtyState();
     }
@@ -204,37 +209,39 @@ export class ComponentsPacksWebviewMain {
         return undefined;
     }
 
-    private async isDirty(): Promise<boolean> {
+    private async isDirty(usedItems?: UsedItems): Promise<boolean> {
         const actx = this.getActiveContext();
 
         if (this.solutionManager.getCsolution()?.cbuildPackFile.isModified()) {
             return true;
         }
 
-        const usedItems = await this.csolutionService.getUsedItems({ context: actx });
-        if (this.usedItems?.packs.length !== usedItems.packs.length || this.usedItems?.components.length !== usedItems.components.length) {
+        const latestUsedItems = usedItems ?? await this.csolutionService.getUsedItems({ context: actx });
+        if (this.usedItems?.packs.length !== latestUsedItems.packs.length || this.usedItems?.components.length !== latestUsedItems.components.length) {
             return true;
         }
 
         const componentMapper = (c: ComponentInstance) => ({ id: c.id, variant: c.resolvedComponent?.pack });
         const packMapper = (p: PackReference) => ({ pack: p.pack, origin: normalizeForCompare(p.origin) });
         const localUsedItemsSorted = {
-            components: this.usedItems?.components.sort((a, b) => a.id.localeCompare(b.id)).map(componentMapper) ?? [],
-            packs: this.usedItems?.packs.sort((a, b) => a.pack.localeCompare(b.pack)).map(packMapper) ?? [],
+            components: [...(this.usedItems?.components ?? [])].sort((a, b) => a.id.localeCompare(b.id)).map(componentMapper),
+            packs: [...(this.usedItems?.packs ?? [])].sort((a, b) => a.pack.localeCompare(b.pack)).map(packMapper),
         };
         const usedItemsSorted = {
-            components: usedItems.components.sort((a, b) => a.id.localeCompare(b.id)).map(componentMapper),
-            packs: usedItems.packs.sort((a, b) => a.pack.localeCompare(b.pack)).map(packMapper),
+            components: [...latestUsedItems.components].sort((a, b) => a.id.localeCompare(b.id)).map(componentMapper),
+            packs: [...latestUsedItems.packs].sort((a, b) => a.pack.localeCompare(b.pack)).map(packMapper),
         };
         const usedItemsChanged = !isDeepStrictEqual(localUsedItemsSorted, usedItemsSorted);
         return usedItemsChanged;
     }
 
-    private async sendDirtyState(): Promise<void> {
+    private async sendDirtyState(options?: { skipApply?: boolean, usedItems?: UsedItems }): Promise<void> {
         const actx = this.getActiveContext();
-        await this.csolutionService.apply({ context: actx });
+        if (!options?.skipApply) {
+            await this.csolutionService.apply({ context: actx });
+        }
 
-        const isDirty = await this.isDirty();
+        const isDirty = await this.isDirty(options?.usedItems);
         await this.webviewManager.sendMessage({ type: 'IS_DIRTY', isDirty: isDirty });
     }
 
@@ -368,7 +375,7 @@ export class ComponentsPacksWebviewMain {
                         label: `Layer: ${layerLabel}`,
                         key: layer.absolutePath,
                         path: backToForwardSlashes(layer.absolutePath),
-                        relativePath: backToForwardSlashes(path.relative(dirname(this.currentProject?.solutionPath ?? ''), layer.absolutePath)),
+                        relativePath: this.getRelativePath(this.getSolutionDir(), layer.absolutePath),
                         type: 'layer' as const
                     };
 
@@ -413,11 +420,12 @@ export class ComponentsPacksWebviewMain {
         const activeContext = this.getActiveContext();
         const state = await this.csolutionService.apply({ context: activeContext });
         this.usedItems = await this.csolutionService.getUsedItems({ context: activeContext });
+        const usedItemsForProjectFileUpdate = cloneDeep(this.usedItems);
         const projectFileName = this.currentProject?.project.projectId ?? '';
         const requestAll = this.scope === ComponentScope.All;
         this.componentTree = this.manageComponentsActions.mapComponentsFromService(await this.csolutionService.getComponentsTree({ context: activeContext, all: requestAll }));
         this.validations = await this.csolutionService.validateComponents({ context: activeContext });
-        await this.projectFileUpdater.updateUsedItems(activeContext, projectFileName, this.usedItems);
+        await this.projectFileUpdater.updateUsedItems(activeContext, projectFileName, usedItemsForProjectFileUpdate);
 
         await Promise.all([
             this.webviewManager.sendMessage({ type: 'SET_ERROR_MESSAGES', messages: [] }),
@@ -426,7 +434,7 @@ export class ComponentsPacksWebviewMain {
         if (state.success === false) {
             this.webviewManager.sendMessage({ type: 'SET_SOLUTION_STATE', stateMessage: state.message ?? 'Unspecified error when writing solution information' });
         }
-        await this.sendDirtyState();
+        await this.sendDirtyState({ skipApply: true, usedItems: usedItemsForProjectFileUpdate });
     }
 
     private async handleOpenFile(message: Messages.OutgoingMessage): Promise<void> {
@@ -447,9 +455,7 @@ export class ComponentsPacksWebviewMain {
                 );
 
                 await this.sendDirtyState();
-                const validations = await this.csolutionService.validateComponents({ context: activeContext });
-                this.componentTree = this.manageComponentsActions.mapComponentsFromService(await this.csolutionService.getComponentsTree({ context: activeContext, all: this.scope === ComponentScope.All }));
-                await this.webviewManager?.sendMessage({ type: 'SET_COMPONENT_TREE', tree: this.componentTree, validations: validations.validation });
+                await this.refreshComponentTree(activeContext);
             }
         }
     }
@@ -465,9 +471,7 @@ export class ComponentsPacksWebviewMain {
                     variant
                 );
                 await this.sendDirtyState();
-                this.componentTree = this.manageComponentsActions.mapComponentsFromService(await this.csolutionService.getComponentsTree({ context: activeContext, all: this.scope === ComponentScope.All }));
-                const validations = await this.csolutionService.validateComponents({ context: activeContext });
-                await this.webviewManager?.sendMessage({ type: 'SET_COMPONENT_TREE', tree: this.componentTree, validations: validations.validation });
+                await this.refreshComponentTree(activeContext);
             }
         }
     }
@@ -483,10 +487,7 @@ export class ComponentsPacksWebviewMain {
                     bundle
                 );
                 await this.sendDirtyState();
-                const requestAll = this.scope === ComponentScope.All;
-                this.componentTree = this.manageComponentsActions.mapComponentsFromService(await this.csolutionService.getComponentsTree({ context: activeContext, all: requestAll }));
-                this.validations = await this.csolutionService.validateComponents({ context: activeContext });
-                await this.webviewManager.sendMessage({ type: 'SET_COMPONENT_TREE', tree: this.componentTree, validations: this.validations.validation ?? [], scope: this.scope });
+                await this.refreshComponentTree(activeContext);
             }
         }
     }
@@ -596,37 +597,40 @@ export class ComponentsPacksWebviewMain {
         }
     };
 
+    private async handlePackageSelectionChange(
+        target: string,
+        packId: string,
+        stateMessage: string,
+        action: (actx: string, target: string, packId: string) => Promise<void>
+    ): Promise<void> {
+        try {
+            await this.webviewManager.sendMessage({ type: 'SET_SOLUTION_STATE', stateMessage });
+            const actx = this.getActiveContext();
+            await action(actx, target, packId);
+            const requestAll = this.scope === ComponentScope.All;
+            const packs = this.mapPacksFromService(await this.csolutionService.getPacksInfo({ context: actx, all: requestAll }));
+            await this.webviewManager.sendMessage({ type: 'SET_PACKS_INFO', packs: packs?.packs || [] });
+            await this.sendDirtyState();
+        } finally {
+            await this.webviewManager.sendMessage({ type: 'SET_SOLUTION_STATE', stateMessage: undefined });
+        }
+    }
+
     private async selectPackage(message: Messages.OutgoingMessage): Promise<void> {
         if (isSelectPackageMessage(message)) {
-            try {
-                await this.webviewManager.sendMessage({ type: 'SET_SOLUTION_STATE', stateMessage: 'Selecting Pack' });
-
-                const actx = this.getActiveContext();
-                await this.manageComponentsActions.selectPackage(actx, message.target, message.packId);
-                const requestAll = this.scope === ComponentScope.All;
-                const packs = this.mapPacksFromService(await this.csolutionService?.getPacksInfo({ context: actx, all: requestAll }));
-                await this.webviewManager?.sendMessage({ type: 'SET_PACKS_INFO', packs: packs?.packs || [] });
-                await this.sendDirtyState();
-            } finally {
-                await this.webviewManager.sendMessage({ type: 'SET_SOLUTION_STATE', stateMessage: undefined });
-            }
+            await this.handlePackageSelectionChange(
+                message.target, message.packId, 'Selecting Pack',
+                (actx, target, packId) => this.manageComponentsActions.selectPackage(actx, target, packId)
+            );
         }
     }
 
     private async unselectPackage(message: Messages.OutgoingMessage): Promise<void> {
         if (isUnselectPackageMessage(message)) {
-            try {
-                await this.webviewManager.sendMessage({ type: 'SET_SOLUTION_STATE', stateMessage: 'Unselecting Pack' });
-
-                const actx = this.getActiveContext();
-                await this.manageComponentsActions.unselectPackage(actx, message.target, message.packId);
-                const requestAll = this.scope === ComponentScope.All;
-                const packs = this.mapPacksFromService(await this.csolutionService?.getPacksInfo({ context: actx, all: requestAll }));
-                await this.webviewManager?.sendMessage({ type: 'SET_PACKS_INFO', packs: packs?.packs || [] });
-                await this.sendDirtyState();
-            } finally {
-                await this.webviewManager.sendMessage({ type: 'SET_SOLUTION_STATE', stateMessage: undefined });
-            }
+            await this.handlePackageSelectionChange(
+                message.target, message.packId, 'Unselecting Pack',
+                (actx, target, packId) => this.manageComponentsActions.unselectPackage(actx, target, packId)
+            );
         }
     }
 
@@ -658,14 +662,14 @@ export class ComponentsPacksWebviewMain {
         const activeContext = this.getActiveContext();
         const requestAll = this.scope === ComponentScope.All;
 
-        this.componentTree = this.manageComponentsActions.mapComponentsFromService(await this.csolutionService.getComponentsTree({ context: activeContext, all: requestAll }));
-        this.validations = await this.csolutionService.validateComponents({ context: activeContext });
-        const packsInfo = this.mapPacksFromService(await this.csolutionService.getPacksInfo({ context: activeContext, all: requestAll }));
-
         if (!this.availablePacksCache || Object.keys(this.availablePacksCache).length === 0) {
             this.availablePacksCache = await this.filterAvailablePacks(activeContext);
         }
 
+        this.componentTree = this.manageComponentsActions.mapComponentsFromService(await this.csolutionService.getComponentsTree({ context: activeContext, all: requestAll }));
+        this.validations = await this.csolutionService.validateComponents({ context: activeContext });
+        const packsInfo = this.mapPacksFromService(await this.csolutionService.getPacksInfo({ context: activeContext, all: requestAll }));
+
         componentTreeWalker(this.componentTree, (node, type) => {
             if (type === 'aggregate' && (node as CtAggregate).options?.layer) {
                 (node as CtAggregate).options!.layer = (node as CtAggregate).options!.layer || '';
@@ -776,6 +780,19 @@ export class ComponentsPacksWebviewMain {
         await this.webviewManager.sendMessage(programMessage);
     }
 
+    private async refreshComponentTree(activeContext: string): Promise<void> {
+        this.componentTree = this.manageComponentsActions.mapComponentsFromService(
+            await this.csolutionService.getComponentsTree({ context: activeContext, all: this.scope === ComponentScope.All })
+        );
+        this.validations = await this.csolutionService.validateComponents({ context: activeContext });
+        await this.webviewManager.sendMessage({
+            type: 'SET_COMPONENT_TREE',
+            tree: this.componentTree,
+            validations: this.validations.validation ?? [],
+            scope: this.scope
+        });
+    }
+
     private async openFile(filePath: string, openExternal?: boolean, focusOn?: string): Promise<void> {
         if (openExternal) {
             this.openFileExternal.openFile(filePath);

src/views/manage-solution/manage-solution-custom-editor.ts

@@ -26,6 +26,7 @@ import { ConfigurationProvider } from '../../vscode-api/configuration-provider';
 import { CsolutionService } from '../../json-rpc/csolution-rpc-client';
 import { SolutionData } from './view/state/manage-solution-state';
 import { COMMAND_OPEN_SOLUTION } from '../../solutions/active-solution-tracker';
+import { IOpenFileExternal } from '../../open-file-external-if';
 
 type EditEntry = {
     label: string;
@@ -118,6 +119,7 @@ export class ManageSolutionCustomEditorProvider implements vscode.CustomEditorPr
         private readonly commandsProvider: CommandsProvider,
         private readonly configurationProvider: ConfigurationProvider,
         private readonly csolutionService: CsolutionService,
+        private readonly openFileExternal: IOpenFileExternal,
     ) { }
 
     private getOrCreateWebviewMain(): ManageSolutionWebviewMain {
@@ -134,6 +136,7 @@ export class ManageSolutionCustomEditorProvider implements vscode.CustomEditorPr
                 this.context,
                 this.solutionManager,
                 this.commandsProvider,
+                this.openFileExternal,
                 this.configurationProvider,
                 this.csolutionService,
                 (label, before, after) => this.activeDocument?.recordEdit(label, before, after),

src/views/manage-solution/manage-solution-webview-main.factories.ts

@@ -25,6 +25,8 @@ import { solutionManagerFactory } from '../../solutions/solution-manager.factori
 import { DataManager } from '../../data-manager/data-manager';
 import { DebugAdaptersYamlFile } from '../../debug/debug-adapters-yaml-file';
 import { configurationProviderFactory } from '../../vscode-api/configuration-provider.factories';
+import { IOpenFileExternal } from '../../open-file-external-if';
+import { openFileExternalFactory } from '../../open-file-external.factories';
 import { ETextFileResult } from '../../generic/text-file';
 import { SolutionData } from './view/state/manage-solution-state';
 import { ManageSolutionController } from './manage-solution-controller';
@@ -36,6 +38,7 @@ export type ManageSolutionWebviewMainFactoryOptions = {
     commandsProvider?: MockCommandsProvider;
     dataManager?: DataManager;
     debugAdaptersYmlFile?: DebugAdaptersYamlFile;
+    openFileExternal?: IOpenFileExternal;
     configurationProvider?: ReturnType<typeof configurationProviderFactory>;
     csolutionService?: CsolutionService,
     onEdit?: (label: string, before: SolutionData, after: SolutionData) => void,
@@ -76,6 +79,7 @@ export function manageSolutionWebviewMainFactory(options?: ManageSolutionWebview
         { subscriptions: [] } as unknown as vscode.ExtensionContext,
         options?.solutionManager ?? solutionManagerFactory(),
         options?.commandsProvider ?? commandsProviderFactory(),
+        options?.openFileExternal ?? openFileExternalFactory(),
         options?.configurationProvider ?? configurationProviderFactory(),
         options?.csolutionService ?? jest.mocked<CsolutionService>({
             getDeviceList: async function (_args: GetDeviceListParams): Promise<DeviceList> { throw new Error('Function not implemented.'); },