Compile logical properties

Author: devongovett

build-prefixes.js

@@ -195,7 +195,8 @@ let mdnFeatures = {
   placeItems: mdn.css.properties['place-items'].__compat.support,
   overflowShorthand: mdn.css.properties['overflow'].multiple_keywords.__compat.support,
   mediaRangeSyntax: mdn.css['at-rules'].media.range_syntax.__compat.support,
-  mediaIntervalSyntax: {} // currently no browsers
+  mediaIntervalSyntax: {}, // currently no browsers
+  logicalBorders: mdn.css.properties['border-inline-start'].__compat.support
 };
 
 for (let feature in mdnFeatures) {

src/compat.rs

@@ -32,6 +32,7 @@ pub enum Feature {
   DoublePositionGradients,
   FormValidation,
   Fullscreen,
+  LogicalBorders,
   MediaIntervalSyntax,
   MediaRangeSyntax,
   OverflowShorthand,
@@ -1287,6 +1288,48 @@ impl Feature {
           }
         }
       }
+      Feature::LogicalBorders => {
+        if let Some(version) = browsers.chrome {
+          if version >= 4521984 {
+            return true
+          }
+        }
+        if let Some(version) = browsers.edge {
+          if version >= 5177344 {
+            return true
+          }
+        }
+        if let Some(version) = browsers.firefox {
+          if version >= 2686976 {
+            return true
+          }
+        }
+        if let Some(version) = browsers.opera {
+          if version >= 3145728 {
+            return true
+          }
+        }
+        if let Some(version) = browsers.safari {
+          if version >= 786688 {
+            return true
+          }
+        }
+        if let Some(version) = browsers.ios_saf {
+          if version >= 786944 {
+            return true
+          }
+        }
+        if let Some(version) = browsers.samsung {
+          if version >= 655360 {
+            return true
+          }
+        }
+        if let Some(version) = browsers.android {
+          if version >= 4521984 {
+            return true
+          }
+        }
+      }
     }
     false
   }

src/declaration.rs

