react-outline 2.1.0 → 2.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-outline",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "react styling framework to keep your makeup clean",
   "main": "./dist/reactOutline.js",
   "types": "./index.d.ts",
@@ -9,14 +9,13 @@
     "index.d.ts"
   ],
   "scripts": {
-    "prepare": "cp .hooks/* .git/hooks/ 2>/dev/null && chmod +x .git/hooks/* || true",
-    "build": "babel --copy-files source --out-dir dist",
-    "build:watch": "babel --copy-files source --out-dir dist -s --source-maps inline -w",
-    "test": "jest --no-cache ",
+    "build:dist": "npx esbuild source/main.js --bundle --minify --sourcemap --outfile=dist/reactOutline.js --format=cjs --platform=node --loader:.js=jsx --external:react --external:react-dom",
+    "pretest": "npm run build:dist",
+    "test": "jest --no-cache",
     "test:go": "npm test -- --watch --coverage",
     "test:update": "npm test -- --updateSnapshot",
-    "test:cover": "npm test -- --coverage --no-cache",
-    "test:watch": "npm test -- --watch --runInBand",
+    "test:cover": "jest --no-cache --config jest.coverage.config.js --coverage",
+    "test:watch": "npm run build:dist && jest --no-cache --watch --runInBand",
     "release": "bash scripts/_publish.sh"
   },
   "repository": {
@@ -57,8 +56,7 @@
     "@faker-js/faker": "^8.3.0",
     "@testing-library/jest-dom": "^6.1.0",
     "@testing-library/react": "^14.1.0",
-    "coveralls": "^3.1.1",
-    "esbuild": "^0.24.2",
+    "esbuild": "^0.27.2",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
     "raw-loader": "^4.0.2",
@@ -71,7 +69,7 @@
     "moduleNameMapper": {
       "\\.(css|jpg|png)$": "<rootDir>/empty-module.js",
       "^raw-loader": "<rootDir>/empty-module.js",
-      "react-outline": "<rootDir>/source/main.js",
+      "react-outline": "<rootDir>/dist/reactOutline.js",
       "^react-addons-css-transition-group$": "<rootDir>/empty-module.js"
     },
     "testPathIgnorePatterns": [

package/dist/Styles.js

@@ -1,45 +0,0 @@
-"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
-});
-exports["default"] = Styles;
-var _react = _interopRequireWildcard(require("react"));
-var _utils = require("./utils");
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
-function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _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."); }
-function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
-// TODO: make Styles a "ref" and manual set the content
-
-function StylesElem(props) {
-  var _useState = (0, _react.useState)(function () {
-      return (0, _utils.buildCssString)(_utils.pubsub.get(), props);
-    }),
-    _useState2 = _slicedToArray(_useState, 2),
-    cssString = _useState2[0],
-    setCssString = _useState2[1];
-  (0, _react.useEffect)(function () {
-    var updateCss = function updateCss() {
-      setCssString((0, _utils.buildCssString)(_utils.pubsub.get(), props));
-    };
-    _utils.pubsub.subscribe(updateCss);
-
-    // Cleanup subscription on unmount
-    return function () {
-      // Note: pubsub.subscribe doesn't return an unsubscribe function in the current implementation
-      // This is kept for future compatibility if unsubscribe is added
-    };
-  }, [props]);
-  return /*#__PURE__*/_react["default"].createElement("style", null, cssString);
-}
-function Styles(props) {
-  return /*#__PURE__*/_react["default"].createElement(StylesElem, props);
-}
-Styles.toString = function () {
-  return (0, _utils.buildCssString)(_utils.pubsub.get());
-};

package/dist/element.js

