@khanacademy/wonder-blocks-testing 7.1.10 → 7.1.11

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @khanacademy/wonder-blocks-testing
 
+## 7.1.11
+
+### Patch Changes
+
+-   873f4a14: Update type narrowing logic to work better with TypeScript
+-   d816af08: Update build and test configs use TypeScript
+-   3891f544: Update babel config to include plugins that Storybook needed
+-   3813715d: Update wonder-stuff dependencies (non-functional changes)
+-   0d28bb1c: Configured TypeScript
+-   3d05f764: Fix HOCs and other type errors
+-   c2ec4902: Update eslint configuration, fix lint
+-   2983c05b: Include 'types' field in package.json
+-   77ff6a66: Generate Flow types from TypeScript types
+-   ec8d4b7f: Fix miscellaneous TypeScript errors
+-   Updated dependencies [d816af08]
+-   Updated dependencies [3891f544]
+-   Updated dependencies [3813715d]
+-   Updated dependencies [0d28bb1c]
+-   Updated dependencies [3d05f764]
+-   Updated dependencies [c2ec4902]
+-   Updated dependencies [2983c05b]
+-   Updated dependencies [77ff6a66]
+-   Updated dependencies [ec8d4b7f]
+    -   @khanacademy/wonder-blocks-data@10.1.1
+
 ## 7.1.10
 
 ### Patch Changes

package/dist/es/index.js

@@ -1,10 +1,7 @@
 import * as React from 'react';
 import { action } from '@storybook/addon-actions';
-import _classPrivateFieldLooseBase from '@babel/runtime/helpers/classPrivateFieldLooseBase';
-import _classPrivateFieldLooseKey from '@babel/runtime/helpers/classPrivateFieldLooseKey';
 import { InterceptRequests } from '@khanacademy/wonder-blocks-data';
 import { StaticRouter, MemoryRouter, Switch, Route } from 'react-router-dom';
-import _extends from '@babel/runtime/helpers/extends';
 
 const fixtures = Component => {
   const templateMap = new WeakMap();
@@ -13,27 +10,20 @@ const fixtures = Component => {
     log: (message, ...args) => action(message).apply(void 0, args),
     logHandler: action
   };
-
   const makeStory = (description, props, wrapper = null) => {
     const storyName = `${storyNumber++} ${description}`;
-
     const getProps = options => typeof props === "function" ? props(options) : props;
-
     const RealComponent = wrapper || Component;
     let Template = templateMap.get(RealComponent);
-
     if (Template == null) {
       Template = args => React.createElement(RealComponent, args);
-
       templateMap.set(RealComponent, Template);
     }
-
     const story = Template.bind({});
     story.args = getProps(getPropsOptions);
     story.storyName = storyName;
     return story;
   };
-
   return makeStory;
 };
 
@@ -48,10 +38,8 @@ const getHref = input => {
     throw new Error(`Unsupported input type`);
   }
 };
