@eclipse-lyra/core 0.0.0

package/dist/i18n/filebrowser.json.d.ts

@@ -0,0 +1,29 @@
+declare const _default: {
+  "namespace": "filebrowser",
+  "en": {
+    "CONNECT_WORKSPACE": "Connect Workspace...",
+    "REFRESH_RESOURCE": "Refresh resource",
+    "CREATE_NEW": "Create new...",
+    "OPEN": "Open",
+    "FILE": "File",
+    "FOLDER": "Folder",
+    "FILE_EXISTS_OVERWRITE": "File \"{fileName}\" already exists. Do you want to overwrite it?",
+    "SELECT_WORKSPACE": "Select a workspace.",
+    "DROP_FILES_HERE": "\ud83d\udcc1 Drop files here",
+    "OPEN_WITH": "Open with..."
+  },
+  "de": {
+    "CONNECT_WORKSPACE": "Arbeitsbereich verbinden...",
+    "REFRESH_RESOURCE": "Ressource aktualisieren",
+    "CREATE_NEW": "Neu erstellen...",
+    "OPEN": "\u00d6ffnen",
+    "FILE": "Datei",
+    "FOLDER": "Ordner",
+    "FILE_EXISTS_OVERWRITE": "Die Datei \"{fileName}\" existiert bereits. M\u00f6chten Sie sie \u00fcberschreiben?",
+    "SELECT_WORKSPACE": "W\u00e4hlen Sie einen Arbeitsbereich aus.",
+    "DROP_FILES_HERE": "\ud83d\udcc1 Dateien hier ablegen",
+    "OPEN_WITH": "\u00d6ffnen mit..."
+  }
+};
+
+export default _default;

package/dist/i18n/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/i18n/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/i18n/index.ts"],"names":[],"mappings":""}

package/dist/i18n/logterminal.json.d.ts

@@ -0,0 +1,45 @@
+declare const _default: {
+    "namespace": "logterminal",
+    "en": {
+        "ALL_LOGS": "All logs",
+        "ALL": "All",
+        "INFO_LOGS": "Info logs",
+        "INFO": "Info",
+        "WARNING_LOGS": "Warning logs",
+        "WARNINGS": "Warnings",
+        "ERROR_LOGS": "Error logs",
+        "ERRORS": "Errors",
+        "DEBUG_LOGS": "Debug logs",
+        "DEBUG": "Debug",
+        "AUTO_SCROLL_ENABLED": "Auto-scroll enabled",
+        "AUTO_SCROLL_DISABLED": "Auto-scroll disabled",
+        "AUTO_SCROLL": "Auto-scroll",
+        "MANUAL": "Manual",
+        "CLEAR_LOGS": "Clear logs",
+        "CLEAR": "Clear",
+        "NO_LOG_MESSAGES": "No log messages"
+    },
+    "de": {
+        "ALL_LOGS": "Alle Protokolle",
+        "ALL": "Alle",
+        "INFO_LOGS": "Info-Protokolle",
+        "INFO": "Info",
+        "WARNING_LOGS": "Warnungsprotokolle",
+        "WARNINGS": "Warnungen",
+        "ERROR_LOGS": "Fehlerprotokolle",
+        "ERRORS": "Fehler",
+        "DEBUG_LOGS": "Debug-Protokolle",
+        "DEBUG": "Debug",
+        "AUTO_SCROLL_ENABLED": "Automatisches Scrollen aktiviert",
+        "AUTO_SCROLL_DISABLED": "Automatisches Scrollen deaktiviert",
+        "AUTO_SCROLL": "Automatisches Scrollen",
+        "MANUAL": "Manuell",
+        "CLEAR_LOGS": "Protokolle löschen",
+        "CLEAR": "Löschen",
+        "NO_LOG_MESSAGES": "Keine Protokollnachrichten"
+    }
+}
+
+;
+
+export default _default;

package/dist/i18n/partname.json.d.ts

