ar_sync 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1998952425317eff3faa4eb8511f2ad0e40a5f5025dbdc3fae6b5ca7916c454f
-  data.tar.gz: 2b5819d226d4f05892e6fda8a639d758d5579414e6e0ce7eb0fe2cddae978da4
+  metadata.gz: 5ce8f54d9f17ebdd9341d3ba5e1087bde5875d5a4f88b5eeddded0602aece480
+  data.tar.gz: 209d8c04edf0d06b42c853eea568e298ccd626438fb64b416a8cc8e82293f0b8
 SHA512:
-  metadata.gz: d8c730609dedb72287c26ae09b39dfbe75aeb2b9e9c41b029e2c90212bb4253383a08e96fa975d00f56eb24154ba34dbe4fc13620654314e7fe061b227465a5b
-  data.tar.gz: 5c5bed249fbc71e1c620aa1d0ef476efbb34492ee28554b86a158181d1f572e6449959b0e2fabd60af16f9b75e33b043e8d7d58dc8b50934949d88784cdc320a
+  metadata.gz: bb0b79346ca7062f69f77254ac4463aba3261ae8419937c64b0a0cb17715b5e97dc4035c76c863bdc87739fb1070ee21c27b034d908839309b83f26462038663
+  data.tar.gz: 2b633cdcff19283fd2626e41751de5e969888e905452f2a86621c39be9eed6a6c467e5abe98d194b120aa7096e370f95a5fdb80439829a47cf60047f9ed0d608

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ar_sync (1.0.4)
+    ar_sync (1.0.5)
       activerecord
       ar_serializer
 

data/core/ActionCableAdapter.js

