@breakside/jskit 2022.22.3 → 2022.25.0

package/Frameworks/Foundation.jsframework/JS/JSFontDescriptor.js

@@ -18,6 +18,8 @@
 // #import "UnicodeChar.js"
 // #import "Zlib.js"
 // #import "CoreTypes.js"
+// #import "JSURLSession.js"
+/* global JSFont */
 'use strict';
 
 (function(){
@@ -38,11 +40,11 @@ JSClass("JSFontDescriptor", JSObject, {
     unitsPerEM: JSReadOnlyProperty('_unitsPerEM', 0),
 
     descriptorWithWeight: function(weight){
-        return this;
+        return JSFontDescriptor.descriptorWithFamily(this.family, weight, this.style) || this;
     },
 
     descriptorWithStyle: function(style){
-        return this;
+        return JSFontDescriptor.descriptorWithFamily(this.family, this.weight, style) || this;
     },
 
     glyphForCharacter: function(character){
@@ -89,6 +91,29 @@ JSClass("JSFontDescriptor", JSObject, {
 
 });
 
+JSFontDescriptor.system = null;
+
+JSFontDescriptor.descriptorsByFamily = {
+};
+
+JSFontDescriptor.registerDescriptor = function(descriptor){
+    if (!(descriptor._family in JSFontDescriptor.descriptorsByFamily)){
+        JSFontDescriptor.descriptorsByFamily[descriptor._family] = {};
+    }
+    if (!(descriptor._weight in JSFontDescriptor.descriptorsByFamily[descriptor._family])){
+        JSFontDescriptor.descriptorsByFamily[descriptor._family][descriptor._weight] = {};
+    }
+    if (!(descriptor._style in JSFontDescriptor.descriptorsByFamily[descriptor._family][descriptor._weight])){
+        JSFontDescriptor.descriptorsByFamily[descriptor._family][descriptor._weight][descriptor._style] = descriptor;
+    }
+};
+
+JSFontDescriptor.descriptorWithFamily = function(family, weight, style){
+    var weights = JSFontDescriptor.descriptorsByFamily[family] || {};
+    var styles = weights[weight] || {};
+    return styles[style] || null;
+};
+
 JSClass("JSDataFontDescriptor", JSFontDescriptor, {
 
     data: null,
@@ -131,23 +156,6 @@ JSClass("JSResourceFontDescriptor", JSFontDescriptor, {
             widths: null,
         };
         JSResourceFontDescriptor.descriptorsByName[metadata.font.unique_identifier] = this;
-        if (!(this._family in JSResourceFontDescriptor.descriptorsByFamily)){
-            JSResourceFontDescriptor.descriptorsByFamily[this._family] = {};
-        }
-        if (!(this._weight in JSResourceFontDescriptor.descriptorsByFamily[this._family])){
-            JSResourceFontDescriptor.descriptorsByFamily[this._family][this._weight] = {};
-        }
-        if (!(this._style in JSResourceFontDescriptor.descriptorsByFamily[this._family][this._weight])){
-            JSResourceFontDescriptor.descriptorsByFamily[this._family][this._weight][this._style] = this;
-        }
-    },
-
-    descriptorWithWeight: function(weight){
-        return JSResourceFontDescriptor.descriptorWithFamily(this.family, weight, this.style) || this;
-    },
-
-    descriptorWithStyle: function(style){
-        return JSResourceFontDescriptor.descriptorWithFamily(this.family, this.weight, style) || this;
     },
 
     glyphForCharacter: function(character){
@@ -228,17 +236,87 @@ JSClass("JSResourceFontDescriptor", JSFontDescriptor, {
 
 });
 
-JSResourceFontDescriptor.descriptorWithFamily = function(family, weight, style){
-    var weights = JSResourceFontDescriptor.descriptorsByFamily[family] || {};
-    var styles = weights[weight] || {};
-    return styles[style];
+JSResourceFontDescriptor.descriptorsByName = {
 };
 
-JSResourceFontDescriptor.descriptorsByFamily = {
-};
+JSClass("JSURLFontDescriptor", JSFontDescriptor, {
 
-JSResourceFontDescriptor.descriptorsByName = {
-};
+    url: null,
+
+    initWithURL: function(url, family, weight, style){
+        this.url = url;
+        this._family = family;
+        this._weight = weight;
+        this._style = style;
+        this._postScriptName = "%s-%s".sprintf(family.replace(" ", ""), this.face.replce(" ", ""));
+        // this._ascender
+        // this._descender
+        // this._unitsPerEM
+    },
+
+    getData: function(completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.rejectNonNullSecondArgument);
+        }
+        var session = JSURLSession.shared;
+        var task = session.dataTaskWithURL(this.url, function(error){
+            if (error !== null){
+                completion.call(target, null, error);
+                return;
+            }
+            try{
+                task.response.assertSuccess();
+            }catch (e){
+                completion.call(target, null, e);
+                return;
+            }
+            completion.call(target, task.response.data, null);
+        });
+        task.resume();
+        return completion.promise;
+    },
+
+    face: JSLazyInitProperty(function(){
+        if (this.weight === JSFont.Weight.regular){
+            if (this.style === JSFont.Style.italic){
+                return "Italic";
+            }
+            return "Regular";
+        }
+        var name = "";
+        switch (this.weight){
+            case JSFont.Weight.ultraLight:
+                name = "UltraLight";
+                break;
+            case JSFont.Weight.thin:
+                name = "Thin";
+                break;
+            case JSFont.Weight.light:
+                name = "Light";
+                break;
+            case JSFont.Weight.medium:
+                name = "Medium";
+                break;
+            case JSFont.Weight.semibold:
+                name = "SemiBold";
+                break;
+            case JSFont.Weight.bold:
+                name = "Bold";
+                break;
+            case JSFont.Weight.heavy:
+                name = "Heavy";
+                break;
+            case JSFont.Weight.black:
+                name = "Black";
+                break;
+        }
+        if (this.style === JSFont.Style.italic){
+            name += " Italic";
+        }
+        return name;
+    }),
+
+});
 
 var CMap = function(format, data){
     if (this === undefined){

package/Frameworks/Foundation.jsframework/JS/JSParagraphStyle.js

@@ -0,0 +1,71 @@
+// #import "JSObject.js"
+// #import "CoreTypes.js"
+"use strict";
+
+JSClass("JSParagraphStyle", JSObject, {
+
+    textAlignment: JSTextAlignment.left,
+    lineBreakMode: JSLineBreakMode.truncateTail,
+    lineSpacing: 0,
+    minimumLineHeight: 0,
+    lineHeightMultiple: 0,
+    paragraphSpacing: 0,
+    beforeParagraphSpacing: 0,
+    firstLineHeadIndent: 0,
+    headIndent: 0,
+    tailIndent: 0,
+
+    init: function(){
+    },
+
+    styleWithAttributes: function(attributes){
+        var style = this.copy();
+        if (attributes.textAlignment !== undefined){
+            style.textAlignment = attributes.textAlignment;
+        }
+        if (attributes.lineBreakMode !== undefined){
+            style.lineBreakMode = attributes.lineBreakMode;
+        }
+        if (attributes.lineSpacing !== undefined){
+            style.lineSpacing = attributes.lineSpacing;
+        }
+        if (attributes.minimumLineHeight !== undefined){
+            style.minimumLineHeight = attributes.minimumLineHeight;
+        }
+        if (attributes.lineHeightMultiple !== undefined){
+            style.lineHeightMultiple = attributes.lineHeightMultiple;
+        }
+        if (attributes.paragraphSpacing !== undefined){
+            style.paragraphSpacing = attributes.paragraphSpacing;
+        }
+        if (attributes.beforeParagraphSpacing !== undefined){
+            style.beforeParagraphSpacing = attributes.beforeParagraphSpacing;
+        }
+        if (attributes.firstLineHeadIndent !== undefined){
+            style.firstLineHeadIndent = attributes.firstLineHeadIndent;
+        }
+        if (attributes.headIndent !== undefined){
+            style.headIndent = attributes.headIndent;
+        }
+        if (attributes.tailIndent !== undefined){
+            style.tailIndent = attributes.tailIndent;
+        }
+        return style;
+    },
+
+    copy: function(){
+        var style = JSParagraphStyle.init();
+        style.textAlignment = this.textAlignment;
+        style.lineBreakMode = this.lineBreakMode;
+        style.lineSpacing = this.lineSpacing;
+        style.minimumLineHeight = this.minimumLineHeight;
+        style.lineHeightMultiple = this.lineHeightMultiple;
+        style.paragraphSpacing = this.paragraphSpacing;
+        style.beforeParagraphSpacing = this.beforeParagraphSpacing;
+        style.firstLineHeadIndent = this.firstLineHeadIndent;
+        style.headIndent = this.headIndent;
+        style.tailIndent = this.tailIndent;
+        return style;
+    }
+
+});

package/Frameworks/Foundation.jsframework/JS/JSTextAttachment.js

@@ -32,7 +32,7 @@ JSClass("JSTextAttachment", JSObject, {
         this._image = image;
         var ratio = image.size.width / image.size.height;
         this._size = JSSize(ratio * font.displayLineHeight, font.displayLineHeight);
-        this.baselineAdjustment = font.displayDescender;
+        this.baselineAdjustment = -font.displayDescender;
     },
 
     initWithImage: function(image, size){

package/Frameworks/Foundation.jsframework/JS/JSTextContainer.js

@@ -21,37 +21,13 @@
 
 (function(){
 
-var JSTextContainerAttributeProperty = function(){
-    if (this === undefined){
-        return new JSTextContainerAttributeProperty();
-    }
-};
-
-JSTextContainerAttributeProperty.prototype = Object.create(JSCustomProperty.prototype);
-
-JSTextContainerAttributeProperty.prototype.define = function(C, key, extensions){
-    Object.defineProperty(C.prototype, key, {
-        configurable: false,
-        enumerable: false,
-        set: function JSTextContainer_setAttributeProperty(value){
-            this.framesetter.attributes[key] = value;
-            this._notifyLayoutManager();
-        },
-        get: function JSTextContainer_getAttributeProperty(){
-            return this.framesetter.attributes[key];
-        }
-    });
-};
+var logger = JSLog("foundation", "text");
 
 JSClass("JSTextContainer", JSObject, {
 
     origin: JSDynamicProperty('_origin', JSPoint.Zero),
     size: JSDynamicProperty('_size', null),
     range: JSReadOnlyProperty(),
-    lineBreakMode: JSTextContainerAttributeProperty(),
-    textAlignment: JSTextContainerAttributeProperty(),
-    lineSpacing: JSTextContainerAttributeProperty(),
-    minimumLineHeight: JSTextContainerAttributeProperty(),
     textLayoutManager: JSDynamicProperty('_textLayoutManager', null),
     maximumNumberOfLines: JSDynamicProperty('_maximumNumberOfLines', 0),
     framesetter: null,
@@ -83,10 +59,10 @@ JSClass("JSTextContainer", JSObject, {
                     // If we are a single line label and we have all of the string, we *may not* need to do a new layout
                     if (this._maximumNumberOfLines == 1 && this._textFrame.range.location === 0 && this._textFrame.range.length >= this._textLayoutManager.textStorage.string.length){
                         // If the new size can still fit the entire layout, then no need to do a new layout manager layout
-                        if (size.width >= this._textFrame.usedSize.width && size.height >= this._textFrame.usedSize.height){
+                        if (size.width < Number.MAX_VALUE && size.height < Number.MAX_VALUE && size.width >= this._textFrame.usedSize.width && size.height >= this._textFrame.usedSize.height){
                             // Text frame can do a shortcut update by trimming excess size without affecting truncation
                             shouldNotify = false;
-                            this._textFrame.adjustSize(size);
+                            this.framesetter._resizeFrame(this._textFrame, size);
                         }
                     }
                     if (shouldNotify){
@@ -110,6 +86,7 @@ JSClass("JSTextContainer", JSObject, {
 
     createTextFrame: function(attributedString, range){
         this.framesetter.attributedString = attributedString;
+        this.framesetter.defaultParagraphStyle = this._textLayoutManager.defaultParagraphStyle;
         this._textFrame = this.framesetter.createFrame(this.size, range, this._maximumNumberOfLines);
     },
 
@@ -125,7 +102,7 @@ JSClass("JSTextContainer", JSObject, {
     rectForCharacterAtIndex: function(index, useLineHeight){
         var line = this.lineForCharacterAtIndex(index);
         if (line !== null){
-            var rect = line.rectForCharacterAtIndex(index - (line.range.location - this._textFrame.range.location));
+            var rect = line.rectForCharacterAtIndex(index);
             if (useLineHeight){
                 rect.origin.y = line.origin.y;
                 rect.size.height = line.size.height;
@@ -167,7 +144,57 @@ JSClass("JSTextContainer", JSObject, {
         if (this._textLayoutManager !== null){
             this._textLayoutManager.setNeedsLayout();
         }
-    }
+    },
+
+    // MARK: - Deprecated
+
+    lineBreakMode: JSDynamicProperty(),
+
+    getLineBreakMode: function(){
+        logger.warn("JSTextContainer.lineBreakMode is deprecated");
+        return this._textLayoutManager.defaultParagraphStyle.lineBreakMode;
+    },
+
+    setLineBreakMode: function(lineBreakMode){
+        logger.warn("JSTextContainer.lineBreakMode is deprecated");
+        this._textLayoutManager.defaultParagraphStyle = this._textLayoutManager.defaultParagraphStyle.styleWithAttributes({lineBreakMode: lineBreakMode});
+    },
+
+    textAlignment: JSDynamicProperty(),
+
+    getTextAlignment: function(){
+        logger.warn("JSTextContainer.textAlignment is deprecated");
+        return this._textLayoutManager.defaultParagraphStyle.textAlignment;
+    },
+
+    setTextAlignment: function(textAlignment){
+        logger.warn("JSTextContainer.textAlignment is deprecated");
+        this._textLayoutManager.defaultParagraphStyle = this._textLayoutManager.defaultParagraphStyle.styleWithAttributes({textAlignment: textAlignment});
+    },
+
+    lineSpacing: JSDynamicProperty(),
+
+    getLineSpacing: function(){
+        logger.warn("JSTextContainer.lineSpacing is deprecated");
+        return this._textLayoutManager.defaultParagraphStyle.lineSpacing;
+    },
+
+    setLineSpacing: function(lineSpacing){
+        logger.warn("JSTextContainer.lineSpacing is deprecated");
+        this._textLayoutManager.defaultParagraphStyle = this._textLayoutManager.defaultParagraphStyle.styleWithAttributes({lineSpacing: lineSpacing});
+    },
+
+    minimumLineHeight: JSDynamicProperty(),
+
+    getMinimumLineHeight: function(){
+        logger.warn("JSTextContainer.minimumLineHeight is deprecated");
+        return this._textLayoutManager.defaultParagraphStyle.minimumLineHeight;
+    },
+
+    setMinimumLineHeight: function(minimumLineHeight){
+        logger.warn("JSTextContainer.minimumLineHeight is deprecated");
+        this._textLayoutManager.defaultParagraphStyle = this._textLayoutManager.defaultParagraphStyle.styleWithAttributes({minimumLineHeight: minimumLineHeight});
+    },
 
 });
 

package/Frameworks/Foundation.jsframework/JS/JSTextFrame.js

@@ -25,9 +25,8 @@ JSClass("JSTextFrame", JSObject, {
     usedSize: JSReadOnlyProperty('_usedSize', null),
     range: JSReadOnlyProperty('_range', null),
     lines: JSReadOnlyProperty('_lines', null),
-    _alignment: JSTextAlignment.left,
 
-    initWithLines: function(lines, size, attributes){
+    initWithLines: function(lines, size){
         if (lines.length > 0){
             this._range = JSRange(lines[0].range.location, lines[lines.length - 1].range.end - lines[0].range.location);   
         }else{
@@ -52,35 +51,6 @@ JSClass("JSTextFrame", JSObject, {
         if (this._size.height === 0 || this._size.height === Number.MAX_VALUE){
             this._size.height = y;
         }
-        this._alignment = attributes.textAlignment;
-        this._alignLines();
-    },
-
-    adjustSize: function(newSize){
-        if (newSize.width < this._usedSize.width || newSize.height < this._usedSize.height){
-            throw new Error("Cannot adjust text frame to smaller than its used size");
-        }
-        this._size = JSSize(newSize);
-        this._alignLines();
-    },
-
-    _alignLines: function(){
-        var i, l;
-        var line;
-        switch (this._alignment){
-            case JSTextAlignment.center:
-                for (i = 0, l = this.lines.length; i < l; ++i){
-                    line = this.lines[i];
-                    line.origin.x = (this._size.width - line.size.width + line.trailingWhitespaceWidth) / 2.0;
-                }
-                break;
-            case JSTextAlignment.right:
-                for (i = 0, l = this.lines.length; i < l; ++i){
-                    line = this.lines[i];
-                    line.origin.x = (this._size.width - line.size.width + line.trailingWhitespaceWidth);
-                }
-                break;
-        }
     },
 
     drawInContextAtPoint: function(context, point){
@@ -107,7 +77,7 @@ JSClass("JSTextFrame", JSObject, {
         while (min < max){
             mid = Math.floor(min + (max - min) / 2);
             line = this._lines[mid];
-            i = line.range.location - this.range.location;
+            i = line.range.location;
             l = line.range.length;
             if (index < i){
                 max = mid;

package/Frameworks/Foundation.jsframework/JS/JSTextFramesetter.js

@@ -18,15 +18,18 @@
 // #import "JSTextTypesetter.js"
 // #import "JSTextFrame.js"
 // #import "JSAttributedString.js"
+// #import "JSParagraphStyle.js"
 'use strict';
 
 (function(){
 
+var logger = JSLog("foundation", "text");
+
 JSClass("JSTextFramesetter", JSObject, {
 
     typesetter: JSReadOnlyProperty('_typesetter', null),
     attributedString: JSDynamicProperty(),
-    attributes: null,
+    defaultParagraphStyle: JSDynamicProperty("_defaultParagraphStyle", null),
 
     init: function(){
         this.initWithTypesetter(JSTextTypesetter.init());
@@ -34,7 +37,7 @@ JSClass("JSTextFramesetter", JSObject, {
 
     initWithTypesetter: function(typesetter){
         this._typesetter = typesetter;
-        this.attributes = Object.create(JSTextParagraphAttributes);
+        this._defaultParagraphStyle = JSParagraphStyle.init();
     },
 
     getAttributedString: function(){
@@ -45,8 +48,8 @@ JSClass("JSTextFramesetter", JSObject, {
         this._typesetter.attributedString = attributedString;
     },
 
-    constructFrame: function(lines, size, attributes){
-        return JSTextFrame.initWithLines(lines, size, attributes);
+    constructFrame: function(lines, size){
+        return JSTextFrame.initWithLines(lines, size);
     },
 
     createFrame: function(size, range, maximumLines){
@@ -61,35 +64,96 @@ JSClass("JSTextFramesetter", JSObject, {
         var widthLimit = size.width || Number.MAX_VALUE;
         var heightLimit = size.height || Number.MAX_VALUE;
         var lineLimit = maximumLines || Number.MAX_VALUE;
-        var spacing = 0;
+        var lineWidthLimit;
+        var attributes = this._typesetter.resolveAttributes(this._typesetter.attributedString.attributesAtIndex(remianingRange.location));
+        var paragraphStyle = this._defaultParagraphStyle.styleWithAttributes(attributes);
+        var characterIterator = this._typesetter.attributedString.string.userPerceivedCharacterIterator(remianingRange.location);
+        characterIterator.decrement();
         do{
-            lineRange = this._typesetter.suggestLineBreak(widthLimit, remianingRange, this.effectiveLineBreakMode(this.attributes.lineBreakMode, lines.length + 1, lineLimit));
+            lineWidthLimit = widthLimit;
+            if (lineWidthLimit < Number.MAX_VALUE){
+                if (characterIterator.isParagraphBreak){
+                    lineWidthLimit -= paragraphStyle.firstLineHeadIndent;
+                }else{
+                    lineWidthLimit -= paragraphStyle.headIndent;
+                }
+                lineWidthLimit -= paragraphStyle.tailIndent;
+            }
+            lineRange = this._typesetter.suggestLineBreak(lineWidthLimit, remianingRange, this.effectiveLineBreakMode(paragraphStyle.lineBreakMode, lines.length + 1, lineLimit));
             line = this._typesetter.createLine(lineRange);
             line.origin.y = y;
+            if (paragraphStyle.lineHeightMultiple > 0){
+                line.size.height *= paragraphStyle.lineHeightMultiple;
+            }
+            if (line.size.height < paragraphStyle.minimumLineHeight){
+                line.size.height = paragraphStyle.minimumLineHeight;
+            }
             y += line.size.height;
             if (y <= heightLimit){
-                spacing = Math.min(heightLimit - y, (this.attributes.lineSpacing - 1.0) * line.size.height);
-                line.size.height += Math.max(0, spacing);
-                y += spacing;
-                lines.push(line);
                 remianingRange.advance(line.range.length);
-            }else{
-                spacing = 0;
+                characterIterator = this._typesetter.attributedString.string.userPerceivedCharacterIterator(remianingRange.location);
+                characterIterator.decrement();
+                if (characterIterator.isParagraphBreak){
+                    y += Math.max(0, Math.min(heightLimit - y, paragraphStyle.paragraphSpacing));
+                    attributes = this._typesetter.resolveAttributes(this._typesetter.attributedString.attributesAtIndex(remianingRange.location));
+                    paragraphStyle = this._defaultParagraphStyle.styleWithAttributes(attributes);
+                    y += Math.max(0, Math.min(heightLimit - y, paragraphStyle.beforeParagraphSpacing));
+                }
+                y += Math.max(0, Math.min(heightLimit - y, paragraphStyle.lineSpacing));
+                lines.push(line);
             }
         } while (lineRange.length > 0 && remianingRange.length > 0 && y < heightLimit && lines.length < lineLimit);
 
-        if (this.attributes.lineBreakMode == JSLineBreakMode.truncateTail && lines.length > 0){
+        if (paragraphStyle.lineBreakMode == JSLineBreakMode.truncateTail && lines.length > 0){
             line = lines.pop();
             if (remianingRange.length > 0 && lineLimit > lines.length + 1){
                 // we got truncated because of height.  Re-run the last line so it
                 // gets broken according to truncation rules rather than word break
-                lineRange = this._typesetter.suggestLineBreak(widthLimit, JSRange(line.range.location, line.range.length + remianingRange.length), this.attributes.lineBreakMode);
+                lineRange = this._typesetter.suggestLineBreak(widthLimit, JSRange(line.range.location, line.range.length + remianingRange.length), paragraphStyle.lineBreakMode);
                 line = this._typesetter.createLine(lineRange);
             }
             var truncated = line.truncatedLine(widthLimit);
             lines.push(truncated);
         }
-        return this.constructFrame(lines, size, this.attributes);
+        var frame = this.constructFrame(lines, size);
+        this._alignLinesInFrame(frame);
+        return frame;
+    },
+
+    _resizeFrame: function(frame, size){
+        if (size.width < frame._usedSize.width || size.height < frame._usedSize.height){
+            throw new Error("Cannot adjust text frame to smaller than its used size");
+        }
+        frame._size = JSSize(size);
+        this._alignLinesInFrame(frame);
+    },
+
+    _alignLinesInFrame: function(frame){
+        var i, l;
+        var line;
+        var attributes;
+        var headIndent = 0;
+        var characterIterator;
+        var paragraphStyle;
+        for (i = 0, l = frame.lines.length; i < l; ++i){
+            line = frame.lines[i];
+            attributes = this._typesetter.resolveAttributes(this._typesetter.attributedString.attributesAtIndex(line.range.location));
+            paragraphStyle = this._defaultParagraphStyle.styleWithAttributes(attributes);
+            characterIterator = this._typesetter.attributedString.string.userPerceivedCharacterIterator(line.range.location);
+            characterIterator.decrement();
+            if (characterIterator.isParagraphBreak){
+                headIndent = paragraphStyle.firstLineHeadIndent;
+            }else{
+                headIndent = paragraphStyle.headIndent;
+            }
+            if (paragraphStyle.textAlignment === JSTextAlignment.left){
+                line.origin.x = headIndent;
+            }else if (paragraphStyle.textAlignment === JSTextAlignment.center){
+                line.origin.x = headIndent + (frame._size.width - headIndent - paragraphStyle.tailIndent - line.size.width + line.trailingWhitespaceWidth) / 2.0;
+            }else if (paragraphStyle.textAlignment === JSTextAlignment.right){
+                line.origin.x = (frame._size.width - line.size.width + line.trailingWhitespaceWidth) - paragraphStyle.tailIndent;
+            }
+        }
     },
 
     effectiveLineBreakMode: function(frameLineBreakMode, lineNumber, lineLimit){
@@ -104,15 +168,54 @@ JSClass("JSTextFramesetter", JSObject, {
             case JSLineBreakMode.characterWrap:
                 return frameLineBreakMode;
         }
+    },
+
+    // Deprecated:
+
+    attributes: JSReadOnlyProperty("_attributes", null),
+
+    getAttributes: function(){
+        logger.warn("JSTextFramesetter.attributes is deprecated");
+        if (this._attributes === null){
+            var framesetter = this;
+            this._attributes = Object.create({}, {
+                lineBreakMode: {
+                    get: function(){
+                        return framesetter._defaultParagraphStyle.lineBreakMode;
+                    },
+                    set: function(lineBreakMode){
+                        framesetter._defaultParagraphStyle.lineBreakMode = lineBreakMode;
+                    }
+                },
+                textAlignment: {
+                    get: function(){
+                        return framesetter._defaultParagraphStyle.textAlignment;
+                    },
+                    set: function(textAlignment){
+                        framesetter._defaultParagraphStyle.textAlignment = textAlignment;
+                    }
+                },
+                lineSpacing: {
+                    get: function(){
+                        return framesetter._defaultParagraphStyle.lineHeightMultiple > 0 ? framesetter._defaultParagraphStyle.lineHeightMultiple : 1.0;
+                    },
+                    set: function(lineSpacing){
+                        framesetter._defaultParagraphStyle.lineHeightMultiple = lineSpacing;
+                    }
+                },
+                minimumLineHeight: {
+                    get: function(){
+                        return framesetter._defaultParagraphStyle.minimumLineHeight;
+                    },
+                    set: function(minimumLineHeight){
+                        framesetter._defaultParagraphStyle.minimumLineHeight = minimumLineHeight;
+                    }
+                }
+            });
+        }
+        return this._attributes;
     }
 
 });
 
-var JSTextParagraphAttributes = {
-    minimumLineHeight: 0,
-    lineSpacing: 1.0,
-    textAlignment: JSTextAlignment.left,
-    lineBreakMode: JSLineBreakMode.truncateTail
-};
-
 })();