react-cosmos 5.6.4

package/dist/getFixtures.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFixturesSync = getFixturesSync;
+exports.getFixtures = void 0;
+
+var _FixtureLoader = require("react-cosmos-shared2/FixtureLoader");
+
+var _react = require("react-cosmos-shared2/react");
+
+var _userDeps = require("./shared/userDeps");
+
+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); }); }; }
+
+var getFixtures = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(args) {
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", getFixturesSync(args));
+
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function getFixtures(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+exports.getFixtures = getFixtures;
+
+function getFixturesSync(_ref2) {
+  var cosmosConfig = _ref2.cosmosConfig;
+
+  var _getUserModules = (0, _userDeps.getUserModules)(cosmosConfig),
+      fixtureExportsByPath = _getUserModules.fixtureExportsByPath,
+      decoratorsByPath = _getUserModules.decoratorsByPath;
+
+  var fixtures = [];
+  Object.keys(fixtureExportsByPath).forEach(function (fixturePath) {
+    var fixtureExport = fixtureExportsByPath[fixturePath];
+
+    if ((0, _react.isMultiFixture)(fixtureExport)) {
+      // FIXME: Why does fixtureExport need to be cast as ReactFixtureMap when
+      // the type predicate returned by isMultiFixture already ensures it?
+      var multiFixtureExport = fixtureExport;
+      Object.keys(fixtureExport).forEach(function (fixtureName) {
+        var fixtureId = {
+          path: fixturePath,
+          name: fixtureName
+        };
+        fixtures.push({
+          fixtureId: fixtureId,
+          getElement: createFixtureElementGetter(multiFixtureExport[fixtureName], fixturePath, decoratorsByPath)
+        });
+      });
+    } else {
+      var fixtureId = {
+        path: fixturePath,
+        name: null
+      };
+      fixtures.push({
+        fixtureId: fixtureId,
+        getElement: createFixtureElementGetter(fixtureExport, fixturePath, decoratorsByPath)
+      });
+    }
+  });
+  return fixtures;
+}
+
+function createFixtureElementGetter(fixture, fixturePath, decoratorsByPath) {
+  var decorators = (0, _react.getSortedDecoratorsForFixturePath)(fixturePath, decoratorsByPath);
+  return function () {
+    return (0, _FixtureLoader.getDecoratedFixtureElement)(fixture, decorators, {
+      fixtureState: {},
+      setFixtureState: function setFixtureState() {},
+      onErrorReset: function onErrorReset() {}
+    });
+  };
+}

package/dist/getFixtures2.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import { CosmosConfig } from './config';
+export declare type FixtureApi = {
+    absoluteFilePath: string;
+    fileName: string;
+    getElement: () => React.ReactElement<any>;
+    name: string | null;
+    parents: string[];
+    playgroundUrl: string;
+    relativeFilePath: string;
+    rendererUrl: string;
+    treePath: string[];
+};
+export declare function getFixtures2(cosmosConfig: CosmosConfig): FixtureApi[];

package/dist/getFixtures2.js

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFixtures2 = getFixtures2;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _FixtureLoader = require("react-cosmos-shared2/FixtureLoader");
+
+var _fixtureTree = require("react-cosmos-shared2/fixtureTree");
+
+var _react = require("react-cosmos-shared2/react");
+
+var _url = require("react-cosmos-shared2/url");
+
+var _url2 = _interopRequireDefault(require("url"));
+
+var _playgroundHtml = require("./shared/playgroundHtml");
+
+var _userDeps = require("./shared/userDeps");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+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 getFixtures2(cosmosConfig) {
+  var fixturesDir = cosmosConfig.fixturesDir,
+      fixtureFileSuffix = cosmosConfig.fixtureFileSuffix,
+      rootDir = cosmosConfig.rootDir;
+  var fixtureInfo = [];
+
+  var _getUserModules = (0, _userDeps.getUserModules)(cosmosConfig),
+      fixtureExportsByPath = _getUserModules.fixtureExportsByPath,
+      decoratorsByPath = _getUserModules.decoratorsByPath;
+
+  var fixtureNamesByPath = (0, _react.getFixtureNamesByPath)(fixtureExportsByPath);
+  var fixtureTree = (0, _fixtureTree.createFixtureTree)({
+    fixtures: fixtureNamesByPath,
+    fixturesDir: fixturesDir,
+    fixtureFileSuffix: fixtureFileSuffix
+  });
+  var flatFixtureTree = (0, _fixtureTree.flattenFixtureTree)(fixtureTree);
+  flatFixtureTree.forEach(function (_ref) {
+    var fileName = _ref.fileName,
+        fixtureId = _ref.fixtureId,
+        name = _ref.name,
+        parents = _ref.parents;
+    var fixtureExport = fixtureExportsByPath[fixtureId.path];
+    var fixture = fixtureId.name === null ? fixtureExport : fixtureExport[fixtureId.name];
+    var treePath = [].concat(_toConsumableArray(parents), [fileName]);
+    if (name) treePath.push(name);
+    fixtureInfo.push({
+      absoluteFilePath: _path.default.join(rootDir, fixtureId.path),
+      fileName: fileName,
+      getElement: createFixtureElementGetter(fixture, fixtureId.path, decoratorsByPath),
+      name: name,
+      parents: parents,
+      playgroundUrl: getPlaygroundUrl(cosmosConfig, fixtureId),
+      relativeFilePath: fixtureId.path,
+      rendererUrl: getRendererUrl(cosmosConfig, fixtureId),
+      treePath: treePath
+    });
+  });
+  return fixtureInfo;
+}
+
+function getPlaygroundUrl(cosmosConfig, fixtureId) {
+  var host = getPlaygroundHost(cosmosConfig);
+  var query = (0, _url.stringifyPlaygroundUrlQuery)({
+    fixtureId: fixtureId
+  });
+  return "".concat(host, "/?").concat(query);
+}
+
+function getRendererUrl(cosmosConfig, fixtureId) {
+  var publicUrl = cosmosConfig.publicUrl,
+      experimentalRendererUrl = cosmosConfig.experimentalRendererUrl;
+  var query = (0, _url.stringifyRendererUrlQuery)({
+    _fixtureId: fixtureId
+  });
+  if (experimentalRendererUrl) return "".concat(experimentalRendererUrl, "?").concat(query);
+  var host = getPlaygroundHost(cosmosConfig);
+
+  var urlPath = _url2.default.resolve(publicUrl, _playgroundHtml.RENDERER_FILENAME);
+
+  return "".concat(host).concat(urlPath, "?").concat(query);
+}
+
+function getPlaygroundHost(_ref2) {
+  var hostname = _ref2.hostname,
+      port = _ref2.port,
+      https = _ref2.https;
+  return "".concat(https ? 'https' : 'http', "://").concat(hostname || 'localhost', ":").concat(port);
+}
+
+function createFixtureElementGetter(fixture, fixturePath, decoratorsByPath) {
+  var decorators = (0, _react.getSortedDecoratorsForFixturePath)(fixturePath, decoratorsByPath);
+  return function () {
+    return (0, _FixtureLoader.getDecoratedFixtureElement)(fixture, decorators, {
+      fixtureState: {},
+      setFixtureState: function setFixtureState() {},
+      onErrorReset: function onErrorReset() {}
+    });
+  };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { createCosmosConfig, detectCosmosConfig, getCosmosConfigAtPath, } from './config';
+export { getFixtures, getFixturesSync } from './getFixtures';
+export { FixtureApi, getFixtures2 } from './getFixtures2';
+export { getFixtureUrls, getFixtureUrlsSync } from './getFixtureUrls';

package/dist/index.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createCosmosConfig", {
+  enumerable: true,
+  get: function get() {
+    return _config.createCosmosConfig;
+  }
+});
+Object.defineProperty(exports, "detectCosmosConfig", {
+  enumerable: true,
+  get: function get() {
+    return _config.detectCosmosConfig;
+  }
+});
+Object.defineProperty(exports, "getCosmosConfigAtPath", {
+  enumerable: true,
+  get: function get() {
+    return _config.getCosmosConfigAtPath;
+  }
+});
+Object.defineProperty(exports, "getFixtures", {
+  enumerable: true,
+  get: function get() {
+    return _getFixtures.getFixtures;
+  }
+});
+Object.defineProperty(exports, "getFixturesSync", {
+  enumerable: true,
+  get: function get() {
+    return _getFixtures.getFixturesSync;
+  }
+});
+Object.defineProperty(exports, "FixtureApi", {
+  enumerable: true,
+  get: function get() {
+    return _getFixtures2.FixtureApi;
+  }
+});
+Object.defineProperty(exports, "getFixtures2", {
+  enumerable: true,
+  get: function get() {
+    return _getFixtures2.getFixtures2;
+  }
+});
+Object.defineProperty(exports, "getFixtureUrls", {
+  enumerable: true,
+  get: function get() {
+    return _getFixtureUrls.getFixtureUrls;
+  }
+});
+Object.defineProperty(exports, "getFixtureUrlsSync", {
+  enumerable: true,
+  get: function get() {
+    return _getFixtureUrls.getFixtureUrlsSync;
+  }
+});
+
+var _config = require("./config");
+
+var _getFixtures = require("./getFixtures");
+
+var _getFixtures2 = require("./getFixtures2");
+
+var _getFixtureUrls = require("./getFixtureUrls");

package/dist/native.d.ts

@@ -0,0 +1,9 @@
+import { ReactDecoratorsByPath, ReactFixtureExportsByPath } from 'react-cosmos-shared2/react';
+import { NativeRendererConfig } from './shared/rendererConfig';
+declare type Props = {
+    rendererConfig: NativeRendererConfig;
+    fixtures: ReactFixtureExportsByPath;
+    decorators: ReactDecoratorsByPath;
+};
+export declare function NativeFixtureLoader({ rendererConfig: { port }, fixtures, decorators, }: Props): JSX.Element;
+export {};

package/dist/native.js

@@ -0,0 +1,69 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NativeFixtureLoader = NativeFixtureLoader;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _FixtureLoader = require("react-cosmos-shared2/FixtureLoader");
+
+var ReactNative = _interopRequireWildcard(require("react-native"));
+
+var _urlParse = _interopRequireDefault(require("url-parse"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var View = ReactNative.View,
+    Text = ReactNative.Text,
+    StyleSheet = ReactNative.StyleSheet,
+    NativeModules = ReactNative.NativeModules; // https://stackoverflow.com/a/53655887/128816
+
+var wsWarning = 'Unrecognized WebSocket connection option(s) `agent`, `perMessageDeflate`, `pfx`, `key`, `passphrase`, `cert`, `ca`, `ciphers`, `rejectUnauthorized`. Did you mean to put these under `headers`?';
+if (ReactNative.LogBox) ReactNative.LogBox.ignoreLogs([wsWarning]);else if (ReactNative.YellowBox) ReactNative.YellowBox.ignoreWarnings([wsWarning]); // TODO: Generate unique ID per device
+
+var rendererId = 'native-renderer';
+
+function NativeFixtureLoader(_ref) {
+  var port = _ref.rendererConfig.port,
+      fixtures = _ref.fixtures,
+      decorators = _ref.decorators;
+  var socketUrl = getSocketUrl(port);
+  return /*#__PURE__*/_react.default.createElement(_FixtureLoader.FixtureLoader, {
+    rendererId: rendererId,
+    rendererConnect: (0, _FixtureLoader.createWebSocketsConnect)(socketUrl),
+    fixtures: fixtures,
+    selectedFixtureId: null,
+    systemDecorators: [],
+    userDecorators: decorators,
+    renderMessage: renderMessage
+  });
+}
+
+function getSocketUrl(port) {
+  var host = (0, _urlParse.default)(NativeModules.SourceCode.scriptURL).hostname;
+  return "ws://".concat(host, ":").concat(port);
+}
+
+function renderMessage(_ref2) {
+  var msg = _ref2.msg;
+  return /*#__PURE__*/_react.default.createElement(View, {
+    style: styles.container
+  }, /*#__PURE__*/_react.default.createElement(Text, null, msg));
+}
+
+var styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: '#fff',
+    alignItems: 'center',
+    justifyContent: 'center'
+  }
+});

