@croct/sdk 0.9.1 → 0.11.0-alpha

package/facade/trackerFacade.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrackerFacade = void 0;
-var tslib_1 = require("tslib");
-var error_1 = require("../error");
-var schema_1 = require("../schema");
-var eventSchemas = {
+const error_1 = require("../error");
+const schema_1 = require("../schema");
+const eventSchemas = {
     cartViewed: schema_1.cartViewed,
     cartModified: schema_1.cartModified,
     checkoutStarted: schema_1.checkoutStarted,
@@ -17,6 +16,18 @@ var eventSchemas = {
     goalCompleted: schema_1.goalCompleted,
     linkOpened: schema_1.linkOpened,
 };
+function validateEvent(event) {
+    const { type, ...payload } = event;
+    if (!(type in eventSchemas)) {
+        throw new Error(`Unknown event type '${type}'.`);
+    }
+    try {
+        eventSchemas[type].validate(payload);
+    }
+    catch (violation) {
+        throw new Error(`Invalid event payload: ${(0, error_1.formatCause)(violation)}`);
+    }
+}
 function createEvent(type, payload) {
     if (typeof type !== 'string') {
         throw new Error('The event type must of type string.');
@@ -24,48 +35,31 @@ function createEvent(type, payload) {
     if (typeof payload !== 'object' || payload == null) {
         throw new Error('The event payload must of type object.');
     }
-    var event = tslib_1.__assign({ type: type }, payload);
+    const event = { type: type, ...payload };
     validateEvent(event);
     return event;
 }
-function validateEvent(event) {
-    var type = event.type, payload = tslib_1.__rest(event, ["type"]);
-    if (!(type in eventSchemas)) {
-        throw new Error("Unknown event type '".concat(type, "'."));
-    }
-    try {
-        eventSchemas[type].validate(payload);
-    }
-    catch (violation) {
-        throw new Error("Invalid event payload: ".concat((0, error_1.formatCause)(violation)));
-    }
-}
-var TrackerFacade = /** @class */ (function () {
-    function TrackerFacade(tracker) {
+class TrackerFacade {
+    constructor(tracker) {
         this.tracker = tracker;
     }
-    Object.defineProperty(TrackerFacade.prototype, "flushed", {
-        get: function () {
-            return this.tracker.flushed;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    TrackerFacade.prototype.enable = function () {
+    get flushed() {
+        return this.tracker.flushed;
+    }
+    enable() {
         this.tracker.enable();
-    };
-    TrackerFacade.prototype.disable = function () {
+    }
+    disable() {
         this.tracker.disable();
-    };
-    TrackerFacade.prototype.addListener = function (listener) {
+    }
+    addListener(listener) {
         this.tracker.addListener(listener);
-    };
-    TrackerFacade.prototype.removeListener = function (listener) {
+    }
+    removeListener(listener) {
         this.tracker.removeListener(listener);
-    };
-    TrackerFacade.prototype.track = function (type, payload) {
+    }
+    track(type, payload) {
         return this.tracker.track(createEvent(type, payload));
-    };
-    return TrackerFacade;
-}());
+    }
+}
 exports.TrackerFacade = TrackerFacade;

package/facade/userFacade.js

@@ -1,21 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserFacade = void 0;
-var userPatch_1 = require("./userPatch");
-var UserFacade = /** @class */ (function () {
-    function UserFacade(context, tracker) {
+const userPatch_1 = require("./userPatch");
+class UserFacade {
+    constructor(context, tracker) {
         this.context = context;
         this.tracker = tracker;
     }
-    UserFacade.prototype.isIdentified = function () {
+    isIdentified() {
         return !this.isAnonymous();
-    };
-    UserFacade.prototype.isAnonymous = function () {
+    }
+    isAnonymous() {
         return this.context.isAnonymous();
-    };
-    UserFacade.prototype.edit = function () {
+    }
+    edit() {
         return new userPatch_1.UserPatch(this.tracker);
-    };
-    return UserFacade;
-}());
+    }
+}
 exports.UserFacade = UserFacade;

package/facade/userPatch.js

@@ -1,16 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserPatch = void 0;
-var tslib_1 = require("tslib");
-var activeRecord_1 = require("../activeRecord");
-var UserPatch = /** @class */ (function (_super) {
-    tslib_1.__extends(UserPatch, _super);
-    function UserPatch(tracker) {
-        var _this = _super.call(this) || this;
-        _this.tracker = tracker;
-        return _this;
+const activeRecord_1 = require("../activeRecord");
+class UserPatch extends activeRecord_1.ActiveRecord {
+    constructor(tracker) {
+        super();
+        this.tracker = tracker;
     }
-    UserPatch.prototype.save = function () {
+    save() {
         if (!this.isDirty()) {
             // Empty patch
             return Promise.resolve({
@@ -18,13 +15,12 @@ var UserPatch = /** @class */ (function (_super) {
                 patch: { operations: [] },
             });
         }
-        var promise = this.tracker.track({
+        const promise = this.tracker.track({
             type: 'userProfileChanged',
             patch: this.buildPatch(),
         });
         this.reset();
         return promise;
-    };
-    return UserPatch;
-}(activeRecord_1.ActiveRecord));
+    }
+}
 exports.UserPatch = UserPatch;

package/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = exports.Sdk = void 0;
-var constants_1 = require("./constants");
+const constants_1 = require("./constants");
 Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return constants_1.VERSION; } });
-var sdk_1 = require("./sdk");
+const sdk_1 = require("./sdk");
 Object.defineProperty(exports, "Sdk", { enumerable: true, get: function () { return sdk_1.Sdk; } });

package/logging/consoleLogger.js

@@ -1,44 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleLogger = void 0;
-var ConsoleLogger = /** @class */ (function () {
-    function ConsoleLogger(namespace) {
+class ConsoleLogger {
+    constructor(namespace) {
         this.namespace = namespace;
     }
-    Object.defineProperty(ConsoleLogger.prototype, "debug", {
-        get: function () {
-            return this.bind(window.console.debug);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConsoleLogger.prototype, "info", {
-        get: function () {
-            return this.bind(window.console.info);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConsoleLogger.prototype, "warn", {
-        get: function () {
-            return this.bind(window.console.warn);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ConsoleLogger.prototype, "error", {
-        get: function () {
-            return this.bind(window.console.error);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ConsoleLogger.prototype.bind = function (method) {
+    get debug() {
+        return this.bind(window.console.debug);
+    }
+    get info() {
+        return this.bind(window.console.info);
+    }
+    get warn() {
+        return this.bind(window.console.warn);
+    }
+    get error() {
+        return this.bind(window.console.error);
+    }
+    bind(method) {
         if (this.namespace !== undefined) {
-            return method.bind(window.console, "[".concat(this.namespace, "]"));
+            return method.bind(window.console, `[${this.namespace}]`);
         }
         return method.bind(window.console);
-    };
-    return ConsoleLogger;
-}());
+    }
+}
 exports.ConsoleLogger = ConsoleLogger;

package/logging/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NullLogger = exports.NamespacedLogger = exports.ConsoleLogger = void 0;
-var tslib_1 = require("tslib");
+const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./logger"), exports);
 var consoleLogger_1 = require("./consoleLogger");
 Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return consoleLogger_1.ConsoleLogger; } });

package/logging/namespacedLogger.js

@@ -1,26 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NamespacedLogger = void 0;
-var NamespacedLogger = /** @class */ (function () {
-    function NamespacedLogger(logger, namespace) {
+class NamespacedLogger {
+    constructor(logger, namespace) {
         this.logger = logger;
         this.namespace = namespace;
     }
-    NamespacedLogger.prototype.debug = function (message) {
+    debug(message) {
         this.logger.debug(this.format(message));
-    };
-    NamespacedLogger.prototype.info = function (message) {
+    }
+    info(message) {
         this.logger.info(this.format(message));
-    };
-    NamespacedLogger.prototype.warn = function (message) {
+    }
+    warn(message) {
         this.logger.warn(this.format(message));
-    };
-    NamespacedLogger.prototype.error = function (message) {
+    }
+    error(message) {
         this.logger.error(this.format(message));
-    };
-    NamespacedLogger.prototype.format = function (message) {
-        return "[".concat(this.namespace, "] ").concat(message);
-    };
-    return NamespacedLogger;
-}());
+    }
+    format(message) {
+        return `[${this.namespace}] ${message}`;
+    }
+}
 exports.NamespacedLogger = NamespacedLogger;

package/logging/nullLogger.js

@@ -1,21 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NullLogger = void 0;
-var NullLogger = /** @class */ (function () {
-    function NullLogger() {
-    }
-    NullLogger.prototype.debug = function () {
+class NullLogger {
+    debug() {
         // suppress debug logs
-    };
-    NullLogger.prototype.info = function () {
+    }
+    info() {
         // suppress info logs
-    };
-    NullLogger.prototype.warn = function () {
+    }
+    warn() {
         // suppress warning logs
-    };
-    NullLogger.prototype.error = function () {
+    }
+    error() {
         // suppress error logs
-    };
-    return NullLogger;
-}());
+    }
+}
 exports.NullLogger = NullLogger;

package/namespacedStorage.js

@@ -1,71 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NamespacedStorage = void 0;
-var tslib_1 = require("tslib");
-var NamespacedStorage = /** @class */ (function () {
-    function NamespacedStorage(storage, namespace) {
+class NamespacedStorage {
+    constructor(storage, namespace) {
         if (namespace === '') {
             throw new Error('The namespace cannot be empty.');
         }
         this.storage = storage;
         this.namespace = namespace;
     }
-    Object.defineProperty(NamespacedStorage.prototype, "length", {
-        get: function () {
-            return this.getKeys().length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    NamespacedStorage.prototype.clear = function () {
-        var e_1, _a;
-        try {
-            for (var _b = tslib_1.__values(this.getKeys()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var key = _c.value;
-                this.storage.removeItem(key);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
+    get length() {
+        return this.getKeys().length;
+    }
+    clear() {
+        for (const key of this.getKeys()) {
+            this.storage.removeItem(key);
         }
-    };
-    NamespacedStorage.prototype.getItem = function (key) {
+    }
+    getItem(key) {
         return this.storage.getItem(this.getPrefixedKey(key));
-    };
-    NamespacedStorage.prototype.key = function (index) {
-        var keys = this.getKeys();
+    }
+    key(index) {
+        const keys = this.getKeys();
         if (index >= keys.length) {
             return null;
         }
         return keys[index].substring(this.namespace.length + 1);
-    };
-    NamespacedStorage.prototype.removeItem = function (key) {
+    }
+    removeItem(key) {
         this.storage.removeItem(this.getPrefixedKey(key));
-    };
-    NamespacedStorage.prototype.setItem = function (key, value) {
+    }
+    setItem(key, value) {
         this.storage.setItem(this.getPrefixedKey(key), value);
-    };
-    NamespacedStorage.prototype.getKeys = function () {
-        var keys = [];
-        var prefix = this.getPrefix();
-        for (var index = 0; index < this.storage.length; index++) {
-            var key = this.storage.key(index);
+    }
+    getKeys() {
+        const keys = [];
+        const prefix = this.getPrefix();
+        for (let index = 0; index < this.storage.length; index++) {
+            const key = this.storage.key(index);
             if (key !== null && key.indexOf(prefix) === 0) {
                 keys.push(key);
             }
         }
         return keys;
-    };
-    NamespacedStorage.prototype.getPrefixedKey = function (key) {
+    }
+    getPrefixedKey(key) {
         return this.getPrefix() + key;
-    };
-    NamespacedStorage.prototype.getPrefix = function () {
-        return "".concat(this.namespace, ".");
-    };
-    return NamespacedStorage;
-}());
+    }
+    getPrefix() {
+        return `${this.namespace}.`;
+    }
+}
 exports.NamespacedStorage = NamespacedStorage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@croct/sdk",
-  "version": "0.9.1",
+  "version": "0.11.0-alpha",
   "description": "Croct SDK for JavaScript.",
   "license": "MIT",
   "author": {
@@ -25,28 +25,25 @@
     "lint": "eslint 'src/**/*.ts' 'test/**/*.ts'",
     "test": "jest -c jest.config.js --coverage",
     "validate": "tsc --noEmit",
-    "build": "tsc"
+    "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
     "@croct/json": "^1.0",
-    "tslib": "^2.3.1"
+    "tslib": "^2.4.1"
   },
   "devDependencies": {
-    "@types/jest": "^26.0.24",
-    "@typescript-eslint/eslint-plugin": "^4.33.0",
-    "@typescript-eslint/parser": "^4.33.0",
-    "eslint": "^7.32.0",
-    "eslint-config-airbnb-base": "^14.2.1",
-    "eslint-plugin-import": "^2.25.4",
-    "eslint-plugin-jest": "^24.7.0",
+    "@croct/eslint-plugin": "^0.6.3",
+    "@types/jest": "^29.2.3",
+    "eslint": "^8.27.0",
     "fetch-mock": "^9.11.0",
-    "jest": "^26.6.3",
-    "jest-websocket-mock": "^2.3.0",
-    "mock-socket": "^9.1.0",
+    "jest": "^29.3.1",
+    "jest-environment-jsdom": "^29.3.1",
+    "jest-extended": "^3.1.0",
+    "jest-websocket-mock": "^2.4.0",
+    "mock-socket": "^9.1.5",
     "node-fetch": "^2.6.7",
-    "temp-dir": "^2.0.0",
-    "ts-jest": "^26.5.6",
-    "typescript": "^4.5.4"
+    "ts-jest": "^29.0.3",
+    "typescript": "^4.8.0"
   },
   "files": [
     "**/*.js",

package/patch.d.ts

@@ -37,7 +37,7 @@ interface removeOperation extends AbstractOperation {
     type: 'remove';
     value: JsonValue;
 }
-export declare type Operation = UnsetOperation | ClearOperation | AddOperation | SetOperation | CombineOperation | MergeOperation | IncrementOperation | DecrementOperation | removeOperation;
+export type Operation = UnsetOperation | ClearOperation | AddOperation | SetOperation | CombineOperation | MergeOperation | IncrementOperation | DecrementOperation | removeOperation;
 export interface Patch {
     operations: Operation[];
 }

package/queue/capacityRestrictedQueue.js

@@ -1,35 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CapacityRestrictedQueue = void 0;
-var CapacityRestrictedQueue = /** @class */ (function () {
-    function CapacityRestrictedQueue(queue, capacity) {
+class CapacityRestrictedQueue {
+    constructor(queue, capacity) {
         this.queue = queue;
         this.capacity = capacity;
     }
-    CapacityRestrictedQueue.prototype.all = function () {
+    all() {
         return this.queue.all();
-    };
-    CapacityRestrictedQueue.prototype.getCapacity = function () {
+    }
+    getCapacity() {
         return this.capacity;
-    };
-    CapacityRestrictedQueue.prototype.isEmpty = function () {
+    }
+    isEmpty() {
         return this.queue.isEmpty();
-    };
-    CapacityRestrictedQueue.prototype.length = function () {
+    }
+    length() {
         return Math.min(this.capacity, this.queue.length());
-    };
-    CapacityRestrictedQueue.prototype.peek = function () {
+    }
+    peek() {
         return this.queue.peek();
-    };
-    CapacityRestrictedQueue.prototype.push = function (value) {
+    }
+    push(value) {
         if (this.queue.length() >= this.capacity) {
             throw new Error('Maximum queue capacity reached.');
         }
         this.queue.push(value);
-    };
-    CapacityRestrictedQueue.prototype.shift = function () {
+    }
+    shift() {
         return this.queue.shift();
-    };
-    return CapacityRestrictedQueue;
-}());
+    }
+}
 exports.CapacityRestrictedQueue = CapacityRestrictedQueue;

package/queue/inMemoryQueue.js

@@ -1,42 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryQueue = void 0;
-var tslib_1 = require("tslib");
-var InMemoryQueue = /** @class */ (function () {
-    function InMemoryQueue() {
-        var _a;
-        var values = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            values[_i] = arguments[_i];
-        }
+class InMemoryQueue {
+    constructor(...values) {
         this.queue = [];
-        (_a = this.queue).unshift.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(values), false));
+        this.queue.unshift(...values);
     }
-    InMemoryQueue.prototype.all = function () {
+    all() {
         return this.queue.slice();
-    };
-    InMemoryQueue.prototype.getCapacity = function () {
+    }
+    getCapacity() {
         return Infinity;
-    };
-    InMemoryQueue.prototype.isEmpty = function () {
+    }
+    isEmpty() {
         return this.queue.length === 0;
-    };
-    InMemoryQueue.prototype.push = function (value) {
+    }
+    push(value) {
         this.queue.push(value);
-    };
-    InMemoryQueue.prototype.peek = function () {
-        return this.queue[0] || null;
-    };
-    InMemoryQueue.prototype.shift = function () {
-        var value = this.queue.shift();
-        if (!value) {
+    }
+    peek() {
+        var _a;
+        return (_a = this.queue[0]) !== null && _a !== void 0 ? _a : null;
+    }
+    shift() {
+        const value = this.queue.shift();
+        if (value === undefined) {
             throw new Error('The queue is empty.');
         }
         return value;
-    };
-    InMemoryQueue.prototype.length = function () {
+    }
+    length() {
         return this.queue.length;
-    };
-    return InMemoryQueue;
-}());
+    }
+}
 exports.InMemoryQueue = InMemoryQueue;

package/queue/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PersistentQueue = exports.MonitoredQueue = exports.InMemoryQueue = exports.CapacityRestrictedQueue = void 0;
-var tslib_1 = require("tslib");
+const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./queue"), exports);
 var capacityRestrictedQueue_1 = require("./capacityRestrictedQueue");
 Object.defineProperty(exports, "CapacityRestrictedQueue", { enumerable: true, get: function () { return capacityRestrictedQueue_1.CapacityRestrictedQueue; } });

package/queue/monitoredQueue.d.ts

@@ -1,7 +1,7 @@
 import { Queue } from './queue';
 import { Logger } from '../logging';
-export declare type QueueStatus = 'halfEmpty' | 'almostEmpty' | 'empty' | 'halfFull' | 'almostFull' | 'full';
-export declare type QueueCallback<T> = {
+export type QueueStatus = 'halfEmpty' | 'almostEmpty' | 'empty' | 'halfFull' | 'almostFull' | 'full';
+export type QueueCallback<T> = {
     (queue: Queue<T>): void;
 };
 export declare class MonitoredQueue<T> implements Queue<T> {