@actualwave/react-native-codeditor 1.0.0

package/app.plugin.js

@@ -0,0 +1,133 @@
+const { withDangerousMod, withXcodeProject } = require("@expo/config-plugins");
+const fs = require("fs");
+const path = require("path");
+
+// Resolved once at require-time — works both when published (node_modules/react-native-codeditor/)
+// and when linked from a monorepo workspace (package root).
+const ASSETS_SRC = path.resolve(__dirname, "src/assets");
+
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function withCodeditorAssets(config) {
+  // ── Android ──────────────────────────────────────────────────────────────
+  config = withDangerousMod(config, [
+    "android",
+    (modConfig) => {
+      const destDir = path.resolve(
+        modConfig.modRequest.projectRoot,
+        "android/app/src/main/assets/codeditor"
+      );
+      if (!fs.existsSync(ASSETS_SRC)) {
+        console.warn("[@actualwave/react-native-codeditor] ⚠️  src/assets not found — run `npm run prepare` in the library first");
+        return modConfig;
+      }
+      copyDirSync(ASSETS_SRC, destDir);
+      console.log("[@actualwave/react-native-codeditor] ✅ Android assets copied to android/app/src/main/assets/codeditor");
+      return modConfig;
+    },
+  ]);
+
+  // ── iOS: copy files ───────────────────────────────────────────────────────
+  config = withDangerousMod(config, [
+    "ios",
+    (modConfig) => {
+      const { projectRoot, projectName } = modConfig.modRequest;
+      const destDir = path.resolve(projectRoot, `ios/${projectName}/assets/codeditor`);
+      if (!fs.existsSync(ASSETS_SRC)) {
+        console.warn("[@actualwave/react-native-codeditor] ⚠️  src/assets not found — run `npm run prepare` in the library first");
+        return modConfig;
+      }
+      copyDirSync(ASSETS_SRC, destDir);
+      console.log(`[@actualwave/react-native-codeditor] ✅ iOS assets copied to ios/${projectName}/assets/codeditor`);
+      return modConfig;
+    },
+  ]);
+
+  // ── iOS: add folder reference to Xcode project ───────────────────────────
+  config = withXcodeProject(config, (modConfig) => {
+    const xcodeProject = modConfig.modResults;
+    const { projectName } = modConfig.modRequest;
+
+    // Idempotent — skip if already present
+    const existing = Object.values(
+      xcodeProject.hash.project.objects.PBXFileReference || {}
+    ).find(
+      (ref) =>
+        ref &&
+        typeof ref === "object" &&
+        ref.name === "assets" &&
+        ref.lastKnownFileType === "folder"
+    );
+    if (existing) {
+      return modConfig;
+    }
+
+    // Find the main app group (named after the project)
+    const groups = xcodeProject.hash.project.objects.PBXGroup || {};
+    const mainGroupEntry = Object.entries(groups).find(
+      ([, g]) => g && typeof g === "object" && g.name === projectName
+    );
+    if (!mainGroupEntry) {
+      console.warn(
+        `[@actualwave/react-native-codeditor] ⚠️  Xcode group "${projectName}" not found — add the assets folder reference manually`
+      );
+      return modConfig;
+    }
+    const [, mainGroupObj] = mainGroupEntry;
+
+    // PBXFileReference
+    // path must be relative to the Xcode project root (ios/), so it includes the project name.
+    const fileRefUuid = xcodeProject.generateUuid();
+    xcodeProject.hash.project.objects.PBXFileReference[fileRefUuid] = {
+      isa: "PBXFileReference",
+      lastKnownFileType: "folder",
+      name: "assets",
+      path: `${projectName}/assets`,
+      sourceTree: '"<group>"',
+    };
+    xcodeProject.hash.project.objects.PBXFileReference[`${fileRefUuid}_comment`] = "assets";
+
+    // Add to group children
+    if (!mainGroupObj.children) mainGroupObj.children = [];
+    mainGroupObj.children.push({ value: fileRefUuid, comment: "assets" });
+
+    // PBXBuildFile
+    const buildFileUuid = xcodeProject.generateUuid();
+    const pbxBuildFile = xcodeProject.hash.project.objects.PBXBuildFile || {};
+    pbxBuildFile[buildFileUuid] = {
+      isa: "PBXBuildFile",
+      fileRef: fileRefUuid,
+      settings: "{}",
+    };
+    pbxBuildFile[`${buildFileUuid}_comment`] = "assets in Resources";
+    xcodeProject.hash.project.objects.PBXBuildFile = pbxBuildFile;
+
+    // Add to PBXResourcesBuildPhase
+    const resourcesPhases =
+      xcodeProject.hash.project.objects.PBXResourcesBuildPhase || {};
+    for (const [, phase] of Object.entries(resourcesPhases)) {
+      if (phase && typeof phase === "object" && Array.isArray(phase.files)) {
+        phase.files.push({ value: buildFileUuid, comment: "assets in Resources" });
+        break;
+      }
+    }
+
+    console.log("[@actualwave/react-native-codeditor] ✅ Xcode folder reference added to project.pbxproj");
+    return modConfig;
+  });
+
+  return config;
+}
+
+module.exports = withCodeditorAssets;

package/lib/module/BlockingView.js

@@ -0,0 +1,25 @@
+"use strict";
+
+import { View, Text } from 'react-native';
+import { jsx as _jsx } from "react/jsx-runtime";
+const BlockingView = () => /*#__PURE__*/_jsx(View, {
+  style: {
+    position: 'absolute',
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    backgroundColor: '#00000066',
+    justifyContent: 'center',
+    alignItems: 'center'
+  },
+  children: /*#__PURE__*/_jsx(Text, {
+    style: {
+      color: '#fff',
+      fontSize: 12
+    },
+    children: "Initializing, please wait..."
+  })
+});
+export default BlockingView;
+//# sourceMappingURL=BlockingView.js.map

package/lib/module/CodeEditor.js

@@ -0,0 +1,239 @@
+"use strict";
+
+import React, { useState, useEffect, useRef, useCallback } from "react";
+import { Platform, View, StyleSheet } from "react-native";
+import WebView from "react-native-webview";
+import WebViewAPI from "./WebViewAPI.js";
+import BlockingView from "./BlockingView.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const styles = StyleSheet.create({
+  container: {
+    position: "relative",
+    flex: 1
+  },
+  webView: {
+    flex: 1
+  }
+});
+
+// Stable empty array used as the default for the extensions prop.
+// A new [] on every render would cause the extensions effect to fire every re-render,
+// calling setExtensions([]) and wiping the theme from the extensionCompartment.
+const DEFAULT_EXTENSIONS = [];
+
+/**
+ * Default WebView source URI for the bundled editor page.
+ * Android: assets are copied to android/app/src/main/assets/ by react-native link.
+ * iOS: override via editorUri prop until a MainBundlePath helper is added.
+ */
+const DEFAULT_EDITOR_URI = Platform.select({
+  android: "file:///android_asset/codeditor/editor.html",
+  default: "file:///android_asset/codeditor/editor.html",
+  ios: "assets/codeditor/editor.html"
+});
+const CodeEditor = ({
+  onInitialized,
+  onHistorySizeUpdate,
+  onLog,
+  onError,
+  onContentUpdate,
+  onSelectionChange,
+  onWebViewRefUpdated,
+  onLoad,
+  onLoadStart,
+  onLoadProgress,
+  onLoadEnd,
+  onNavigationStateChange,
+  renderBlockingView = () => /*#__PURE__*/_jsx(BlockingView, {}),
+  language,
+  extensions = DEFAULT_EXTENSIONS,
+  theme,
+  content = "",
+  viewport,
+  allowFileAccess = true,
+  editorUri = DEFAULT_EDITOR_URI
+}) => {
+  const [initialized, setInitialized] = useState(false);
+  const apiRef = useRef(null);
+  const currentContentRef = useRef(content);
+  const initializedRef = useRef(false);
+
+  // Always-current prop snapshot for stable callbacks
+  const callbacksRef = useRef({
+    onInitialized,
+    onContentUpdate,
+    onSelectionChange,
+    onHistorySizeUpdate,
+    onLog,
+    onError,
+    onWebViewRefUpdated
+  });
+  callbacksRef.current = {
+    onInitialized,
+    onContentUpdate,
+    onSelectionChange,
+    onHistorySizeUpdate,
+    onLog,
+    onError,
+    onWebViewRefUpdated
+  };
+  const propsRef = useRef({
+    content,
+    language,
+    extensions,
+    theme,
+    viewport
+  });
+  propsRef.current = {
+    content,
+    language,
+    extensions,
+    theme,
+    viewport
+  };
+  if (apiRef.current === null) {
+    apiRef.current = new WebViewAPI({
+      onInitialized: api => {
+        initializedRef.current = true;
+        setInitialized(true);
+        callbacksRef.current.onInitialized(api);
+      },
+      onContentUpdate: value => {
+        currentContentRef.current = value;
+        callbacksRef.current.onContentUpdate(value);
+      },
+      onSelectionChange: text => callbacksRef.current.onSelectionChange?.(text),
+      onHistorySizeUpdate: size => callbacksRef.current.onHistorySizeUpdate(size),
+      onLog: (...args) => callbacksRef.current.onLog(...args),
+      onError: error => callbacksRef.current.onError(error)
+    });
+  }
+  const callEditor = fn => {
+    if (initializedRef.current) {
+      void (async () => {
+        try {
+          await fn(apiRef.current.editor);
+        } catch (e) {
+          callbacksRef.current.onError(e);
+        }
+      })();
+    }
+  };
+
+  // Push content changes to live editor (skip initial render)
+  const prevContentRef = useRef(null);
+  useEffect(() => {
+    if (prevContentRef.current === null) {
+      prevContentRef.current = content;
+      return;
+    }
+    if (prevContentRef.current === content) return;
+    prevContentRef.current = content;
+    if (initializedRef.current && currentContentRef.current !== content) {
+      currentContentRef.current = content;
+      callEditor(e => e.setValue(content));
+    }
+  }, [content]);
+
+  // Push language changes to live editor
+  const prevLanguageRef = useRef(null);
+  useEffect(() => {
+    if (prevLanguageRef.current === null) {
+      prevLanguageRef.current = language;
+      return;
+    }
+    if (prevLanguageRef.current === language) return;
+    prevLanguageRef.current = language;
+    if (language) callEditor(e => e.setLanguage(language));
+  }, [language]);
+
+  // Push theme changes to live editor
+  const prevThemeRef = useRef(null);
+  useEffect(() => {
+    if (prevThemeRef.current === null) {
+      prevThemeRef.current = theme;
+      return;
+    }
+    if (prevThemeRef.current === theme) return;
+    prevThemeRef.current = theme;
+    callEditor(e => e.setTheme(theme));
+  }, [theme]);
+
+  // Push extension changes to live editor
+  const prevExtensionsRef = useRef(null);
+  useEffect(() => {
+    if (prevExtensionsRef.current === null) {
+      prevExtensionsRef.current = extensions;
+      return;
+    }
+    if (prevExtensionsRef.current === extensions) return;
+    prevExtensionsRef.current = extensions;
+    callEditor(e => e.setExtensions(extensions));
+  }, [extensions]);
+
+  // Push viewport changes to live editor
+  const prevViewportRef = useRef(null);
+  useEffect(() => {
+    if (prevViewportRef.current === null) {
+      prevViewportRef.current = viewport;
+      return;
+    }
+    if (prevViewportRef.current === viewport) return;
+    prevViewportRef.current = viewport;
+    if (viewport) callEditor(e => e.setViewport(viewport));
+  }, [viewport]);
+  const handleWebViewReference = useCallback(webView => {
+    setInitialized(false);
+    initializedRef.current = false;
+    if (webView) {
+      const {
+        content: c,
+        language: l,
+        extensions: e,
+        theme: t,
+        viewport: v
+      } = propsRef.current;
+      currentContentRef.current = c;
+      apiRef.current.setInitialConfig({
+        content: c,
+        language: l,
+        extensions: e,
+        theme: t,
+        viewport: v
+      });
+      apiRef.current.initialize(webView);
+    }
+    callbacksRef.current.onWebViewRefUpdated?.(webView);
+  }, []);
+  const handleMessage = useCallback(event => {
+    apiRef.current.onMessage(event);
+  }, []);
+  const handleLoadError = useCallback((...args) => {
+    console.log("WebView Load Error:", ...args);
+  }, []);
+  return /*#__PURE__*/_jsxs(View, {
+    style: styles.container,
+    children: [/*#__PURE__*/_jsx(WebView, {
+      ref: handleWebViewReference,
+      onMessage: handleMessage,
+      onError: handleLoadError,
+      onLoad: onLoad,
+      onLoadStart: onLoadStart,
+      onLoadProgress: onLoadProgress,
+      onLoadEnd: onLoadEnd,
+      onNavigationStateChange: onNavigationStateChange,
+      allowFileAccess: allowFileAccess,
+      allowFileAccessFromFileURLs: true,
+      allowUniversalAccessFromFileURLs: true,
+      allowingReadAccessToURL: Platform.OS === "ios" ? "file://" : undefined,
+      source: {
+        uri: editorUri
+      },
+      style: styles.webView,
+      javaScriptEnabled: true,
+      originWhitelist: ["file://*", "about:*"]
+    }), !initialized && renderBlockingView()]
+  });
+};
+export default CodeEditor;
+//# sourceMappingURL=CodeEditor.js.map

