react-cosmos 5.6.4

package/dist/shared/devServer/httpServer.js

@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createHttpServer = createHttpServer;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _http = _interopRequireDefault(require("http"));
+
+var _https = _interopRequireDefault(require("https"));
+
+var _pem = _interopRequireDefault(require("pem"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function createHttpServer(_x, _x2) {
+  return _createHttpServer.apply(this, arguments);
+}
+
+function _createHttpServer() {
+  _createHttpServer = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(cosmosConfig, requestListener) {
+    var port, hostname, httpsEnabled, server, start, _start, stop, _stop;
+
+    return regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _stop = function _stop3() {
+              _stop = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
+                return regeneratorRuntime.wrap(function _callee2$(_context2) {
+                  while (1) {
+                    switch (_context2.prev = _context2.next) {
+                      case 0:
+                        _context2.next = 2;
+                        return new Promise(function (resolve) {
+                          return server.close(resolve);
+                        });
+
+                      case 2:
+                      case "end":
+                        return _context2.stop();
+                    }
+                  }
+                }, _callee2);
+              }));
+              return _stop.apply(this, arguments);
+            };
+
+            stop = function _stop2() {
+              return _stop.apply(this, arguments);
+            };
+
+            _start = function _start3() {
+              _start = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+                var hostnameDisplay, protocol;
+                return regeneratorRuntime.wrap(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                        _context.next = 2;
+                        return new Promise(function (resolve) {
+                          if (hostname === null) {
+                            server.listen(port, resolve);
+                          } else {
+                            server.listen(port, hostname, resolve);
+                          }
+                        });
+
+                      case 2:
+                        hostnameDisplay = hostname || 'localhost';
+                        protocol = httpsEnabled ? 'https' : 'http';
+                        console.log("[Cosmos] See you at ".concat(protocol, "://").concat(hostnameDisplay, ":").concat(port));
+
+                      case 5:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+              return _start.apply(this, arguments);
+            };
+
+            start = function _start2() {
+              return _start.apply(this, arguments);
+            };
+
+            port = cosmosConfig.port, hostname = cosmosConfig.hostname, httpsEnabled = cosmosConfig.https;
+
+            if (!httpsEnabled) {
+              _context3.next = 14;
+              break;
+            }
+
+            _context3.t1 = _https.default;
+            _context3.next = 9;
+            return getHttpsOpts(cosmosConfig);
+
+          case 9:
+            _context3.t2 = _context3.sent;
+            _context3.t3 = requestListener;
+            _context3.t0 = _context3.t1.createServer.call(_context3.t1, _context3.t2, _context3.t3);
+            _context3.next = 15;
+            break;
+
+          case 14:
+            _context3.t0 = _http.default.createServer(requestListener);
+
+          case 15:
+            server = _context3.t0;
+            return _context3.abrupt("return", {
+              server: server,
+              start: start,
+              stop: stop
+            });
+
+          case 17:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _createHttpServer.apply(this, arguments);
+}
+
+function getHttpsOpts(_x3) {
+  return _getHttpsOpts.apply(this, arguments);
+}
+
+function _getHttpsOpts() {
+  _getHttpsOpts = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(cosmosConfig) {
+    var httpsOptions;
+    return regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            httpsOptions = cosmosConfig.httpsOptions;
+
+            if (!httpsOptions) {
+              _context4.next = 3;
+              break;
+            }
+
+            return _context4.abrupt("return", {
+              key: _fs.default.readFileSync(httpsOptions.keyPath, 'utf8'),
+              cert: _fs.default.readFileSync(httpsOptions.certPath, 'utf8')
+            });
+
+          case 3:
+            console.log('[Cosmos] Generating HTTPS certificate');
+            _context4.next = 6;
+            return new Promise(function (resolve, reject) {
+              _pem.default.createCertificate({
+                days: 1000,
+                selfSigned: true
+              }, function (err, keys) {
+                if (err) return reject(err);
+                return resolve({
+                  key: keys.serviceKey,
+                  cert: keys.certificate
+                });
+              });
+            });
+
+          case 6:
+            return _context4.abrupt("return", _context4.sent);
+
+          case 7:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _getHttpsOpts.apply(this, arguments);
+}

package/dist/shared/devServer/index.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import express from 'express';
+import http from 'http';
+import { Message } from 'react-cosmos-shared2/util';
+import { CosmosConfig } from '../../config';
+import { PlatformType } from '../shared';
+declare type PluginCleanupCallback = () => unknown;
+declare type PluginReturn = void | null | PluginCleanupCallback;
+export declare type DevServerPluginArgs = {
+    cosmosConfig: CosmosConfig;
+    platformType: PlatformType;
+    httpServer: http.Server;
+    expressApp: express.Express;
+    sendMessage(msg: Message): unknown;
+};
+export declare type DevServerPlugin = (args: DevServerPluginArgs) => PluginReturn | Promise<PluginReturn>;
+export declare function startDevServer(platformType: PlatformType, plugins?: DevServerPlugin[]): Promise<() => Promise<void>>;
+export {};

package/dist/shared/devServer/index.js

@@ -0,0 +1,209 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startDevServer = startDevServer;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _config = require("../../config");
+
+var _pluginConfigs = require("../pluginConfigs");
+
+var _static = require("../static");
+
+var _app = require("./app");
+
+var _httpServer = require("./httpServer");
+
+var _messageHandler = require("./messageHandler");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function startDevServer(_x) {
+  return _startDevServer.apply(this, arguments);
+}
+
+function _startDevServer() {
+  _startDevServer = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(platformType) {
+    var plugins,
+        cosmosConfig,
+        pluginConfigs,
+        app,
+        pluginCleanupCallbacks,
+        httpServer,
+        msgHandler,
+        cleanUp,
+        _cleanUp,
+        _iterator,
+        _step,
+        plugin,
+        pluginReturn,
+        _args2 = arguments;
+
+    return regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _cleanUp = function _cleanUp3() {
+              _cleanUp = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+                return regeneratorRuntime.wrap(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                        _context.next = 2;
+                        return Promise.all(pluginCleanupCallbacks.map(function (cleanup) {
+                          return cleanup();
+                        }));
+
+                      case 2:
+                        _context.next = 4;
+                        return httpServer.stop();
+
+                      case 4:
+                        msgHandler.cleanUp();
+
+                      case 5:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+              return _cleanUp.apply(this, arguments);
+            };
+
+            cleanUp = function _cleanUp2() {
+              return _cleanUp.apply(this, arguments);
+            };
+
+            plugins = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : [];
+            cosmosConfig = (0, _config.detectCosmosConfig)();
+            logCosmosConfigInfo();
+            pluginConfigs = (0, _pluginConfigs.getPluginConfigs)(cosmosConfig);
+            logPluginInfo(pluginConfigs);
+            app = (0, _app.createApp)(platformType, cosmosConfig, pluginConfigs);
+
+            if (cosmosConfig.staticPath) {
+              (0, _static.serveStaticDir)(app, cosmosConfig.staticPath, cosmosConfig.publicUrl);
+            }
+
+            pluginCleanupCallbacks = [];
+            _context2.next = 12;
+            return (0, _httpServer.createHttpServer)(cosmosConfig, app);
+
+          case 12:
+            httpServer = _context2.sent;
+            _context2.next = 15;
+            return httpServer.start();
+
+          case 15:
+            msgHandler = (0, _messageHandler.createMessageHandler)(httpServer.server);
+            _context2.prev = 16;
+            _iterator = _createForOfIteratorHelper(plugins);
+            _context2.prev = 18;
+
+            _iterator.s();
+
+          case 20:
+            if ((_step = _iterator.n()).done) {
+              _context2.next = 28;
+              break;
+            }
+
+            plugin = _step.value;
+            _context2.next = 24;
+            return plugin({
+              cosmosConfig: cosmosConfig,
+              platformType: platformType,
+              httpServer: httpServer.server,
+              expressApp: app,
+              sendMessage: msgHandler.sendMessage
+            });
+
+          case 24:
+            pluginReturn = _context2.sent;
+
+            if (typeof pluginReturn === 'function') {
+              pluginCleanupCallbacks.push(pluginReturn);
+            }
+
+          case 26:
+            _context2.next = 20;
+            break;
+
+          case 28:
+            _context2.next = 33;
+            break;
+
+          case 30:
+            _context2.prev = 30;
+            _context2.t0 = _context2["catch"](18);
+
+            _iterator.e(_context2.t0);
+
+          case 33:
+            _context2.prev = 33;
+
+            _iterator.f();
+
+            return _context2.finish(33);
+
+          case 36:
+            _context2.next = 42;
+            break;
+
+          case 38:
+            _context2.prev = 38;
+            _context2.t1 = _context2["catch"](16);
+            cleanUp();
+            throw _context2.t1;
+
+          case 42:
+            return _context2.abrupt("return", cleanUp);
+
+          case 43:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[16, 38], [18, 30, 33, 36]]);
+  }));
+  return _startDevServer.apply(this, arguments);
+}
+
+function logCosmosConfigInfo() {
+  var cosmosConfigPath = (0, _config.detectCosmosConfigPath)();
+
+  if (!cosmosConfigPath) {
+    console.log("[Cosmos] Using default cosmos config");
+    return;
+  }
+
+  var relConfigPath = _path.default.relative(process.cwd(), cosmosConfigPath);
+
+  console.log("[Cosmos] Using cosmos config found at ".concat(relConfigPath));
+}
+
+function logPluginInfo(pluginConfigs) {
+  var pluginCount = pluginConfigs.length;
+
+  if (pluginCount > 0) {
+    var pluginLabel = pluginCount === 1 ? 'plugin' : 'plugins';
+    var pluginNames = pluginConfigs.map(function (p) {
+      return p.name;
+    }).join(', ');
+    console.log("[Cosmos] Found ".concat(pluginCount, " ").concat(pluginLabel, ": ").concat(pluginNames));
+  }
+}