@@ -0,0 +1,15 @@
+declare const _default: {
+    "namespace": "partname",
+    "en": {
+        "NO_PART": "<no part>",
+        "ACTIVE_PART": "Active part"
+    },
+    "de": {
+        "NO_PART": "<kein Bereich>",
+        "ACTIVE_PART": "Aktiver Bereich"
+    }
+}
+
+;
+
+export default _default;

package/dist/i18n/tasks.json.d.ts

@@ -0,0 +1,15 @@
+declare const _default: {
+    "namespace": "tasks",
+    "en": {
+        "ACTIVE_TASKS": "Active Tasks",
+        "ACTIVE_TASKS_TITLE": "Active tasks: {taskCount}. Click to view details."
+    },
+    "de": {
+        "ACTIVE_TASKS": "Aktive Aufgaben",
+        "ACTIVE_TASKS_TITLE": "Aktive Aufgaben: {taskCount}. Klicken Sie, um Details anzuzeigen."
+    }
+}
+
+;
+
+export default _default;

package/dist/i18n/workspace.json.d.ts

@@ -0,0 +1,15 @@
+declare const _default: {
+    "namespace": "workspace",
+    "en": {
+        "NO_WORKSPACE": "<no workspace>",
+        "LOAD_WORKSPACE": "Load workspace"
+    },
+    "de": {
+        "NO_WORKSPACE": "<kein Arbeitsbereich>",
+        "LOAD_WORKSPACE": "Arbeitsbereich laden"
+    }
+}
+
+;
+
+export default _default;

package/dist/icon-DN6fp0dg.js