package/lib/module/EditorAPI.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=EditorAPI.js.map

package/lib/module/WebViewAPI.js

@@ -0,0 +1,133 @@
+"use strict";
+
+import { initializeHost } from '@actualwave/webview-interface';
+/**
+ * WebViewAPI wires the DDA bridge between React Native and the WebView editor.
+ * After onInitialized fires, call api.editor to reach the full EditorAPI proxy.
+ * api.focus() is the only method kept here directly — it additionally calls
+ * requestFocus() on the native WebView ref to trigger the Android soft keyboard.
+ */
+class WebViewAPI {
+  webView = null;
+  _editor = null;
+  stopFn = null;
+  _onMessage = null;
+  _initialConfig = {};
+  constructor(handlers) {
+    this.handlers = handlers;
+  }
+
+  /** DDA proxy to the WebView's EditorController. Available after onInitialized fires. */
+  get editor() {
+    return this._editor;
+  }
+  setInitialConfig(config) {
+    this._initialConfig = config;
+  }
+  initialize(webView) {
+    this.webView = webView;
+    this._editor = null;
+    this.stopFn?.();
+    this.stopFn = null;
+
+    // Methods exposed to the GUEST via DDA. The GUEST calls these on nativeApi.
+    const hostRoot = {
+      getInitialConfig: () => this._initialConfig,
+      onLog: (...args) => this.handlers.onLog(...args),
+      onError: error => this.handlers.onError(error)
+    };
+    const {
+      onMessage,
+      connection
+    } = initializeHost({
+      webView,
+      root: hostRoot,
+      handshakeTimeout: 30000
+    });
+    this._onMessage = onMessage;
+    void connection.then(({
+      root: pageApi,
+      stop
+    }) => {
+      this._editor = pageApi;
+      this.stopFn = stop;
+      // onInitialized is called when __editorReady__ arrives (after createEditor completes)
+    });
+  }
+
+  // Intercepts out-of-band messages before DDA sees them:
+  //   __editorLog__   — window.log() calls from the WebView
+  //   __editorError__ — window.onerror / unhandledrejection from the WebView
+  //   __editorReady__ — sent after createEditor + theme/language load; fires onInitialized
+  // Everything else is forwarded to the DDA subscriber.
+  onMessage = event => {
+    const raw = event?.nativeEvent?.data ?? event?.data;
+    if (typeof raw === 'string') {
+      try {
+        const parsed = JSON.parse(raw);
+        if (parsed?.type === '__editorError__') {
+          this.handlers.onError(parsed.data);
+          return;
+        }
+        if (parsed?.type === '__editorLog__') {
+          this.handlers.onLog(...(Array.isArray(parsed.data) ? parsed.data : [parsed.data]));
+          return;
+        }
+        if (parsed?.type === '__editorReady__') {
+          // Fires only after the GUEST finishes createEditor (theme + language applied),
+          // so the BlockingView is removed only when the editor is visually complete.
+          this.handlers.onInitialized(this);
+          return;
+        }
+        if (parsed?.type === '__contentChange__') {
+          // One-way notification — no DDA round trip, no injectJavaScript response.
+          // Keeps content updates off the DDA channel so injectJavaScript is never
+          // called while the user is typing (avoids disrupting Android IME composition).
+          const {
+            value,
+            undo,
+            redo
+          } = parsed.data ?? {};
+          this.handlers.onContentUpdate(value ?? '');
+          this.handlers.onHistorySizeUpdate({
+            undo: undo ?? 0,
+            redo: redo ?? 0
+          });
+          return;
+        }
+        if (parsed?.type === '__selectionChange__') {
+          this.handlers.onSelectionChange?.(typeof parsed.data === 'string' ? parsed.data : '');
+          return;
+        }
+      } catch {
+        // not JSON — fall through to DDA
+      }
+    }
+    this._onMessage?.(event);
+  };
+  stop() {
+    this.stopFn?.();
+    this.stopFn = null;
+    this._onMessage = null;
+    this._editor = null;
+  }
+  injectJavaScript(code) {
+    this.webView?.injectJavaScript(code);
+  }
+  requestFocus() {
+    this.webView?.requestFocus?.();
+  }
+
+  // focus() is kept here rather than on editor because it must also call
+  // requestFocus() on the native WebView ref to raise the Android soft keyboard.
+  focus = () => {
+    try {
+      this.webView?.requestFocus?.();
+    } catch {
+      // requestFocus is best-effort on Android
+    }
+    return this._editor.focus();
+  };
+}
+export default WebViewAPI;
+//# sourceMappingURL=WebViewAPI.js.map

