@breakside/jskit 2022.3.0 → 2022.6.1

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: 2022.3.0
+JSBundleVersion: 2022.6.1
 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: 2022.3.0
+JSBundleVersion: 2022.6.1
 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: 2022.3.0
+JSBundleVersion: 2022.6.1
 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.3.0
+JSBundleVersion: 2022.6.1
 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.3.0
+JSBundleVersion: 2022.6.1
 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/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){

package/Root/Frameworks/Foundation/JSUserDefaults.js

@@ -29,12 +29,17 @@ var logger = JSLog("foundation", "user-defaults");
 JSClass("JSUserDefaults", JSObject, {
 
     identifier: JSReadOnlyProperty('_identifier', null),
+    _fileManager: null,
     _defaults: null,
     _values: null,
 
-    initWithIdentifier: function(identifier){
+    initWithIdentifier: function(identifier, fileManager){
+        if (fileManager === undefined){
+            fileManager = JSFileManager.shared;
+        }
+        this._fileManager = fileManager;
         this._identifier = identifier;
-        this._url = JSFileManager.shared.persistentContainerURL.appendingPathComponents(['Preferences', '%s.prefs.json'.sprintf(this._identifier)]);
+        this._url = this._fileManager.persistentContainerURL.appendingPathComponents(['Preferences', '%s.prefs.json'.sprintf(this._identifier)]);
         this._defaults = {};
     },
 
@@ -42,7 +47,7 @@ JSClass("JSUserDefaults", JSObject, {
         if (!completion){
             completion = Promise.completion(Promise.resolveTrue);
         }
-        JSFileManager.shared.contentsAtURL(this._url, function JSUserDefaults_open_contents(data){
+        this._fileManager.contentsAtURL(this._url, function JSUserDefaults_open_contents(data){
             try{
                 if (data !== null){
                     var json = String.initWithData(data, String.Encoding.utf8);
@@ -60,6 +65,19 @@ JSClass("JSUserDefaults", JSObject, {
     },
 
     close: function(completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.resolveTrue);
+        }
+        this.synchronize(function(success){
+            if (success){
+                this._values = null;
+            }
+            completion.call(target, success);
+        }, this);
+        return completion.promise;
+    },
+
+    synchronize: function(completion, target){
         if (!completion){
             completion = Promise.completion(Promise.resolveTrue);
         }
@@ -75,9 +93,6 @@ JSClass("JSUserDefaults", JSObject, {
         }
         if (needsSave){
             this._persist(function JSUserDefaults_close_persisted(success){
-                if (success){
-                    this._values = null;
-                }
                 completion.call(target, success);
             }, this);
         }else{
@@ -89,6 +104,9 @@ JSClass("JSUserDefaults", JSObject, {
     // MARK: - Getting and Setting values
 
     valueForKey: function(key){
+        if (this._values === null){
+            throw new Error("JSUserDefaults is closed, cannot get value.  Be sure to call open() first.");
+        }
         if (key in this._values){
             return this._values[key];
         }
@@ -99,6 +117,9 @@ JSClass("JSUserDefaults", JSObject, {
     },
 
     setValueForKey: function(value, key){
+        if (this._values === null){
+            throw new Error("JSUserDefaults is closed, cannot set value.  Be sure to call open() first.");
+        }
         this._values[key] = value;
         this._persistAfterDelay();
         this._definePropertyForKey(key);
@@ -161,7 +182,7 @@ JSClass("JSUserDefaults", JSObject, {
         }else{
             var data = JSON.stringify(this._values).utf8();
             logger.info("saving user defaults");
-            JSFileManager.shared.createFileAtURL(this._url, data, function JSUserDefaults_persist_createFile(success){
+            this._fileManager.createFileAtURL(this._url, data, function JSUserDefaults_persist_createFile(success){
                 if (!success){
                     logger.error("failed to write user defaults");
                 }else{

package/Root/Frameworks/ImageKit/IKColorProfile.js

@@ -803,47 +803,159 @@ JSClass("IKColorProfileLookupTable8", IKColorProfileType, {
 JSClass("IKColorProfileLookupTable16", IKColorProfileType, {
 
     type: IKColorProfile.DataType.lookupTable16,
+    numberOfInputTableEntries: 0,
+    mumberOfOutputTableEntries: 0,
+    numberOfInputChannels: 0,
+    numberOfOutputChannels: 0,
+    numberOfGridPoints: 0,
+    matrix: null,
+    inputTables: null,
+    outputTables: null,
+    lookupTableDataView: null,
+    stride: 0,
 
     initWithData: function(data){
         IKColorProfileLookupTable16.$super.initWithData.call(this, data);
         var dataView = data.dataView();
-        // TODO:
+        if (data.length < 48){
+            logger.warn("not enough data for lut8 matrix");
+            return null;
+        }
+        this.numberOfInputChannels = dataView.getUint8(8);
+        this.numberOfOutputChannels = dataView.getUint8(9);
+        this.numberOfGridPoints = dataView.getUint8(10);
+        this.matrix = IKMatrix([
+            [s15Fixed16(dataView.getUint32(12)), s15Fixed16(dataView.getUint32(16)), s15Fixed16(dataView.getUint32(20))],
+            [s15Fixed16(dataView.getUint32(24)), s15Fixed16(dataView.getUint32(28)), s15Fixed16(dataView.getUint32(32))],
+            [s15Fixed16(dataView.getUint32(36)), s15Fixed16(dataView.getUint32(40)), s15Fixed16(dataView.getUint32(44))]
+        ]);
+        this.numberOfInputTableEntries = dataView.getUint16(48);
+        this.numberOfOutputTableEntries = dataView.getUint16(50);
+        var offset = 52;
+        var end;
+        var i, j, k;
+        var table;
+        this.stride = this.numberOfOutputChannels + this.numberOfOutputChannels;
+        this.inputTables = [];
+        this.outputTables = [];
+        for (i = 0; i < this.numberOfInputChannels; ++i){
+            this.stride *= this.numberOfGridPoints;
+            end = offset + this.numberOfInputTableEntries + this.numberOfInputTableEntries;
+            if (data.length < end){
+                logger.warn("not enough data for lut16 input tables");
+                return null;
+            }
+            table = [];
+            for (; offset < end; offset += 2){
+                table.push(dataView.getUint16(offset) / 65535.0);
+            }
+            this.inputTables.push(table);
+        }
+        end = offset + this.stride;
+        if (data.length < end){
+            logger.warn("not enough data for lut8 clut");
+            return null;
+        }
+        this.lookupTableDataView = this.data.subdataInRange(JSRange(offset, this.stride)).dataView();
+        offset += this.stride;
+        for (i = 0; i < this.numberOfOutputChannels; ++i){
+            end = offset + this.numberOfOutputTableEntries + this.numberOfOutputTableEntries;
+            if (data.length < end){
+                logger.warn("not enough data for lut8 output tables");
+                return null;
+            }
+            table = [];
+            for (; offset < end; offset += 2){
+                table.push(dataView.getUint16(offset) / 65535.0);
+            }
+            this.outputTables.push(table);
+        }
     },
 
     lookup: function(components){
+        var input = [];
+        var i, j, l;
+        var x, x0, x1;
+        var offsetCount;
+        var offsets = [0];
+        var weights = [1];
+        var w0, w1;
+        var stride = this.stride;
+        var d;
+        for (i = 0; i < this.numberOfInputChannels; ++i){
+            stride /= this.numberOfGridPoints;
+            x = this.inputTables[i][Math.round(Math.max(0, Math.min(1, components[i])) * (this.numberOfInputTableEntries - 1))];
+            x *= (this.numberOfGridPoints - 1);
+            x0 = Math.floor(x);
+            d = x0 * stride;
+            for (j = 0, l = offsets.length; j < l; ++j){
+                offsets[j] += d;
+            }
+            if (x > x0){
+                x1 = x0 + 1;
+                w1 = (x - x0);
+                w0 = 1 - w1;
+                for (j = 0, l = offsets.length; j < l; ++j){
+                    offsets.push(offsets[j] + stride);
+                    weights.push(weights[j] * w1);
+                    weights[j] *= w0;
+                }
+            }
+        }
+        var output = [];
+        for (i = 0; i < this.numberOfOutputChannels; ++i){
+            output.push(0);
+        }
+        var offset;
+        for (i = 0, l = offsets.length; i < l; ++i){
+            offset = offsets[i];
+            for (j = 0; j < this.numberOfOutputChannels; ++j, offset += 2){
+                x = (this.lookupTableDataView.getUint16(offset) / 65535.0) * (this.numberOfOutputTableEntries - 1);
+                x0 = Math.floor(x);
+                if (x0 < x){
+                    x1 = x0 + 1;
+                    w1 = (x - x0);
+                    w0 = 1 - w1;
+                    output[j] += (this.outputTables[j][x0] * w0 + this.outputTables[j][x1] * w1) * weights[i];
+                }else{
+                    output[j] += this.outputTables[j][x0] * weights[i];
+                }
+            }
+        }
+        return output;
     }
 
 });
 
-JSClass("IKColorProfileLookupTableAToB", IKColorProfileType, {
+// JSClass("IKColorProfileLookupTableAToB", IKColorProfileType, {
 
-    type: IKColorProfile.DataType.lookupTableAToB,
+//     type: IKColorProfile.DataType.lookupTableAToB,
 
-    initWithData: function(data){
-        IKColorProfileLookupTableAToB.$super.initWithData.call(this, data);
-        var dataView = data.dataView();
-        // TODO:
-    },
+//     initWithData: function(data){
+//         IKColorProfileLookupTableAToB.$super.initWithData.call(this, data);
+//         var dataView = data.dataView();
+//         // TODO:
+//     },
 
-    lookup: function(components){
-    }
+//     lookup: function(components){
+//     }
 
-});
+// });
 
-JSClass("IKColorProfileLookupTableBToA", IKColorProfileType, {
+// JSClass("IKColorProfileLookupTableBToA", IKColorProfileType, {
 
-    type: IKColorProfile.DataType.lookupTableBToA,
+//     type: IKColorProfile.DataType.lookupTableBToA,
 
-    initWithData: function(data){
-        IKColorProfileLookupTableBToA.$super.initWithData.call(this, data);
-        var dataView = data.dataView();
-        // TODO:
-    },
+//     initWithData: function(data){
+//         IKColorProfileLookupTableBToA.$super.initWithData.call(this, data);
+//         var dataView = data.dataView();
+//         // TODO:
+//     },
 
-    lookup: function(components){
-    }
+//     lookup: function(components){
+//     }
 
-});
+// });
 
 JSClass("IKColorProfileComponentConverter", JSObject, {
 

package/Root/Frameworks/ImageKit/IKMatrix.js

@@ -1,4 +1,4 @@
-// // Copyright 2022 Breakside Inc.
+// Copyright 2022 Breakside Inc.
 //
 // Licensed under the Breakside Public License, Version 1.0 (the "License");
 // you may not use this file except in compliance with the License.

package/Root/Frameworks/ImageKit/Info.yaml

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

package/Root/Frameworks/MediaKit/Info.yaml

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

package/Root/Frameworks/MediaKitUI/Info.yaml

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

package/Root/Frameworks/NotificationKit/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.NotificationKit
-JSBundleVersion: 2022.3.0
+JSBundleVersion: 2022.6.1
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2021 Breakside Inc.
 JSBundleEnvironments: