@eclipse-lyra/core 0.7.15 → 0.7.16

package/dist/widgets/index.js

@@ -1,3 +1,3 @@
-import "../nocontent-BhrN6yxJ.js";
-import "../icon-DN6fp0dg.js";
+import "../nocontent-TgnGDnXO.js";
+import "../icon-C3H7IMWU.js";
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-lyra/core",
-  "version": "0.7.15",
+  "version": "0.7.16",
   "description": "Eclipse Lyra platform core: registries, services, parts, widgets, and API",
   "type": "module",
   "license": "EPL-2.0",

package/src/api/services.ts

@@ -51,4 +51,10 @@ export { persistenceService } from '../core/persistenceservice';
 export { esmShService } from '../core/esmsh-service';
 export type { EsmShSource, EsmShOptions } from '../core/esmsh-service';
 export { i18nLazy, i18n, SYSTEM_LANGUAGE_BUNDLES } from '../core/i18n';
+export {
+    contributionTargetMappingRegistry,
+    overrideContributionTargets,
+    applyConfigNameRemaps,
+    listContributionNameRemaps
+} from '../core/contribution-mapping';
 

package/src/contributions/default-ui-contributions.ts

@@ -5,22 +5,31 @@ import {
     TOOLBAR_BOTTOM_END,
     TOOLBAR_MAIN_RIGHT
 } from "../core/constants";
