@aurigma/design-atoms-model 6.5.30 → 6.5.33

package/Product/Serializer/ProductParser.js

@@ -1,765 +0,0 @@
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spread = (this && this.__spread) || function () {
-    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
-    return ar;
-};
-import { Product } from "../Product";
-import { Surface } from "../Surface";
-import { SurfaceMockup } from "../SurfaceMockup";
-import * as _ from "underscore";
-import { MockupContainer, Container, SurfaceContainer, SpotColorContainer, TextureContainer } from "../Container";
-import { SizeF, RectangleF, PointF, Path, RotatedRectangleF } from "../../Math/index";
-import { SafetyLine } from "../SafetyLine";
-import { CropMark, CropMarkText } from "../CropMark";
-import { PrintArea } from "../PrintArea";
-import { ItemMask } from "../ItemMask";
-import { RectangleItem, EllipseItem, ShapeItem, BaseTextItem, PlainTextItem, ImageItem, BoundedTextItem, CurvedTextItem, PathBoundedTextItem, BarcodeItem, PlaceholderItem, LineItem, DashedLineItem, AutoScaledTextItem, ThemeBinding, SmartItem, InStringPlaceholder, ImageMetaData, OverlayEffect, GroupItem, ArchedTextItem, EncodingOptions, LayoutItem } from "../Items";
-import { NotImplementedException, Exception } from "../../Exception";
-import { ColorFactory } from "../../Colors";
-import { Transform } from "../../Math/Transform";
-import { ManipulationPermissions, ContentPermissions, BarcodePermissions, TextPermissions, ImagePermissions, ItemPermissions, ItemToolbarPermissions, FrontendPermissions, ResizeGripsPermissions, ShapePermissions, PathBoundedTextPermissions, PlaceholderPermissions, VisualizationPermissions, LinePermissions } from "../Items";
-import { ParagraphSettings } from "../Items/ParagraphSettings";
-import { StrokeSettings } from "../Items/StrokeSettings";
-import { ShadowSettings } from "../Items/ShadowSettings";
-import { MODELVERSION } from "../../Version";
-import { Collection } from "../../Collection";
-import { WatermarkConfig, WatermarkTextConfig, WatermarkImageConfig, WatermarkVisibilityConfig } from "../../Configuration/WatermarkConfig";
-import { Watermark } from "..";
-import { GroupItemPermissions } from "../Items/GroupItemPermissions";
-import { ClipartItem, ColorGroup } from "../Items/ClipartItem";
-import { Margin } from "../../Math/Margin";
-import { DefaultLayoutSettings, AutoLayoutSettings } from "../Items/LayoutItem";
-import { ViolationSettings } from "../Items/ViolationSettings";
-import { ShapeViolationSettings } from "../Items/ShapeViolationSettings";
-import { ImageViolationSettings } from "../Items/ImageViolationSettings";
-import { TextViolationSettings } from "../Items/TextViolationSettings";
-var ProductParser = /** @class */ (function () {
-    function ProductParser(additionalConverters) {
-        var _this = this;
-        this.parseSurface = function (rawSurface) {
-            var surface = new Surface();
-            _this._parseModelComponent(rawSurface, surface, [
-                new PropertyConverter("mockup", _this.parseMockup.bind(_this)),
-                new PropertyConverter("printAreas", function (rawContainers) { return _this.parseCollection(rawContainers, _this.parsePrintArea, surface.printAreas); }, true),
-                new PropertyConverter("containers", function (rawContainers) { return _this.parseCollection(rawContainers, _this.parseSurfaceContainer, surface.containers); }, true),
-                new PropertyConverter("previewMockups", function (rawContainers) { return _this.parseCollection(rawContainers, _this.parseMockup.bind(_this), surface.previewMockups); }, true),
-                new PropertyConverter("watermark", _this.parseWatermark.bind(_this))
-            ]);
-            return surface;
-        };
-        this.parseMockupContainer = function (rawContainer) {
-            var container = new MockupContainer();
-            _this.parseContainer(rawContainer, container);
-            return container;
-        };
-        //TODO next release
-        //parsePrintAreaContainer = (rawContainer: Object) => {
-        //    var container = new PrintAreaContainer();
-        //    this.parseContainer(rawContainer, container);
-        //    return container;
-        //}
-        this.parseSurfaceContainer = function (rawContainer) {
-            var container;
-            var type = rawContainer["type"];
-            delete rawContainer["type"];
-            switch (type) {
-                case "SpotColorContainer":
-                    container = new SpotColorContainer();
-                    _this.parseContainer(rawContainer, container);
-                    delete rawContainer["version"];
-                    delete rawContainer["items"];
-                    Object.assign(container, rawContainer);
-                    break;
-                case "TextureContainer":
-                    container = new TextureContainer();
-                    _this.parseContainer(rawContainer, container);
-                    container.previewTextureSource = _this.parseImageSource(rawContainer["previewTextureSource"]);
-                    delete rawContainer["previewTextureSource"];
-                    delete rawContainer["version"];
-                    delete rawContainer["items"];
-                    Object.assign(container, rawContainer);
-                    break;
-                default:
-                    container = new SurfaceContainer();
-                    _this.parseContainer(rawContainer, container);
-                    break;
-            }
-            return container;
-        };
-        this.parseContainer = function (rawContainer, emptyContainer) {
-            if (emptyContainer === void 0) { emptyContainer = new Container(); }
-            _this._parseModelComponent(rawContainer, emptyContainer, [
-                new PropertyConverter("region", _this.parseRectangleF.bind(_this)),
-                new PropertyConverter("size", _this.parseSizeF.bind(_this)),
-                new PropertyConverter("items", function (rawItems) { return _this.parseCollection(rawItems, _this.parseItem, emptyContainer.items); }, true)
-            ]);
-            return emptyContainer;
-        };
-        this.parseSafetyLine = function (rawSafetyLine) {
-            var safetyLine = new SafetyLine();
-            var converters = [
-                new PropertyConverter("color", _this.parseColor.bind(_this)),
-                new PropertyConverter("altColor", _this.parseColor.bind(_this)),
-                new PropertyConverter("margin", _this._parseMargin)
-            ];
-            _this._parseObject(rawSafetyLine, safetyLine, converters);
-            return safetyLine;
-        };
-        this.parseCropMark = function (rawCropMark) {
-            var cropMark = new CropMark();
-            var converters = [
-                new PropertyConverter("color", _this.parseColor.bind(_this)),
-                new PropertyConverter("leftNotes", _this._setConvertedArray.bind(_this, _this.parseCropMarkText, function (obj) { cropMark.leftNotes = obj; }), true),
-                new PropertyConverter("rightNotes", _this._setConvertedArray.bind(_this, _this.parseCropMarkText, function (obj) { cropMark.rightNotes = obj; }), true),
-                new PropertyConverter("topNotes", _this._setConvertedArray.bind(_this, _this.parseCropMarkText, function (obj) { cropMark.topNotes = obj; }), true),
-                new PropertyConverter("bottomNotes", _this._setConvertedArray.bind(_this, _this.parseCropMarkText, function (obj) { cropMark.bottomNotes = obj; }), true),
-            ];
-            _this._parseObject(rawCropMark, cropMark, converters);
-            return cropMark;
-        };
-        this.parseCropMarkText = function (rawCropMarkText) {
-            var cropMarkText = new CropMarkText();
-            _this._parseObject(rawCropMarkText, cropMarkText, []);
-            return cropMarkText;
-        };
-        this.parsePrintArea = function (rawPrintArea) {
-            var printArea = new PrintArea();
-            _this._parseModelComponent(rawPrintArea, printArea, [
-                new PropertyConverter("bounds", _this.parseRectangleF.bind(_this)),
-                new PropertyConverter("safetyLines", function (rawLines) { return _this.parseCollection(rawLines, _this.parseSafetyLine, printArea.safetyLines); }, true),
-                new PropertyConverter("cropMarks", function (rawMarks) { return new Collection(rawMarks.map(_this.parseCropMark)); }),
-                new PropertyConverter("slug", _this._parseMargin),
-                new PropertyConverter("bleed", _this._parseMargin),
-            ]);
-            return printArea;
-        };
-        this._parseMargin = function (rawMargin) {
-            if (rawMargin == null)
-                return new Margin(0);
-            return new Margin({
-                left: rawMargin["left"], top: rawMargin["top"], right: rawMargin["right"], bottom: rawMargin["bottom"]
-            });
-        };
-        this.parseItem = function (rawItem) {
-            if (rawItem == null)
-                return null;
-            var type = rawItem["$type"];
-            delete rawItem["$type"];
-            var converters = [
-                new PropertyConverter("pathBoundedTextPermissions", _this.parsePathBoundedTextPermissions.bind(_this)),
-                new PropertyConverter("manipulationPermissions", _this.parseManipulationPermissions.bind(_this)),
-                new PropertyConverter("frontendPermissions", _this.parseFrontendPermissions.bind(_this)),
-                new PropertyConverter("visualizationPermissions", _this.parseVisualizationPermissions.bind(_this)),
-                new PropertyConverter("violationSettings", _this.parseViolationSettings),
-                new PropertyConverter("itemPermissions", _this.parseItemPermissions.bind(_this)),
-                new PropertyConverter("transform", _this.parseTransform.bind(_this)),
-                new PropertyConverter("color", _this.parseColor.bind(_this)),
-                new PropertyConverter("themeBinding", _this.parseThemeBinding.bind(_this)),
-                new PropertyConverter("mask", _this.parseMask.bind(_this))
-            ];
-            var item = null;
-            var textConverters = converters.concat([
-                new PropertyConverter("textPermissions", _this.parseTextPermissions.bind(_this)),
-                new PropertyConverter("font", _this.parseFontSettings.bind(_this), true),
-                new PropertyConverter("stroke", _this.parseStrokeSettings.bind(_this)),
-                new PropertyConverter("shadow", _this.parseShadowSettings.bind(_this))
-            ]);
-            if (type == null)
-                throw new Exception("Serialized data seems to be corrupted.");
-            switch (type) {
-                case SmartItem.type:
-                    item = _this.parseSmartItem(rawItem);
-                    break;
-                case RectangleItem.type:
-                    item = _this.parseRectangleItem(rawItem, converters);
-                    break;
-                case ShapeItem.type:
-                    item = _this.parseShapeItem(rawItem, converters);
-                    break;
-                case LineItem.type:
-                    item = _this.parseLineItem(rawItem, converters);
-                    break;
-                case DashedLineItem.type:
-                    item = _this.parseDashedLineItem(rawItem, converters);
-                    break;
-                case EllipseItem.type:
-                    item = _this.parseEllipseItem(rawItem, converters);
-                    break;
-                case ImageItem.type:
-                    item = _this.parseImageItem(rawItem, converters);
-                    break;
-                case BarcodeItem.type:
-                    item = _this.parseBarcodeItem(rawItem, converters);
-                    break;
-                case PlainTextItem.type:
-                    item = _this.parsePlainTextItem(rawItem, textConverters);
-                    break;
-                case BoundedTextItem.type:
-                    item = _this.parseBoundedTextItem(rawItem, textConverters);
-                    break;
-                case PathBoundedTextItem.type:
-                    item = _this.parsePathBoundedTextItem(rawItem, textConverters);
-                    break;
-                case CurvedTextItem.type:
-                    item = _this.parseCurvedTextItem(rawItem, textConverters);
-                    break;
-                case AutoScaledTextItem.type:
-                    item = _this.parseAutoScaledTextItem(rawItem, textConverters);
-                    break;
-                case ArchedTextItem.type:
-                    item = _this.parseArchedTextItem(rawItem, textConverters);
-                    break;
-                case PlaceholderItem.type:
-                    item = _this.parsePlaceholderItem(rawItem, converters);
-                    break;
-                case GroupItem.type:
-                    item = _this.parseGroupItem(rawItem, converters);
-                    break;
-                case ClipartItem.type:
-                    item = _this.parseClipartItem(rawItem, converters);
-                    break;
-                case LayoutItem.type:
-                    item = _this.parseLayoutItem(rawItem, converters);
-                    break;
-                default:
-                    throw new NotImplementedException("Deserializing of item with type - " + type + " is not implemented");
-            }
-            return item;
-        };
-        this.parseEncodingOptions = function (raw) {
-            var result = new EncodingOptions();
-            _this._parseModelComponent(raw, result, []);
-            return result;
-        };
-        this.parseLineItem = function (rawLine, baseConverters) {
-            var line = new LineItem();
-            var converters = __spread(baseConverters, _this._getLineConverters());
-            _this._parseModelComponent(rawLine, line, converters);
-            return line;
-        };
-        this.parseRotatedRectangle = function (rawRectangle) {
-            return new RotatedRectangleF(rawRectangle["centerX"], rawRectangle["centerY"], rawRectangle["width"], rawRectangle["height"], rawRectangle["angle"]);
-        };
-        this.parseViolationSettings = function (rawPerms) {
-            delete rawPerms["version"];
-            switch (rawPerms["type"]) {
-                case ViolationSettings.type:
-                    return Object.assign(new ViolationSettings(), rawPerms);
-                case ShapeViolationSettings.type:
-                    return Object.assign(new ShapeViolationSettings(), rawPerms);
-                case ImageViolationSettings.type:
-                    return Object.assign(new ImageViolationSettings(), rawPerms);
-                case TextViolationSettings.type:
-                    return Object.assign(new TextViolationSettings(), rawPerms);
-                default:
-                    throw new NotImplementedException("Deserializing of item with type - " + rawPerms["type"] + " is not implemented");
-            }
-        };
-        this.parsePlaceholderPermissions = function (rawPerms) {
-            return Object.assign(new PlaceholderPermissions(), rawPerms);
-        };
-        this.parseLayoutSettings = function (rawPerms) {
-            var layoutSettings;
-            switch (rawPerms["type"]) {
-                case AutoLayoutSettings.type:
-                    layoutSettings = new AutoLayoutSettings();
-                    break;
-                default:
-                    layoutSettings = new DefaultLayoutSettings();
-                    break;
-            }
-            return Object.assign(layoutSettings, rawPerms);
-        };
-        this.parseGroupItemPermissions = function (rawPerms) {
-            return Object.assign(new GroupItemPermissions(), rawPerms);
-        };
-        this.parseLinePermissions = function (rawPerms) {
-            return Object.assign(new LinePermissions(), rawPerms);
-        };
-        this.parseBarcodePermissions = function (rawPerms) {
-            return Object.assign(new BarcodePermissions(), rawPerms);
-        };
-        this._parseOverlayEffect = function (value) {
-            if (value != null)
-                return new OverlayEffect({
-                    color: value["color"] != null ? _this.parseColor(value["color"]) : null,
-                    opacity: value["opacity"] != null ? value["opacity"] : null,
-                    blendMode: value["blendMode"] != null ? value["blendMode"] : null
-                });
-        };
-        this._parseImageItemValue = function (value) {
-            return new ImageItem.ImageItemValue(value["name"], new ImageItem.ImageMetaData(value["value"]), _this.parseRotatedRectangle(value["transformedRectangle"]));
-        };
-        this._parseTextItemValue = function (value) {
-            return new BaseTextItem.BaseTextValue(value["name"], value["text"]);
-        };
-        this._parseObject = function (rawObject, destObject, converters) {
-            for (var propertyName in rawObject)
-                if (rawObject.hasOwnProperty(propertyName)) {
-                    var converter = converters.find(function (c) { return c.property === propertyName; });
-                    var rawValue = rawObject[propertyName];
-                    if (converter == null) {
-                        if (_.isObject(rawValue)) {
-                            var type = rawValue["$type"];
-                            delete rawValue["$type"];
-                            if (_.isString(type)) {
-                                var typeConverter = _.find(_this._additionalConverters, function (converterBound) { return (converterBound.type === type); });
-                                if (typeConverter != null) {
-                                    destObject[propertyName] = typeConverter.parseRawValue(rawValue);
-                                    continue;
-                                }
-                                else
-                                    console.warn("Unknown type " + type);
-                            }
-                        }
-                        destObject[propertyName] = rawValue;
-                        continue;
-                    }
-                    if (converter.setByConverter) {
-                        try {
-                            converter.convert(rawValue, destObject);
-                        }
-                        catch (ex) {
-                            console.error("Error while parsing property " + propertyName + " with converter ", converter, ex);
-                            throw ex;
-                        }
-                    }
-                    else {
-                        if (propertyName === "manipulationPermissions" && destObject instanceof GroupItem) {
-                            destObject["groupManipulationPermissions"] = converter.convert(rawValue);
-                            continue;
-                        }
-                        destObject[propertyName] = converter.convert(rawValue);
-                    }
-                }
-        };
-        /*
-         TODO: it crushes an insertion of psd when downloadPsdAsImage=false
-        const defaultConverters = [
-            new Model.AdditionalConverter(
-                "CustomersCanvas.Core.Model.PrintAreaContainer, CustomersCanvas.Core",
-                this.parsePrintAreaContainer.bind(this),
-                PrintAreaContainer),
-            new Model.AdditionalConverter(
-                "CustomersCanvas.Core.Model.PrintArea, CustomersCanvas.Core",
-                this.parsePrintArea.bind(this),
-                PrintArea)
-        ];
-        this._additionalConverters = additionalConverters != null ? additionalConverters.concat(defaultConverters) : defaultConverters;
-        */
-        this._additionalConverters = additionalConverters != null ? additionalConverters : [];
-    }
-    //#region public methods
-    ProductParser.prototype.parseProduct = function (rawProduct) {
-        var _this = this;
-        var product = new Product();
-        var productConverters = [
-            new PropertyConverter("surfaces", function (rawSurfaces) { return _this.parseCollection(rawSurfaces, _this.parseSurface, product.surfaces); }, true),
-            new PropertyConverter("watermarkConfig", this.parseWatermarkConfig.bind(this)),
-            new PropertyConverter("defaultSafetyLines", function (rawLines) { return _this.parseCollection(rawLines, _this.parseSafetyLine, product.defaultSafetyLines); }, true),
-            new PropertyConverter("defaultCropMarks", function (rawMarks) { return _this.parseCollection(rawMarks, _this.parseCropMark, product.defaultCropMarks); }, true),
-            new PropertyConverter("defaultDesignLocation", this.parsePointF.bind(this))
-        ];
-        this._parseModelComponent(rawProduct, product, productConverters);
-        return product;
-    };
-    ProductParser.prototype.parseWatermarkConfig = function (rawConfig) {
-        var _this = this;
-        if (rawConfig == null)
-            return null;
-        var config = new WatermarkConfig();
-        var parseFontSettings = new PropertyConverter("fontSettings", (function (rawFontSettings) {
-            if (rawFontSettings == null)
-                return null;
-            var fontSettings = new BaseTextItem.FontSettings(null);
-            _this._parseObject(rawFontSettings, fontSettings, []);
-            return fontSettings;
-        }));
-        var parseWatermarkTextConfig = new PropertyConverter("text", (function (rawText) {
-            if (rawText == null)
-                return null;
-            var text = new WatermarkTextConfig();
-            _this._parseObject(rawText, text, [parseFontSettings]);
-            return text;
-        }));
-        var parseWatermarkImageConfig = new PropertyConverter("image", (function (rawImage) {
-            if (rawImage == null)
-                return null;
-            var image = new WatermarkImageConfig();
-            _this._parseObject(rawImage, image, []);
-            return image;
-        }));
-        var parseWatermarkVisibilityConfig = new PropertyConverter("visibility", (function (rawVisibility) {
-            if (rawVisibility == null)
-                return null;
-            var visibility = new WatermarkVisibilityConfig();
-            _this._parseObject(rawVisibility, visibility, []);
-            return visibility;
-        }));
-        this._parseObject(rawConfig, config, [parseWatermarkTextConfig, parseWatermarkImageConfig, parseWatermarkVisibilityConfig]);
-        return config;
-    };
-    ProductParser.prototype.parseWatermark = function (rawWatermark) {
-        if (rawWatermark == null)
-            return null;
-        var watermark = new Watermark();
-        this._parseObject(rawWatermark, watermark, []);
-        return watermark;
-    };
-    ProductParser.prototype.parseMockup = function (rawMockup) {
-        var _this = this;
-        var mockup = new SurfaceMockup();
-        this._parseModelComponent(rawMockup, mockup, [
-            new PropertyConverter("underContainers", function (rawContainers) { return _this.parseCollection(rawContainers, _this.parseMockupContainer, mockup.underContainers); }, true),
-            new PropertyConverter("overContainers", function (rawContainers) { return _this.parseCollection(rawContainers, _this.parseMockupContainer, mockup.overContainers); }, true)
-        ]);
-        return mockup;
-    };
-    ProductParser.prototype.parseCollection = function (rawCollection, parseCollectionItem, targetCollection) {
-        /*if (rawCollection instanceof Collection)
-            targetCollection.setRange(rawCollection.select(i => parseCollectionItem(i)));
-        else*/
-        if (rawCollection != null)
-            targetCollection.setRange(rawCollection.map(function (rawColItem) { return parseCollectionItem(rawColItem); }));
-    };
-    ProductParser.prototype.parseRectangleF = function (rawRectangle) {
-        if (rawRectangle == null)
-            return null;
-        return new RectangleF(rawRectangle["left"], rawRectangle["top"], rawRectangle["width"], rawRectangle["height"]);
-    };
-    ProductParser.prototype.parsePointF = function (rawPoint) {
-        if (rawPoint == null)
-            return null;
-        var pointF = new PointF();
-        Object.assign(pointF, rawPoint);
-        return pointF;
-    };
-    ProductParser.prototype.parseSizeF = function (rawSize) {
-        if (rawSize == null)
-            return null;
-        //TODO: use server-side JsonConverter
-        if (_.isString(rawSize)) {
-            var values = rawSize.split(",");
-            return new SizeF(parseFloat(values[0].trim()), parseFloat(values[1].trim()));
-        }
-        else
-            return _.extend(new SizeF(), rawSize);
-    };
-    ProductParser.prototype.parsePath = function (rawPath) {
-        if (rawPath == null)
-            return null;
-        if (typeof rawPath === "string")
-            return new Path(rawPath);
-        return new Path(rawPath["path"]);
-    };
-    ProductParser.prototype.parsePaths = function (rawPaths) {
-        var _this = this;
-        if (rawPaths == null || !_.isArray(rawPaths))
-            return null;
-        var paths = [];
-        _.toArray(rawPaths).forEach(function (v) {
-            paths.push(_this.parsePath(v));
-        });
-        return paths;
-    };
-    ProductParser.prototype.parseSmartItem = function (rawSmartItem) {
-        var smartItem = new SmartItem();
-        this._parseModelComponent(rawSmartItem, smartItem, []);
-        return smartItem;
-    };
-    ProductParser.prototype.parsePlainTextItem = function (rawPlainText, baseConverters) {
-        var plainTextItem = new PlainTextItem();
-        var converters = baseConverters.concat(this._getShapeConverters(), this._getBaseTextItemConverters(plainTextItem), [new PropertyConverter("baselineLocation", this.parsePointF.bind(this))]);
-        this._parseModelComponent(rawPlainText, plainTextItem, converters);
-        return plainTextItem;
-    };
-    ProductParser.prototype.parseArchedTextItem = function (rawArchedText, baseConverters) {
-        var archedTextItem = new ArchedTextItem();
-        var converters = baseConverters.concat(this._getShapeConverters(), this._getBaseTextItemConverters(archedTextItem), [new PropertyConverter("center", this.parsePointF.bind(this))]);
-        this._parseModelComponent(rawArchedText, archedTextItem, converters);
-        return archedTextItem;
-    };
-    ProductParser.prototype.parseAutoScaledTextItem = function (rawAutoScaledText, baseConverters) {
-        var autoScaledTextItem = new AutoScaledTextItem();
-        var converters = baseConverters.concat(this._getShapeConverters(), this._getBaseTextItemConverters(autoScaledTextItem), [new PropertyConverter("textRectangle", this.parseRectangleF.bind(this))]);
-        this._parseModelComponent(rawAutoScaledText, autoScaledTextItem, converters);
-        return autoScaledTextItem;
-    };
-    ProductParser.prototype.parseBoundedTextItem = function (rawBoundedText, baseConverters) {
-        var boundedTextItem = new BoundedTextItem();
-        var converters = baseConverters.concat(this._getShapeConverters(), this._getBaseTextItemConverters(boundedTextItem), [
-            new PropertyConverter("paragraphSettings", this.parseParagraphSettings.bind(this)),
-            new PropertyConverter("textRectangle", this.parseRectangleF.bind(this)),
-            new PropertyConverter("wrappingPath", this.parsePath.bind(this))
-        ]);
-        this._parseModelComponent(rawBoundedText, boundedTextItem, converters);
-        return boundedTextItem;
-    };
-    ProductParser.prototype.parsePathBoundedTextItem = function (rawBoundedText, baseConverters) {
-        var pathBoundedTextItem = new PathBoundedTextItem();
-        var converters = baseConverters.concat(this._getShapeConverters(), this._getBaseTextItemConverters(pathBoundedTextItem), [
-            new PropertyConverter("pathBoundedTextPermissions", this.parsePathBoundedTextPermissions.bind(this)),
-            new PropertyConverter("boundingPaths", this.parsePaths.bind(this)),
-            new PropertyConverter("paragraphSettings", this.parseParagraphSettings.bind(this)),
-            new PropertyConverter("wrappingPath", this.parsePath.bind(this))
-        ]);
-        this._parseModelComponent(rawBoundedText, pathBoundedTextItem, converters);
-        return pathBoundedTextItem;
-    };
-    ProductParser.prototype.parseCurvedTextItem = function (rawCurvedText, baseConverters) {
-        var curvedTextItem = new CurvedTextItem();
-        var converters = baseConverters.concat(this._getShapeConverters(), this._getBaseTextItemConverters(curvedTextItem), [new PropertyConverter("textPath", this.parsePath.bind(this))]);
-        this._parseModelComponent(rawCurvedText, curvedTextItem, converters);
-        return curvedTextItem;
-    };
-    ProductParser.prototype._getBaseTextItemConverters = function (item) {
-        var _this = this;
-        return [
-            new PropertyConverter("values", this._setConvertedArray.bind(this, this._parseTextItemValue, function (obj) { item.values = obj; }), true),
-            new PropertyConverter("placeholders", function (rawPlaceholders) { return _this.parseCollection(rawPlaceholders, _this.parseInStringPlaceholder, item.placeholders); }, true),
-            new PropertyConverter("colorPalette", function (rawPalette) { return _this.parseCollection(rawPalette, _this.parseColor, item.colorPalette); }, true)
-        ];
-    };
-    ProductParser.prototype.parseImageItem = function (rawImage, baseConverters) {
-        var image = new ImageItem();
-        var converters = baseConverters.concat(this._getShapeConverters(), this._getImageConverters(image));
-        this._parseModelComponent(rawImage, image, converters);
-        return image;
-    };
-    ProductParser.prototype.parseBarcodeItem = function (rawBarcode, baseConverters) {
-        var barcode = new BarcodeItem();
-        var converters = baseConverters.concat(this._getShapeConverters(), this._getImageConverters(barcode), [
-            new PropertyConverter("barcodePermissions", this.parseBarcodePermissions.bind(this)),
-            new PropertyConverter("color", this.parseColor.bind(this)),
-            new PropertyConverter("barcodeOptions", this.parseEncodingOptions)
-        ]);
-        this._parseModelComponent(rawBarcode, barcode, converters);
-        return barcode;
-    };
-    ProductParser.prototype.parsePlaceholderItem = function (rawPlaceholder, baseConverters) {
-        var self = this;
-        var placeholder = new PlaceholderItem();
-        var converters = __spread(baseConverters, this._getShapeConverters(), [
-            new PropertyConverter("placeholderPermissions", this.parsePlaceholderPermissions),
-            new PropertyConverter("contentPermissions", this.parseContentPermissions.bind(this)),
-            new PropertyConverter("content", this.parseItem),
-            new PropertyConverter("topFrames", parseRawFrames),
-            new PropertyConverter("bottomFrames", parseRawFrames),
-            new PropertyConverter("stubStorageMeta", function (rawObject) { return new ImageMetaData(rawObject); }),
-            new PropertyConverter("contentFillColor", this.parseColor.bind(this)),
-            new PropertyConverter("contentOverlayEffect", this._parseOverlayEffect.bind(this))
-        ]);
-        this._parseModelComponent(rawPlaceholder, placeholder, converters);
-        return placeholder;
-        function parseRawFrames(rawFrames) {
-            return rawFrames.map(self.parseItem);
-        }
-    };
-    ProductParser.prototype.parseGroupItem = function (rawGroupItem, baseConverters) {
-        var groupItem = new GroupItem();
-        var converters = __spread(baseConverters, this._getShapeConverters(), this._getGroupConverters(groupItem));
-        this._parseModelComponent(rawGroupItem, groupItem, converters);
-        return groupItem;
-    };
-    ProductParser.prototype.parseClipartItem = function (rawClipartItem, baseConverters) {
-        var clipartItem = new ClipartItem();
-        var converters = __spread(baseConverters, this._getShapeConverters(), this._getGroupConverters(clipartItem), [
-            new PropertyConverter("colorGroups", this._setConvertedArray.bind(this, this.parseColorGroup.bind(this), function (colorGroups) { return clipartItem.colorGroups = colorGroups; }), true),
-        ]);
-        this._parseModelComponent(rawClipartItem, clipartItem, converters);
-        return clipartItem;
-    };
-    ProductParser.prototype.parseLayoutItem = function (rawLayoutItem, baseConverters) {
-        var layoutItem = new LayoutItem();
-        var converters = __spread(baseConverters, this._getShapeConverters(), this._getGroupConverters(layoutItem), [
-            new PropertyConverter("layoutSettings", this.parseLayoutSettings),
-            new PropertyConverter("sourceRectangle", this.parseRotatedRectangle)
-        ]);
-        this._parseModelComponent(rawLayoutItem, layoutItem, converters);
-        return layoutItem;
-    };
-    ProductParser.prototype.parseContentPermissions = function (rawContentPermissions, baseConverters) {
-        var contentPermissions = new ContentPermissions();
-        contentPermissions.barcodePermissions = this.parseBarcodePermissions(rawContentPermissions["barcodePermissions"]);
-        contentPermissions.imagePermissions = this.parseImagePermissions(rawContentPermissions["imagePermissions"]);
-        return contentPermissions;
-    };
-    ProductParser.prototype.parseEllipseItem = function (rawEllipse, baseConverters) {
-        var ellipse = new EllipseItem();
-        var converters = baseConverters.concat(this._getShapeConverters());
-        this._parseModelComponent(rawEllipse, ellipse, converters);
-        return ellipse;
-    };
-    ProductParser.prototype.parseRectangleItem = function (rawRectangle, baseConverters) {
-        var rectangle = new RectangleItem();
-        var converters = baseConverters.concat(this._getShapeConverters());
-        this._parseModelComponent(rawRectangle, rectangle, converters);
-        return rectangle;
-    };
-    ProductParser.prototype.parseShapeItem = function (rawShape, baseConverters) {
-        var shape = new ShapeItem();
-        var converters = baseConverters.concat(this._getShapeConverters());
-        this._parseModelComponent(rawShape, shape, converters);
-        return shape;
-    };
-    ProductParser.prototype.parseDashedLineItem = function (rawLine, baseConverters) {
-        var line = new DashedLineItem();
-        var converters = __spread(baseConverters, this._getLineConverters(), this._getDashedLineConverters());
-        this._parseModelComponent(rawLine, line, converters);
-        return line;
-    };
-    ProductParser.prototype.parseThemeBinding = function (rawThemeBinding) {
-        return rawThemeBinding != null ? ThemeBinding.fromRaw(rawThemeBinding) : null;
-    };
-    ProductParser.prototype.parseMask = function (rawMask) {
-        if (rawMask == null)
-            return null;
-        var mask = new ItemMask();
-        if (rawMask.vectorMask != null)
-            mask.vectorMask = this.parsePath(rawMask.vectorMask);
-        return mask;
-    };
-    ProductParser.prototype.parseColor = function (rawColor) {
-        return rawColor != null ? ColorFactory.createColor(rawColor) : null;
-    };
-    ProductParser.prototype.parseTransform = function (rawTransform) {
-        return new Transform(rawTransform["scaleX"], rawTransform["scaleY"], rawTransform["translateX"], rawTransform["translateY"], rawTransform["angle"]);
-    };
-    ProductParser.prototype.parseFontSettings = function (rawSettings, destTextItem) {
-        var font = new BaseTextItem.FontSettings(null);
-        Object.assign(font, rawSettings);
-        destTextItem.font = font;
-        return destTextItem.font;
-    };
-    ProductParser.prototype.parseManipulationPermissions = function (rawPerms) {
-        var result = Object.assign(new ManipulationPermissions(), rawPerms);
-        result.resizeGrips = Object.assign(new ResizeGripsPermissions(false, false), rawPerms["resizeGrips"]);
-        return result;
-    };
-    ProductParser.prototype.parseFrontendPermissions = function (rawPerms) {
-        return Object.assign(new FrontendPermissions(), rawPerms);
-    };
-    ProductParser.prototype.parseVisualizationPermissions = function (rawPerms) {
-        return Object.assign(new VisualizationPermissions(), rawPerms);
-    };
-    ProductParser.prototype.parseColorGroup = function (rawPerms) {
-        return new ColorGroup(this.parseColor(rawPerms["color"]), rawPerms["targets"]);
-    };
-    ProductParser.prototype.parseItemPermissions = function (rawPerms) {
-        var result = Object.assign(new ItemPermissions(), rawPerms);
-        result.itemToolbarPermissions = Object.assign(new ItemToolbarPermissions(false), rawPerms["itemToolbarPermissions"]);
-        return result;
-    };
-    ProductParser.prototype.parseTextPermissions = function (rawPerms) {
-        return Object.assign(new TextPermissions(), rawPerms);
-    };
-    ProductParser.prototype.parsePathBoundedTextPermissions = function (rawPerms) {
-        return Object.assign(new PathBoundedTextPermissions(), rawPerms);
-    };
-    ProductParser.prototype.parseShapePermissions = function (rawPerms) {
-        return Object.assign(new ShapePermissions(), rawPerms);
-    };
-    ProductParser.prototype.parseImagePermissions = function (rawPerms) {
-        return Object.assign(new ImagePermissions(), rawPerms);
-    };
-    ProductParser.prototype.parseImageSource = function (rawImageSource) {
-        var origin = null;
-        if (rawImageSource["origin"] != null)
-            origin = new ImageItem.ImageSource.Origin(rawImageSource["origin"]);
-        if (rawImageSource["origin"] !== undefined)
-            delete rawImageSource["origin"];
-        return Object.assign(new ImageItem.ImageSource(rawImageSource["id"], rawImageSource["url"], 0, false, true, origin), rawImageSource);
-    };
-    ProductParser.prototype.parseParagraphSettings = function (rawSettings) {
-        return new ParagraphSettings(rawSettings);
-    };
-    ProductParser.prototype.parseStrokeSettings = function (rawSettings) {
-        return StrokeSettings._from_data(rawSettings);
-    };
-    ProductParser.prototype.parseShadowSettings = function (rawSettings) {
-        return ShadowSettings._from_data(rawSettings);
-    };
-    ProductParser.prototype.parseInStringPlaceholder = function (rawSettings) {
-        return new InStringPlaceholder(rawSettings["id"], rawSettings["name"], rawSettings["mask"], rawSettings["value"], rawSettings["values"]);
-    };
-    //#endregion
-    //#region private members
-    ProductParser.prototype._setConvertedArray = function (convertFunc, setFunc, rawArray) {
-        if (!_.isArray(rawArray))
-            return;
-        setFunc(_.map(rawArray, function (rawValue) { return convertFunc(rawValue); }));
-    };
-    ProductParser.prototype._getImageConverters = function (imageItem /*: ImageItem*/) {
-        return [
-            new PropertyConverter("source", this.parseImageSource.bind(this)),
-            new PropertyConverter("imagePermissions", this.parseImagePermissions.bind(this)),
-            new PropertyConverter("values", this._setConvertedArray.bind(this, this._parseImageItemValue, function (obj) { imageItem.values = obj; }), true),
-            new PropertyConverter("overlayEffect", this._parseOverlayEffect.bind(this))
-        ];
-    };
-    ProductParser.prototype._getShapeConverters = function () {
-        return [
-            new PropertyConverter("fillColor", this.parseColor.bind(this)),
-            new PropertyConverter("borderColor", this.parseColor.bind(this)),
-            new PropertyConverter("altBorderColor", this.parseColor.bind(this)),
-            new PropertyConverter("sourceRectangle", this.parseRectangleF.bind(this)),
-            new PropertyConverter("sourcePath", this.parsePath.bind(this)),
-            new PropertyConverter("shapePermissions", this.parseShapePermissions.bind(this))
-        ];
-    };
-    ProductParser.prototype._getGroupConverters = function (groupItem) {
-        return [
-            new PropertyConverter("items", this._setConvertedArray.bind(this, this.parseItem, function (items) { return groupItem.items.addRange(items); }), true),
-            new PropertyConverter("groupItemPermissions", this.parseGroupItemPermissions)
-        ];
-    };
-    ProductParser.prototype._getLineConverters = function () {
-        return [
-            new PropertyConverter("color", this.parseColor.bind(this)),
-            new PropertyConverter("sourcePoint0", this.parsePointF.bind(this)),
-            new PropertyConverter("sourcePoint1", this.parsePointF.bind(this)),
-            new PropertyConverter("linePermissions", this.parseLinePermissions)
-        ];
-    };
-    ProductParser.prototype._getDashedLineConverters = function () {
-        return [
-            new PropertyConverter("altColor", this.parseColor.bind(this))
-        ];
-    };
-    ProductParser.prototype._parseModelComponent = function (rawComponent, destComponent, converters) {
-        if (rawComponent["version"] !== MODELVERSION)
-            throw new Exception("Version of serialized model component (" + rawComponent["version"] + ") does not match the editor's version (" + MODELVERSION + ").");
-        converters = converters.concat([
-            new PropertyConverter("tags", function (rawTags, destComponent) { destComponent["_tags"] = rawTags; }, true),
-            new PropertyConverter("version", function (rawVersion, destComponent) { }, true)
-        ]);
-        this._parseObject(rawComponent, destComponent, converters);
-    };
-    return ProductParser;
-}());
-export { ProductParser };
-var PropertyConverter = /** @class */ (function () {
-    function PropertyConverter(rawPropertyName, convertFunc, isSetByConvertFunc) {
-        this.property = rawPropertyName;
-        this.convert = convertFunc;
-        this.setByConverter = isSetByConvertFunc ? isSetByConvertFunc : false;
-    }
-    return PropertyConverter;
-}());
-export { PropertyConverter };
-//# sourceMappingURL=ProductParser.js.map