@croct/sdk 0.9.1 → 0.11.0-alpha

package/activeRecord.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActiveRecord = void 0;
-var tslib_1 = require("tslib");
-var schema_1 = require("./schema");
-var operationSchema = {
+const schema_1 = require("./schema");
+const operationSchema = {
     add: schema_1.addOperation,
     set: schema_1.setOperation,
     merge: schema_1.mergeOperation,
@@ -14,11 +13,11 @@ var operationSchema = {
     unset: schema_1.unsetOperation,
     remove: schema_1.removeOperation,
 };
-var ActiveRecord = /** @class */ (function () {
-    function ActiveRecord() {
+class ActiveRecord {
+    constructor() {
         this.operations = [];
     }
-    ActiveRecord.prototype.set = function (propertyOrValue, value) {
+    set(propertyOrValue, value) {
         if (typeof propertyOrValue === 'string') {
             return this.pushOperation({
                 type: 'set',
@@ -31,22 +30,22 @@ var ActiveRecord = /** @class */ (function () {
             path: '.',
             value: propertyOrValue,
         });
-    };
-    ActiveRecord.prototype.add = function (property, value) {
+    }
+    add(property, value) {
         return this.pushOperation({
             type: 'add',
             path: property,
             value: value,
         });
-    };
-    ActiveRecord.prototype.combine = function (property, value) {
+    }
+    combine(property, value) {
         return this.pushOperation({
             type: 'combine',
             path: property,
             value: value,
         });
-    };
-    ActiveRecord.prototype.merge = function (propertyOrValue, value) {
+    }
+    merge(propertyOrValue, value) {
         if (typeof propertyOrValue === 'string') {
             return this.pushOperation({
                 type: 'merge',
@@ -59,58 +58,55 @@ var ActiveRecord = /** @class */ (function () {
             path: '.',
             value: propertyOrValue,
         });
-    };
-    ActiveRecord.prototype.increment = function (property, amount) {
-        if (amount === void 0) { amount = 1; }
+    }
+    increment(property, amount = 1) {
         return this.pushOperation({
             type: 'increment',
             path: property,
             value: amount,
         });
-    };
-    ActiveRecord.prototype.decrement = function (property, amount) {
-        if (amount === void 0) { amount = 1; }
+    }
+    decrement(property, amount = 1) {
         return this.pushOperation({
             type: 'decrement',
             path: property,
             value: amount,
         });
-    };
-    ActiveRecord.prototype.clear = function (property) {
+    }
+    clear(property) {
         return this.pushOperation({
             type: 'clear',
             path: property,
         });
-    };
-    ActiveRecord.prototype.unset = function (property) {
+    }
+    unset(property) {
         return this.pushOperation({
             type: 'unset',
             path: property,
         });
-    };
-    ActiveRecord.prototype.remove = function (property, value) {
+    }
+    remove(property, value) {
         return this.pushOperation({
             type: 'remove',
             path: property,
             value: value,
         });
-    };
-    ActiveRecord.prototype.pushOperation = function (operation) {
-        var type = operation.type, data = tslib_1.__rest(operation, ["type"]);
+    }
+    pushOperation(operation) {
+        const { type, ...data } = operation;
         operationSchema[type].validate(data);
         this.operations.push(operation);
         return this;
-    };
-    ActiveRecord.prototype.reset = function () {
+    }
+    reset() {
         this.operations.splice(0);
         return this;
-    };
-    ActiveRecord.prototype.isDirty = function () {
+    }
+    isDirty() {
         return this.operations.length > 0;
-    };
-    ActiveRecord.prototype.buildPatch = function () {
+    }
+    buildPatch() {
         return { operations: this.operations.slice() };
-    };
-    return ActiveRecord;
-}());
+    }
+}
 exports.ActiveRecord = ActiveRecord;

package/cache/fallbackCache.js

@@ -1,41 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FallbackCache = void 0;
-var tslib_1 = require("tslib");
-var FallbackCache = /** @class */ (function () {
-    function FallbackCache() {
-        var caches = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            caches[_i] = arguments[_i];
-        }
+class FallbackCache {
+    constructor(...caches) {
         this.caches = caches;
     }
-    FallbackCache.prototype.get = function () {
-        var e_1, _a;
-        try {
-            for (var _b = tslib_1.__values(this.caches), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var cache = _c.value;
-                var value = cache.get();
-                if (value !== null) {
-                    return value;
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+    get() {
+        for (const cache of this.caches) {
+            const value = cache.get();
+            if (value !== null) {
+                return value;
             }
-            finally { if (e_1) throw e_1.error; }
         }
         return null;
-    };
-    FallbackCache.prototype.put = function (value) {
-        this.caches.forEach(function (cache) { return cache.put(value); });
-    };
-    FallbackCache.prototype.clear = function () {
-        this.caches.forEach(function (cache) { return cache.clear(); });
-    };
-    return FallbackCache;
-}());
+    }
+    put(value) {
+        this.caches.forEach(cache => cache.put(value));
+    }
+    clear() {
+        this.caches.forEach(cache => cache.clear());
+    }
+}
 exports.FallbackCache = FallbackCache;

package/cache/inMemoryCache.js

@@ -1,20 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryCache = void 0;
-var InMemoryCache = /** @class */ (function () {
-    function InMemoryCache(cache) {
+class InMemoryCache {
+    constructor(cache) {
         this.cache = cache;
     }
-    InMemoryCache.prototype.get = function () {
+    get() {
         var _a;
         return (_a = this.cache) !== null && _a !== void 0 ? _a : null;
-    };
-    InMemoryCache.prototype.put = function (value) {
+    }
+    put(value) {
         this.cache = value;
-    };
-    InMemoryCache.prototype.clear = function () {
+    }
+    clear() {
         delete this.cache;
-    };
-    return InMemoryCache;
-}());
+    }
+}
 exports.InMemoryCache = InMemoryCache;

package/cache/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalStorageCache = exports.InMemoryCache = exports.FallbackCache = void 0;
-var tslib_1 = require("tslib");
+const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./cache"), exports);
 var fallbackCache_1 = require("./fallbackCache");
 Object.defineProperty(exports, "FallbackCache", { enumerable: true, get: function () { return fallbackCache_1.FallbackCache; } });

package/cache/localStorageCache.js

@@ -1,50 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalStorageCache = void 0;
-var LocalStorageCache = /** @class */ (function () {
-    function LocalStorageCache(storage, key) {
+class LocalStorageCache {
+    constructor(storage, key) {
         this.listeners = [];
         this.storage = storage;
         this.key = key;
         this.value = storage.getItem(key);
     }
-    LocalStorageCache.autoSync = function (cache) {
-        var listener = cache.sync.bind(cache);
+    static autoSync(cache) {
+        const listener = cache.sync.bind(cache);
         window.addEventListener('storage', listener);
-        return function () { return window.removeEventListener('storage', listener); };
-    };
-    LocalStorageCache.prototype.get = function () {
+        return () => window.removeEventListener('storage', listener);
+    }
+    get() {
         return this.value;
-    };
-    LocalStorageCache.prototype.put = function (value) {
+    }
+    put(value) {
         this.storage.setItem(this.key, value);
         if (this.value !== value) {
             this.value = value;
             this.notifyChange(value);
         }
-    };
-    LocalStorageCache.prototype.clear = function () {
+    }
+    clear() {
         this.storage.removeItem(this.key);
         if (this.value !== null) {
             this.value = null;
             this.notifyChange(null);
         }
-    };
-    LocalStorageCache.prototype.addListener = function (listener) {
+    }
+    addListener(listener) {
         if (!this.listeners.includes(listener)) {
             this.listeners.push(listener);
         }
-    };
-    LocalStorageCache.prototype.removeListener = function (listener) {
-        var index = this.listeners.indexOf(listener);
+    }
+    removeListener(listener) {
+        const index = this.listeners.indexOf(listener);
         if (index > -1) {
             this.listeners.splice(index, 1);
         }
-    };
-    LocalStorageCache.prototype.notifyChange = function (value) {
-        this.listeners.forEach(function (listener) { return listener(value); });
-    };
-    LocalStorageCache.prototype.sync = function (event) {
+    }
+    notifyChange(value) {
+        this.listeners.forEach(listener => listener(value));
+    }
+    sync(event) {
         if (event.storageArea !== this.storage || (event.key !== null && event.key !== this.key)) {
             // Ignore unrelated changes
             return;
@@ -55,12 +55,11 @@ var LocalStorageCache = /** @class */ (function () {
          * In case of cascading changes, it prevents notifying listeners
          * about intermediate states already outdated at this point.
          */
-        var value = this.storage.getItem(this.key);
+        const value = this.storage.getItem(this.key);
         if (this.value !== value) {
             this.value = value;
             this.notifyChange(value);
         }
-    };
-    return LocalStorageCache;
-}());
+    }
+}
 exports.LocalStorageCache = LocalStorageCache;

package/channel/beaconSocketChannel.d.ts

@@ -5,7 +5,7 @@ import { CidAssigner } from '../cid';
 export interface DuplexChannelFactory {
     (url: string, logger: Logger): DuplexChannel<string, string>;
 }
-declare type Configuration = {
+type Configuration = {
     logger?: Logger;
     loggerFactory?: LoggerFactory;
     tokenParameter: string;

package/channel/beaconSocketChannel.js

@@ -1,112 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BeaconSocketChannel = void 0;
-var tslib_1 = require("tslib");
-var logging_1 = require("../logging");
-var BeaconSocketChannel = /** @class */ (function () {
-    function BeaconSocketChannel(configuration) {
+const logging_1 = require("../logging");
+class BeaconSocketChannel {
+    constructor(configuration) {
         var _a, _b;
         this.listeners = [];
         this.connectionIndex = 0;
         this.socketFactory = configuration.channelFactory;
         this.logger = (_a = configuration.logger) !== null && _a !== void 0 ? _a : new logging_1.NullLogger();
-        this.loggerFactory = (_b = configuration.loggerFactory) !== null && _b !== void 0 ? _b : (function () { return new logging_1.NullLogger(); });
+        this.loggerFactory = (_b = configuration.loggerFactory) !== null && _b !== void 0 ? _b : (() => new logging_1.NullLogger());
         this.cidAssigner = configuration.cidAssigner;
         this.cidParameter = configuration.cidParameter;
         this.trackerEndpointUrl = configuration.trackerEndpointUrl;
         this.tokenParameter = configuration.tokenParameter;
         this.notify = this.notify.bind(this);
     }
-    BeaconSocketChannel.prototype.publish = function (_a) {
-        var receiptId = _a.id, message = _a.message;
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _b, token, timestamp, context, payload, _c;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        _b = JSON.parse(message), token = _b.token, timestamp = _b.timestamp, context = _b.context, payload = _b.payload;
-                        if (!(this.token !== token || this.socketChannel === undefined)) return [3 /*break*/, 4];
-                        if (!(this.socketChannel !== undefined)) return [3 /*break*/, 2];
-                        this.logger.info('Connection no longer valid for current message.');
-                        this.socketChannel.unsubscribe(this.notify);
-                        return [4 /*yield*/, this.socketChannel.close()];
-                    case 1:
-                        _d.sent();
-                        _d.label = 2;
-                    case 2:
-                        this.token = token;
-                        _c = this;
-                        return [4 /*yield*/, this.createSocketChannel(token)];
-                    case 3:
-                        _c.socketChannel = _d.sent();
-                        _d.label = 4;
-                    case 4: return [2 /*return*/, this.socketChannel.publish(JSON.stringify({
-                            receiptId: receiptId,
-                            originalTime: timestamp,
-                            departureTime: Date.now(),
-                            context: context,
-                            payload: payload,
-                        }))];
-                }
-            });
-        });
-    };
-    BeaconSocketChannel.prototype.createSocketChannel = function (token) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var endpoint, _a, _b, _c, channel;
-            return tslib_1.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        endpoint = new URL(this.trackerEndpointUrl);
-                        _b = (_a = endpoint.searchParams).append;
-                        _c = [this.cidParameter];
-                        return [4 /*yield*/, this.cidAssigner.assignCid()];
-                    case 1:
-                        _b.apply(_a, _c.concat([_d.sent()]));
-                        if (token !== undefined) {
-                            endpoint.searchParams.append(this.tokenParameter, token);
-                        }
-                        channel = this.socketFactory(endpoint.toString(), this.loggerFactory("WebSocket#".concat(this.connectionIndex)));
-                        this.connectionIndex += 1;
-                        channel.subscribe(this.notify);
-                        return [2 /*return*/, channel];
-                }
-            });
-        });
-    };
-    BeaconSocketChannel.prototype.subscribe = function (listener) {
+    async publish({ id: receiptId, message }) {
+        const { token, timestamp, context, payload } = JSON.parse(message);
+        if (this.token !== token || this.socketChannel === undefined) {
+            if (this.socketChannel !== undefined) {
+                this.logger.info('Connection no longer valid for current message.');
+                this.socketChannel.unsubscribe(this.notify);
+                await this.socketChannel.close();
+            }
+            this.token = token;
+            this.socketChannel = await this.createSocketChannel(token);
+        }
+        return this.socketChannel.publish(JSON.stringify({
+            receiptId: receiptId,
+            originalTime: timestamp,
+            departureTime: Date.now(),
+            context: context,
+            payload: payload,
+        }));
+    }
+    async createSocketChannel(token) {
+        const endpoint = new URL(this.trackerEndpointUrl);
+        endpoint.searchParams.append(this.cidParameter, await this.cidAssigner.assignCid());
+        if (token !== undefined) {
+            endpoint.searchParams.append(this.tokenParameter, token);
+        }
+        const channel = this.socketFactory(endpoint.toString(), this.loggerFactory(`WebSocket#${this.connectionIndex}`));
+        this.connectionIndex += 1;
+        channel.subscribe(this.notify);
+        return channel;
+    }
+    subscribe(listener) {
         if (!this.listeners.includes(listener)) {
             this.listeners.push(listener);
         }
-    };
-    BeaconSocketChannel.prototype.unsubscribe = function (listener) {
-        var index = this.listeners.indexOf(listener);
+    }
+    unsubscribe(listener) {
+        const index = this.listeners.indexOf(listener);
         if (index >= 0) {
             this.listeners.splice(index, 1);
         }
-    };
-    BeaconSocketChannel.prototype.notify = function (message) {
-        var _this = this;
-        var confirmation;
+    }
+    notify(message) {
+        let confirmation;
         try {
             confirmation = JSON.parse(message);
         }
-        catch (_a) {
+        catch {
             this.logger.error('Invalid JSON message received.');
             return;
         }
-        var _b = confirmation.violations, violations = _b === void 0 ? [] : _b, receiptId = confirmation.receiptId;
-        violations.forEach(function (violation) { return _this.logger.error(violation.message); });
+        const { violations = [], receiptId } = confirmation;
+        violations.forEach(violation => this.logger.error(violation.message));
         if (receiptId !== null) {
-            this.listeners.forEach(function (dispatch) { return dispatch(receiptId); });
+            this.listeners.forEach(dispatch => dispatch(receiptId));
         }
-    };
-    BeaconSocketChannel.prototype.close = function () {
+    }
+    close() {
         if (this.socketChannel === undefined) {
             return Promise.resolve();
         }
         return this.socketChannel.close();
-    };
-    return BeaconSocketChannel;
-}());
+    }
+}
 exports.BeaconSocketChannel = BeaconSocketChannel;

package/channel/channel.d.ts

@@ -4,7 +4,7 @@ export interface Closeable {
 export interface OutputChannel<O> extends Closeable {
     publish(message: O): Promise<void>;
 }
-export declare type ChannelListener<T> = {
+export type ChannelListener<T> = {
     (message: T): void;
 };
 export interface InputChannel<I> extends Closeable {

package/channel/encodedChannel.js

@@ -1,18 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EncodedChannel = void 0;
-var EncodedChannel = /** @class */ (function () {
-    function EncodedChannel(channel, encoder) {
+class EncodedChannel {
+    constructor(channel, encoder) {
         this.channel = channel;
         this.encode = encoder;
     }
-    EncodedChannel.prototype.publish = function (message) {
-        var _this = this;
-        return this.encode(message).then((function (result) { return _this.channel.publish(result); }));
-    };
-    EncodedChannel.prototype.close = function () {
+    publish(message) {
+        return this.encode(message).then((result => this.channel.publish(result)));
+    }
+    close() {
         return this.channel.close();
-    };
-    return EncodedChannel;
-}());
+    }
+}
 exports.EncodedChannel = EncodedChannel;

package/channel/guaranteedChannel.d.ts

@@ -1,19 +1,19 @@
 import { Logger } from '../logging';
 import { DuplexChannel, OutputChannel } from './channel';
-export declare type MessageStamper<M, S> = {
+export type MessageStamper<M, S> = {
     generate(message: M): S;
 };
 export declare class TimeStamper implements MessageStamper<any, string> {
     generate(): string;
 }
-export declare type Envelope<M, S> = {
+export type Envelope<M, S> = {
     id: S;
     message: M;
 };
-declare type Options = {
+type Options = {
     ackTimeout: number;
 };
-declare type Configuration<M, S> = Partial<Options> & {
+type Configuration<M, S> = Partial<Options> & {
     channel: DuplexChannel<S, Envelope<M, S>>;
     stamper: MessageStamper<M, S>;
     logger?: Logger;