rescript-polished 1.13.0 → 2.0.0

package/.github/dependabot.yml

@@ -0,0 +1,26 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: weekly
+    time: "04:00"
+  open-pull-requests-limit: 10
+  ignore:
+  - dependency-name: semantic-release
+    versions:
+    - 17.4.1
+  - dependency-name: rescript-dom-testing-library
+    versions:
+    - 1.12.0
+  - dependency-name: bs-platform
+    versions:
+    - 8.4.2
+    - 9.0.0
+    - 9.0.1
+  - dependency-name: polished
+    versions:
+    - 4.1.0
+  - dependency-name: mem
+    versions:
+    - 8.0.0

package/.github/workflows/release.yml

@@ -2,9 +2,9 @@ name: Release
 
 on:
   push:
-    branches: [master]
+    branches: [main]
   pull_request:
-    branches: [master]
+    branches: [main]
 
 jobs:
   build:
@@ -15,7 +15,7 @@ jobs:
       - name: Setup node
         uses: actions/setup-node@v1
         with:
-          node-version: "12.x"
+          node-version: "14.x"
       - name: Install dependencies
         run: yarn --frozen-lockfile --ignore-engines
       - name: Compile ReScript files
@@ -28,4 +28,4 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: yarn global add semantic-release && semantic-release
+        run: yarn global add semantic-release && semantic-release

package/README.md

