@kispace-io/core 0.7.0

package/src/core/i18n.ts

@@ -0,0 +1,221 @@
+import { signal, Signal } from '@lit-labs/signals';
+import { Contribution, contributionRegistry, TOPIC_CONTRIBUTEIONS_CHANGED, ContributionChangeEvent } from "./contributionregistry";
+import { appSettings, TOPIC_SETTINGS_CHANGED } from "./settingsservice";
+import { subscribe } from "./events";
+import { rootContext } from "./di";
+
+export const SYSTEM_LANGUAGE_BUNDLES = 'system.language_bundles';
+export const SETTINGS_KEY_LANGUAGE = 'language';
+
+export interface LanguageBundleContribution extends Omit<Contribution, 'label'> {
+    namespace: string;
+    language?: string;
+    translations?: Record<string, string>;
+    [languageCode: string]: any;
+}
+
+function replaceParameters(text: string, params?: Record<string, string>): string {
+    if (!params) {
+        return text;
+    }
+
+    return text.replace(/\{(\w+)\}/g, (match, paramKey) => {
+        return params[paramKey] !== undefined ? params[paramKey] : match;
+    });
+}
+
+export class LazyTranslation extends String {
+    private cachedValue?: string;
+    private cachedLanguage?: string;
+
+    constructor(
+        private readonly i18nService: I18nService,
+        private readonly namespace: string,
+        private readonly key: string,
+        private readonly params?: Record<string, string>
+    ) {
+        super('');
+    }
+
+    toString(): string {
+        const currentLanguage = this.i18nService.currentLanguageSignal.get();
+        
+        if (this.cachedValue !== undefined && this.cachedLanguage === currentLanguage) {
+            return this.cachedValue;
+        }
+
+        this.cachedValue = this.i18nService.translate(this.namespace, this.key, this.params);
+        this.cachedLanguage = currentLanguage;
+        return this.cachedValue;
+    }
+
+    valueOf(): string {
+        return this.toString();
+    }
+
+    [Symbol.toPrimitive](hint: 'default' | 'string' | 'number'): string | number {
+        if (hint === 'number') {
+            const num = Number(this.toString());
+            return isNaN(num) ? 0 : num;
+        }
+        return this.toString();
+    }
+
+    toJSON(): string {
+        return this.toString();
+    }
+}
+
+export type UILabel = string | LazyTranslation;
+
+class I18nService {
+    private static readonly DEFAULT_LANGUAGE = 'en';
+    private readonly translationCache = new Map<string, Record<string, string>>();
+
+    public readonly currentLanguageSignal: Signal.State<string>;
+    public readonly languageContributionsSignal: Signal.State<LanguageBundleContribution[]>;
+
+    constructor() {
+        this.currentLanguageSignal = signal<string>(this.getBrowserLanguage());
+        this.languageContributionsSignal = signal<LanguageBundleContribution[]>([]);
+
+        this.initialize();
+    }
+
+    private getBrowserLanguage(): string {
+        const browserLanguage = navigator.language || navigator.languages?.[0] || I18nService.DEFAULT_LANGUAGE;
+        return browserLanguage.split('-')[0].toLowerCase();
+    }
+
+    private async initializeLanguage(): Promise<string> {
+        const settingsLanguage = await appSettings.get(SETTINGS_KEY_LANGUAGE);
+        return settingsLanguage || this.getBrowserLanguage();
+    }
+
+    private async updateLanguageFromSettings(): Promise<void> {
+        const language = await this.initializeLanguage();
+        this.currentLanguageSignal.set(language);
+    }
+
+    private getPrimaryLanguage(language: string): string {
+        return language.split('-')[0].toLowerCase();
+    }
+
+    private updateLanguageContributions(): void {
+        const contributions = contributionRegistry.getContributions<Contribution>(SYSTEM_LANGUAGE_BUNDLES) as unknown as LanguageBundleContribution[];
+        this.languageContributionsSignal.set(contributions);
+    }
+
+    private createCacheKey(namespace: string, language: string): string {
+        return `${namespace}:${language}`;
+    }
+
+    public mergeTranslationsForLanguage(
+        contributions: LanguageBundleContribution[],
+        namespace: string,
+        language: string
+    ): Record<string, string> {
+        const cacheKey = this.createCacheKey(namespace, language);
+        const cached = this.translationCache.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+
+        const merged: Record<string, string> = {};
+
+        for (const contribution of contributions) {
+            if (contribution.namespace !== namespace) {
+                continue;
+            }
+
+            let translations: Record<string, string> | undefined;
+
+            if (contribution.translations && contribution.language === language) {
+                translations = contribution.translations;
+            } else if (contribution[language] && typeof contribution[language] === 'object') {
+                translations = contribution[language] as Record<string, string>;
+            }
+
+            if (translations) {
+                Object.assign(merged, translations);
+            }
+        }
+
+        this.translationCache.set(cacheKey, merged);
+        return merged;
+    }
+
+    private invalidateTranslationCache(): void {
+        this.translationCache.clear();
+    }
+
+    public translate(namespace: string, key: string, params?: Record<string, string>): string {
+        const currentLanguage = this.currentLanguageSignal.get();
+        const primaryLanguage = this.getPrimaryLanguage(currentLanguage);
+        const contributions = this.languageContributionsSignal.get();
+
+        let translation: string | undefined;
+
+        const currentLangTranslations = this.mergeTranslationsForLanguage(contributions, namespace, currentLanguage);
+        if (currentLangTranslations[key]) {
+            translation = currentLangTranslations[key];
+        } else {
+            const primaryLangTranslations = currentLanguage !== primaryLanguage
+                ? this.mergeTranslationsForLanguage(contributions, namespace, primaryLanguage)
+                : currentLangTranslations;
+            if (primaryLangTranslations[key]) {
+                translation = primaryLangTranslations[key];
+            } else if (primaryLanguage !== I18nService.DEFAULT_LANGUAGE && currentLanguage !== I18nService.DEFAULT_LANGUAGE) {
+                const defaultLangTranslations = this.mergeTranslationsForLanguage(contributions, namespace, I18nService.DEFAULT_LANGUAGE);
+                if (defaultLangTranslations[key]) {
+                    translation = defaultLangTranslations[key];
+                }
+            }
+        }
+
+        if (!translation) {
+            return key;
+        }
+
+        return replaceParameters(translation, params);
+    }
+
+    private initialize(): void {
+        subscribe(TOPIC_SETTINGS_CHANGED, async (settings: any) => {
+            const language = settings?.[SETTINGS_KEY_LANGUAGE] || this.getBrowserLanguage();
+            this.currentLanguageSignal.set(language);
+            this.invalidateTranslationCache();
+        });
+
+        subscribe(TOPIC_CONTRIBUTEIONS_CHANGED, (event: ContributionChangeEvent) => {
+            if (event.target === SYSTEM_LANGUAGE_BUNDLES) {
+                this.invalidateTranslationCache();
+                this.updateLanguageContributions();
+            }
+        });
+
+        this.updateLanguageFromSettings();
+        this.updateLanguageContributions();
+    }
+
+    public i18n(namespace: string) {
+        return (key: string, params?: Record<string, string>): string => {
+            return this.translate(namespace, key, params);
+        };
+    }
+
+    public i18nLazy(namespace: string) {
+        return (key: string, params?: Record<string, string>): LazyTranslation => {
+            return new LazyTranslation(this, namespace, key, params);
+        };
+    }
+}
+
+export const i18nService = new I18nService();
+rootContext.put("i18nService", i18nService);
+
+export const currentLanguageSignal = i18nService.currentLanguageSignal;
+export const languageContributionsSignal = i18nService.languageContributionsSignal;
+
+export const i18n = (namespace: string) => i18nService.i18n(namespace);
+export const i18nLazy = (namespace: string) => i18nService.i18nLazy(namespace);

