@wix/editor-application 1.393.0 → 1.395.0

package/dist/statics/index.js

@@ -1,8 +1,25 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@wix/public-editor-platform-events'), require('@wix/public-editor-platform-interfaces'), require('@wix/public-editor-platform-errors')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@wix/public-editor-platform-events', '@wix/public-editor-platform-interfaces', '@wix/public-editor-platform-errors'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.EditorPlatformApplicationRuntime = {}, global.publicEditorPlatformEvents, global.publicEditorPlatformInterfaces, global.publicEditorPlatformErrors));
-})(this, (function (exports, publicEditorPlatformEvents, publicEditorPlatformInterfaces, publicEditorPlatformErrors) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@wix/public-editor-platform-events'), require('@wix/public-editor-platform-interfaces'), require('@wix/public-editor-platform-errors'), require('@wix/editor-platform-contexts')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@wix/public-editor-platform-events', '@wix/public-editor-platform-interfaces', '@wix/public-editor-platform-errors', '@wix/editor-platform-contexts'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.EditorPlatformApplicationRuntime = {}, global.publicEditorPlatformEvents, global.publicEditorPlatformInterfaces, global.publicEditorPlatformErrors, global.editorPlatformContexts));
+})(this, (function (exports, publicEditorPlatformEvents, publicEditorPlatformInterfaces, publicEditorPlatformErrors, editorPlatformContexts) { 'use strict';
+
+  function hash() {
+    const _performance = globalThis["performance"];
+    if (_performance && _performance.now) {
+      return _performance.now();
+    }
+    let result = "";
+    const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    const charactersLength = characters.length;
+    let counter = 0;
+    const length = 10;
+    while (counter < length) {
+      result += characters.charAt(Math.floor(Math.random() * charactersLength));
+      counter += 1;
+    }
+    return result;
+  }
 
   class ApplicationLifecycle {
     constructor(events) {
@@ -22,7 +39,7 @@
       if (!this.callbacks[event]) {
         this.callbacks[event] = [];
       }
-      const id = `${performance.now()}`;
+      const id = `${hash()}`;
       this.callbacks[event].push({
         id,
         fn
@@ -45,21 +62,12 @@
 
   var EditorPlatformApplicationErrorCode = /* @__PURE__ */ ((EditorPlatformApplicationErrorCode2) => {
     EditorPlatformApplicationErrorCode2["ApplicationRuntimeError"] = "ApplicationRuntimeError";
-    EditorPlatformApplicationErrorCode2["ApplicationCreationError"] = "ApplicationCreationError";
-    EditorPlatformApplicationErrorCode2["ApplicationLoadError"] = "ApplicationLoadError";
-    EditorPlatformApplicationErrorCode2["ApplicationFetchError"] = "ApplicationFetchError";
-    EditorPlatformApplicationErrorCode2["ApplicationExecuteError"] = "ApplicationExecuteError";
-    EditorPlatformApplicationErrorCode2["ApplicationWasRemoved"] = "ApplicationWasRemoved";
-    EditorPlatformApplicationErrorCode2["UndefinedApiMethod"] = "UndefinedApiMethod";
-    EditorPlatformApplicationErrorCode2["ApplicationIsNotMutable"] = "ApplicationIsNotMutable";
-    EditorPlatformApplicationErrorCode2["FailedToGetPrivateAPI"] = "FailedToGetPrivateAPI";
-    EditorPlatformApplicationErrorCode2["ClientAuthError"] = "ClientAuthError";
     return EditorPlatformApplicationErrorCode2;
   })(EditorPlatformApplicationErrorCode || {});
   class EditorPlatformApplicationError extends publicEditorPlatformErrors.BaseError {
     state = {};
     constructor(message, code) {
-      super(message, code, "Editor Platform Application Error");
+      super(message, code, "EP Application Error");
     }
     withUrl(url) {
       this.state = { ...this.state, url };
@@ -97,8 +105,7 @@
     constructor(type, context) {
       this.type = type;
       this.#context = context;
-      const bindings = this.#context.getBindings();
-      this.appDefinitionId = bindings.appDefinitionId;
+      this.appDefinitionId = this.#context.getAppDefinitionId();
       const events = this.#context.getEvents();
       this.lifecycle = new ApplicationLifecycle(events);
       events.addEventListener(publicEditorPlatformInterfaces.EventType.removeAppCompleted, (e) => {
@@ -156,277 +163,6 @@
     }
   }
 
-  var EditorPlatformApplicationContextErrorCode = /* @__PURE__ */ ((EditorPlatformApplicationContextErrorCode2) => {
-    EditorPlatformApplicationContextErrorCode2["IncorrectEnvironment"] = "IncorrectEnvironment";
-    EditorPlatformApplicationContextErrorCode2["ClientAuthError"] = "ClientAuthError";
-    return EditorPlatformApplicationContextErrorCode2;
-  })(EditorPlatformApplicationContextErrorCode || {});
-  class EditorPlatformApplicationContextError extends publicEditorPlatformErrors.BaseError {
-    state = {};
-    constructor(message, code) {
-      super(message, code, "Editor Platform Application Context Error");
-    }
-    withUrl(url) {
-      this.state = { ...this.state, url };
-      return this;
-    }
-    withAppDefinitionId(appDefinitionId) {
-      this.state = { ...this.state, appDefinitionId };
-      return this;
-    }
-  }
-  const createEditorPlatformApplicationContextError = publicEditorPlatformErrors.createErrorBuilder(EditorPlatformApplicationContextError);
-  async function transformEventPayload(eventPayload, privateAPI) {
-    if (!eventPayload?.type) {
-      return eventPayload;
-    }
-    switch (eventPayload.type) {
-      case "componentSelectionChanged":
-        const componentRefs = eventPayload.componentRefs || [];
-        const components = await Promise.all(
-          componentRefs.map((ref) => {
-            return privateAPI.components.getComponent(ref);
-          })
-        );
-        return {
-          type: eventPayload.type,
-          components
-        };
-      default:
-        return eventPayload;
-    }
-  }
-  class ApplicationBoundEvents {
-    constructor(appDefinitionId, events, privateAPI) {
-      this.appDefinitionId = appDefinitionId;
-      this.privateAPI = privateAPI;
-      this.events = events;
-      this.subscribe = events.subscribe.bind(events);
-      this.commit = events.commit.bind(events);
-      this.startTransaction = events.startTransaction.bind(events);
-      this.silent = events.silent.bind(events);
-    }
-    events;
-    subscribe;
-    commit;
-    startTransaction;
-    silent;
-    notify(event) {
-      this.events.notify({
-        type: event.type,
-        payload: event.payload,
-        meta: {
-          appDefinitionId: this.appDefinitionId
-        }
-      });
-    }
-    notifyCustomEvent(type, payload) {
-      this.notify({
-        type: publicEditorPlatformEvents.PlatformAppEvent.CustomEvent,
-        payload: {
-          ...payload,
-          type
-        }
-      });
-    }
-    /**
-     * TODO: we should use same interface for all events
-     * (subscribe vs addEventListener)
-     */
-    addEventListener(eventType, fn) {
-      return this.events.subscribe(async (event) => {
-        const isAppMatch = event.meta?.appDefinitionId === this.appDefinitionId || event.meta?.appDefinitionId === null;
-        const transformPayload = () => transformEventPayload(event.payload, this.privateAPI);
-        if (eventType === "*") {
-          fn(await transformPayload());
-        } else if (event.type === publicEditorPlatformEvents.PlatformAppEvent.CustomEvent) {
-          if (eventType === event.payload?.type && !isAppMatch) {
-            fn(await transformPayload());
-          }
-        } else if (event.type === publicEditorPlatformEvents.PlatformAppEvent.HostEvent) {
-          if (eventType === event.payload?.type && isAppMatch) {
-            fn(await transformPayload());
-          }
-        }
-      });
-    }
-  }
-  const WAIT_INJECTED_TIMEOUT = 200;
-  const WAIT_INJECTED_RETRY_COUNT = 50;
-  class ContextInjectionStatus {
-    _resolveContextInjected = () => {
-    };
-    _isInjected = false;
-    key;
-    constructor(uuid) {
-      this.key = `__${uuid}_CONTEXT_INJECTION_STATUS_KEY`;
-      if (!globalThis[this.key]) {
-        globalThis[this.key] = new Promise((resolve) => {
-          this._resolveContextInjected = () => {
-            this._isInjected = true;
-            resolve();
-          };
-        });
-      }
-    }
-    isInjected() {
-      return !!this._isInjected;
-    }
-    resolveInjected() {
-      this._resolveContextInjected?.();
-    }
-    waitInjected() {
-      return new Promise((resolve, reject) => {
-        let injected = false;
-        let timeoutId;
-        let retryCount = 0;
-        const timeout = () => {
-          if (injected) {
-            return;
-          }
-          timeoutId = setTimeout(() => {
-            retryCount++;
-            if (retryCount < WAIT_INJECTED_RETRY_COUNT) {
-              if (retryCount % 10 === 0) {
-                console.log(
-                  createEditorPlatformApplicationContextError(
-                    EditorPlatformApplicationContextErrorCode.IncorrectEnvironment,
-                    "contexts are not resolved, still re-trying"
-                  ).withMessage(`try number ${retryCount}`).message
-                );
-              }
-              timeout();
-              return;
-            }
-            if (!injected) {
-              const error = createEditorPlatformApplicationContextError(
-                EditorPlatformApplicationContextErrorCode.IncorrectEnvironment,
-                "contexts are not resolved, threw by timeout"
-              );
-              reject(error);
-            }
-          }, WAIT_INJECTED_TIMEOUT);
-        };
-        timeout();
-        const _waitContextInjectedPromise = globalThis[this.key];
-        _waitContextInjectedPromise.then(() => {
-          injected = true;
-          clearTimeout(timeoutId);
-          resolve();
-        });
-      });
-    }
-  }
-  const ENVIRONMENT_CONTEXT_KEY = "__ENVIRONMENT_CONTEXT_KEY";
-  var PlatformEnvironment = /* @__PURE__ */ ((PlatformEnvironment2) => {
-    PlatformEnvironment2["Worker"] = "Worker";
-    PlatformEnvironment2["Frame"] = "Frame";
-    PlatformEnvironment2["ComponentPanel"] = "ComponentPanel";
-    return PlatformEnvironment2;
-  })(PlatformEnvironment || {});
-  class EnvironmentContext {
-    constructor(environmentContext) {
-      this.environmentContext = environmentContext;
-    }
-    static status = new ContextInjectionStatus("environment");
-    static async inject(context) {
-      if (globalThis[ENVIRONMENT_CONTEXT_KEY]) {
-        throw createEditorPlatformApplicationContextError(
-          EditorPlatformApplicationContextErrorCode.IncorrectEnvironment,
-          "Environment context already exists and should not be overridden"
-        );
-      }
-      globalThis[ENVIRONMENT_CONTEXT_KEY] = new EnvironmentContext(context);
-      this.status.resolveInjected();
-    }
-    static async getInstance() {
-      await this.status.waitInjected();
-      return globalThis[ENVIRONMENT_CONTEXT_KEY];
-    }
-    getPrivateAPI() {
-      return this.environmentContext.privateApi;
-    }
-    getEvents() {
-      return this.environmentContext.events;
-    }
-    getApplicationAPIs() {
-      return this.environmentContext.applicationAPIs ?? {};
-    }
-    getEnvironment() {
-      return this.environmentContext.environment;
-    }
-  }
-  const APPLICATION_CONTEXT_KEY = "__APPLICATION_CONTEXT_KEY";
-  class ApplicationContext {
-    constructor(applicationContext, environment) {
-      this.applicationContext = applicationContext;
-      this.environment = environment;
-      this.events = new ApplicationBoundEvents(
-        this.applicationContext.appDefinitionId,
-        this.environment.getEvents(),
-        this.environment.getPrivateAPI()
-      );
-    }
-    static status = new ContextInjectionStatus("application");
-    /**
-     * TODO: use generics for context type
-     * - application
-     * - editor
-     */
-    static async inject(context) {
-      const environment = await EnvironmentContext.getInstance();
-      if (environment.getEnvironment() !== PlatformEnvironment.Frame) {
-        throw createEditorPlatformApplicationContextError(
-          EditorPlatformApplicationContextErrorCode.IncorrectEnvironment,
-          "Application context can be injected only in frame environment"
-        );
-      }
-      if (globalThis[APPLICATION_CONTEXT_KEY]) {
-        throw createEditorPlatformApplicationContextError(
-          EditorPlatformApplicationContextErrorCode.IncorrectEnvironment,
-          "Application context already exists and should not be overridden"
-        );
-      }
-      globalThis[APPLICATION_CONTEXT_KEY] = new ApplicationContext(
-        context,
-        await EnvironmentContext.getInstance()
-      );
-      this.status.resolveInjected();
-    }
-    static async getInstance() {
-      const environment = await EnvironmentContext.getInstance();
-      if (environment.getEnvironment() === PlatformEnvironment.Frame) {
-        await this.status.waitInjected();
-        return globalThis[APPLICATION_CONTEXT_KEY];
-      } else {
-        return __APPLICATION_CONTEXT_KEY;
-      }
-    }
-    events;
-    getAppDefinitionId() {
-      return this.applicationContext.appDefinitionId;
-    }
-    getBindings() {
-      return this.applicationContext;
-    }
-    getEvents() {
-      return this.events;
-    }
-    getPrivateAPI() {
-      return this.environment.getPrivateAPI();
-    }
-    getPrivateApplicationAPI() {
-      const appDefinitionId = this.getAppDefinitionId();
-      if (!appDefinitionId) {
-        throw createEditorPlatformApplicationContextError(
-          EditorPlatformApplicationContextErrorCode.IncorrectEnvironment,
-          "appDefinitionId is not available"
-        );
-      }
-      return this.environment.getApplicationAPIs()[appDefinitionId];
-    }
-  }
-
   var ApplicationType = /* @__PURE__ */ ((ApplicationType2) => {
     ApplicationType2["EditorAddon"] = "EDITOR_ADDON";
     ApplicationType2["Platform"] = "PLATFORM";
@@ -436,7 +172,7 @@
   class WixEditorPlatformApplication extends EditorPlatformApplication {
     static async create() {
       return new WixEditorPlatformApplication(
-        await ApplicationContext.getInstance()
+        await editorPlatformContexts.ApplicationContext.getInstance()
       );
     }
     constructor(context) {
@@ -446,7 +182,7 @@
 
   class WixEditorPlatformAddon extends EditorPlatformApplication {
     static async create() {
-      const context = await ApplicationContext.getInstance();
+      const context = await editorPlatformContexts.ApplicationContext.getInstance();
       return new WixEditorPlatformAddon(context);
     }
     constructor(context) {
@@ -454,327 +190,8 @@
     }
   }
 
-  class WorkerEventsBridge {
-    constructor(platformAppEvents) {
-      this.platformAppEvents = platformAppEvents;
-    }
-    /**
-     * Notify by event from Worker Manager (platform infrastructure)
-     */
-    notify(event) {
-      switch (event.type) {
-        case publicEditorPlatformEvents.PlatformLifecycleEvent.EditorReady:
-          this.platformAppEvents.notify({
-            ...event,
-            // @ts-expect-error TODO: fix me
-            type: publicEditorPlatformEvents.PlatformAppEvent.EditorReady
-          });
-          break;
-        case publicEditorPlatformEvents.PlatformPrivateEvent.HostEvent:
-          this.platformAppEvents.notify({
-            ...event,
-            type: publicEditorPlatformEvents.PlatformAppEvent.HostEvent
-          });
-          break;
-      }
-    }
-    /**
-     * Subscribe to Worker (Application) event
-     */
-    subscribe(cb) {
-      this.platformAppEvents.subscribe((event) => {
-        cb(event);
-      });
-    }
-  }
-
-  var PlatformConsumerEnvironmentAPIType = /* @__PURE__ */ ((PlatformConsumerEnvironmentAPIType2) => {
-    PlatformConsumerEnvironmentAPIType2["Frame"] = "PLATFORM_FRAME_API";
-    PlatformConsumerEnvironmentAPIType2["Worker"] = "PLATFORM_WORKER_API";
-    return PlatformConsumerEnvironmentAPIType2;
-  })(PlatformConsumerEnvironmentAPIType || {});
-  class AbstractEnvironmentAPI {
-    constructor(env) {
-      this.env = env;
-      this.create();
-    }
-  }
-
-  const DESIGN_SYSTEM_STYLES_MAP = {
-    classic: "https://www.unpkg.com/@wix/design-system/dist/statics/tokens-default.global.css",
-    studio: "https://www.unpkg.com/@wix/design-system/dist/statics/tokens-studio.global.css"
-  };
-  class PlatformFrameAPI extends AbstractEnvironmentAPI {
-    type = PlatformConsumerEnvironmentAPIType.Frame;
-    #events = new publicEditorPlatformEvents.PlatformAppEventEmitter();
-    #eventsBridge = new WorkerEventsBridge(this.#events);
-    #privateAPI;
-    #applicationPrivateAPI;
-    constructor() {
-      super(PlatformConsumerEnvironmentAPIType.Frame);
-    }
-    create() {
-      if (typeof globalThis?.document?.head?.prepend === "function") {
-        const params = new URL(globalThis.location.href).searchParams;
-        const host = params.get("editorType") === "CLASSIC" ? "classic" : "studio";
-        const url = DESIGN_SYSTEM_STYLES_MAP[host];
-        const isAlreadyLoaded = url && !!document.querySelectorAll(`link[type="text/css"][href="${url}"]`)?.length;
-        if (url && !isAlreadyLoaded) {
-          const link = document.createElement("link");
-          link.setAttribute("rel", "stylesheet");
-          link.setAttribute("type", "text/css");
-          link.setAttribute("href", url);
-          globalThis.document.head.prepend(link);
-        }
-      }
-    }
-    async initEnvironment(props) {
-      const { applicationPrivateAPI, privateAPI, appDefinitionId } = props;
-      this.#applicationPrivateAPI = applicationPrivateAPI;
-      this.#privateAPI = privateAPI;
-      await EnvironmentContext.inject({
-        environment: PlatformEnvironment.Frame,
-        privateApi: privateAPI,
-        events: this.#events,
-        applicationAPIs: {
-          [appDefinitionId]: this.#applicationPrivateAPI
-        }
-      });
-      await ApplicationContext.inject({
-        appDefinitionId,
-        appDefinitionName: ""
-      });
-    }
-    notify(event) {
-      this.#eventsBridge.notify(event);
-    }
-    subscribe(cb) {
-      this.#eventsBridge.subscribe(cb);
-    }
-  }
-
-  const APPLICATION_REGISTRY_KEY = "__APPLICATION_REGISTRY_KEY";
-  async function executeApplication(events, spec, bundle) {
-    const executable = new Function(
-      APPLICATION_CONTEXT_KEY,
-      APPLICATION_REGISTRY_KEY,
-      bundle
-    );
-    let instance;
-    const applicationRegistryCallback = (_instance) => {
-      if (instance) {
-        throw createEditorPlatformApplicationError(
-          EditorPlatformApplicationErrorCode.ApplicationExecuteError,
-          "Application registry called more than once"
-        ).withAppDefinitionId(spec.appDefinitionId);
-      }
-      if (_instance.type !== spec.type) {
-        throw createEditorPlatformApplicationError(
-          EditorPlatformApplicationErrorCode.ApplicationExecuteError,
-          "Application has different type"
-        ).withMessage("expected type", spec.type).withMessage("received type", _instance.type);
-      }
-      instance = _instance;
-    };
-    try {
-      const context = { ...spec };
-      executable.call(
-        null,
-        new ApplicationContext(context, await EnvironmentContext.getInstance()),
-        applicationRegistryCallback
-      );
-    } catch (e) {
-      throw createEditorPlatformApplicationError(
-        EditorPlatformApplicationErrorCode.ApplicationExecuteError,
-        e.message
-      ).withAppDefinitionId(spec.appDefinitionId).withParentError(e);
-    }
-    return new Promise((resolve, reject) => {
-      const unsubscribe = events.subscribe((event) => {
-        const timeoutId = setTimeout(() => {
-          clearTimeout(timeoutId);
-          unsubscribe();
-          if (!instance) {
-            reject(
-              createEditorPlatformApplicationError(
-                EditorPlatformApplicationErrorCode.ApplicationExecuteError,
-                "Application registry was not called, threw by timeout"
-              ).withAppDefinitionId(spec.appDefinitionId)
-            );
-          }
-        }, 5e3);
-        if (event.type === publicEditorPlatformEvents.PlatformAppEvent.ApplicationInit && event.meta.appDefinitionId === spec.appDefinitionId) {
-          clearTimeout(timeoutId);
-          unsubscribe();
-          if (!instance) {
-            reject(
-              createEditorPlatformApplicationError(
-                EditorPlatformApplicationErrorCode.ApplicationExecuteError,
-                "Application registry was not called"
-              ).withAppDefinitionId(spec.appDefinitionId)
-            );
-          }
-          resolve({ instance });
-        }
-      });
-    });
-  }
-
-  class PlatformApplicationContainer {
-    #apps = {};
-    #privateAPI;
-    #events;
-    constructor(privateApi, events) {
-      this.#privateAPI = privateApi;
-      this.#events = events;
-      this.#events.subscribe((event) => {
-        switch (event.type) {
-          case publicEditorPlatformEvents.PlatformAppEvent.HostEvent: {
-            if (event.payload.type === publicEditorPlatformInterfaces.EventType.removeAppCompleted) {
-              void this.#events.withEvent(
-                this.#events.factories.createApplicationRemovedEvent(
-                  event.payload.appDefinitionId
-                ),
-                () => {
-                  return this.removeApplication(event.payload.appDefinitionId);
-                }
-              );
-            }
-            break;
-          }
-        }
-      });
-    }
-    async runApplication(appSpec) {
-      const bundle = await this.loadApplication(appSpec);
-      const instance = await this.executeApplication(appSpec, bundle);
-      this.setApplication(appSpec.appDefinitionId, instance);
-      return instance;
-    }
-    setApplication(appDefId, instance) {
-      this.#apps[appDefId] = instance;
-      void this.#events.withEvent(
-        this.#events.factories.createApplicationApiInitEvent(
-          appDefId,
-          // TODO: both types are set here...
-          // @ts-expect-error TODO: fix me
-          instance?.api?.private ? "private" : "public"
-        ),
-        () => {
-          this.#privateAPI.applicationManager.setApplication(instance);
-        }
-      );
-    }
-    getApplication(appDefId) {
-      return this.#apps[appDefId];
-    }
-    getAppDefinitionIds() {
-      return Object.keys(this.#apps);
-    }
-    removeApplication(appDefinitionId) {
-      delete this.#apps[appDefinitionId];
-    }
-    async loadApplication(appSpec) {
-      const url = appSpec.url;
-      return this.#events.withEvent(
-        this.#events.factories.createApplicationLoadEvent(appSpec, url),
-        async () => {
-          try {
-            return await this.loadApplicationBundle(url);
-          } catch (e) {
-            throw createEditorPlatformApplicationError(
-              EditorPlatformApplicationErrorCode.ApplicationLoadError
-            ).withUrl(url).withAppDefinitionId(appSpec.appDefinitionId).withParentError(e);
-          }
-        }
-      );
-    }
-    async loadApplicationBundle(url) {
-      const res = await fetch(url, {
-        method: "GET"
-      });
-      const isSuccessfulResponse = res.status >= 200 && res.status <= 299;
-      if (!isSuccessfulResponse) {
-        throw createEditorPlatformApplicationError(
-          EditorPlatformApplicationErrorCode.ApplicationFetchError
-        ).withUrl(url);
-      }
-      return res.text();
-    }
-    async executeApplication(appSpec, bundle) {
-      return this.#events.withEvent(
-        this.#events.factories.createApplicationExecuteEvent(
-          appSpec,
-          appSpec.url
-        ),
-        async () => {
-          const { instance } = await executeApplication(
-            this.#events,
-            appSpec,
-            bundle
-          );
-          return instance;
-        }
-      );
-    }
-  }
-
-  class PlatformWorkerAPI extends AbstractEnvironmentAPI {
-    type = PlatformConsumerEnvironmentAPIType.Worker;
-    #events = new publicEditorPlatformEvents.PlatformAppEventEmitter();
-    #eventsBridge = new WorkerEventsBridge(this.#events);
-    #container = null;
-    #privateAPI;
-    #pendingWaiters = [];
-    constructor() {
-      super(PlatformConsumerEnvironmentAPIType.Worker);
-    }
-    create() {
-    }
-    async initEnvironment(props) {
-      const { buildPrivateAPI } = props;
-      this.#privateAPI = await buildPrivateAPI({
-        // TODO: should be per application (within the container before app execution)
-        type: "EDITOR_ADDON"
-      });
-      await EnvironmentContext.inject({
-        environment: PlatformEnvironment.Worker,
-        events: this.#events,
-        privateApi: this.#privateAPI,
-        applicationAPIs: {}
-      });
-      this.#container = new PlatformApplicationContainer(
-        this.#privateAPI,
-        this.#events
-      );
-      this.#pendingWaiters.forEach((res) => res(this));
-    }
-    async notify(event) {
-      await this.waitReady();
-      this.#eventsBridge.notify(event);
-    }
-    subscribe(cb) {
-      this.#eventsBridge.subscribe(cb);
-    }
-    async runApplication(app) {
-      await this.waitReady();
-      await this.#container.runApplication(app);
-    }
-    waitReady() {
-      return new Promise((res) => {
-        if (this.#privateAPI) {
-          return res(this);
-        }
-        this.#pendingWaiters.push(res);
-      });
-    }
-  }
-
   exports.ApplicationType = ApplicationType;
   exports.EditorPlatformApplication = EditorPlatformApplication;
-  exports.PlatformConsumerEnvironmentAPIType = PlatformConsumerEnvironmentAPIType;
-  exports.PlatformFrameAPI = PlatformFrameAPI;
-  exports.PlatformWorkerAPI = PlatformWorkerAPI;
   exports.WixEditorPlatformAddon = WixEditorPlatformAddon;
   exports.WixEditorPlatformApplication = WixEditorPlatformApplication;