impact-ui 5.0.0-alpha.2 → 5.0.0-alpha.4

package/dist/node_modules/react-with-styles/node_modules/react-with-direction/dist/withDirection.js

@@ -0,0 +1,160 @@
+import { __exports as withDirection } from "../../../../../_virtual/withDirection.js";
+import React__default from "react";
+import { __require as requireHoistNonReactStatics_cjs } from "../../../../hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js";
+import { __require as requireCjs } from "../../deepmerge/dist/cjs.js";
+import { __require as requireGetComponentName } from "../../airbnb-prop-types/build/helpers/getComponentName.js";
+import { __require as requireConstants } from "./constants.js";
+import { __require as requireBrcast } from "./proptypes/brcast.js";
+import { __require as requireDirection } from "./proptypes/direction.js";
+var hasRequiredWithDirection;
+function requireWithDirection() {
+  if (hasRequiredWithDirection) return withDirection;
+  hasRequiredWithDirection = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.withDirectionPropTypes = exports.DIRECTIONS = void 0;
+    var _extends = Object.assign || 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;
+    };
+    var _createClass = /* @__PURE__ */ 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);
+        }
+      }
+      return function(Constructor, protoProps, staticProps) {
+        if (protoProps) defineProperties(Constructor.prototype, protoProps);
+        if (staticProps) defineProperties(Constructor, staticProps);
+        return Constructor;
+      };
+    }();
+    exports["default"] = withDirection2;
+    var _react = React__default;
+    var _react2 = _interopRequireDefault(_react);
+    var _hoistNonReactStatics = requireHoistNonReactStatics_cjs();
+    var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);
+    var _deepmerge = requireCjs();
+    var _deepmerge2 = _interopRequireDefault(_deepmerge);
+    var _getComponentName = requireGetComponentName();
+    var _getComponentName2 = _interopRequireDefault(_getComponentName);
+    var _constants = requireConstants();
+    var _brcast = requireBrcast();
+    var _brcast2 = _interopRequireDefault(_brcast);
+    var _direction = requireDirection();
+    var _direction2 = _interopRequireDefault(_direction);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { "default": obj };
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    function _possibleConstructorReturn(self, call) {
+      if (!self) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return call && (typeof call === "object" || typeof call === "function") ? call : self;
+    }
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });
+      if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+    }
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    var contextTypes = _defineProperty({}, _constants.CHANNEL, _brcast2["default"]);
+    exports.DIRECTIONS = _constants.DIRECTIONS;
+    var defaultDirection = _constants.DIRECTIONS.LTR;
+    exports.withDirectionPropTypes = {
+      direction: _direction2["default"].isRequired
+    };
+    function withDirection2(WrappedComponent) {
+      var WithDirection = function(_React$Component) {
+        _inherits(WithDirection2, _React$Component);
+        function WithDirection2(props, context) {
+          _classCallCheck(this, WithDirection2);
+          var _this = _possibleConstructorReturn(this, (WithDirection2.__proto__ || Object.getPrototypeOf(WithDirection2)).call(this, props, context));
+          _this.state = {
+            direction: context[_constants.CHANNEL] ? context[_constants.CHANNEL].getState() : defaultDirection
+          };
+          return _this;
+        }
+        _createClass(WithDirection2, [{
+          key: "componentDidMount",
+          value: /* @__PURE__ */ function() {
+            function componentDidMount() {
+              var _this2 = this;
+              if (this.context[_constants.CHANNEL]) {
+                this.channelUnsubscribe = this.context[_constants.CHANNEL].subscribe(function(direction) {
+                  _this2.setState({ direction });
+                });
+              }
+            }
+            return componentDidMount;
+          }()
+        }, {
+          key: "componentWillUnmount",
+          value: /* @__PURE__ */ function() {
+            function componentWillUnmount() {
+              if (this.channelUnsubscribe) {
+                this.channelUnsubscribe();
+              }
+            }
+            return componentWillUnmount;
+          }()
+        }, {
+          key: "render",
+          value: /* @__PURE__ */ function() {
+            function render() {
+              var direction = this.state.direction;
+              return _react2["default"].createElement(WrappedComponent, _extends({}, this.props, {
+                direction
+              }));
+            }
+            return render;
+          }()
+        }]);
+        return WithDirection2;
+      }(_react2["default"].Component);
+      var wrappedComponentName = (0, _getComponentName2["default"])(WrappedComponent) || "Component";
+      WithDirection.WrappedComponent = WrappedComponent;
+      WithDirection.contextTypes = contextTypes;
+      WithDirection.displayName = "withDirection(" + String(wrappedComponentName) + ")";
+      if (WrappedComponent.propTypes) {
+        WithDirection.propTypes = (0, _deepmerge2["default"])({}, WrappedComponent.propTypes);
+        delete WithDirection.propTypes.direction;
+      }
+      if (WrappedComponent.defaultProps) {
+        WithDirection.defaultProps = (0, _deepmerge2["default"])({}, WrappedComponent.defaultProps);
+      }
+      return (0, _hoistNonReactStatics2["default"])(WithDirection, WrappedComponent);
+    }
+  })(withDirection);
+  return withDirection;
+}
+export {
+  requireWithDirection as __require
+};

package/dist/node_modules/react-with-styles-interface-css/dist/index.js

@@ -1,4 +1,4 @@
-import { __exports as dist } from "../../../_virtual/index5.js";
+import { __exports as dist } from "../../../_virtual/index10.js";
 import require$$0 from "@babel/runtime/helpers/interopRequireDefault";
 import { __require as requireArray_prototype_flat } from "../../array.prototype.flat/index.js";
 import { __require as requireGlobalCache } from "../../global-cache/index.js";