@@ -1,141 +0,0 @@
-"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
-});
-exports["default"] = _default;
-var _react = _interopRequireDefault(require("react"));
-var _reactDom = require("react-dom");
-var _utils = require("./utils");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
-function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : 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 _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
-function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
-function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
-function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
-function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
-function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
-function _default(_ref) {
-  var elemName = _ref.elemName,
-    css = _ref.css,
-    styleCSS = _ref.styleCSS,
-    inlineStyle = _ref.inlineStyle,
-    style = _ref.style,
-    styleName = _ref.styleName,
-    colors = _ref.colors,
-    randomClassName = _ref.randomClassName,
-    options = _ref.options,
-    replacedStyle = _ref.replacedStyle;
-  var C2 = /*#__PURE__*/function (_React$Component) {
-    function C2(props) {
-      var _this;
-      _classCallCheck(this, C2);
-      _this = _callSuper(this, C2, [props]);
-      _this.eventHandlers = {};
-      return _this;
-    }
-    _inherits(C2, _React$Component);
-    return _createClass(C2, [{
-      key: "createEventHandler",
-      value: function createEventHandler(listen, onDomEvent) {
-        var _this2 = this;
-        return function (event) {
-          return onDomEvent[listen](_this2.domElem, event);
-        };
-      }
-    }, {
-      key: "componentDidMount",
-      value: function componentDidMount() {
-        var onDomEvent = this.props.onDomEvent;
-        for (var listen in onDomEvent) {
-          this.eventHandlers[listen] = this.createEventHandler(listen, onDomEvent);
-          this.domElem.addEventListener(listen, this.eventHandlers[listen]);
-        }
-      }
-    }, {
-      key: "componentWillUnmount",
-      value: function componentWillUnmount() {
-        for (var listen in this.eventHandlers) {
-          this.domElem.removeEventListener(listen, this.eventHandlers[listen]);
-        }
-      }
-    }, {
-      key: "render",
-      value: function render() {
-        var _this3 = this;
-        var props = this.props;
-        if ("css" in props) {
-          var updatedCss = Object.assign({}, css);
-          for (var selectorRule in props.css) {
-            updatedCss[selectorRule] = Object.assign({}, css[selectorRule], "function" === typeof props.css[selectorRule] ? props.css[selectorRule]() : props.css[selectorRule]);
-          }
-          _utils.pubsub.publish(randomClassName, (0, _utils.genCss)({
-            randomClassName: randomClassName,
-            css: updatedCss,
-            styleCSS: styleCSS,
-            colors: colors,
-            style: style,
-            styleName: styleName
-          }));
-        }
-        var elemProps = Object.assign({}, props);
-        var passedTrueProps = Object.keys(props).filter(function (name) {
-          return props[name] === true && styleCSS[styleName] && name in styleCSS[styleName];
-        });
-        //  console.log("passedTrueProps",passedTrueProps)
-        if (0 < passedTrueProps.length) {
-          passedTrueProps = passedTrueProps.reduce(function (styleProps, name) {
-            // If elem is a HTML type = Removed it Unknown prop `...` on <...> tag. Remove this prop from the element.
-            if ("function" !== typeof elemName && "disabled" !== name) {
-              delete elemProps[name];
-            }
-            return Object.assign(styleProps, _defineProperty({}, name, true));
-          }, {});
-        } else {
-          passedTrueProps = null;
-        }
-        if (passedTrueProps || props.hasOwnProperty("style")) {
-          //if(props.style instanceof Object)
-          //    passedTrueProps = Object.assign({},props.style,passedTrueProps);
-          if (randomClassName) elemProps.style = props.style;else elemProps.style = replacedStyle[styleName](props.style, passedTrueProps);
-        } else {
-          elemProps.style = inlineStyle || replacedStyle[styleName]();
-        }
-        //TODO: write a test for this
-        // For some reason in prod!
-        // a custom element in a perfect storm can have style undefined
-        //SEE: test - should generated an element with css selector
-        // thss is the same prod code.. BUT this is not catching this case :(
-        if (elemProps.style && Object.keys(elemProps.style).length === 0) {
-          delete elemProps.style;
-        }
-        if (options.named) {
-          elemProps.name = elemProps.name || styleName;
-        }
-        elemProps.className = elemProps.className || "";
-        if (elemProps.className && randomClassName) {
-          elemProps.className += " ";
-        }
-        elemProps.className += randomClassName || "";
-        if ("" === elemProps.className) delete elemProps.className;
-        if (props.onDomEvent) {
-          elemProps.ref = function (reatElem) {
-            return _this3.domElem = (0, _reactDom.findDOMNode)(reatElem);
-          };
-        }
-        return /*#__PURE__*/_react["default"].createElement(elemName || styleName, elemProps, elemProps && elemProps.children);
-      }
-    }]);
-  }(_react["default"].Component);
-  Object.defineProperty(C2, 'name', {
-    value: styleName
-  });
-  return C2;
-}

package/dist/main.js

