@wix/editor 1.335.0 → 1.337.0

package/dist/statics/index.js

@@ -1,279 +1,10 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@wix/public-editor-platform-errors'), require('@wix/public-editor-platform-events'), require('@wix/editor-platform-transport'), require('@wix/editor-application/platform-frame-api'), require('@wix/editor-application/platform-worker-api'), require('@wix/sdk-runtime/host-modules')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@wix/public-editor-platform-errors', '@wix/public-editor-platform-events', '@wix/editor-platform-transport', '@wix/editor-application/platform-frame-api', '@wix/editor-application/platform-worker-api', '@wix/sdk-runtime/host-modules'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.editorPlatformSdk = {}, global.publicEditorPlatformErrors, global.publicEditorPlatformEvents, global.editorPlatformTransport, global.platformFrameApi, global.platformWorkerApi, global.hostModules));
-})(this, (function (exports, publicEditorPlatformErrors, publicEditorPlatformEvents, editorPlatformTransport, platformFrameApi, platformWorkerApi, hostModules) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@wix/editor-platform-environment-api'), require('@wix/editor-platform-contexts'), require('@wix/public-editor-platform-errors'), require('@wix/sdk-runtime/host-modules')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@wix/editor-platform-environment-api', '@wix/editor-platform-contexts', '@wix/public-editor-platform-errors', '@wix/sdk-runtime/host-modules'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.editorPlatformSdk = {}, global.editorPlatformEnvironmentApi, global.editorPlatformContexts, global.publicEditorPlatformErrors, global.hostModules));
+})(this, (function (exports, editorPlatformEnvironmentApi, editorPlatformContexts, publicEditorPlatformErrors, hostModules) { 'use strict';
 
-  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];
-    }
-  }
+  new editorPlatformEnvironmentApi.EditorPlatformContextEnvironment().expose();
 
   class EditorPlatformSDKAuthError extends publicEditorPlatformErrors.BaseError {
     state = {};
@@ -296,7 +27,7 @@
     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) {
@@ -334,118 +65,110 @@
     };
   };
 
-  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;
-  }
-
   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,
+          [method]: (host) => {
+            if (host?.applicationContext) {
+              const _instance = instance.withApplicationContext(
+                host.applicationContext
+              );
+              return _instance[method].bind(_instance);
+            } else {
+              return 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 {
+    /**
+     * note, constructor might be called multiple times
+     * because of the context override
+     */
+    constructor(overrideApplicationContext = null) {
+      this.overrideApplicationContext = overrideApplicationContext;
+    }
+    getApplicationContext() {
+      return this.overrideApplicationContext ? this.overrideApplicationContext : editorPlatformContexts.ApplicationContext.getInstance();
     }
-  });
-  var index$4 = applicationShape.build();
+    async getEnvironmentContext() {
+      return (await this.getApplicationContext()).getEnvironmentContext();
+    }
+    async getPlatformPrivateAPI() {
+      return (await this.getApplicationContext()).getPrivateAPI();
+    }
+    async getContextBindings() {
+      return (await this.getApplicationContext()).getBindings();
+    }
+    withApplicationContext(applicationContext) {
+      return new this.constructor(applicationContext);
+    }
+  }
 
-  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();
+    }
+    async getLanguageCode() {
+      const privateAPI = await this.getPlatformPrivateAPI();
+      return privateAPI.info.getLanguageCode();
     }
-  });
-  var index$2 = infoShape.build();
+  }
+  var index$3 = new PlatformSDKShape("info", InfoSDKShape).build();
 
   var WidgetShapeErrorCode = /* @__PURE__ */ ((WidgetShapeErrorCode2) => {
     WidgetShapeErrorCode2["UndefinedCompRef"] = "UndefinedCompRef";
@@ -458,31 +181,28 @@
   }
   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) {
@@ -587,145 +307,125 @@
       }
     }
   };
-  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: {},
+      applicationContext: editorPlatformContexts.ApplicationContext.getInstance(),
       channel: {
         observeState: async () => {
           return { disconnect() {
           } };
         }
       },
-      environmentContext: EnvironmentContext.getInstance(),
-      applicationContext: ApplicationContext.getInstance(),
       essentials: queryParams.has("essentials") ? JSON.parse(queryParams.get("essentials")) : {}
     };
   };
-
-  const editorPlatformWorkerHost = () => {
+  const worker = () => {
     return {
       environment: {},
+      applicationContext: editorPlatformContexts.ApplicationContext.getInstance(),
       channel: {
         observeState: async () => {
           return { disconnect() {
           } };
         }
-      },
-      environmentContext: EnvironmentContext.getInstance(),
-      applicationContext: ApplicationContext.getInstance()
+      }
     };
   };
 
@@ -733,21 +433,21 @@
     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