@onecx/integration-interface 8.0.0-rc.7 → 8.0.0-rc.8

package/dist/index.cjs

@@ -0,0 +1,1076 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/integration-interface/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConfigurationTopic: () => ConfigurationTopic,
+  CurrentLocationTopic: () => CurrentLocationTopic,
+  CurrentMfeTopic: () => CurrentMfeTopic,
+  CurrentPageTopic: () => CurrentPageTopic,
+  CurrentThemeTopic: () => CurrentThemeTopic,
+  CurrentWorkspaceTopic: () => CurrentWorkspaceTopic,
+  DynamicTranslationService: () => DynamicTranslationService,
+  DynamicTranslationsMessageType: () => DynamicTranslationsMessageType,
+  DynamicTranslationsTopic: () => DynamicTranslationsTopic,
+  EventType: () => EventType,
+  EventsTopic: () => EventsTopic,
+  GlobalErrorTopic: () => GlobalErrorTopic,
+  GlobalLoadingTopic: () => GlobalLoadingTopic,
+  IconService: () => IconService,
+  IconTopic: () => IconTopic,
+  ImageRepositoryService: () => ImageRepositoryService,
+  ImageRepositoryTopic: () => ImageRepositoryTopic,
+  IsAuthenticatedTopic: () => IsAuthenticatedTopic,
+  MessageTopic: () => MessageTopic,
+  OverrideType: () => OverrideType,
+  ParametersTopic: () => ParametersTopic,
+  PermissionsRpcTopic: () => PermissionsRpcTopic,
+  PermissionsTopic: () => PermissionsTopic,
+  PhoneType: () => PhoneType,
+  RemoteComponentsTopic: () => RemoteComponentsTopic,
+  ResizedEventType: () => ResizedEventType,
+  ResizedEventsTopic: () => ResizedEventsTopic,
+  ShellCapability: () => ShellCapability,
+  Technologies: () => Technologies,
+  UNVERSIONED_KEY: () => UNVERSIONED_KEY,
+  UserProfileTopic: () => UserProfileTopic,
+  ensureIconCache: () => ensureIconCache,
+  generateClassName: () => generateClassName,
+  getDynamicTranslationsCache: () => getDynamicTranslationsCache,
+  hasShellCapability: () => hasShellCapability,
+  normalizeIconName: () => normalizeIconName
+});
+module.exports = __toCommonJS(index_exports);
+
+// libs/accelerator/src/lib/topic/topic.ts
+var import_operators = require("rxjs/operators");
+var import_rxjs = require("rxjs");
+
+// libs/accelerator/src/lib/declarations.ts
+window["@onecx/accelerator"] ??= {};
+window["@onecx/accelerator"].gatherer ??= {};
+window["@onecx/accelerator"].gatherer.promises ??= {};
+window["@onecx/accelerator"].topic ??= {};
+window["@onecx/accelerator"].topic.useBroadcastChannel ??= "V2";
+window["@onecx/accelerator"].topic.initDate ??= Date.now();
+window["@onecx/accelerator"].topic.tabId ??= Math.ceil(globalThis.performance.now());
+
+// libs/accelerator/src/lib/utils/logs.utils.ts
+function isStatsEnabled() {
+  return window["@onecx/accelerator"]?.topic?.statsEnabled === true;
+}
+function increaseMessageCount(topicName, messageType) {
+  window["@onecx/accelerator"].topic ??= {};
+  window["@onecx/accelerator"].topic.stats ??= {};
+  window["@onecx/accelerator"].topic.stats.messagesPublished ??= {};
+  if (isStatsEnabled()) {
+    const messageStats = window["@onecx/accelerator"].topic.stats.messagesPublished;
+    if (!messageStats[topicName]) {
+      messageStats[topicName] = {
+        TopicNext: 0,
+        TopicGet: 0,
+        TopicResolve: 0
+      };
+    }
+    messageStats[topicName][messageType]++;
+  }
+}
+function increaseInstanceCount(topicName) {
+  window["@onecx/accelerator"].topic ??= {};
+  window["@onecx/accelerator"].topic.stats ??= {};
+  window["@onecx/accelerator"].topic.stats.instancesCreated ??= {};
+  if (isStatsEnabled()) {
+    const instanceStats = window["@onecx/accelerator"].topic.stats.instancesCreated;
+    if (!instanceStats[topicName]) {
+      instanceStats[topicName] = 0;
+    }
+    instanceStats[topicName]++;
+  }
+}
+
+// libs/accelerator/src/lib/topic/message.ts
+window["onecxMessageId"] ??= 1;
+var Message = class {
+  // id can be undefined while used via old implementation
+  constructor(type) {
+    this.type = type;
+    this.timestamp = window.performance.now();
+    this.id = window["onecxMessageId"]++;
+  }
+  timestamp;
+  id;
+};
+
+// libs/accelerator/src/lib/topic/topic-message.ts
+var TopicMessage = class extends Message {
+  constructor(type, name, version) {
+    super(type);
+    this.name = name;
+    this.version = version;
+    if (isStatsEnabled()) {
+      increaseMessageCount(this.name, type);
+    }
+  }
+};
+
+// libs/accelerator/src/lib/topic/topic-data-message.ts
+var TopicDataMessage = class extends TopicMessage {
+  constructor(type, name, version, data) {
+    super(type, name, version);
+    this.data = data;
+  }
+};
+
+// libs/accelerator/src/lib/topic/topic-resolve-message.ts
+var TopicResolveMessage = class extends TopicMessage {
+  constructor(type, name, version, resolveId) {
+    super(type, name, version);
+    this.resolveId = resolveId;
+  }
+};
+
+// libs/accelerator/src/lib/utils/create-logger.utils.ts
+var import_debug = __toESM(require("debug"), 1);
+import_debug.default.log = console.log.bind(console);
+function createLoggerFactory(libOrAppName) {
+  const prefix = libOrAppName.trim();
+  if (!prefix) throw new Error("createLoggerFactory(libOrAppName): libOrAppName must be a non-empty string.");
+  const createLogger3 = (location) => {
+    const trimmedLocation = location.trim();
+    if (!trimmedLocation) throw new Error("createLogger(location): location must be a non-empty string.");
+    const ns = (level) => `${prefix}:${trimmedLocation}:${level}`;
+    return {
+      debug: (0, import_debug.default)(ns("debug")),
+      info: (0, import_debug.default)(ns("info")),
+      warn: (0, import_debug.default)(ns("warn")),
+      error: (0, import_debug.default)(ns("error"))
+    };
+  };
+  return createLogger3;
+}
+
+// libs/accelerator/src/lib/utils/logger.utils.ts
+var createLogger = createLoggerFactory("@onecx/accelerator");
+
+// libs/accelerator/src/lib/topic/topic-publisher.ts
+var TopicPublisher = class {
+  constructor(name, version) {
+    this.name = name;
+    this.version = version;
+    this.baseLogger = createLogger(`TopicPublisher:${this.name}`);
+  }
+  publishPromiseResolver = {};
+  publishBroadcastChannel;
+  publishBroadcastChannelV2;
+  baseLogger;
+  publish(value) {
+    const message = new TopicDataMessage("TopicNext" /* TopicNext */, this.name, this.version, value);
+    this.sendMessage(message);
+    const resolveMessage = new TopicResolveMessage("TopicResolve" /* TopicResolve */, this.name, this.version, message.id);
+    const promise = new Promise((resolve) => {
+      this.publishPromiseResolver[message.id] = resolve;
+    });
+    this.sendMessage(resolveMessage);
+    return promise;
+  }
+  createBroadcastChannel() {
+    if (this.publishBroadcastChannel && this.publishBroadcastChannelV2) {
+      return;
+    }
+    if (window["@onecx/accelerator"]?.topic?.useBroadcastChannel) {
+      if (typeof BroadcastChannel === "undefined") {
+        this.baseLogger.info("BroadcastChannel not supported. Disabling BroadcastChannel for topic publisher");
+        window["@onecx/accelerator"] ??= {};
+        window["@onecx/accelerator"].topic ??= {};
+        window["@onecx/accelerator"].topic.useBroadcastChannel = false;
+      } else {
+        this.publishBroadcastChannel = new BroadcastChannel(`Topic-${this.name}|${this.version}`);
+        this.publishBroadcastChannelV2 = new BroadcastChannel(`TopicV2-${this.name}|${this.version}-${window["@onecx/accelerator"].topic.tabId}`);
+      }
+    }
+  }
+  sendMessage(message) {
+    this.createBroadcastChannel();
+    if (window["@onecx/accelerator"]?.topic?.useBroadcastChannel === "V2") {
+      this.publishBroadcastChannelV2?.postMessage(message);
+    } else if (window["@onecx/accelerator"]?.topic?.useBroadcastChannel) {
+      this.publishBroadcastChannel?.postMessage(message);
+    } else {
+      window.postMessage(message, "*");
+    }
+  }
+};
+
+// libs/accelerator/src/lib/topic/topic.ts
+var Topic = class extends TopicPublisher {
+  logger = createLogger(`Topic:${this.name}`);
+  isInitializedPromise;
+  data = new import_rxjs.BehaviorSubject(void 0);
+  isInit = false;
+  resolveInitPromise;
+  windowEventListener = (m) => this.onWindowMessage(m);
+  readBroadcastChannel;
+  readBroadcastChannelV2;
+  constructor(name, version, sendGetMessage = true) {
+    super(name, version);
+    window["@onecx/accelerator"] ??= {};
+    window["@onecx/accelerator"].topic ??= {};
+    window["@onecx/accelerator"].topic.initDate ??= Date.now();
+    if (window["@onecx/accelerator"]?.topic?.useBroadcastChannel) {
+      if (typeof BroadcastChannel === "undefined") {
+        this.logger.info("BroadcastChannel not supported. Disabling BroadcastChannel for topic");
+        window["@onecx/accelerator"] ??= {};
+        window["@onecx/accelerator"].topic ??= {};
+        window["@onecx/accelerator"].topic.useBroadcastChannel = false;
+      } else {
+        this.readBroadcastChannel = new BroadcastChannel(`Topic-${this.name}|${this.version}`);
+        this.readBroadcastChannelV2 = new BroadcastChannel(`TopicV2-${this.name}|${this.version}-${window["@onecx/accelerator"].topic.tabId}`);
+      }
+    }
+    if (isStatsEnabled()) {
+      increaseInstanceCount(this.name);
+    }
+    this.isInitializedPromise = new Promise((resolve) => {
+      this.resolveInitPromise = resolve;
+    });
+    window.addEventListener("message", this.windowEventListener);
+    this.readBroadcastChannel?.addEventListener("message", (m) => this.onBroadcastChannelMessage(m));
+    this.readBroadcastChannelV2?.addEventListener("message", (m) => this.onBroadcastChannelMessageV2(m));
+    if (sendGetMessage) {
+      if (window["@onecx/accelerator"].topic.initDate && Date.now() - window["@onecx/accelerator"].topic.initDate < 2e3) {
+        setTimeout(() => {
+          if (!this.isInit) {
+            const message = new TopicMessage("TopicGet" /* TopicGet */, this.name, this.version);
+            this.sendMessage(message);
+          }
+        }, 100);
+      } else {
+        const message = new TopicMessage("TopicGet" /* TopicGet */, this.name, this.version);
+        this.sendMessage(message);
+      }
+    }
+  }
+  get isInitialized() {
+    return this.isInitializedPromise;
+  }
+  asObservable() {
+    return this.data.asObservable().pipe(
+      (0, import_operators.filter)(() => this.isInit),
+      (0, import_operators.map)((d) => d.data)
+    );
+  }
+  subscribe(observerOrNext, error, complete) {
+    return this.asObservable().subscribe(observerOrNext, error, complete);
+  }
+  pipe(...operations) {
+    return this.asObservable().pipe(...operations);
+  }
+  /**
+   * @deprecated source is deprecated in rxjs. This is only here to be compatible with the interface.
+   */
+  get source() {
+    return this.asObservable().source;
+  }
+  /**
+   * @deprecated operator is deprecated in rxjs. This is only here to be compatible with the interface.
+   */
+  get operator() {
+    return this.asObservable().operator;
+  }
+  /**
+   * @deprecated lift is deprecated in rxjs. This is only here to be compatible with the interface.
+   */
+  lift(operator) {
+    return this.asObservable().lift(operator);
+  }
+  /**
+   * @deprecated foreach is deprecated in rxjs. This is only here to be compatible with the interface.
+   */
+  forEach(next, thisArg) {
+    return this.asObservable().forEach(next, thisArg);
+  }
+  /**
+   * @deprecated toPromise is deprecated in rxjs. This is only here to be compatible with the interface.
+   */
+  toPromise() {
+    return this.asObservable().toPromise();
+  }
+  destroy() {
+    window.removeEventListener("message", this.windowEventListener, true);
+    this.readBroadcastChannel?.close();
+    this.publishBroadcastChannel?.close();
+    this.readBroadcastChannelV2?.close();
+    this.publishBroadcastChannelV2?.close();
+  }
+  onWindowMessage(m) {
+    if (m.data?.name === this.name && m.data?.version === this.version) {
+      this.logger.debug("received message via window", m.data);
+    }
+    switch (m.data.type) {
+      case "TopicNext" /* TopicNext */: {
+        this.disableBroadcastChannel();
+        if (m.data.name === this.name && m.data.version === this.version) {
+          this.handleTopicNextMessage(m);
+        }
+        break;
+      }
+      case "TopicGet" /* TopicGet */: {
+        this.disableBroadcastChannel();
+        if (m.data.name === this.name && m.data.version === this.version && this.isInit && this.data.value) {
+          this.handleTopicGetMessage(m);
+        }
+        break;
+      }
+      case "TopicResolve" /* TopicResolve */: {
+        this.disableBroadcastChannel();
+        this.handleTopicResolveMessage(m);
+        break;
+      }
+    }
+  }
+  onBroadcastChannelMessage(m) {
+    this.disableBroadcastChannelV2();
+    this.onBroadcastChannelMessageV2(m);
+  }
+  onBroadcastChannelMessageV2(m) {
+    this.logger.debug("received message", m.data);
+    switch (m.data.type) {
+      case "TopicNext" /* TopicNext */: {
+        this.handleTopicNextMessage(m);
+        break;
+      }
+      case "TopicGet" /* TopicGet */: {
+        if (this.isInit && this.data.value) {
+          this.handleTopicGetMessage(m);
+        }
+        break;
+      }
+      case "TopicResolve" /* TopicResolve */: {
+        this.handleTopicResolveMessage(m);
+        break;
+      }
+    }
+  }
+  disableBroadcastChannel() {
+    window["@onecx/accelerator"] ??= {};
+    window["@onecx/accelerator"].topic ??= {};
+    if (window["@onecx/accelerator"].topic.useBroadcastChannel === true) {
+      this.logger.info("Disabling BroadcastChannel for topic");
+    }
+    window["@onecx/accelerator"].topic.useBroadcastChannel = false;
+  }
+  disableBroadcastChannelV2() {
+    window["@onecx/accelerator"] ??= {};
+    window["@onecx/accelerator"].topic ??= {};
+    if (window["@onecx/accelerator"].topic.useBroadcastChannel === "V2") {
+      this.logger.info("Disabling BroadcastChannel V2 for topic");
+    }
+    window["@onecx/accelerator"].topic.useBroadcastChannel = true;
+  }
+  handleTopicResolveMessage(m) {
+    const publishPromiseResolver = this.publishPromiseResolver[m.data.resolveId];
+    if (publishPromiseResolver) {
+      try {
+        publishPromiseResolver();
+        m.stopImmediatePropagation();
+        m.stopPropagation();
+        delete this.publishPromiseResolver[m.data.resolveId];
+      } catch (error) {
+        this.logger.error("Error handling TopicResolveMessage:", error);
+      }
+    }
+  }
+  handleTopicGetMessage(m) {
+    if (this.data.value) {
+      this.sendMessage(this.data.value);
+      m.stopImmediatePropagation();
+      m.stopPropagation();
+    }
+  }
+  handleTopicNextMessage(m) {
+    if (!this.data.value || this.isInit && m.data.id !== void 0 && this.data.value.id !== void 0 && m.data.id > this.data.value.id || this.isInit && m.data.timestamp > this.data.value.timestamp) {
+      this.isInit = true;
+      this.data.next(m.data);
+      this.resolveInitPromise();
+    } else if (this.data.value && this.isInit && m.data.timestamp === this.data.value.timestamp && (m.data.id && !this.data.value.id || !m.data.id && this.data.value.id)) {
+      this.logger.warn(
+        "Message was dropped because of equal timestamps, because there was an old style message in the system. Please upgrade all libraries to the latest version."
+      );
+    }
+  }
+};
+
+// libs/accelerator/src/lib/topic/mocks/fake-topic.ts
+var import_rxjs2 = require("rxjs");
+
+// libs/accelerator/src/lib/utils/ensure-property.utils.ts
+function ensureProperty(obj, path, initialValue) {
+  let current = obj;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (current[key] == null || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const lastKey = path.at(-1);
+  if (lastKey === void 0) {
+    return obj;
+  }
+  current[lastKey] ??= initialValue;
+  return obj;
+}
+
+// libs/integration-interface/src/lib/topics/current-mfe/v1/current-mfe.topic.ts
+var CurrentMfeTopic = class extends Topic {
+  constructor() {
+    super("currentMfe", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/current-page/v1/current-page.topic.ts
+var import_rxjs3 = require("rxjs");
+var import_BehaviorSubject = require("rxjs/internal/BehaviorSubject");
+
+// libs/integration-interface/src/lib/utils/logger.utils.ts
+var createLogger2 = createLoggerFactory("@onecx/integration-interface");
+
+// libs/integration-interface/src/lib/topics/current-page/v1/current-page.topic.ts
+var logger = createLogger2("CurrentPageTopic");
+var CurrentPageTopic = class extends Topic {
+  currentPath$ = new import_BehaviorSubject.BehaviorSubject(document.location.pathname);
+  constructor() {
+    super("currentPage", 1);
+    this.watchForPathChanges();
+  }
+  asObservable() {
+    return (0, import_rxjs3.combineLatest)([super.asObservable(), this.currentPath$.pipe((0, import_rxjs3.distinctUntilChanged)())]).pipe(
+      (0, import_rxjs3.map)(([v, path]) => v.path === path ? v : void 0)
+    );
+  }
+  watchForPathChanges() {
+    const body = document.querySelector("body");
+    if (body === null) {
+      logger.error("could not listen to location changes");
+      throw new Error("could not listen to location changes");
+    }
+    const observer = new MutationObserver(() => {
+      this.currentPath$.next(document.location.pathname);
+    });
+    observer.observe(body, { childList: true, subtree: true });
+  }
+};
+
+// libs/integration-interface/src/lib/topics/global-error/v1/global-error.topic.ts
+var GlobalErrorTopic = class extends Topic {
+  constructor() {
+    super("globalError", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/global-loading/v1/global-loading.topic.ts
+var GlobalLoadingTopic = class extends Topic {
+  constructor() {
+    super("globalLoading", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/current-theme/v1/current-theme.topic.ts
+var CurrentThemeTopic = class extends Topic {
+  constructor() {
+    super("currentTheme", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/current-theme/v1/theme-override.model.ts
+var OverrideType = /* @__PURE__ */ ((OverrideType2) => {
+  OverrideType2["PRIMENG"] = "PRIMENG";
+  OverrideType2["CSS"] = "CSS";
+  return OverrideType2;
+})(OverrideType || {});
+
+// libs/integration-interface/src/lib/topics/user-profile/v1/user-profile.model.ts
+var PhoneType = /* @__PURE__ */ ((PhoneType2) => {
+  PhoneType2["MOBILE"] = "MOBILE";
+  PhoneType2["LANDLINE"] = "LANDLINE";
+  return PhoneType2;
+})(PhoneType || {});
+
+// libs/integration-interface/src/lib/topics/user-profile/v1/user-profile.topic.ts
+var UserProfileTopic = class extends Topic {
+  constructor() {
+    super("userProfile", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/configuration/v1/configuration.topic.ts
+var ConfigurationTopic = class extends Topic {
+  constructor() {
+    super("configuration", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/current-workspace/v1/current-workspace.topic.ts
+var CurrentWorkspaceTopic = class extends Topic {
+  constructor() {
+    super("currentPortal", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/is-authenticated/v1/isAuthenticated.topic.ts
+var IsAuthenticatedTopic = class extends Topic {
+  constructor() {
+    super("isAuthenticated", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/message/v1/message.topic.ts
+var MessageTopic = class extends Topic {
+  constructor() {
+    super("message", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/remote-components/v1/remote-component.model.ts
+var Technologies = /* @__PURE__ */ ((Technologies2) => {
+  Technologies2["Angular"] = "Angular";
+  Technologies2["WebComponentScript"] = "WebComponentScript";
+  Technologies2["WebComponentModule"] = "WebComponentModule";
+  return Technologies2;
+})(Technologies || {});
+
+// libs/integration-interface/src/lib/topics/remote-components/v1/remote-components.topic.ts
+var RemoteComponentsTopic = class extends Topic {
+  constructor() {
+    super("remoteComponentsInfo", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/permissions/v1/permissions.topic.ts
+var PermissionsTopic = class extends Topic {
+  constructor() {
+    super("permissions", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/permissions-rpc/v1/permissions-rpc.topic.ts
+var PermissionsRpcTopic = class extends Topic {
+  constructor() {
+    super("permissionsRpc", 1, false);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/events/v1/events-topic.ts
+var EventsTopic = class extends Topic {
+  constructor() {
+    super("events", 1, false);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/events/v1/event-type.ts
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["NAVIGATED"] = "navigated";
+  EventType2["AUTH_LOGOUT_BUTTON_CLICKED"] = "authentication#logoutButtonClicked";
+  return EventType2;
+})(EventType || {});
+
+// libs/integration-interface/src/lib/topics/resized-events/v1/resized-event-type.ts
+var ResizedEventType = /* @__PURE__ */ ((ResizedEventType2) => {
+  ResizedEventType2["SLOT_RESIZED"] = "slot_resized";
+  ResizedEventType2["SLOT_GROUP_RESIZED"] = "slot_group_resized";
+  ResizedEventType2["REQUESTED_EVENTS_CHANGED"] = "requested_events_changed";
+  return ResizedEventType2;
+})(ResizedEventType || {});
+
+// libs/integration-interface/src/lib/topics/resized-events/v1/resized-events.topic.ts
+var ResizedEventsPublisher = class extends TopicPublisher {
+  constructor() {
+    super("resizedEvents", 1);
+  }
+  //NOSONAR
+  publish(event) {
+    if (!["slot_group_resized" /* SLOT_GROUP_RESIZED */, "slot_resized" /* SLOT_RESIZED */].includes(event.type)) {
+      return super.publish(event);
+    }
+    const resizedEvent = event;
+    const entityName = eventToEntityName(resizedEvent);
+    if (window["@onecx/integration-interface"]["resizedEvents"]?.[resizedEvent.type]?.includes(entityName)) {
+      return super.publish(event);
+    }
+    return Promise.resolve();
+  }
+};
+var ResizedEventsTopic = class extends Topic {
+  constructor() {
+    super("resizedEvents", 1, false);
+    window["@onecx/integration-interface"] ??= {};
+    window["@onecx/integration-interface"]["resizedEvents"] ??= {};
+  }
+  /**
+   * Request resized update events for a specific entity
+   * @param eventType - The type of resized event to request
+   * @param entityName - The name of the entity (slot or slot group) to request events for
+   */
+  static requestEvent(eventType, entityName) {
+    window["@onecx/integration-interface"] ??= {};
+    window["@onecx/integration-interface"]["resizedEvents"] ??= {};
+    window["@onecx/integration-interface"]["resizedEvents"][eventType] ??= [];
+    window["@onecx/integration-interface"]["resizedEvents"][eventType].push(entityName);
+    new ResizedEventsPublisher().publish({
+      type: "requested_events_changed" /* REQUESTED_EVENTS_CHANGED */,
+      payload: {
+        type: eventType,
+        name: entityName
+      }
+    });
+  }
+  //NOSONAR
+  publish(event) {
+    if (!["slot_group_resized" /* SLOT_GROUP_RESIZED */, "slot_resized" /* SLOT_RESIZED */].includes(event.type)) {
+      return super.publish(event);
+    }
+    const resizedEvent = event;
+    const entityName = eventToEntityName(resizedEvent);
+    if (window["@onecx/integration-interface"]["resizedEvents"]?.[resizedEvent.type]?.includes(entityName)) {
+      return super.publish(event);
+    }
+    return Promise.resolve();
+  }
+};
+function eventToEntityName(event) {
+  switch (event.type) {
+    case "slot_resized" /* SLOT_RESIZED */:
+      return event.payload.slotName;
+    case "slot_group_resized" /* SLOT_GROUP_RESIZED */:
+      return event.payload.slotGroupName;
+  }
+}
+
+// libs/integration-interface/src/lib/topics/current-location/v1/current-location.topic.ts
+var CurrentLocationTopic = class extends Topic {
+  constructor() {
+    super("currentLocation", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/parameters/v1/parameters.topic.ts
+var ParametersTopic = class extends Topic {
+  constructor() {
+    super("parameters", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/topics/image-repository/image-repository.topic.ts
+var ImageRepositoryTopic = class extends Topic {
+  constructor() {
+    super("imageRepository", 1);
+  }
+};
+
+// libs/integration-interface/src/lib/services/image-repository.service.ts
+var import_rxjs4 = require("rxjs");
+var ImageRepositoryService = class {
+  _imageRepositoryTopic$;
+  get imageRepositoryTopic() {
+    this._imageRepositoryTopic$ ??= new ImageRepositoryTopic();
+    return this._imageRepositoryTopic$;
+  }
+  set imageRepositoryTopic(source) {
+    this._imageRepositoryTopic$ = source;
+  }
+  async getUrl(names, fallbackUrl) {
+    if (!names || names.length === 0) {
+      return fallbackUrl;
+    }
+    const imagePaths = await (0, import_rxjs4.firstValueFrom)(this.imageRepositoryTopic.asObservable());
+    const urls = imagePaths.images || {};
+    const isUrlListEmpty = Object.entries(urls).length === 0;
+    if (isUrlListEmpty) {
+      return fallbackUrl;
+    }
+    for (const name of names) {
+      if (name in urls) {
+        return urls[name];
+      }
+    }
+    return fallbackUrl;
+  }
+  destroy() {
+    this.imageRepositoryTopic.destroy();
+  }
+};
+
+// libs/integration-interface/src/lib/topics/icons/v1/icon.topic.ts
+var IconTopic = class extends Topic {
+  constructor() {
+    super("icon", 1, false);
+  }
+};
+
+// libs/integration-interface/src/lib/services/icon.service.ts
+var import_rxjs5 = require("rxjs");
+var DEFAULT_CLASS_TYPE = "background-before";
+function ensureIconCache() {
+  ensureProperty(globalThis, ["onecxIcons"], {});
+}
+function generateClassName(name, classType) {
+  const safeName = normalizeIconName(name);
+  return `onecx-theme-icon-${classType}-${safeName}`;
+}
+function normalizeIconName(name) {
+  return name.replaceAll(/[^a-zA-Z0-9_-]+/g, "-");
+}
+var IconService = class {
+  _iconTopic$;
+  get iconTopic() {
+    this._iconTopic$ ??= new IconTopic();
+    return this._iconTopic$;
+  }
+  set iconTopic(source) {
+    this._iconTopic$ = source;
+  }
+  constructor() {
+    ensureIconCache();
+  }
+  requestIcon(name, classType = DEFAULT_CLASS_TYPE) {
+    const className = generateClassName(name, classType);
+    if (globalThis.onecxIcons && !(name in globalThis.onecxIcons)) {
+      ensureProperty(globalThis, ["onecxIcons", name], void 0);
+      this.iconTopic.publish({ type: "IconRequested", name });
+    }
+    return className;
+  }
+  async requestIconAsync(name, classType = DEFAULT_CLASS_TYPE) {
+    const className = this.requestIcon(name, classType);
+    const cached = globalThis.onecxIcons?.[name];
+    if (cached === null) return null;
+    if (cached) return className;
+    await (0, import_rxjs5.firstValueFrom)(
+      this.iconTopic.pipe(
+        (0, import_rxjs5.filter)((e) => e.type === "IconsReceived"),
+        (0, import_rxjs5.map)(() => globalThis.onecxIcons?.[name]),
+        (0, import_rxjs5.filter)((v) => v !== void 0)
+      )
+    );
+    return globalThis.onecxIcons?.[name] ? className : null;
+  }
+  destroy() {
+    this.iconTopic.destroy();
+  }
+};
+
+// libs/integration-interface/src/lib/topics/dynamic-translations/v1/dynamic-translations.model.ts
+var DynamicTranslationsMessageType = /* @__PURE__ */ ((DynamicTranslationsMessageType2) => {
+  DynamicTranslationsMessageType2["REQUESTED"] = "REQUESTED";
+  DynamicTranslationsMessageType2["RECEIVED"] = "RECEIVED";
+  return DynamicTranslationsMessageType2;
+})(DynamicTranslationsMessageType || {});
+
+// libs/integration-interface/src/lib/topics/dynamic-translations/v1/dynamic-translations.topic.ts
+var DynamicTranslationsTopic = class extends Topic {
+  constructor() {
+    super("dynamicTranslations", 1, false);
+  }
+};
+
+// libs/integration-interface/src/lib/services/dynamic-translation.service.ts
+var import_rxjs6 = require("rxjs");
+var import_semver = require("semver");
+
+// libs/integration-interface/src/version.ts
+var LIB_NAME = "@onecx/integration-interface";
+
+// libs/integration-interface/src/lib/models/shell-capability.model.ts
+var ShellCapability = /* @__PURE__ */ ((ShellCapability2) => {
+  ShellCapability2["CURRENT_LOCATION_TOPIC"] = "currentLocationTopic";
+  ShellCapability2["PARAMETERS_TOPIC"] = "parametersTopic";
+  ShellCapability2["ACTIVENESS_AWARE_MENUS"] = "activenessAwareMenus";
+  ShellCapability2["DYNAMIC_TRANSLATIONS_TOPIC"] = "dynamicTranslationsTopic";
+  return ShellCapability2;
+})(ShellCapability || {});
+
+// libs/integration-interface/src/lib/utils/shell-capability.utils.ts
+function hasShellCapability(capability) {
+  return window["onecx-shell-capabilities"]?.includes(capability) ?? false;
+}
+
+// libs/integration-interface/src/lib/services/dynamic-translation.service.ts
+var UNVERSIONED_KEY = "undefined";
+function getDynamicTranslationsCache() {
+  const global = ensureProperty(globalThis, [LIB_NAME, "dynamicTranslationsCache"], {});
+  return global[LIB_NAME].dynamicTranslationsCache;
+}
+var DynamicTranslationService = class {
+  logger = createLogger2("DynamicTranslationService");
+  _dynamicTranslationsTopic$;
+  /**
+   * Topic used to request and receive dynamic translations.
+   */
+  get dynamicTranslationsTopic$() {
+    this._dynamicTranslationsTopic$ ??= new DynamicTranslationsTopic();
+    return this._dynamicTranslationsTopic$;
+  }
+  set dynamicTranslationsTopic$(source) {
+    this._dynamicTranslationsTopic$ = source;
+  }
+  /**
+   * Returns translations for the given locale and contexts.
+   *
+   * The method first attempts to resolve from cache, requests missing entries,
+   * and waits for a `RECEIVED` message when data is still pending.
+   *
+   * @param locale Target locale (for example `en`, `de`).
+   * @param contexts Translation contexts to resolve.
+   * @returns An observable emitting a context-keyed translation map.
+   */
+  getTranslations(locale, contexts) {
+    this.logger.debug("getTranslations", { locale, contexts });
+    const safeContexts = contexts.filter((context) => this.isSafeContext(context));
+    if (safeContexts.length !== contexts.length) {
+      this.logger.debug("Skipping unsafe translation contexts", { locale, contexts });
+    }
+    if (!this.isSafeCacheKey(locale)) {
+      this.logger.debug("Skipping dynamic translation resolution for unsafe locale key", { locale });
+      return (0, import_rxjs6.of)(this.createEmptyRecords(safeContexts));
+    }
+    if (!hasShellCapability("dynamicTranslationsTopic" /* DYNAMIC_TRANSLATIONS_TOPIC */)) {
+      this.logger.debug("Shell does not support dynamic translations, returning empty records");
+      return (0, import_rxjs6.of)(this.createEmptyRecords(safeContexts));
+    }
+    const cache = getDynamicTranslationsCache();
+    ensureProperty(cache, [locale], {});
+    const { missing, pending } = this.categorizeContexts(locale, safeContexts);
+    this.logger.debug("Categorized contexts", { missing, pending });
+    if (missing.length > 0) {
+      this.logger.debug("Marking contexts as requested and publishing request", { missing });
+      this.markContextsAsRequested(cache, locale, missing);
+      this.requestTranslations(locale, missing);
+    }
+    if (this.hasIncompleteContexts(missing, pending)) {
+      this.logger.debug("Waiting for translations", { missing, pending });
+      return this.waitForTranslations(locale, safeContexts);
+    }
+    const result = this.collectTranslations(locale, safeContexts);
+    this.logger.debug("Collected translations", { translations: result.translations });
+    return (0, import_rxjs6.of)(result.translations);
+  }
+  createEmptyRecords(contexts) {
+    const emptyRecords = {};
+    for (const context of contexts) {
+      const contextKey = this.getContextKey(context);
+      emptyRecords[contextKey] = {};
+    }
+    return emptyRecords;
+  }
+  categorizeContexts(locale, contexts) {
+    const missing = [];
+    const pending = [];
+    for (const context of contexts) {
+      const cachedVersion = this.findMatchingVersion(locale, context.name, context.version);
+      this.logger.debug("Context version match result", { context, cachedVersion });
+      if (cachedVersion === null) {
+        this.logger.debug("Context marked as null (no translations)", { context });
+        continue;
+      }
+      if (cachedVersion === void 0) {
+        this.logger.debug("Context missing in cache", { context });
+        missing.push(context);
+      } else if (cachedVersion.value === void 0) {
+        this.logger.debug("Context pending (requested but not received)", { context });
+        pending.push(context);
+      }
+    }
+    return { missing, pending };
+  }
+  findMatchingVersion(locale, contextName, requestedVersion) {
+    const contextCache = this.getContextCache(locale, contextName);
+    if (!contextCache) {
+      return void 0;
+    }
+    const versions = Object.keys(contextCache);
+    if (versions.length === 0) {
+      return void 0;
+    }
+    const normalizedVersion = requestedVersion || UNVERSIONED_KEY;
+    if (!requestedVersion || requestedVersion === UNVERSIONED_KEY) {
+      return this.getFirstAvailableVersion(contextCache, versions);
+    }
+    return this.findBestMatchingVersion(contextCache, versions, normalizedVersion);
+  }
+  getContextCache(locale, contextName) {
+    if (!this.isSafeCacheKey(locale) || !this.isSafeCacheKey(contextName)) {
+      return void 0;
+    }
+    const cache = getDynamicTranslationsCache();
+    const localeCache = cache[locale];
+    if (!localeCache || !Object.hasOwn(localeCache, contextName)) {
+      return void 0;
+    }
+    return localeCache[contextName];
+  }
+  getFirstAvailableVersion(contextCache, versions) {
+    const firstVersion = versions[0];
+    return { value: contextCache[firstVersion], version: firstVersion };
+  }
+  findBestMatchingVersion(contextCache, versions, requestedVersion) {
+    if (contextCache[requestedVersion] !== void 0) {
+      this.logger.debug("Exact version match found in cache", { requestedVersion });
+      return { value: contextCache[requestedVersion], version: requestedVersion };
+    }
+    const semanticMatch = this.findSemanticVersionMatch(contextCache, versions, requestedVersion);
+    if (semanticMatch) {
+      this.logger.debug("Semantic version match found", { requestedVersion, matchedVersion: semanticMatch.version });
+      return semanticMatch;
+    }
+    const nullCheck = this.checkForNullTranslations(contextCache, versions);
+    const hasNullMatch = nullCheck === null;
+    if (hasNullMatch) {
+      this.logger.debug("Found null translations check result", { requestedVersion });
+    } else {
+      this.logger.debug("No match found", { requestedVersion });
+    }
+    return nullCheck;
+  }
+  findSemanticVersionMatch(contextCache, versions, requestedVersion) {
+    const satisfyingVersions = versions.filter((v) => v !== UNVERSIONED_KEY && (0, import_semver.valid)(v) !== null && this.satisfiesVersion(v, requestedVersion)).sort(import_semver.rcompare);
+    if (satisfyingVersions.length > 0) {
+      const bestMatch = satisfyingVersions[0];
+      return { value: contextCache[bestMatch], version: bestMatch };
+    }
+    return void 0;
+  }
+  satisfiesVersion(availableVersion, requestedVersion) {
+    try {
+      return (0, import_semver.satisfies)(availableVersion, requestedVersion, { includePrerelease: true });
+    } catch {
+      return false;
+    }
+  }
+  checkForNullTranslations(contextCache, versions) {
+    const hasNullTranslation = versions.some((version) => contextCache[version] === null);
+    return hasNullTranslation ? null : void 0;
+  }
+  markContextsAsRequested(cache, locale, contexts) {
+    this.logger.debug("Marking contexts as requested", { locale, contexts });
+    for (const context of contexts) {
+      if (!this.isSafeContext(context)) {
+        this.logger.debug("Skipping unsafe context key while marking as requested", { locale, context });
+        continue;
+      }
+      ensureProperty(cache, [locale, context.name], {});
+      cache[locale][context.name][context.version ?? UNVERSIONED_KEY] = void 0;
+      this.logger.debug("Marked context as requested", { locale, context });
+    }
+  }
+  isSafeContext(context) {
+    return this.isSafeCacheKey(context.name) && this.isSafeCacheKey(context.version);
+  }
+  isSafeCacheKey(key) {
+    if (!key) {
+      return true;
+    }
+    return key !== "__proto__" && key !== "prototype" && key !== "constructor";
+  }
+  requestTranslations(locale, contexts) {
+    const message = {
+      type: "REQUESTED" /* REQUESTED */,
+      locale,
+      contexts: contexts.map(({ name, version }) => ({ name, version }))
+    };
+    this.logger.debug("Publishing translation request message", { message });
+    this.dynamicTranslationsTopic$.publish(message);
+  }
+  hasIncompleteContexts(missing, pending) {
+    return missing.length > 0 || pending.length > 0;
+  }
+  waitForTranslations(locale, contexts) {
+    this.logger.debug("Starting to wait for translations", { locale, contexts });
+    return this.dynamicTranslationsTopic$.pipe(
+      (0, import_rxjs6.filter)((msg) => {
+        const isReceived = msg.type === "RECEIVED" /* RECEIVED */;
+        this.logger.debug("Received message", { type: msg.type, isReceived });
+        return isReceived;
+      }),
+      (0, import_rxjs6.map)(() => {
+        const result = this.collectTranslations(locale, contexts);
+        this.logger.debug("Collected after message", { complete: result.complete });
+        return result;
+      }),
+      (0, import_rxjs6.filter)((result) => result.complete),
+      (0, import_rxjs6.map)((result) => {
+        this.logger.debug("Translations complete, returning", { contextCount: Object.keys(result.translations).length });
+        return result.translations;
+      }),
+      (0, import_rxjs6.first)()
+    );
+  }
+  collectTranslations(locale, contexts) {
+    const translations = {};
+    let complete = true;
+    for (const context of contexts) {
+      const match = this.findMatchingVersion(locale, context.name, context.version);
+      if (this.shouldSkipContext(match)) {
+        this.logger.debug("Skipping context (null)", { context });
+        continue;
+      }
+      if (this.isContextIncomplete(match)) {
+        this.logger.debug("Context incomplete", { context });
+        complete = false;
+        continue;
+      }
+      this.addContextTranslations(translations, context, match);
+    }
+    this.logger.debug("Collection complete", { complete, contextCount: Object.keys(translations).length });
+    return { translations, complete };
+  }
+  shouldSkipContext(match) {
+    return match === null;
+  }
+  isContextIncomplete(match) {
+    return match?.value === void 0;
+  }
+  addContextTranslations(target, context, match) {
+    const matchedValue = match?.value;
+    if (matchedValue !== null && matchedValue !== void 0) {
+      const contextKey = this.getContextKey(context);
+      target[contextKey] = matchedValue;
+      this.logger.debug("Added context translations", { contextKey, translationKeys: Object.keys(matchedValue) });
+    }
+  }
+  getContextKey(context) {
+    return context.version ? `${context.name}@${context.version}` : context.name;
+  }
+  /**
+   * Releases topic resources held by this service instance.
+   */
+  destroy() {
+    this.dynamicTranslationsTopic$.destroy();
+  }
+};