@@ -1,64 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "Styles", {
-  enumerable: true,
-  get: function get() {
-    return _Styles["default"];
-  }
-});
-exports["default"] = void 0;
-exports.setOptions = setOptions;
-exports.testing = void 0;
-exports.withOptions = withOptions;
-var _react = _interopRequireDefault(require("react"));
-var _utils = require("./utils");
-var _wrapStyles = _interopRequireDefault(require("./wrapStyles"));
-var _Styles = _interopRequireDefault(require("./Styles"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-var userSetOptions = {
-  named: true /* prefix:getVendorPrefix()*/
-};
-var wrapStyles = (0, _wrapStyles["default"])(userSetOptions);
-
-//=====================================================
-//============================= top Level - Wrap Styles
-//=====================================================
-
-function outline(_styles) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  return sanitizeOutline((0, _utils.sanitizeOutlineInput)(_styles, options), options);
-}
-function sanitizeOutline(_styles, options) {
-  var wrappedStyles = wrapStyles(_styles, options);
-  wrappedStyles.colors = wrappedStyles.colors || options && options.colors || userSetOptions && userSetOptions.colors;
-  return wrappedStyles;
-}
-
-//=====================================================
-//============================================= Options
-//=====================================================
-
-function withOptions(options) {
-  if (!options) throw new Error("Bad options values for react-outline:" + JSON.stringify(options));
-  var tempOutlineFn = function tempOutlineFn(_styles, optionsOrLogic) {
-    return sanitizeOutline((0, _utils.sanitizeOutlineInput)(_styles, optionsOrLogic), options);
-  };
-  if (options.colors) {
-    tempOutlineFn.colors = options.colors;
-  }
-  return tempOutlineFn;
-}
-function setOptions(options) {
-  if (!options) throw new Error("Bad options values for react-outline:" + JSON.stringify(options));
-  if (options.colors) {
-    outline.colors = options.colors;
-  }
-  Object.assign(userSetOptions, options);
-}
-var testing = exports.testing = {
-  resetCSS: _utils.pubsub.clear
-};
-var _default = exports["default"] = outline;

package/dist/styleItem.js

@@ -1,168 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = _default;
-var _utils = require("./utils");
-var _element = _interopRequireDefault(require("./element"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-//=====================================================
-//========================================== build Elem
-//=====================================================
-
-function buildElem(_ref) {
-  var elemName = _ref.elemName,
-    args = _ref.args,
-    styleCSS = _ref.styleCSS,
-    styleName = _ref.styleName,
-    options = _ref.options,
-    replacedStyle = _ref.replacedStyle,
-    colors = _ref.colors;
-  elemName = elemName[0] || args[1];
-  var inlineStyle = null; //replacedStyle[styleName]();
-
-  var baseStyle = styleCSS[styleName] && styleCSS[styleName].base || {};
-  for (var propN in styleCSS[styleName]) {
-    //if(specialCharacters.includes(propN[0]) || !!propN.match(new RegExp(`[${specialInnerCharacters}]`, "gi"))){
-    if (/^[a-zA-Z0-9-]+$/.test(propN) === false) {
-      baseStyle[propN] = styleCSS[styleName][propN];
-    }
-  }
-  //splict ":" and "@" from all over styles
-  var _separateCssStyle = (0, _utils.separateCssStyle)(baseStyle),
-    css = _separateCssStyle.css,
-    style = _separateCssStyle.style;
-  /*
-  const cssPropNames = Object.keys(styleCSS[styleName])
-                             .filter(stylePropName => stylePropName[0] === "@" ||  stylePropName[0] === ":");
-  */
-  var randomClassName = "";
-
-  //if(0 < cssPropNames.length){
-  if (css) {
-    randomClassName = "react-outline-";
-    if (!global.__TEST__) randomClassName += (0, _utils.makeid)();
-    _utils.pubsub.publish(randomClassName, (0, _utils.genCss)({
-      randomClassName: randomClassName,
-      css: css,
-      styleCSS: styleCSS,
-      colors: colors,
-      style: style,
-      styleName: styleName
-    }));
-    inlineStyle = {};
-  }
-  return (0, _element["default"])({
-    elemName: elemName,
-    css: css,
-    styleCSS: styleCSS,
-    inlineStyle: inlineStyle,
-    style: style,
-    styleName: styleName,
-    colors: colors,
-    randomClassName: randomClassName,
-    options: options,
-    replacedStyle: replacedStyle
-  });
-}
-
-//=====================================================
-//===================================== build Style Obj
-//=====================================================
-
-function buildStyleObj(_ref2) {
-  var styleStuff = _ref2.styleStuff,
-    genStyles = _ref2.genStyles,
-    args = _ref2.args,
-    colors = _ref2.colors,
-    caching = _ref2.caching,
-    cached = _ref2.cached;
-  if (!caching) {
-    return genStyles(styleStuff, args, colors);
-  }
-  // quick test
-  if (cached.value && cached.source[0] === args[0] && cached.source[0] === args[1]) {
-    return cached.value;
-  }
-  // deep test
-  var key = "" + JSON.stringify(args[0]) + JSON.stringify(args[1]);
-  if (key === cached.key) {
-    return cached.value;
-  }
-  cached.key = key;
-  cached.source[0] = args[0];
-  cached.source[1] = args[1];
-  cached.value = genStyles(styleStuff, args, colors);
-  return cached.value;
-}
-
-//=====================================================
-//========================================== style Item
-//=====================================================
-
-function _default(_ref3) {
-  var _styles = _ref3._styles,
-    replacedStyle = _ref3.replacedStyle,
-    styleCSS = _ref3.styleCSS,
-    colors = _ref3.colors,
-    options = _ref3.options,
-    caching = _ref3.caching,
-    wrapStyles = _ref3.wrapStyles;
-  //+++++++++++++++++++++++++++++++++++++ style function
-  //++++++++++++++++++++++++++++++++++++++++++++++++++++
-  return function (styleName) {
-    var styleFn = _styles[styleName] || function () {
-      return {};
-    };
-    var cached = {
-      key: null,
-      value: null,
-      source: []
-    };
-    replacedStyle[styleName] = function () {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-      var elemName = args[0];
-
-      //+++++++++++++++++++++++++++++++++++ build an element
-      //++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-      if (Array.isArray(elemName) && elemName.hasOwnProperty("raw")) {
-        return buildElem({
-          elemName: elemName,
-          args: args,
-          styleCSS: styleCSS,
-          styleName: styleName,
-          options: options,
-          replacedStyle: replacedStyle,
-          colors: colors
-        });
-      } // elem gen
-
-      //++++++++++++++++++++++++++++++++++++++ generat style
-      //++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-      var styleStuff = {
-        styleCSS: styleCSS[styleName],
-        styleFn: styleFn
-      };
-      return buildStyleObj({
-        styleStuff: styleStuff,
-        genStyles: _utils.genStyles,
-        args: args,
-        colors: colors,
-        caching: caching,
-        cached: cached
-      });
-    }; // END replacedStyle[styleName] = function(...args)
-
-    //+++++++++++++++++++++++++++++++++ step down the tree
-    //++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-    if (0 < Object.keys(styleFn).length || (0, _utils.hasKids)(styleCSS[styleName])) {
-      Object.assign(replacedStyle[styleName], wrapStyles(styleFn, options, styleCSS[styleName]));
-    }
-  };
-}