package/dist/shared/devServer/messageHandler.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import http from 'http';
+import { BuildMessage } from 'react-cosmos-shared2/build';
+export declare function createMessageHandler(httpServer: http.Server): {
+    sendMessage: (msg: BuildMessage) => void;
+    cleanUp: () => void;
+};

package/dist/shared/devServer/messageHandler.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMessageHandler = createMessageHandler;
+
+var _socket = _interopRequireDefault(require("socket.io"));
+
+var _build = require("react-cosmos-shared2/build");
+
+var _renderer = require("react-cosmos-shared2/renderer");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function createMessageHandler(httpServer) {
+  var io = (0, _socket.default)(httpServer);
+  io.on('connection', function (socket) {
+    // Forward commands between connected clients. Parties involved can be the
+    // - The Cosmos UI, which acts as a remote control
+    // - The web iframe or the React Native component renderers
+    socket.on(_renderer.RENDERER_MESSAGE_EVENT_NAME, function (msg) {
+      socket.broadcast.emit(_renderer.RENDERER_MESSAGE_EVENT_NAME, msg);
+    });
+  });
+
+  function sendMessage(msg) {
+    io.emit(_build.SERVER_MESSAGE_EVENT_NAME, msg);
+  }
+
+  function cleanUp() {
+    var sockets = io.sockets.sockets;
+    Object.keys(sockets).forEach(function (id) {
+      sockets[id].disconnect(true);
+    });
+  }
+
+  return {
+    sendMessage: sendMessage,
+    cleanUp: cleanUp
+  };
+}

