Merge branch 'develop'

README.md

@@ -153,6 +153,34 @@ Use color names from Color Palette or default `UIColor(red:green:blue:alpha:)` i
 #### Use custom color initializer
 Use `UIColor(r:g:b:a:)` initializer.
 
+#### Use layer extension for shadows
+Use this function for shadow parameters. Don't forget to add this extension to your project.
+
+```swift
+import UIKit
+
+extension CALayer {
+
+    func makeShadow(color: UIColor,
+                    x: CGFloat = 0,
+                    y: CGFloat = 0,
+                    blur: CGFloat = 0,
+                    spread: CGFloat = 0) {
+        shadowColor = color.cgColor
+        shadowOpacity = 1
+        shadowOffset = CGSize(width: x, height: y)
+        shadowRadius = blur / 2
+        if spread == 0 {
+            shadowPath = nil
+        }
+        else {
+            let rect = bounds.insetBy(dx: -spread, dy: -spread)
+            shadowPath = UIBezierPath(rect: rect).cgPath
+        }
+    }
+}
+```
+
 ## How to Install
 
 Download and unzip [the latest release](https://github.com/artemnovichkov/zepcode/releases/).

package.json

@@ -1,6 +1,6 @@
 {
   "name": "zepcode",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "Generates Swift snippets from colors, fonts and layers.",
   "lint-staged": {
     "src/**/*.{js,json}": [
@@ -67,6 +67,12 @@
         "type": "switch",
         "id": "use_custom_color_initializer",
         "default": false
+      },
+      {
+        "name": "Use layer extension for shadows",
+        "type": "switch",
+        "id": "use_layer_shadow_extension",
+        "default": false
       }
     ]
   }

src/index.js

@@ -59,19 +59,7 @@ function layer(context, layerParams) {
 
   if (layerParams.shadows.length) {
     const shadow = layerParams.shadows[0];
-    const { color } = shadow;
-
-    if (color !== undefined) {
-      const shadowColor = zepcodeInstance.cgColorString(shadow.color);
-      string += `view.layer.shadowColor = ${shadowColor}\n`;
-    }
-    string += `view.layer.shadowOffset = `;
-    if (shadow.offsetX && shadow.offsetY) {
-      string += `CGSize(width: ${shadow.offsetX}, height: ${shadow.offsetY})\n`;
-    } else {
-      string += `.zero\n`;
-    }
-    string += `view.layer.shadowRadius = ${layerParams.borderRadius}`;
+    string += zepcodeInstance.shadow(shadow);
   }
 
   let result = {};

src/templates/custom-shadow.js

@@ -0,0 +1,15 @@
+const customShadowTemplate = (shadow, colorString) => `view.layer.makeShadow(color: ${colorString}${
+    shadow.offsetX ? `,
+                      x: ${shadow.offsetX}` : ``
+}${
+    shadow.offsetY ? `,
+                      y: ${shadow.offsetY}` : ``
+}${
+    shadow.blurRadius ? `,
+                      blur: ${shadow.blurRadius}` : ``
+}${
+    shadow.spread ? `,
+                      spread: ${shadow.spread}` : ``
+})`;
+
+export default customShadowTemplate;

src/templates/shadow.js

@@ -0,0 +1,17 @@
+import customColorTemplate from './custom-color';
+import colorTemplate from './color';
+
+const shadowTemplate = (shadow, colorString) => `view.layer.shadowColor = ${colorString}
+view.layer.shadowOpacity = 1
+view.layer.shadowOffset = ${
+    shadow.offsetX || shadow.offsetY
+    ? `CGSize(width: ${shadow.offsetX}, height: ${shadow.offsetY})` 
+    : `.zero`}
+view.layer.shadowRadius = ${shadow.blurRadius} / 2
+${
+    shadow.spread > 0
+    ? `let rect = view.bounds.insetBy(dx: ${-shadow.spread}, dy: ${-shadow.spread})
+view.layer.shadowPath = UIBezierPath(rect: rect).cgPath`
+    : `view.layer.shadowPath = nil`}`;
+
+export default shadowTemplate;

src/zepcode.js

@@ -5,6 +5,8 @@ import linearGradientTemplate from './templates/linear-gradient';
 import radialGradientTemplate from './templates/radial-gradient';
 import fontExtensionTemplate from './templates/font-extension';
 import headerTemplate from './templates/header';
+import shadowTemplate from './templates/shadow';
+import customShadowTemplate from './templates/custom-shadow';
 
 const zepcode = (() => {
   let instance;
@@ -18,24 +20,28 @@ const zepcode = (() => {
           useCustomColorInitializer: privateContext.getOption(
             'use_custom_color_initializer'
           ),
+          useLayerShadowExtension: privateContext.getOption(
+            'use_layer_shadow_extension'
+          ),
         },
         project: privateContext.project,
       };
     }
 
-    me.cgColorString = color => {
+    me.colorString = (color, postfix) => {
       const styleguideColor = me.project.findColorEqual(color);
-      const cgColorPostfix = '.cgColor';
 
       if (me.options.useColorNames && styleguideColor) {
-        return `UIColor.${styleguideColor.name}${cgColorPostfix}`;
+        return `UIColor.${styleguideColor.name}${postfix}`;
       }
       if (me.options.useCustomColorInitializer) {
-        return customColorTemplate(color) + cgColorPostfix;
+        return customColorTemplate(color) + postfix;
       }
-      return colorTemplate(color) + cgColorPostfix;
+      return colorTemplate(color) + postfix;
     };
 
+    me.cgColorString = color => me.colorString(color, `.cgColor`);
+
     me.colorStopsString = gradient => {
       const { colorStops } = gradient;
       return colorStops
@@ -81,6 +87,15 @@ const zepcode = (() => {
       };
     };
 
+    me.shadow = shadow => {
+      if (me.options.useLayerShadowExtension) {
+        const colorString = me.colorString(shadow.color, ``);
+        return customShadowTemplate(shadow, colorString);
+      }
+      const colorString = me.cgColorString(shadow.color);
+      return shadowTemplate(shadow, colorString);
+    };
+
     return me;
   }