@theia/plugin-ext 1.75.0-next.21 → 1.75.0-next.28

package/src/hosted/browser/worker/plugin-manifest-loader.ts

@@ -16,11 +16,11 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { PluginIdentifiers, PluginModel, PluginPackage } from '../../../common/plugin-protocol';
+import { PluginModel, PluginPackage } from '../../../common/plugin-protocol';
 import { Endpoint } from '@theia/core/lib/browser/endpoint';
 import URI from '@theia/core/lib/common/uri';
-
-const NLS_REGEX = /^%([\w\d.-]+)%$/i;
+import { localizeWithResolver } from '@theia/plugin-utils/lib/common/package-nls';
+import { prepareLoadedManifest } from '@theia/plugin-utils/lib/common/plugin-manifest';
 
 function getUri(pluginModel: PluginModel, relativePath: string): URI {
     const ownURI = new Endpoint().getRestUrl();
@@ -54,23 +54,18 @@ function readContents(uri: string): Promise<string> {
 
 async function readPluginJson(pluginModel: PluginModel, relativePath: string): Promise<any> {
     const content = await readPluginFile(pluginModel, relativePath);
-    const json = JSON.parse(content) as PluginPackage;
-    json.publisher ??= PluginIdentifiers.UNPUBLISHED;
-    return json;
+    return JSON.parse(content);
 }
 
 export async function loadManifest(pluginModel: PluginModel): Promise<any> {
     const [manifest, translations] = await Promise.all([
-        readPluginJson(pluginModel, 'package.json'),
+        readPluginJson(pluginModel, 'package.json').then(raw =>
+            prepareLoadedManifest(raw as PluginPackage, { updateActivationEvents: false })
+        ),
         loadTranslations(pluginModel)
     ]);
-    // translate vscode builtins, as they are published with a prefix.
-    const built_prefix = '@theia/vscode-builtin-';
-    if (manifest && manifest.name && manifest.name.startsWith(built_prefix)) {
-        manifest.name = manifest.name.substring(built_prefix.length);
-    }
     return manifest && translations && Object.keys(translations).length ?
-        localize(manifest, translations) :
+        localizeWithResolver(manifest, key => translations[key]) :
         manifest;
 }
 
@@ -84,31 +79,3 @@ async function loadTranslations(pluginModel: PluginModel): Promise<any> {
         return {};
     }
 }
-
-function localize(value: any, translations: {
-    [key: string]: string
-}): any {
-    if (typeof value === 'string') {
-        const match = NLS_REGEX.exec(value);
-        return match && translations[match[1]] || value;
-    }
-    if (Array.isArray(value)) {
-        const result = [];
-        for (const item of value) {
-            result.push(localize(item, translations));
-        }
-        return result;
-    }
-    if (value === null) {
-        return value;
-    }
-    if (typeof value === 'object') {
-        const result: { [key: string]: any } = {};
-        // eslint-disable-next-line guard-for-in
-        for (const propertyName in value) {
-            result[propertyName] = localize(value[propertyName], translations);
-        }
-        return result;
-    }
-    return value;
-}

package/src/hosted/browser/worker/worker-main.ts

@@ -35,6 +35,7 @@ import { EnvExtImpl } from '../../../plugin/env';
 import { DebugExtImpl } from '../../../plugin/debug/debug-ext';
 import { LocalizationExtImpl } from '../../../plugin/localization-ext';
 import pluginHostModule from './worker-plugin-module';
+import { PLUGINS_BASE_PATH } from '@theia/plugin-utils/lib/common/constants';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const ctx = self as any;
@@ -70,7 +71,7 @@ pluginManager.setPluginHost({
                         ctx.frontendModuleName = plugin.lifecycle.frontendModuleName;
                     }
 
-                    ctx.importScripts('./hostedPlugin/' + getPluginId(plugin.model) + '/' + plugin.pluginPath);
+                    ctx.importScripts(`./${PLUGINS_BASE_PATH}/` + getPluginId(plugin.model) + '/' + plugin.pluginPath);
                 }
             }
 

package/src/hosted/node/hosted-plugin-localization-service.ts

@@ -22,9 +22,11 @@ import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { DeployedPlugin, Localization as PluginLocalization, PluginIdentifiers, Translation } from '../../common';
 import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import { BackendApplicationContribution } from '@theia/core/lib/node';