package/dist/shared/export.d.ts

@@ -0,0 +1,6 @@
+import { CosmosConfig } from '../config';
+export declare type ExportPluginArgs = {
+    cosmosConfig: CosmosConfig;
+};
+export declare type ExportPlugin = (args: ExportPluginArgs) => unknown;
+export declare function generateExport(plugins?: ExportPlugin[]): Promise<void>;

package/dist/shared/export.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateExport = generateExport;
+
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _config = require("../config");
+
+var _playgroundHtml = require("./playgroundHtml");
+
+var _pluginConfigs = require("./pluginConfigs");
+
+var _shared = require("./shared");
+
+var _static = require("./static");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function generateExport() {
+  return _generateExport.apply(this, arguments);
+}
+
+function _generateExport() {
+  _generateExport = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+    var plugins,
+        cosmosConfig,
+        exportPath,
+        _args = arguments;
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            plugins = _args.length > 0 && _args[0] !== undefined ? _args[0] : [];
+            cosmosConfig = (0, _config.detectCosmosConfig)(); // Clear previous export (or other files at export path)
+
+            exportPath = cosmosConfig.exportPath;
+
+            _fsExtra.default.removeSync(exportPath); // Copy static assets first, so that the built index.html overrides the its
+            // template file (in case the static assets are served from the root path)
+
+
+            copyStaticAssets(cosmosConfig);
+            _context.next = 7;
+            return Promise.all(plugins.map(function (plugin) {
+              return plugin({
+                cosmosConfig: cosmosConfig
+              });
+            }));
+
+          case 7:
+            exportPlaygroundFiles(cosmosConfig);
+            console.log('[Cosmos] Export complete!');
+            console.log("Export path: ".concat(cosmosConfig.exportPath));
+
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _generateExport.apply(this, arguments);
+}
+
+function copyStaticAssets(cosmosConfig) {
+  var staticPath = cosmosConfig.staticPath;
+
+  if (!staticPath) {
+    return;
+  }
+
+  var exportPath = cosmosConfig.exportPath;
+
+  if (exportPath.indexOf(staticPath) !== -1) {
+    console.warn("[Cosmos] Warning: Can't export static path because it contains the export path! (avoiding infinite loop)");
+    console.warn('Public path:', staticPath);
+    console.warn('Export path:', exportPath);
+    return;
+  }
+
+  if (!_fsExtra.default.existsSync(staticPath)) {
+    console.log('[Cosmos] Warning: config.staticPath points to missing dir', staticPath);
+    return;
+  }
+
+  var publicUrl = cosmosConfig.publicUrl;
+
+  var exportStaticPath = _path.default.resolve(exportPath, (0, _shared.removeLeadingSlash)(publicUrl));
+
+  _fsExtra.default.copySync(staticPath, exportStaticPath);
+}
+
+function exportPlaygroundFiles(cosmosConfig) {
+  var exportPath = cosmosConfig.exportPath;
+  var pluginConfigs = (0, _pluginConfigs.getPluginConfigs)(cosmosConfig);
+  pluginConfigs.forEach(function (pluginConfig) {
+    return exportPlugin(cosmosConfig, pluginConfig);
+  });
+
+  _fsExtra.default.copySync(require.resolve('react-cosmos-playground2/dist'), _path.default.resolve(exportPath, '_playground.js'));
+
+  _fsExtra.default.copySync((0, _static.getStaticPath)('favicon.ico'), _path.default.resolve(exportPath, '_cosmos.ico'));
+
+  var playgroundHtml = (0, _playgroundHtml.getExportPlaygroundHtml)(cosmosConfig, pluginConfigs);
+
+  _fsExtra.default.writeFileSync(_path.default.resolve(exportPath, 'index.html'), playgroundHtml);
+}
+
+function exportPlugin(cosmosConfig, pluginConfig) {
+  var rootDir = cosmosConfig.rootDir,
+      exportPath = cosmosConfig.exportPath;
+
+  var pluginExportDir = _path.default.resolve(exportPath, '_plugin'); // Copy plugin config
+
+
+  var relConfigPath = _path.default.join(pluginConfig.rootDir, 'cosmos.plugin.json');
+
+  var absConfigPath = _path.default.resolve(rootDir, relConfigPath);
+
+  _fsExtra.default.copySync(absConfigPath, _path.default.resolve(pluginExportDir, relConfigPath)); // Copy UI script
+
+
+  if (pluginConfig.ui) {
+    var absUiPath = _path.default.resolve(rootDir, pluginConfig.ui);
+
+    _fsExtra.default.copySync(absUiPath, _path.default.resolve(pluginExportDir, pluginConfig.ui));
+  }
+}