@@ -6,7 +6,7 @@
 
 Bindings for [polished](https://polished.js.org/), _a lightweight toolset for writing styles in JavaScript_, **now in ReScript** ✨.
 
-**Note:** these bindings are still under development, check the [Polished](https://github.com/brnrdog/rescript-polished/blob/master/src/Polished.res) module to see the available functions.
+**Note:** these bindings are still under development, check the [Polished](https://github.com/brnrdog/rescript-polished/blob/main/src/Polished.res) module to see the available functions.
 
 ## Installation
 
@@ -33,10 +33,35 @@ For better convenience in ReScript, these bindings were written in a data-first
 ```rescript
 open Polished
 
-let primaryColor      = "#ed5051"
-let primaryColorLight = primaryColor -> Color.lighten(~amount=0.25) // #f9c4c4
-let primaryColorDark  = primaryColor -> Color.darken(~amount=0.25) // #ac1213
-let secondaryColor    = primaryColor -> Color.complement // #50edec
+let primaryColor = "#ed5051"
+let primaryColorLight = primaryColor->Color.lighten(~amount=0.25) // #f9c4c4
+let primaryColorDark = primaryColor->Color.darken(~amount=0.25) // #ac1213
+let secondaryColor = primaryColor->Color.complement // #50edec
+```
+
+If you're using `bs-css` or `bs-css-emotion`, you can use `PolishedCss`:
+
+```rescript
+module Style = {
+  open CssJs
+  open PolishedCss
+
+  let primary = #hex("e6484f") // or any possible Css_AtomicTypes.Color.t
+
+  let button = style(. [
+    background(primary),
+    hover([background(primary->Color.lighten(0.25))])
+    active([background(primary->Color.darken(0.25)]),
+    focus([
+      boxShadow(
+        Shadow.box(
+          primary->Color.transparentize(~amount=0.8),
+          ~spread=#rem(0.25),
+        ),
+      ),
+    ]),
+  ])
+}
 ```
 
 ## License

package/__tests__/PolishedCssTest.res

@@ -7,26 +7,77 @@ let toEqual = (x, y) => x |> toEqual(y)
 describe("Color", () => {
   open Color
 
-  test("shade", () => {
-    #hex("ff0000")->shade(~amount=0.25)->expect->toEqual(#hex("bf000"))
+  test("shade with hex", () => {
+    #hex("ff0000")->shade(~amount=0.25)->expect->toEqual(#hex("bf0000"))
   })
 
-  test("tint", () => {
-    #hex("ff0000")->tint(~amount=0.25)->expect->toEqual(#hex("ff3f3"))
+  test("shade with rgb", () => {
+    Css_AtomicTypes.Color.rgb(255, 0, 0)->shade(~amount=0.25)->expect->toEqual(#hex("bf0000"))
   })
 
-  test("darken", () => {
-    #hex("ff0000")->darken(~amount=0.25)->expect->toEqual(#hex("80000"))
+  test("shade with rgba", () => {
+    Css_AtomicTypes.Color.rgba(255, 0, 0, #num(0.25))
+    ->shade(~amount=0.25)
+    ->expect
+    ->toEqual(Css_AtomicTypes.Color.rgba(76, 0, 0, #num(0.4375)))
+  })
+
+  test("tint with hex", () => {
+    #hex("ff0000")->tint(~amount=0.25)->expect->toEqual(#hex("ff3f3f"))
+  })
+
+  test("tint with rgb", () => {
+    Css_AtomicTypes.Color.rgb(255, 0, 0)->tint(~amount=0.25)->expect->toEqual(#hex("ff3f3f"))
+  })
+
+  test("darken with hex", () => {
+    #hex("ff0000")->darken(~amount=0.25)->expect->toEqual(#hex("800000"))
   })
 
-  test("lighten", () => {
-    #hex("ff0000")->lighten(~amount=0.25)->expect->toEqual(#hex("ff808"))
+  test("lighten with hex", () => {
+    #hex("ff0000")->lighten(~amount=0.25)->expect->toEqual(#hex("ff8080"))
   })
 
-  test("transparentize", () => {
+  test("transparentize with hex", () => {
     #hex("ff0000")
     ->transparentize(~amount=0.5)
     ->expect
-    ->toEqual(Rgba.fromString("rgba(255, 0, 0, 0.5)"))
+    ->toEqual(Utils.Rgba.fromString("rgba(255, 0, 0, 0.5)"))
+  })
+
+  test("getContrast with hex", () => {
+    #hex("ff0000")->getContrast(#hex("0000ff"))->expect->toEqual(2.16)
+  })
+
+  test("getLuminance with hex", () => {
+    #hex("ff0000")->getLuminance->expect->toEqual(0.213)
+  })
+
+  test("grayscale with hex", () => {
+    #hex("ff0000")->grayscale->expect->toEqual(#hex("808080"))
+  })
+
+  test("desaturate with hex", () => {
+    #hex("ff0000")->desaturate(~amount=0.3)->expect->toEqual(#hex("d92626"))
+  })
+
+  test("complement with hex", () => {
+    #hex("ff0000")->complement->expect->toEqual(#hex("0ff"))
+  })
+
+  test("adjustHue with hex", () => {
+    #hex("ff0000")->adjustHue(~degree=0.3)->expect->toEqual(#hex("ff0100"))
+  })
+
+  describe("Utils", () => {
+    open Color.Utils
+
+    test("fromString with hex", () => {
+      "#ff0000"->fromString->expect->toEqual(#hex("ff0000"))
+    })
+
+    test("fromString with rgba", () => {
+      "rgba(255, 0, 0, 0.5)"->fromString->expect->toEqual(#rgba(255, 0, 0, #num(0.5)))
+    })
   })
 })

package/bsconfig.json

@@ -11,6 +11,12 @@
       "type": "dev"
     }
   ],
+  "package-specs": [
+    {
+      "module": "commonjs"
+    }
+  ],
+  "suffix": ".bs.js",
   "bs-dev-dependencies": ["@glennsl/bs-jest"],
   "bs-dependencies": ["bs-css"],
   "warnings": {

package/package.json

@@ -1,31 +1,48 @@
 {
   "name": "rescript-polished",
-  "version": "1.13.0",
+  "version": "2.0.0",
   "description": "ReScript bindings for polished.",
   "main": "dist/index.js",
   "repository": "https://github.com/brnrdog/rescript-polished",
   "author": "Bernardo Gurgel <brnrdog@hey.com>",
   "license": "MIT",
+  "keywords": [
+    "rescript",
+    "polished",
+    "color",
+    "css-in-js",
+    "color manipulate",
+    "color manipulation",
+    "colour",
+    "styled-components"
+  ],
+  "release": {
+    "branches": [
+      "main"
+    ]
+  },
   "scripts": {
-    "res:start": "bsb -make-world -w",
-    "res:build": "bsb -make-world",
-    "res:clean": "bsb -clean-world",
+    "res:start": "rescript build -w",
+    "res:build": "rescript build -with-deps",
+    "res:clean": "rescript clean -with-deps",
     "test": "jest",
     "test:ci": "jest --collect-coverage"
   },
   "dependencies": {
-    "bs-css": "^13.4.0",
-    "bs-platform": "^9.0.1",
-    "polished": "^4.0.3"
+    "bs-css": "^15.0.1",
+    "polished": "^4.0.3",
+    "rescript": "^9.1.4"
   },
   "devDependencies": {
-    "@glennsl/bs-jest": "^0.6.0",
-    "jest": "^26.6.3",
-    "semantic-release": "^17.2.2"
+    "@glennsl/bs-jest": "^0.7.0",
+    "jest": "^27.0.4",
+    "semantic-release": "^18.0.0"
   },
   "jest": {
     "collectCoverageFrom": [
-      "<rootDir>/lib/js/src/**/*.js"
+      "<rootDir>/{lib/js/src/**/*.js",
+      "!<rootDir>/lib/js/src/Polished.js",
+      "!<rootDir>/lib/js/src/PolishedCss.js"
     ],
     "verbose": true
   }

package/src/PolishedCss__Color.res

@@ -1,46 +1,72 @@
-module Rgba = {
+module Utils = {
   open Css_AtomicTypes
 
-  let regex = "rgba\(\s*(-?\d+|-?\d*\.\d+(?=%))\s*,\s*(-?\d+|-?\d*\.\d+(?=%))\s*,\s*(-?\d+|-?\d*\.\d+(?=%))\s*,\s*(-?\d+|-?\d*.\d+)\s*\)"
-  let rgbaRegexGroups = (_, i) => [1, 2, 3, 4]->Js.Array2.includes(i)
-  let rgbValue = v => v->Js.Nullable.toOption->Belt.Option.getUnsafe->int_of_string
-  let alphaValue = v => v->Js.Nullable.toOption->Belt.Option.getUnsafe->float_of_string
+  module Rgba = {
+    let regex = "rgba\(\s*(-?\d+|-?\d*\.\d+(?=%))\s*,\s*(-?\d+|-?\d*\.\d+(?=%))\s*,\s*(-?\d+|-?\d*\.\d+(?=%))\s*,\s*(-?\d+|-?\d*.\d+)\s*\)"
+    let rgbaRegexGroups = (_, i) => [1, 2, 3, 4]->Js.Array2.includes(i)
+    let rgbValue = v => v->Js.Nullable.toOption->Belt.Option.getExn->int_of_string
+    let alphaValue = v => v->Js.Nullable.toOption->Belt.Option.getUnsafe->float_of_string
 
-  let fromString = string => {
-    let values =
-      regex
-      ->Js.Re.fromString
-      ->Js.Re.exec_(string)
-      ->Belt.Option.getUnsafe
-      ->Js.Re.captures
-      ->Js.Array2.filteri(rgbaRegexGroups)
-
-    let red = values->Array.get(0)->rgbValue
-    let green = values->Array.get(1)->rgbValue
-    let blue = values->Array.get(2)->rgbValue
-    let alpha = values->Array.get(3)->alphaValue
-
-    Color.rgba(red, green, blue, #num(alpha))
+    let fromString = string => {
+      let result = regex->Js.Re.fromString->Js.Re.exec_(string)
+
+      switch result {
+      | None => None
+      | Some(result) => {
+          let values = result->Js.Re.captures->Js.Array2.filteri(rgbaRegexGroups)
+
+          let red = values->Array.get(0)->rgbValue
+          let green = values->Array.get(1)->rgbValue
+          let blue = values->Array.get(2)->rgbValue
+          let alpha = values->Array.get(3)->alphaValue
+
+          Some(Color.rgba(red, green, blue, #num(alpha)))
+        }
+      }
+    }
   }
-}
 
-module Hex = {
-  let fromString = string => #hex(string->Js.String2.slice(~from=1, ~to_=-1))
-  let toString = hex =>
-    switch hex {
-    | #hex(str) => "#" ++ str
+  module Hex = {
+    let fromString = string =>
+      #hex(string->Js.String2.slice(~from=1, ~to_=Js.String.length(string)))
+  }
+
+  let toString = Color.toString
+
+  let fromString = string => {
+    switch string->Js.String2.slice(~from=0, ~to_=4) {
+    | "rgba" => string->Rgba.fromString->Belt.Option.getExn
+    | _ => string->Hex.fromString
     }
+  }
 }
 
-let shade = (color, ~amount) => color->Hex.toString->Polished__Color.shade(~amount)->Hex.fromString
+let shade = (color, ~amount) => {
+  color->Utils.toString->Polished__Color.shade(~amount)->Utils.fromString
+}
 
-let tint = (color, ~amount) => color->Hex.toString->Polished__Color.tint(~amount)->Hex.fromString
+let tint = (color, ~amount) =>
+  color->Utils.toString->Polished__Color.tint(~amount)->Utils.fromString
 
 let lighten = (color, ~amount) =>
-  color->Hex.toString->Polished__Color.lighten(~amount)->Hex.fromString
+  color->Utils.toString->Polished__Color.lighten(~amount)->Utils.fromString
 
 let darken = (color, ~amount) =>
-  color->Hex.toString->Polished__Color.darken(~amount)->Hex.fromString
+  color->Utils.toString->Polished__Color.darken(~amount)->Utils.fromString
 
 let transparentize = (color, ~amount) =>
-  color->Hex.toString->Polished__Color.transparentize(~amount)->Rgba.fromString
+  color->Utils.toString->Polished__Color.transparentize(~amount)->Utils.Rgba.fromString
+
+let getContrast = (c1, c2) => c1->Utils.toString->Polished__Color.getContrast(c2->Utils.toString)
+
+let getLuminance = color => color->Utils.toString->Polished__Color.getLuminance
+
+let grayscale = color => color->Utils.toString->Polished__Color.grayscale->Utils.fromString
+
+let desaturate = (color, ~amount) =>
+  color->Utils.toString->Polished__Color.desaturate(~amount)->Utils.fromString
+
+let complement = color => color->Utils.toString->Polished__Color.complement->Utils.fromString
+
+let adjustHue = (color, ~degree) =>
+  color->Utils.toString->Polished__Color.adjustHue(~degree)->Utils.fromString

package/lib/js/__tests__/PolishedCssTest.js

@@ -1,63 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var Jest = require("@glennsl/bs-jest/lib/js/src/jest.js");
-var PolishedCss__Color = require("../src/PolishedCss__Color.js");
-
-function toEqual(x, y) {
-  return Jest.Expect.toEqual(y, x);
-}
-
-Jest.describe("Color", (function (param) {
-        Jest.test("shade", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.shade({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }, 0.25));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "bf000"
-                          }, x);
-              }));
-        Jest.test("tint", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.tint({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }, 0.25));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "ff3f3"
-                          }, x);
-              }));
-        Jest.test("darken", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.darken({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }, 0.25));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "80000"
-                          }, x);
-              }));
-        Jest.test("lighten", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.lighten({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }, 0.25));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "ff808"
-                          }, x);
-              }));
-        return Jest.test("transparentize", (function (param) {
-                      var y = PolishedCss__Color.Rgba.fromString("rgba(255, 0, 0, 0.5)");
-                      var x = Jest.Expect.expect(PolishedCss__Color.transparentize({
-                                NAME: "hex",
-                                VAL: "ff0000"
-                              }, 0.5));
-                      return Jest.Expect.toEqual(y, x);
-                    }));
-      }));
-
-exports.toEqual = toEqual;
-/*  Not a pure module */

package/lib/js/__tests__/PolishedTest.js

@@ -1,183 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var Jest = require("@glennsl/bs-jest/lib/js/src/jest.js");
-var Caml_option = require("bs-platform/lib/js/caml_option.js");
-var Polished__Math = require("../src/Polished__Math.js");
-var Polished__Color = require("../src/Polished__Color.js");
-var Polished__Mixins = require("../src/Polished__Mixins.js");
-
-function keepGoing(param) {
-  
-}
-
-Jest.describe("Color", (function (param) {
-        Jest.test("shade", (function (param) {
-                return Jest.Expect.toBe("#b13c3c", Jest.Expect.expect(Polished__Color.shade("#ed5051", 0.25)));
-              }));
-        Jest.test("tint", (function (param) {
-                return Jest.Expect.toBe("#f17b7c", Jest.Expect.expect(Polished__Color.tint("#ed5051", 0.25)));
-              }));
-        Jest.test("lighten", (function (param) {
-                return Jest.Expect.toBe("#f9c4c4", Jest.Expect.expect(Polished__Color.lighten("#ed5051", 0.25)));
-              }));
-        Jest.test("darken", (function (param) {
-                return Jest.Expect.toBe("#ac1213", Jest.Expect.expect(Polished__Color.darken("#ed5051", 0.25)));
-              }));
-        Jest.test("hsl", (function (param) {
-                return Jest.Expect.toBe("#734d26", Jest.Expect.expect(Polished__Color.hsl(30, 0.5, 0.3)));
-              }));
-        Jest.test("adjustHue", (function (param) {
-                return Jest.Expect.toBe("#ed9f50", Jest.Expect.expect(Polished__Color.adjustHue("#ed5051", 30.5)));
-              }));
-        Jest.test("complement", (function (param) {
-                return Jest.Expect.toBe("#50edec", Jest.Expect.expect(Polished__Color.complement("#ed5051")));
-              }));
-        Jest.test("desaturate", (function (param) {
-                return Jest.Expect.toBe("#9f9f9f", Jest.Expect.expect(Polished__Color.desaturate("#ed5051", 25.5)));
-              }));
-        Jest.test("getContrast", (function (param) {
-                return Jest.Expect.toBe(3.58, Jest.Expect.expect(Polished__Color.getContrast("#ed5051", "#fff")));
-              }));
-        Jest.test("getLuminance", (function (param) {
-                return Jest.Expect.toBe(0.243, Jest.Expect.expect(Polished__Color.getLuminance("#ed5051")));
-              }));
-        Jest.test("grayscale", (function (param) {
-                return Jest.Expect.toBe("#9f9f9f", Jest.Expect.expect(Polished__Color.grayscale("#ed5051")));
-              }));
-        Jest.test("hsla", (function (param) {
-                return Jest.Expect.toBe("rgba(96,159,106,0.5)", Jest.Expect.expect(Polished__Color.hsla(130, 0.25, 0.5, 0.5)));
-              }));
-        Jest.test("invert", (function (param) {
-                return Jest.Expect.toBe("#12a6ae", Jest.Expect.expect(Polished__Color.invert("#ed5951")));
-              }));
-        Jest.test("meetsContrastGuidelines", (function (param) {
-                var expected = {
-                  AA: true,
-                  AALarge: true,
-                  AAA: true,
-                  AAALarge: true
-                };
-                return Jest.Expect.toEqual(expected, Jest.Expect.expect(Polished__Color.meetsContrastGuidelines("#000000", "#ffffff")));
-              }));
-        Jest.test("transparentize", (function (param) {
-                return Jest.Expect.toBe("rgba(237,80,81,0.5)", Jest.Expect.expect(Polished__Color.transparentize("#ed5051", 0.5)));
-              }));
-        Jest.test("hslToColorString", (function (param) {
-                var hsl = {
-                  hue: 240,
-                  lightness: 1.0,
-                  saturation: 0.5
-                };
-                return Jest.Expect.toBe("#fff", Jest.Expect.expect(Polished__Color.hslToColorString(hsl)));
-              }));
-        Jest.test("mix", (function (param) {
-                return Jest.Expect.toBe("#c58383", Jest.Expect.expect(Polished__Color.mix("#ed5051", "#bc9090", 0.2)));
-              }));
-        Jest.test("opacify", (function (param) {
-                return Jest.Expect.toBe("rgba(237,80,81,0.5)", Jest.Expect.expect(Polished__Color.opacify("#ed505100", 0.5)));
-              }));
-        Jest.test("parseToHsl", (function (param) {
-                var expected = {
-                  hue: 0.0,
-                  lightness: 0.5,
-                  saturation: 1.0
-                };
-                return Jest.Expect.toEqual(expected, Jest.Expect.expect(Polished__Color.parseToHsl("#FF0000")));
-              }));
-        Jest.test("parseToRgb", (function (param) {
-                var expected = {
-                  red: 237,
-                  green: 80,
-                  blue: 81
-                };
-                return Jest.Expect.toEqual(expected, Jest.Expect.expect(Polished__Color.parseToRgb("#ed5051")));
-              }));
-        Jest.test("readableColor", (function (param) {
-                Jest.Expect.toBe("#fff", Jest.Expect.expect(Polished__Color.readableColor("#ed5051", undefined, undefined, false, undefined)));
-                Jest.Expect.toBe("#000", Jest.Expect.expect(Polished__Color.readableColor("#000", undefined, undefined, undefined, undefined)));
-                Jest.Expect.toBe("#ff8", Jest.Expect.expect(Polished__Color.readableColor("black", undefined, "#ff8", undefined, undefined)));
-                Jest.Expect.toBe("#001", Jest.Expect.expect(Polished__Color.readableColor("white", "#001", undefined, undefined, undefined)));
-                Jest.Expect.toBe("#000", Jest.Expect.expect(Polished__Color.readableColor("red", "#333", "#ddd", true, undefined)));
-                Jest.Expect.toBe("#333", Jest.Expect.expect(Polished__Color.readableColor("yellow", "#333", "#ddd", true, undefined)));
-                return Jest.Expect.toBe("#ddd", Jest.Expect.expect(Polished__Color.readableColor("blue", "#333", "#ddd", true, undefined)));
-              }));
-        Jest.test("rgb", (function (param) {
-                var subject = {
-                  red: 255,
-                  green: 255,
-                  blue: 255
-                };
-                return Jest.Expect.toBe("#fff", Jest.Expect.expect(Polished__Color.rgb(subject)));
-              }));
-        Jest.test("rgba", (function (param) {
-                var subject = {
-                  red: 255,
-                  green: 205,
-                  blue: 100,
-                  alpha: 0.7
-                };
-                return Jest.Expect.toBe("rgba(255,205,100,0.7)", Jest.Expect.expect(Polished__Color.rgba(subject)));
-              }));
-        Jest.test("saturate", (function (param) {
-                return Jest.Expect.toBe("#ff3e3f", Jest.Expect.expect(Polished__Color.saturate("#ed5051", 0.5)));
-              }));
-        Jest.test("setHue", (function (param) {
-                return Jest.Expect.toBe("#cdae64", Jest.Expect.expect(Polished__Color.setHue("#CCCD64", 42)));
-              }));
-        Jest.test("setLightness", (function (param) {
-                return Jest.Expect.toBe("#4d4d19", Jest.Expect.expect(Polished__Color.setLightness("#CCCD64", 0.2)));
-              }));
-        return Jest.test("setSaturation", (function (param) {
-                      return Jest.Expect.toBe("#adad84", Jest.Expect.expect(Polished__Color.setSaturation("#CCCD64", 0.2)));
-                    }));
-      }));
-
-Jest.describe("Math", (function (param) {
-        return Jest.test("math", (function (param) {
-                      Jest.Expect.toBe("20px", Jest.Expect.expect(Polished__Math.math("12px + 8px", undefined)));
-                      Jest.Expect.toBe("20rem", Jest.Expect.expect(Polished__Math.math("12rem + 8rem", undefined)));
-                      return Jest.Expect.toThrow(Jest.Expect.expect(function (param) {
-                                      return Polished__Math.math("10px + 8rem", param);
-                                    }));
-                    }));
-      }));
-
-Jest.describe("Mixins", (function (param) {
-        Jest.test("between", (function (param) {
-                return Jest.Expect.toMatchSnapshot(Jest.Expect.expect(Polished__Mixins.between("400px", "1000px", Polished__Mixins.Size.makeString("16px"), Polished__Mixins.Size.makeString("100px"), undefined)));
-              }));
-        Jest.test("clearfix", (function (param) {
-                return Jest.Expect.toMatchSnapshot(Jest.Expect.expect(Polished__Mixins.clearFix("div")));
-              }));
-        Jest.test("cover", (function (param) {
-                return Jest.Expect.toMatchSnapshot(Jest.Expect.expect(Polished__Mixins.cover(Caml_option.some(Polished__Mixins.Size.makeString("16px")), undefined)));
-              }));
-        Jest.test("ellipsis", (function (param) {
-                return Jest.Expect.toMatchSnapshot(Jest.Expect.expect(Polished__Mixins.ellipsis(Caml_option.some(Polished__Mixins.Size.makeString("16px")), 10, undefined)));
-              }));
-        Jest.test("fluidRange", (function (param) {
-                return Jest.Expect.toMatchSnapshot(Jest.Expect.expect(Polished__Mixins.fluidRange("320px", "1024px", {
-                                    prop: "padding",
-                                    fromSize: Polished__Mixins.Size.makeString("20px"),
-                                    toSize: Polished__Mixins.Size.makeString("20px")
-                                  })));
-              }));
-        return Jest.test("fluidRangeWithArray", (function (param) {
-                      return Jest.Expect.toMatchSnapshot(Jest.Expect.expect(Polished__Mixins.fluidRangeWithArray("320px", "1024px", [
-                                          {
-                                            prop: "padding",
-                                            fromSize: Polished__Mixins.Size.makeString("16px"),
-                                            toSize: Polished__Mixins.Size.makeString("32px")
-                                          },
-                                          {
-                                            prop: "margin",
-                                            fromSize: Polished__Mixins.Size.makeString("16px"),
-                                            toSize: Polished__Mixins.Size.makeString("32px")
-                                          }
-                                        ])));
-                    }));
-      }));
-
-exports.keepGoing = keepGoing;
-/*  Not a pure module */

package/lib/js/__tests__/__snapshots__/PolishedTest.js.snap

@@ -1,63 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Mixins between 1`] = `"calc(-40.00px + 14.00vw)"`;
-
-exports[`Mixins clearfix 1`] = `
-Object {
-  "div::after": Object {
-    "clear": "both",
-    "content": "\\"\\"",
-    "display": "table",
-  },
-}
-`;
-
-exports[`Mixins cover 1`] = `
-Object {
-  "bottom": "16px",
-  "left": "16px",
-  "position": "absolute",
-  "right": "16px",
-  "top": "16px",
-}
-`;
-
-exports[`Mixins ellipsis 1`] = `
-Object {
-  "WebkitBoxOrient": "vertical",
-  "WebkitLineClamp": 10,
-  "display": "-webkit-box",
-  "maxWidth": "16px",
-  "overflow": "hidden",
-  "textOverflow": "ellipsis",
-  "whiteSpace": "normal",
-  "wordWrap": "normal",
-}
-`;
-
-exports[`Mixins fluidRange 1`] = `
-Object {
-  "@media (min-width: 1024px)": Object {
-    "padding": "20px",
-  },
-  "@media (min-width: 320px)": Object {
-    "padding": "calc(20.00px + 0.00vw)",
-  },
-  "padding": "20px",
-}
-`;
-
-exports[`Mixins fluidRangeWithArray 1`] = `
-Object {
-  "@media (min-width: 1024px)": Object {
-    "margin": "32px",
-    "padding": "32px",
-  },
-  "@media (min-width: 320px)": Object {
-    "margin": "calc(8.73px + 2.27vw)",
-    "padding": "calc(8.73px + 2.27vw)",
-  },
-  "margin": "16px",
-  "padding": "16px",
-}
-`;

package/lib/js/src/Polished.js

@@ -1,14 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-
-var Color;
-
-var $$Math;
-
-var Mixins;
-
-exports.Color = Color;
-exports.$$Math = $$Math;
-exports.Mixins = Mixins;
-/* No side effect */

package/lib/js/src/PolishedCss.js

@@ -1,8 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-
-var Color;
-
-exports.Color = Color;
-/* No side effect */

package/lib/js/src/PolishedCss__Color.js

@@ -1,92 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var Caml_array = require("bs-platform/lib/js/caml_array.js");
-var Caml_format = require("bs-platform/lib/js/caml_format.js");
-var Caml_option = require("bs-platform/lib/js/caml_option.js");
-var Css_AtomicTypes = require("bs-css/lib/js/src/Css_AtomicTypes.js");
-var Polished__Color = require("./Polished__Color.js");
-
-var regex = "rgba\\(\\s*(-?\\d+|-?\\d*\\.\\d+(?=%))\\s*,\\s*(-?\\d+|-?\\d*\\.\\d+(?=%))\\s*,\\s*(-?\\d+|-?\\d*\\.\\d+(?=%))\\s*,\\s*(-?\\d+|-?\\d*.\\d+)\\s*\\)";
-
-function rgbaRegexGroups(param, i) {
-  return [
-            1,
-            2,
-            3,
-            4
-          ].includes(i);
-}
-
-function rgbValue(v) {
-  return Caml_format.caml_int_of_string((v == null) ? undefined : Caml_option.some(v));
-}
-
-function alphaValue(v) {
-  return Caml_format.caml_float_of_string((v == null) ? undefined : Caml_option.some(v));
-}
-
-function fromString(string) {
-  var values = Caml_option.null_to_opt(new RegExp(regex).exec(string)).filter(rgbaRegexGroups);
-  var red = Caml_format.caml_int_of_string(Caml_option.nullable_to_opt(Caml_array.get(values, 0)));
-  var green = Caml_format.caml_int_of_string(Caml_option.nullable_to_opt(Caml_array.get(values, 1)));
-  var blue = Caml_format.caml_int_of_string(Caml_option.nullable_to_opt(Caml_array.get(values, 2)));
-  var alpha = Caml_format.caml_float_of_string(Caml_option.nullable_to_opt(Caml_array.get(values, 3)));
-  return Css_AtomicTypes.Color.rgba(red, green, blue, {
-              NAME: "num",
-              VAL: alpha
-            });
-}
-
-var Rgba = {
-  regex: regex,
-  rgbaRegexGroups: rgbaRegexGroups,
-  rgbValue: rgbValue,
-  alphaValue: alphaValue,
-  fromString: fromString
-};
-
-function fromString$1(string) {
-  return {
-          NAME: "hex",
-          VAL: string.slice(1, -1)
-        };
-}
-
-function toString(hex) {
-  return "#" + hex.VAL;
-}
-
-var Hex = {
-  fromString: fromString$1,
-  toString: toString
-};
-
-function shade(color, amount) {
-  return fromString$1(Polished__Color.shade(toString(color), amount));
-}
-
-function tint(color, amount) {
-  return fromString$1(Polished__Color.tint(toString(color), amount));
-}
-
-function lighten(color, amount) {
-  return fromString$1(Polished__Color.lighten(toString(color), amount));
-}
-
-function darken(color, amount) {
-  return fromString$1(Polished__Color.darken(toString(color), amount));
-}
-
-function transparentize(color, amount) {
-  return fromString(Polished__Color.transparentize(toString(color), amount));
-}
-
-exports.Rgba = Rgba;
-exports.Hex = Hex;
-exports.shade = shade;
-exports.tint = tint;
-exports.lighten = lighten;
-exports.darken = darken;
-exports.transparentize = transparentize;
-/* Polished__Color Not a pure module */

package/lib/js/src/Polished__Color.js

@@ -1,144 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var Polished = require("polished");
-
-function shade(color, amount) {
-  return Polished.shade(amount, color);
-}
-
-function tint(color, amount) {
-  return Polished.tint(amount, color);
-}
-
-function lighten(color, amount) {
-  return Polished.lighten(amount, color);
-}
-
-function darken(color, amount) {
-  return Polished.darken(amount, color);
-}
-
-function hsl(hue, saturation, lightness) {
-  return Polished.hsl(hue, saturation, lightness);
-}
-
-function adjustHue(color, degree) {
-  return Polished.adjustHue(degree, color);
-}
-
-function complement(prim) {
-  return Polished.complement(prim);
-}
-
-function desaturate(color, amount) {
-  return Polished.desaturate(amount, color);
-}
-
-function getContrast(prim, prim$1) {
-  return Polished.getContrast(prim, prim$1);
-}
-
-function getLuminance(prim) {
-  return Polished.getLuminance(prim);
-}
-
-function grayscale(prim) {
-  return Polished.grayscale(prim);
-}
-
-function hsla(hue, saturation, lightness, alpha) {
-  return Polished.hsla(hue, saturation, lightness, alpha);
-}
-
-function invert(prim) {
-  return Polished.invert(prim);
-}
-
-function meetsContrastGuidelines(prim, prim$1) {
-  return Polished.meetsContrastGuidelines(prim, prim$1);
-}
-
-function transparentize(color, amount) {
-  return Polished.transparentize(amount, color);
-}
-
-function hslToColorString(prim) {
-  return Polished.hslToColorString(prim);
-}
-
-function mix(color1, color2, weight) {
-  return Polished.mix(weight, color1, color2);
-}
-
-function opacify(color, amount) {
-  return Polished.opacify(amount, color);
-}
-
-function parseToHsl(prim) {
-  return Polished.parseToHsl(prim);
-}
-
-function parseToRgb(prim) {
-  return Polished.parseToRgb(prim);
-}
-
-function readableColor(color, lightReturnColorOpt, darkReturnColorOpt, strictOpt, param) {
-  var lightReturnColor = lightReturnColorOpt !== undefined ? lightReturnColorOpt : "#fff";
-  var darkReturnColor = darkReturnColorOpt !== undefined ? darkReturnColorOpt : "#000";
-  var strict = strictOpt !== undefined ? strictOpt : true;
-  return Polished.readableColor(color, lightReturnColor, darkReturnColor, strict);
-}
-
-function rgb(prim) {
-  return Polished.rgb(prim);
-}
-
-function rgba(prim) {
-  return Polished.rgba(prim);
-}
-
-function saturate(color, amount) {
-  return Polished.saturate(amount, color);
-}
-
-function setHue(color, hue) {
-  return Polished.setHue(hue, color);
-}
-
-function setLightness(color, lightness) {
-  return Polished.setLightness(lightness, color);
-}
-
-function setSaturation(color, saturation) {
-  return Polished.setSaturation(saturation, color);
-}
-
-exports.shade = shade;
-exports.tint = tint;
-exports.lighten = lighten;
-exports.darken = darken;
-exports.hsl = hsl;
-exports.adjustHue = adjustHue;
-exports.complement = complement;
-exports.desaturate = desaturate;
-exports.getContrast = getContrast;
-exports.getLuminance = getLuminance;
-exports.grayscale = grayscale;
-exports.hsla = hsla;
-exports.invert = invert;
-exports.meetsContrastGuidelines = meetsContrastGuidelines;
-exports.transparentize = transparentize;
-exports.hslToColorString = hslToColorString;
-exports.mix = mix;
-exports.opacify = opacify;
-exports.parseToHsl = parseToHsl;
-exports.parseToRgb = parseToRgb;
-exports.readableColor = readableColor;
-exports.rgb = rgb;
-exports.rgba = rgba;
-exports.saturate = saturate;
-exports.setHue = setHue;
-exports.setLightness = setLightness;
-exports.setSaturation = setSaturation;
-/* polished Not a pure module */

package/lib/js/src/Polished__Math.js

@@ -1,11 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var Polished = require("polished");
-
-function math(prim, prim$1) {
-  return Polished.math(prim, prim$1);
-}
-
-exports.math = math;
-/* polished Not a pure module */

package/lib/js/src/Polished__Mixins.js

@@ -1,51 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var Polished = require("polished");
-var Js_undefined = require("bs-platform/lib/js/js_undefined.js");
-
-function makeString(s) {
-  return s;
-}
-
-function makeFloat(i) {
-  return i;
-}
-
-var Size = {
-  makeString: makeString,
-  makeFloat: makeFloat
-};
-
-function between(minScreen, maxScreen, fromSize, toSize, param) {
-  return Polished.between(fromSize, toSize, minScreen, maxScreen);
-}
-
-function clearFix(parent) {
-  return Polished.clearFix(parent);
-}
-
-function cover(offset, param) {
-  return Polished.cover(Js_undefined.fromOption(offset));
-}
-
-function ellipsis(width, lines, param) {
-  return Polished.ellipsis(Js_undefined.fromOption(width), lines);
-}
-
-function fluidRange(minScreen, maxScreen, cssProp) {
-  return Polished.fluidRange(cssProp, Js_undefined.fromOption(minScreen), Js_undefined.fromOption(maxScreen));
-}
-
-function fluidRangeWithArray(minScreen, maxScreen, cssProps) {
-  return Polished.fluidRange(cssProps, Js_undefined.fromOption(minScreen), Js_undefined.fromOption(maxScreen));
-}
-
-exports.Size = Size;
-exports.between = between;
-exports.clearFix = clearFix;
-exports.cover = cover;
-exports.ellipsis = ellipsis;
-exports.fluidRange = fluidRange;
-exports.fluidRangeWithArray = fluidRangeWithArray;
-/* polished Not a pure module */