package/dist/nativeServer.d.ts

@@ -0,0 +1 @@
+export declare function startNativeServer(): Promise<void>;

package/dist/nativeServer.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startNativeServer = startNativeServer;
+
+var _openFile = require("./plugins/openFile");
+
+var _userDepsFile = require("./plugins/userDepsFile");
+
+var _devServer = require("./shared/devServer");
+
+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 startNativeServer() {
+  return _startNativeServer.apply(this, arguments);
+}
+
+function _startNativeServer() {
+  _startNativeServer = _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 (0, _devServer.startDevServer)('native', [_userDepsFile.userDepsFile, _openFile.openFile]);
+
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _startNativeServer.apply(this, arguments);
+}

package/dist/plugins/httpProxy.d.ts

@@ -0,0 +1,2 @@
+import { DevServerPluginArgs } from '../shared/devServer';
+export declare function httpProxy({ cosmosConfig, expressApp }: DevServerPluginArgs): void;

package/dist/plugins/httpProxy.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.httpProxy = httpProxy;
+
+var _httpProxyMiddleware = require("http-proxy-middleware");
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function httpProxy(_ref) {
+  var cosmosConfig = _ref.cosmosConfig,
+      expressApp = _ref.expressApp;
+  var httpProxyConfig = getHttpProxyCosmosConfig(cosmosConfig);
+  Object.keys(httpProxyConfig).forEach(function (context) {
+    var config = httpProxyConfig[context];
+
+    if (typeof config === 'string') {
+      expressApp.use(context, (0, _httpProxyMiddleware.createProxyMiddleware)(context, {
+        target: config
+      }));
+    } else if (_typeof(config) === 'object') {
+      expressApp.use(context, (0, _httpProxyMiddleware.createProxyMiddleware)(context, config));
+    }
+  });
+}
+
+function getHttpProxyCosmosConfig(cosmosConfig) {
+  return cosmosConfig.httpProxy || {};
+}

