@kispace-io/core 0.7.0

package/src/core/commandregistry.ts

@@ -0,0 +1,210 @@
+import logger from "./logger";
+import { publish } from "./events";
+import { CommandContribution, Contribution, contributionRegistry } from "./contributionregistry";
+import { rootContext } from "./di";
+import { activePartSignal, activeEditorSignal } from "./appstate";
+
+export const TOPIC_COMMAND_REGISTERED = "events/commandregistry/commandRegistered";
+
+export interface Parameter {
+    name: string;
+    description: string;
+    type?: string;
+    required: boolean;
+    allowedValues?: string[];
+}
+
+export interface Variable {
+    name: string;
+    description: string;
+    type?: string;
+}
+
+export interface LLMOptions {
+    prompt?: string;
+    model?: string;
+}
+
+export class Command {
+    id: string;
+    name: string;
+    description: string;
+    icon?: string;
+    keyBinding?: string;
+    parameters?: Parameter[];
+    output?: Variable[];
+    llm?: LLMOptions;
+
+    constructor(id: string, name: string, description: string, parameters?: Parameter[], output?: Variable[]) {
+        this.id = id;
+        this.name = name;
+        this.description = description;
+        this.parameters = parameters || [];
+        this.output = output || [];
+    }
+}
+
+export interface ExecutionContext {
+    [key: string]: any;
+
+    params?: ExecuteParams;
+    activePart?: any;
+    activeEditor?: any;
+}
+
+export interface ExecuteParams {
+    [key: string]: any;
+}
+
+export interface Handler {
+    canExecute?: (context: ExecutionContext) => boolean;
+    execute: (context: ExecutionContext) => any;
+    ranking?: number;  // Higher ranking = higher priority (default: 0)
+}
+
+export interface Commands {
+    [commandId: string]: Command
+}
+
+export class CommandStack {
+    //private stack: any[] = []
+
+    public async execute(commandId: any, context: ExecutionContext) {
+        return commandRegistry.execute(commandId, context);
+    }
+
+    public async undo() {
+        // TODO undo last command on stack
+    }
+
+    public async redo() {
+        // TODO redo last command on stack
+    }
+}
+
+export class CommandRegistry {
+    private commands: Commands = {};
+    private handlers: Map<string, Handler[]> = new Map();
+
+    registerHandler(commandId: string, handler: Handler) {
+        if (!this.handlers.has(commandId)) {
+            this.handlers.set(commandId, []);
+        }
+        const handlerList = this.handlers.get(commandId) as Handler[];
+        handlerList.push(handler);
+        // Sort by ranking (higher ranking first), default ranking is 0
+        handlerList.sort((a, b) => (b.ranking ?? 0) - (a.ranking ?? 0));
+    }
+
+    getHandler(commandId: string): Handler[] | undefined {
+        return this.handlers.get(commandId)
+    }
+
+    /**
+     * Creates an ExecutionContext with the current application state
+     * 
+     * @param params Optional command parameters
+     * @returns ExecutionContext with captured application state
+     */
+    createExecutionContext(params?: ExecuteParams): ExecutionContext {
+        const context: ExecutionContext = {
+            params: params || {},
+            activePart: activePartSignal.get(),
+            activeEditor: activeEditorSignal.get()
+        };
+
+        return context;
+    }
+
+    execute(commandId: string, context: ExecutionContext = {}) {
+        const handlers = this.getHandler(commandId);
+
+        if (!handlers) {
+            logger.debug(`[CommandRegistry] No handlers registered for command: ${commandId}`);
+            throw new Error(`No handlers registered for command: ${commandId}`);
+        }
+
+        const command = this.getCommand(commandId);
+        const paramsStr = context.params ? ` params: ${JSON.stringify(context.params)}` : '';
+        logger.debug(`[CommandRegistry] Executing command: ${commandId}${command ? ` (${command.name})` : ''}${paramsStr}`);
+
+        // Handlers are already sorted by ranking, so iterate in order
+        for (const handler of handlers) {
+            if (handler.canExecute === undefined || handler.canExecute(context)) {
+                try {
+                    const result: any | Promise<any> = handler.execute(context);
+                    logger.debug(`[CommandRegistry] Command executed successfully: ${commandId} (result: ${result})`);
+                    return result;
+                } catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    logger.error(`[CommandRegistry] Command execution failed: ${commandId} - ${errorMsg}`);
+                    throw error;
+                }
+            }
+        }
+        logger.error(`[CommandRegistry] No handler found to execute command: ${commandId}`);
+    }
+
+    createAndRegisterCommand(id: string, name: string, description: string, parameters: Parameter[], handler?: Handler) {
+        const command = new Command(id, name, description, parameters);
+        this.registerCommand(command)
+        if (handler) {
+            this.registerHandler(id, handler)
+        }
+    }
+
+    registerCommand(command: Command): void {
+        this.commands[command.id] = command;
+        logger.debug(`Command registered: ${command.id}`);
+        publish(TOPIC_COMMAND_REGISTERED, command);
+    }
+
+    hasCommand(commandId: string): boolean {
+        return commandId in this.commands
+    }
+
+    listCommands(context?: ExecutionContext): Commands {
+        if (context) {
+            // filter by commands which have at least one executable handler
+            return Object.values(this.commands).filter(command => {
+                const handlers = commandRegistry.getHandler(command.id) || []
+                return handlers.some(handler => handler.canExecute === undefined || handler.canExecute(context))
+            }).reduce((acc: any, command) => {
+                acc[command.id] = command
+                return acc
+            }, {})
+        }
+        return this.commands
+    }
+
+    getCommand(commandId: string): Command {
+        return <Command>this.commands[commandId]
+    }
+
+    registerAll(options: RegisterOptions) {
+        const commandId = options.command.id
+        this.registerCommand(options.command)
+        if (options.handler) {
+            this.registerHandler(commandId, options.handler)
+        }
+        if (options.contribution && options.contribution.target) {
+            contributionRegistry.registerContribution(options.contribution.target, {
+                command: commandId,
+                ...options.contribution
+            } as CommandContribution)
+        }
+    }
+}
+
+export const commandRegistry = new CommandRegistry();
+rootContext.put("commandRegistry", commandRegistry);
+
+export interface RegisterOptions {
+    command: Command,
+    handler?: Handler,
+    contribution?: Contribution
+}
+
+export const registerAll = (options: RegisterOptions) => {
+    commandRegistry.registerAll(options);
+}