package/src/core/index.ts

@@ -0,0 +1,51 @@
+// 0. Context seed (lit, constants, toast) – di only provides empty contexts
+import { rootContext, uiContext } from './di';
+import { html, render } from 'lit';
+import * as constants from './constants';
+import { toastInfo, toastError, toastWarning } from './toast';
+
+rootContext.put('constants', constants);
+uiContext.put('html', html);
+uiContext.put('render', render);
+uiContext.put('toastInfo', toastInfo);
+uiContext.put('toastError', toastError);
+uiContext.put('toastWarning', toastWarning);
+
+// 1. Foundation: logging, persistence, settings
+import './logger';
+import './persistenceservice';
+import './settingsservice';
+
+// 2. Registries and task service (contribution first – others depend on it)
+import './contributionregistry';
+import './packageinfoservice';
+import './taskservice';
+
+// 3. i18n and ESM
+import './i18n';
+import './esmsh-service';
+
+// 4. Command and extension registries
+import './commandregistry';
+import './extensionregistry';
+
+// 5. UI and workspace services
+import './keybindings';
+import './dialogservice';
+import './editorregistry';
+import './filesys';
+
+// 6. App loader and marketplace
+import './apploader';
+import './marketplaceregistry';
+
+// 7. Language bundles and dialogs (use contributionRegistry / dialogService)
+import '../i18n';
+import '../dialogs';
+
+// 8. Parts, components, widgets, contributions, commands (extensions registered by app host)
+import '../parts';
+import '../components';
+import '../widgets';
+import '../contributions';
+import '../commands';

