@teamturing/react-kit 1.1.0

package/esm/node_modules/@styled-system/css/dist/index.esm.js

@@ -0,0 +1,209 @@
+function _extends() {
+  _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;
+  };
+  return _extends.apply(this, arguments);
+}
+
+// based on https://github.com/developit/dlv
+var get = function get(obj, key, def, p, undef) {
+  key = key && key.split ? key.split('.') : [key];
+  for (p = 0; p < key.length; p++) {
+    obj = obj ? obj[key[p]] : undef;
+  }
+  return obj === undef ? def : obj;
+};
+var defaultBreakpoints = [40, 52, 64].map(function (n) {
+  return n + 'em';
+});
+var defaultTheme = {
+  space: [0, 4, 8, 16, 32, 64, 128, 256, 512],
+  fontSizes: [12, 14, 16, 20, 24, 32, 48, 64, 72]
+};
+var aliases = {
+  bg: 'backgroundColor',
+  m: 'margin',
+  mt: 'marginTop',
+  mr: 'marginRight',
+  mb: 'marginBottom',
+  ml: 'marginLeft',
+  mx: 'marginX',
+  my: 'marginY',
+  p: 'padding',
+  pt: 'paddingTop',
+  pr: 'paddingRight',
+  pb: 'paddingBottom',
+  pl: 'paddingLeft',
+  px: 'paddingX',
+  py: 'paddingY'
+};
+var multiples = {
+  marginX: ['marginLeft', 'marginRight'],
+  marginY: ['marginTop', 'marginBottom'],
+  paddingX: ['paddingLeft', 'paddingRight'],
+  paddingY: ['paddingTop', 'paddingBottom'],
+  size: ['width', 'height']
+};
+var scales = {
+  color: 'colors',
+  backgroundColor: 'colors',
+  borderColor: 'colors',
+  margin: 'space',
+  marginTop: 'space',
+  marginRight: 'space',
+  marginBottom: 'space',
+  marginLeft: 'space',
+  marginX: 'space',
+  marginY: 'space',
+  padding: 'space',
+  paddingTop: 'space',
+  paddingRight: 'space',
+  paddingBottom: 'space',
+  paddingLeft: 'space',
+  paddingX: 'space',
+  paddingY: 'space',
+  top: 'space',
+  right: 'space',
+  bottom: 'space',
+  left: 'space',
+  gridGap: 'space',
+  gridColumnGap: 'space',
+  gridRowGap: 'space',
+  gap: 'space',
+  columnGap: 'space',
+  rowGap: 'space',
+  fontFamily: 'fonts',
+  fontSize: 'fontSizes',
+  fontWeight: 'fontWeights',
+  lineHeight: 'lineHeights',
+  letterSpacing: 'letterSpacings',
+  border: 'borders',
+  borderTop: 'borders',
+  borderRight: 'borders',
+  borderBottom: 'borders',
+  borderLeft: 'borders',
+  borderWidth: 'borderWidths',
+  borderStyle: 'borderStyles',
+  borderRadius: 'radii',
+  borderTopRightRadius: 'radii',
+  borderTopLeftRadius: 'radii',
+  borderBottomRightRadius: 'radii',
+  borderBottomLeftRadius: 'radii',
+  borderTopWidth: 'borderWidths',
+  borderTopColor: 'colors',
+  borderTopStyle: 'borderStyles',
+  borderBottomWidth: 'borderWidths',
+  borderBottomColor: 'colors',
+  borderBottomStyle: 'borderStyles',
+  borderLeftWidth: 'borderWidths',
+  borderLeftColor: 'colors',
+  borderLeftStyle: 'borderStyles',
+  borderRightWidth: 'borderWidths',
+  borderRightColor: 'colors',
+  borderRightStyle: 'borderStyles',
+  outlineColor: 'colors',
+  boxShadow: 'shadows',
+  textShadow: 'shadows',
+  zIndex: 'zIndices',
+  width: 'sizes',
+  minWidth: 'sizes',
+  maxWidth: 'sizes',
+  height: 'sizes',
+  minHeight: 'sizes',
+  maxHeight: 'sizes',
+  flexBasis: 'sizes',
+  size: 'sizes',
+  // svg
+  fill: 'colors',
+  stroke: 'colors'
+};
+var positiveOrNegative = function positiveOrNegative(scale, value) {
+  if (typeof value !== 'number' || value >= 0) {
+    return get(scale, value, value);
+  }
+  var absolute = Math.abs(value);
+  var n = get(scale, absolute, absolute);
+  if (typeof n === 'string') return '-' + n;
+  return n * -1;
+};
+var transforms = ['margin', 'marginTop', 'marginRight', 'marginBottom', 'marginLeft', 'marginX', 'marginY', 'top', 'bottom', 'left', 'right'].reduce(function (acc, curr) {
+  var _extends2;
+  return _extends({}, acc, (_extends2 = {}, _extends2[curr] = positiveOrNegative, _extends2));
+}, {});
+var responsive = function responsive(styles) {
+  return function (theme) {
+    var next = {};
+    var breakpoints = get(theme, 'breakpoints', defaultBreakpoints);
+    var mediaQueries = [null].concat(breakpoints.map(function (n) {
+      return "@media screen and (min-width: " + n + ")";
+    }));
+    for (var key in styles) {
+      var value = typeof styles[key] === 'function' ? styles[key](theme) : styles[key];
+      if (value == null) continue;
+      if (!Array.isArray(value)) {
+        next[key] = value;
+        continue;
+      }
+      for (var i = 0; i < value.slice(0, mediaQueries.length).length; i++) {
+        var media = mediaQueries[i];
+        if (!media) {
+          next[key] = value[i];
+          continue;
+        }
+        next[media] = next[media] || {};
+        if (value[i] == null) continue;
+        next[media][key] = value[i];
+      }
+    }
+    return next;
+  };
+};
+var css = function css(args) {
+  return function (props) {
+    if (props === void 0) {
+      props = {};
+    }
+    var theme = _extends({}, defaultTheme, {}, props.theme || props);
+    var result = {};
+    var obj = typeof args === 'function' ? args(theme) : args;
+    var styles = responsive(obj)(theme);
+    for (var key in styles) {
+      var x = styles[key];
+      var val = typeof x === 'function' ? x(theme) : x;
+      if (key === 'variant') {
+        var variant = css(get(theme, val))(theme);
+        result = _extends({}, result, {}, variant);
+        continue;
+      }
+      if (val && typeof val === 'object') {
+        result[key] = css(val)(theme);
+        continue;
+      }
+      var prop = get(aliases, key, key);
+      var scaleName = get(scales, prop);
+      var scale = get(theme, scaleName, get(theme, prop, {}));
+      var transform = get(transforms, prop, get);
+      var value = transform(scale, val, val);
+      if (multiples[prop]) {
+        var dirs = multiples[prop];
+        for (var i = 0; i < dirs.length; i++) {
+          result[dirs[i]] = value;
+        }
+      } else {
+        result[prop] = value;
+      }
+    }
+    return result;
+  };
+};
+var css$1 = css;
+
+export { css, css$1 as default, get, responsive };

