Update dependencies

Add prettier
Change eslint config

.eslintrc.json

@@ -0,0 +1,10 @@
+{
+    "env": {
+        "es6": true
+    },
+    "extends": ["eslint:recommended", "eslint-config-prettier"],
+    "parserOptions": {
+        "ecmaVersion": 2017,
+        "sourceType": "module"
+    }
+}

.prettierrc.json

@@ -0,0 +1,3 @@
+{
+    "tabWidth": 4
+}

package.json

@@ -16,6 +16,14 @@
     "author": {
         "name": "Berk Çebi"
     },
+    "dependencies": {
+        "zem": "^1.0.6"
+    },
+    "devDependencies": {
+        "eslint": "^7.32.0",
+        "eslint-config-prettier": "^9.0.0",
+        "prettier": "^3.0.3"
+    },
     "zeplin": {
         "displayName": "JSON Design Tokens",
         "platforms": [
@@ -52,10 +60,5 @@
                 "default": true
             }
         ]
-    },
-    "devDependencies": {
-        "@zeplin/eslint-config": "^1.2.2",
-        "eslint": "^4.18.2",
-        "zem": "^0.4.2"
     }
 }

src/index.js

@@ -48,34 +48,52 @@ function textStyles(context) {
 
     let zeplinTextStyles;
     if (context.getOption("includeReferencedStyleguides")) {
-        zeplinTextStyles = getContainerReferencedObjects(container, "textStyles");
+        zeplinTextStyles = getContainerReferencedObjects(
+            container,
+            "textStyles",
+        );
     } else {
         zeplinTextStyles = container.textStyles;
     }
 
-    const extensionTextStyles = TextStyle.fromZeplinTextStyles(zeplinTextStyles, context);
+    const extensionTextStyles = TextStyle.fromZeplinTextStyles(
+        zeplinTextStyles,
+        context,
+    );
 
     return CodeObject.fromJSONObject(extensionTextStyles);
 }
 
 // TODO: Remove after 2020/01/01.
 function styleguideTextStyles(context, zeplinTextStyles) {
-    const extensionTextStyles = TextStyle.fromZeplinTextStyles(zeplinTextStyles, context);
+    const extensionTextStyles = TextStyle.fromZeplinTextStyles(
+        zeplinTextStyles,
+        context,
+    );
 
     return CodeObject.fromJSONObject(extensionTextStyles);
 }
 
 function exportTextStyles(context) {
     const textStylesCodeObject = textStyles(context);
 
-    return CodeExportObject.fromCodeObject(textStylesCodeObject, TEXT_STYLES_FILENAME);
+    return CodeExportObject.fromCodeObject(
+        textStylesCodeObject,
+        TEXT_STYLES_FILENAME,
+    );
 }
 
 // TODO: Remove after 2020/01/01.
 function exportStyleguideTextStyles(context, zeplinTextStyles) {
-    const textStylesCodeObject = styleguideTextStyles(context, zeplinTextStyles);
-
-    return CodeExportObject.fromCodeObject(textStylesCodeObject, TEXT_STYLES_FILENAME);
+    const textStylesCodeObject = styleguideTextStyles(
+        context,
+        zeplinTextStyles,
+    );
+
+    return CodeExportObject.fromCodeObject(
+        textStylesCodeObject,
+        TEXT_STYLES_FILENAME,
+    );
 }
 
 // TODO: Remove after 2020/01/01.
@@ -92,7 +110,9 @@ function getContainerReferencedObjects(container, key) {
         return containerObjects;
     }
 
