@breakside/jskit 2022.22.2 → 2022.24.0

package/Root/Frameworks/DOM/XMLSerializer.js

@@ -113,10 +113,15 @@ XMLSerializer.prototype = {
                     str += " " + node.name;
                 }
                 if (node.publicId.length > 0){
-                    str += " " + node.publicId;
-                }
-                if (node.systemId.length > 0){
-                    str += " " + node.systemId;
+                    value = node.publicId.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+                    str += ' PUBLIC "%s"'.sprintf(value);
+                    if (node.systemId.length > 0){
+                        value = node.systemId.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+                        str += ' "%s"'.sprintf(value);
+                    }
+                }else if (node.systemId.length > 0){
+                    value = node.systemId.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+                    str += ' SYSTEM "%s"'.sprintf(value);
                 }
                 str += ">\n";
             }

package/Root/Frameworks/Dispatch/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.Dispatch
-JSBundleVersion: 2022.22.2
+JSBundleVersion: 2022.24.0
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSBundleEnvironments:
   html: Dispatch+HTML.js

package/Root/Frameworks/FontKit/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.FontKit
-JSBundleVersion: 2022.22.2
+JSBundleVersion: 2022.24.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSBundleEnvironments:

package/Root/Frameworks/Foundation/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.Foundation
-JSBundleVersion: 2022.22.2
+JSBundleVersion: 2022.24.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSBundleEnvironments:

package/Root/Frameworks/Foundation/JSAttributedString.js

@@ -16,6 +16,8 @@
 // #import "Javascript.js"
 // #import "JSObject.js"
 // #import "JSTextAttachment.js"