package/src/core/config.ts

@@ -0,0 +1,29 @@
+// Framework Configuration
+// 
+// This module provides framework-wide configuration that can be customized
+// by applications built on the framework.
+
+export interface FrameworkConfig {
+    // Logger configuration
+    logger?: {
+        level?: 'debug' | 'info' | 'warning' | 'error';
+    };
+}
+
+let frameworkConfig: FrameworkConfig = {};
+
+/**
+ * Initialize framework configuration
+ * This should be called before framework bootstrap (if custom config is needed)
+ */
+export function configureFramework(config: FrameworkConfig): void {
+    frameworkConfig = { ...frameworkConfig, ...config };
+}
+
+/**
+ * Get current framework configuration
+ */
+export function getFrameworkConfig(): Readonly<FrameworkConfig> {
+    return { ...frameworkConfig };
+}
+

package/src/core/constants.ts

@@ -0,0 +1,27 @@
+// Toolbars
+export const TOOLBAR_MAIN = "app-toolbars-main"
+export const TOOLBAR_MAIN_RIGHT = "app-toolbars-main-right"
+export const TOOLBAR_MAIN_CENTER = "app-toolbars-main-center"
+export const TOOLBAR_BOTTOM = "app-toolbars-bottom"
+export const TOOLBAR_BOTTOM_CENTER = "app-toolbars-bottom-center"
+export const TOOLBAR_BOTTOM_END = "app-toolbars-bottom-end"
+
+// VS Code-style layout containers
+export const EDITOR_AREA_MAIN = "editor-area-main"
+export const SIDEBAR_MAIN = "sidebar-main"
+export const SIDEBAR_MAIN_BOTTOM = "sidebar-main-bottom"
+export const SIDEBAR_AUXILIARY = "sidebar-auxiliary"
+export const PANEL_BOTTOM = "panel-bottom"
+
+export const COMMAND_SAVE = "command-save"
+
+export const HIDE_DOT_RESOURCE = false
+
+// Mouse button constants
+export enum MouseButton {
+    LEFT = 0,
+    MIDDLE = 1,
+    RIGHT = 2,
+    BACK = 3,
+    FORWARD = 4
+}