@@ -24,6 +24,7 @@ use crate::properties::{
 use crate::targets::Browsers;
 use crate::parser::ParserOptions;
 use crate::error::{ParserError, PrinterError};
+use crate::logical::LogicalProperties;
 
 #[derive(Debug, PartialEq)]
 pub struct DeclarationBlock {
@@ -67,20 +68,25 @@ impl ToCss for DeclarationBlock {
 }
 
 impl DeclarationBlock {
-  pub(crate) fn minify(&mut self, handler: &mut DeclarationHandler, important_handler: &mut DeclarationHandler) {
+  pub(crate) fn minify(
+    &mut self,
+    handler: &mut DeclarationHandler,
+    important_handler: &mut DeclarationHandler,
+    logical_properties: &mut LogicalProperties
+  ) {
     let mut decls: Vec<Declaration> = vec![];
     for decl in self.declarations.iter() {
       let handled = 
-        (decl.important && important_handler.handle_property(decl)) ||
-        (!decl.important && handler.handle_property(decl));
+        (decl.important && important_handler.handle_property(decl, logical_properties)) ||
+        (!decl.important && handler.handle_property(decl, logical_properties));
 
       if !handled {
         decls.push(decl.clone());
       }
     }
 
-    decls.extend(handler.finalize());
-    decls.extend(important_handler.finalize());
+    decls.extend(handler.finalize(logical_properties));
+    decls.extend(important_handler.finalize(logical_properties));
     self.declarations = decls;
   }
 }
@@ -157,7 +163,6 @@ impl DeclarationList {
   }
 }
 
-#[derive(Default)]
 pub(crate) struct DeclarationHandler {
   background: BackgroundHandler,
   border: BorderHandler,
@@ -188,68 +193,76 @@ impl DeclarationHandler {
     DeclarationHandler {
       background: BackgroundHandler::new(targets),
       border: BorderHandler::new(targets),
+      outline: OutlineHandler::default(),
       flex: FlexHandler::new(targets),
+      grid: GridHandler::default(),
       align: AlignHandler::new(targets),
+      margin: MarginHandler::default(),
+      padding: PaddingHandler::default(),
+      scroll_margin: ScrollMarginHandler::default(),
+      scroll_padding: ScrollPaddingHandler::default(),
+      font: FontHandler::default(),
+      text: TextDecorationHandler::new(targets),
+      list: ListStyleHandler::default(),
       transition: TransitionHandler::new(targets),
       animation: AnimationHandler::new(targets),
       display: DisplayHandler::new(targets),
       position: PositionHandler::new(targets),
+      inset: InsetHandler::default(),
       overflow: OverflowHandler::new(targets),
       transform: TransformHandler::new(targets),
-      text: TextDecorationHandler::new(targets),
       prefix: PrefixHandler::new(targets),
-      decls: DeclarationList::new(important),
-      ..DeclarationHandler::default()
+      decls: DeclarationList::new(important)
     }
   }
 
-  pub fn handle_property(&mut self, decl: &Declaration) -> bool {
+  pub fn handle_property(&mut self, decl: &Declaration, logical_properties: &mut LogicalProperties) -> bool {
     let property = &decl.property;
-    self.background.handle_property(property, &mut self.decls) ||
-    self.border.handle_property(property, &mut self.decls) ||
-    self.outline.handle_property(property, &mut self.decls) ||
-    self.flex.handle_property(property, &mut self.decls) ||
-    self.grid.handle_property(property, &mut self.decls) ||
-    self.align.handle_property(property, &mut self.decls) ||
-    self.margin.handle_property(property, &mut self.decls) ||
-    self.padding.handle_property(property, &mut self.decls) ||
-    self.scroll_margin.handle_property(property, &mut self.decls) ||
-    self.scroll_padding.handle_property(property, &mut self.decls) ||
-    self.font.handle_property(property, &mut self.decls) ||
-    self.text.handle_property(property, &mut self.decls) ||
-    self.list.handle_property(property, &mut self.decls) ||
-    self.transition.handle_property(property, &mut self.decls) ||
-    self.animation.handle_property(property, &mut self.decls) ||
-    self.display.handle_property(property, &mut self.decls) ||
-    self.position.handle_property(property, &mut self.decls) ||
-    self.inset.handle_property(property, &mut self.decls) ||
-    self.overflow.handle_property(property, &mut self.decls) ||
-    self.transform.handle_property(property, &mut self.decls) ||
-    self.prefix.handle_property(property, &mut self.decls)
+    self.background.handle_property(property, &mut self.decls, logical_properties) ||
+    self.border.handle_property(property, &mut self.decls, logical_properties) ||
+    self.outline.handle_property(property, &mut self.decls, logical_properties) ||
+    self.flex.handle_property(property, &mut self.decls, logical_properties) ||
+    self.grid.handle_property(property, &mut self.decls, logical_properties) ||
+    self.align.handle_property(property, &mut self.decls, logical_properties) ||
+    self.margin.handle_property(property, &mut self.decls, logical_properties) ||
+    self.padding.handle_property(property, &mut self.decls, logical_properties) ||
+    self.scroll_margin.handle_property(property, &mut self.decls, logical_properties) ||
+    self.scroll_padding.handle_property(property, &mut self.decls, logical_properties) ||
+    self.font.handle_property(property, &mut self.decls, logical_properties) ||
+    self.text.handle_property(property, &mut self.decls, logical_properties) ||
+    self.list.handle_property(property, &mut self.decls, logical_properties) ||
+    self.transition.handle_property(property, &mut self.decls, logical_properties) ||
+    self.animation.handle_property(property, &mut self.decls, logical_properties) ||
+    self.display.handle_property(property, &mut self.decls, logical_properties) ||
+    self.position.handle_property(property, &mut self.decls, logical_properties) ||
+    self.inset.handle_property(property, &mut self.decls, logical_properties) ||
+    self.overflow.handle_property(property, &mut self.decls, logical_properties) ||
+    self.transform.handle_property(property, &mut self.decls, logical_properties) ||
+    self.prefix.handle_property(property, &mut self.decls, logical_properties)
   }
 
-  pub fn finalize(&mut self) -> Vec<Declaration> {
-    self.background.finalize(&mut self.decls);
-    self.border.finalize(&mut self.decls);
-    self.outline.finalize(&mut self.decls);
-    self.flex.finalize(&mut self.decls);
-    self.grid.finalize(&mut self.decls);
-    self.align.finalize(&mut self.decls);
-    self.margin.finalize(&mut self.decls);
-    self.padding.finalize(&mut self.decls);
-    self.scroll_margin.finalize(&mut self.decls);
-    self.scroll_padding.finalize(&mut self.decls);
-    self.font.finalize(&mut self.decls);
-    self.text.finalize(&mut self.decls);
-    self.list.finalize(&mut self.decls);
-    self.transition.finalize(&mut self.decls);
-    self.animation.finalize(&mut self.decls);
-    self.display.finalize(&mut self.decls);
-    self.position.finalize(&mut self.decls);
-    self.inset.finalize(&mut self.decls);
-    self.overflow.finalize(&mut self.decls);
-    self.transform.finalize(&mut self.decls);
-    self.prefix.finalize(&mut self.decls);
+  pub fn finalize(&mut self, logical_properties: &mut LogicalProperties) -> Vec<Declaration> {
+    self.background.finalize(&mut self.decls, logical_properties);
+    self.border.finalize(&mut self.decls, logical_properties);
+    self.outline.finalize(&mut self.decls, logical_properties);
+    self.flex.finalize(&mut self.decls, logical_properties);
+    self.grid.finalize(&mut self.decls, logical_properties);
+    self.align.finalize(&mut self.decls, logical_properties);
+    self.margin.finalize(&mut self.decls, logical_properties);
+    self.padding.finalize(&mut self.decls, logical_properties);
+    self.scroll_margin.finalize(&mut self.decls, logical_properties);
+    self.scroll_padding.finalize(&mut self.decls, logical_properties);
+    self.font.finalize(&mut self.decls, logical_properties);
+    self.text.finalize(&mut self.decls, logical_properties);
+    self.list.finalize(&mut self.decls, logical_properties);
+    self.transition.finalize(&mut self.decls, logical_properties);
+    self.animation.finalize(&mut self.decls, logical_properties);
+    self.display.finalize(&mut self.decls, logical_properties);
+    self.position.finalize(&mut self.decls, logical_properties);
+    self.inset.finalize(&mut self.decls, logical_properties);
+    self.overflow.finalize(&mut self.decls, logical_properties);
+    self.transform.finalize(&mut self.decls, logical_properties);
+    self.prefix.finalize(&mut self.decls, logical_properties);
     std::mem::take(&mut self.decls.declarations)
   }
 }