@breakside/jskit 2021.52.0 → 2022.6.0

package/Root/Frameworks/DBKit/DBRedisStore.js

@@ -41,7 +41,7 @@ JSClass("DBRedisStore", DBObjectStore, {
 
     open: function(completion){
         logger.info("Redis client connecting to %{public}:%d...", this.url.host, this.url.port || 6379);
-        this.client = this.redis.createClient({url: this.url.encodedString});
+        this.client = this.redis.createClient({url: this.url.encodedString, legacyMode: true});
         var store = this;
         var errorHandler = function(error){
             logger.info("Failed to open Redis connection: %{error}", error);
@@ -67,8 +67,12 @@ JSClass("DBRedisStore", DBObjectStore, {
                 store.close(fn);
             }
         };
-        this.client.on("error", errorHandler);
-        this.client.on("ready", readyHandler);
+        if (this.client.connect){
+            this.client.connect().then(readyHandler, errorHandler);
+        }else{
+            this.client.on("error", errorHandler);
+            this.client.on("ready", readyHandler);
+        }
     },
 
     closeCallback: null,
@@ -233,7 +237,7 @@ JSClass("DBRedisStore", DBObjectStore, {
 
     watchClientQueue: null,
 
-    dequeueReusableWatchClient: function(){
+    dequeueReusableWatchClient: function(completion, target){
         if (this.watchClientQueue === null){
             this.watchClientQueue = [];
         }
@@ -245,7 +249,17 @@ JSClass("DBRedisStore", DBObjectStore, {
             return this.watchClientQueue.shift();
         }
         logger.info("opening watch client to %{public}:%d", this.url.host, this.url.port || 6379);
-        return this.redis.createClient({url: this.url.encodedString});
+        var client = this.redis.createClient({url: this.url.encodedString, legacyMode: true});
+        if (client.connect){
+            client.connect().then(function(){
+                completion.call(target, client);
+            }, function(error){
+                logger.error("Error connecting to watch client: %{error}", error);
+                completion.call(target, null);
+            });
+        }else{
+            completion.call(target, client);
+        }
     },
 
     enqueueReusableWatchClient: function(client){
@@ -277,120 +291,125 @@ JSClass("DBRedisStore", DBObjectStore, {
     },
 
     exclusiveSave: function(id, change, completion){
-        var watchClient = this.dequeueReusableWatchClient();
-        var maxRetires = 30;
-        var waitInterval = JSTimeInterval.milliseconds(20);
-        var retires = 0;
-        var store = this;
-        var trySave = function(){
-            try{
-                watchClient.watch(id, function(error){
-                    if (error !== null){
-                        logger.error("Failure calling redis watch: %{error}", error);
-                        watchClient.quit();
-                        completion(false);
-                        return;
-                    }
-                    try{
-                        watchClient.get(id, function(error, json){
-                            if (error !== null){
-                                logger.error("Failure calling redis get: %{error}", error);
-                                watchClient.quit();
-                                completion(false);
-                                return;
-                            }
-                            var object = null;
-                            try{
-                                object = JSON.parse(json);
-                            }catch (e){
-                                logger.error("Failure parsing object json: %{error}", error);
-                                watchClient.quit();
-                                completion(false);
-                                return;
-                            }
-                            try{
-                                watchClient.ttl(id, function(error, ttl){
-                                    if (error !== null){
-                                        logger.error("Failure calling redis ttl: %{error}", error);
-                                        watchClient.quit();
-                                        completion(false);
-                                        return;
-                                    }
-                                    try{
-                                        change(object, function(changedObject){
-                                            if (changedObject === null){
-                                                watchClient.quit();
-                                                completion(false);
-                                                return;
-                                            }
-                                            var changedJSON = null;
-                                            try{
-                                                changedJSON = JSON.stringify(changedObject);
-                                            }catch (e){
-                                                logger.error("Failed to serialize object for redis: %{error}", e);
-                                                watchClient.quit();
-                                                completion(false);
-                                                return;
-                                            }
-                                            var args = [id, changedJSON];
-                                            if (ttl > 0){
-                                                args.push("EX");
-                                                args.push(ttl);
-                                            }
-                                            try{
-                                                watchClient.multi().set(args).exec(function(error, results){
-                                                    if (error !== null){
-                                                        logger.error("Failure calling redis multi/set/exec: %{error}", error);
-                                                        watchClient.quit();
-                                                        completion(false);
-                                                        return;
-                                                    }
-                                                    if (results === null){
-                                                        // null results means the transaction failed, so it's our signal to retry
-                                                        ++retires;
-                                                        if (retires > maxRetires){
-                                                            store.enqueueReusableWatchClient(watchClient);
-                                                            completion(true);
-                                                            return;
-                                                        }
-                                                        JSTimer.scheduledTimerWithInterval(waitInterval, trySave);
-                                                        waitInterval = Math.min(1, waitInterval * 2);
-                                                        return;
-                                                    }
-                                                    store.enqueueReusableWatchClient(watchClient);
-                                                    completion(true);
-                                                });
-                                            }catch (e){
-                                                logger.error("Error thrown calling redis multi/set/exec: %{error}", e);
-                                                watchClient.quit();
-                                                completion(false);
-                                            }
-                                        });
-                                    }catch (e){
-                                        logger.error("Error thrown calling change function: %{error}", e);
-                                        watchClient.quit();
-                                        completion(false);
-                                    }
-                                });
-                            }catch (e){
-                                logger.error("Error thrown calling redis ttl: %{error}", error);
-                                watchClient.quit();
-                                completion(false);
-                            }
-                        });
-                    }catch (e){
-                        logger.error("Error thrown calling redis get: %{error}", error);
-                        watchClient.quit();
-                        completion(false);
-                    }
-                });
-            }catch (e){
-                logger.error("Error thrown calling redis watch: %{error}", e);
-                watchClient.quit();
+        this.dequeueReusableWatchClient(function(watchClient){
+            if (watchClient === null){
                 completion(false);
+                return;
             }
-        };
-        trySave();
+            var maxRetires = 30;
+            var waitInterval = JSTimeInterval.milliseconds(20);
+            var retires = 0;
+            var store = this;
+            var trySave = function(){
+                try{
+                    watchClient.watch(id, function(error){
+                        if (error !== null){
+                            logger.error("Failure calling redis watch: %{error}", error);
+                            watchClient.quit();
+                            completion(false);
+                            return;
+                        }
+                        try{
+                            watchClient.get(id, function(error, json){
+                                if (error !== null){
+                                    logger.error("Failure calling redis get: %{error}", error);
+                                    watchClient.quit();
+                                    completion(false);
+                                    return;
+                                }
+                                var object = null;
+                                try{
+                                    object = JSON.parse(json);
+                                }catch (e){
+                                    logger.error("Failure parsing object json: %{error}", error);
+                                    watchClient.quit();
+                                    completion(false);
+                                    return;
+                                }
+                                try{
+                                    watchClient.ttl(id, function(error, ttl){
+                                        if (error !== null){
+                                            logger.error("Failure calling redis ttl: %{error}", error);
+                                            watchClient.quit();
+                                            completion(false);
+                                            return;
+                                        }
+                                        try{
+                                            change(object, function(changedObject){
+                                                if (changedObject === null){
+                                                    watchClient.quit();
+                                                    completion(false);
+                                                    return;
+                                                }
+                                                var changedJSON = null;
+                                                try{
+                                                    changedJSON = JSON.stringify(changedObject);
+                                                }catch (e){
+                                                    logger.error("Failed to serialize object for redis: %{error}", e);
+                                                    watchClient.quit();
+                                                    completion(false);
+                                                    return;
+                                                }
+                                                var args = [id, changedJSON];
+                                                if (ttl > 0){
+                                                    args.push("EX");
+                                                    args.push(ttl);
+                                                }
+                                                try{
+                                                    watchClient.multi().set(args).exec(function(error, results){
+                                                        if (error !== null){
+                                                            logger.error("Failure calling redis multi/set/exec: %{error}", error);
+                                                            watchClient.quit();
+                                                            completion(false);
+                                                            return;
+                                                        }
+                                                        if (results === null){
+                                                            // null results means the transaction failed, so it's our signal to retry
+                                                            ++retires;
+                                                            if (retires > maxRetires){
+                                                                store.enqueueReusableWatchClient(watchClient);
+                                                                completion(true);
+                                                                return;
+                                                            }
+                                                            JSTimer.scheduledTimerWithInterval(waitInterval, trySave);
+                                                            waitInterval = Math.min(1, waitInterval * 2);
+                                                            return;
+                                                        }
+                                                        store.enqueueReusableWatchClient(watchClient);
+                                                        completion(true);
+                                                    });
+                                                }catch (e){
+                                                    logger.error("Error thrown calling redis multi/set/exec: %{error}", e);
+                                                    watchClient.quit();
+                                                    completion(false);
+                                                }
+                                            });
+                                        }catch (e){
+                                            logger.error("Error thrown calling change function: %{error}", e);
+                                            watchClient.quit();
+                                            completion(false);
+                                        }
+                                    });
+                                }catch (e){
+                                    logger.error("Error thrown calling redis ttl: %{error}", error);
+                                    watchClient.quit();
+                                    completion(false);
+                                }
+                            });
+                        }catch (e){
+                            logger.error("Error thrown calling redis get: %{error}", error);
+                            watchClient.quit();
+                            completion(false);
+                        }
+                    });
+                }catch (e){
+                    logger.error("Error thrown calling redis watch: %{error}", e);
+                    watchClient.quit();
+                    completion(false);
+                }
+            };
+            trySave();
+        }, this);
     },
 
     saveChange: function(change, completion){

package/Root/Frameworks/DBKit/Info.yaml

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

package/Root/Frameworks/DOM/Info.yaml

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

package/Root/Frameworks/Dispatch/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.Dispatch
-JSBundleVersion: 2021.52.0
+JSBundleVersion: 2022.6.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: 2021.52.0
+JSBundleVersion: 2022.6.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: 2021.52.0
+JSBundleVersion: 2022.6.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSBundleEnvironments:

package/Root/Frameworks/Foundation/JSColor.js

@@ -300,6 +300,15 @@ JSClass('JSColor', JSObject, {
         return JSColor.initWithSpaceAndComponents(JSColorSpace.gray, gray);
     },
 
+    colorInSpace: function(space){
+        if (space === this._space){
+            return this;
+        }
+        var components = space.componentsFromSpace(this._space, this._components);
+        components.push(this._components[this._components.length - 1]);
+        return JSColor.initWithSpaceAndComponents(space, components);
+    },
+
     rgbaHexStringRepresentation: function(){
         var color = this.rgbaColor();
         var r = Math.round(color.red * 255);

package/Root/Frameworks/Foundation/JSColorSpace.js

@@ -88,14 +88,14 @@ JSClass("JSXYZColorSpace", JSColorSpace, {
 
     name: "xyz",
 
-    initWithWhitepoint: function(mediaWhitepoint, connectionWhitepoint){
-        if (mediaWhitepoint === connectionWhitepoint){
+    initWithWhitepoint: function(mediaWhitepoint){
+        if (mediaWhitepoint === JSColorSpace.Whitepoint.profileConnection){
             return JSColorSpace.xyz;
         }
-        if (mediaWhitepoint[0] === connectionWhitepoint[0] && mediaWhitepoint[1] === connectionWhitepoint[1] && mediaWhitepoint[2] === connectionWhitepoint[2]){
+        if (mediaWhitepoint[0] === JSColorSpace.Whitepoint.profileConnection[0] && mediaWhitepoint[1] === JSColorSpace.Whitepoint.profileConnection[1] && mediaWhitepoint[2] === JSColorSpace.Whitepoint.profileConnection[2]){
             return JSColorSpace.xyz;
         }
-        return JSXYZScaledColorSpace.initWithWhitepoint(mediaWhitepoint, connectionWhitepoint);
+        return JSXYZScaledColorSpace.initWithWhitepoint(mediaWhitepoint);
     },
 
     initWithScale: function(scale){
@@ -125,11 +125,11 @@ JSClass("JSXYZScaledColorSpace", JSXYZColorSpace, {
     _scale: null,
     _inverseScale: null,
 
-    initWithWhitepoint: function(mediaWhitepoint, connectionWhitepoint){
+    initWithWhitepoint: function(mediaWhitepoint){
         this.initWithScale([
-            mediaWhitepoint[0] / connectionWhitepoint[0],
-            mediaWhitepoint[1] / connectionWhitepoint[1],
-            mediaWhitepoint[2] / connectionWhitepoint[2]
+            mediaWhitepoint[0] / JSColorSpace.Whitepoint.profileConnection[0],
+            mediaWhitepoint[1] / JSColorSpace.Whitepoint.profileConnection[1],
+            mediaWhitepoint[2] / JSColorSpace.Whitepoint.profileConnection[2]
         ]);
     },
 
@@ -164,10 +164,7 @@ JSClass("JSLabColorSpace", JSColorSpace, {
 
     name: "lab",
 
-    mediaWhitepoint: null,
-
-    initWithWhitepoint: function(mediaWhitepoint){
-        this.mediaWhitepoint = mediaWhitepoint;
+    init: function(){
     },
 
     xyzFromComponents: function(components){
@@ -181,9 +178,9 @@ JSClass("JSLabColorSpace", JSColorSpace, {
         var fx = components[1] / 500.0 + fy;
         var fz = fy - components[2] / 200.0;
         return [
-            this.mediaWhitepoint[0] * fi(fx),
-            this.mediaWhitepoint[1] * fi(fy),
-            this.mediaWhitepoint[2] * fi(fz)
+            JSColorSpace.Whitepoint.profileConnection[0] * fi(fx),
+            JSColorSpace.Whitepoint.profileConnection[1] * fi(fy),
+            JSColorSpace.Whitepoint.profileConnection[2] * fi(fz)
         ];
     },
 
@@ -194,9 +191,9 @@ JSClass("JSLabColorSpace", JSColorSpace, {
             }
             return (841.0 / 108.0) * x + 4.0 / 29.0;
         }; 
-        var fx = f(xyz[0] / this.mediaWhitepoint[0]);
-        var fy = f(xyz[1] / this.mediaWhitepoint[1]);
-        var fz = f(xyz[2] / this.mediaWhitepoint[2]);
+        var fx = f(xyz[0] / JSColorSpace.Whitepoint.profileConnection[0]);
+        var fy = f(xyz[1] / JSColorSpace.Whitepoint.profileConnection[1]);
+        var fz = f(xyz[2] / JSColorSpace.Whitepoint.profileConnection[2]);
         return [
             116.0 * fy - 16.0,
             500.0 * (fx - fy),
@@ -239,10 +236,52 @@ JSClass("JSRGBColorSpace", JSColorSpace, {
 
     // MARK: - Lab conversions
 
+    xyzMatrix: [
+        [0.4360, 0.3851, 0.1431],
+        [0.2225, 0.7169, 0.0606],
+        [0.0139, 0.09710, 0.7139]
+    ],
+
+    xyzInverseMatrix: [
+        [3.13458, -1.61731, -0.491034],
+        [-0.978957, 1.91622, 0.0335704],
+        [0.0721194, -0.229142, 1.40575]
+    ],
+
+    g: 2.4,
+    a: 1.0 / 1.055,
+    b: 0.055 / 1.055,
+    c: 1.0 / 12.92,
+    d: 0.04045,
+
+    curve: function(x){
+        return parametricCurve3(x, this.g, this.a, this.b, this.c, this.d);
+    },
+
+    inverseCurve: function(y){
+        y = Math.max(0, Math.min(1, y));
+        return inverseParametricCurve3(y, this.g, this.a, this.b, this.c, this.d);
+    },
+
     xyzFromComponents: function(components){
+        var rgb = [
+            this.curve(components[0]),
+            this.curve(components[1]),
+            this.curve(components[2])
+        ];
+        return [
+            this.xyzMatrix[0][0] * rgb[0] + this.xyzMatrix[0][1] * rgb[1] + this.xyzMatrix[0][2] * rgb[2],
+            this.xyzMatrix[1][0] * rgb[0] + this.xyzMatrix[1][1] * rgb[1] + this.xyzMatrix[1][2] * rgb[2],
+            this.xyzMatrix[2][0] * rgb[0] + this.xyzMatrix[2][1] * rgb[1] + this.xyzMatrix[2][2] * rgb[2]
+        ];
     },
 
     componentsFromXYZ: function(xyz){
+        return [
+            this.inverseCurve(this.xyzInverseMatrix[0][0] * xyz[0] + this.xyzInverseMatrix[0][1] * xyz[1] + this.xyzInverseMatrix[0][2] * xyz[2]),
+            this.inverseCurve(this.xyzInverseMatrix[1][0] * xyz[0] + this.xyzInverseMatrix[1][1] * xyz[1] + this.xyzInverseMatrix[1][2] * xyz[2]),
+            this.inverseCurve(this.xyzInverseMatrix[2][0] * xyz[0] + this.xyzInverseMatrix[2][1] * xyz[1] + this.xyzInverseMatrix[2][2] * xyz[2])
+        ];
     },
 
     // MARK: - rgb <-> hsl
@@ -425,7 +464,38 @@ JSClass("JSGrayColorSpace", JSColorSpace, {
         return [
             components[0] + (1.0 - components[0]) * percentage
         ];
-    }
+    },
+
+    g: 2.4,
+    a: 1.0 / 1.055,
+    b: 0.055 / 1.055,
+    c: 1.0 / 12.92,
+    d: 0.04045,
+
+    curve: function(x){
+        return parametricCurve3(x, this.g, this.a, this.b, this.c, this.d);
+    },
+
+    inverseCurve: function(y){
+        y = Math.max(0, Math.min(1, y));
+        return inverseParametricCurve3(y, this.g, this.a, this.b, this.c, this.d);
+    },
+
+    // MARK: - Lab conversions
+
+    xyzFromComponents: function(components){
+        var w = this.curve(components[0]);
+        return [
+            JSColorSpace.Whitepoint.profileConnection[0] * w,
+            JSColorSpace.Whitepoint.profileConnection[1] * w,
+            JSColorSpace.Whitepoint.profileConnection[2] * w
+        ];
+    },
+
+    componentsFromXYZ: function(xyz){
+        var y = Math.min(JSColorSpace.Whitepoint.profileConnection[1], Math.max(0, xyz[1])) / JSColorSpace.Whitepoint.profileConnection[1];
+        return [this.inverseCurve(y)];
+    },
 
 });
 
@@ -622,7 +692,7 @@ Object.defineProperties(JSColorSpace, {
     lab: {
         configurable: true,
         get: function(){
-            var space = JSLabColorSpace.initWithWhitepoint(JSColorSpace.Whitepoint.D50);
+            var space = JSLabColorSpace.init();
             Object.defineProperty(this, "lab", {value: space});
             return space;
         }
@@ -635,4 +705,20 @@ JSColorSpace.Whitepoint = {
     D65: [0.9505, 1.0, 1.08883]
 };
 
+JSColorSpace.Whitepoint.profileConnection = JSColorSpace.Whitepoint.D50;
+
+var parametricCurve3 = function(x, g, a, b, c, d){
+    if (x >= d){
+        return Math.pow(a * x + b, g);
+    }
+    return c * x;
+};
+
+var inverseParametricCurve3 = function(y, g, a, b, c, d){
+    if (y < c * d){
+        return y / c;
+    }
+    return (Math.pow(y, 1.0 / g) - b) / a;
+};
+
 })();

package/Root/Frameworks/Foundation/JSMediaType.js

@@ -17,7 +17,7 @@
 'use strict';
 
 JSGlobalObject.JSMediaType = function(str, parameters){
-    if (str === null || str === undefined){
+    if (str === null || str === undefined || str === ""){
         return null;
     }
     if (this === undefined){