-    return containerObjects.concat(getContainerReferencedObjects(referencedStyleguide, key));
+    return containerObjects.concat(
+        getContainerReferencedObjects(referencedStyleguide, key),
+    );
 }
 
 export default {
@@ -104,5 +124,5 @@ export default {
     styleguideTextStyles,
     exportTextStyles,
     exportStyleguideTextStyles,
-    comment
+    comment,
 };

src/model/codeExportObject.js

@@ -1,21 +1,17 @@
 export default class CodeExportObject {
-    constructor({
-        code,
-        language,
-        filename
-    }) {
+    constructor({ code, language, filename }) {
         Object.assign(this, {
             code,
             language,
-            filename
+            filename,
         });
     }
 
     static fromCodeObject(codeObject, filename) {
         return new CodeExportObject({
             code: codeObject.code,
             language: codeObject.language,
-            filename
+            filename,
         });
     }
 }

src/model/codeObject.js

@@ -1,20 +1,17 @@
 const JSON_STRINGIFY_SPACE = 2;
 
 export default class CodeObject {
-    constructor({
-        code,
-        language
-    }) {
+    constructor({ code, language }) {
         Object.assign(this, {
             code,
-            language
+            language,
         });
     }
 
     static fromJSONObject(object) {
         return new CodeObject({
             code: JSON.stringify(object, null, JSON_STRINGIFY_SPACE),
-            language: "json"
+            language: "json",
         });
     }
 }

src/model/color.js

@@ -1,21 +1,13 @@
 export default class Color {
-    constructor({
-        name,
-        red,
-        green,
-        blue,
-        hex,
-        hsla,
-        alpha
-    }) {
+    constructor({ name, red, green, blue, hex, hsla, alpha }) {
         Object.assign(this, {
             name,
             red,
             green,
             blue,
             hex,
             hsla,
-            alpha
+            alpha,
         });
     }
 
@@ -29,7 +21,7 @@ export default class Color {
                     red: zeplinColor.r,
                     green: zeplinColor.g,
                     blue: zeplinColor.b,
-                    alpha: zeplinColor.a
+                    alpha: zeplinColor.a,
                 });
             }
             case "hex": {
@@ -38,7 +30,7 @@ export default class Color {
                 return new Color({
                     name: zeplinColor.name,
                     hex: hex.r + hex.g + hex.b,
-                    alpha: zeplinColor.a
+                    alpha: zeplinColor.a,
                 });
             }
             case "hsla": {
@@ -48,16 +40,18 @@ export default class Color {
                         zeplinColor.r,
                         zeplinColor.g,
                         zeplinColor.b,
-                        zeplinColor.a
-                    )
+                        zeplinColor.a,
+                    ),
                 });
             }
             default:
         }
     }
 
     static fromZeplinColors(zeplinColors, context) {
-        return zeplinColors.map(zeplinColor => Color.fromZeplinColor(zeplinColor, context));
+        return zeplinColors.map((zeplinColor) =>
+            Color.fromZeplinColor(zeplinColor, context),
+        );
     }
 
     static rgbaToHsla(red, green, blue, a) {

src/model/textStyle.js

@@ -1,39 +1,26 @@
 import Color from "./color";
 
 class Font {
-    constructor({
-        postscriptName,
-        family,
-        size,
-        weight,
-        stretch
-    }) {
+    constructor({ postscriptName, family, size, weight, stretch }) {
         Object.assign(this, {
             postscriptName,
             family,
             size,
             weight,
-            stretch
+            stretch,
         });
     }
 }
 
 export default class TextStyle {
-    constructor({
-        name,
-        letterSpacing,
-        lineHeight,
-        alignment,
-        font,
-        color
-    }) {
+    constructor({ name, letterSpacing, lineHeight, alignment, font, color }) {
         Object.assign(this, {
             name,
             letterSpacing,
             lineHeight,
             alignment,
             font,
-            color
+            color,
         });
     }
 
@@ -43,7 +30,9 @@ export default class TextStyle {
 
         let color;
         if (zeplinTextStyle.color) {
-            const zeplinColor = container.findColorEqual(zeplinTextStyle.color) || zeplinTextStyle.color;
+            const zeplinColor =
+                container.findColorEqual(zeplinTextStyle.color) ||
+                zeplinTextStyle.color;
 
             color = Color.fromZeplinColor(zeplinColor, context);
         }
@@ -53,7 +42,7 @@ export default class TextStyle {
             family: zeplinTextStyle.fontFamily,
             size: zeplinTextStyle.fontSize,
             weight: zeplinTextStyle.weightText,
-            stretch: zeplinTextStyle.fontStretch
+            stretch: zeplinTextStyle.fontStretch,
         });
 
         return new TextStyle({
@@ -62,11 +51,13 @@ export default class TextStyle {
             lineHeight: zeplinTextStyle.lineHeight,
             alignment: zeplinTextStyle.textAlign,
             font,
-            color
+            color,
         });
     }
 
     static fromZeplinTextStyles(zeplinTextStyles, context) {
-        return zeplinTextStyles.map(zeplinTextStyle => TextStyle.fromZeplinTextStyle(zeplinTextStyle, context));
+        return zeplinTextStyles.map((zeplinTextStyle) =>
+            TextStyle.fromZeplinTextStyle(zeplinTextStyle, context),
+        );
     }
 }