@punica/editor 1.0.1 → 1.0.3

package/dist/impl/activityBar/index.js

@@ -0,0 +1,75 @@
+class ActivityBarManager {
+    #primaryItems = new Map();
+    #secondaryItems = new Map();
+    #content;
+    #primaryContent;
+    #secondaryContent;
+    /**
+     *
+     */
+    #initiliazeContent() {
+        const layoutManager = window.punica.Layout.manager;
+        const activityBarContent = layoutManager.getItem('activityBar').content;
+        this.#content = document.createElement('punica-row');
+        this.#primaryContent = document.createElement('punica-col');
+        this.#secondaryContent = document.createElement('punica-col');
+        this.#content.setAttribute('direction', 'column');
+        this.#content.setAttribute('alignitems', 'stretch');
+        this.#content.appendChild(this.#primaryContent);
+        this.#content.appendChild(this.#secondaryContent);
+        activityBarContent?.appendChild(this.#content);
+    }
+    /**
+     *
+     */
+    constructor() { }
+    /**
+     *
+     * @param alignment
+     * @param item
+     */
+    addItem(item) {
+        if (!this.#content) {
+            this.#initiliazeContent();
+        }
+        const button = document.createElement('punica-button');
+        button.setAttribute('id', item.id);
+        button.setAttribute('disabled', 'false');
+        button.setAttribute('title', item.title);
+        button.onclick = () => { };
+        button.innerHTML = `<punica-icon size="xlarge">${item.icon}</punica-icon>`;
+        button.className = 'extension';
+        if (item.alignment === 'primary') {
+            this.#primaryItems.set(item.id, item);
+            this.#primaryContent.appendChild(button);
+        }
+        else {
+            this.#secondaryItems.set(item.id, item);
+            this.#secondaryContent.appendChild(button);
+        }
+    }
+    /**
+     *
+     * @param itemId
+     */
+    removeItem(itemId) {
+        if (this.#primaryItems.has(itemId)) {
+            const itemElement = this.#primaryContent.querySelector('#' + itemId);
+            if (itemElement) {
+                this.#primaryContent.removeChild(itemElement);
+                this.#primaryItems.delete(itemId);
+            }
+        }
+        else if (this.#secondaryItems.has(itemId)) {
+            const itemElement = this.#secondaryContent.querySelector('#' + itemId);
+            if (itemElement) {
+                this.#secondaryContent.removeChild(itemElement);
+                this.#secondaryItems.delete(itemId);
+            }
+        }
+    }
+}
+const activityBar = {
+    manager: new ActivityBarManager()
+};
+export default activityBar;

package/dist/impl/commands/index.js

@@ -0,0 +1,52 @@
+class CommandManager {
+    #commands = new Map();
+    #disposables = new Map();
+    /**
+     *
+     * @param commandName
+     * @param command
+     * @returns
+     */
+    registerCommand(commandName, command) {
+        const disposable = {
+            dispose: () => {
+                this.#commands.delete(commandName);
+                this.#disposables.delete(commandName);
+            }
+        };
+        command.disposable = disposable;
+        this.#disposables.set(commandName, disposable);
+        this.#commands.set(commandName, command);
+    }
+    /**
+     *
+     * @param commandName
+     * @param args
+     */
+    executeCommand(commandName, ...args) {
+        const command = this.#commands.get(commandName);
+        if (command) {
+            command.execute(...args);
+        }
+        else {
+            console.error(`Command ${commandName} not found`);
+        }
+    }
+    /**
+     *
+     * @param commandName
+     */
+    disposeCommand(commandName) {
+        const disposable = this.#disposables.get(commandName);
+        if (disposable) {
+            disposable.dispose();
+        }
+        else {
+            console.error(`Command ${commandName} not found or already disposed`);
+        }
+    }
+}
+const commands = {
+    manager: new CommandManager()
+};
+export default commands;

package/dist/impl/extensions/active/decorators/base.js

@@ -0,0 +1,19 @@
+class BaseDecorator {
+    #decorator;
+    /**
+     *
+     * @param decorator
+     */
+    constructor(decorator) {
+        this.#decorator = decorator;
+    }
+    /**
+     *
+     * @param extension
+     */
+    async execute() {
+        const extension = await this.#decorator.execute();
+        return extension;
+    }
+}
+export default BaseDecorator;

package/dist/impl/extensions/active/decorators/configuration/index.js

