@wix/editor-application 1.308.0

package/dist/statics/index.js

@@ -0,0 +1,775 @@
+(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';
+
+  class ApplicationLifecycle {
+    constructor(events) {
+      this.events = events;
+      this.subscribe();
+    }
+    callbacks = {};
+    subscribe() {
+      this.events.subscribe((event) => {
+        const { type, payload } = event;
+        if (this.callbacks[type]) {
+          this.callbacks[type].forEach(({ fn }) => fn(payload));
+        }
+      });
+    }
+    addCallback(event, fn) {
+      if (!this.callbacks[event]) {
+        this.callbacks[event] = [];
+      }
+      const id = `${performance.now()}`;
+      this.callbacks[event].push({
+        id,
+        fn
+      });
+      return () => {
+        this.callbacks[event] = this.callbacks[event].filter(
+          (cb) => cb.id !== id
+        );
+      };
+    }
+    /**
+     * NOTE: currently, we return function to unsubscribe from the event,
+     * probably it is better to return `this` to allow chaining
+     * and provide another way to unsubscribe from events.
+     */
+    onEditorReady(fn) {
+      return this.addCallback(publicEditorPlatformEvents.PlatformAppEvent.EditorReady, fn);
+    }
+  }
+
+  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";
+    return EditorPlatformApplicationErrorCode2;
+  })(EditorPlatformApplicationErrorCode || {});
+  class EditorPlatformApplicationError extends publicEditorPlatformErrors.BaseError {
+    state = {};
+    constructor(message, code) {
+      super(message, code, "Editor Platform Application Error");
+    }
+    withUrl(url) {
+      this.state = { ...this.state, url };
+      return this;
+    }
+    withAppDefinitionId(appDefinitionId) {
+      this.state = { ...this.state, appDefinitionId };
+      return this;
+    }
+    withApiMethod(apiMethod) {
+      this.state = { ...this.state, apiMethod };
+      return this;
+    }
+    withApiType(apiType) {
+      this.state = { ...this.state, apiType };
+      return this;
+    }
+  }
+  const createEditorPlatformApplicationError = publicEditorPlatformErrors.createErrorBuilder(EditorPlatformApplicationError);
+
+  class ChainAPIConfiguration {
+    constructor(api) {
+      this.api = api;
+    }
+    exposePublicAPI(api) {
+      this.api.public = api;
+      return this;
+    }
+    exposePrivateAPI(api) {
+      this.api.private = api;
+      return this;
+    }
+  }
+  class EditorPlatformApplication {
+    constructor(type, context) {
+      this.type = type;
+      this.#context = context;
+      const bindings = this.#context.getBindings();
+      this.appDefinitionId = bindings.appDefinitionId;
+      const events = this.#context.getEvents();
+      this.lifecycle = new ApplicationLifecycle(events);
+      events.addEventListener(publicEditorPlatformInterfaces.EventType.removeAppCompleted, (e) => {
+        if (e.appDefinitionId === this.appDefinitionId) {
+          this.state = "REMOVED";
+        }
+      });
+      const registerApplicationInContainer = __APPLICATION_REGISTRY_KEY;
+      registerApplicationInContainer(this);
+      events.notify({
+        type: publicEditorPlatformEvents.PlatformAppEvent.ApplicationInit,
+        payload: {}
+      });
+    }
+    appDefinitionId;
+    state = "READY";
+    lifecycle;
+    #applicationAPI = {};
+    #chainAPIConfiguration = new ChainAPIConfiguration(
+      this.#applicationAPI
+    );
+    #manifest;
+    #context;
+    get context() {
+      return this.#context;
+    }
+    get events() {
+      return this.#context.getEvents();
+    }
+    setManifest(manifest) {
+      this.#manifest = manifest;
+    }
+    getManifest() {
+      return this.#manifest;
+    }
+    exposePublicAPI(api) {
+      return this.#chainAPIConfiguration.exposePublicAPI(api);
+    }
+    exposePrivateAPI(api) {
+      return this.#chainAPIConfiguration.exposePrivateAPI(api);
+    }
+    getPublicAPI() {
+      return this.#applicationAPI.public;
+    }
+    getPrivateAPI() {
+      return this.#applicationAPI.private;
+    }
+    ready() {
+    }
+    buildApplicationError(message) {
+      return createEditorPlatformApplicationError(
+        EditorPlatformApplicationErrorCode.ApplicationRuntimeError,
+        message
+      ).withAppDefinitionId(this.appDefinitionId);
+    }
+  }
+
+  var EditorPlatformApplicationContextErrorCode = /* @__PURE__ */ ((EditorPlatformApplicationContextErrorCode2) => {
+    EditorPlatformApplicationContextErrorCode2["IncorrectEnvironment"] = "IncorrectEnvironment";
+    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";
+    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";
+    return ApplicationType2;
+  })(ApplicationType || {});
+
+  class WixEditorPlatformApplication extends EditorPlatformApplication {
+    static async create() {
+      return new WixEditorPlatformApplication(
+        await ApplicationContext.getInstance()
+      );
+    }
+    constructor(context) {
+      super(ApplicationType.Platform, context);
+    }
+  }
+
+  class WixEditorPlatformAddon extends EditorPlatformApplication {
+    static async create() {
+      const context = await ApplicationContext.getInstance();
+      const instance = new WixEditorPlatformAddon(
+        context
+      );
+      try {
+        await instance.init();
+        return instance;
+      } catch (e) {
+        const error = createEditorPlatformApplicationError(
+          EditorPlatformApplicationErrorCode.ApplicationRuntimeError
+        ).withParentError(e).withMessage("Failed to initialize addon");
+        console.error(error);
+        return instance;
+      }
+    }
+    constructor(context) {
+      super(ApplicationType.EditorAddon, context);
+    }
+    async init() {
+      try {
+        await this.registerToolsPanel();
+      } catch (e) {
+        throw createEditorPlatformApplicationError(
+          EditorPlatformApplicationErrorCode.ApplicationRuntimeError
+        ).withMessage("Failed to register addon tools panel").withParentError(e);
+      }
+    }
+    async registerToolsPanel() {
+      const bindings = this.context.getBindings();
+      const { url, width, height, initialPosition } = bindings.data?.toolPanelConfig;
+      if (url) {
+        await this.context.getPrivateAPI().addons.registerToolsPanel(
+          { appDefinitionId: bindings.appDefinitionId, applicationId: "111" },
+          {
+            title: bindings.appDefinitionName
+          },
+          {
+            url,
+            // TODO: this can become "200px", "50%" etc in future. For now we simply assume numeric values like "250".
+            width: Number(width),
+            height: Number(height),
+            initialPosition: {
+              x: Number(initialPosition.x),
+              y: Number(initialPosition.y)
+            }
+          }
+        );
+      }
+    }
+  }
+
+  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);
+      });
+    }
+  }
+
+  const PLATFORM_FRAME_API_TYPE = "PLATFORM_FRAME_API";
+  class PlatformFrameAPI {
+    type = PLATFORM_FRAME_API_TYPE;
+    #events = new publicEditorPlatformEvents.PlatformAppEventEmitter();
+    #eventsBridge = new WorkerEventsBridge(this.#events);
+    #privateAPI;
+    #applicationPrivateAPI;
+    async initFrameEnvironment(appDefinitionId, privateAPI, applicationPrivateAPI) {
+      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(
+        void 0,
+        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 {
+    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) {
+              this.events.withEvent(
+                this.events.factories.createApplicationRemovedEvent(
+                  event.payload.appDefinitionId
+                ),
+                () => {
+                  return this.removeApplication(event.payload.appDefinitionId);
+                }
+              );
+            }
+            break;
+          }
+        }
+      });
+    }
+    apps = {};
+    async runApplication(app) {
+      const bundle = await this.loadApplication(app);
+      const instance = await this.executeApplication(app, bundle);
+      this.setApplication(app.appDefinitionId, instance);
+      return instance;
+    }
+    setApplication(appDefId, instance) {
+      this.apps[appDefId] = instance;
+      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(app) {
+      const url = app.url;
+      return this.events.withEvent(
+        this.events.factories.createApplicationLoadEvent(app, url),
+        async () => {
+          try {
+            return await this.loadApplicationBundle(url);
+          } catch (e) {
+            throw createEditorPlatformApplicationError(
+              EditorPlatformApplicationErrorCode.ApplicationLoadError
+            ).withUrl(url).withAppDefinitionId(app.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(app, bundle) {
+      return this.events.withEvent(
+        this.events.factories.createApplicationExecuteEvent(app, app.url),
+        async () => {
+          const { instance } = await executeApplication(this.events, app, bundle);
+          return instance;
+        }
+      );
+    }
+  }
+
+  const PLATFORM_WORKER_API_TYPE = "PLATFORM_WORKER_API";
+  class PlatformWorkerAPI {
+    type = PLATFORM_WORKER_API_TYPE;
+    #events = new publicEditorPlatformEvents.PlatformAppEventEmitter();
+    #eventsBridge = new WorkerEventsBridge(this.#events);
+    #container = null;
+    #privateAPI;
+    #pendingWaiters = [];
+    async initWorkerEnvironment(buildPrivateAPI) {
+      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.PLATFORM_FRAME_API_TYPE = PLATFORM_FRAME_API_TYPE;
+  exports.PLATFORM_WORKER_API_TYPE = PLATFORM_WORKER_API_TYPE;
+  exports.PlatformFrameAPI = PlatformFrameAPI;
+  exports.PlatformWorkerAPI = PlatformWorkerAPI;
+  exports.WixEditorPlatformAddon = WixEditorPlatformAddon;
+  exports.WixEditorPlatformApplication = WixEditorPlatformApplication;
+
+}));
+//# sourceMappingURL=index.js.map