@@ -0,0 +1,487 @@
+import { property, customElement } from "lit/decorators.js";
+import { LitElement, css, nothing, html } from "lit";
+import { publish, unsubscribe, subscribe } from "./core/events.js";
+import Toastify from "toastify-js";
+import "toastify-js/src/toastify.css";
+import { Signal, signal, SignalWatcher } from "@lit-labs/signals";
+class DependencyContext {
+  constructor(variables) {
+    this.children = [];
+    this.variables = variables;
+    this.proxy = new Proxy(variables, this);
+  }
+  get(target, prop) {
+    return target[prop] || this.parent?.getProxy()[prop];
+  }
+  set(target, prop, value) {
+    target[prop] = value;
+  }
+  put(prop, value) {
+    this.variables[prop] = value;
+  }
+  getProxy() {
+    return this.proxy;
+  }
+  createChild(variables = {}) {
+    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 !== void 0 && index >= 0) {
+      this.parent?.children.splice(index, 1);
+    }
+    this.parent = void 0;
+  }
+}
+const rootContext = new DependencyContext({});
+const uiContext = rootContext.createChild({});
+const DURATION = 4e3;
+const BASE = { duration: DURATION, gravity: "bottom", position: "right", close: true };
+const show = (msg, style) => {
+  Toastify({ ...BASE, text: msg, style }).showToast();
+};
+const toastInfo = (msg) => {
+  show(msg, { background: "var(--wa-color-brand-50)", color: "var(--wa-color-brand-on)" });
+};
+const toastError = (msg) => {
+  show(msg, { background: "var(--wa-color-danger-50)", color: "var(--wa-color-danger-on)" });
+};
+const toastWarning = (msg) => {
+  show(msg, { background: "var(--wa-color-warning-50)", color: "var(--wa-color-warning-on)" });
+};
+const LogLevelPriority = {
+  "debug": 0,
+  "info": 1,
+  "warning": 2,
+  "error": 3
+};
+let globalLogLevel = "debug";
+const originalConsole = {
+  log: console.log.bind(console),
+  info: console.info.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console),
+  debug: console.debug.bind(console)
+};
+let logHandler = null;
+const messageBuffer = [];
+function formatArg(arg) {
+  if (arg === null) return "null";
+  if (arg === void 0) return "undefined";
+  if (typeof arg === "string") return arg;
+  if (typeof arg === "number" || typeof arg === "boolean") return String(arg);
+  if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+  try {
+    return JSON.stringify(arg);
+  } catch {
+    return String(arg);
+  }
+}
+class Logger {
+  constructor(source) {
+    this.source = source;
+  }
+  info(message) {
+    this.log(message, "info");
+  }
+  warning(message) {
+    this.log(message, "warning");
+  }
+  warn(message) {
+    this.log(message, "warning");
+  }
+  error(message) {
+    this.log(message, "error");
+  }
+  debug(message) {
+    this.log(message, "debug");
+  }
+  log(message, level) {
+    dispatch(this.source, message, level);
+  }
+}
+function shouldLog(level) {
+  return LogLevelPriority[level] >= LogLevelPriority[globalLogLevel];
+}
+function dispatch(source, message, level) {
+  if (!shouldLog(level)) {
+    return;
+  }
+  if (logHandler) {
+    logHandler(source, message, level);
+  } else {
+    messageBuffer.push({ source, message, level });
+    originalConsole[level === "error" ? "error" : level === "warning" ? "warn" : level === "debug" ? "debug" : "log"](
+      `[${source}] ${message}`
+    );
+  }
+}
+function initializeConsoleInterception() {
+  console.log = function(...args) {
+    originalConsole.log.apply(console, args);
+    dispatch("Console", args.map((a) => formatArg(a)).join(" "), "info");
+  };
+  console.info = function(...args) {
+    originalConsole.info.apply(console, args);
+    dispatch("Console", args.map((a) => formatArg(a)).join(" "), "info");
+  };
+  console.warn = function(...args) {
+    originalConsole.warn.apply(console, args);
+    dispatch("Console", args.map((a) => formatArg(a)).join(" "), "warning");
+  };
+  console.error = function(...args) {
+    originalConsole.error.apply(console, args);
+    dispatch("Console", args.map((a) => formatArg(a)).join(" "), "error");
+  };
+  console.debug = function(...args) {
+    originalConsole.debug.apply(console, args);
+    dispatch("Console", args.map((a) => formatArg(a)).join(" "), "debug");
+  };
+}
+initializeConsoleInterception();
+function registerLogHandler(handler) {
+  logHandler = handler;
+  while (messageBuffer.length > 0) {
+    const msg = messageBuffer.shift();
+    if (msg) {
+      handler(msg.source, msg.message, msg.level);
+    }
+  }
+}
+function unregisterLogHandler() {
+  logHandler = null;
+}
+function createLogger(source) {
+  return new Logger(source);
+}
+function setLogLevel(level) {
+  globalLogLevel = level;
+}
+const defaultLogger = createLogger("System");
+rootContext.put("logger", defaultLogger);
+const TOPIC_CONTRIBUTEIONS_CHANGED = "events/contributionregistry/contributionsChanged";
+class ContributionRegistry {
+  constructor() {
+    this.contributions = /* @__PURE__ */ new Map();
+  }
+  registerContribution(target, contribution) {
+    const targetSlot = this.getContributions(target);
+    if ("command" in contribution) {
+      const cmd = contribution;
+      if (cmd.disabled instanceof Function) {
+        cmd.disabled = new Signal.Computed(cmd.disabled);
+      }
+    }
+    targetSlot.push(contribution);
+    publish(TOPIC_CONTRIBUTEIONS_CHANGED, { target, contributions: targetSlot });
+  }
+  getContributions(target) {
+    if (!this.contributions.has(target)) {
+      this.contributions.set(target, []);
+    }
+    return this.contributions.get(target);
+  }
+}
+const contributionRegistry = new ContributionRegistry();
+rootContext.put("contributionRegistry", contributionRegistry);
+const EMPTY_SIGNALPORT = {};
+const activePartSignal = signal(null);
+const activeEditorSignal = signal(null);
+const partDirtySignal = signal(null);
+const activeTasksSignal = signal(0);
+const activeSelectionSignal = signal(void 0);
+const perspectiveSwitchedSignal = signal({ name: "", timestamp: 0 });
+const TOPIC_COMMAND_REGISTERED = "events/commandregistry/commandRegistered";
+class Command {
+  constructor(id, name, description, parameters, output) {
+    this.id = id;
+    this.name = name;
+    this.description = description;
+    this.parameters = parameters || [];
+    this.output = output || [];
+  }
+}
+class CommandStack {
+  //private stack: any[] = []
+  async execute(commandId, context) {
+    return commandRegistry.execute(commandId, context);
+  }
+  async undo() {
+  }
+  async redo() {
+  }
+}
+class CommandRegistry {
+  constructor() {
+    this.commands = {};
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  registerHandler(commandId, handler) {
+    if (!this.handlers.has(commandId)) {
+      this.handlers.set(commandId, []);
+    }
+    const handlerList = this.handlers.get(commandId);
+    handlerList.push(handler);
+    handlerList.sort((a, b) => (b.ranking ?? 0) - (a.ranking ?? 0));
+  }
+  getHandler(commandId) {
+    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) {
+    const context = {
+      params: params || {},
+      activePart: activePartSignal.get(),
+      activeEditor: activeEditorSignal.get()
+    };
+    return context;
+  }
+  execute(commandId, context = {}) {
+    const handlers = this.getHandler(commandId);
+    if (!handlers) {
+      defaultLogger.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)}` : "";
+    defaultLogger.debug(`[CommandRegistry] Executing command: ${commandId}${command ? ` (${command.name})` : ""}${paramsStr}`);
+    for (const handler of handlers) {
+      if (handler.canExecute === void 0 || handler.canExecute(context)) {
+        try {
+          const result = handler.execute(context);
+          defaultLogger.debug(`[CommandRegistry] Command executed successfully: ${commandId} (result: ${result})`);
+          return result;
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          defaultLogger.error(`[CommandRegistry] Command execution failed: ${commandId} - ${errorMsg}`);
+          throw error;
+        }
+      }
+    }
+    defaultLogger.error(`[CommandRegistry] No handler found to execute command: ${commandId}`);
+  }
+  createAndRegisterCommand(id, name, description, parameters, handler) {
+    const command = new Command(id, name, description, parameters);
+    this.registerCommand(command);
+    if (handler) {
+      this.registerHandler(id, handler);
+    }
+  }
+  registerCommand(command) {
+    this.commands[command.id] = command;
+    defaultLogger.debug(`Command registered: ${command.id}`);
+    publish(TOPIC_COMMAND_REGISTERED, command);
+  }
+  hasCommand(commandId) {
+    return commandId in this.commands;
+  }
+  listCommands(context) {
+    if (context) {
+      return Object.values(this.commands).filter((command) => {
+        const handlers = commandRegistry.getHandler(command.id) || [];
+        return handlers.some((handler) => handler.canExecute === void 0 || handler.canExecute(context));
+      }).reduce((acc, command) => {
+        acc[command.id] = command;
+        return acc;
+      }, {});
+    }
+    return this.commands;
+  }
+  getCommand(commandId) {
+    return this.commands[commandId];
+  }
+  registerAll(options) {
+    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
+      });
+    }
+  }
+}
+const commandRegistry = new CommandRegistry();
+rootContext.put("commandRegistry", commandRegistry);
+const registerAll = (options) => {
+  commandRegistry.registerAll(options);
+};
+const watchSignal = (signal2, callback) => {
+  const watcher = new Signal.subtle.Watcher(async () => {
+    try {
+      await 0;
+      callback(signal2.get());
+    } finally {
+      watcher.watch(signal2);
+    }
+  });
+  watcher.watch(signal2);
+  signal2.get();
+  return () => {
+    watcher.unwatch(signal2);
+  };
+};
+Object.defineProperty(LitElement.prototype, "model", {
+  enumerable: true,
+  configurable: true,
+  writable: true
+});
+const LyraWidgetBase = SignalWatcher(LitElement);
+class LyraWidget extends LyraWidgetBase {
+  constructor() {
+    super(...arguments);
+    this.signalCleanups = /* @__PURE__ */ new Set();
+    this.eventSubscriptions = /* @__PURE__ */ new Set();
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.doBeforeUI();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.eventSubscriptions.forEach((token) => unsubscribe(token));
+    this.eventSubscriptions.clear();
+    this.signalCleanups.forEach((cleanup) => cleanup());
+    this.signalCleanups.clear();
+  }
+  subscribe(topic, callback) {
+    const token = subscribe(topic, callback.bind(this));
+    this.eventSubscriptions.add(token);
+  }
+  showInfo(msg) {
+    toastInfo(msg);
+  }
+  showError(msg) {
+    toastError(msg);
+  }
+  nobubble(wrap) {
+    return (event) => {
+      event.stopPropagation();
+      wrap.bind(this)(event);
+    };
+  }
+  command(command, state = {}) {
+    return () => {
+      this.executeCommand(command, state);
+    };
+  }
+  executeCommand(command, params) {
+    const execContext = commandRegistry.createExecutionContext(params);
+    commandRegistry.execute(command, execContext);
+  }
+  watch(signal2, callback) {
+    const cleanup = watchSignal(signal2, callback.bind(this));
+    this.signalCleanups.add(cleanup);
+  }
+  firstUpdated(_changedProperties) {
+    super.firstUpdated(_changedProperties);
+    this.doInitUI();
+  }
+  updateIdle() {
+    requestIdleCallback(() => this.requestUpdate());
+  }
+  updateLater() {
+    requestAnimationFrame(() => this.requestUpdate());
+  }
+  doBeforeUI() {
+  }
+  doInitUI() {
+  }
+  withRefresh(callback) {
+    callback();
+    this.updateLater();
+  }
+}
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+let LyraIcon = class extends LyraWidget {
+  constructor() {
+    super(...arguments);
+    this.family = "regular";
+  }
+  render() {
+    if (!this.name) {
+      return "";
+    }
+    const parts = this.name.trim().split(/ +/);
+    const iconName = parts.pop();
+    const library = parts.pop();
+    return html`
+            <wa-icon library="${library || nothing}" variant="${this.variant || nothing}"
+                         family="${this.family || nothing}" name=${iconName} label="${this.label || this.name || nothing}"></wa-icon>`;
+  }
+};
+LyraIcon.styles = css`
+        :host {
+            display: contents;
+        }
+    `;
+__decorateClass([
+  property()
+], LyraIcon.prototype, "name", 2);
+__decorateClass([
+  property()
+], LyraIcon.prototype, "family", 2);
+__decorateClass([
+  property()
+], LyraIcon.prototype, "variant", 2);
+__decorateClass([
+  property()
+], LyraIcon.prototype, "label", 2);
+LyraIcon = __decorateClass([
+  customElement("lyra-icon")
+], LyraIcon);
+export {
+  CommandRegistry as C,
+  EMPTY_SIGNALPORT as E,
+  LyraWidget as L,
+  TOPIC_COMMAND_REGISTERED as T,
+  CommandStack as a,
+  TOPIC_CONTRIBUTEIONS_CHANGED as b,
+  activeEditorSignal as c,
+  activePartSignal as d,
+  activeSelectionSignal as e,
+  activeTasksSignal as f,
+  commandRegistry as g,
+  contributionRegistry as h,
+  createLogger as i,
+  defaultLogger as j,
+  perspectiveSwitchedSignal as k,
+  rootContext as l,
+  toastInfo as m,
+  toastWarning as n,
+  registerLogHandler as o,
+  partDirtySignal as p,
+  unregisterLogHandler as q,
+  registerAll as r,
+  setLogLevel as s,
+  toastError as t,
+  uiContext as u,
+  watchSignal as w
+};
+//# sourceMappingURL=icon-DN6fp0dg.js.map