@breakside/jskit 2022.22.2 → 2022.24.0

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

@@ -49,7 +49,7 @@ JSClass("JSFont", JSObject, {
         var weight;
         var style;
         var size;
-        var defaults = JSFont._systemFontDescriptor;
+        var defaults = JSFontDescriptor.system;
         // if ('descriptor' in values){
         //     values = values.descriptor;
         // }
@@ -78,7 +78,7 @@ JSClass("JSFont", JSObject, {
             size = JSFont.Size.normal;
         }
         if (family){
-            var descriptor = JSResourceFontDescriptor.descriptorWithFamily(family, weight, style);
+            var descriptor = JSFontDescriptor.descriptorWithFamily(family, weight, style);
             if (descriptor !== null){
                 return JSFont.initWithDescriptor(descriptor, size);
             }
@@ -86,6 +86,30 @@ JSClass("JSFont", JSObject, {
         return null;
     },
 
+    initFromDictionary: function(dictionary){
+        var descriptor = JSFontDescriptor.descriptorWithFamily(dictionary.family, dictionary.weight, dictionary.style);
+        if (descriptor === null){
+            if (dictionary.url){
+                descriptor = JSURLFontDescriptor.initWithURL(JSURL.initWithString(dictionary.url), dictionary.family, dictionary.weight, dictionary.style);
+                JSFontDescriptor.registerDescriptor(descriptor);
+            }
+        }
+        if (descriptor !== null){
+            return JSFont.initWithDescriptor(descriptor, dictionary.size);
+        }
+        return null;
+    },
+
+    dictionaryRepresentation: function(){
+        return {
+            url: this.descriptor instanceof JSURLFontDescriptor ? this._descriptor.url : undefined,
+            family: this._descriptor.family,
+            weight: this._descriptor.weight,
+            style: this._descriptor.style,
+            size: this.pointSize
+        };
+    },
+
     getFullName: function(){
         return this._descriptor.name;
     },
@@ -187,7 +211,7 @@ JSClass("JSFont", JSObject, {
 });
 
 JSFont.fontWithFamily = function(family, pointSize, weight, style){
-    var descriptor = JSResourceFontDescriptor.descriptorWithFamily(family, weight || JSFont.Weight.regular, style || JSFont.Style.normal);
+    var descriptor = JSFontDescriptor.descriptorWithFamily(family, weight || JSFont.Weight.regular, style || JSFont.Style.normal);
     return JSFont.initWithDescriptor(descriptor, pointSize);
 };
 
@@ -204,12 +228,12 @@ JSFont.registerBundleFonts = function(bundle){
 
 JSFont._registerFontResource = function(bundle, metadata){
     var descriptor = JSResourceFontDescriptor.initWithMetadata(bundle, metadata);
+    JSFontDescriptor.registerDescriptor(descriptor);
     return descriptor;
 };
 
-JSFont._systemFontDescriptor = null;
-
-JSFont.registerSystemFontResource = function(name){
+JSFont.registerSystemFontResource = function(name, bundle){
+    bundle = bundle || JSBundle.mainBundle;
     var ext;
     var extIndex = name.lastIndexOf('.');
     var i, l;
@@ -221,33 +245,33 @@ JSFont.registerSystemFontResource = function(name){
         extGuessed = true;
         ext = "ttf";
     }
-    var metadata = JSBundle.mainBundle.metadataForResourceName(name, ext);
+    var metadata = bundle.metadataForResourceName(name, ext);
     if (extGuessed && metadata === null){
         ext = "otf";
-        metadata = JSBundle.mainBundle.metadataForResourceName(name, ext);
+        metadata = bundle.metadataForResourceName(name, ext);
     }
-    this._systemFontDescriptor = JSResourceFontDescriptor.descriptorsByName[metadata.font.unique_identifier];
+    JSFontDescriptor.system = JSResourceFontDescriptor.descriptorsByName[metadata.font.unique_identifier];
 };
 
 JSFont.registerSystemFont = function(familyName, weight, style){
-    this._systemFontDescriptor = JSResourceFontDescriptor.descriptorWithFamily(familyName, weight || JSFont.Weight.regular, style || JSFont.Style.normal);
+    JSFontDescriptor.system = JSFontDescriptor.descriptorWithFamily(familyName, weight || JSFont.Weight.regular, style || JSFont.Style.normal);
 };
 
 JSFont.registerSystemFontDescriptor = function(descriptor){
-    this._systemFontDescriptor = descriptor;
+    JSFontDescriptor.system = descriptor;
 };
 
 JSFont.unregisterAllFonts = function(){
-    JSResourceFontDescriptor.descriptorsByFamily = {};
+    JSFontDescriptor.descriptorsByFamily = {};
     JSResourceFontDescriptor.descriptorsByName = {};
-    this._systemFontDescriptor = null;
+    JSFontDescriptor.system = null;
 };
 
 JSFont.systemFontOfSize = function(pointSize){
-    if (this._systemFontDescriptor === null){
+    if (JSFontDescriptor.system === null){
         return null;
     }
-    return JSFont.initWithDescriptor(this._systemFontDescriptor, pointSize);
+    return JSFont.initWithDescriptor(JSFontDescriptor.system, pointSize);
 };
 
 JSFont.Size = {

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

@@ -94,4 +94,12 @@ JSDataFontDescriptor.definePropertiesFromExtensions({
 
 });
 
+JSURLFontDescriptor.definePropertiesFromExtensions({
+
+    htmlURLString: function(){
+        return this.url.encodedString;
+    }
+
+});
+
 })();

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;