@wix/editor-application 1.308.0

package/dist/esm/index.js

@@ -0,0 +1,764 @@
+import { PlatformAppEvent, PlatformPrivateEvent, PlatformLifecycleEvent, PlatformAppEventEmitter } from '@wix/public-editor-platform-events';
+import { EventType } from '@wix/public-editor-platform-interfaces';
+import { createErrorBuilder, BaseError } from '@wix/public-editor-platform-errors';
+
+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(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 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 = 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(EventType.removeAppCompleted, (e) => {
+      if (e.appDefinitionId === this.appDefinitionId) {
+        this.state = "REMOVED";
+      }
+    });
+    const registerApplicationInContainer = __APPLICATION_REGISTRY_KEY;
+    registerApplicationInContainer(this);
+    events.notify({
+      type: 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 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 = 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: 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 === PlatformAppEvent.CustomEvent) {
+        if (eventType === event.payload?.type && !isAppMatch) {
+          fn(await transformPayload());
+        }
+      } else if (event.type === 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 PlatformLifecycleEvent.EditorReady:
+        this.platformAppEvents.notify({
+          ...event,
+          // @ts-expect-error TODO: fix me
+          type: PlatformAppEvent.EditorReady
+        });
+        break;
+      case PlatformPrivateEvent.HostEvent:
+        this.platformAppEvents.notify({
+          ...event,
+          type: 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 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 === 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 PlatformAppEvent.HostEvent: {
+          if (event.payload.type === 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 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);
+    });
+  }
+}
+
+export { ApplicationType, EditorPlatformApplication, PLATFORM_FRAME_API_TYPE, PLATFORM_WORKER_API_TYPE, PlatformFrameAPI, PlatformWorkerAPI, WixEditorPlatformAddon, WixEditorPlatformApplication };
+//# sourceMappingURL=index.js.map