Release package version 0.0.2

Update models, added parser

lib/src/parser.ts

@@ -0,0 +1,104 @@
+import { _switch } from "@gxc-solutions/lett-js";
+import {
+  FillType,
+  GradientType,
+  IBaseFill,
+  IEllipseModel,
+  IImageModel,
+  IModel,
+  IRectangle,
+  IRectangleModel,
+  ISolidFill,
+  IStroke,
+  ITransform,
+  TypeOfModel,
+} from "./interfaces";
+import { EllipseObject } from "./models/objects/ellipce";
+import { ImageItem } from "./models/objects/image";
+import { Stroke } from "./models/stroke";
+import { SolidFill } from "./models/solid-fill";
+import { Ellipse, Rectangle, Transform } from "@gxc-solutions/math";
+import { RectangleItem } from "./models/objects/rectangle";
+
+export class Parser {
+  constructor() {}
+
+  parse() {}
+
+  parseModel(objects: IModel[]) {
+    return objects.map((object) =>
+      _switch<TypeOfModel, EllipseObject | ImageItem | RectangleItem>(object.type)
+        .case("ellipse-model", () => {
+          const ellipseObj = object as IEllipseModel;
+          const ellipse = new EllipseObject(ellipseObj.id);
+
+          ellipse.ellipse = new Ellipse(ellipseObj.ellipse.center, ellipseObj.ellipse.radiusX, ellipseObj.ellipse.radiusY);
+          ellipse.blendMode = ellipseObj.blendMode;
+          ellipse.opacity = ellipseObj.opacity;
+          ellipse.stroke = this.parseStroke(ellipseObj.stroke);
+          ellipse.fill = this.parseFill(ellipseObj.fill);
+          ellipse.transform = this.parseTransform(ellipseObj.transform);
+          return ellipse;
+        })
+        .case("image-model", () => {
+          const imageObj = object as IImageModel;
+          const image = new ImageItem(imageObj.id);
+
+          image.rectangle = this.parseRectangle(imageObj.rectangle);
+          image.blendMode = imageObj.blendMode;
+          image.opacity = imageObj.opacity;
+          image.stroke = this.parseStroke(imageObj.stroke);
+          image.fill = this.parseFill(imageObj.fill);
+          image.transform = this.parseTransform(imageObj.transform);
+          image.image = {
+            isLoading: true,
+            image: null,
+            url: imageObj.url,
+          };
+          return image;
+        })
+        .case("rectangle-model", () => {
+          const rectangleObj = object as IRectangleModel;
+          const rectangle = new RectangleItem(rectangleObj.id);
+
+          rectangle.rectangle = this.parseRectangle(rectangleObj.rectangle);
+          rectangle.blendMode = rectangleObj.blendMode;
+          rectangle.opacity = rectangleObj.opacity;
+          rectangle.stroke = this.parseStroke(rectangleObj.stroke);
+          rectangle.fill = this.parseFill(rectangleObj.fill);
+          rectangle.transform = this.parseTransform(rectangleObj.transform);
+          return rectangle;
+        })
+        .result(),
+    );
+  }
+
+  parseStroke(strokeObj: IStroke) {
+    return new Stroke(strokeObj.width, strokeObj.color, strokeObj.dash);
+  }
+
+  parseFill(fillObj: IBaseFill) {
+    return _switch<GradientType | FillType, SolidFill>(fillObj.type)
+      .case("solid", () => {
+        const solidFillObj = fillObj as ISolidFill;
+        return new SolidFill(solidFillObj.color);
+      })
+      .result();
+  }
+
+  parseTransform(transformObj: ITransform) {
+    const transform = new Transform();
+    transform.rotate = transformObj.rotate;
+    transform.scaleX = transformObj.scaleX;
+    transform.scaleY = transformObj.scaleY;
+    transform.skewX = transformObj.skewX;
+    transform.skewY = transformObj.skewY;
+    transform.translateX = transformObj.translateX;
+    transform.translateY = transformObj.translateY;
+    return transform;
+  }
+
+  parseRectangle(rectangleObj: IRectangle) {
+    return new Rectangle(rectangleObj.top, rectangleObj.left, rectangleObj.width, rectangleObj.height);
+  }
+}