package/esm/node_modules/@styled-system/flexbox/dist/index.esm.js

@@ -0,0 +1,21 @@
+import { system } from '../../core/dist/index.esm.js';
+
+var config = {
+  alignItems: true,
+  alignContent: true,
+  justifyItems: true,
+  justifyContent: true,
+  flexWrap: true,
+  flexDirection: true,
+  // item
+  flex: true,
+  flexGrow: true,
+  flexShrink: true,
+  flexBasis: true,
+  justifySelf: true,
+  alignSelf: true,
+  order: true
+};
+var flexbox = system(config);
+
+export { flexbox as default, flexbox };

package/esm/node_modules/@styled-system/grid/dist/index.esm.js

@@ -0,0 +1,34 @@
+import { system } from '../../core/dist/index.esm.js';
+
+var defaults = {
+  space: [0, 4, 8, 16, 32, 64, 128, 256, 512]
+};
+var config = {
+  gridGap: {
+    property: 'gridGap',
+    scale: 'space',
+    defaultScale: defaults.space
+  },
+  gridColumnGap: {
+    property: 'gridColumnGap',
+    scale: 'space',
+    defaultScale: defaults.space
+  },
+  gridRowGap: {
+    property: 'gridRowGap',
+    scale: 'space',
+    defaultScale: defaults.space
+  },
+  gridColumn: true,
+  gridRow: true,
+  gridAutoFlow: true,
+  gridAutoColumns: true,
+  gridAutoRows: true,
+  gridTemplateColumns: true,
+  gridTemplateRows: true,
+  gridTemplateAreas: true,
+  gridArea: true
+};
+var grid = system(config);
+
+export { grid as default, grid };