+import {
+    VIEW_FILEBROWSER,
+    VIEW_LOG_TERMINAL,
+    TOOLBAR_APP_SWITCHER,
+    TOOLBAR_FAST_VIEWS,
+    TOOLBAR_INFO,
+    TOOLBAR_LANGUAGE_SELECTOR
+} from "../core/ui-ids";
 
 contributionRegistry.registerContribution(SIDEBAR_MAIN, {
-    name: "filebrowser",
+    name: VIEW_FILEBROWSER,
     label: "Workspace",
     icon: "folder-open",
     component: (id: string) => html`<lyra-filebrowser id="${id}"></lyra-filebrowser>`
 });
 
 contributionRegistry.registerContribution("system.fastviews-bottomend", {
-    name: "log-terminal",
+    name: VIEW_LOG_TERMINAL,
     label: "Log Messages",
     icon: "list",
     component: (id: string) => html`<lyra-log-terminal id="${id}"></lyra-log-terminal>`
 });
 
 contributionRegistry.registerContribution(TOOLBAR_BOTTOM_END, {
+    name: TOOLBAR_INFO,
     label: "Info",
     icon: "circle-info",
     command: "show_version_info",
@@ -28,16 +37,19 @@ contributionRegistry.registerContribution(TOOLBAR_BOTTOM_END, {
 });
 
 contributionRegistry.registerContribution(TOOLBAR_BOTTOM_END, {
+    name: TOOLBAR_FAST_VIEWS,
     label: `Fast Views`,
     component: `<lyra-fastviews target="system.fastviews-bottomend" icon="bolt" title="Fast Views"></lyra-fastviews>`
 });
 
 contributionRegistry.registerContribution(TOOLBAR_BOTTOM_END, {
+    name: TOOLBAR_LANGUAGE_SELECTOR,
     label: "Language",
     component: () => html`<lyra-language-selector></lyra-language-selector>`
 });
 
 contributionRegistry.registerContribution(TOOLBAR_MAIN_RIGHT, {
+    name: TOOLBAR_APP_SWITCHER,
     label: "App Switcher",
     component: () => html`<lyra-layout-switcher></lyra-layout-switcher>`
 } as HTMLContribution);

package/src/core/apploader.ts

@@ -12,14 +12,16 @@
  * - App Loader: Bridge between framework and application
  */
 
-import {render, TemplateResult, html} from "lit";
-import {rootContext} from "./di";
-import {createLogger} from "./logger";
-import {extensionRegistry, Extension} from "./extensionregistry";
-import {contributionRegistry, Contribution, LayoutContribution} from "./contributionregistry";
-import {SYSTEM_LAYOUTS} from "./constants";
-import {appSettings} from "./settingsservice";
+import { render, TemplateResult, html } from "lit";
+import { rootContext } from "./di";
+import { createLogger } from "./logger";
+import { extensionRegistry, Extension } from "./extensionregistry";
+import { contributionRegistry, Contribution, LayoutContribution, TOPIC_CONTRIBUTEIONS_CHANGED } from "./contributionregistry";
+import { SYSTEM_LAYOUTS } from "./constants";
+import { appSettings } from "./settingsservice";
 import { marketplaceRegistry } from "./marketplaceregistry";
+import { contributionTargetMappingRegistry, type ContributionNameRemap } from "./contribution-mapping";
+import { publish } from "./events";
 
 
 const logger = createLogger('AppLoader');
@@ -209,6 +211,12 @@ export interface AppDefinition {
 
     /** Marketplace catalog URLs for this app. Registered when the app is registered. */
     marketplaceCatalogUrls?: string[];
+
+    /**
+     * Optional contribution remaps for this application.
+     * Allows apps to declaratively remap contributions to different targets.
+     */
+    remaps?: ContributionNameRemap[];
 }
 
 /**
@@ -451,6 +459,19 @@ class AppLoaderService {
             }
         }
         
+        // Apply app-level contribution remaps before registering contributions
+        contributionTargetMappingRegistry.applyAppNameRemaps(app.remaps);
+        if (app.remaps?.length) {
+            const remappedTargets = new Set<string>();
+            for (const r of app.remaps) {
+                for (const t of r.targets) remappedTargets.add(t);
+            }
+            for (const target of remappedTargets) {
+                const contributions = contributionRegistry.getContributions(target);
+                publish(TOPIC_CONTRIBUTEIONS_CHANGED, { target, contributions });
+            }
+        }
+
         // Register app contributions
         if (app.contributions) {
             logger.info('Registering app contributions...');

package/src/core/contribution-mapping.ts

@@ -0,0 +1,142 @@
+import { rootContext } from "./di";
+import type { Contribution } from "./contributionregistry";
+
+export interface ContributionNameRemap {
+    /**
+     * Globally unique, namespaced contribution name
+     * (e.g. "view.filebrowser", "toolbar.filebrowser.rename").
+     */
+    name: string;
+    /**
+     * Effective target slots for this contribution.
+     * If empty, the original target is used.
+     */
+    targets: string[];
+}
+
+interface NameRemapState {
+    appTargets: string[] | undefined;
+    globalTargets: string[] | undefined;
+}
+
+/**
+ * Registry responsible for resolving effective contribution targets.
+ *
+ * It supports:
+ * - Global (framework-level) remaps.
+ * - App-level remaps coming from AppDefinition.
+ * - Multiple targets per contribution.
+ *
+ * Resolution precedence:
+ *   app-level remap > global remap > original target
+ */
+class ContributionTargetMappingRegistry {
+    private globalNameRemaps = new Map<string, string[]>();
+    private appNameRemaps = new Map<string, string[]>();
+
+    setGlobalNameRemap(name: string, targets: string[]): void {
+        this.globalNameRemaps.set(name, this.normalizeTargets(targets));
+    }
+
+    /** Clears all remaps. For testing only. */
+    resetForTesting(): void {
+        this.globalNameRemaps.clear();
+        this.appNameRemaps.clear();
+    }
+
+    applyAppNameRemaps(remaps: ContributionNameRemap[] | undefined | null): void {
+        this.appNameRemaps.clear();
+        if (!remaps) return;
+        for (const remap of remaps) {
+            this.appNameRemaps.set(remap.name, this.normalizeTargets(remap.targets));
+        }
+    }
+
+    /**
+     * Returns the effective target slots for a contribution given its original target.
+     *
+     * Semantics:
+     * - When a remap exists with a non-empty targets array, those targets are used.
+     * - When a remap exists with an empty targets array, the contribution is disabled (no targets).
+     * - When no remap exists, the original target is used.
+     */
+    getEffectiveTargets(originalTarget: string, contribution: Contribution): string[] {
+        const name = (contribution as any).name as string | undefined;
+        if (!name) {
+            return [originalTarget];
+        }
+
+        const appTargets = this.appNameRemaps.get(name);
+        if (appTargets) {
+            return appTargets.length > 0 ? appTargets : [];
+        }
+
+        const globalTargets = this.globalNameRemaps.get(name);
+        if (globalTargets) {
+            return globalTargets.length > 0 ? globalTargets : [];
+        }
+
+        return [originalTarget];
+    }
+
+    /**
+     * Returns current mapping state for debugging and tooling.
+     */
+    listNameRemaps(): Record<string, NameRemapState> {
+        const result: Record<string, NameRemapState> = {};
+        const allNames = new Set<string>([
+            ...this.globalNameRemaps.keys(),
+            ...this.appNameRemaps.keys()
+        ]);
+        for (const name of allNames) {
+            result[name] = {
+                appTargets: this.appNameRemaps.get(name),
+                globalTargets: this.globalNameRemaps.get(name)
+            };
+        }
+        return result;
+    }
+
+    private normalizeTargets(targets: string[]): string[] {
+        const seen = new Set<string>();
+        const result: string[] = [];
+        for (const t of targets) {
+            if (!t || seen.has(t)) continue;
+            seen.add(t);
+            result.push(t);
+        }
+        return result;
+    }
+}
+
+export const contributionTargetMappingRegistry = new ContributionTargetMappingRegistry();
+rootContext.put("contributionTargetMappingRegistry", contributionTargetMappingRegistry);
+
+/**
+ * Public helper to override contribution targets programmatically.
+ * This sets a global remap that applies across all apps.
+ */
+export function overrideContributionTargets(name: string, targets: string | string[]): void {
+    const normalized = Array.isArray(targets) ? targets : [targets];
+    contributionTargetMappingRegistry.setGlobalNameRemap(name, normalized);
+}
+
+/**
+ * Apply config-driven name remaps from a simple object.
+ * Intended for hosts that want to load JSON/YAML mapping files.
+ */
+export function applyConfigNameRemaps(config: Record<string, string | string[]>): void {
+    for (const [name, targets] of Object.entries(config)) {
+        const normalized = Array.isArray(targets) ? targets : [targets];
+        contributionTargetMappingRegistry.setGlobalNameRemap(name, normalized);
+    }
+}
+
+/**
+ * Convenience helper for debugging: returns current remap state
+ * for all known contribution names.
+ */
+export function listContributionNameRemaps(): Record<string, NameRemapState> {
+    return contributionTargetMappingRegistry.listNameRemaps();
+}
+

package/src/core/contributionregistry.ts

@@ -1,7 +1,8 @@
-import {Signal} from "@lit-labs/signals";
-import {TemplateResult} from "lit";
-import {publish} from "./events";
-import {rootContext} from "./di";
+import { Signal } from "@lit-labs/signals";
+import { TemplateResult } from "lit";
+import { publish } from "./events";
+import { rootContext } from "./di";
+import { contributionTargetMappingRegistry } from "./contribution-mapping";
 
 export const TOPIC_CONTRIBUTEIONS_CHANGED = "events/contributionregistry/contributionsChanged"
 
@@ -11,6 +12,8 @@ export interface ContributionChangeEvent {
 }
 
 export interface Contribution {
+    /** Optional globally unique, namespaced contribution name (e.g. "view.filebrowser"). */
+    name?: string;
     target?: string;
     label: string;
     icon?: string;
@@ -58,7 +61,7 @@ class ContributionRegistry {
     private contributions: Map<string, Contribution[]> = new Map();
 
     registerContribution<T extends Contribution>(target: string, contribution: T) {
-        const targetSlot = this.getContributions(target)!
+        const targetSlot = this.getOrCreateSlot(target);
         if ("command" in contribution) {
             const cmd = contribution as unknown as CommandContribution
             if (cmd.disabled instanceof Function) {
@@ -66,14 +69,47 @@ class ContributionRegistry {
             }
         }
         targetSlot.push(contribution);
-        publish(TOPIC_CONTRIBUTEIONS_CHANGED, { target, contributions: targetSlot } as ContributionChangeEvent)
+        publish(TOPIC_CONTRIBUTEIONS_CHANGED, { target, contributions: targetSlot } as ContributionChangeEvent);
+
+        const effectiveTargets = contributionTargetMappingRegistry.getEffectiveTargets(target, contribution);
+        for (const effectiveTarget of effectiveTargets) {
+            if (effectiveTarget === target) continue;
+            const contributionsForSlot = this.getContributions(effectiveTarget);
+            publish(TOPIC_CONTRIBUTEIONS_CHANGED, { target: effectiveTarget, contributions: contributionsForSlot } as ContributionChangeEvent);
+        }
     }
 
+    /**
+     * Returns all contributions whose *effective* targets include the given slot.
+     *
+     * Note: This currently scans all registered contributions and resolves
+     * remaps on each call (O(N) in number of contributions). This is acceptable
+     * for typical Lyra apps (dozens/hundreds of contributions and few slots),
+     * but if contribution counts grow significantly we may want to introduce a
+     * cached index of effective targets per slot to keep lookups O(1).
+     */
     getContributions<T extends Contribution>(target: string): T[] {
+        const results: T[] = [];
+        for (const [originalTarget, list] of this.contributions.entries()) {
+            const typedList = list as T[];
+            for (const contribution of typedList) {
+                const effectiveTargets = contributionTargetMappingRegistry.getEffectiveTargets(originalTarget, contribution);
+                if (effectiveTargets.includes(target)) {
+                    results.push(contribution);
+                }
+            }
+        }
+        if (results.length === 0) {
+            this.getOrCreateSlot(target);
+        }
+        return results;
+    }
+
+    private getOrCreateSlot(target: string): Contribution[] {
         if (!this.contributions.has(target)) {
-            this.contributions.set(target, [])
+            this.contributions.set(target, []);
         }
-        return this.contributions.get(target)! as T[]
+        return this.contributions.get(target)!;
     }
 }
 

package/src/core/ui-ids.ts

@@ -0,0 +1,14 @@
+export const VIEW_FILEBROWSER = "view.filebrowser";
+export const VIEW_LOG_TERMINAL = "view.logTerminal";
+
+export const TOOLBAR_INFO = "toolbar.info";
+export const TOOLBAR_FAST_VIEWS = "toolbar.fastViews";
+export const TOOLBAR_LANGUAGE_SELECTOR = "toolbar.languageSelector";
+export const TOOLBAR_APP_SWITCHER = "toolbar.appSwitcher";
+
+export const TOOLBAR_FILEBROWSER_RENAME = "toolbar.filebrowser.rename";
+export const TOOLBAR_FILEBROWSER_DELETE = "toolbar.filebrowser.delete";
+
+export const CTXMENU_FILEBROWSER_RENAME = "contextmenu.filebrowser.rename";
+export const CTXMENU_FILEBROWSER_DELETE = "contextmenu.filebrowser.delete";
+