@@ -0,0 +1,20 @@
+import BaseReader from '../base';
+class Decorator extends BaseReader {
+    /**
+     *
+     * @param decorator
+     */
+    constructor(decorator) {
+        super(decorator);
+    }
+    /**
+     *
+     * @param extension
+     * @returns
+     */
+    async execute() {
+        const extension = await super.execute();
+        return extension;
+    }
+}
+export default Decorator;

package/dist/impl/extensions/active/decorators/index.js

@@ -0,0 +1,3 @@
+export { default as Configuration } from './configuration';
+export { default as ModuleLoader } from './moduleLoader';
+export { default as Views } from './views';

package/dist/impl/extensions/active/decorators/moduleLoader/index.js

@@ -0,0 +1,29 @@
+import BaseReader from '../base';
+class Decorator extends BaseReader {
+    /**
+     *
+     * @param decorator
+     */
+    constructor(decorator) {
+        super(decorator);
+    }
+    /**
+     *
+     * @param extension
+     * @returns
+     */
+    async execute() {
+        try {
+            const extension = await super.execute();
+            const extensionMain = `${extension.moduleURL}${extension.main}`;
+            const module = await import(/* webpackIgnore: true */ `${extensionMain}`);
+            const extensionModule = module.default;
+            extension.module = extensionModule;
+            return extension;
+        }
+        catch (error) {
+            throw new Error();
+        }
+    }
+}
+export default Decorator;

package/dist/impl/extensions/active/decorators/views/index.js

@@ -0,0 +1,34 @@
+import BaseReader from '../base';
+class Decorator extends BaseReader {
+    /**
+     * Creates an instance of Decorator.
+     * @param decorator An ExtensionDecorator instance to decorate.
+     */
+    constructor(decorator) {
+        super(decorator);
+    }
+    /**
+     * Reads the extension and adds it to the relevant views.
+     * @returns A promise resolving to the read extension.
+     */
+    async execute() {
+        const extension = await super.execute();
+        const { integrations } = extension;
+        if (!integrations) {
+            return extension;
+        }
+        const { views } = integrations;
+        if (!views) {
+            return extension;
+        }
+        const { activityBar, statusBar } = views;
+        if (activityBar) {
+            window.punica.ActivityBar.manager.addItem(activityBar);
+        }
+        if (statusBar) {
+            window.punica.Statusbar.manager.addItem(statusBar);
+        }
+        return extension;
+    }
+}
+export default Decorator;

package/dist/impl/extensions/active/getter/index.js