package/src/core/contributionregistry.ts

@@ -0,0 +1,77 @@
+import {Signal} from "@lit-labs/signals";
+import {TemplateResult} from "lit";
+import {publish} from "./events";
+import {rootContext} from "./di";
+
+export const TOPIC_CONTRIBUTEIONS_CHANGED = "events/contributionregistry/contributionsChanged"
+
+export interface ContributionChangeEvent {
+    target: string;
+    contributions: Contribution[];
+}
+
+export interface Contribution {
+    target?: string;
+    label: string;
+    icon?: string;
+    slot?: string;
+}
+
+export interface CommandContribution extends Contribution {
+    command: string;
+    params?: Record<string, any>;
+    showLabel?: boolean;
+    disabled?: (() => boolean) | Signal.Computed<boolean>;
+}
+
+export interface HTMLContribution extends Contribution {
+    html: string | (() => TemplateResult)
+}
+
+export interface TabContribution extends Contribution {
+    name: string;
+    editorId?: string;
+    closable?: boolean;
+    noOverflow?: boolean;
+    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;
+}
+
+class ContributionRegistry {
+    private contributions: Map<string, Contribution[]> = new Map();
+
+    registerContribution<T extends Contribution>(target: string, contribution: T) {
+        const targetSlot = this.getContributions(target)!
+        if ("command" in contribution) {
+            const cmd = contribution as unknown as CommandContribution
+            if (cmd.disabled instanceof Function) {
+                cmd.disabled = new Signal.Computed<boolean>(cmd.disabled)
+            }
+        }
+        targetSlot.push(contribution);
+        publish(TOPIC_CONTRIBUTEIONS_CHANGED, { target, contributions: targetSlot } as ContributionChangeEvent)
+    }
+
+    getContributions<T extends Contribution>(target: string): T[] {
+        if (!this.contributions.has(target)) {
+            this.contributions.set(target, [])
+        }
+        return this.contributions.get(target)! as T[]
+    }
+}
+
+export const contributionRegistry = new ContributionRegistry()
+rootContext.put("contributionRegistry", contributionRegistry)

package/src/core/di.ts

@@ -0,0 +1,54 @@
+export class DependencyContext {
+    private variables: any;
+    private proxy: any;
+    private children: DependencyContext[] = [];
+    private parent?: DependencyContext;
+
+    constructor(variables: any) {
+        this.variables = variables
+        // @ts-ignore
+        this.proxy = new Proxy(variables, this)
+    }
+
+    get(target: any, prop: string): any {
+        return target[prop] || this.parent?.getProxy()[prop];
+    }
+
+    set(target: any, prop: string, value: any) {
+        target[prop] = value;
+    }
+
+    put(prop: string, value: any) {
+        this.variables[prop] = value;
+    }
+
+    public getProxy() {
+        return this.proxy;
+    }
+
+    public createChild(variables: any = {}): DependencyContext {
+        const child = new DependencyContext(variables)
+        child.parent = this
+        this.children.push(child)
+        return child
+    }
+
+    getChildren() {
+        return this.children;
+    }
+
+    getParent() {
+        return this.parent;
+    }
+
+    destroy() {
+        const index = this.parent?.children.indexOf(this)
+        if (index !== undefined && index >= 0) {
+            this.parent?.children.splice(index, 1)
+        }
+        this.parent = undefined
+    }
+}
+
+export const rootContext = new DependencyContext({});
+export const uiContext = rootContext.createChild({});

