@wix/editor-application 1.392.0 → 1.394.0

package/dist/cjs/index.js

@@ -3,6 +3,24 @@
 var publicEditorPlatformEvents = require('@wix/public-editor-platform-events');
 var publicEditorPlatformInterfaces = require('@wix/public-editor-platform-interfaces');
 var publicEditorPlatformErrors = require('@wix/public-editor-platform-errors');
+var editorPlatformContexts = require('@wix/editor-platform-contexts');
+
+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 +40,7 @@ class ApplicationLifecycle {
     if (!this.callbacks[event]) {
       this.callbacks[event] = [];
     }
-    const id = `${performance.now()}`;
+    const id = `${hash()}`;
     this.callbacks[event].push({
       id,
       fn
@@ -45,21 +63,12 @@ class ApplicationLifecycle {
 
 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 +106,7 @@ class EditorPlatformApplication {
   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 +164,6 @@ class EditorPlatformApplication {
   }
 }
 
-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 +173,7 @@ var ApplicationType = /* @__PURE__ */ ((ApplicationType2) => {
 class WixEditorPlatformApplication extends EditorPlatformApplication {
   static async create() {
     return new WixEditorPlatformApplication(
-      await ApplicationContext.getInstance()
+      await editorPlatformContexts.ApplicationContext.getInstance()
     );
   }
   constructor(context) {
@@ -446,7 +183,7 @@ class WixEditorPlatformApplication extends EditorPlatformApplication {
 
 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 +191,8 @@ class WixEditorPlatformAddon extends EditorPlatformApplication {
   }
 }
 
-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;
 //# sourceMappingURL=index.js.map