@breakside/jskit 2022.23.0 → 2022.25.1

package/Root/Frameworks/Foundation/JSAttributedString.js

@@ -68,19 +68,26 @@ JSClass("JSAttributedString", JSObject, {
                     // TODO:
                     return JSAttributedString.AttributeDecoder.skip(value);
                 case JSAttributedString.Attribute.maskCharacter:
+                case JSAttributedString.Attribute.paragraphStyleName:
                     return JSAttributedString.AttributeDecoder.string(value);
                 case JSAttributedString.Attribute.bold:
                 case JSAttributedString.Attribute.italic:
                 case JSAttributedString.Attribute.underline:
                 case JSAttributedString.Attribute.strike:
                     return JSAttributedString.AttributeDecoder.boolean(value);
-                case JSAttributedString.Attribute.lineHeight:
+                case JSAttributedString.Attribute.lineHeightMultiple:
                 case JSAttributedString.Attribute.lineSpacing:
+                case JSAttributedString.Attribute.paragraphSpacing:
+                case JSAttributedString.Attribute.beforeParagraphSpacing:
+                case JSAttributedString.Attribute.firstLineHeadIndent:
+                case JSAttributedString.Attribute.headIndent:
+                case JSAttributedString.Attribute.tailIndent:
+                case JSAttributedString.Attribute.minimumLineHeight:
                     return JSAttributedString.AttributeDecoder.number(value);
                 case JSAttributedString.Attribute.textAlignment:
-                    // TODO: validate
+                    return JSAttributedString.AttributeDecoder.enumValue(JSTextAlignment)(value);
                 case JSAttributedString.Attribute.lineBreakMode:
-                    // TODO: validate
+                    return JSAttributedString.AttributeDecoder.enumName(JSLineBreakMode)(value);
                 default:
                     return value;
             }
@@ -136,11 +143,18 @@ JSClass("JSAttributedString", JSObject, {
                 case JSAttributedString.Attribute.italic:
                 case JSAttributedString.Attribute.underline:
                 case JSAttributedString.Attribute.strike:
-                case JSAttributedString.Attribute.lineHeight:
+                case JSAttributedString.Attribute.lineHeightMultiple:
+                case JSAttributedString.Attribute.minimumLineHeight:
                 case JSAttributedString.Attribute.lineSpacing:
+                case JSAttributedString.Attribute.paragraphSpacing:
+                case JSAttributedString.Attribute.beforeParagraphSpacing:
+                case JSAttributedString.Attribute.firstLineHeadIndent:
+                case JSAttributedString.Attribute.headIndent:
+                case JSAttributedString.Attribute.tailIndent:
                 case JSAttributedString.Attribute.textAlignment:
                 case JSAttributedString.Attribute.lineBreakMode:
                 case JSAttributedString.Attribute.maskCharacter:
+                case JSAttributedString.Attribute.paragraphStyleName:
                 default:
                     return value;
             }
@@ -332,6 +346,8 @@ JSClass("JSAttributedString", JSObject, {
         }
         this._fixRunsAtIndex(runIndex);
         this._fixRunsAtIndex(runRange.location);
+        this._fixParagraphAttributesAtIndex(range.location);
+        this._fixParagraphAttributesAtIndex(range.location + attributedString.string.length);
     },
 
     // MARK: - Attribute mutations
@@ -521,6 +537,44 @@ JSClass("JSAttributedString", JSObject, {
         }
     },
 
+    _fixParagraphAttributesAtIndex: function(index){
+        if (index >= this._string.length){
+            return;
+        }
+        var paragraphRange = this._string.rangeForParagraphAtIndex(index);
+        var runIndex = this._runIndexForStringIndex(paragraphRange.location);
+        var run = this._runs[runIndex];
+        var paragraphAttributes = run.attributes;
+        var copy;
+        var i, l;
+        var attribute;
+        var value;
+        while (run.range.end < paragraphRange.end && runIndex < this._runs.length){
+            run = this._runs[runIndex];
+            if (!run.containsEqualParagraphAttributes(paragraphAttributes)){
+                if (run.range.end > paragraphRange.end){
+                    copy = JSAttributedStringRun(JSRange(paragraphRange.end, run.range.end - paragraphRange.end), run.attributes);
+                    this._runs.splice(runIndex + 1, 0, copy);
+                    run.range.length -= copy.range.length;
+                }
+                for (i = 0, l = JSAttributedString.paragraphAttributes.length; i < l; ++i){
+                    attribute = JSAttributedString.paragraphAttributes[i];
+                    if (attribute in paragraphAttributes){
+                        run.attributes[attribute] = paragraphAttributes[attribute];
+                    }else{
+                        delete run.attributes[attribute];
+                    }
+                }
+                if (this._runs[runIndex - 1].onlyContainsEqualAttributes(run.attributes)){
+                    this._runs[runIndex - 1].range.length += run.range.length;
+                    this._runs.splice(runIndex, 1);
+                    --runIndex;
+                }
+            }
+            ++runIndex;
+        }
+    },
+
     _rangeOfRunsPreparedForChangeInStringRange: function(range){
         var firstRunIndex = this._splitRunAtIndex(range.location);
         if (range.length > 0){
@@ -591,15 +645,38 @@ JSAttributedString.Attribute = {
     underline: "underline",
     strike: "strike",
     attachment: "attachment",
-    lineHeight: "lineHeight",
-    lineSpacing: "lineSpacing",
-    textAlignment: "textAlignment",
-    lineBreakMode: "lineBreakMode",
     maskCharacter: "maskCharacter",
     cursor: "cursor",
-    link: "link"
+    link: "link",
+
+    // Paragraph
+    paragraphStyleName: "paragraphStyleName",
+    textAlignment: "textAlignment",
+    lineBreakMode: "lineBreakMode",
+    minimumLineHeight: "minimumLineHeight",
+    lineHeightMultiple: "lineHeightMultiple",
+    lineSpacing: "lineSpacing",
+    paragraphSpacing: "paragraphSpacing",
+    beforeParagraphSpacing: "beforeParagraphSpacing",
+    firstLineHeadIndent: "firstLineHeadIndent",
+    headIndent: "headIndent",
+    tailIndent: "tailIndent",
 };
 
+JSAttributedString.paragraphAttributes = [
+    JSAttributedString.Attribute.paragraphStyleName,
+    JSAttributedString.Attribute.textAlignment,
+    JSAttributedString.Attribute.lineBreakMode,
+    JSAttributedString.Attribute.minimumLineHeight,
+    JSAttributedString.Attribute.lineHeightMultiple,
+    JSAttributedString.Attribute.lineSpacing,
+    JSAttributedString.Attribute.paragraphSpacing,
+    JSAttributedString.Attribute.beforeParagraphSpacing,
+    JSAttributedString.Attribute.firstLineHeadIndent,
+    JSAttributedString.Attribute.headIndent,
+    JSAttributedString.Attribute.tailIndent
+];
+
 JSAttributedString.AttributeEncoder = {
     skip: function(value){ return undefined; },
     identity: function(value){ return value; },
@@ -609,6 +686,15 @@ JSAttributedString.AttributeEncoder = {
     url: function(value){ return value.encodedString; },
     font: function(value){ return value.dictionaryRepresentation(); },
     color: function(value){ return value.dictionaryRepresentation(); },
+    enumName: function(obj){
+        return function(value){
+            for (var name in obj){
+                if (obj[name] === value){
+                    return name;
+                }
+            }
+        };
+    }
 };
 
 JSAttributedString.AttributeDecoder = {
@@ -623,6 +709,20 @@ JSAttributedString.AttributeDecoder = {
     boolean: function(value){ return typeof(value) === "boolean" ? value : undefined; },
     number: function(value){ return typeof(value) === "number" ? value : undefined; },
     string: function(value){ return typeof(value) === "string" ? value : undefined; },
+    enumName: function(obj){
+        return function(value){
+            return obj[value];
+        };
+    },
+    enumValue: function(obj){
+        return function(value){
+            for (var name in obj){
+                if (obj[name] === value){
+                    return value;
+                }
+            }
+        };
+    }
 };
 
 JSAttributedString.SpecialCharacter = {
@@ -694,6 +794,35 @@ JSAttributedStringRun.prototype = {
         return true;
     },
 
+    containsEqualParagraphAttributes: function(attributes){
+        var attribute;
+        var a, b;
+        for (var i = 0, l = JSAttributedString.paragraphAttributes.length; i < l; ++i){
+            attribute = JSAttributedString.paragraphAttributes[i];
+            a = attributes[attribute];
+            b = this.attributes[attribute];
+            if (a === undefined){
+                if (!!b){
+                    return false;
+                }
+            }else if (a === null){
+                if (b !== null && b !== undefined){
+                    return false;
+                }
+            }else if (a.isEqual){
+                if (b === null || b === undefined){
+                    return false;
+                }
+                if (!a.isEqual(b)){
+                    return false;
+                }
+            }else if (a != b){
+                return false;
+            }
+        }
+        return true;
+    }
+
 };
 
 var JSAttributedStringRunIterator = function(attributedString, startIndex){
@@ -764,7 +893,7 @@ Object.defineProperties(JSAttributedStringRunIterator.prototype, {
                 return null;
             }
             var run = this._attributedString._runs[this._runIndex];
-            if (run.range.length === 1 && this._attributedString.charCodeAt(run.range.location) === JSAttributedString.SpecialCharacter.attachment){
+            if (run.range.length === 1 && this._attributedString.string.charCodeAt(run.range.location) === JSAttributedString.SpecialCharacter.attachment){
                 return run.attributes[JSAttributedString.Attribute.attachment];
             }
             return null;

package/Root/Frameworks/Foundation/JSFileManager+Node.js

@@ -157,8 +157,8 @@ JSClass("JSNodeFileManager", JSFileManager, {
             if (!error){
                 attrs = {
                     itemType: JSFileManager.ItemType.fromStat(stats),
-                    created: Math.floor(stats.ctimeMs),
-                    modified: Math.floor(stats.mtimeMs),
+                    created: Math.floor(stats.ctimeMs / 1000.0),
+                    updated: Math.floor(stats.mtimeMs / 1000.0),
                     size: stats.size
                 };
             }

package/Root/Frameworks/Foundation/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/Root/Frameworks/Foundation/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/Root/Frameworks/Foundation/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/Root/Frameworks/Foundation/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;