@punica/editor 1.0.2 → 1.0.3

package/dist/impl/history/index.js

@@ -0,0 +1,57 @@
+class HistoryManager {
+    #commandMap = new Map();
+    #history = [];
+    #undone = [];
+    /**
+     *
+     * @param command
+     */
+    registerCommand(command) {
+        this.#commandMap.set(command.id, command);
+    }
+    /**
+     *
+     * @param commandId
+     */
+    executeCommand(commandId) {
+        const command = this.#commandMap.get(commandId);
+        if (command) {
+            command.execute();
+            this.#history.push(command);
+            this.#undone = [];
+        }
+        else {
+            console.error(`Command with ID ${commandId} not found.`);
+        }
+    }
+    /**
+     *
+     */
+    undo() {
+        const command = this.#history.pop();
+        if (command) {
+            command.undo();
+            this.#undone.push(command);
+        }
+        else {
+            console.error('No command to undo.');
+        }
+    }
+    /**
+     *
+     */
+    redo() {
+        const command = this.#undone.pop();
+        if (command) {
+            command.execute();
+            this.#history.push(command);
+        }
+        else {
+            console.error('No command to redo.');
+        }
+    }
+}
+const history = {
+    manager: new HistoryManager()
+};
+export default history;

package/dist/impl/index.js

@@ -1,7 +1,9 @@
-export { default as View } from './view';
-export { default as Extensions } from './extensions';
+export { default as ActivityBar } from './activityBar';
 export { default as Commands } from './commands';
-export { default as Layout } from './layout';
+export { default as History } from './history';
+export { default as Extensions } from './extensions';
 export { default as KeyboardShortcuts } from './keyboardShortcuts';
-export { default as TimeServer } from './timeServer';
+export { default as Layout } from './layout';
 export { default as Statusbar } from './statusbar';
+export { default as TimeServer } from './timeServer';
+export { default as View } from './view';

package/dist/impl/keyboardShortcuts/index.js

@@ -0,0 +1,67 @@
+class KeyboardShortcutsManager {
+    #shortcuts = [];
+    /**
+     *
+     * @param keys1
+     * @param keys2
+     * @returns
+     */
+    #areKeysEqual(keys1, keys2) {
+        if (keys1.length !== keys2.length)
+            return false;
+        return keys1.every((key1, index) => key1.key.toLowerCase() === keys2[index].key.toLowerCase() &&
+            key1.ctrlKey === keys2[index].ctrlKey &&
+            key1.shiftKey === keys2[index].shiftKey &&
+            key1.altKey === keys2[index].altKey &&
+            key1.metaKey === keys2[index].metaKey);
+    }
+    /**
+     *
+     * @param event
+     * @param keys
+     * @returns
+     */
+    #areKeysPressed(event, keys) {
+        return keys.every((key) => (key.ctrlKey ? event.ctrlKey : true) &&
+            (key.shiftKey ? event.shiftKey : true) &&
+            (key.altKey ? event.altKey : true) &&
+            (key.metaKey ? event.metaKey : true) &&
+            event.key.toLowerCase() === key.key.toLowerCase());
+    }
+    /**
+     *
+     */
+    constructor() {
+        document.addEventListener('keydown', this.handleKeyEvent.bind(this));
+    }
+    /**
+     *
+     * @param shortcut
+     */
+    registerShortcut(shortcut) {
+        this.#shortcuts.push(shortcut);
+    }
+    /**
+     *
+     * @param keys
+     */
+    unregisterShortcut(keys) {
+        this.#shortcuts = this.#shortcuts.filter((shortcut) => this.#areKeysEqual(shortcut.keys, keys));
+    }
+    /**
+     *
+     * @param event
+     */
+    handleKeyEvent(event) {
+        const matchedShortcut = this.#shortcuts.find((shortcut) => this.#areKeysPressed(event, shortcut.keys));
+        if (matchedShortcut) {
+            event.preventDefault();
+            const commandsManager = window.punica.Commands.manager;
+            commandsManager.executeCommand(matchedShortcut.command);
+        }
+    }
+}
+const keyboardShortcuts = {
+    manager: new KeyboardShortcutsManager()
+};
+export default keyboardShortcuts;

package/dist/impl/layout/index.js