@@ -1,29 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-class ActionCableAdapter {
-    constructor(actionCableClass) {
+var ActionCableAdapter = /** @class */ (function () {
+    function ActionCableAdapter(actionCableClass) {
         this.connected = true;
         this.actionCableClass = actionCableClass;
-        this.subscribe(Math.random().toString(), () => { });
+        this.subscribe(Math.random().toString(), function () { });
     }
-    subscribe(key, received) {
-        const disconnected = () => {
-            if (!this.connected)
+    ActionCableAdapter.prototype.subscribe = function (key, received) {
+        var _this = this;
+        var disconnected = function () {
+            if (!_this.connected)
                 return;
-            this.connected = false;
-            this.ondisconnect();
+            _this.connected = false;
+            _this.ondisconnect();
         };
-        const connected = () => {
-            if (this.connected)
+        var connected = function () {
+            if (_this.connected)
                 return;
-            this.connected = true;
-            this.onreconnect();
+            _this.connected = true;
+            _this.onreconnect();
         };
         if (!this._cable)
             this._cable = this.actionCableClass.createConsumer();
-        return this._cable.subscriptions.create({ channel: 'SyncChannel', key }, { received, disconnected, connected });
-    }
-    ondisconnect() { }
-    onreconnect() { }
-}
+        return this._cable.subscriptions.create({ channel: 'SyncChannel', key: key }, { received: received, disconnected: disconnected, connected: connected });
+    };
+    ActionCableAdapter.prototype.ondisconnect = function () { };
+    ActionCableAdapter.prototype.onreconnect = function () { };
+    return ActionCableAdapter;
+}());
 exports.default = ActionCableAdapter;

data/core/ArSyncApi.js

@@ -1,79 +1,143 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-async function apiBatchFetch(endpoint, requests) {
-    const headers = {
-        'Accept': 'application/json',
-        'Content-Type': 'application/json'
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
     };
-    const body = JSON.stringify({ requests });
-    const option = { credentials: 'include', method: 'POST', headers, body };
-    if (ArSyncApi.domain)
-        endpoint = ArSyncApi.domain + endpoint;
-    const res = await fetch(endpoint, option);
-    if (res.status === 200)
-        return res.json();
-    throw new Error(res.statusText);
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function apiBatchFetch(endpoint, requests) {
+    return __awaiter(this, void 0, void 0, function () {
+        var headers, body, option, res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    headers = {
+                        'Accept': 'application/json',
+                        'Content-Type': 'application/json'
+                    };
+                    body = JSON.stringify({ requests: requests });
+                    option = { credentials: 'include', method: 'POST', headers: headers, body: body };
+                    if (ArSyncApi.domain)
+                        endpoint = ArSyncApi.domain + endpoint;
+                    return [4 /*yield*/, fetch(endpoint, option)];
+                case 1:
+                    res = _a.sent();
+                    if (res.status === 200)
+                        return [2 /*return*/, res.json()];
+                    throw new Error(res.statusText);
+            }
+        });
+    });
 }
-class ApiFetcher {
-    constructor(endpoint) {
+var ApiFetcher = /** @class */ (function () {
+    function ApiFetcher(endpoint) {
         this.batches = [];
         this.batchFetchTimer = null;
         this.endpoint = endpoint;
     }
-    fetch(request) {
-        return new Promise((resolve, reject) => {
-            this.batches.push([request, { resolve, reject }]);
-            if (this.batchFetchTimer)
+    ApiFetcher.prototype.fetch = function (request) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.batches.push([request, { resolve: resolve, reject: reject }]);
+            if (_this.batchFetchTimer)
                 return;
-            this.batchFetchTimer = setTimeout(() => {
-                this.batchFetchTimer = null;
-                const compacts = {};
-                const requests = [];
-                const callbacksList = [];
-                for (const batch of this.batches) {
-                    const request = batch[0];
-                    const callback = batch[1];
-                    const key = JSON.stringify(request);
+            _this.batchFetchTimer = setTimeout(function () {
+                _this.batchFetchTimer = null;
+                var compacts = {};
+                var requests = [];
+                var callbacksList = [];
+                for (var _i = 0, _a = _this.batches; _i < _a.length; _i++) {
+                    var batch = _a[_i];
+                    var request_1 = batch[0];
+                    var callback = batch[1];
+                    var key = JSON.stringify(request_1);
                     if (compacts[key]) {
                         compacts[key].push(callback);
                     }
                     else {
-                        requests.push(request);
+                        requests.push(request_1);
                         callbacksList.push(compacts[key] = [callback]);
                     }
                 }
-                this.batches = [];
-                ArSyncApi._batchFetch(this.endpoint, requests).then((results) => {
-                    for (const i in callbacksList) {
-                        const result = results[i];
-                        const callbacks = callbacksList[i];
-                        for (const callback of callbacks) {
+                _this.batches = [];
+                ArSyncApi._batchFetch(_this.endpoint, requests).then(function (results) {
+                    for (var i in callbacksList) {
+                        var result = results[i];
+                        var callbacks = callbacksList[i];
+                        for (var _i = 0, callbacks_1 = callbacks; _i < callbacks_1.length; _i++) {
+                            var callback = callbacks_1[_i];
                             if (result.data) {
                                 callback.resolve(result.data);
                             }
                             else {
-                                const error = result.error || { type: 'Unknown Error' };
-                                callback.reject(Object.assign(Object.assign({}, error), { retry: false }));
+                                var error = result.error || { type: 'Unknown Error' };
+                                callback.reject(__assign(__assign({}, error), { retry: false }));
                             }
                         }
                     }
-                }).catch(e => {
-                    const error = { type: e.name, message: e.message, retry: true };
-                    for (const callbacks of callbacksList) {
-                        for (const callback of callbacks)
+                }).catch(function (e) {
+                    var error = { type: e.name, message: e.message, retry: true };
+                    for (var _i = 0, callbacksList_1 = callbacksList; _i < callbacksList_1.length; _i++) {
+                        var callbacks = callbacksList_1[_i];
+                        for (var _a = 0, callbacks_2 = callbacks; _a < callbacks_2.length; _a++) {
+                            var callback = callbacks_2[_a];
                             callback.reject(error);
+                        }
                     }
                 });
             }, 16);
         });
-    }
-}
-const staticFetcher = new ApiFetcher('/static_api');
-const syncFetcher = new ApiFetcher('/sync_api');
-const ArSyncApi = {
+    };
+    return ApiFetcher;
+}());
+var staticFetcher = new ApiFetcher('/static_api');
+var syncFetcher = new ApiFetcher('/sync_api');
+var ArSyncApi = {
     domain: null,
     _batchFetch: apiBatchFetch,
-    fetch: (request) => staticFetcher.fetch(request),
-    syncFetch: (request) => syncFetcher.fetch(request),
+    fetch: function (request) { return staticFetcher.fetch(request); },
+    syncFetch: function (request) { return syncFetcher.fetch(request); },
 };
 exports.default = ArSyncApi;

data/core/ArSyncModel.js

@@ -1,104 +1,107 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ArSyncStore_1 = require("./ArSyncStore");
-const ConnectionManager_1 = require("./ConnectionManager");
-class ArSyncModel {
-    constructor(request, option) {
+var ArSyncStore_1 = require("./ArSyncStore");
+var ConnectionManager_1 = require("./ConnectionManager");
+var ArSyncModel = /** @class */ (function () {
+    function ArSyncModel(request, option) {
+        var _this = this;
         this._ref = ArSyncModel.retrieveRef(request, option);
         this._listenerSerial = 0;
         this._listeners = {};
         this.complete = false;
         this.connected = ArSyncStore_1.default.connectionManager.networkStatus;
-        const setData = () => {
-            this.data = this._ref.model.data;
-            this.complete = this._ref.model.complete;
-            this.notfound = this._ref.model.notfound;
+        var setData = function () {
+            _this.data = _this._ref.model.data;
+            _this.complete = _this._ref.model.complete;
+            _this.notfound = _this._ref.model.notfound;
         };
         setData();
         this.subscribe('load', setData);
         this.subscribe('change', setData);
-        this.subscribe('connection', (status) => {
-            this.connected = status;
+        this.subscribe('connection', function (status) {
+            _this.connected = status;
         });
     }
-    onload(callback) {
+    ArSyncModel.prototype.onload = function (callback) {
         this.subscribeOnce('load', callback);
-    }
-    subscribeOnce(event, callback) {
-        const subscription = this.subscribe(event, (arg) => {
+    };
+    ArSyncModel.prototype.subscribeOnce = function (event, callback) {
+        var subscription = this.subscribe(event, function (arg) {
             callback(arg);
             subscription.unsubscribe();
         });
         return subscription;
-    }
-    dig(path) {
+    };
+    ArSyncModel.prototype.dig = function (path) {
         return ArSyncModel.digData(this.data, path);
-    }
-    static digData(data, path) {
+    };
+    ArSyncModel.digData = function (data, path) {
         function dig(data, path) {
             if (path.length === 0)
                 return data;
             if (data == null)
                 return data;
-            const key = path[0];
-            const other = path.slice(1);
+            var key = path[0];
+            var other = path.slice(1);
             if (Array.isArray(data)) {
-                return this.digData(data.find(el => el.id === key), other);
+                return this.digData(data.find(function (el) { return el.id === key; }), other);
             }
             else {
                 return this.digData(data[key], other);
             }
         }
         return dig(data, path);
-    }
-    subscribe(event, callback) {
-        const id = this._listenerSerial++;
-        const subscription = this._ref.model.subscribe(event, callback);
-        let unsubscribed = false;
-        const unsubscribe = () => {
+    };
+    ArSyncModel.prototype.subscribe = function (event, callback) {
+        var _this = this;
+        var id = this._listenerSerial++;
+        var subscription = this._ref.model.subscribe(event, callback);
+        var unsubscribed = false;
+        var unsubscribe = function () {
             unsubscribed = true;
             subscription.unsubscribe();
-            delete this._listeners[id];
+            delete _this._listeners[id];
         };
         if (this.complete) {
             if (event === 'load')
-                setTimeout(() => {
+                setTimeout(function () {
                     if (!unsubscribed)
                         callback();
                 }, 0);
             if (event === 'change')
-                setTimeout(() => {
+                setTimeout(function () {
                     if (!unsubscribed)
-                        callback({ path: [], value: this.data });
+                        callback({ path: [], value: _this.data });
                 }, 0);
         }
-        return this._listeners[id] = { unsubscribe };
-    }
-    release() {
-        for (const id in this._listeners)
+        return this._listeners[id] = { unsubscribe: unsubscribe };
+    };
+    ArSyncModel.prototype.release = function () {
+        for (var id in this._listeners)
             this._listeners[id].unsubscribe();
         this._listeners = {};
         ArSyncModel._detach(this._ref);
         this._ref = null;
-    }
-    static retrieveRef(request, option) {
-        const key = JSON.stringify([request, option]);
-        let ref = this._cache[key];
+    };
+    ArSyncModel.retrieveRef = function (request, option) {
+        var key = JSON.stringify([request, option]);
+        var ref = this._cache[key];
         if (!ref) {
-            const model = new ArSyncStore_1.default(request, option);
-            ref = this._cache[key] = { key, count: 0, timer: null, model };
+            var model = new ArSyncStore_1.default(request, option);
+            ref = this._cache[key] = { key: key, count: 0, timer: null, model: model };
         }
         this._attach(ref);
         return ref;
-    }
-    static _detach(ref) {
+    };
+    ArSyncModel._detach = function (ref) {
+        var _this = this;
         ref.count--;
-        const timeout = this.cacheTimeout;
+        var timeout = this.cacheTimeout;
         if (ref.count !== 0)
             return;
-        const timedout = () => {
+        var timedout = function () {
             ref.model.release();
-            delete this._cache[ref.key];
+            delete _this._cache[ref.key];
         };
         if (timeout) {
             ref.timer = setTimeout(timedout, timeout);
@@ -106,28 +109,34 @@ class ArSyncModel {
         else {
             timedout();
         }
-    }
-    static _attach(ref) {
+    };
+    ArSyncModel._attach = function (ref) {
         ref.count++;
         if (ref.timer)
             clearTimeout(ref.timer);
-    }
-    static setConnectionAdapter(adapter) {
+    };
+    ArSyncModel.setConnectionAdapter = function (adapter) {
         ArSyncStore_1.default.connectionManager = new ConnectionManager_1.default(adapter);
-    }
-    static waitForLoad(...models) {
-        return new Promise((resolve) => {
-            let count = 0;
-            for (const model of models) {
-                model.onload(() => {
+    };
+    ArSyncModel.waitForLoad = function () {
+        var models = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            models[_i] = arguments[_i];
+        }
+        return new Promise(function (resolve) {
+            var count = 0;
+            for (var _i = 0, models_1 = models; _i < models_1.length; _i++) {
+                var model = models_1[_i];
+                model.onload(function () {
                     count++;
                     if (models.length == count)
                         resolve(models);
                 });
             }
         });
-    }
-}
+    };
+    ArSyncModel._cache = {};
+    ArSyncModel.cacheTimeout = 10 * 1000;
+    return ArSyncModel;
+}());
 exports.default = ArSyncModel;
-ArSyncModel._cache = {};
-ArSyncModel.cacheTimeout = 10 * 1000;