package/lib/module/index.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export { default } from "./CodeEditor.js";
+export { default as CodeEditor } from "./CodeEditor.js";
+export { default as WebViewAPI } from "./WebViewAPI.js";
+//# sourceMappingURL=index.js.map

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/app.plugin.d.ts

@@ -0,0 +1,3 @@
+export = withCodeditorAssets;
+declare function withCodeditorAssets(config: any): any;
+//# sourceMappingURL=app.plugin.d.ts.map

package/lib/typescript/babel.config.d.ts

@@ -0,0 +1,10 @@
+export let overrides: ({
+    exclude: RegExp;
+    presets: string[];
+    include?: undefined;
+} | {
+    include: RegExp;
+    presets: string[];
+    exclude?: undefined;
+})[];
+//# sourceMappingURL=babel.config.d.ts.map

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/react-native.config.d.ts

@@ -0,0 +1,2 @@
+export let assets: string[];
+//# sourceMappingURL=react-native.config.d.ts.map

package/lib/typescript/scripts/copy-assets.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=copy-assets.d.ts.map

package/lib/typescript/src/BlockingView.d.ts

@@ -0,0 +1,3 @@
+declare const BlockingView: () => import("react/jsx-runtime").JSX.Element;
+export default BlockingView;
+//# sourceMappingURL=BlockingView.d.ts.map