@@ -0,0 +1,50 @@
+class LayoutManager {
+    #item = new Map();
+    #layoutElement;
+    /**
+     *
+     * @param type
+     */
+    #addItem(type) {
+        const content = document.createElement('div');
+        content.id = type;
+        this.#layoutElement.appendChild(content);
+        this.#item.set(type, { type, content });
+    }
+    /**
+     *
+     */
+    constructor() {
+        this.#layoutElement = document.createElement('div');
+        this.#layoutElement.id = 'punica-editor';
+        this.#addItem('appBar');
+        this.#addItem('activityBar');
+        this.#addItem('content');
+        this.#addItem('statusbar');
+        this.#addItem('primarySidebar');
+        this.#addItem('secondarySidebar');
+    }
+    /**
+     *
+     * @param type
+     * @returns
+     */
+    getItem(type) {
+        const item = this.#item.get(type);
+        if (item === undefined) {
+            throw new Error(`Item of type '${type}' not found`);
+        }
+        return item;
+    }
+    /**
+     *
+     * @param container
+     */
+    render(container) {
+        container.appendChild(this.#layoutElement);
+    }
+}
+const layout = {
+    manager: new LayoutManager()
+};
+export default layout;

package/dist/impl/statusbar/index.js

@@ -0,0 +1,81 @@
+class StatusbarManager {
+    #primaryItems = new Map();
+    #secondaryItems = new Map();
+    #content;
+    #primaryContent;
+    #secondaryContent;
+    /**
+     *
+     */
+    #initiliazeContent() {
+        const layoutManager = window.punica.Layout.manager;
+        const statusbarContent = layoutManager.getItem('statusbar').content;
+        this.#content = document.createElement('punica-row');
+        this.#primaryContent = document.createElement('punica-col');
+        this.#secondaryContent = document.createElement('punica-col');
+        this.#content.setAttribute('alignItems', 'center');
+        this.#content.setAttribute('justifyContent', 'space-between');
+        this.#content.appendChild(this.#primaryContent);
+        this.#content.appendChild(this.#secondaryContent);
+        statusbarContent?.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('size', 'dd');
+        button.setAttribute('title', item.title);
+        button.onclick = () => { };
+        button.className = 'status-bar-action';
+        if (item.icon) {
+            button.innerHTML = `<punica-icon size="xlarge">${item.icon}</punica-icon>`;
+        }
+        else if (item.label) {
+            button.innerHTML = item.label;
+        }
+        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 statusbar = {
+    manager: new StatusbarManager()
+};
+export default statusbar;

package/dist/impl/timeServer/index.js

@@ -0,0 +1,49 @@
+class TimeServerManager {
+    #subscribers = [];
+    #intervalId = null;
+    /**
+     *
+     */
+    #start() {
+        if (this.#intervalId === null) {
+            this.#intervalId = window.setInterval(() => {
+                const currentTime = new Date();
+                this.#subscribers.forEach((subscriber) => subscriber.update(currentTime));
+            }, 1000);
+        }
+    }
+    /**
+     *
+     */
+    #stop() {
+        if (this.#intervalId !== null) {
+            window.clearInterval(this.#intervalId);
+            this.#intervalId = null;
+        }
+    }
+    /**
+     *
+     * @param subscriber
+     */
+    subscribe(subscriber) {
+        this.#subscribers.push(subscriber);
+        if (this.#subscribers.length == 1) {
+            this.#start();
+        }
+    }
+    /**
+     *
+     * @param subscriber
+     */
+    unsubscribe(subscriber) {
+        this.#subscribers = this.#subscribers.filter((sub) => sub !== subscriber);
+        if (this.#subscribers.length == 0) {
+            this.#stop();
+        }
+    }
+}
+const timeServerManager = {
+    manager: new TimeServerManager()
+};
+//timeServerManager.manager.start();
+export default timeServerManager;

package/dist/index.js