@@ -0,0 +1,28 @@
+class Getter {
+    #name;
+    /**
+     *
+     * @param name
+     */
+    constructor(name) {
+        this.#name = name;
+    }
+    /**
+     *
+     * @param extension
+     * @returns
+     */
+    execute() {
+        return new Promise((resolve, reject) => {
+            const extensionManager = window.punica.Extensions.manager;
+            const extension = extensionManager.getExtension(this.#name);
+            if (extension) {
+                resolve(extension);
+            }
+            else {
+                reject(new Error('Extension not found'));
+            }
+        });
+    }
+}
+export default Getter;

package/dist/impl/extensions/active/index.js

@@ -0,0 +1,14 @@
+import Getter from './getter';
+import { Views, Configuration, ModuleLoader } from './decorators';
+/**
+ *
+ * @param extensionName
+ * @returns
+ */
+export const activeExtension = (extensionName) => {
+    const getter = new Getter(extensionName);
+    const moduleLoader = new ModuleLoader(getter);
+    const views = new Views(moduleLoader);
+    const configuration = new Configuration(views);
+    return configuration;
+};

package/dist/impl/extensions/analysis/decorators/activationEvents/commands/base.js

@@ -0,0 +1,2 @@
+export class Command {
+}

package/dist/impl/extensions/analysis/decorators/activationEvents/commands/index.js

@@ -0,0 +1,2 @@
+export * from './onCommand';
+export * from './onExtension';

package/dist/impl/extensions/analysis/decorators/activationEvents/commands/onCommand.js

@@ -0,0 +1,16 @@
+import { Command } from './base';
+export class OnCommand extends Command {
+    #detail;
+    /**
+     *
+     * @param detail
+     */
+    constructor(detail) {
+        super();
+        this.#detail = detail;
+    }
+    /**
+     *
+     */
+    execute() { }
+}

package/dist/impl/extensions/analysis/decorators/activationEvents/commands/onExtension.js

@@ -0,0 +1,16 @@
+import { Command } from './base';
+export class OnExtensionCommand extends Command {
+    #detail;
+    /**
+     *
+     * @param detail
+     */
+    constructor(detail) {
+        super();
+        this.#detail = detail;
+    }
+    /**
+     *
+     */
+    execute() { }
+}

package/dist/impl/extensions/analysis/decorators/activationEvents/handler/index.js

@@ -0,0 +1,32 @@
+export class EventHandler {
+    #commandMap;
+    /**
+     *
+     */
+    constructor() {
+        this.#commandMap = new Map();
+    }
+    /**
+     *
+     * @param eventType
+     * @param commandClass
+     */
+    register(eventType, commandClass) {
+        this.#commandMap.set(eventType, commandClass);
+    }
+    /**
+     *
+     * @param event
+     */
+    handleEvent(event) {
+        const [eventType, eventDetail] = event.split(':');
+        const CommandClass = this.#commandMap.get(eventType);
+        if (CommandClass) {
+            const command = new CommandClass(eventDetail);
+            command.execute();
+        }
+        else {
+            console.warn(`Unknown event type: ${eventType}`);
+        }
+    }
+}

package/dist/impl/extensions/analysis/decorators/activationEvents/index.js

@@ -0,0 +1,29 @@
+import BaseReader from '../base';
+import { EventHandler } from './handler';
+import { OnCommand, OnExtensionCommand } from './commands';
+class Decorator extends BaseReader {
+    #eventHandler;
+    /**
+     *
+     * @param decorator
+     */
+    constructor(decorator) {
+        super(decorator);
+        this.#eventHandler = new EventHandler();
+        this.#eventHandler.register('onExtension', OnExtensionCommand);
+        this.#eventHandler.register('onCommand', OnCommand);
+    }
+    /**
+     *
+     * @returns
+     */
+    async execute() {
+        const extension = await super.execute();
+        const { activationEvents } = extension;
+        if (activationEvents) {
+            activationEvents.forEach((event) => this.#eventHandler.handleEvent(event));
+        }
+        return extension;
+    }
+}
+export default Decorator;

package/dist/impl/extensions/analysis/decorators/base.js

@@ -0,0 +1,19 @@
+class BaseDecorator {
+    #decorator;
+    /**
+     *
+     * @param decorator
+     */
+    constructor(decorator) {
+        this.#decorator = decorator;
+    }
+    /**
+     *
+     * @param extension
+     */
+    async execute() {
+        const extension = await this.#decorator.execute();
+        return extension;
+    }
+}
+export default BaseDecorator;

package/dist/impl/extensions/analysis/decorators/commands/index.js

@@ -0,0 +1,37 @@
+import BaseReader from '../base';
+class Decorator extends BaseReader {
+    /**
+     *
+     * @param decorator
+     */
+    constructor(decorator) {
+        super(decorator);
+    }
+    /**
+     *
+     * @param extension
+     * @returns
+     */
+    async execute() {
+        const extension = await super.execute();
+        const { integrations } = extension;
+        if (integrations) {
+            const { commands } = integrations;
+            if (commands) {
+                commands.forEach((item) => {
+                    const { command, title } = item;
+                    const commandsManager = window.punica.Commands.manager;
+                    const extensionsManager = window.punica.Extensions.manager;
+                    commandsManager.registerCommand(command, {
+                        title,
+                        execute: () => {
+                            extensionsManager.activate(extension.name);
+                        }
+                    });
+                });
+            }
+        }
+        return extension;
+    }
+}
+export default Decorator;

package/dist/impl/extensions/analysis/decorators/index.js

@@ -0,0 +1,4 @@
+export { default as ActivationEvents } from './activationEvents';
+export { default as Commands } from './commands';
+export { default as Keybindings } from './keybindings';
+export { default as Menus } from './menus';

package/dist/impl/extensions/analysis/decorators/keybindings/index.js

@@ -0,0 +1,65 @@
+import BaseReader from '../base';
+class Decorator extends BaseReader {
+    /**
+     *
+     * @param shortcut
+     * @returns
+     */
+    #parseShortcut(shortcut) {
+        const parts = shortcut.split('+').map((part) => part.trim().toLowerCase());
+        const shortcutObj = {
+            key: ''
+        };
+        parts.forEach((part) => {
+            switch (part) {
+                case 'ctrl':
+                    shortcutObj.ctrlKey = true;
+                    break;
+                case 'shift':
+                    shortcutObj.shiftKey = true;
+                    break;
+                case 'alt':
+                    shortcutObj.altKey = true;
+                    break;
+                case 'meta':
+                case 'cmd':
+                case 'command':
+                    shortcutObj.metaKey = true;
+                    break;
+                default:
+                    shortcutObj.key = part;
+            }
+        });
+        return shortcutObj;
+    }
+    /**
+     *
+     * @param decorator
+     */
+    constructor(decorator) {
+        super(decorator);
+    }
+    /**
+     *
+     * @returns
+     */
+    async execute() {
+        const extension = await super.execute();
+        const { integrations } = extension;
+        if (integrations) {
+            const { keybindings } = integrations;
+            if (keybindings) {
+                keybindings.forEach((item) => {
+                    const { command, key } = item;
+                    const keyboardShortcutsManager = window.punica.KeyboardShortcuts.manager;
+                    keyboardShortcutsManager.registerShortcut({
+                        command,
+                        keys: [this.#parseShortcut(key)]
+                    });
+                });
+            }
+        }
+        return extension;
+    }
+}
+export default Decorator;

package/dist/impl/extensions/analysis/decorators/menus/index.js

@@ -0,0 +1,20 @@
+import BaseReader from '../base';
+class Decorator extends BaseReader {
+    /**
+     *
+     * @param decorator
+     */
+    constructor(decorator) {
+        super(decorator);
+    }
+    /**
+     *
+     * @param extension
+     * @returns
+     */
+    async execute() {
+        const extension = await super.execute();
+        return extension;
+    }
+}
+export default Decorator;

package/dist/impl/extensions/analysis/index.js

@@ -0,0 +1,15 @@
+import Reader from './reader';
+import { ActivationEvents, Commands, Keybindings, Menus } from './decorators';
+/**
+ *
+ * @param extensionURL
+ * @returns
+ */
+export const analysisExtension = (extensionURL) => {
+    const reader = new Reader(extensionURL);
+    const commands = new Commands(reader);
+    const keybindings = new Keybindings(commands);
+    const menus = new Menus(keybindings);
+    const activationEvents = new ActivationEvents(menus);
+    return activationEvents;
+};

package/dist/impl/extensions/analysis/reader/index.js

@@ -0,0 +1,31 @@
+import yaml from 'yaml';
+class Reader {
+    #extensionURL;
+    /**
+     *
+     * @param extensionURL
+     */
+    constructor(extensionURL) {
+        this.#extensionURL = extensionURL;
+    }
+    /**
+     *
+     * @param extension
+     * @returns
+     */
+    execute() {
+        return new Promise((resolve) => {
+            const extensionConfig = `${this.#extensionURL}.punica/config.yaml`;
+            fetch(extensionConfig, { method: 'GET' })
+                .then((res) => {
+                return res.text();
+            })
+                .then((config) => {
+                const extension = yaml.parse(config);
+                extension.moduleURL = this.#extensionURL;
+                resolve(extension);
+            });
+        });
+    }
+}
+export default Reader;

package/dist/impl/extensions/index.js

@@ -0,0 +1,76 @@
+import { analysisExtension } from './analysis';
+import { activeExtension } from './active';
+class ExtensionManager {
+    #extensions;
+    #activeExtension;
+    /**
+     *
+     */
+    constructor() {
+        this.#extensions = new Map();
+        this.#activeExtension = new Map();
+    }
+    /**
+     *
+     * @param extensionURL
+     * @param args
+     */
+    async load(extensionURL, ...args) {
+        try {
+            const extensionURLs = [extensionURL, ...args];
+            for (const url of extensionURLs) {
+                const analysis = analysisExtension(url);
+                const extension = await analysis.execute();
+                this.#extensions.set(extension.name, extension);
+                this.#activeExtension.set(extension.name, false);
+                console.log(extension.name, extension);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    /**
+     *
+     * @param extensionName
+     */
+    async activate(extensionName) {
+        if (this.#activeExtension.get(extensionName)) {
+            console.log(`Extension "${extensionName}" is already active.`);
+            return;
+        }
+        const extension = this.#extensions.get(extensionName);
+        if (!extension) {
+            console.error(`Extension "${extensionName}" not found.`);
+            return;
+        }
+        try {
+            const active = activeExtension(extensionName);
+            const activatedExtension = await active.execute();
+            if (activatedExtension &&
+                activatedExtension.module &&
+                typeof activatedExtension.module.activate === 'function') {
+                await activatedExtension.module.activate({});
+                this.#activeExtension.set(extensionName, true);
+            }
+            else {
+                throw new Error(`Failed to activate extension "${extensionName}". The "activate" method is missing or invalid.`);
+            }
+        }
+        catch (error) {
+            console.error(`Error activating extension "${extensionName}":`, error);
+        }
+    }
+    /**
+     *
+     * @param extensionName
+     * @returns
+     */
+    getExtension(extensionName) {
+        return this.#extensions.get(extensionName);
+    }
+}
+const extension = {
+    manager: new ExtensionManager()
+};
+export default extension;