package/lib/typescript/src/CodeEditor.d.ts

@@ -0,0 +1,33 @@
+import React from "react";
+import WebView from "react-native-webview";
+import WebViewAPI from "./WebViewAPI";
+import type { ExtensionSpec, HistorySize, ViewportSettings } from "./EditorAPI";
+export interface CodeEditorProps {
+    onInitialized: (api: WebViewAPI) => void;
+    onHistorySizeUpdate: (size: HistorySize) => void;
+    onLog: (...args: unknown[]) => void;
+    onError: (error: unknown) => void;
+    onContentUpdate: (content: string) => void;
+    onSelectionChange?: (text: string) => void;
+    onWebViewRefUpdated?: (webView: WebView | null) => void;
+    onLoad?: (event: unknown) => void;
+    onLoadStart?: (event: unknown) => void;
+    onLoadProgress?: (event: unknown) => void;
+    onLoadEnd?: (event: unknown) => void;
+    onNavigationStateChange?: (event: unknown) => void;
+    renderBlockingView?: () => React.ReactNode;
+    /** Language name for syntax highlighting, e.g. 'javascript', 'python'. */
+    language?: string;
+    /** Additional CodeMirror extension specs loaded on top of the language. */
+    extensions?: ExtensionSpec[];
+    /** Theme name from the @uiw/codemirror-themes collection, e.g. 'darcula', 'monokai'. */
+    theme?: string;
+    content?: string;
+    viewport?: ViewportSettings;
+    allowFileAccess?: boolean;
+    /** Override the default editor HTML URI (useful on iOS where the bundle path varies). */
+    editorUri?: string;
+}
+declare const CodeEditor: ({ onInitialized, onHistorySizeUpdate, onLog, onError, onContentUpdate, onSelectionChange, onWebViewRefUpdated, onLoad, onLoadStart, onLoadProgress, onLoadEnd, onNavigationStateChange, renderBlockingView, language, extensions, theme, content, viewport, allowFileAccess, editorUri, }: CodeEditorProps) => import("react/jsx-runtime").JSX.Element;
+export default CodeEditor;
+//# sourceMappingURL=CodeEditor.d.ts.map

