victory-create-container 36.9.2-next.1 → 36.9.2

package/lib/create-container.js

@@ -3,31 +3,30 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createContainer = void 0;
-exports.makeCreateContainerFunction = makeCreateContainerFunction;
-
-var _toPairs2 = _interopRequireDefault(require("lodash/toPairs"));
+exports.makeCreateContainerFunction = exports.createContainer = exports.combineContainerMixins = void 0;
 
 var _isEmpty2 = _interopRequireDefault(require("lodash/isEmpty"));
 
-var _groupBy2 = _interopRequireDefault(require("lodash/groupBy"));
+var _flow2 = _interopRequireDefault(require("lodash/flow"));
 
 var _forOwn2 = _interopRequireDefault(require("lodash/forOwn"));
 
-var _victoryZoomContainer = require("victory-zoom-container");
-
-var _victorySelectionContainer = require("victory-selection-container");
+var _groupBy2 = _interopRequireDefault(require("lodash/groupBy"));
 
-var _react = _interopRequireDefault(require("react"));
+var _toPairs2 = _interopRequireDefault(require("lodash/toPairs"));
 
 var _victoryCore = require("victory-core");
 
 var _victoryVoronoiContainer = require("victory-voronoi-container");
 
-var _victoryCursorContainer = require("victory-cursor-container");
+var _victoryZoomContainer = require("victory-zoom-container");
+
+var _victorySelectionContainer = require("victory-selection-container");
 
 var _victoryBrushContainer = require("victory-brush-container");
 
+var _victoryCursorContainer = require("victory-cursor-container");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
@@ -44,6 +43,26 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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, 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; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
 
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -111,63 +130,94 @@ var combineDefaultEvents = function (defaultEvents) {
   return events.filter(Boolean);
 };
 
