@wix/editor 1.335.0 → 1.336.0

package/dist/cjs/index.js

@@ -1,283 +1,10 @@
 'use strict';
 
+var editorPlatformContexts = require('@wix/editor-platform-contexts');
 var publicEditorPlatformErrors = require('@wix/public-editor-platform-errors');
-var publicEditorPlatformEvents = require('@wix/public-editor-platform-events');
-var editorPlatformTransport = require('@wix/editor-platform-transport');
-var platformFrameApi = require('@wix/editor-application/platform-frame-api');
-var platformWorkerApi = require('@wix/editor-application/platform-worker-api');
+var editorPlatformEnvironmentApi = require('@wix/editor-platform-environment-api');
 var hostModules = require('@wix/sdk-runtime/host-modules');
 
-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];
-  }
-}
-
 class EditorPlatformSDKAuthError extends publicEditorPlatformErrors.BaseError {
   state = {};
   constructor(message, code) {
@@ -299,7 +26,7 @@ const auth = () => {
   let instance;
   return {
     getAuthHeaders: async () => {
-      const context = await ApplicationContext.getInstance();
+      const context = await editorPlatformContexts.ApplicationContext.getInstance();
       const bindings = context.getBindings();
       const privateAPI = context.getPrivateAPI();
       if (!bindings.appDefinitionId) {
@@ -337,118 +64,91 @@ const auth = () => {
   };
 };
 
-const INIT_KEY = "_EP_TRANSPORT_INIT_KEY";
-if (!globalThis[INIT_KEY]) {
-  const isWorker = typeof importScripts === "function";
-  if (isWorker) {
-    editorPlatformTransport.WorkerConsumerEndpoint.exposeAPI(new platformWorkerApi.PlatformWorkerAPI());
-  } else {
-    editorPlatformTransport.IFrameConsumerEndpoint.exposeAPI(new platformFrameApi.PlatformFrameAPI());
-  }
-  globalThis[INIT_KEY] = true;
-}
+new editorPlatformEnvironmentApi.EditorPlatformContextEnvironment().expose();
 
 class PlatformSDKShape {
-  constructor(namespace, shape) {
+  constructor(namespace, shapeConstructor) {
     this.namespace = namespace;
-    this.shape = shape;
+    this.shapeConstructor = shapeConstructor;
   }
   build() {
-    return hostModules.createHostModule(
-      Object.fromEntries(
-        Object.entries(this.shape).map(([key, value]) => [
-          key,
-          (host) => {
-            if (host?.environmentContext && host?.applicationContext) {
-              return async (...args) => {
-                const [environmentContext, applicationContext] = await Promise.all([
-                  host.environmentContext,
-                  host.applicationContext
-                ]);
-                return value({
-                  environmentContext,
-                  applicationContext
-                })(...args);
-              };
-            }
-            return async (...args) => {
-              const [environmentContext, applicationContext] = await Promise.all([
-                EnvironmentContext.getInstance(),
-                ApplicationContext.getInstance()
-              ]);
-              return value({
-                environmentContext,
-                applicationContext
-              })(...args);
-            };
-          }
-        ])
-      )
+    const instance = new this.shapeConstructor();
+    const methods = Object.getOwnPropertyNames(
+      Object.getPrototypeOf(instance)
+    ).filter(
+      (prop) => prop !== "constructor" && typeof // @ts-expect-error
+      instance[prop] === "function"
     );
+    const api = methods.reduce((acc, method) => {
+      return {
+        ...acc,
+        // @ts-expect-error
+        [method]: () => instance[method].bind(instance)
+      };
+    }, {});
+    return hostModules.createHostModule(api);
   }
 }
 
-const applicationShape = new PlatformSDKShape("application", {
-  getPrivateAPI({ applicationContext }) {
-    return async () => {
-      return applicationContext.getPrivateApplicationAPI();
-    };
-  },
-  getPublicAPI({ applicationContext }) {
-    return async (appDefinitionId) => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      return privateAPI.applicationManager.getPublicApplicationAPI(
-        appDefinitionId
-      );
-    };
-  },
-  getAppInstance({ applicationContext }) {
-    return async () => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      const bindings = applicationContext.getBindings();
-      return privateAPI.info.getAppInstance(bindings.appDefinitionId);
-    };
+class BaseSDKShape {
+  getApplicationContext() {
+    return editorPlatformContexts.ApplicationContext.getInstance();
+  }
+  async getPlatformPrivateAPI() {
+    return (await this.getApplicationContext()).getPrivateAPI();
   }
-});
-var index$4 = applicationShape.build();
+  async getContextBindings() {
+    return (await this.getApplicationContext()).getBindings();
+  }
+}
 
-const componentsShape = new PlatformSDKShape("components", {
-  getSelectedComponents({ applicationContext }) {
-    return async () => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      const refs = await privateAPI.components.getSelectedComponents();
-      return Promise.all(
-        refs.map((ref) => privateAPI.components.getComponent(ref))
-      );
-    };
+class ApplicationSDKShape extends BaseSDKShape {
+  async getPrivateAPI() {
+    return (await this.getApplicationContext()).getPrivateApplicationAPI();
+  }
+  async getPublicAPI(appDefinitionId) {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    return privateAPI.applicationManager.getPublicApplicationAPI(
+      appDefinitionId
+    );
   }
-});
-var components = componentsShape.build();
+  async getAppInstance() {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    const bindings = await this.getContextBindings();
+    return privateAPI.info.getAppInstance(bindings.appDefinitionId);
+  }
+}
+var index$5 = new PlatformSDKShape("application", ApplicationSDKShape).build();
 
-const eventsShape = new PlatformSDKShape("events", {
-  addEventListener({ applicationContext }) {
-    return async (name, cb) => {
-      return applicationContext.getEvents().addEventListener(name, cb);
-    };
+class ComponentsSDKShape extends BaseSDKShape {
+  async getSelectedComponents() {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    const refs = await privateAPI.components.getSelectedComponents();
+    return Promise.all(
+      refs.map((ref) => privateAPI.components.getComponent(ref))
+    );
   }
-});
-var index$3 = eventsShape.build();
+}
+var components = new PlatformSDKShape("components", ComponentsSDKShape).build();
 
-const infoShape = new PlatformSDKShape("info", {
-  getViewMode({ applicationContext }) {
-    return async () => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      return privateAPI.info.getViewMode();
-    };
-  },
-  getLanguageCode({ applicationContext }) {
-    return async () => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      return privateAPI.info.getLanguageCode();
-    };
+class EventsSDKShape extends BaseSDKShape {
+  async addEventListener(name, cb) {
+    return (await this.getApplicationContext()).getEvents().addEventListener(name, cb);
+  }
+}
+var index$4 = new PlatformSDKShape("events", EventsSDKShape).build();
+
+class InfoSDKShape extends BaseSDKShape {
+  async getViewMode() {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    return privateAPI.info.getViewMode();
   }
-});
-var index$2 = infoShape.build();
+  async getLanguageCode() {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    return privateAPI.info.getLanguageCode();
+  }
+}
+var index$3 = new PlatformSDKShape("info", InfoSDKShape).build();
 
 var WidgetShapeErrorCode = /* @__PURE__ */ ((WidgetShapeErrorCode2) => {
   WidgetShapeErrorCode2["UndefinedCompRef"] = "UndefinedCompRef";
@@ -461,31 +161,28 @@ class WidgetShapeError extends publicEditorPlatformErrors.BaseError {
 }
 const createWidgetShapeError = publicEditorPlatformErrors.createErrorBuilder(WidgetShapeError);
 
-const getSelectedComponentRef = async () => {
-  const selected = await components.getSelectedComponents();
-  const compRef = selected[0]?.compRef;
-  if (!compRef) {
-    throw createWidgetShapeError(WidgetShapeErrorCode.UndefinedCompRef);
-  }
-  return compRef;
-};
-const widgetShape = new PlatformSDKShape("widget", {
-  getProp({ applicationContext }) {
-    return async (propName) => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      const compRef = await getSelectedComponentRef();
-      return privateAPI.customElement.getAttribute(compRef, propName);
-    };
-  },
-  setProp({ applicationContext }) {
-    return async (propName, value) => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      const compRef = await getSelectedComponentRef();
-      await privateAPI.customElement.setAttribute(compRef, propName, value);
-    };
+class WidgetSDKShape extends BaseSDKShape {
+  async getProp(propName) {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    const compRef = await this.#getSelectedComponentRef();
+    return privateAPI.customElement.getAttribute(compRef, propName);
+  }
+  async setProp(propName, value) {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    const compRef = await this.#getSelectedComponentRef();
+    await privateAPI.customElement.setAttribute(compRef, propName, value);
+  }
+  async #getSelectedComponentRef() {
+    const selected = await components.getSelectedComponents();
+    const compRef = selected[0]?.compRef;
+    if (!compRef) {
+      throw createWidgetShapeError(WidgetShapeErrorCode.UndefinedCompRef);
+    }
+    return compRef;
   }
-});
-var index$1 = widgetShape.build();
+}
+const widgetShape = new PlatformSDKShape("widget", WidgetSDKShape);
+var index$2 = widgetShape.build();
 
 const UNDERLINE_DEFINITION = "underline";
 function extractFontVar(fontString) {
@@ -590,119 +287,102 @@ const fonts = {
     }
   }
 };
-const inputsShape = new PlatformSDKShape("inputs", {
-  selectColor({ applicationContext }) {
-    return async (value, options) => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      let colorValue = parseColorString(value);
-      let colorResult = colorValueToCSS(colorValue);
-      await privateAPI.inputs.openColorPicker(
-        {
-          color: colorValue?.cssVariableName || colorValue?.theme || colorValue?.color
-        },
-        ({
+class InputsSDKShape extends BaseSDKShape {
+  async selectColor(value, options) {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    let colorValue = parseColorString(value);
+    let colorResult = colorValueToCSS(colorValue);
+    await privateAPI.inputs.openColorPicker(
+      {
+        color: colorValue?.cssVariableName || colorValue?.theme || colorValue?.color
+      },
+      ({
+        color,
+        theme,
+        cssVariableTheme
+      }) => {
+        colorValue = {
           color,
           theme,
-          cssVariableTheme
-        }) => {
-          colorValue = {
-            color,
-            theme,
-            cssVariableName: cssVariableTheme
-          };
-          colorResult = colorValueToCSS(colorValue);
-          options?.onChange?.(colorResult);
-        }
-      );
-      return colorResult;
-    };
-  },
-  selectFont({ applicationContext }) {
-    return async (value, options) => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      const fontValue = parseFontString(value);
-      let _value = value;
-      await privateAPI.inputs.openFontPickerV2(
-        {
-          ...options,
-          panelSectionsDefinition: {
-            htmlTag: "hidden"
-          },
-          componentStyle: fonts.transformFontInternalValue(fontValue)
+          cssVariableName: cssVariableTheme
+        };
+        colorResult = colorValueToCSS(colorValue);
+        options?.onChange?.(colorResult);
+      }
+    );
+    return colorResult;
+  }
+  async selectFont(value, options) {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    const fontValue = parseFontString(value);
+    let _value = value;
+    await privateAPI.inputs.openFontPickerV2(
+      {
+        ...options,
+        panelSectionsDefinition: {
+          htmlTag: "hidden"
         },
-        (font, accessibility) => {
-          _value = {
-            font: fontValueToCSS(font),
-            textDecoration: font.underline ? UNDERLINE_DEFINITION : void 0
-          };
-          options?.onChange?.(_value);
-        }
-      );
-      return _value;
-    };
+        componentStyle: fonts.transformFontInternalValue(fontValue)
+      },
+      (font, accessibility) => {
+        _value = {
+          font: fontValueToCSS(font),
+          textDecoration: font.underline ? UNDERLINE_DEFINITION : void 0
+        };
+        options?.onChange?.(_value);
+      }
+    );
+    return _value;
   }
-});
-var index = inputsShape.build();
+}
+var index$1 = new PlatformSDKShape("inputs", InputsSDKShape).build();
 
-const externalPanels = new PlatformSDKShape("externalPanels", {
-  getData({ applicationContext }) {
-    return async () => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      return privateAPI.externalPanels.getData();
-    };
-  },
-  setData({ applicationContext }) {
-    return async (newData) => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      return privateAPI.externalPanels.setData(newData);
-    };
-  },
-  getStyle({ applicationContext }) {
-    return async () => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      return privateAPI.externalPanels.getStyle();
-    };
-  },
-  setStyle({ applicationContext }) {
-    return async (newStyle) => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      return privateAPI.externalPanels.setStyle(newStyle);
-    };
-  },
-  getTheme({ applicationContext }) {
-    return async () => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      return privateAPI.externalPanels.getTheme();
-    };
-  },
-  selectMedia({ applicationContext }) {
+class ExternalPanelsSDKShape extends BaseSDKShape {
+  async getData() {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    return privateAPI.externalPanels.getData();
+  }
+  async setData(newData) {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    return privateAPI.externalPanels.setData(newData);
+  }
+  async getStyle() {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    return privateAPI.externalPanels.getStyle();
+  }
+  async setStyle(newStyle) {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    return privateAPI.externalPanels.setStyle(newStyle);
+  }
+  async getTheme() {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    return privateAPI.externalPanels.getTheme();
+  }
+  async selectMedia() {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    return privateAPI.externalPanels.selectMedia();
+  }
+  async selectLink(...options) {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    return privateAPI.externalPanels.selectLink(...options);
+  }
+  async selectColor(...options) {
     return async () => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      return privateAPI.externalPanels.selectMedia();
-    };
-  },
-  selectLink({ applicationContext }) {
-    return async (...options) => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      return privateAPI.externalPanels.selectLink(...options);
-    };
-  },
-  selectColor({ applicationContext }) {
-    return async (...options) => {
-      const privateAPI = applicationContext.getPrivateAPI();
+      const privateAPI = await this.getPlatformPrivateAPI();
       return privateAPI.externalPanels.selectColor(...options);
     };
-  },
-  translate({ applicationContext }) {
-    return async (key, values) => {
-      const privateAPI = applicationContext.getPrivateAPI();
-      return privateAPI.externalPanels.translate(key, values);
-    };
   }
-});
-var externalPanels$1 = externalPanels.build();
+  async translate(key, values) {
+    const privateAPI = await this.getPlatformPrivateAPI();
+    return privateAPI.externalPanels.translate(key, values);
+  }
+}
+var index = new PlatformSDKShape(
+  "externalPanels",
+  ExternalPanelsSDKShape
+).build();
 