@@ -1,13 +1,15 @@
-import { View, Extensions, Commands, Layout, KeyboardShortcuts, TimeServer, Statusbar } from './impl';
-export function initiliaze() {
+import { ActivityBar, Commands, History, Extensions, KeyboardShortcuts, Layout, Statusbar, TimeServer, View } from './impl';
+export function initialize() {
     window.punica = {
         version: '1.0.0',
-        Layout,
-        View,
-        Extensions,
+        ActivityBar,
         Commands,
+        History,
+        Extensions,
         KeyboardShortcuts,
+        Layout,
+        Statusbar,
         TimeServer,
-        Statusbar
+        View
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@punica/editor",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Punica Editor",
   "private": false,
   "main": "dist/index.js",
@@ -9,7 +9,6 @@
     "access": "public"
   },
   "scripts": {
-    "start": "webpack-dev-server --config webpack.config.dev.js",
     "build": "tsc -p tsconfig.build.json",
     "lint": "eslint . --ext .js,.ts",
     "lint:fix": "eslint . --ext .js,.ts --fix",
@@ -30,33 +29,18 @@
     "README.md"
   ],
   "dependencies": {
-    "@punica/common": "^1.0.2"
+    "@punica/common": "^1.0.2",
+    "yaml":"^2.4.5",
+    "classnames": "^2.3.2"
   },
   "devDependencies": {
-    "@babel/core": "^7.24.7",
-    "@babel/plugin-transform-runtime": "^7.24.7",
-    "@babel/preset-env": "^7.24.7",
-    "@babel/preset-typescript": "^7.24.7",
     "@types/node": "^20.14.10",
-    "@typescript-eslint/eslint-plugin":"",
+    "@typescript-eslint/eslint-plugin": "",
     "@typescript-eslint/parser": "^7.16.0",
-    "@eslint/config-array":"^0.17.0",
-    "raw-loader": "^4.0.2",
-    "babel-loader": "^9.1.3",
-    "copy-webpack-plugin": "^12.0.2",
-    "css-loader": "^7.1.2",
+    "@eslint/config-array": "^0.17.0",
     "eslint": "^8.56.0",
-    "husky": "^8.0.3",
-    "file-loader": "^6.2.0",
-    "html-webpack-plugin": "^5.6.0",
-    "portfinder-sync": "^0.0.2",
+    "husky": "^9.1.1",
     "prettier": "^3.3.2",
-    "serve": "^14.2.3",
-    "ts-loader": "^9.5.1",
-    "typescript": "^5.5.3",
-    "webpack": "^5.92.1",
-    "webpack-cli": "^5.1.4",
-    "webpack-dev-server": "^5.0.4",
-    "webpack-merge": "^6.0.1"
+    "typescript": "^5.5.3"
   }
 }

package/types/index.d.ts

@@ -1,4 +1,6 @@
+/// <reference path="punica.module.activityBar.d.ts" />
 /// <reference path="punica.module.commands.d.ts" />
+/// <reference path="punica.module.history.d.ts" />
 /// <reference path="punica.module.dragDrop.d.ts" />
 /// <reference path="punica.module.extensions.d.ts" />
 /// <reference path="punica.module.keyboardShortcuts.d.ts" />
@@ -6,23 +8,12 @@
 /// <reference path="punica.module.statusbar.d.ts" />
 /// <reference path="punica.module.timeServer.d.ts" />
 /// <reference path="punica.module.view.d.ts" />
+/// <reference path="punica.types.d.ts" />
 
 declare module 'punica' {
   export const version: string;
 }
 
-declare global {
-  interface Window {
-    punica: typeof punica;
-  }
-}
-
-import * as punica from 'punica';
-
-window.punica = punica;
-
-export function initialize(): void {
-  console.log('Punica initialized');
-}
+export function initialize(): void;
 
 export {};

package/types/punica.module.activityBar.d.ts

@@ -0,0 +1,21 @@
+declare module 'punica' {
+  export namespace ActivityBar {
+    type Alignment = 'primary' | 'secondary';
+    type ItemType = 'normal' | 'menu';
+
+    interface IItem {
+      id: string;
+      name: string;
+      alignment: Alignment;
+      title: string;
+      icon: string;
+    }
+
+    interface IActivityBarManager {
+      addItem(item: IItem): void;
+      removeItem(itemId: string): void;
+    }
+
+    const manager: IActivityBarManager;
+  }
+}

package/types/punica.module.commands.d.ts

@@ -1,16 +1,19 @@
 declare module 'punica' {
   export namespace Commands {
+    interface IDisposable {
+      dispose(): void;
+    }
+
     interface ICommand {
-      id: string;
-      execute(): void;
-      undo(): void;
+      title: string;
+      disposable?: Disposable;
+      execute(...args: any[]): void;
     }
 
     interface ICommandManager {
-      registerCommand(command: ICommand): void;
-      executeCommand(commandId: string): void;
-      undo(): void;
-      redo(): void;
+      registerCommand(commandName: string, command: ICommand): void;
+      executeCommand(commandName: string, ...args: any[]): void;
+      disposeCommand(commandName: string): void;
     }
 
     const manager: ICommandManager;

package/types/punica.module.extensions.d.ts

@@ -1,14 +1,132 @@
 declare module 'punica' {
   export namespace Extensions {
-    interface IExtension {
+    interface BaseView {
+      id: string;
       name: string;
-      activate: () => void;
+      title?: string;
+      label?: string;
+      icon?: string;
+      alignment?: 'primary' | 'secondary';
+      content?: HTMLElement;
+    }
+
+    interface Views {
+      primarySidebar?: BaseView;
+      secondarySidebar?: BaseView;
+      content?: BaseView;
+      activityBar?: Pick<BaseView, 'id' | 'name'> &
+        Required<Pick<BaseView, 'title' | 'icon' | 'alignment'>>;
+      statusBar?: Pick<BaseView, 'id' | 'name'> &
+        Required<Pick<BaseView, 'title' | 'label' | 'icon' | 'alignment'>>;
+    }
+
+    interface Command {
+      command: string;
+      title: string;
+    }
+
+    interface Keybinding {
+      command: string;
+      key: string;
+      when: string;
+    }
+
+    interface MenuItem {
+      command: string;
+      when: string;
+      group: string;
+    }
+
+    interface Menu {
+      commandPalette: MenuItem;
+      context: MenuItem;
+    }
+
+    interface BooleanProperty {
+      type: 'boolean';
+      default: boolean;
+      description: string;
+    }
+
+    interface StringProperty {
+      type: 'string';
+      default: string;
+      description: string;
+    }
+
+    interface NumberProperty {
+      type: 'number';
+      default: number;
+      description: string;
+    }
+
+    interface ArrayProperty {
+      type: 'array';
+      default: any[];
+      description: string;
+      items: any;
+    }
+
+    interface ObjectProperty {
+      type: 'object';
+      default: { [key: string]: any };
+      description: string;
+      properties: { [key: string]: Property };
+    }
+
+    type Property =
+      | BooleanProperty
+      | StringProperty
+      | NumberProperty
+      | ArrayProperty
+      | ObjectProperty;
+
+    interface Configuration {
+      title: string;
+      properties: {
+        [key: string]: Property;
+      };
+    }
+
+    interface Integrations {
+      commands?: Command[];
+      keybindings?: Keybinding[];
+      menus?: Menu;
+      views?: Views;
+      configuration?: Configuration;
+    }
+
+    interface Extension {
+      module: Extensions.IExtension;
+      moduleURL: string;
+      name: string;
+      displayName: string;
+      description: string;
+      version: string;
+      main: string;
+      activationEvents?: string[];
+      dependOns?: string[];
+      integrations: Integrations;
+      engines: {
+        punica: string;
+      };
+    }
+
+    interface ExtensionDecorator {
+      execute(): Promise<Extension>;
+    }
+
+    interface IExtensionContext {}
+
+    interface IExtension {
+      activate: (context: IExtensionContext) => Promise<void>;
       deactivate: () => void;
     }
 
     interface IExtensionManager {
-      load(extensionPath: IExtension): void;
-      getExtension(extensionName: string): IExtension | undefined;
+      load(extensionPath: string, ...args: string[]): Promise<void>;
+      activate(extensionName): Promise<void>;
+      getExtension(extensionName: string): Extension | undefined;
     }
 
     const manager: IExtensionManager;

package/types/punica.module.history.d.ts

@@ -0,0 +1,18 @@
+declare module 'punica' {
+  export namespace History {
+    interface ICommand {
+      id: string;
+      execute(): void;
+      undo(): void;
+    }
+
+    interface IHistoryManager {
+      registerCommand(command: ICommand): void;
+      executeCommand(commandId: string): void;
+      undo(): void;
+      redo(): void;
+    }
+
+    const manager: IHistoryManager;
+  }
+}

package/types/punica.module.keyboardShortcuts.d.ts

@@ -1,5 +1,9 @@
 declare module 'punica' {
   export namespace KeyboardShortcuts {
+    interface IDisposable {
+      dispose(): void;
+    }
+
     interface IKey {
       key: string;
       ctrlKey?: boolean;
@@ -9,8 +13,9 @@ declare module 'punica' {
     }
 
     interface IShortcut {
+      command: string;
       keys: IKey[];
-      commandId: string;
+      disposable?: IDisposable;
     }
 
     interface IShortcutManager {

package/types/punica.module.statusbar.d.ts

@@ -1,17 +1,18 @@
 declare module 'punica' {
   export namespace Statusbar {
-    type Alignment = 'left' | 'right';
+    type Alignment = 'primary' | 'secondary';
     type ItemType = 'progress' | 'warning' | 'error' | 'normal';
 
     interface IItem {
       id: string;
-      type: ItemType;
-      content: HTMLElement;
-      command?: () => void;
+      label: string;
+      alignment: Alignment;
+      title: string;
+      icon: string;
     }
 
     interface IStatusbarManager {
-      addItem(alignment: Alignment, item: IItem): void;
+      addItem(item: IItem): void;
       removeItem(itemId: string): void;
     }
 

package/types/punica.module.view.d.ts

@@ -3,6 +3,6 @@ declare module 'punica' {
     const showInformationMessage: <T extends string>(
       message: string,
       ...items: T[]
-    ) => Array<T | undefined>;
+    ) => T[];
   }
 }