@eclipse-lyra/core 0.7.5 → 0.7.7

package/src/core/apploader.ts

@@ -16,8 +16,10 @@ import {render, TemplateResult, html} from "lit";
 import {rootContext} from "./di";
 import {createLogger} from "./logger";
 import {extensionRegistry, Extension} from "./extensionregistry";
-import {contributionRegistry, Contribution} from "./contributionregistry";
+import {contributionRegistry, Contribution, LayoutContribution} from "./contributionregistry";
+import {SYSTEM_LAYOUTS} from "./constants";
 import {appSettings} from "./settingsservice";
+import { marketplaceRegistry } from "./marketplaceregistry";
 
 
 const logger = createLogger('AppLoader');
@@ -122,17 +124,17 @@ export interface RenderDescriptor {
  * Applications implement this interface to integrate with the framework.
  */
 export interface AppDefinition {
-    /** Unique application identifier */
-    id: string;
-    
-    /** Human-readable application name */
-    name: string;
-    
-    /** Application version */
-    version: string;
-    
-    /** Optional application description */
+    /** Application name (from package.json). Unique key; set by hostConfig resolution when omitted. */
+    name?: string;
+
+    /** Application version. Set by hostConfig resolution from package.json when omitted. */
+    version?: string;
+
+    /** Application description. Set by hostConfig resolution from package.json when omitted. */
     description?: string;
+
+    /** Optional URL path segment for routing (e.g. "geospace"). When absent, name is used for lookup. */
+    path?: string;
     
     /**
      * Custom application metadata (optional).
@@ -168,32 +170,32 @@ export interface AppDefinition {
      * (if metadata.github is configured).
      */
     releaseHistory?: ReleaseHistory | (() => ReleaseHistory | Promise<ReleaseHistory>);
-    
+
     /**
-     * Root component to render. Can be:
-     * - A tag name string (e.g. "lyra-standard-layout") for a single custom element with no attributes.
-     * - A descriptor { tag, attributes? } for a single custom element with optional attributes.
-     * - A function returning a Lit TemplateResult for custom templates (requires lit in the app).
-     * If not provided, defaults to lyra-standard-layout.
+     * Id of a layout registered to the system.layouts contribution slot.
+     * The app root is always the chosen layout's component. Defaults to 'standard' when omitted.
      */
-    render?: string | RenderDescriptor | (() => TemplateResult);
+    layoutId?: string;
 
     /**
      * Optional cleanup function.
      * Called when the app is being unloaded, before extensions are disabled.
      */
     dispose?: () => void | Promise<void>;
+
+    /** Resolved dependency versions (e.g. from build plugin). Shown in About / version info. */
+    dependencies?: Record<string, string>;
+
+    /** Marketplace catalog URLs for this app. Registered when the app is registered. */
+    marketplaceCatalogUrls?: string[];
 }
 
 /**
  * Options for registering an application with the apploader.
  */
 export interface RegisterAppOptions {
-    /** 
-     * Default app ID to load if no app URL parameter is provided.
-     * If not specified, the first registered app will be loaded.
-     */
-    defaultAppId?: string;
+    /** Default app name to load if no app URL parameter is provided. If not specified, the first registered app is loaded. */
+    defaultAppName?: string;
     
     /** 
      * Whether to automatically start the apploader after registration.
@@ -207,6 +209,11 @@ export interface RegisterAppOptions {
      * Defaults to document.body.
      */
     container?: HTMLElement;
+
+    /**
+     * When true, fill name, version, description, dependencies, marketplaceCatalogUrls from __RESOLVED_PACKAGE_INFO__ only when not already set on the app.
+     */
+    hostConfig?: boolean;
 }
 
 /**
@@ -222,10 +229,12 @@ class AppLoaderService {
     private apps: Map<string, AppDefinition> = new Map();
     private currentApp?: AppDefinition;
     private started: boolean = false;
-    private defaultAppId?: string;
+    private defaultAppName?: string;
     private container: HTMLElement = document.body;
     private systemRequiredExtensions: Set<string> = new Set();
-    private static readonly PREFERRED_APP_KEY = 'preferredAppId';
+    private static readonly PREFERRED_APP_KEY = 'preferredAppName';
+    private static readonly PREFERRED_LAYOUT_KEY = 'preferredLayoutId';
+    private preferredLayoutId?: string;
     
     /**
      * Register an application with the framework.
@@ -235,15 +244,29 @@ class AppLoaderService {
      * @param options - Optional configuration for registration and auto-starting
      */
     registerApp(app: AppDefinition, options?: RegisterAppOptions): void {
-        if (this.apps.has(app.id)) {
-            logger.warn(`App '${app.id}' is already registered. Overwriting.`);
+        if (options?.hostConfig === true && typeof __RESOLVED_PACKAGE_INFO__ !== 'undefined') {
+            const resolved = __RESOLVED_PACKAGE_INFO__;
+            if (app.name === undefined) app.name = resolved.name;
+            if (app.version === undefined) app.version = resolved.version;
+            if (app.description === undefined) app.description = resolved.description;
+            if (app.dependencies === undefined) app.dependencies = resolved.dependencies;
+            if (app.marketplaceCatalogUrls === undefined) app.marketplaceCatalogUrls = resolved.marketplaceCatalogUrls;
         }
-        
-        this.apps.set(app.id, app);
-        logger.info(`Registered app: ${app.name} (${app.id}) v${app.version}`);
-        
-        if (options?.defaultAppId) {
-            this.defaultAppId = options.defaultAppId;
+        app.name = app.name ?? 'app';
+        app.version = app.version ?? '0.0.0';
+
+        if (this.apps.has(app.name)) {
+            logger.warn(`App '${app.name}' is already registered. Overwriting.`);
+        }
+        if (app.marketplaceCatalogUrls?.length) {
+            app.marketplaceCatalogUrls.forEach((url) => marketplaceRegistry.addCatalogUrl(url).catch(() => {}));
+        }
+
+        this.apps.set(app.name, app);
+        logger.info(`Registered app: ${app.name} v${app.version}`);
+
+        if (options?.defaultAppName) {
+            this.defaultAppName = options.defaultAppName;
         }
         
         if (options?.container) {
@@ -279,11 +302,10 @@ class AppLoaderService {
             
             const app = module.default as AppDefinition;
             
-            if (!app.id || !app.name || !app.version) {
-                throw new Error(`Module at ${url} does not export a valid AppDefinition`);
+            if (!app.name || !app.version) {
+                throw new Error(`Module at ${url} does not export a valid AppDefinition (name and version required)`);
             }
-            
-            logger.info(`Successfully loaded app definition from URL: ${app.name} (${app.id})`);
+            logger.info(`Successfully loaded app definition from URL: ${app.name}`);
             return app;
         } catch (error) {
             logger.error(`Failed to load app from URL ${url}: ${getErrorMessage(error)}`);
@@ -294,7 +316,7 @@ class AppLoaderService {
     /**
      * Start the application loader.
      * Checks URL parameters for app=URL, loads that extension or app if found.
-     * URL parameter has higher precedence than defaultAppId.
+     * URL parameter has higher precedence than defaultAppName.
      * Then loads the default app or first registered app.
      * This method is idempotent - calling it multiple times only starts once.
      */
@@ -338,7 +360,8 @@ class AppLoaderService {
                     try {
                         const app = await this.loadAppFromUrl(appUrl);
                         this.registerApp(app);
-                        await this.loadApp(app.id, this.container);
+                        if (!app.name) throw new Error('App from URL has no name after registration');
+                        await this.loadApp(app.name, this.container);
                         logger.info(`Successfully loaded app from URL: ${appUrl}`);
                         return;
                     } catch (appError) {
@@ -365,17 +388,26 @@ class AppLoaderService {
         await this.loadApp(appToLoad, this.container);
     }
 
+    /**
+     * Resolve a path/URL segment to an app name (map key). Matches app.path, app.name, or name ending with /segment.
+     */
+    private findAppNameBySegment(segment: string): string | undefined {
+        if (this.apps.has(segment)) return segment;
+        for (const app of this.apps.values()) {
+            if (app.path === segment || (app.name && app.name.endsWith('/' + segment))) return app.name ?? undefined;
+        }
+        return undefined;
+    }
+
     /**
      * Load and initialize an application.
-     * 
-     * @param appId - Application identifier (must be already registered)
+     * @param appName - Application name (must be already registered)
      * @param container - Optional DOM element to render into (if provided, auto-renders after loading)
-     * @returns Promise that resolves when app is initialized and rendered
      */
-    async loadApp(appId: string, container?: HTMLElement): Promise<void> {
-        const app = this.apps.get(appId);
+    async loadApp(appName: string, container?: HTMLElement): Promise<void> {
+        const app = this.apps.get(appName);
         if (!app) {
-            throw new Error(`App '${appId}' not found. Make sure it's registered.`);
+            throw new Error(`App '${appName}' not found. Make sure it's registered.`);
         }
         
         logger.info(`Loading app: ${app.name}...`);
@@ -442,25 +474,21 @@ class AppLoaderService {
         
         this.currentApp = app;
         logger.info(`App ${app.name} loaded successfully`);
-        
-        // Update document metadata from app
+        this.preferredLayoutId = await this.getPreferredLayoutId();
         this.updateDocumentMetadata(app);
-        
-        // Auto-render if container provided
         if (container) {
             this.renderApp(container);
         }
         
         // Dispatch event for components to react to app changes
-        window.dispatchEvent(new CustomEvent('app-loaded', { detail: { appId: app.id } }));
+        window.dispatchEvent(new CustomEvent('app-loaded', { detail: { appName: app.name } }));
     }
     
     /**
      * Updates document title and favicon from app metadata
      */
     private updateDocumentMetadata(app: AppDefinition): void {
-        // Set document title
-        document.title = app.name;
+        document.title = app.name ?? '';
         
         // Set favicon if provided in metadata
         if (app.metadata?.favicon) {
@@ -478,7 +506,8 @@ class AppLoaderService {
     
     /**
      * Render the current application to the DOM.
-     * 
+     * Resolves the layout by layoutId (default 'standard'), renders its component, then calls layout.onShow if defined.
+     *
      * @param container - DOM element to render into
      */
     renderApp(container: HTMLElement): void {
@@ -486,23 +515,39 @@ class AppLoaderService {
             throw new Error('No app loaded. Call loadApp() first.');
         }
 
-        const r = this.currentApp.render;
+        const layoutId = this.preferredLayoutId ?? this.currentApp.layoutId ?? 'standard';
+        const layouts = contributionRegistry.getContributions<LayoutContribution>(SYSTEM_LAYOUTS);
+        let layout = layouts.find((c) => c.id === layoutId);
+        if (!layout) {
+            logger.warn(`Layout '${layoutId}' not found, falling back to 'standard'`);
+            layout = layouts.find((c) => c.id === 'standard');
+        }
+        if (!layout) {
+            throw new Error(`No layout found for layoutId '${layoutId}' and no 'standard' layout registered.`);
+        }
+
+        const r = layout.component;
+        container.innerHTML = '';
         if (typeof r === 'string') {
-            const el = document.createElement(r);
-            container.innerHTML = '';
-            container.appendChild(el);
+            container.appendChild(document.createElement(r));
         } else if (r && typeof r === 'object' && 'tag' in r) {
             const el = document.createElement(r.tag);
             for (const [key, value] of Object.entries(r.attributes ?? {})) {
                 el.setAttribute(key, value);
             }
-            container.innerHTML = '';
             container.appendChild(el);
         } else if (typeof r === 'function') {
-            const template = r();
-            render(template, container);
+            render(r(), container);
         } else {
-            render(html`<lyra-standard-layout></lyra-standard-layout>`, container);
+            throw new Error(`Layout '${layout.id}' has invalid component.`);
+        }
+
+        if (layout.onShow) {
+            requestAnimationFrame(() => {
+                void Promise.resolve(layout!.onShow!()).catch((err) =>
+                    logger.error(`Layout onShow failed for '${layout!.id}': ${getErrorMessage(err)}`)
+                );
+            });
         }
         logger.info(`Rendered ${this.currentApp.name}`);
     }
@@ -540,13 +585,48 @@ class AppLoaderService {
         if (!this.apps.has(appId)) {
             throw new Error(`App '${appId}' not found. Make sure it's registered.`);
         }
-        
         try {
             await appSettings.set(AppLoaderService.PREFERRED_APP_KEY, appId);
-            this.defaultAppId = appId;
+            this.defaultAppName = appId;
             logger.info(`Set preferred app to: ${appId}`);
         } catch (error) {
-            logger.error(`Failed to persist preferred app ID: ${getErrorMessage(error)}`);
+            logger.error(`Failed to persist preferred app: ${getErrorMessage(error)}`);
+            throw error;
+        }
+    }
+
+    getRegisteredLayouts(): LayoutContribution[] {
+        return contributionRegistry.getContributions<LayoutContribution>(SYSTEM_LAYOUTS);
+    }
+
+    getCurrentLayoutId(): string {
+        return this.preferredLayoutId ?? this.currentApp?.layoutId ?? 'standard';
+    }
+
+    async getPreferredLayoutId(): Promise<string | undefined> {
+        try {
+            return await appSettings.get(AppLoaderService.PREFERRED_LAYOUT_KEY);
+        } catch (error) {
+            logger.debug(`Failed to get preferred layout ID: ${getErrorMessage(error)}`);
+            return undefined;
+        }
+    }
+
+    async setPreferredLayoutId(layoutId: string): Promise<void> {
+        const layouts = this.getRegisteredLayouts();
+        if (!layouts.some((l) => l.id === layoutId)) {
+            throw new Error(`Layout '${layoutId}' not found.`);
+        }
+        try {
+            await appSettings.set(AppLoaderService.PREFERRED_LAYOUT_KEY, layoutId);
+            this.preferredLayoutId = layoutId;
+            logger.info(`Set preferred layout to: ${layoutId}`);
+            if (this.currentApp && this.container) {
+                this.renderApp(this.container);
+            }
+            window.dispatchEvent(new CustomEvent('layout-changed', { detail: { layoutId } }));
+        } catch (error) {
+            logger.error(`Failed to persist preferred layout: ${getErrorMessage(error)}`);
             throw error;
         }
     }
@@ -554,11 +634,11 @@ class AppLoaderService {
     /**
      * Select which app to load based on priority:
      * 1. appId URL parameter (?appId=...)
-     * 2. App ID from current page URL path (/geospace)
-     * 3. App ID extracted from app URL parameter (?app=...)
+     * 2. App from current page URL path (/geospace)
+     * 3. App from app URL parameter (?app=...)
      * 4. App registered by extension
-     * 5. Preferred app ID from settings
-     * 6. Default app ID
+     * 5. Preferred app from settings
+     * 6. Default app
      * 7. First registered app
      */
     private async selectAppToLoad(options: {
@@ -568,59 +648,62 @@ class AppLoaderService {
         appsBeforeExtension: number;
     }): Promise<string | undefined> {
         const { appIdFromUrl, appIdFromPath, appIdFromAppUrl, appsBeforeExtension } = options;
-        
+
         if (appIdFromUrl) {
-            if (this.apps.has(appIdFromUrl)) {
-                logger.info(`Loading app specified by URL parameter 'appId': ${appIdFromUrl}`);
-                return appIdFromUrl;
+            const name = this.findAppNameBySegment(appIdFromUrl) ?? appIdFromUrl;
+            if (this.apps.has(name)) {
+                logger.info(`Loading app specified by URL parameter 'appId': ${name}`);
+                return name;
             }
-            logger.warn(`App ID '${appIdFromUrl}' from URL parameter not found`);
+            logger.warn(`App '${appIdFromUrl}' from URL parameter not found`);
         }
-        
+
         if (appIdFromPath) {
-            if (this.apps.has(appIdFromPath)) {
+            const name = this.findAppNameBySegment(appIdFromPath);
+            if (name) {
                 logger.info(`Loading app from URL path: ${appIdFromPath}`);
-                return appIdFromPath;
+                return name;
             }
-            logger.debug(`App ID '${appIdFromPath}' from URL path not found, continuing search`);
+            logger.debug(`App for path '${appIdFromPath}' not found, continuing search`);
         }
-        
+
         if (appIdFromAppUrl) {
-            if (this.apps.has(appIdFromAppUrl)) {
-                logger.info(`Loading app using ID extracted from app URL path: ${appIdFromAppUrl}`);
-                return appIdFromAppUrl;
+            const name = this.findAppNameBySegment(appIdFromAppUrl) ?? appIdFromAppUrl;
+            if (this.apps.has(name)) {
+                logger.info(`Loading app using segment from app URL path: ${name}`);
+                return name;
             }
         }
-        
+
         if (this.apps.size > appsBeforeExtension) {
             const newlyRegisteredApps = Array.from(this.apps.values()).slice(appsBeforeExtension);
             if (newlyRegisteredApps.length > 0) {
                 const app = newlyRegisteredApps[0];
-                logger.info(`Loading app registered by extension: ${app.name} (${app.id})`);
-                return app.id;
+                logger.info(`Loading app registered by extension: ${app.name}`);
+                return app.name;
             }
         }
-        
-        const preferredAppId = await this.getPreferredAppId();
-        if (preferredAppId && this.apps.has(preferredAppId)) {
-            logger.info(`Loading preferred app from settings: ${preferredAppId}`);
-            return preferredAppId;
+
+        const preferred = await this.getPreferredAppId();
+        if (preferred && this.apps.has(preferred)) {
+            logger.info(`Loading preferred app from settings: ${preferred}`);
+            return preferred;
         }
-        
-        if (this.defaultAppId) {
-            if (this.apps.has(this.defaultAppId)) {
-                return this.defaultAppId;
-            }
-            logger.warn(`Default app '${this.defaultAppId}' not found`);
+
+        if (this.defaultAppName && this.apps.has(this.defaultAppName)) {
+            return this.defaultAppName;
         }
-        
+        if (this.defaultAppName) {
+            logger.warn(`Default app '${this.defaultAppName}' not found`);
+        }
+
         const registeredApps = this.getRegisteredApps();
         if (registeredApps.length > 0) {
             const app = registeredApps[0];
-            logger.info(`Loading first registered app: ${app.name} (${app.id})`);
-            return app.id;
+            logger.info(`Loading first registered app: ${app.name}`);
+            return app.name;
         }
-        
+
         return undefined;
     }
 }

package/src/core/constants.ts

@@ -7,6 +7,7 @@ export const TOOLBAR_BOTTOM_CENTER = "app-toolbars-bottom-center"
 export const TOOLBAR_BOTTOM_END = "app-toolbars-bottom-end"
 
 export const SYSTEM_VIEWS = "system-views"
+export const SYSTEM_LAYOUTS = "system.layouts"
 
 // VS Code-style layout containers
 export const EDITOR_AREA_MAIN = "editor-area-main"

package/src/core/contributionregistry.ts

@@ -25,7 +25,7 @@ export interface CommandContribution extends Contribution {
 }
 
 export interface HTMLContribution extends Contribution {
-    html: string | (() => TemplateResult)
+    component: string | (() => TemplateResult)
 }
 
 export interface TabContribution extends Contribution {
@@ -40,20 +40,18 @@ export interface TabContribution extends Contribution {
     component?: (id: string) => TemplateResult;
 }
 
-export interface PaneContribution extends Contribution {
-    name: string;
-    size?: number;
-    minSize?: number;
-    maxSize?: number;
-    order?: number;
-    component: () => TemplateResult;
-}
-
 export interface IconContribution extends Contribution {
     mappings: Record<string, string>;
     priority?: number;
 }
 
+export interface LayoutContribution extends Contribution {
+    id: string;
+    name: string;
+    component: string | { tag: string; attributes?: Record<string, string> } | (() => TemplateResult);
+    onShow?: () => void | Promise<void>;
+}
+
 class ContributionRegistry {
     private contributions: Map<string, Contribution[]> = new Map();
 

package/src/core/editorregistry.ts

@@ -16,7 +16,7 @@ export interface EditorInput {
     icon?: string;
     data: any;
     noOverflow?: boolean;
-    widgetFactory: (container: any, tab: HTMLElement) => any;
+    component: (container: any, tab: HTMLElement) => any;
     state: { [key: string]: any };
 }
 
@@ -246,11 +246,11 @@ class EditorRegistry {
             return
         }
 
-        if (!("widgetFactory" in editorInput)) {
+        if (!("component" in editorInput)) {
             editorInput = await this.handleInput(editorInput, preferredEditorId)
         }
 
-        if (!editorInput || !("widgetFactory" in editorInput)) {
+        if (!editorInput || !("component" in editorInput)) {
             return
         }
 
@@ -264,7 +264,7 @@ class EditorRegistry {
             icon: editorInput.icon,
             closable: true,
             noOverflow: editorInput.noOverflow,
-            component: editorInput.widgetFactory
+            component: editorInput.component
         } as TabContribution) 
     }
 

package/src/core/index.ts

@@ -18,7 +18,6 @@ import './settingsservice';
 
 // 2. Registries and task service (contribution first – others depend on it)
 import './contributionregistry';
-import './packageinfoservice';
 import './taskservice';
 
 // 3. i18n and ESM

package/src/parts/contextmenu.ts

@@ -198,8 +198,8 @@ export class LyraContextMenu extends LyraElement {
                     ${commandContribution.label}
                 </lyra-command>
             `;
-        } else if ("html" in contribution) {
-            const contents = (contribution as HTMLContribution).html;
+        } else if ("component" in contribution) {
+            const contents = (contribution as HTMLContribution).component;
             if (contents instanceof Function) {
                 return contents();
             }

package/src/parts/toolbar.ts

@@ -186,7 +186,7 @@ export class LyraToolbar extends LyraElement {
     }
 
     private isToolbarItem(contribution: Contribution): boolean {
-        return "command" in contribution || "html" in contribution;
+        return "command" in contribution || "component" in contribution;
     }
 
     contributionCreator(contribution: Contribution) {
@@ -203,8 +203,8 @@ export class LyraToolbar extends LyraElement {
                 </wa-button>
             `;
         }
-        if ("html" in contribution) {
-            const contents = (contribution as HTMLContribution).html
+        if ("component" in contribution) {
+            const contents = (contribution as HTMLContribution).component
             if (contents instanceof Function) {
                 return contents()
             }

package/src/vite-env.d.ts

@@ -1,5 +1,14 @@
 /// <reference types="vite/client" />
 
+/** Injected by resolveDepVersionsPlugin when hostConfig is true. */
+declare const __RESOLVED_PACKAGE_INFO__: {
+  name: string;
+  version: string;
+  description?: string;
+  dependencies: Record<string, string>;
+  marketplaceCatalogUrls?: string[];
+} | undefined;
+
 declare module 'toastify-js' {
   interface ToastifyOptions {
     text?: string;