package/src/core/dialogservice.ts

@@ -0,0 +1,266 @@
+import { html, render, TemplateResult } from "lit";
+import { contributionRegistry, Contribution, TOPIC_CONTRIBUTEIONS_CHANGED } from "./contributionregistry";
+import { subscribe } from "./events";
+import { createLogger } from "./logger";
+import { rootContext } from "./di";
+import { KDialogContent } from "../parts/k-dialog-content";
+
+const logger = createLogger('DialogService');
+
+export const DIALOG_CONTRIBUTION_TARGET = "dialogs";
+
+export interface DialogButton {
+    id: string;
+    label: string;
+    variant?: 'default' | 'primary' | 'success' | 'neutral' | 'warning' | 'danger';
+    disabled?: boolean;
+}
+
+export const OK_BUTTON: DialogButton = {
+    id: 'ok',
+    label: 'OK',
+    variant: 'primary'
+};
+
+export const CANCEL_BUTTON: DialogButton = {
+    id: 'cancel',
+    label: 'Cancel',
+    variant: 'default'
+};
+
+export const YES_BUTTON: DialogButton = {
+    id: 'yes',
+    label: 'Yes',
+    variant: 'primary'
+};
+
+export const NO_BUTTON: DialogButton = {
+    id: 'no',
+    label: 'No',
+    variant: 'default'
+};
+
+export const CLOSE_BUTTON: DialogButton = {
+    id: 'close',
+    label: 'Close',
+    variant: 'default'
+};
+
+export const SAVE_BUTTON: DialogButton = {
+    id: 'save',
+    label: 'Save',
+    variant: 'primary'
+};
+
+export const DELETE_BUTTON: DialogButton = {
+    id: 'delete',
+    label: 'Delete',
+    variant: 'danger'
+};
+
+export interface DialogContribution extends Contribution {
+    id: string;
+    buttons?: DialogButton[];
+    component: (state?: any) => TemplateResult;
+    onButton: (id: string, result: any, state?: any) => boolean | Promise<boolean> | void | Promise<void>;
+}
+
+let dialogContainer: HTMLElement | null = null;
+
+function getDialogContainer(): HTMLElement {
+    if (!dialogContainer) {
+        dialogContainer = document.createElement('div');
+        dialogContainer.id = 'global-dialog-container';
+        document.body.appendChild(dialogContainer);
+    }
+    return dialogContainer;
+}
+
+class DialogService {
+    private contributions: Map<string, DialogContribution> = new Map();
+
+    constructor() {
+        this.loadContributions();
+        
+        subscribe(TOPIC_CONTRIBUTEIONS_CHANGED, (event: any) => {
+            if (event.target === DIALOG_CONTRIBUTION_TARGET) {
+                this.loadContributions();
+            }
+        });
+    }
+
+    private loadContributions(): void {
+        const contributions = contributionRegistry.getContributions<DialogContribution>(DIALOG_CONTRIBUTION_TARGET);
+        
+        this.contributions.clear();
+        
+        for (const contribution of contributions) {
+            if (!contribution.id) {
+                logger.warn('Dialog contribution missing id, skipping');
+                continue;
+            }
+
+
+            if (!contribution.component) {
+                logger.warn(`Dialog contribution "${contribution.id}" has no component function, skipping`);
+                continue;
+            }
+
+            if (!contribution.onButton) {
+                logger.warn(`Dialog contribution "${contribution.id}" has no onButton callback, skipping`);
+                continue;
+            }
+
+            this.contributions.set(contribution.id, contribution);
+            logger.debug(`Loaded dialog contribution: ${contribution.id}`);
+        }
+
+        logger.info(`Loaded ${this.contributions.size} dialog contributions`);
+    }
+
+    async open(dialogId: string, state?: any): Promise<void> {
+        const contribution = this.contributions.get(dialogId);
+        
+        if (!contribution) {
+            logger.error(`Dialog "${dialogId}" not found`);
+            throw new Error(`Dialog "${dialogId}" not found`);
+        }
+
+        return new Promise((resolve) => {
+            const container = getDialogContainer();
+            let isOpen = true;
+            let dialogContentElement: KDialogContent | null = null;
+
+            const cleanup = async () => {
+                if (!isOpen) return;
+                isOpen = false;
+                
+                if (dialogContentElement) {
+                    try {
+                        await dialogContentElement.dispose();
+                    } catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        logger.error(`Error disposing dialog content for "${dialogId}": ${errorMessage}`);
+                    }
+                }
+                
+                try {
+                    const result = dialogContentElement ? dialogContentElement.getResult() : undefined;
+                    await contribution.onButton('close', result, stateWithClose);
+                } catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    logger.error(`Error executing close callback for dialog "${dialogId}": ${errorMessage}`);
+                }
+                
+                render(html``, container);
+                resolve();
+            };
+
+            const handleButtonClick = async (buttonId: string) => {
+                try {
+                    const result = dialogContentElement ? dialogContentElement.getResult() : undefined;
+                    const shouldClose = await contribution.onButton(buttonId, result, stateWithClose);
+                    
+                    if (shouldClose !== false) {
+                        cleanup();
+                    }
+                } catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    logger.error(`Error executing button callback for dialog "${dialogId}": ${errorMessage}`);
+                    cleanup();
+                }
+            };
+
+            const buttons = contribution.buttons && contribution.buttons.length > 0 
+                ? contribution.buttons 
+                : [OK_BUTTON];
+
+            if (state && typeof state === 'object') {
+                (state as any).close = cleanup;
+            }
+            const stateWithClose = { ...state, close: cleanup };
+
+            const template = html`
+                <wa-dialog label="${contribution.label || dialogId}" open @wa-request-close=${cleanup}>
+                    <style>
+                        .dialog-service-content {
+                            display: flex;
+                            flex-direction: column;
+                            gap: 1rem;
+                            padding: 1rem;
+                            min-width: 400px;
+                        }
+                        
+                        .dialog-service-footer {
+                            display: flex;
+                            gap: 0.5rem;
+                            justify-content: flex-end;
+                            margin-top: 1rem;
+                            padding-top: 1rem;
+                            border-top: 1px solid var(--wa-color-neutral-20);
+                        }
+
+                        :host-context(.wa-light) .dialog-service-footer {
+                            border-top-color: var(--wa-color-neutral-80);
+                        }
+                    </style>
+                    
+                    <div class="dialog-service-content" 
+                         @dialog-ok=${() => {
+                             const okButton = buttons.find(b => b.id === 'ok');
+                             if (okButton) {
+                                 handleButtonClick(okButton.id);
+                             }
+                         }}
+                         @dialog-cancel=${() => {
+                             const cancelButton = buttons.find(b => b.id === 'cancel');
+                             if (cancelButton) {
+                                 handleButtonClick(cancelButton.id);
+                             } else {
+                                 cleanup();
+                             }
+                         }}>
+                        ${contribution.component(state)}
+                        
+                        <div class="dialog-service-footer">
+                            ${buttons.map(button => html`
+                                <wa-button 
+                                    variant="${button.variant || 'default'}"
+                                    ?disabled=${button.disabled}
+                                    @click=${() => handleButtonClick(button.id)}
+                                >
+                                    ${button.label}
+                                </wa-button>
+                            `)}
+                        </div>
+                    </div>
+                </wa-dialog>
+            `;
+
+            render(template, container);
+            
+            (async () => {
+                const allElements = Array.from(container.querySelectorAll('*'));
+                for (const element of allElements) {
+                    if (element instanceof KDialogContent) {
+                        await element.updateComplete;
+                        dialogContentElement = element;
+                        break;
+                    }
+                }
+            })();
+        });
+    }
+
+    getDialogIds(): string[] {
+        return Array.from(this.contributions.keys());
+    }
+
+    hasDialog(dialogId: string): boolean {
+        return this.contributions.has(dialogId);
+    }
+}
+
+export const dialogService = new DialogService();
+rootContext.put("dialogService", dialogService);
+