package/esm/node_modules/@styled-system/layout/dist/index.esm.js

@@ -0,0 +1,47 @@
+import { system, get } from '../../core/dist/index.esm.js';
+
+var isNumber = function isNumber(n) {
+  return typeof n === 'number' && !isNaN(n);
+};
+var getWidth = function getWidth(n, scale) {
+  return get(scale, n, !isNumber(n) || n > 1 ? n : n * 100 + '%');
+};
+var config = {
+  width: {
+    property: 'width',
+    scale: 'sizes',
+    transform: getWidth
+  },
+  height: {
+    property: 'height',
+    scale: 'sizes'
+  },
+  minWidth: {
+    property: 'minWidth',
+    scale: 'sizes'
+  },
+  minHeight: {
+    property: 'minHeight',
+    scale: 'sizes'
+  },
+  maxWidth: {
+    property: 'maxWidth',
+    scale: 'sizes'
+  },
+  maxHeight: {
+    property: 'maxHeight',
+    scale: 'sizes'
+  },
+  size: {
+    properties: ['width', 'height'],
+    scale: 'sizes'
+  },
+  overflow: true,
+  overflowX: true,
+  overflowY: true,
+  display: true,
+  verticalAlign: true
+};
+var layout = system(config);
+
+export { layout as default, layout };

package/esm/node_modules/@styled-system/position/dist/index.esm.js

@@ -0,0 +1,35 @@
+import { system } from '../../core/dist/index.esm.js';
+
+var defaults = {
+  space: [0, 4, 8, 16, 32, 64, 128, 256, 512]
+};
+var config = {
+  position: true,
+  zIndex: {
+    property: 'zIndex',
+    scale: 'zIndices'
+  },
+  top: {
+    property: 'top',
+    scale: 'space',
+    defaultScale: defaults.space
+  },
+  right: {
+    property: 'right',
+    scale: 'space',
+    defaultScale: defaults.space
+  },
+  bottom: {
+    property: 'bottom',
+    scale: 'space',
+    defaultScale: defaults.space
+  },
+  left: {
+    property: 'left',
+    scale: 'space',
+    defaultScale: defaults.space
+  }
+};
+var position = system(config);
+
+export { position as default, position };

package/esm/node_modules/@styled-system/shadow/dist/index.esm.js

@@ -0,0 +1,14 @@
+import { system } from '../../core/dist/index.esm.js';
+
+var shadow = system({
+  boxShadow: {
+    property: 'boxShadow',
+    scale: 'shadows'
+  },
+  textShadow: {
+    property: 'textShadow',
+    scale: 'shadows'
+  }
+});
+
+export { shadow as default, shadow };

package/esm/node_modules/@styled-system/space/dist/index.esm.js