-const editorPlatformFrameHost = () => {
+const frame = () => {
   const queryParams = new URLSearchParams(window.location.search);
   return {
     environment: {},
@@ -712,13 +392,10 @@ const editorPlatformFrameHost = () => {
         } };
       }
     },
-    environmentContext: EnvironmentContext.getInstance(),
-    applicationContext: ApplicationContext.getInstance(),
     essentials: queryParams.has("essentials") ? JSON.parse(queryParams.get("essentials")) : {}
   };
 };
-
-const editorPlatformWorkerHost = () => {
+const worker = () => {
   return {
     environment: {},
     channel: {
@@ -726,9 +403,7 @@ const editorPlatformWorkerHost = () => {
         return { disconnect() {
         } };
       }
-    },
-    environmentContext: EnvironmentContext.getInstance(),
-    applicationContext: ApplicationContext.getInstance()
+    }
   };
 };
 
@@ -736,19 +411,19 @@ const editor = {
   host: () => {
     const isWorker = typeof importScripts === "function";
     if (isWorker) {
-      return editorPlatformWorkerHost();
+      return worker();
     }
-    return editorPlatformFrameHost();
+    return frame();
   },
   auth
 };
 
-exports.application = index$4;
+exports.application = index$5;
 exports.components = components;
 exports.editor = editor;
-exports.events = index$3;
-exports.externalPanels = externalPanels$1;
-exports.info = index$2;
-exports.inputs = index;
-exports.widget = index$1;
+exports.events = index$4;
+exports.externalPanels = index;
+exports.info = index$3;
+exports.inputs = index$1;
+exports.widget = index$2;
 //# sourceMappingURL=index.js.map