package/dist/shared/fs.d.ts

@@ -0,0 +1,4 @@
+export declare function requireModule(modulePath: string): any;
+export declare function moduleExists(modulePath: string): boolean | "";
+export declare function fileExists(filePath: string): boolean;
+export declare function dirExists(dirPath: string): boolean;

package/dist/shared/fs.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requireModule = requireModule;
+exports.moduleExists = moduleExists;
+exports.fileExists = fileExists;
+exports.dirExists = dirExists;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// NOTE: This API has been extracted to be easily mocked inside tests
+function requireModule(modulePath) {
+  // This purpose of this wrapper is merely to make it easy to mock user
+  // modules in tests
+  return require(modulePath);
+} // Better than fs.exists because it works for module paths without an extension
+
+
+function moduleExists(modulePath) {
+  try {
+    return require.resolve(modulePath) && true;
+  } catch (err) {
+    return false;
+  }
+}
+
+function fileExists(filePath) {
+  return _fs.default.existsSync(filePath) && _fs.default.lstatSync(filePath).isFile();
+}
+
+function dirExists(dirPath) {
+  return _fs.default.existsSync(dirPath) && _fs.default.lstatSync(dirPath).isDirectory();
+}

package/dist/shared/playgroundHtml.d.ts

@@ -0,0 +1,6 @@
+import { CosmosPluginConfig } from 'react-cosmos-plugin';
+import { CosmosConfig } from '../config';
+import { PlatformType } from './shared';
+export declare const RENDERER_FILENAME = "_renderer.html";
+export declare function getDevPlaygroundHtml(platformType: PlatformType, cosmosConfig: CosmosConfig, pluginConfigs: CosmosPluginConfig[]): string;
+export declare function getExportPlaygroundHtml(cosmosConfig: CosmosConfig, pluginConfigs: CosmosPluginConfig[]): string;