package/dist/node_modules/react-with-styles-interface-css/dist/utils/constants.js

@@ -1,4 +1,4 @@
-import { __exports as constants } from "../../../../_virtual/constants.js";
+import { __exports as constants } from "../../../../_virtual/constants3.js";
 var hasRequiredConstants;
 function requireConstants() {
   if (hasRequiredConstants) return constants;

package/dist/node_modules/reflect.ownkeys/implementation.js

@@ -0,0 +1,15 @@
+import { __require as requireOwnPropertyKeys } from "../es-abstract/helpers/OwnPropertyKeys.js";
+var implementation;
+var hasRequiredImplementation;
+function requireImplementation() {
+  if (hasRequiredImplementation) return implementation;
+  hasRequiredImplementation = 1;
+  var OwnPropertyKeys = requireOwnPropertyKeys();
+  implementation = function ownKeys(o) {
+    return OwnPropertyKeys(o);
+  };
+  return implementation;
+}
+export {
+  requireImplementation as __require
+};

package/dist/node_modules/reflect.ownkeys/index.js

@@ -0,0 +1,27 @@
+import { __require as requireDefineProperties } from "../define-properties/index.js";
+import { __require as requireCallBind } from "../call-bind/index.js";
+import { __require as requireImplementation } from "./implementation.js";
+import { __require as requirePolyfill } from "./polyfill.js";
+import { __require as requireShim } from "./shim.js";
+var reflect_ownkeys;
+var hasRequiredReflect_ownkeys;
+function requireReflect_ownkeys() {
+  if (hasRequiredReflect_ownkeys) return reflect_ownkeys;
+  hasRequiredReflect_ownkeys = 1;
+  var define = requireDefineProperties();
+  var callBind = requireCallBind();
+  var implementation = requireImplementation();
+  var getPolyfill = requirePolyfill();
+  var shim = requireShim();
+  var polyfill = callBind(getPolyfill(), null);
+  define(polyfill, {
+    getPolyfill,
+    implementation,
+    shim
+  });
+  reflect_ownkeys = polyfill;
+  return reflect_ownkeys;
+}
+export {
+  requireReflect_ownkeys as __require
+};

package/dist/node_modules/reflect.ownkeys/polyfill.js

@@ -0,0 +1,18 @@
+import { __require as requireImplementation } from "./implementation.js";
+var polyfill;
+var hasRequiredPolyfill;
+function requirePolyfill() {
+  if (hasRequiredPolyfill) return polyfill;
+  hasRequiredPolyfill = 1;
+  var implementation = requireImplementation();
+  polyfill = function getPolyfill() {
+    if (typeof Reflect === "object" && typeof Reflect.ownKeys === "function") {
+      return Reflect.ownKeys;
+    }
+    return implementation;
+  };
+  return polyfill;
+}
+export {
+  requirePolyfill as __require
+};

package/dist/node_modules/reflect.ownkeys/shim.js

@@ -0,0 +1,30 @@
+import { __require as requireCreateMethodProperty } from "../es-abstract/2023/CreateMethodProperty.js";
+import { __require as requireEsSetTostringtag } from "../es-set-tostringtag/index.js";
+import { __require as requireGlobalthis } from "../globalthis/index.js";
+import { __require as requirePolyfill } from "./polyfill.js";
+var shim;
+var hasRequiredShim;
+function requireShim() {
+  if (hasRequiredShim) return shim;
+  hasRequiredShim = 1;
+  var CreateMethodProperty = requireCreateMethodProperty();
+  var setToStringTag = requireEsSetTostringtag();
+  var globalThis = requireGlobalthis()();
+  var getPolyfill = requirePolyfill();
+  shim = function shimReflectOwnKeys() {
+    if (typeof Reflect === "undefined") {
+      var R = {};
+      setToStringTag(R, "Reflect");
+      CreateMethodProperty(globalThis, "Reflect", R);
+    }
+    var polyfill = getPolyfill();
+    if (polyfill !== Reflect.ownKeys) {
+      CreateMethodProperty(Reflect, "ownKeys", polyfill);
+    }
+    return polyfill;
+  };
+  return shim;
+}
+export {
+  requireShim as __require
+};

package/dist/node_modules/safe-push-apply/index.js

@@ -0,0 +1,22 @@
+import { __require as requireType } from "../es-errors/type.js";
+import { __require as requireIsarray } from "./node_modules/isarray/index.js";
+var safePushApply;
+var hasRequiredSafePushApply;
+function requireSafePushApply() {
+  if (hasRequiredSafePushApply) return safePushApply;
+  hasRequiredSafePushApply = 1;
+  var $TypeError = requireType();
+  var isArray = requireIsarray();
+  safePushApply = function safePushApply2(target, source) {
+    if (!isArray(target)) {
+      throw new $TypeError("target must be an array");
+    }
+    for (var i = 0; i < source.length; i++) {
+      target[target.length] = source[i];
+    }
+  };
+  return safePushApply;
+}
+export {
+  requireSafePushApply as __require
+};

package/dist/node_modules/safe-push-apply/node_modules/isarray/index.js

@@ -0,0 +1,14 @@
+var isarray;
+var hasRequiredIsarray;
+function requireIsarray() {
+  if (hasRequiredIsarray) return isarray;
+  hasRequiredIsarray = 1;
+  var toString = {}.toString;
+  isarray = Array.isArray || function(arr) {
+    return toString.call(arr) == "[object Array]";
+  };
+  return isarray;
+}
+export {
+  requireIsarray as __require
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "impact-ui",
-  "version": "5.0.0-alpha.2",
+  "version": "5.0.0-alpha.4",
   "description": "Impact Analytics UI library",
   "type": "module",
   "main": "./dist/components/index.js",