@@ -0,0 +1,121 @@
+import { system, compose, get } from '../../core/dist/index.esm.js';
+
+var defaults = {
+  space: [0, 4, 8, 16, 32, 64, 128, 256, 512]
+};
+var isNumber = function isNumber(n) {
+  return typeof n === 'number' && !isNaN(n);
+};
+var getMargin = function getMargin(n, scale) {
+  if (!isNumber(n)) {
+    return get(scale, n, n);
+  }
+  var isNegative = n < 0;
+  var absolute = Math.abs(n);
+  var value = get(scale, absolute, absolute);
+  if (!isNumber(value)) {
+    return isNegative ? '-' + value : value;
+  }
+  return value * (isNegative ? -1 : 1);
+};
+var configs = {};
+configs.margin = {
+  margin: {
+    property: 'margin',
+    scale: 'space',
+    transform: getMargin,
+    defaultScale: defaults.space
+  },
+  marginTop: {
+    property: 'marginTop',
+    scale: 'space',
+    transform: getMargin,
+    defaultScale: defaults.space
+  },
+  marginRight: {
+    property: 'marginRight',
+    scale: 'space',
+    transform: getMargin,
+    defaultScale: defaults.space
+  },
+  marginBottom: {
+    property: 'marginBottom',
+    scale: 'space',
+    transform: getMargin,
+    defaultScale: defaults.space
+  },
+  marginLeft: {
+    property: 'marginLeft',
+    scale: 'space',
+    transform: getMargin,
+    defaultScale: defaults.space
+  },
+  marginX: {
+    properties: ['marginLeft', 'marginRight'],
+    scale: 'space',
+    transform: getMargin,
+    defaultScale: defaults.space
+  },
+  marginY: {
+    properties: ['marginTop', 'marginBottom'],
+    scale: 'space',
+    transform: getMargin,
+    defaultScale: defaults.space
+  }
+};
+configs.margin.m = configs.margin.margin;
+configs.margin.mt = configs.margin.marginTop;
+configs.margin.mr = configs.margin.marginRight;
+configs.margin.mb = configs.margin.marginBottom;
+configs.margin.ml = configs.margin.marginLeft;
+configs.margin.mx = configs.margin.marginX;
+configs.margin.my = configs.margin.marginY;
+configs.padding = {
+  padding: {
+    property: 'padding',
+    scale: 'space',
+    defaultScale: defaults.space
+  },
+  paddingTop: {
+    property: 'paddingTop',
+    scale: 'space',
+    defaultScale: defaults.space
+  },
+  paddingRight: {
+    property: 'paddingRight',
+    scale: 'space',
+    defaultScale: defaults.space
+  },
+  paddingBottom: {
+    property: 'paddingBottom',
+    scale: 'space',
+    defaultScale: defaults.space
+  },
+  paddingLeft: {
+    property: 'paddingLeft',
+    scale: 'space',
+    defaultScale: defaults.space
+  },
+  paddingX: {
+    properties: ['paddingLeft', 'paddingRight'],
+    scale: 'space',
+    defaultScale: defaults.space
+  },
+  paddingY: {
+    properties: ['paddingTop', 'paddingBottom'],
+    scale: 'space',
+    defaultScale: defaults.space
+  }
+};
+configs.padding.p = configs.padding.padding;
+configs.padding.pt = configs.padding.paddingTop;
+configs.padding.pr = configs.padding.paddingRight;
+configs.padding.pb = configs.padding.paddingBottom;
+configs.padding.pl = configs.padding.paddingLeft;
+configs.padding.px = configs.padding.paddingX;
+configs.padding.py = configs.padding.paddingY;
+var margin = system(configs.margin);
+var padding = system(configs.padding);
+var space = compose(margin, padding);
+
+export { space as default, margin, padding, space };

package/esm/node_modules/@styled-system/typography/dist/index.esm.js

@@ -0,0 +1,33 @@
+import { system } from '../../core/dist/index.esm.js';
+
+var defaults = {
+  fontSizes: [12, 14, 16, 20, 24, 32, 48, 64, 72]
+};
+var config = {
+  fontFamily: {
+    property: 'fontFamily',
+    scale: 'fonts'
+  },
+  fontSize: {
+    property: 'fontSize',
+    scale: 'fontSizes',
+    defaultScale: defaults.fontSizes
+  },
+  fontWeight: {
+    property: 'fontWeight',
+    scale: 'fontWeights'
+  },
+  lineHeight: {
+    property: 'lineHeight',
+    scale: 'lineHeights'
+  },
+  letterSpacing: {
+    property: 'letterSpacing',
+    scale: 'letterSpacings'
+  },
+  textAlign: true,
+  fontStyle: true
+};
+var typography = system(config);
+
+export { typography as default, typography };

