@sproutsocial/racine 24.2.0 → 25.0.1

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Change Log
 
+## 25.0.1
+
+### Patch Changes
+
+- 57648a5: All packages now depend on the latest seed component builds
+- Updated dependencies [57648a5]
+  - @sproutsocial/seeds-react-theme-provider@1.1.1
+  - @sproutsocial/seeds-react-partner-logo@1.2.1
+  - @sproutsocial/seeds-react-system-props@3.0.1
+  - @sproutsocial/seeds-react-utilities@4.0.1
+  - @sproutsocial/seeds-border@1.6.2
+  - @sproutsocial/seeds-react-button@1.1.1
+  - @sproutsocial/seeds-react-mixins@3.0.1
+  - @sproutsocial/seeds-react-popout@1.2.1
+  - @sproutsocial/seeds-react-switch@1.1.1
+  - @sproutsocial/seeds-react-hooks@3.0.1
+  - @sproutsocial/seeds-react-theme@2.0.1
+  - @sproutsocial/seeds-react-icon@1.1.1
+  - @sproutsocial/seeds-react-box@1.1.1
+
+## 25.0.0
+
+### Major Changes
+
+- 8f63add: Discontinuation of Flow Type System
+
+  We have officially discontinued the use of the Flow type system in `@sproutsocial/racine`. All Flow types have been removed from the codebase as part of this major release.
+
+  To continue using `@sproutsocial/racine`, please ensure your projects have migrated away from Flow and are now using TypeScript.
+
+### Patch Changes
+
+- bd717d0: # Allows overrides to Avatar border prop
+  - Before this change, Avatar component accepted a `border` prop as one of its system props, however it did not have any effect due to a default border style in the component.
+  - With this change, Avatar now allows `border` prop overrides.
+  - The `border` prop accepts system values `500`, `600`, and `700` for `1px solid`, `2px solid`, and `3px solid`, respectively. Valid strings such as `'1px dashed'` or `'4px solid'` are also accepted.
+- 63beb74: Update displayUnits prop on Duration component to account for partial durations with missing display units
+- Updated dependencies [8f63add]
+- Updated dependencies [15009dd]
+  - @sproutsocial/seeds-react-system-props@3.0.0
+  - @sproutsocial/seeds-react-utilities@4.0.0
+  - @sproutsocial/seeds-react-mixins@3.0.0
+  - @sproutsocial/seeds-react-hooks@3.0.0
+  - @sproutsocial/seeds-react-theme@2.0.0
+  - @sproutsocial/seeds-border@1.6.1
+
 ## 24.2.0
 
 ### Minor Changes

package/codemods/__tests__/icon-library.test.js