package/dist/utils/buildCssString.js

@@ -1,14 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = buildCssString;
-function buildCssString(classesValues, props) {
-  var css = Object.keys(classesValues).map(function (className) {
-    return classesValues[className];
-  }).join(" ");
-  css += (props === null || props === void 0 ? void 0 : props.children) || "";
-  css = css.replace(/\n/g, ' ').replace(/\s+/g, ' ');
-  return css;
-}

package/dist/utils/genCss.js

@@ -1,27 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = genCss;
-var _object2css = _interopRequireDefault(require("./object2css"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-function genCss(_ref) {
-  var randomClassName = _ref.randomClassName,
-    css = _ref.css,
-    styleCSS = _ref.styleCSS,
-    colors = _ref.colors,
-    style = _ref.style,
-    styleName = _ref.styleName;
-  var newStyle = style ? ".".concat(randomClassName, "{").concat((0, _object2css["default"])(colors, style), "}") : "";
-  newStyle = Object.keys(css).reduce(function (cssString, propName) {
-    var styleContent = (0, _object2css["default"])(colors, css[propName]
-    /*  || styleCSS[styleName].base
-      && styleCSS[styleName].base[propName]
-      || styleCSS[styleName][propName]*/);
-    if (propName[0] === "@") return cssString + " ".concat(propName, "{ .").concat(randomClassName, "{ ").concat(styleContent, " } } ");else if (propName[0] === ":") return " .".concat(randomClassName).concat(propName, "{ ").concat(styleContent, " } ") + cssString;else return " .".concat(randomClassName, " ").concat(propName, "{ ").concat(styleContent, " } ") + cssString;
-    //  else // skip unknown prop
-    //      return cssString
-  }, newStyle);
-  return newStyle;
-}

package/dist/utils/genStyles.js

@@ -1,23 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = genStyles;
-var _inlineStylePrefixer = _interopRequireDefault(require("inline-style-prefixer"));
-var _replacedStyleFn = _interopRequireDefault(require("./replacedStyleFn"));
-var _replaceColors = _interopRequireDefault(require("./replaceColors"));
-var _index = require("./index");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
-var prefixer = new _inlineStylePrefixer["default"]();
-function genStyles(styleStuff, args, colors) {
-  var userResult = (0, _replacedStyleFn["default"])(styleStuff, args);
-  var swapedColor = (0, _replaceColors["default"])(colors, userResult);
-  for (var name in swapedColor) {
-    //if(!specialCharacters.includes(name[0]))
-    swapedColor[name] = prefixer.prefix({
-      a: swapedColor[name]
-    }).a;
-  }
-  return swapedColor;
-}

package/dist/utils/hasKids.js

@@ -1,12 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = hasKids;
-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 hasKids(obj) {
-  for (var name in obj) {
-    if ("base" !== name && "object" === _typeof(obj[name])) return true;
-  }
-}

package/dist/utils/index.js

@@ -1,83 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "buildCssString", {
-  enumerable: true,
-  get: function get() {
-    return _buildCssString["default"];
-  }
-});
-Object.defineProperty(exports, "genCss", {
-  enumerable: true,
-  get: function get() {
-    return _genCss["default"];
-  }
-});
-Object.defineProperty(exports, "genStyles", {
-  enumerable: true,
-  get: function get() {
-    return _genStyles["default"];
-  }
-});
-Object.defineProperty(exports, "hasKids", {
-  enumerable: true,
-  get: function get() {
-    return _hasKids["default"];
-  }
-});
-Object.defineProperty(exports, "makeid", {
-  enumerable: true,
-  get: function get() {
-    return _makeid["default"];
-  }
-});
-Object.defineProperty(exports, "object2css", {
-  enumerable: true,
-  get: function get() {
-    return _object2css["default"];
-  }
-});
-Object.defineProperty(exports, "pubsub", {
-  enumerable: true,
-  get: function get() {
-    return _pubsub["default"];
-  }
-});
-Object.defineProperty(exports, "replaceColors", {
-  enumerable: true,
-  get: function get() {
-    return _replaceColors["default"];
-  }
-});
-Object.defineProperty(exports, "replacedStyleFn", {
-  enumerable: true,
-  get: function get() {
-    return _replacedStyleFn["default"];
-  }
-});
-Object.defineProperty(exports, "sanitizeOutlineInput", {
-  enumerable: true,
-  get: function get() {
-    return _sanitizeOutlineInput["default"];
-  }
-});
-Object.defineProperty(exports, "separateCssStyle", {
-  enumerable: true,
-  get: function get() {
-    return _separateCssStyle["default"];
-  }
-});
-var _buildCssString = _interopRequireDefault(require("./buildCssString"));
-var _genCss = _interopRequireDefault(require("./genCss"));
-var _genStyles = _interopRequireDefault(require("./genStyles"));
-var _hasKids = _interopRequireDefault(require("./hasKids"));
-var _makeid = _interopRequireDefault(require("./makeid"));
-var _object2css = _interopRequireDefault(require("./object2css"));
-var _pubsub = _interopRequireDefault(require("./pubsub"));
-var _replaceColors = _interopRequireDefault(require("./replaceColors"));
-var _replacedStyleFn = _interopRequireDefault(require("./replacedStyleFn"));
-var _sanitizeOutlineInput = _interopRequireDefault(require("./sanitizeOutlineInput"));
-var _separateCssStyle = _interopRequireDefault(require("./separateCssStyle"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }

package/dist/utils/makeid.js

@@ -1,13 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = makeid;
-var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-function makeid() {
-  var side = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
-  var text = "";
-  for (var i = 0; i < side; i++) text += possible.charAt(~~(Math.random() * possible.length));
-  return text;
-}