-
 const fetchRequestMatchesMock = (mock, input, init) => {
   const href = getHref(input);
-
   if (typeof mock === "string") {
     return href === mock;
   } else if (mock instanceof RegExp) {
@@ -63,26 +51,22 @@ const fetchRequestMatchesMock = (mock, input, init) => {
 
 const mockRequester = (operationMatcher, operationToString) => {
   const mocks = [];
-
   const mockFn = (...args) => {
     for (const mock of mocks) {
       if (mock.onceOnly && mock.used) {
         continue;
       }
-
       if (operationMatcher.apply(void 0, [mock.operation].concat(args))) {
         mock.used = true;
         return mock.response();
       }
     }
-
+    const operation = operationToString.apply(void 0, args);
     return Promise.reject(new Error(`No matching mock response found for request:
-    ${operationToString.apply(void 0, args)}`));
+    ${operation}`));
   };
-
   const addMockedOperation = (operation, response, onceOnly) => {
     const mockResponse = () => response.toPromise();
-
     mocks.push({
       operation,
       response: mockResponse,
@@ -91,104 +75,58 @@ const mockRequester = (operationMatcher, operationToString) => {
     });
     return mockFn;
   };
-
   mockFn.mockOperation = (operation, response) => addMockedOperation(operation, response, false);
-
   mockFn.mockOperationOnce = (operation, response) => addMockedOperation(operation, response, true);
-
   return mockFn;
 };
 
 const mockFetch = () => mockRequester(fetchRequestMatchesMock, (input, init) => `Input: ${typeof input === "string" ? input : JSON.stringify(input, null, 2)}
-    Options: ${init == null ? "None" : JSON.stringify(init, null, 2)}`);
+Options: ${init == null ? "None" : JSON.stringify(init, null, 2)}`);
 
 const safeHasOwnProperty = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
-
 const areObjectsEqual = (a, b) => {
   if (a === b) {
     return true;
   }
-
   if (a == null || b == null) {
     return false;
   }
-
   if (typeof a !== "object" || typeof b !== "object") {
     return false;
   }
-
   const aKeys = Object.keys(a);
   const bKeys = Object.keys(b);
-
   if (aKeys.length !== bKeys.length) {
     return false;
   }
-
   for (let i = 0; i < aKeys.length; i++) {
     const key = aKeys[i];
-
     if (!safeHasOwnProperty(b, key) || !areObjectsEqual(a[key], b[key])) {
       return false;
     }
   }
-
   return true;
 };
-
 const gqlRequestMatchesMock = (mock, operation, variables, context) => {
   if (mock.operation.id !== operation.id || mock.operation.type !== operation.type) {
     return false;
   }
-
   if (mock.variables != null) {
     if (!areObjectsEqual(mock.variables, variables)) {
       return false;
     }
   }
-
   if (mock.context != null) {
     if (!areObjectsEqual(mock.context, context)) {
       return false;
     }
   }
-
   return true;
 };
 
 const mockGqlFetch = () => mockRequester(gqlRequestMatchesMock, (operation, variables, context) => `Operation: ${operation.type} ${operation.id}
-    Variables: ${variables == null ? "None" : JSON.stringify(variables, null, 2)}
-    Context: ${JSON.stringify(context, null, 2)}`);
-
-var _settled = _classPrivateFieldLooseKey("settled");
-
-class SettleSignal extends EventTarget {
-  constructor(setSettleFn = null) {
-    super();
-    Object.defineProperty(this, _settled, {
-      writable: true,
-      value: false
-    });
-    setSettleFn == null ? void 0 : setSettleFn(() => {
-      if (_classPrivateFieldLooseBase(this, _settled)[_settled]) {
-        throw new Error("SettleSignal already settled");
-      }
-
-      _classPrivateFieldLooseBase(this, _settled)[_settled] = true;
-      this.dispatchEvent(new Event("settled"));
-    });
-  }
-
-  static settle() {
-    const signal = new SettleSignal();
-    _classPrivateFieldLooseBase(signal, _settled)[_settled] = true;
-    return signal;
-  }
-
-  get settled() {
-    return _classPrivateFieldLooseBase(this, _settled)[_settled];
-  }
-
-}
+Variables: ${variables == null ? "None" : JSON.stringify(variables, null, 2)}
+Context: ${JSON.stringify(context, null, 2)}`);
 
 const ResponseImpl = typeof Response === "undefined" ? require("node-fetch").Response : Response;
 
@@ -200,7 +138,6 @@ const textResponse = (text, statusCode, signal) => ({
     signal
   })
 });
-
 const rejectResponse = (error, signal) => ({
   toPromise: () => makeMockResponse({
     type: "reject",
@@ -208,7 +145,6 @@ const rejectResponse = (error, signal) => ({
     signal
   })
 });
-
 const RespondWith = Object.freeze({
   text: (text, statusCode = 200, signal = null) => textResponse(text, statusCode, signal),
   json: (json, signal = null) => textResponse(() => JSON.stringify(json), 200, signal),
@@ -226,7 +162,6 @@ const RespondWith = Object.freeze({
     if (statusCode < 300) {
       throw new Error(`${statusCode} is not a valid error status code`);
     }
-
     return textResponse("{}", statusCode, signal);
   },
   nonGraphQLBody: (signal = null) => textResponse(() => JSON.stringify({
@@ -239,26 +174,21 @@ const RespondWith = Object.freeze({
     }))
   }), 200, signal)
 });
-
 const callOnSettled = (signal, fn) => {
   if (signal == null || signal.settled) {
     fn();
     return;
   }
-
   const onSettled = () => {
     signal.removeEventListener("settled", onSettled);
     fn();
   };
-
   signal.addEventListener("settled", onSettled);
 };
-
 const makeMockResponse = response => {
   const {
     signal
   } = response;
-
   switch (response.type) {
     case "text":
       return new Promise((resolve, reject) => {
@@ -269,17 +199,14 @@ const makeMockResponse = response => {
           }));
         });
       });
-
     case "reject":
       return new Promise((resolve, reject) => {
         callOnSettled(signal, () => reject(response.error instanceof Error ? response.error : response.error()));
       });
-
     default:
       if (process.env.NODE_ENV !== "production") {
         throw new Error(`Unknown response type: ${response.type}`);
       }
-
       return makeMockResponse({
         type: "reject",
         error: new Error("Unknown response type"),
@@ -288,35 +215,179 @@ const makeMockResponse = response => {
   }
 };
 
-var _settleFn = _classPrivateFieldLooseKey("settleFn");
+function _typeof(obj) {
+  "@babel/helpers - typeof";
 
-var _signal = _classPrivateFieldLooseKey("signal");
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
 
-class SettleController {
-  constructor() {
-    Object.defineProperty(this, _settleFn, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _signal, {
-      writable: true,
-      value: void 0
-    });
-    _classPrivateFieldLooseBase(this, _signal)[_signal] = new SettleSignal(settleFn => _classPrivateFieldLooseBase(this, _settleFn)[_settleFn] = settleFn);
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
   }
+  return (hint === "string" ? String : Number)(input);
+}
+
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
 
-  get signal() {
-    return _classPrivateFieldLooseBase(this, _signal)[_signal];
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
   }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
 
-  settle() {
-    _classPrivateFieldLooseBase(this, _settleFn)[_settleFn]();
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
   }
+}
 
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
 }
 
-const defaultConfig$3 = null;
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+      _cache.set(Class, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+  return _wrapNativeSuper(Class);
+}
 
+let SettleSignal = function (_EventTarget) {
+  _inheritsLoose(SettleSignal, _EventTarget);
+  function SettleSignal(setSettleFn = null) {
+    var _this;
+    _this = _EventTarget.call(this) || this;
+    _this._settled = false;
+    setSettleFn == null ? void 0 : setSettleFn(() => {
+      if (_this._settled) {
+        throw new Error("SettleSignal already settled");
+      }
+      _this._settled = true;
+      _this.dispatchEvent(new Event("settled"));
+    });
+    return _this;
+  }
+  SettleSignal.settle = function settle() {
+    const signal = new SettleSignal();
+    signal._settled = true;
+    return signal;
+  };
+  _createClass(SettleSignal, [{
+    key: "settled",
+    get: function () {
+      return this._settled;
+    }
+  }]);
+  return SettleSignal;
+}(_wrapNativeSuper(EventTarget));
+
+let SettleController = function () {
+  function SettleController() {
+    this._settleFn = void 0;
+    this._signal = void 0;
+    this._signal = new SettleSignal(settleFn => this._settleFn = settleFn);
+  }
+  var _proto = SettleController.prototype;
+  _proto.settle = function settle() {
+    this._settleFn();
+  };
+  _createClass(SettleController, [{
+    key: "signal",
+    get: function () {
+      return this._signal;
+    }
+  }]);
+  return SettleController;
+}();
+
+const defaultConfig$3 = null;
 const normalizeConfig = config => {
   if (typeof config === "string") {
     return {
@@ -324,28 +395,23 @@ const normalizeConfig = config => {
       style: {}
     };
   }
-
   if (Array.isArray(config)) {
     return {
       classes: config,
       style: {}
     };
   }
-
   if (typeof config === "object") {
-    if (config.classes != null && config.style != null) {
+    if ("classes" in config && config.classes != null && "style" in config && config.style != null) {
       return config;
     }
-
     return {
       classes: [],
       style: config
     };
   }
-
   throw new Error(`Invalid config: ${config}`);
 };
-
 const adapter$3 = (children, config) => {
   const {
     classes,
@@ -362,13 +428,11 @@ const defaultConfig$2 = [];
 const adapter$2 = (children, config) => {
   let currentChildren = children;
   const interceptors = Array.isArray(config) ? config : [config];
-
   for (const interceptor of interceptors) {
     currentChildren = React.createElement(InterceptRequests, {
       interceptor: interceptor
     }, currentChildren);
   }
-
   return React.createElement(React.Fragment, null, currentChildren);
 };
 
@@ -381,12 +445,10 @@ const adapter$1 = (children, config) => React.createElement(React.Fragment, null
 const defaultConfig = {
   location: "/"
 };
-
 const maybeWithRoute = (children, path) => {
   if (path == null) {
     return children;
   }
-
   return React.createElement(Switch, null, React.createElement(Route, {
     exact: true,
     path: path
@@ -397,46 +459,37 @@ const maybeWithRoute = (children, path) => {
     }
   }));
 };
-
 const adapter = (children, config) => {
   if (typeof config === "string") {
     config = {
       location: config
     };
   }
-
   const wrappedWithRoute = maybeWithRoute(children, config.path);
-
   if (config.forceStatic) {
     return React.createElement(StaticRouter, {
       location: config.location,
       context: {}
     }, wrappedWithRoute);
   }
-
   if (typeof config.location !== "undefined") {
     return React.createElement(MemoryRouter, {
       initialEntries: [config.location]
     }, wrappedWithRoute);
   }
-
   if (typeof config.initialEntries === "undefined") {
     throw new Error("A location or initial history entries must be provided.");
   }
-
   const entries = config.initialEntries.length === 0 ? [defaultConfig.location] : config.initialEntries;
   const routerProps = {
     initialEntries: entries
   };
-
   if (config.initialIndex != null) {
     routerProps.initialIndex = config.initialIndex;
   }
-
   if (config.getUserConfirmation != null) {
     routerProps.getUserConfirmation = config.getUserConfirmation;
   }
-
   return React.createElement(MemoryRouter, routerProps, wrappedWithRoute);
 };
 
@@ -459,25 +512,36 @@ var adapters = /*#__PURE__*/Object.freeze({
     DefaultConfigs: DefaultConfigs
 });
 
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
 const renderAdapters = (adapters, configs, children) => {
   let currentChildren = children;
-
   for (const adapterName of Object.keys(adapters)) {
     const adapter = adapters[adapterName];
     const config = configs[adapterName];
-
     if (config != null) {
       currentChildren = adapter(currentChildren, config);
     }
   }
-
   return currentChildren;
 };
 
 const makeTestHarness = (adapters, defaultConfigs) => {
   return (Component, configs) => {
     const fullConfig = _extends({}, defaultConfigs, configs);
-
     const harnessedComponent = React.forwardRef((props, ref) => renderAdapters(adapters, fullConfig, React.createElement(Component, _extends({}, props, {
       ref: ref
     }))));
@@ -489,7 +553,6 @@ const makeTestHarness = (adapters, defaultConfigs) => {
 const HookHarness = ({
   children
 }) => children;
-
 const makeHookHarness = (adapters, defaultConfigs) => {
   const testHarness = makeTestHarness(adapters, defaultConfigs);
   return configs => testHarness(HookHarness, configs);

package/dist/fetch/fetch-request-matches-mock.d.ts

@@ -0,0 +1,5 @@
+import type { FetchMockOperation } from "./types";
+/**
+ * Determines if a given fetch invocation matches the given mock.
+ */
+export declare const fetchRequestMatchesMock: (mock: FetchMockOperation, input: RequestInfo, init?: RequestInit | null) => boolean;

package/dist/fetch/fetch-request-matches-mock.js.flow

@@ -0,0 +1,17 @@
+/**
+ * Flowtype definitions for fetch-request-matches-mock
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+
+import type { FetchMockOperation } from "./types";
+
+/**
+ * Determines if a given fetch invocation matches the given mock.
+ */
+declare export var fetchRequestMatchesMock: (
+  mock: FetchMockOperation,
+  input: RequestInfo,
+  init?: RequestInit | null
+) => boolean;

package/dist/fetch/mock-fetch.d.ts

@@ -0,0 +1,5 @@
+import type { FetchMockFn } from "./types";
+/**
+ * A mock for the fetch function passed to GqlRouter.
+ */
+export declare const mockFetch: () => FetchMockFn;

package/dist/fetch/mock-fetch.js.flow

@@ -0,0 +1,13 @@
+/**
+ * Flowtype definitions for mock-fetch
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+
+import type { FetchMockFn } from "./types";
+
+/**
+ * A mock for the fetch function passed to GqlRouter.
+ */
+declare export var mockFetch: () => FetchMockFn;

package/dist/fetch/types.d.ts

@@ -0,0 +1,9 @@
+import type { MockResponse } from "../respond-with";
+export type FetchMockOperation = RegExp | string;
+type FetchMockOperationFn = (operation: FetchMockOperation, response: MockResponse<any>) => FetchMockFn;
+export type FetchMockFn = {
+    (input: RequestInfo, init?: RequestInit): Promise<Response>;
+    mockOperation: FetchMockOperationFn;
+    mockOperationOnce: FetchMockOperationFn;
+};
+export {};