package/dist/plugins/openFile.d.ts

@@ -0,0 +1,2 @@
+import { DevServerPluginArgs } from '../shared/devServer';
+export declare function openFile({ cosmosConfig, expressApp }: DevServerPluginArgs): void;

package/dist/plugins/openFile.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.openFile = openFile;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _open = _interopRequireDefault(require("open"));
+
+var _launchEditor = _interopRequireDefault(require("@skidding/launch-editor"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function openFile(_ref) {
+  var cosmosConfig = _ref.cosmosConfig,
+      expressApp = _ref.expressApp;
+  expressApp.get('/_open', function (req, res) {
+    var _getReqQuery = getReqQuery(req),
+        filePath = _getReqQuery.filePath,
+        line = _getReqQuery.line,
+        column = _getReqQuery.column;
+
+    if (!filePath) {
+      res.status(400).send("File path missing");
+      return;
+    }
+
+    var absFilePath = resolveFilePath(cosmosConfig, filePath);
+
+    if (!_fs.default.existsSync(absFilePath)) {
+      res.status(404).send("File not found at path: ".concat(absFilePath));
+      return;
+    }
+
+    new Promise(function (resolve, reject) {
+      var file = "".concat(absFilePath, ":").concat(line, ":").concat(column);
+      (0, _launchEditor.default)(file, function (fileName, errorMsg) {
+        return reject(errorMsg);
+      }); // If launchEditor doesn't report error within 500ms we assume it worked
+
+      setTimeout(resolve, 500);
+    }) // Fall back to open in case launchEditor fails. launchEditor only works
+    // when the editor app is already open, but is favorable because it can
+    // open a code file on a specific line & column.
+    .catch(function (err) {
+      return (0, _open.default)(absFilePath);
+    }).catch(function (err) {
+      return res.status(500).send('Failed to open file');
+    }).then(function () {
+      return res.send();
+    });
+  });
+}
+
+function getReqQuery(req) {
+  var _req$query = req.query,
+      filePath = _req$query.filePath,
+      line = _req$query.line,
+      column = _req$query.column;
+  if (typeof filePath !== 'string') throw new Error('filePath missing');
+  return {
+    filePath: filePath,
+    line: typeof line === 'string' ? parseInt(line, 10) : 1,
+    column: typeof column === 'string' ? parseInt(column, 10) : 1
+  };
+}
+
+function resolveFilePath(cosmosConfig, filePath) {
+  // This heuristic is needed because the open file endpoint is used for
+  // multiple applications, which provide different file path types:
+  // 1. Edit fixture button: Sends path relative to Cosmos rootDir
+  // 2. react-error-overlay runtime error: Sends absolute path
+  // 3. react-error-overlay compile error: Sends path relative to CWD
+  if (_path.default.isAbsolute(filePath)) {
+    return filePath;
+  }
+
+  var cosmosRelPath = _path.default.join(cosmosConfig.rootDir, filePath);
+
+  var cwdRelPath = _path.default.join(process.cwd(), filePath);
+
+  return _fs.default.existsSync(cosmosRelPath) ? cosmosRelPath : cwdRelPath;
+}

package/dist/plugins/userDepsFile.d.ts

@@ -0,0 +1,2 @@
+import { DevServerPluginArgs } from '../shared/devServer';
+export declare function userDepsFile(args: DevServerPluginArgs): Promise<(() => void) | undefined>;