-/**
- * Container hooks are used to provide the container logic to the container components through props and a modified children object
- * - These hooks contain shared logic for both web and Victory Native containers.
- * - In this utility, we call multiple of these hooks with the props returned by the previous to combine the container logic.
- */
-var CONTAINER_HOOKS = {
-  zoom: _victoryZoomContainer.useVictoryZoomContainer,
-  selection: _victorySelectionContainer.useVictorySelectionContainer,
-  brush: _victoryBrushContainer.useVictoryBrushContainer,
-  cursor: _victoryCursorContainer.useVictoryCursorContainer,
-  voronoi: _victoryVoronoiContainer.useVictoryVoronoiContainer
+var combineContainerMixins = function (mixins, Container) {
+  var _class;
+
+  // similar to Object.assign(A, B), this function will decide conflicts in favor mixinB.
+  // this applies to propTypes and defaultProps.
+  // getChildren will call A's getChildren() and pass the resulting children to B's.
+  // defaultEvents attempts to resolve any conflicts between A and B's defaultEvents.
+  var Classes = mixins.map(function (mixin) {
+    return mixin(Container);
+  });
+  var instances = Classes.map(function (Class) {
+    return new Class();
+  });
+  var NaiveCombinedContainer = (0, _flow2.default)(mixins)(Container);
+  var displayType = Classes.map(function (Class) {
+    var match = Class.displayName.match(/Victory(.*)Container/);
+    return match[1] || "";
+  }).join("");
+  return _class = /*#__PURE__*/function (_NaiveCombinedContain) {
+    _inherits(VictoryCombinedContainer, _NaiveCombinedContain);
+
+    var _super = _createSuper(VictoryCombinedContainer);
+
+    function VictoryCombinedContainer() {
+      _classCallCheck(this, VictoryCombinedContainer);
+
+      return _super.apply(this, arguments);
+    }
+
+    _createClass(VictoryCombinedContainer, [{
+      key: "getChildren",
+      value: function getChildren(props) {
+        return instances.reduce(function (children, instance) {
+          return instance.getChildren(_objectSpread(_objectSpread({}, props), {}, {
+            children: children
+          }));
+        }, props.children);
+      }
+    }]);
+
+    return VictoryCombinedContainer;
+  }(NaiveCombinedContainer), _class.displayName = "Victory".concat(displayType, "Container"), _class.propTypes = Classes.reduce(function (propTypes, Class) {
+    return _objectSpread(_objectSpread({}, propTypes), Class.propTypes);
+  }, {}), _class.defaultProps = Classes.reduce(function (defaultProps, Class) {
+    return _objectSpread(_objectSpread({}, defaultProps), Class.defaultProps);
+  }, {}), _class.defaultEvents = function (props) {
+    return combineDefaultEvents(Classes.reduce(function (defaultEvents, Class) {
+      var events = _victoryCore.Helpers.isFunction(Class.defaultEvents) ? Class.defaultEvents(props) : Class.defaultEvents;
+      return [].concat(_toConsumableArray(defaultEvents), _toConsumableArray(events));
+    }, []));
+  }, _class;
 };
-/**
- * Container hooks are wrappers that return a VictoryContainer with the props provided by their respective hooks, and the modified children.
- * - These containers are specific to the web. Victory Native has its own container components.
- * - For this utility, we only need the container components to extract the defaultEvents.
- */
-
-var CONTAINER_COMPONENTS = {
-  zoom: _victoryZoomContainer.VictoryZoomContainer,
-  selection: _victorySelectionContainer.VictorySelectionContainer,
-  brush: _victoryBrushContainer.VictoryBrushContainer,
-  cursor: _victoryCursorContainer.VictoryCursorContainer,
-  voronoi: _victoryVoronoiContainer.VictoryVoronoiContainer
+
+exports.combineContainerMixins = combineContainerMixins;
+
+var checkBehaviorName = function (behavior, behaviors) {
+  if (behavior && !behaviors.includes(behavior)) {
+    _victoryCore.Log.warn("\"".concat(behavior, "\" is not a valid behavior. Choose from [").concat(behaviors.join(", "), "]."));
+  }
 };
 
-function makeCreateContainerFunction(containerComponents, VictoryContainerBase) {
-  return function combineContainers(containerA, containerB) {
-    var ContainerA = containerComponents[containerA];
-    var ContainerB = containerComponents[containerB];
-    var useContainerA = CONTAINER_HOOKS[containerA];
-    var useContainerB = CONTAINER_HOOKS[containerB];
-
-    var CombinedContainer = function (props) {
-      var _useContainerA = useContainerA(props),
-          childrenA = _useContainerA.children,
-          propsA = _useContainerA.props;
-
-      var _useContainerB = useContainerB(_objectSpread(_objectSpread({}, propsA), {}, {
-        children: childrenA
-      })),
-          combinedChildren = _useContainerB.children,
-          combinedProps = _useContainerB.props;
-
-      return /*#__PURE__*/_react.default.createElement(VictoryContainerBase, combinedProps, combinedChildren);
-    };
+var makeCreateContainerFunction = function (mixinMap, Container) {
+  return function (behaviorA, behaviorB) {
+    var behaviors = Object.keys(mixinMap);
+    checkBehaviorName(behaviorA, behaviors);
+    checkBehaviorName(behaviorB, behaviors);
 
-    CombinedContainer.displayName = "Victory".concat(containerA).concat(containerB, "Container");
-    CombinedContainer.role = "container";
+    if (arguments.length <= 2 ? 0 : arguments.length - 2) {
+      _victoryCore.Log.warn("too many arguments given to createContainer (maximum accepted: 2).");
+    }
 
-    CombinedContainer.defaultEvents = function (props) {
-      return combineDefaultEvents([].concat(_toConsumableArray(ContainerA.defaultEvents(props)), _toConsumableArray(ContainerB.defaultEvents(props))));
-    };
+    var firstMixins = mixinMap[behaviorA];
+    var secondMixins = mixinMap[behaviorB] || [];
 
-    return CombinedContainer;
+    if (!firstMixins) {
+      return Container;
+    }
+
+    return combineContainerMixins([].concat(_toConsumableArray(firstMixins), _toConsumableArray(secondMixins)), Container);
   };
-}
+};
 
-var createContainer = makeCreateContainerFunction(CONTAINER_COMPONENTS, _victoryCore.VictoryContainer);
+exports.makeCreateContainerFunction = makeCreateContainerFunction;
+var createContainer = makeCreateContainerFunction({
+  zoom: [_victoryZoomContainer.zoomContainerMixin],
+  voronoi: [_victoryVoronoiContainer.voronoiContainerMixin],
+  selection: [_victorySelectionContainer.selectionContainerMixin],
+  cursor: [_victoryCursorContainer.cursorContainerMixin],
+  brush: [_victoryBrushContainer.brushContainerMixin]
+}, _victoryCore.VictoryContainer);
 exports.createContainer = createContainer;

package/lib/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./create-container";
+export * from "./create-container";
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "victory-create-container",
-  "version": "36.9.2-next.1",
+  "version": "36.9.2",
   "description": "Container Helper for Victory",
   "keywords": [
     "data visualization",
@@ -12,7 +12,7 @@
     "type": "git",
     "url": "https://github.com/FormidableLabs/victory"
   },
-  "homepage": "https://formidable.com/open-source/victory",
+  "homepage": "https://commerce.nearform.com/open-source/victory",
   "sideEffects": false,
   "main": "lib/index.js",
   "module": "es/index.js",
@@ -21,16 +21,19 @@
   "license": "MIT",
   "dependencies": {
     "lodash": "^4.17.19",
-    "victory-brush-container": "^36.9.2-next.1",
-    "victory-core": "^36.9.2-next.1",
-    "victory-cursor-container": "^36.9.2-next.1",
-    "victory-selection-container": "^36.9.2-next.1",
-    "victory-voronoi-container": "^36.9.2-next.1",
-    "victory-zoom-container": "^36.9.2-next.1"
+    "victory-brush-container": "^36.9.2",
+    "victory-core": "^36.9.2",
+    "victory-cursor-container": "^36.9.2",
+    "victory-selection-container": "^36.9.2",
+    "victory-voronoi-container": "^36.9.2",
+    "victory-zoom-container": "^36.9.2"
   },
   "peerDependencies": {
     "react": ">=16.6.0"
   },
+  "publishConfig": {
+    "provenance": true
+  },
   "wireit": {
     "###            THESE WIREIT CONFIGS ARE GENERATED        ####": {},
     "###            DO NOT MODIFY THESE MANUALLY              ####": {},

package/src/create-container.ts

@@ -0,0 +1,173 @@
+import React from "react";
+import { toPairs, groupBy, forOwn, flow, isEmpty } from "lodash";
+import { Helpers, VictoryContainer, Log } from "victory-core";
+import { voronoiContainerMixin } from "victory-voronoi-container";
+import { zoomContainerMixin } from "victory-zoom-container";
+import { selectionContainerMixin } from "victory-selection-container";
+import { brushContainerMixin } from "victory-brush-container";
+import { cursorContainerMixin } from "victory-cursor-container";
+
+export type ContainerType =
+  | "brush"
+  | "cursor"
+  | "selection"
+  | "voronoi"
+  | "zoom";
+
+type MixinFunction = (...args: any[]) => any;
+
+function ensureArray<T>(thing: T): [] | T | T[] {
+  if (!thing) {
+    return [];
+  } else if (!Array.isArray(thing)) {
+    return [thing];
+  }
+  return thing;
+}
+
+const combineEventHandlers = (eventHandlersArray: any[]) => {
+  // takes an array of event handler objects and produces one eventHandlers object
+  // creates a custom combinedHandler() for events with multiple conflicting handlers
+  return eventHandlersArray.reduce((localHandlers, finalHandlers) => {
+    forOwn(localHandlers, (localHandler, eventName) => {
+      const existingHandler = finalHandlers[eventName];
+      if (existingHandler) {
+        // create new handler for event that concats the existing handler's mutations with new ones
+        finalHandlers[eventName] = function combinedHandler(...params) {
+          // named for debug clarity
+          // sometimes handlers return undefined; use empty array instead, for concat()
+          const existingMutations = ensureArray(existingHandler(...params));
+          const localMutations = ensureArray(localHandler(...params));
+          return existingMutations.concat(localMutations);
+        };
+      } else {
+        finalHandlers[eventName] = localHandler;
+      }
+    });
+    return finalHandlers;
+  });
+};
+
+const combineDefaultEvents = (defaultEvents: any[]) => {
+  // takes a defaultEvents array and returns one equal or lesser length,
+  // by combining any events that have the same target
+  const eventsByTarget = groupBy(defaultEvents, "target");
+  const events = toPairs(eventsByTarget).map(([target, eventsArray]) => {
+    const newEventsArray = eventsArray.filter(Boolean);
+    return isEmpty(newEventsArray)
+      ? null
+      : {
+          target,
+          eventHandlers: combineEventHandlers(
+            eventsArray.map((event) => event.eventHandlers),
+          ),
+          // note: does not currently handle eventKey or childName
+        };
+  });
+  return events.filter(Boolean);
+};
+
+export const combineContainerMixins = (
+  mixins: MixinFunction[],
+  Container: React.ComponentType<any>,
+) => {
+  // similar to Object.assign(A, B), this function will decide conflicts in favor mixinB.
+  // this applies to propTypes and defaultProps.
+  // getChildren will call A's getChildren() and pass the resulting children to B's.
+  // defaultEvents attempts to resolve any conflicts between A and B's defaultEvents.
+  const Classes = mixins.map((mixin) => mixin(Container));
+  const instances = Classes.map((Class) => new Class());
+  const NaiveCombinedContainer = flow(mixins)(Container);
+
+  const displayType = Classes.map((Class) => {
+    const match = Class.displayName.match(/Victory(.*)Container/);
+    return match[1] || "";
+  }).join("");
+
+  return class VictoryCombinedContainer extends NaiveCombinedContainer {
+    static displayName = `Victory${displayType}Container`;
+
+    static propTypes = Classes.reduce(
+      (propTypes, Class) => ({ ...propTypes, ...Class.propTypes }),
+      {},
+    );
+
+    static defaultProps = Classes.reduce(
+      (defaultProps, Class) => ({ ...defaultProps, ...Class.defaultProps }),
+      {},
+    );
+
+    static defaultEvents = (props) => {
+      return combineDefaultEvents(
+        Classes.reduce((defaultEvents, Class) => {
+          const events = Helpers.isFunction(Class.defaultEvents)
+            ? Class.defaultEvents(props)
+            : Class.defaultEvents;
+          return [...defaultEvents, ...events];
+        }, []),
+      );
+    };
+
+    getChildren(props) {
+      return instances.reduce(
+        (children, instance) => instance.getChildren({ ...props, children }),
+        props.children,
+      );
+    }
+  };
+};
+
+const checkBehaviorName = (
+  behavior: ContainerType,
+  behaviors: ContainerType[],
+) => {
+  if (behavior && !behaviors.includes(behavior)) {
+    Log.warn(
+      `"${behavior}" is not a valid behavior. Choose from [${behaviors.join(
+        ", ",
+      )}].`,
+    );
+  }
+};
+
+export const makeCreateContainerFunction =
+  (
+    mixinMap: Record<ContainerType, MixinFunction[]>,
+    Container: React.ComponentType<any>,
+  ) =>
+  (
+    behaviorA: ContainerType,
+    behaviorB: ContainerType,
+    ...invalid: ContainerType[]
+  ) => {
+    const behaviors = Object.keys(mixinMap) as ContainerType[];
+
+    checkBehaviorName(behaviorA, behaviors);
+    checkBehaviorName(behaviorB, behaviors);
+
+    if (invalid.length) {
+      Log.warn(
+        "too many arguments given to createContainer (maximum accepted: 2).",
+      );
+    }
+
+    const firstMixins = mixinMap[behaviorA];
+    const secondMixins = mixinMap[behaviorB] || [];
+
+    if (!firstMixins) {
+      return Container;
+    }
+
+    return combineContainerMixins([...firstMixins, ...secondMixins], Container);
+  };
+
+export const createContainer = makeCreateContainerFunction(
+  {
+    zoom: [zoomContainerMixin],
+    voronoi: [voronoiContainerMixin],
+    selection: [selectionContainerMixin],
+    cursor: [cursorContainerMixin],
+    brush: [brushContainerMixin],
+  },
+  VictoryContainer,
+);

package/dist/victory-create-container.min.js.LICENSE.txt

@@ -1,19 +0,0 @@
-/**
- * @license React
- * react-dom.production.min.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-/**
- * @license React
- * scheduler.production.min.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */

package/src/create-container.tsx

@@ -1,169 +0,0 @@
-import {
-  VictoryZoomContainer,
-  useVictoryZoomContainer,
-} from "victory-zoom-container";
-import {
-  VictorySelectionContainer,
-  useVictorySelectionContainer,
-} from "victory-selection-container";
-import React from "react";
-import { VictoryContainer } from "victory-core";
-import { forOwn, groupBy, isEmpty, toPairs } from "lodash";
-import {
-  VictoryVoronoiContainer,
-  useVictoryVoronoiContainer,
-} from "victory-voronoi-container";
-import {
-  VictoryCursorContainer,
-  useVictoryCursorContainer,
-} from "victory-cursor-container";
-import {
-  VictoryBrushContainer,
-  useVictoryBrushContainer,
-} from "victory-brush-container";
-
-function ensureArray<T>(thing: T): [] | T | T[] {
-  if (!thing) {
-    return [];
-  } else if (!Array.isArray(thing)) {
-    return [thing];
-  }
-  return thing;
-}
-
-const combineEventHandlers = (eventHandlersArray: any[]) => {
-  // takes an array of event handler objects and produces one eventHandlers object
-  // creates a custom combinedHandler() for events with multiple conflicting handlers
-  return eventHandlersArray.reduce((localHandlers, finalHandlers) => {
-    forOwn(localHandlers, (localHandler, eventName) => {
-      const existingHandler = finalHandlers[eventName];
-      if (existingHandler) {
-        // create new handler for event that concats the existing handler's mutations with new ones
-        finalHandlers[eventName] = function combinedHandler(...params) {
-          // named for debug clarity
-          // sometimes handlers return undefined; use empty array instead, for concat()
-          const existingMutations = ensureArray(existingHandler(...params));
-          const localMutations = ensureArray(localHandler(...params));
-          return existingMutations.concat(localMutations);
-        };
-      } else {
-        finalHandlers[eventName] = localHandler;
-      }
-    });
-    return finalHandlers;
-  });
-};
-
-const combineDefaultEvents = (defaultEvents: any[]) => {
-  // takes a defaultEvents array and returns one equal or lesser length,
-  // by combining any events that have the same target
-  const eventsByTarget = groupBy(defaultEvents, "target");
-  const events = toPairs(eventsByTarget).map(([target, eventsArray]) => {
-    const newEventsArray = eventsArray.filter(Boolean);
-    return isEmpty(newEventsArray)
-      ? null
-      : {
-          target,
-          eventHandlers: combineEventHandlers(
-            eventsArray.map((event) => event.eventHandlers),
-          ),
-          // note: does not currently handle eventKey or childName
-        };
-  });
-  return events.filter(Boolean);
-};
-
-export type ContainerType =
-  | "zoom"
-  | "selection"
-  | "brush"
-  | "cursor"
-  | "voronoi";
-
-/**
- * Container hooks are used to provide the container logic to the container components through props and a modified children object
- * - These hooks contain shared logic for both web and Victory Native containers.
- * - In this utility, we call multiple of these hooks with the props returned by the previous to combine the container logic.
- */
-const CONTAINER_HOOKS = {
-  zoom: useVictoryZoomContainer,
-  selection: useVictorySelectionContainer,
-  brush: useVictoryBrushContainer,
-  cursor: useVictoryCursorContainer,
-  voronoi: useVictoryVoronoiContainer,
-};
-
-/**
- * Container hooks are wrappers that return a VictoryContainer with the props provided by their respective hooks, and the modified children.
- * - These containers are specific to the web. Victory Native has its own container components.
- * - For this utility, we only need the container components to extract the defaultEvents.
- */
-const CONTAINER_COMPONENTS = {
-  zoom: VictoryZoomContainer,
-  selection: VictorySelectionContainer,
-  brush: VictoryBrushContainer,
-  cursor: VictoryCursorContainer,
-  voronoi: VictoryVoronoiContainer,
-};
-
-type ContainerComponents = Record<
-  ContainerType,
-  React.ComponentType<any> & {
-    defaultEvents: (props: any) => any[];
-  }
->;
-
-export function makeCreateContainerFunction<
-  TContainerComponents extends ContainerComponents,
->(
-  containerComponents: TContainerComponents,
-  VictoryContainerBase: typeof VictoryContainer,
-) {
-  type ContainerProps<T extends ContainerType> = React.ComponentProps<
-    TContainerComponents[T]
-  >;
-
-  return function combineContainers<
-    TContainerA extends ContainerType,
-    TContainerB extends ContainerType,
-  >(containerA: TContainerA, containerB: TContainerB) {
-    const ContainerA = containerComponents[containerA];
-    const ContainerB = containerComponents[containerB];
-    const useContainerA = CONTAINER_HOOKS[containerA];
-    const useContainerB = CONTAINER_HOOKS[containerB];
-
-    const CombinedContainer = (
-      props: ContainerProps<TContainerA> & ContainerProps<TContainerB>,
-    ) => {
-      const { children: childrenA, props: propsA } = useContainerA(props);
-      const { children: combinedChildren, props: combinedProps } =
-        useContainerB({
-          ...propsA,
-          children: childrenA,
-        });
-
-      return (
-        <VictoryContainerBase {...combinedProps}>
-          {combinedChildren}
-        </VictoryContainerBase>
-      );
-    };
-
-    CombinedContainer.displayName = `Victory${containerA}${containerB}Container`;
-    CombinedContainer.role = "container";
-    CombinedContainer.defaultEvents = (
-      props: ContainerProps<TContainerA> & ContainerProps<TContainerB>,
-    ) =>
-      combineDefaultEvents([
-        ...ContainerA.defaultEvents(props),
-        ...ContainerB.defaultEvents(props),
-      ]);
-
-    return CombinedContainer;
-  };
-}
-
-export const createContainer = makeCreateContainerFunction(
-  CONTAINER_COMPONENTS,
-  VictoryContainer,
-);