package/lib/typescript/src/EditorAPI.d.ts

@@ -0,0 +1,66 @@
+export interface ViewportSettings {
+    maximumScale?: number;
+    minimumScale?: number;
+    intialScale?: number;
+    userScalable?: boolean;
+    viewportWidth?: string | number;
+}
+export interface CursorPosition {
+    line: number;
+    ch: number;
+    index: number;
+}
+export interface HistorySize {
+    undo: number;
+    redo: number;
+}
+/**
+ * Extension spec forms accepted by createEditor / setExtensions / setTheme:
+ *   - string → package name loaded via the registry, e.g. '@codemirror/autocomplete'
+ *   - [string, string] → [packageName, exportName], e.g. ['@uiw/codemirror-theme-darcula', 'darcula']
+ *   - [string, object] → [packageName, options] passed to the registered resolver
+ *   - anything else → treated as a pre-built CodeMirror Extension and used as-is
+ */
+export type ExtensionSpec = string | [string, unknown] | unknown;
+export interface CompletionItem {
+    label: string;
+    type?: 'function' | 'class' | 'variable' | 'keyword' | 'namespace' | 'type' | 'text';
+    detail?: string;
+    info?: string;
+}
+export interface EditorAPI {
+    getValue(): Promise<string>;
+    setValue(value: string): Promise<void>;
+    resetValue(value?: string): Promise<void>;
+    setLanguage(name: string): Promise<void>;
+    setExtensions(specs: ExtensionSpec[]): Promise<void>;
+    setTheme(themeName?: string): Promise<void>;
+    setFontSize(size: number): Promise<void>;
+    setViewport(options: ViewportSettings): Promise<void>;
+    focus(): Promise<void>;
+    getCursor(where?: 'from' | 'to' | 'head'): Promise<CursorPosition>;
+    setCursor(line: number, ch?: number): Promise<void>;
+    getSelection(): Promise<string>;
+    setSelection(anchor: number, head?: number): Promise<void>;
+    replaceSelection(text: string): Promise<void>;
+    cancelSelection(): Promise<void>;
+    indentMore(): Promise<boolean>;
+    indentLess(): Promise<boolean>;
+    toggleComment(): Promise<boolean>;
+    moveLineUp(): Promise<boolean>;
+    moveLineDown(): Promise<boolean>;
+    deleteLine(): Promise<boolean>;
+    selectLine(): Promise<boolean>;
+    selectParentSyntax(): Promise<boolean>;
+    historyUndo(): Promise<boolean>;
+    historyRedo(): Promise<boolean>;
+    historyClear(): Promise<void>;
+    historySize(): Promise<HistorySize>;
+    scrollToCursor(margin?: number): Promise<void>;
+    startCompletion(): Promise<void>;
+    setCompletions(items: CompletionItem[]): Promise<void>;
+    setSoftKeyboard(enabled: boolean): Promise<void>;
+    loadExtension(moduleName: string): Promise<object>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=EditorAPI.d.ts.map