@@ -4,13 +4,7 @@ const transform = require("../icon-library");
 
 describe("icon-library codemod", () => {
   function createTest(testName, input, output, options = {}) {
-    return defineInlineTest(
-      transform,
-      { parser: "flow", ...options },
-      input,
-      output,
-      testName
-    );
+    return defineInlineTest(transform, { ...options }, input, output, testName);
   }
 
   createTest(
@@ -173,11 +167,11 @@ const iconType = typeof Icon;
 
   createTest(
     "Retain first comments when Icon import is removed",
-    `// @flow
+    `
 import { Icon } from '@sproutsocial/racine';
 
 <Icon name={iconName} />`,
-    `// @flow
+    `
 import { IconShim } from 'script/core/react/IconShim';
 
 <IconShim name={iconName} />
@@ -190,7 +184,7 @@ import { IconShim } from 'script/core/react/IconShim';
 
   createTest(
     "Retain first comments and add new comments",
-    `// @flow
+    `//
 import { Badge, Icon } from '@sproutsocial/racine';
 
 <>
@@ -198,7 +192,7 @@ import { Badge, Icon } from '@sproutsocial/racine';
   <Icon name='not-a-real-name' />
   <Badge iconName={iconName} />
 </>`,
-    `// @flow
+    `//
 /*TODO (icon-library codemod): Please manually migrate icon names passed to 2 component(s) in this file.
    Look for usages of these components: Icon, Badge*/
 import { Badge, Icon } from '@sproutsocial/racine';

package/commonjs/Avatar/Avatar.js

@@ -11,6 +11,7 @@ var _styledComponents = _interopRequireWildcard(require("styled-components"));
 var _Box = _interopRequireDefault(require("../Box"));
 var _Image = _interopRequireDefault(require("../Image"));
 var _Text = _interopRequireDefault(require("../Text"));
+var _seedsReactSystemProps = require("@sproutsocial/seeds-react-system-props");
 var _jsxRuntime = require("react/jsx-runtime");
 var _excluded = ["fontSize"],
   _excluded2 = ["appearance", "name", "src", "type", "size", "bg", "color", "initials"];
@@ -51,14 +52,14 @@ var AvatarText = (0, _styledComponents.default)(function (_ref) {
 var Container = (0, _styledComponents.default)(_Box.default).withConfig({
   displayName: "Avatar__Container",
   componentId: "sc-1ffu253-1"
-})(["", ""], function (_ref3) {
+})(["", " ", ""], function (_ref3) {
   var theme = _ref3.theme,
     $type = _ref3.$type,
     bg = _ref3.bg,
     borderColor = _ref3.borderColor,
     $displayFallback = _ref3.$displayFallback;
   return (0, _styledComponents.css)(["background:", ";border:", ";border-color:", ";color:", ";"], $displayFallback ? bg ? bg : theme.colors.container.background.decorative[$type] : "none", $displayFallback ? "1px solid" : "none", borderColor ? borderColor : theme.colors.container.border.decorative[$type], theme.colors.text.decorative[$type]);
-});
+}, _seedsReactSystemProps.BORDER);
 var getInitials = function getInitials(name) {
   var fallback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "?";
   if (!name || typeof name !== "string") return fallback;

package/commonjs/Duration/Duration.js

@@ -1,6 +1,5 @@
 "use strict";
 
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -16,38 +15,12 @@ var _jsxRuntime = require("react/jsx-runtime");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-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; }
-var getLowestUnit = function getLowestUnit(displayUnits) {
-  return _toConsumableArray(_constants2.ORDERED_UNITS).reverse().find(function (unit) {
-    return displayUnits[unit];
-  }) || _constants2.UNITS.milliseconds;
-};
-var splitMillisecondsIntoUnits = function splitMillisecondsIntoUnits(milliseconds, displayUnits) {
-  var lowestUnit = getLowestUnit(displayUnits);
-  var remainder = milliseconds % _constants2.MILLISECONDS_IN[lowestUnit];
-  if (2 * remainder >= _constants2.MILLISECONDS_IN[lowestUnit]) {
-    // if the remainder is large, add enough seconds to increse the lowest unit
-    milliseconds += _constants2.MILLISECONDS_IN[lowestUnit] - remainder;
-  }
-  var units = {};
-  _constants2.ORDERED_UNITS.forEach(function (unit) {
-    if (displayUnits[unit]) {
-      units[unit] = Math.floor(milliseconds / _constants2.MILLISECONDS_IN[unit]);
-      milliseconds -= units[unit] * _constants2.MILLISECONDS_IN[unit];
-    }
-  });
-  return units;
-};
 var _createDurationFormatter = function _createDurationFormatter(locale, unitDisplay, displayUnits) {
   var timeUnitFormatter = function timeUnitFormatter(locale, unit, unitDisplay) {
     return Intl.NumberFormat(locale, {
@@ -62,13 +35,13 @@ var _createDurationFormatter = function _createDurationFormatter(locale, unitDis
     type: "unit"
   });
   return function (value) {
-    var lowestUnit = getLowestUnit(displayUnits);
+    var lowestUnit = (0, _utils.getLowestUnit)(displayUnits);
 
     // if the value is zero or negative, we just want to return 0 for the lowest unit (ex "0 minutes")
     if (value <= 0) {
       return formatterByUnit[lowestUnit](0);
     }
-    var millisecondsByUnit = splitMillisecondsIntoUnits(value, displayUnits);
+    var millisecondsByUnit = (0, _utils.splitMillisecondsIntoUnits)(value, displayUnits);
     var list = [];
     _constants2.ORDERED_UNITS.forEach(function (unit) {
       if (unit in millisecondsByUnit) {

package/commonjs/Duration/utils.js

@@ -3,11 +3,36 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isValidNumber = exports.getDurationMaxDisplayUnits = void 0;
+exports.splitMillisecondsIntoUnits = exports.isValidNumber = exports.getLowestUnit = exports.getDurationMaxDisplayUnits = void 0;
 var _constants = require("./constants");
 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 _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; }
+var getLowestUnit = exports.getLowestUnit = function getLowestUnit(displayUnits) {
+  return _toConsumableArray(_constants.ORDERED_UNITS).reverse().find(function (unit) {
+    return displayUnits[unit];
+  }) || _constants.UNITS.milliseconds;
+};
+var splitMillisecondsIntoUnits = exports.splitMillisecondsIntoUnits = function splitMillisecondsIntoUnits(milliseconds, displayUnits) {
+  var lowestUnit = getLowestUnit(displayUnits);
+  var remainder = milliseconds % _constants.MILLISECONDS_IN[lowestUnit];
+  if (2 * remainder >= _constants.MILLISECONDS_IN[lowestUnit]) {
+    // if the remainder is large, add enough seconds to increse the lowest unit
+    milliseconds += _constants.MILLISECONDS_IN[lowestUnit] - remainder;
+  }
+  var units = {};
+  _constants.ORDERED_UNITS.forEach(function (unit) {
+    if (displayUnits[unit]) {
+      units[unit] = Math.floor(milliseconds / _constants.MILLISECONDS_IN[unit]);
+      milliseconds -= units[unit] * _constants.MILLISECONDS_IN[unit];
+    }
+  });
+  return units;
+};
 var isValidNumber = exports.isValidNumber = function isValidNumber(value) {
   return typeof value === "number" && isFinite(value);
 };
@@ -29,7 +54,16 @@ var getDurationMaxDisplayUnits = exports.getDurationMaxDisplayUnits = function g
       }
 
       // @ts-expect-error - stupid typescript isn't smart enough to check the isValidNumber check above ¯\_(ツ)_/¯
-      if (milliseconds > _constants.MILLISECONDS_IN[unit]) {
+      var millisecondsByUnit = splitMillisecondsIntoUnits(milliseconds, {
+        days: true,
+        hours: true,
+        minutes: true,
+        seconds: true,
+        milliseconds: true
+      });
+
+      // @ts-expect-error - stupid typescript isn't smart enough to check the isValidNumber check above ¯\_(ツ)_/¯
+      if (milliseconds > _constants.MILLISECONDS_IN[unit] && millisecondsByUnit[unit] > 0) {
         displayUnits[unit] = true;
       }
     }

package/commonjs/themes/light/theme.js

@@ -369,10 +369,14 @@ var radii = exports.radii = {
   pill: _seedsBorder.default.BORDER_RADIUS_1000
 };
 var borders = exports.borders = {
-  500: "".concat(_seedsBorder.default.BORDER_WIDTH_500, " solid")
+  500: "".concat(_seedsBorder.default.BORDER_WIDTH_500, " solid"),
+  600: "".concat(_seedsBorder.default.BORDER_WIDTH_600, " solid"),
+  700: "".concat(_seedsBorder.default.BORDER_WIDTH_700, " solid")
 };
 var borderWidths = exports.borderWidths = {
-  500: _seedsBorder.default.BORDER_WIDTH_500
+  500: _seedsBorder.default.BORDER_WIDTH_500,
+  600: _seedsBorder.default.BORDER_WIDTH_600,
+  700: _seedsBorder.default.BORDER_WIDTH_700
 };
 var shadows = exports.shadows = {
   low: "".concat(_seedsDepth.default.ELEVATION_LEVEL_100, " ").concat(_seedsColor.default.COLOR_NEUTRAL_900, "3D"),

package/dist/types/Avatar/Avatar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Avatar.d.ts","sourceRoot":"","sources":["../../../src/Avatar/Avatar.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAO/B,OAAO,KAAK,EACV,eAAe,EAEf,cAAc,EACf,MAAM,eAAe,CAAC;AAoCvB,eAAO,MAAM,cAAc,SACnB,MAAM,QACN,cAAc,KACnB,cAuBF,CAAC;AAEF,eAAO,MAAM,MAAM,wEAUhB,eAAe,4CAqDjB,CAAC;wHArDC,eAAe;AAsDlB,wBAA4B"}
+{"version":3,"file":"Avatar.d.ts","sourceRoot":"","sources":["../../../src/Avatar/Avatar.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAO/B,OAAO,KAAK,EACV,eAAe,EAEf,cAAc,EACf,MAAM,eAAe,CAAC;AAwCvB,eAAO,MAAM,cAAc,SACnB,MAAM,QACN,cAAc,KACnB,cAuBF,CAAC;AAEF,eAAO,MAAM,MAAM,wEAUhB,eAAe,4CAqDjB,CAAC;wHArDC,eAAe;AAsDlB,wBAA4B"}

package/dist/types/Duration/Duration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Duration.d.ts","sourceRoot":"","sources":["../../../src/Duration/Duration.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAiB/B,OAAO,KAAK,EACV,iBAAiB,EAIlB,MAAM,iBAAiB,CAAC;AAmJzB,eAAO,MAAM,cAAc,UAAW,iBAAiB,KAAG,MAEzD,CAAC;AAEF,QAAA,MAAM,QAAQ,UAAW,iBAAiB,oBAEzC,CAAC;AAEF,eAAe,QAAQ,CAAC"}
+{"version":3,"file":"Duration.d.ts","sourceRoot":"","sources":["../../../src/Duration/Duration.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAgB/B,OAAO,KAAK,EACV,iBAAiB,EAIlB,MAAM,iBAAiB,CAAC;AAqHzB,eAAO,MAAM,cAAc,UAAW,iBAAiB,KAAG,MAEzD,CAAC;AAEF,QAAA,MAAM,QAAQ,UAAW,iBAAiB,oBAEzC,CAAC;AAEF,eAAe,QAAQ,CAAC"}

package/dist/types/Duration/utils.d.ts

@@ -1,4 +1,12 @@
 import type { TypeDurationDisplayUnits, TypeDurationMilliseconds } from "./DurationTypes";
+export declare const getLowestUnit: (displayUnits: TypeDurationDisplayUnits) => string;
+export declare const splitMillisecondsIntoUnits: (milliseconds: number, displayUnits: TypeDurationDisplayUnits) => {
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+    milliseconds?: number;
+};
 export declare const isValidNumber: (value: unknown) => boolean;
 export interface TypeGetDurationMaxDisplayUnitsProps {
     milliseconds: TypeDurationMilliseconds;

package/dist/types/Duration/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/Duration/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,iBAAiB,CAAC;AAGzB,eAAO,MAAM,aAAa,UAAW,OAAO,KAAG,OACD,CAAC;AAE/C,MAAM,WAAW,mCAAmC;IAClD,YAAY,EAAE,wBAAwB,CAAC;IACvC,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,0BAA0B,uCAGpC,mCAAmC,KAAG,wBAmBxC,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/Duration/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,iBAAiB,CAAC;AAGzB,eAAO,MAAM,aAAa,iBAAkB,wBAAwB,WAEhD,CAAC;AAErB,eAAO,MAAM,0BAA0B,iBACvB,MAAM,gBACN,wBAAwB,KACrC;IACD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;CAoBvB,CAAC;AAEF,eAAO,MAAM,aAAa,UAAW,OAAO,KAAG,OACD,CAAC;AAE/C,MAAM,WAAW,mCAAmC;IAClD,YAAY,EAAE,wBAAwB,CAAC;IACvC,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,0BAA0B,uCAGpC,mCAAmC,KAAG,wBA4BxC,CAAC"}

package/dist/types/themes/dark/theme.d.ts

@@ -588,9 +588,13 @@ declare const darkTheme: {
     };
     borders: {
         500: string;
+        600: string;
+        700: string;
     };
     borderWidths: {
         500: string;
+        600: string;
+        700: string;
     };
     easing: {
         ease_in: string;

package/dist/types/themes/dark/theme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../../../src/themes/dark/theme.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,OAAO;;;;CAInB,CAAC;AAgPF,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA7NT,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;gBAyBnD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA2IrD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8DtD,CAAC;AAEF,eAAe,SAAS,CAAC"}
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../../../src/themes/dark/theme.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,OAAO;;;;CAInB,CAAC;AAgPF,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA7NT,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;gBAyBnD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA2IrD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8DtD,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/dist/types/themes/light/theme.d.ts

@@ -72,9 +72,13 @@ export declare const radii: {
 };
 export declare const borders: {
     500: string;
+    600: string;
+    700: string;
 };
 export declare const borderWidths: {
     500: string;
+    600: string;
+    700: string;
 };
 export declare const shadows: {
     low: string;
@@ -670,9 +674,13 @@ declare const theme: {
     };
     borders: {
         500: string;
+        600: string;
+        700: string;
     };
     borderWidths: {
         500: string;
+        600: string;
+        700: string;
     };
     shadows: {
         low: string;

package/dist/types/themes/light/theme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../../../src/themes/light/theme.ts"],"names":[],"mappings":"AA6BA,eAAO,MAAM,WAAW,UAA0C,CAAC;AAyRnE,eAAO,MAAM,UAAU;;;;;;;;;;;;;CAatB,CAAC;AAEF,eAAO,MAAM,SAAS;;;;;;;;;;;;;CAarB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAavB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC;AAE1C,eAAO,MAAM,UAAU,QAA+B,CAAC;AAEvD,eAAO,MAAM,WAAW;;;;;CAKvB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;CAUjB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;CASjB,CAAC;AAEF,eAAO,MAAM,OAAO;;CAEnB,CAAC;AAEF,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,eAAO,MAAM,OAAO;;;;CAInB,CAAC;AAEF,eAAO,MAAM,MAAM;;;;CAIlB,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC;AAEF,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA9WL,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;gBAyBnD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA2IrD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwOtD,CAAC;AAEF,eAAe,KAAK,CAAC"}
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../../../src/themes/light/theme.ts"],"names":[],"mappings":"AA6BA,eAAO,MAAM,WAAW,UAA0C,CAAC;AAyRnE,eAAO,MAAM,UAAU;;;;;;;;;;;;;CAatB,CAAC;AAEF,eAAO,MAAM,SAAS;;;;;;;;;;;;;CAarB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAavB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC;AAE1C,eAAO,MAAM,UAAU,QAA+B,CAAC;AAEvD,eAAO,MAAM,WAAW;;;;;CAKvB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;CAUjB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;CASjB,CAAC;AAEF,eAAO,MAAM,OAAO;;;;CAInB,CAAC;AAEF,eAAO,MAAM,YAAY;;;;CAIxB,CAAC;AAEF,eAAO,MAAM,OAAO;;;;CAInB,CAAC;AAEF,eAAO,MAAM,MAAM;;;;CAIlB,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC;AAEF,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAlXL,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;gBAyBnD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA2IrD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4OtD,CAAC;AAEF,eAAe,KAAK,CAAC"}

package/lib/Avatar/Avatar.js

@@ -20,6 +20,7 @@ import styled, { css } from "styled-components";
 import Box from "../Box";
 import Image from "../Image";
 import Text from "../Text";
+import { BORDER } from "@sproutsocial/seeds-react-system-props";
 import { jsx as _jsx } from "react/jsx-runtime";
 var defaultType = "neutral";
 
@@ -42,14 +43,14 @@ var AvatarText = styled(function (_ref) {
 var Container = styled(Box).withConfig({
   displayName: "Avatar__Container",
   componentId: "sc-1ffu253-1"
-})(["", ""], function (_ref3) {
+})(["", " ", ""], function (_ref3) {
   var theme = _ref3.theme,
     $type = _ref3.$type,
     bg = _ref3.bg,
     borderColor = _ref3.borderColor,
     $displayFallback = _ref3.$displayFallback;
   return css(["background:", ";border:", ";border-color:", ";color:", ";"], $displayFallback ? bg ? bg : theme.colors.container.background.decorative[$type] : "none", $displayFallback ? "1px solid" : "none", borderColor ? borderColor : theme.colors.container.border.decorative[$type], theme.colors.text.decorative[$type]);
-});
+}, BORDER);
 var getInitials = function getInitials(name) {
   var fallback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "?";
   if (!name || typeof name !== "string") return fallback;

package/lib/Duration/Duration.js

@@ -4,43 +4,16 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-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; }
 import * as React from "react";
 import memoize from "lru-memoize";
 import { EM_DASH } from "../utils/constants";
 import { VisuallyHidden } from "../VisuallyHidden";
-import { COMPARE_OBJECTS, DEFAULT_DISPLAY, DEFAULT_DISPLAY_UNITS, DEFAULT_LOCALE, DEFAULT_MILLISECONDS, MEMO_CACHE_SIZE, MILLISECONDS_IN, ORDERED_UNITS, UNITS } from "./constants";
+import { COMPARE_OBJECTS, DEFAULT_DISPLAY, DEFAULT_DISPLAY_UNITS, DEFAULT_LOCALE, DEFAULT_MILLISECONDS, MEMO_CACHE_SIZE, ORDERED_UNITS, UNITS } from "./constants";
 import { Container } from "./styles";
-import { isValidNumber } from "./utils";
+import { isValidNumber, getLowestUnit, splitMillisecondsIntoUnits } from "./utils";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Fragment as _Fragment } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
-var getLowestUnit = function getLowestUnit(displayUnits) {
-  return _toConsumableArray(ORDERED_UNITS).reverse().find(function (unit) {
-    return displayUnits[unit];
-  }) || UNITS.milliseconds;
-};
-var splitMillisecondsIntoUnits = function splitMillisecondsIntoUnits(milliseconds, displayUnits) {
-  var lowestUnit = getLowestUnit(displayUnits);
-  var remainder = milliseconds % MILLISECONDS_IN[lowestUnit];
-  if (2 * remainder >= MILLISECONDS_IN[lowestUnit]) {
-    // if the remainder is large, add enough seconds to increse the lowest unit
-    milliseconds += MILLISECONDS_IN[lowestUnit] - remainder;
-  }
-  var units = {};
-  ORDERED_UNITS.forEach(function (unit) {
-    if (displayUnits[unit]) {
-      units[unit] = Math.floor(milliseconds / MILLISECONDS_IN[unit]);
-      milliseconds -= units[unit] * MILLISECONDS_IN[unit];
-    }
-  });
-  return units;
-};
 var _createDurationFormatter = function _createDurationFormatter(locale, unitDisplay, displayUnits) {
   var timeUnitFormatter = function timeUnitFormatter(locale, unit, unitDisplay) {
     return Intl.NumberFormat(locale, {

package/lib/Duration/utils.js

@@ -1,7 +1,32 @@
 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 _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; }
-import { MILLISECONDS_IN, ORDERED_UNITS } from "./constants";
+import { MILLISECONDS_IN, ORDERED_UNITS, UNITS } from "./constants";
+export var getLowestUnit = function getLowestUnit(displayUnits) {
+  return _toConsumableArray(ORDERED_UNITS).reverse().find(function (unit) {
+    return displayUnits[unit];
+  }) || UNITS.milliseconds;
+};
+export var splitMillisecondsIntoUnits = function splitMillisecondsIntoUnits(milliseconds, displayUnits) {
+  var lowestUnit = getLowestUnit(displayUnits);
+  var remainder = milliseconds % MILLISECONDS_IN[lowestUnit];
+  if (2 * remainder >= MILLISECONDS_IN[lowestUnit]) {
+    // if the remainder is large, add enough seconds to increse the lowest unit
+    milliseconds += MILLISECONDS_IN[lowestUnit] - remainder;
+  }
+  var units = {};
+  ORDERED_UNITS.forEach(function (unit) {
+    if (displayUnits[unit]) {
+      units[unit] = Math.floor(milliseconds / MILLISECONDS_IN[unit]);
+      milliseconds -= units[unit] * MILLISECONDS_IN[unit];
+    }
+  });
+  return units;
+};
 export var isValidNumber = function isValidNumber(value) {
   return typeof value === "number" && isFinite(value);
 };
@@ -23,7 +48,16 @@ export var getDurationMaxDisplayUnits = function getDurationMaxDisplayUnits(_ref
       }
 
       // @ts-expect-error - stupid typescript isn't smart enough to check the isValidNumber check above ¯\_(ツ)_/¯
-      if (milliseconds > MILLISECONDS_IN[unit]) {
+      var millisecondsByUnit = splitMillisecondsIntoUnits(milliseconds, {
+        days: true,
+        hours: true,
+        minutes: true,
+        seconds: true,
+        milliseconds: true
+      });
+
+      // @ts-expect-error - stupid typescript isn't smart enough to check the isValidNumber check above ¯\_(ツ)_/¯
+      if (milliseconds > MILLISECONDS_IN[unit] && millisecondsByUnit[unit] > 0) {
         displayUnits[unit] = true;
       }
     }

package/lib/themes/light/theme.js

@@ -365,10 +365,14 @@ export var radii = {
   pill: BORDER.BORDER_RADIUS_1000
 };
 export var borders = {
-  500: "".concat(BORDER.BORDER_WIDTH_500, " solid")
+  500: "".concat(BORDER.BORDER_WIDTH_500, " solid"),
+  600: "".concat(BORDER.BORDER_WIDTH_600, " solid"),
+  700: "".concat(BORDER.BORDER_WIDTH_700, " solid")
 };
 export var borderWidths = {
-  500: BORDER.BORDER_WIDTH_500
+  500: BORDER.BORDER_WIDTH_500,
+  600: BORDER.BORDER_WIDTH_600,
+  700: BORDER.BORDER_WIDTH_700
 };
 export var shadows = {
   low: "".concat(DEPTH.ELEVATION_LEVEL_100, " ").concat(COLORS.COLOR_NEUTRAL_900, "3D"),

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@sproutsocial/racine",
-  "version": "24.2.0",
+  "version": "25.0.1",
   "license": "MIT",
   "engines": {
     "node": ">=18"
   },
   "readme": "README.NPM.md",
   "files": [
-    "__flow__",
     "commonjs",
     "dist",
     "lib",
@@ -55,28 +54,27 @@
     "release": "yarn build && yarn test && yarn changeset publish",
     "storybook": "rm -rf node_modules/.cache/storybook && storybook dev -c .storybook -p 9999",
     "build-storybook": "storybook build --quiet -c .storybook -o .storybook-dist",
-    "build-chromatic": "storybook build --quiet -c .storybook -o .storybook-dist",
-    "ts-to-flow": "flowgen $FILE -o $OUTPUT --add-flow-header --no-module-exports"
+    "build-chromatic": "storybook build --quiet -c .storybook -o .storybook-dist"
   },
   "dependencies": {
     "@react-spring/web": "^9.0.0",
-    "@sproutsocial/seeds-react-box": "^1.0.0",
-    "@sproutsocial/seeds-react-button": "^1.0.0",
-    "@sproutsocial/seeds-react-checkbox": "^1.0.0",
-    "@sproutsocial/seeds-react-hooks": "^2.0.0",
-    "@sproutsocial/seeds-react-icon": "^1.0.0",
-    "@sproutsocial/seeds-react-input": "^1.0.0",
-    "@sproutsocial/seeds-react-mixins": "^2.0.0",
-    "@sproutsocial/seeds-react-partner-logo": "^1.0.0",
-    "@sproutsocial/seeds-react-popout": "^1.0.0",
-    "@sproutsocial/seeds-react-portal": "^1.0.0",
-    "@sproutsocial/seeds-react-radio": "^1.0.0",
-    "@sproutsocial/seeds-react-switch": "^1.0.0",
-    "@sproutsocial/seeds-react-system-props": "^2.2.0",
-    "@sproutsocial/seeds-react-text": "^1.0.0",
-    "@sproutsocial/seeds-react-theme": "^1.0.0",
-    "@sproutsocial/seeds-react-theme-provider": "^1.0.0",
-    "@sproutsocial/seeds-react-utilities": "^3.0.0",
+    "@sproutsocial/seeds-react-box": "^*",
+    "@sproutsocial/seeds-react-button": "*",
+    "@sproutsocial/seeds-react-checkbox": "*",
+    "@sproutsocial/seeds-react-hooks": "*",
+    "@sproutsocial/seeds-react-icon": "*",
+    "@sproutsocial/seeds-react-input": "*",
+    "@sproutsocial/seeds-react-mixins": "*",
+    "@sproutsocial/seeds-react-partner-logo": "*",
+    "@sproutsocial/seeds-react-popout": "*",
+    "@sproutsocial/seeds-react-portal": "*",
+    "@sproutsocial/seeds-react-radio": "*",
+    "@sproutsocial/seeds-react-switch": "*",
+    "@sproutsocial/seeds-react-system-props": "*",
+    "@sproutsocial/seeds-react-text": "*",
+    "@sproutsocial/seeds-react-theme": "*",
+    "@sproutsocial/seeds-react-theme-provider": "*",
+    "@sproutsocial/seeds-react-utilities": "*",
     "@styled-system/theme-get": "^5.1.2",
     "classnames": "^2.2.6",
     "default-browser-id": "^3.0.0",
@@ -98,13 +96,10 @@
     "@babel/cli": "^7.22.10",
     "@babel/core": "^7.22.10",
     "@babel/eslint-parser": "^7.22.10",
-    "@babel/plugin-syntax-flow": "^7.22.5",
     "@babel/plugin-syntax-jsx": "^7.22.5",
     "@babel/preset-env": "^7.22.10",
-    "@babel/preset-flow": "^7.0.0",
     "@babel/preset-react": "^7.22.5",
     "@babel/preset-typescript": "^7.22.5",
-    "@khanacademy/flow-to-ts": "^0.5.2",
     "@sproutsocial/eslint-config-seeds": "*",
     "@sproutsocial/seeds-border": "*",
     "@sproutsocial/seeds-color": "*",
@@ -161,8 +156,6 @@
     "eslint-import-resolver-babel-module": "^5.3.2",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-jest": "^27.6.3",
-    "flow-bin": "0.131.0",
-    "flowgen": "^1.21.0",
     "glob": "^7.1.6",
     "identity-obj-proxy": "^3.0.0",
     "inquirer": "^6.4.1",

package/__flow__/Avatar/Avatar.flow.js

@@ -1,17 +0,0 @@
-// @flow
-import * as React from "react";
-export type TypeAvatarProps = {
-  /** Circles are used for social profile avatars, leaf is for internal Sprout user avatars */
-  appearance?: "circle" | "leaf",
-  /** The name of the user that the avatar represents */
-  name?: string,
-  /** URL of the avatar image. If a URL is not provided, the component will fall back to showing the user's initials */
-  src?: string,
-  type?: "neutral" | "purple" | "green" | "blue" | "yellow" | "red" | "orange",
-  bg?: string,
-  color?: string,
-  size?: string,
-  ...
-};
-declare var Avatar: React.StatelessFunctionalComponent<TypeAvatarProps>;
-declare export default typeof Avatar;

package/__flow__/Avatar/constants.flow.js

@@ -1,11 +0,0 @@
-// @flow
-export const AvatarColorOptions = Object.freeze({
-  auto: "auto",
-  neutral: "neutral",
-  purple: "purple",
-  green: "green",
-  blue: "blue",
-  yellow: "yellow",
-  red: "red",
-  orange: "orange"
-});

package/__flow__/Avatar/index.flow.js

@@ -1,3 +0,0 @@
-// @flow
-export * from "./Avatar.flow";
-export { AvatarColorOptions } from "./constants.flow";