-import { Disposable, DisposableCollection, isObject, MaybePromise, nls, Path, URI, ILogger } from '@theia/core';
+import { Disposable, DisposableCollection, MaybePromise, nls, Path, URI, ILogger } from '@theia/core';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import { LanguagePackBundle, LanguagePackService } from '../../common/language-pack-service';
+import { localizePackage } from '@theia/plugin-utils/lib/common/package-nls';
+import { loadPackageTranslations } from '@theia/plugin-utils/lib/node/package-nls';
 
 export interface VSCodeNlsConfig {
     locale: string
@@ -327,84 +329,3 @@ async function loadTranslations(packagePath: Path, translations: Translation[]):
 function buildTranslationKey(pluginId: string, scope: string, key: string): string {
     return `${pluginId}/${Localization.transformKey(scope)}/${key}`;
 }
-
-// Localization logic for `package.json` entries
-// Extensions can use `package.nls.json` files to store translations for values in their package.json
-// This logic has not changed with the introduction of the vscode.l10n API
-
-interface PackageTranslation {
-    translation?: Record<string, string>
-    default?: Record<string, string>
-}
-
-async function loadPackageTranslations(pluginPath: string, locale: string): Promise<PackageTranslation> {
-    const localizedPluginPath = path.join(pluginPath, `package.nls.${locale}.json`);
-    try {
-        const defaultValue = coerceLocalizations(await fs.readJson(path.join(pluginPath, 'package.nls.json')));
-        if (await fs.pathExists(localizedPluginPath)) {
-            return {
-                translation: coerceLocalizations(await fs.readJson(localizedPluginPath)),
-                default: defaultValue
-            };
-        }
-        return {
-            default: defaultValue
-        };
-    } catch (e) {
-        if (e.code !== 'ENOENT') {
-            throw e;
-        }
-        return {};
-    }
-}
-
-interface LocalizeInfo {
-    message: string
-    comment?: string
-}
-
-function isLocalizeInfo(obj: unknown): obj is LocalizeInfo {
-    return isObject(obj) && 'message' in obj || false;
-}
-
-function coerceLocalizations(translations: Record<string, string | LocalizeInfo>): Record<string, string> {
-    for (const [key, value] of Object.entries(translations)) {
-        if (isLocalizeInfo(value)) {
-            translations[key] = value.message;
-        } else if (typeof value !== 'string') {
-            // Only strings or LocalizeInfo values are valid
-            translations[key] = 'INVALID TRANSLATION VALUE';
-        }
-    }
-    return translations as Record<string, string>;
-}
-
-function localizePackage(value: unknown, translations: PackageTranslation, callback: (key: string, defaultValue: string) => string): unknown {
-    if (typeof value === 'string') {
-        let result = value;
-        if (value.length > 2 && value.startsWith('%') && value.endsWith('%')) {
-            const key = value.slice(1, -1);
-            if (translations.translation && key in translations.translation) {
-                result = translations.translation[key];
-            } else if (translations.default && key in translations.default) {
-                result = callback(key, translations.default[key]);
-            }
-        }
-        return result;
-    }
-    if (Array.isArray(value)) {
-        const result = [];
-        for (const item of value) {
-            result.push(localizePackage(item, translations, callback));
-        }
-        return result;
-    }
-    if (isObject(value)) {
-        const result: Record<string, unknown> = {};
-        for (const [name, item] of Object.entries(value)) {
-            result[name] = localizePackage(item, translations, callback);
-        }
-        return result;
-    }
-    return value;
-}

package/src/hosted/node/plugin-host-rpc.ts

@@ -25,7 +25,7 @@ import {
     MAIN_RPC_CONTEXT, Plugin, PluginAPIFactory, PluginManager,
     LocalizationExt
 } from '../../common/plugin-api-rpc';
-import { PluginMetadata, PluginModel } from '../../common/plugin-protocol';
+import { PluginMetadata, PluginModel, PluginPackage } from '../../common/plugin-protocol';
 import { createAPIFactory } from '../../plugin/plugin-context';
 import { EnvExtImpl } from '../../plugin/env';
 import { PreferenceRegistryExtImpl } from '../../plugin/preference-registry';
@@ -35,7 +35,7 @@ import { EditorsAndDocumentsExtImpl } from '../../plugin/editors-and-documents';
 import { WorkspaceExtImpl } from '../../plugin/workspace';
 import { MessageRegistryExt } from '../../plugin/message-registry';
 import { ClipboardExt } from '../../plugin/clipboard-ext';
-import { loadManifest } from './plugin-manifest-loader';
+import { loadManifest } from '@theia/plugin-utils/lib/node/plugin-manifest';
 import { KeyValueStorageProxy } from '../../plugin/plugin-storage';
 import { WebviewsExtImpl } from '../../plugin/webviews';
 import { TerminalServiceExtImpl } from '../../plugin/terminal-ext';
@@ -214,7 +214,7 @@ export abstract class AbstractPluginHostRPC<PM extends AbstractPluginManagerExtI
                         const pluginModel = plg.model;
                         const pluginLifecycle = plg.lifecycle;
 
-                        const rawModel = await loadManifest(pluginModel.packagePath);
+                        const rawModel = await loadManifest<PluginPackage>(pluginModel.packagePath);
                         rawModel.packagePath = pluginModel.packagePath;
                         if (pluginModel.entryPoint!.frontend) {
                             foreign.push({

package/src/hosted/node/plugin-reader.ts

@@ -23,7 +23,8 @@ import { inject, injectable, optional, multiInject } from '@theia/core/shared/in
 import { BackendApplicationContribution } from '@theia/core/lib/node/backend-application';
 import { PluginMetadata, getPluginId, MetadataProcessor, PluginPackage, PluginContribution } from '../../common/plugin-protocol';
 import { MetadataScanner } from './metadata-scanner';
-import { loadManifest } from './plugin-manifest-loader';
+import { loadManifest } from '@theia/plugin-utils/lib/node/plugin-manifest';
+import { PLUGINS_BASE_PATH } from '@theia/plugin-utils/lib/common/constants';
 
 @injectable()
 export class HostedPluginReader implements BackendApplicationContribution {
@@ -43,7 +44,7 @@ export class HostedPluginReader implements BackendApplicationContribution {
     protected pluginsIdsFiles: Map<string, string> = new Map();
 
     configure(app: express.Application): void {
-        app.get('/hostedPlugin/:pluginId/:path(*)', async (req, res) => {
+        app.get(`/${PLUGINS_BASE_PATH}/:pluginId/:path(*)`, async (req, res) => {
             const pluginId = req.params.pluginId;
             const filePath = req.params.path;
 
@@ -141,7 +142,7 @@ export class HostedPluginReader implements BackendApplicationContribution {
             return undefined;
         }
         const resolvedPluginPath = await realpath(pluginPath);
-        const manifest = await loadManifest(resolvedPluginPath);
+        const manifest = await loadManifest<PluginPackage>(resolvedPluginPath);
         if (!manifest) {
             return undefined;
         }

package/src/hosted/node/scanners/grammars-reader.ts

@@ -16,16 +16,20 @@
 
 import { injectable } from '@theia/core/shared/inversify';
 import { PluginPackageGrammarsContribution, GrammarsContribution } from '../../../common';
-import * as path from 'path';
-import * as fs from '@theia/core/shared/fs-extra';
+import { readGrammarFromDisk } from '@theia/plugin-utils/lib/node/read-grammars';
+import type { NormalizeContributionsContext } from '@theia/plugin-utils/lib/common/contribution-types';
 
 @injectable()
 export class GrammarsReader {
 
-    async readGrammars(rawGrammars: PluginPackageGrammarsContribution[], pluginPath: string): Promise<GrammarsContribution[]> {
+    async readGrammars(
+        rawGrammars: readonly PluginPackageGrammarsContribution[],
+        pluginPath: string,
+        log?: Pick<NormalizeContributionsContext, 'onError'>
+    ): Promise<GrammarsContribution[]> {
         const result = new Array<GrammarsContribution>();
         for (const rawGrammar of rawGrammars) {
-            const grammar = await this.readGrammar(rawGrammar, pluginPath);
+            const grammar = await this.readGrammar(rawGrammar, pluginPath, log);
             if (grammar) {
                 result.push(grammar);
             }
@@ -34,24 +38,11 @@ export class GrammarsReader {
         return result;
     }
 
-    private async readGrammar(rawGrammar: PluginPackageGrammarsContribution, pluginPath: string): Promise<GrammarsContribution | undefined> {
-        // TODO: validate inputs
-        let grammar: string | object;
-
-        if (rawGrammar.path.endsWith('json')) {
-            grammar = await fs.readJSON(path.resolve(pluginPath, rawGrammar.path));
-        } else {
-            grammar = await fs.readFile(path.resolve(pluginPath, rawGrammar.path), 'utf8');
-        }
-        return {
-            language: rawGrammar.language,
-            scope: rawGrammar.scopeName,
-            format: rawGrammar.path.endsWith('json') ? 'json' : 'plist',
-            grammar: grammar,
-            grammarLocation: rawGrammar.path,
-            injectTo: rawGrammar.injectTo,
-            embeddedLanguages: rawGrammar.embeddedLanguages,
-            tokenTypes: rawGrammar.tokenTypes
-        };
+    protected async readGrammar(
+        rawGrammar: PluginPackageGrammarsContribution,
+        pluginPath: string,
+        log?: Pick<NormalizeContributionsContext, 'onError'>
+    ): Promise<GrammarsContribution | undefined> {
+        return readGrammarFromDisk(rawGrammar, pluginPath, log);
     }
 }

package/src/hosted/node/scanners/scanner-theia.spec.ts

@@ -21,7 +21,7 @@ import * as os from 'os';
 import * as path from 'path';
 import * as fs from 'fs';
 import { AbstractPluginScanner, TheiaPluginScanner } from './scanner-theia';
-import { PluginPackage, PluginEntryPoint } from '../../../common/plugin-protocol';
+import { PluginPackage, PluginEntryPoint, PluginPackageWalkthrough, WalkthroughContribution } from '../../../common/plugin-protocol';
 import { PreferenceSchema } from '@theia/core/lib/common/preferences/preference-schema';
 import URI from '@theia/core/lib/common/uri';
 
@@ -206,3 +206,227 @@ describe('TheiaPluginScanner configuration default derivation', () => {
         expect(props['ext.nullable'].default).to.equal(null);
     });
 });
+
+describe('TheiaPluginScanner - readWalkthroughs', () => {
+    let scannerInstance: TheiaPluginScanner;
+
+    before(() => {
+        scannerInstance = new (TheiaPluginScanner as any)();
+        (scannerInstance as any).logger = { error: () => { }, warn: () => { }, info: () => { }, debug: () => { } };
+    });
+
+    function callReadWalkthroughs(
+        walkthroughs: PluginPackageWalkthrough[],
+        publisher = 'test-publisher',
+        name = 'test-plugin',
+        icon?: string
+    ): WalkthroughContribution[] | undefined {
+        const pkg = {
+            name,
+            publisher,
+            version: '1.0.0',
+            icon,
+            contributes: { walkthroughs }
+        } as any;
+        return (scannerInstance as any).readWalkthroughs(pkg);
+    }
+
+    it('should resolve the icon of the contributing extension', () => {
+        const result = callReadWalkthroughs([{
+            id: 'wt1',
+            title: 'WT',
+            description: 'desc',
+            steps: [{ id: 's1', title: 'S1', description: 'd1' }]
+        }], 'test-publisher', 'test-plugin', 'images/icon.png');
+
+        expect(result![0].pluginIcon).to.equal('hostedPlugin/test_publisher_test_plugin/images/icon.png');
+    });
+
+    it('should leave the extension icon undefined when the package declares none', () => {
+        const result = callReadWalkthroughs([{
+            id: 'wt1',
+            title: 'WT',
+            description: 'desc',
+            steps: [{ id: 's1', title: 'S1', description: 'd1' }]
+        }]);
+
+        expect(result![0].pluginIcon).to.be.undefined;
+    });
+
+    it('should read a valid walkthrough contribution', () => {
+        const result = callReadWalkthroughs([{
+            id: 'my-walkthrough',
+            title: 'My Walkthrough',
+            description: 'A test walkthrough',
+            steps: [{
+                id: 'step1',
+                title: 'Step 1',
+                description: 'First step',
+                completionEvents: ['onCommand:my.command']
+            }]
+        }]);
+
+        expect(result).to.not.be.undefined;
+        expect(result).to.have.lengthOf(1);
+        expect(result![0].id).to.equal('my-walkthrough');
+        expect(result![0].title).to.equal('My Walkthrough');
+        expect(result![0].pluginId).to.equal('test-publisher.test-plugin');
+        expect(result![0].steps).to.have.lengthOf(1);
+        expect(result![0].steps[0].id).to.equal('step1');
+        expect(result![0].steps[0].completionEvents).to.deep.equal(['onCommand:my.command']);
+    });
+
+    it('should skip walkthroughs with missing id', () => {
+        const result = callReadWalkthroughs([{
+            id: '',
+            title: 'No ID Walkthrough',
+            description: 'Missing id',
+            steps: []
+        }]);
+
+        expect(result).to.be.undefined;
+    });
+
+    it('should skip walkthroughs with missing title', () => {
+        const result = callReadWalkthroughs([{
+            id: 'valid-id',
+            title: '',
+            description: 'Missing title',
+            steps: []
+        }]);
+
+        expect(result).to.be.undefined;
+    });
+
+    it('should skip walkthrough steps with missing id', () => {
+        const result = callReadWalkthroughs([{
+            id: 'wt1',
+            title: 'WT1',
+            description: 'desc',
+            steps: [
+                { id: '', title: 'Step', description: 'desc' },
+                { id: 'valid-step', title: 'Valid Step', description: 'desc' }
+            ]
+        }]);
+
+        expect(result).to.have.lengthOf(1);
+        expect(result![0].steps).to.have.lengthOf(1);
+        expect(result![0].steps[0].id).to.equal('valid-step');
+    });
+
+    it('should return undefined when no walkthroughs are contributed', () => {
+        const pkg = { name: 'test', publisher: 'pub', contributes: {} } as any;
+        const result = (scannerInstance as any).readWalkthroughs(pkg);
+        expect(result).to.be.undefined;
+    });
+
+    it('should read multiple walkthroughs', () => {
+        const result = callReadWalkthroughs([
+            {
+                id: 'wt1',
+                title: 'Walkthrough 1',
+                description: 'First',
+                steps: [{ id: 's1', title: 'S1', description: 'd1' }]
+            },
+            {
+                id: 'wt2',
+                title: 'Walkthrough 2',
+                description: 'Second',
+                steps: [{ id: 's2', title: 'S2', description: 'd2' }]
+            }
+        ]);
+
+        expect(result).to.have.lengthOf(2);
+        expect(result![0].id).to.equal('wt1');
+        expect(result![1].id).to.equal('wt2');
+    });
+
+    it('should preserve walkthrough optional fields', () => {
+        const result = callReadWalkthroughs([{
+            id: 'wt-full',
+            title: 'Full Walkthrough',
+            description: 'Full desc',
+            steps: [{
+                id: 's1',
+                title: 'S1',
+                description: 'step desc',
+                when: 'isLinux',
+                media: { markdown: 'content.md' },
+                completionEvents: ['onCommand:test']
+            }],
+            when: 'workspacePlatform == linux',
+            icon: 'book'
+        }]);
+
+        expect(result).to.have.lengthOf(1);
+        expect(result![0].when).to.equal('workspacePlatform == linux');
+        expect(result![0].icon).to.equal('book');
+        expect(result![0].steps[0].when).to.equal('isLinux');
+        expect(result![0].steps[0].media).to.deep.equal({ markdown: 'hostedPlugin/test_publisher_test_plugin/content.md' });
+    });
+
+    it('should lowercase pluginId', () => {
+        const result = callReadWalkthroughs([{
+            id: 'wt1',
+            title: 'WT',
+            description: 'desc',
+            steps: [{ id: 's1', title: 'S1', description: 'd1' }]
+        }], 'MyPublisher', 'MyPlugin');
+
+        expect(result).to.have.lengthOf(1);
+        expect(result![0].pluginId).to.equal('mypublisher.myplugin');
+    });
+
+    it('should resolve media image paths through toPluginUrl', () => {
+        const result = callReadWalkthroughs([{
+            id: 'wt1',
+            title: 'WT',
+            description: 'desc',
+            steps: [{
+                id: 's1',
+                title: 'S1',
+                description: 'd1',
+                media: { image: 'media/image.png' }
+            }]
+        }]);
+
+        expect(result).to.have.lengthOf(1);
+        expect(result![0].steps[0].media).to.deep.equal({ image: 'hostedPlugin/test_publisher_test_plugin/media/image.png' });
+    });
+
+    it('should keep the alt text of svg media', () => {
+        const result = callReadWalkthroughs([{
+            id: 'wt1',
+            title: 'WT',
+            description: 'desc',
+            steps: [{
+                id: 's1',
+                title: 'S1',
+                description: 'd1',
+                media: { svg: 'media/icon.svg', altText: 'An icon' }
+            }]
+        }]);
+
+        expect(result![0].steps[0].media).to.deep.equal({
+            svg: 'hostedPlugin/test_publisher_test_plugin/media/icon.svg',
+            altText: 'An icon'
+        });
+    });
+
+    it('should resolve media svg paths through toPluginUrl', () => {
+        const result = callReadWalkthroughs([{
+            id: 'wt1',
+            title: 'WT',
+            description: 'desc',
+            steps: [{
+                id: 's1',
+                title: 'S1',
+                description: 'd1',
+                media: { svg: 'media/icon.svg' }
+            }]
+        }]);
+
+        expect(result).to.have.lengthOf(1);
+        expect(result![0].steps[0].media).to.deep.equal({ svg: 'hostedPlugin/test_publisher_test_plugin/media/icon.svg' });
+    });
+});