+// #import "JSFont.js"
+// #import "JSColor.js"
 'use strict';
 
 (function(){
@@ -40,6 +42,137 @@ JSClass("JSAttributedString", JSObject, {
         this._runs = [run];
     },
 
+    initFromDictionary: function(dictionary){
+        this._string = typeof(dictionary.string) === "string" ? dictionary.string : "";
+        this._runs = [];
+        var i, l;
+        var runDictionary;
+        var run;
+        var attributes;
+        var name;
+        var location = 0;
+        var length;
+        var maxLength = this._string.length;
+        var decodeAttribute = function(name, value){
+            switch (name){
+                case JSAttributedString.Attribute.font:
+                    return JSAttributedString.AttributeDecoder.font(value);
+                case JSAttributedString.Attribute.textColor:
+                case JSAttributedString.Attribute.backgroundColor:
+                    return JSAttributedString.AttributeDecoder.color(value);
+                case JSAttributedString.Attribute.link:
+                    return JSAttributedString.AttributeDecoder.url(value);
+                case JSAttributedString.Attribute.cursor:
+                    return JSAttributedString.AttributeDecoder.skip(value);
+                case JSAttributedString.Attribute.attachment:
+                    // 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.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:
+                    return JSAttributedString.AttributeDecoder.enumValue(JSTextAlignment)(value);
+                case JSAttributedString.Attribute.lineBreakMode:
+                    return JSAttributedString.AttributeDecoder.enumName(JSLineBreakMode)(value);
+                default:
+                    return value;
+            }
+            
+        };
+        if (dictionary.runs instanceof Array){
+            for (i = 0, l = dictionary.runs.length; i < l && maxLength > 0; ++i){
+                runDictionary = dictionary.runs[i];
+                attributes = {};
+                length = typeof(runDictionary.length) === "number" ? Math.min(maxLength, Math.floor(runDictionary.length)) : 0;
+                if (length > 0 && typeof(runDictionary.attributes) === "object"){
+                    for (name in runDictionary.attributes){
+                        attributes[name] = decodeAttribute(name, runDictionary.attributes[name]);
+                    }
+                    this._runs.push(JSAttributedStringRun(JSRange(location, length), attributes));
+                }
+                location += length;
+                maxLength -= length;
+            }
+        }
+        if (maxLength > 0){
+            this._runs.push(JSAttributedStringRun(JSRange(location, maxLength), {}));
+        }
+        if (this._runs.length === 0){
+            this._runs.push(JSAttributedStringRun(JSRange(0, 0), {}));
+        }
+    },
+
+    dictionaryRepresentation: function(){
+        var dictionary = {
+            string: this._string,
+            runs: []
+        };
+        var i, l;
+        var run;
+        var name;
+        var runDictionary;
+        var encodeAttribute = function(name, value){
+            switch (name){
+                case JSAttributedString.Attribute.font:
+                    return JSAttributedString.AttributeEncoder.font(value);
+                case JSAttributedString.Attribute.textColor:
+                case JSAttributedString.Attribute.backgroundColor:
+                    return JSAttributedString.AttributeEncoder.color(value);
+                case JSAttributedString.Attribute.link:
+                    return JSAttributedString.AttributeEncoder.url(value);
+                case JSAttributedString.Attribute.cursor:
+                    return JSAttributedString.Attribute.Encoder.skip(value);
+                case JSAttributedString.Attribute.attachment:
+                    // TODO:
+                    return JSAttributedString.Attribute.Encoder.skip(value);
+                case JSAttributedString.Attribute.bold:
+                case JSAttributedString.Attribute.italic:
+                case JSAttributedString.Attribute.underline:
+                case JSAttributedString.Attribute.strike:
+                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;
+            }
+        };
+        for (i = 0, l = this._runs.length; i < l; ++i){
+            run = this._runs[i];
+            runDictionary = {
+                length: run.range.length,
+                attributes: {}
+            };
+            for (name in run.attributes){
+                runDictionary.attributes[name] = encodeAttribute(name, run.attributes[name]);
+            }
+            dictionary.runs.push(runDictionary);
+        }
+        return dictionary;
+    },
+
     initWithAttributedString: function(attributedString, defaultAttributes){
         this._string = attributedString.string;
         this._runs = [];
@@ -213,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
@@ -294,6 +429,44 @@ JSClass("JSAttributedString", JSObject, {
         return new JSAttributedStringRunIterator(this, index);
     },
 
+    longestRangeOfAttributeAtIndex: function(attributeName, index){
+        return this.longestRangeOfAttributesAtIndex([attributeName], index);
+    },
+
+    longestRangeOfAttributesAtIndex: function(attributeNames, index){
+        var runIndex = this._runIndexForStringIndex(index);
+        var run = this._runs[runIndex];
+        var range = JSRange(run.range);
+        var attributes = {};
+        var i, l;
+        for (i = 0, l = attributeNames.length; i < l; ++i){
+            attributes[attributeNames[i]] = run.attributes[attributeNames[i]];
+        }
+        i = runIndex - 1;
+        while (i >= 0){
+            run = this._runs[i];
+            if (run.containsEqualAttributes(attributes)){
+                range.length = range.end - run.range.location;
+                range.location = run.range.location;
+            }else{
+                break;
+            }
+            --i;
+        }
+        i = runIndex + 1;
+        l = this._runs.length;
+        while (i < l){
+            run = this._runs[i];
+            if (run.containsEqualAttributes(attributes)){
+                range.length = run.range.end - range.location;
+            }else{
+                break;
+            }
+            ++i;
+        }
+        return range;
+    },
+
     // MARK: - Formatting
 
     replaceFormat: function(){
@@ -339,7 +512,7 @@ JSClass("JSAttributedString", JSObject, {
         var runA;
         for (var runIndex = lastRunIndex - 1; runIndex >= expandedRunRange.location; --runIndex){
             runA = this._runs[runIndex];
-            if (runA.hasIdenticalAttributes(runB)){
+            if (runA.onlyContainsEqualAttributes(runB.attributes)){
                 this._runs.splice(runIndex, 1);
                 runB.range.location = runA.range.location;
                 runB.range.length += runA.range.length;
@@ -358,12 +531,50 @@ JSClass("JSAttributedString", JSObject, {
         }
         var runA = this._runs[runIndex - 1];
         var runB = this._runs[runIndex];
-        if (runA.hasIdenticalAttributes(runB)){
+        if (runA.onlyContainsEqualAttributes(runB.attributes)){
             this._runs.splice(runIndex, 1);
             runA.range.length += runB.range.length;
         }
     },
 
+    _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){
@@ -434,13 +645,84 @@ 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; },
+    dataBase64: function(value){ return value.base64StringRepresentation(); },
+    dataBase64URL: function(value){ return value.base64URLStringRepresentation(); },
+    dataHex: function(value){ return value.hexStringRepresentation(); },
+    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 = {
+    skip: function(value){ return undefined; },
+    identity: function(value){ return value; },
+    dataBase64: function(value){ return value.dataByDecodingBase64(); },
+    dataBase64URL: function(value){ return value.dataByDecodingBase64URL(); },
+    dataHex: function(value){ return value.dataByDecodingHex(); },
+    url: function(value){ return JSURL.initWithString(value); },
+    font: function(value){ return JSFont.initFromDictionary(value); },
+    color: function(value){ return JSColor.initFromDictionary(value); },
+    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 = {
@@ -471,30 +753,70 @@ function JSAttributedStringRun(range, attributes){
 
 JSAttributedStringRun.prototype = {
 
-    hasIdenticalAttributes: function(other){
+    containsEqualAttributes: function(attributes){
         var attribute;
         var a, b;
-        for (attribute in this.attributes){
-            if (attribute in other.attributes){
-                a = this.attributes[attribute];
-                b = other.attributes[attribute];
-                if (a.isEqual){
-                    if (!a.isEqual(b)){
-                        return false;
-                    }
-                }else if (b.isEqual){
-                    if (!b.isEqual(a)){
-                        return false;
-                    }
-                }else if (a != b){
+        for (attribute in attributes){
+            a = attributes[attribute];
+            b = this.attributes[attribute];
+            if (a === undefined){
+                if (!!b){
                     return false;
                 }
-            }else{
+            }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;
             }
         }
-        for (attribute in other.attributes){
-            if (!(attribute in this.attributes)){
+        return true;
+    },
+
+    onlyContainsEqualAttributes: function(attributes){
+        if (!this.containsEqualAttributes(attributes)){
+            return false;
+        }
+        var attribute;
+        for (attribute in this.attributes){
+            if (!(attribute in attributes)){
+                return false;
+            }
+        }
+        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;
             }
         }
@@ -571,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/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/Root/Frameworks/Foundation/JSFontDescriptor+HTML.js

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