package/src/core/k-utils.ts

@@ -0,0 +1,11 @@
+import {registerIconLibrary} from '@awesome.me/webawesome'
+
+registerIconLibrary('k', {
+    resolver: (name: string) => {
+        return new URL(`../icons/${name}.svg`, import.meta.url).href;
+    },
+    mutator: (svg: SVGElement) => {
+        svg.setAttribute('fill', 'currentColor');
+        svg.setAttribute('stroke', 'currentColor');
+    }
+});

package/src/core/keybindings.ts

@@ -0,0 +1,274 @@
+/**
+ * Key Binding Manager for geo!space
+ *
+ * Handles keyboard shortcuts and binds them to commands.
+ * Supports standard modifiers: CTRL, ALT, SHIFT, META (CMD on Mac)
+ */
+
+import logger from "./logger";
+import { subscribe } from "./events";
+import { commandRegistry, TOPIC_COMMAND_REGISTERED } from "./commandregistry";
+import { rootContext } from "./di";
+
+import type { Command } from "./commandregistry";
+
+export type ModifierField = 'ctrl' | 'alt' | 'shift' | 'meta';
+
+export interface KeyBinding {
+    commandId: string;
+    key: string;
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+}
+
+const MODIFIER_FIELDS: ModifierField[] = ['alt', 'ctrl', 'meta', 'shift'];
+
+const MODIFIER_ALIASES: Record<string, ModifierField> = {
+    CTRL: 'ctrl', CONTROL: 'ctrl',
+    ALT: 'alt', OPTION: 'alt',
+    SHIFT: 'shift',
+    META: 'meta', CMD: 'meta', COMMAND: 'meta', WIN: 'meta', WINDOWS: 'meta',
+};
+
+const MODIFIER_DISPLAY: Record<ModifierField, string> = {
+    ctrl: 'Ctrl', alt: 'Alt', shift: 'Shift', meta: 'Cmd',
+};
+
+const KEY_NORMALIZE: Record<string, string> = {
+    SPACE: ' ', ESC: 'ESCAPE', RETURN: 'ENTER',
+    LEFT: 'ARROWLEFT', RIGHT: 'ARROWRIGHT', UP: 'ARROWUP', DOWN: 'ARROWDOWN',
+    DEL: 'DELETE', INS: 'INSERT', PAGEUP: 'PAGEUP', PAGEDOWN: 'PAGEDOWN',
+};
+
+const KNOWN_MODIFIERS = new Set<string>(Object.keys(MODIFIER_ALIASES));
+
+function normalizeKey(key: string): string {
+    return KEY_NORMALIZE[key] ?? key;
+}
+
+export class KeyBindingManager {
+    private bindings: Map<string, KeyBinding[]> = new Map();
+    private enabled: boolean = true;
+
+    constructor() {
+        document.addEventListener('keydown', this.handleKeyDown.bind(this), true);
+        this.registerExistingCommandBindings();
+        subscribe(TOPIC_COMMAND_REGISTERED, (command: Command) => {
+            if (command.keyBinding) {
+                this.registerKeyBinding(command.id, command.keyBinding);
+            }
+        });
+    }
+
+    private registerExistingCommandBindings() {
+        const commands = commandRegistry.listCommands();
+        Object.values(commands).forEach((command: Command) => {
+            if (command.keyBinding) {
+                this.registerKeyBinding(command.id, command.keyBinding);
+            }
+        });
+    }
+
+    /**
+     * Parse a key binding string like "CTRL+SHIFT+P" or "ALT+S"
+     */
+    parseKeyBinding(keyBindingString: string): KeyBinding | null {
+        if (!keyBindingString || keyBindingString.trim() === '') {
+            return null;
+        }
+
+        const parts = keyBindingString.toUpperCase().split('+').map(p => p.trim());
+        if (parts.length === 0) {
+            return null;
+        }
+
+        const key = parts[parts.length - 1];
+        const modifiers = parts.slice(0, -1);
+        if (parts.length === 1 && KNOWN_MODIFIERS.has(key)) {
+            return null;
+        }
+
+        const binding: Partial<KeyBinding> = { ctrl: false, alt: false, shift: false, meta: false };
+        for (const modifier of modifiers) {
+            const field = MODIFIER_ALIASES[modifier];
+            if (field === undefined) return null;
+            binding[field] = true;
+        }
+        binding.key = normalizeKey(key);
+        return binding as KeyBinding;
+    }
+
+    /**
+     * Create a unique key for a binding
+     */
+    private getBindingKey(binding: KeyBinding): string {
+        const parts = [...MODIFIER_FIELDS.filter(f => binding[f]), binding.key.toUpperCase()];
+        return parts.join('+');
+    }
+
+    /**
+     * Register a key binding for a command
+     */
+    registerKeyBinding(commandId: string, keyBindingString: string): boolean {
+        const binding = this.parseKeyBinding(keyBindingString);
+        
+        if (!binding) {
+            logger.error(`Invalid key binding: ${keyBindingString}`);
+            return false;
+        }
+
+        binding.commandId = commandId;
+        
+        const bindingKey = this.getBindingKey(binding);
+        
+        if (!this.bindings.has(bindingKey)) {
+            this.bindings.set(bindingKey, []);
+        }
+        
+        const existing = this.bindings.get(bindingKey)!;
+        const sameCommand = existing.find(b => b.commandId === commandId);
+        if (sameCommand) {
+            logger.error(`Key binding ${keyBindingString} already registered for command ${commandId}`);
+            return false;
+        }
+        const otherCommand = existing.find(b => b.commandId !== commandId);
+        if (otherCommand) {
+            logger.warn(`Key binding ${keyBindingString} already used by command ${otherCommand.commandId}; refusing for ${commandId}`);
+            return false;
+        }
+
+        existing.push(binding);
+        logger.debug(`Key binding registered: ${keyBindingString} -> ${commandId}`);
+        
+        return true;
+    }
+
+    /**
+     * Unregister a key binding
+     */
+    unregisterKeyBinding(commandId: string, keyBindingString?: string): void {
+        if (keyBindingString) {
+            const binding = this.parseKeyBinding(keyBindingString);
+            if (binding) {
+                const bindingKey = this.getBindingKey(binding);
+                const bindings = this.bindings.get(bindingKey);
+                if (bindings) {
+                    const filtered = bindings.filter(b => b.commandId !== commandId);
+                    if (filtered.length === 0) {
+                        this.bindings.delete(bindingKey);
+                    } else {
+                        this.bindings.set(bindingKey, filtered);
+                    }
+                }
+            }
+        } else {
+            // Remove all bindings for this command
+            for (const [key, bindings] of this.bindings.entries()) {
+                const filtered = bindings.filter(b => b.commandId !== commandId);
+                if (filtered.length === 0) {
+                    this.bindings.delete(key);
+                } else {
+                    this.bindings.set(key, filtered);
+                }
+            }
+        }
+    }
+
+    /**
+     * Get all key bindings for a command
+     */
+    getKeyBindingsForCommand(commandId: string): string[] {
+        const result: string[] = [];
+        for (const bindings of this.bindings.values()) {
+            for (const binding of bindings) {
+                if (binding.commandId === commandId) {
+                    result.push(this.formatKeyBinding(binding));
+                }
+            }
+        }
+        return result.sort();
+    }
+
+    /**
+     * Format a key binding for display
+     */
+    formatKeyBinding(binding: KeyBinding): string {
+        const parts = MODIFIER_FIELDS.filter(f => binding[f]).map(f => MODIFIER_DISPLAY[f]);
+        const key = binding.key.length === 1
+            ? binding.key.toUpperCase()
+            : binding.key.charAt(0).toUpperCase() + binding.key.slice(1).toLowerCase();
+        parts.push(key);
+        return parts.join('+');
+    }
+
+    /**
+     * Handle keyboard events
+     */
+    private handleKeyDown(event: KeyboardEvent): void {
+        if (!this.enabled) {
+            return;
+        }
+        // event.key can be empty or layout-specific with some IMEs or dead keys
+        const eventBinding: KeyBinding = {
+            commandId: '',
+            key: normalizeKey(event.key.toUpperCase()),
+            ctrl: event.ctrlKey,
+            alt: event.altKey,
+            shift: event.shiftKey,
+            meta: event.metaKey
+        };
+        const bindingKey = this.getBindingKey(eventBinding);
+        const bindings = this.bindings.get(bindingKey);
+
+        if (bindings && bindings.length > 0) {
+            const binding = bindings[0];
+            try {
+                event.preventDefault();
+                event.stopPropagation();
+                const context = commandRegistry.createExecutionContext({});
+                commandRegistry.execute(binding.commandId, context);
+                logger.debug(`Executed command via key binding: ${binding.commandId}`);
+            } catch (error: any) {
+                logger.error(`Failed to execute command ${binding.commandId}: ${error.message}`);
+            }
+        }
+    }
+
+    /**
+     * Enable or disable key binding handling
+     */
+    setEnabled(enabled: boolean): void {
+        this.enabled = enabled;
+    }
+
+    /**
+     * Check if key binding handling is enabled
+     */
+    isEnabled(): boolean {
+        return this.enabled;
+    }
+
+    /**
+     * Get all registered key bindings
+     */
+    getAllBindings(): Map<string, KeyBinding[]> {
+        const copy = new Map<string, KeyBinding[]>();
+        for (const [key, bindings] of this.bindings) {
+            copy.set(key, [...bindings]);
+        }
+        return copy;
+    }
+
+    /**
+     * Clear all key bindings
+     */
+    clearAll(): void {
+        this.bindings.clear();
+    }
+}
+
+export const keyBindingManager = new KeyBindingManager();
+rootContext.put("keyBindingManager", keyBindingManager);
+