package/esm/node_modules/@styled-system/variant/dist/index.esm.js

@@ -0,0 +1,40 @@
+import { createParser, get } from '../../core/dist/index.esm.js';
+import css from '../../css/dist/index.esm.js';
+
+var variant = function variant(_ref) {
+  var _config;
+  var scale = _ref.scale,
+    _ref$prop = _ref.prop,
+    prop = _ref$prop === void 0 ? 'variant' : _ref$prop,
+    _ref$variants = _ref.variants,
+    variants = _ref$variants === void 0 ? {} : _ref$variants,
+    key = _ref.key;
+  var sx;
+  if (Object.keys(variants).length) {
+    sx = function sx(value, scale, props) {
+      return css(get(scale, value, null))(props.theme);
+    };
+  } else {
+    sx = function sx(value, scale) {
+      return get(scale, value, null);
+    };
+  }
+  sx.scale = scale || key;
+  sx.defaults = variants;
+  var config = (_config = {}, _config[prop] = sx, _config);
+  var parser = createParser(config);
+  return parser;
+};
+variant({
+  key: 'buttons'
+});
+variant({
+  key: 'textStyles',
+  prop: 'textStyle'
+});
+variant({
+  key: 'colorStyles',
+  prop: 'colors'
+});
+
+export { variant as default, variant };

package/esm/node_modules/object-assign/index.js

@@ -0,0 +1,83 @@
+import { getDefaultExportFromCjs } from '../../_virtual/_commonjsHelpers.js';
+
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+/* eslint-disable no-unused-vars */
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+function toObject(val) {
+  if (val === null || val === undefined) {
+    throw new TypeError('Object.assign cannot be called with null or undefined');
+  }
+  return Object(val);
+}
+function shouldUseNative() {
+  try {
+    if (!Object.assign) {
+      return false;
+    }
+
+    // Detect buggy property enumeration order in older V8 versions.
+
+    // https://bugs.chromium.org/p/v8/issues/detail?id=4118
+    var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
+    test1[5] = 'de';
+    if (Object.getOwnPropertyNames(test1)[0] === '5') {
+      return false;
+    }
+
+    // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+    var test2 = {};
+    for (var i = 0; i < 10; i++) {
+      test2['_' + String.fromCharCode(i)] = i;
+    }
+    var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+      return test2[n];
+    });
+    if (order2.join('') !== '0123456789') {
+      return false;
+    }
+
+    // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+    var test3 = {};
+    'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+      test3[letter] = letter;
+    });
+    if (Object.keys(Object.assign({}, test3)).join('') !== 'abcdefghijklmnopqrst') {
+      return false;
+    }
+    return true;
+  } catch (err) {
+    // We don't expect any of the above to throw, but better to be safe.
+    return false;
+  }
+}
+var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+  var from;
+  var to = toObject(target);
+  var symbols;
+  for (var s = 1; s < arguments.length; s++) {
+    from = Object(arguments[s]);
+    for (var key in from) {
+      if (hasOwnProperty.call(from, key)) {
+        to[key] = from[key];
+      }
+    }
+    if (getOwnPropertySymbols) {
+      symbols = getOwnPropertySymbols(from);
+      for (var i = 0; i < symbols.length; i++) {
+        if (propIsEnumerable.call(from, symbols[i])) {
+          to[symbols[i]] = from[symbols[i]];
+        }
+      }
+    }
+  }
+  return to;
+};
+var assign = /*@__PURE__*/getDefaultExportFromCjs(objectAssign);
+
+export { assign as default };