ar_sync 1.0.4 → 1.0.5

data/core/ConnectionManager.js

@@ -1,75 +1,80 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-class ConnectionManager {
-    constructor(adapter) {
+var ConnectionManager = /** @class */ (function () {
+    function ConnectionManager(adapter) {
+        var _this = this;
         this.subscriptions = {};
         this.adapter = adapter;
         this.networkListeners = {};
         this.networkListenerSerial = 0;
         this.networkStatus = true;
-        adapter.ondisconnect = () => {
-            this.unsubscribeAll();
-            this.triggerNetworkChange(false);
+        adapter.ondisconnect = function () {
+            _this.unsubscribeAll();
+            _this.triggerNetworkChange(false);
         };
-        adapter.onreconnect = () => this.triggerNetworkChange(true);
+        adapter.onreconnect = function () { return _this.triggerNetworkChange(true); };
     }
-    triggerNetworkChange(status) {
+    ConnectionManager.prototype.triggerNetworkChange = function (status) {
         if (this.networkStatus == status)
             return;
         this.networkStatus = status;
-        for (const id in this.networkListeners)
+        for (var id in this.networkListeners)
             this.networkListeners[id](status);
-    }
-    unsubscribeAll() {
-        for (const id in this.subscriptions) {
-            const subscription = this.subscriptions[id];
+    };
+    ConnectionManager.prototype.unsubscribeAll = function () {
+        for (var id in this.subscriptions) {
+            var subscription = this.subscriptions[id];
             subscription.listeners = {};
             subscription.connection.unsubscribe();
         }
         this.subscriptions = {};
-    }
-    subscribeNetwork(func) {
-        const id = this.networkListenerSerial++;
+    };
+    ConnectionManager.prototype.subscribeNetwork = function (func) {
+        var _this = this;
+        var id = this.networkListenerSerial++;
         this.networkListeners[id] = func;
-        const unsubscribe = () => {
-            delete this.networkListeners[id];
+        var unsubscribe = function () {
+            delete _this.networkListeners[id];
         };
-        return { unsubscribe };
-    }
-    subscribe(key, func) {
-        const subscription = this.connect(key);
-        const id = subscription.serial++;
+        return { unsubscribe: unsubscribe };
+    };
+    ConnectionManager.prototype.subscribe = function (key, func) {
+        var _this = this;
+        var subscription = this.connect(key);
+        var id = subscription.serial++;
         subscription.ref++;
         subscription.listeners[id] = func;
-        const unsubscribe = () => {
+        var unsubscribe = function () {
             if (!subscription.listeners[id])
                 return;
             delete subscription.listeners[id];
             subscription.ref--;
             if (subscription.ref === 0)
-                this.disconnect(key);
+                _this.disconnect(key);
         };
-        return { unsubscribe };
-    }
-    connect(key) {
+        return { unsubscribe: unsubscribe };
+    };
+    ConnectionManager.prototype.connect = function (key) {
+        var _this = this;
         if (this.subscriptions[key])
             return this.subscriptions[key];
-        const connection = this.adapter.subscribe(key, data => this.received(key, data));
-        return this.subscriptions[key] = { connection, listeners: {}, ref: 0, serial: 0 };
-    }
-    disconnect(key) {
-        const subscription = this.subscriptions[key];
+        var connection = this.adapter.subscribe(key, function (data) { return _this.received(key, data); });
+        return this.subscriptions[key] = { connection: connection, listeners: {}, ref: 0, serial: 0 };
+    };
+    ConnectionManager.prototype.disconnect = function (key) {
+        var subscription = this.subscriptions[key];
         if (!subscription || subscription.ref !== 0)
             return;
         delete this.subscriptions[key];
         subscription.connection.unsubscribe();
-    }
-    received(key, data) {
-        const subscription = this.subscriptions[key];
+    };
+    ConnectionManager.prototype.received = function (key, data) {
+        var subscription = this.subscriptions[key];
         if (!subscription)
             return;
-        for (const id in subscription.listeners)
+        for (var id in subscription.listeners)
             subscription.listeners[id](data);
-    }
-}
+    };
+    return ConnectionManager;
+}());
 exports.default = ConnectionManager;

data/core/hooks.d.ts

@@ -1,10 +1,14 @@
 declare let useState: <T>(t: T | (() => T)) => [T, (t: T | ((t: T) => T)) => void];
 declare let useEffect: (f: (() => void) | (() => (() => void)), deps: any[]) => void;
 declare let useMemo: <T>(f: () => T, deps: any[]) => T;
+declare let useRef: <T>(value: T) => {
+    current: T;
+};
 declare type InitializeHooksParams = {
     useState: typeof useState;
     useEffect: typeof useEffect;
     useMemo: typeof useMemo;
+    useRef: typeof useRef;
 };
 export declare function initializeHooks(hooks: InitializeHooksParams): void;
 interface ModelStatus {

data/core/hooks.js

@@ -1,37 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ArSyncApi_1 = require("./ArSyncApi");
-const ArSyncModel_1 = require("./ArSyncModel");
-let useState;
-let useEffect;
-let useMemo;
+var ArSyncApi_1 = require("./ArSyncApi");
+var ArSyncModel_1 = require("./ArSyncModel");
+var useState;
+var useEffect;
+var useMemo;
+var useRef;
 function initializeHooks(hooks) {
     useState = hooks.useState;
     useEffect = hooks.useEffect;
     useMemo = hooks.useMemo;
+    useRef = hooks.useRef;
 }
 exports.initializeHooks = initializeHooks;
 function checkHooks() {
     if (!useState)
-        throw 'uninitialized. needs `initializeHooks({ useState, useEffect, useMemo })`';
+        throw 'uninitialized. needs `initializeHooks({ useState, useEffect, useMemo, useRef })`';
 }
-const initialResult = [null, { complete: false, notfound: undefined, connected: true }];
+var initialResult = [null, { complete: false, notfound: undefined, connected: true }];
 function useArSyncModel(request) {
     checkHooks();
-    const [result, setResult] = useState(initialResult);
-    const requestString = JSON.stringify(request && request.params);
-    useEffect(() => {
+    var _a = useState(initialResult), result = _a[0], setResult = _a[1];
+    var requestString = JSON.stringify(request && request.params);
+    var prevRequestStringRef = useRef(requestString);
+    useEffect(function () {
+        prevRequestStringRef.current = requestString;
         if (!request) {
             setResult(initialResult);
-            return () => { };
+            return function () { };
         }
-        const model = new ArSyncModel_1.default(request, { immutable: true });
+        var model = new ArSyncModel_1.default(request, { immutable: true });
         function update() {
-            const { complete, notfound, connected, data } = model;
-            setResult(resultWas => {
-                const [, statusWas] = resultWas;
-                const statusPersisted = statusWas.complete === complete && statusWas.notfound === notfound && statusWas.connected === connected;
-                const status = statusPersisted ? statusWas : { complete, notfound, connected };
+            var complete = model.complete, notfound = model.notfound, connected = model.connected, data = model.data;
+            setResult(function (resultWas) {
+                var dataWas = resultWas[0], statusWas = resultWas[1];
+                var statusPersisted = statusWas.complete === complete && statusWas.notfound === notfound && statusWas.connected === connected;
+                if (dataWas === data && statusPersisted)
+                    return resultWas;
+                var status = statusPersisted ? statusWas : { complete: complete, notfound: notfound, connected: connected };
                 return [data, status];
             });
         }
@@ -41,21 +47,38 @@ function useArSyncModel(request) {
         else {
             setResult(initialResult);
         }
+        model.subscribe('load', update);
         model.subscribe('change', update);
         model.subscribe('connection', update);
-        return () => model.release();
+        return function () { return model.release(); };
     }, [requestString]);
-    return result;
+    return prevRequestStringRef.current === requestString ? result : initialResult;
 }
 exports.useArSyncModel = useArSyncModel;
-const initialFetchState = { data: null, status: { complete: false, notfound: undefined } };
+var initialFetchState = { data: null, status: { complete: false, notfound: undefined } };
+function extractParams(query, output) {
+    if (output === void 0) { output = []; }
+    if (typeof (query) !== 'object' || query == null || Array.isArray(query))
+        return output;
+    if ('params' in query)
+        output.push(query.params);
+    for (var key in query) {
+        extractParams(query[key], output);
+    }
+    return output;
+}
 function useArSyncFetch(request) {
     checkHooks();
-    const [state, setState] = useState(initialFetchState);
-    const requestString = JSON.stringify(request && request.params);
-    const loader = useMemo(() => {
-        let lastLoadId = 0;
-        let timer = null;
+    var _a = useState(initialFetchState), state = _a[0], setState = _a[1];
+    var query = request && request.query;
+    var params = request && request.params;
+    var requestString = useMemo(function () {
+        return JSON.stringify(extractParams(query, [params]));
+    }, [query, params]);
+    var prevRequestStringRef = useRef(requestString);
+    var loader = useMemo(function () {
+        var lastLoadId = 0;
+        var timer = null;
         function cancel() {
             if (timer)
                 clearTimeout(timer);
@@ -64,28 +87,28 @@ function useArSyncFetch(request) {
         }
         function fetch(request, retryCount) {
             cancel();
-            const currentLoadingId = lastLoadId;
-            ArSyncApi_1.default.fetch(request).then((response) => {
+            var currentLoadingId = lastLoadId;
+            ArSyncApi_1.default.fetch(request).then(function (response) {
                 if (currentLoadingId !== lastLoadId)
                     return;
                 setState({ data: response, status: { complete: true, notfound: false } });
-            }).catch(e => {
+            }).catch(function (e) {
                 if (currentLoadingId !== lastLoadId)
                     return;
                 if (!e.retry) {
                     setState({ data: null, status: { complete: true, notfound: true } });
                     return;
                 }
-                timer = setTimeout(() => fetch(request, retryCount + 1), 1000 * Math.min(4 ** retryCount, 30));
+                timer = setTimeout(function () { return fetch(request, retryCount + 1); }, 1000 * Math.min(Math.pow(4, retryCount), 30));
             });
         }
         function update() {
             if (request) {
-                setState(state => {
-                    const { data, status } = state;
+                setState(function (state) {
+                    var data = state.data, status = state.status;
                     if (!status.complete && status.notfound === undefined)
                         return state;
-                    return { data, status: { complete: false, notfound: undefined } };
+                    return { data: data, status: { complete: false, notfound: undefined } };
                 });
                 fetch(request, 0);
             }
@@ -93,13 +116,15 @@ function useArSyncFetch(request) {
                 setState(initialFetchState);
             }
         }
-        return { update, cancel };
+        return { update: update, cancel: cancel };
     }, [requestString]);
-    useEffect(() => {
+    useEffect(function () {
+        prevRequestStringRef.current = requestString;
         setState(initialFetchState);
         loader.update();
-        return () => loader.cancel();
+        return function () { return loader.cancel(); };
     }, [requestString]);
-    return [state.data, state.status, loader.update];
+    var responseState = prevRequestStringRef.current === requestString ? state : initialFetchState;
+    return [responseState.data, responseState.status, loader.update];
 }
 exports.useArSyncFetch = useArSyncFetch;

data/lib/ar_sync/type_script.rb

@@ -75,23 +75,24 @@ module ArSync::TypeScript
     <<~CODE
       import { TypeRequest, ApiNameRequests } from './types'
       import { DataTypeFromRequest as DataTypeFromRequestPair } from 'ar_sync/core/DataType'
-      type DataTypeFromRequest<R extends TypeRequest> = DataTypeFromRequestPair<ApiNameRequests[R['api']], R>
+      export type NeverMatchArgument = { __nevermatch: never }
+      type DataTypeFromRequest<R extends TypeRequest | NeverMatchArgument> = NeverMatchArgument extends R ? never : R extends TypeRequest ? DataTypeFromRequestPair<ApiNameRequests[R['api']], R> : never
       export default DataTypeFromRequest
     CODE
   end
 
   def self.generate_hooks_script
     <<~CODE
-      import { useState, useEffect, useMemo } from 'react'
+      import { useState, useEffect, useMemo, useRef } from 'react'
       import { TypeRequest } from './types'
-      import DataTypeFromRequest from './DataTypeFromRequest'
+      import DataTypeFromRequest, { NeverMatchArgument } from './DataTypeFromRequest'
       import { initializeHooks, useArSyncModel as useArSyncModelBase, useArSyncFetch as useArSyncFetchBase } from 'ar_sync/core/hooks'
-      initializeHooks({ useState, useEffect, useMemo })
-      export function useArSyncModel<R extends TypeRequest>(request: R | null) {
-        return useArSyncModelBase<DataTypeFromRequest<R>>(request)
+      initializeHooks({ useState, useEffect, useMemo, useRef })
+      export function useArSyncModel<R extends TypeRequest | NeverMatchArgument>(request: R | null) {
+        return useArSyncModelBase<DataTypeFromRequest<R>>(request as TypeRequest)
       }
-      export function useArSyncFetch<R extends TypeRequest>(request: R | null) {
-        return useArSyncFetchBase<DataTypeFromRequest<R>>(request)
+      export function useArSyncFetch<R extends TypeRequest | NeverMatchArgument>(request: R | null) {
+        return useArSyncFetchBase<DataTypeFromRequest<R>>(request as TypeRequest)
       }
     CODE
   end

data/lib/ar_sync/version.rb

@@ -1,3 +1,3 @@
 module ArSync
-  VERSION = '1.0.4'
+  VERSION = '1.0.5'
 end

data/src/core/DataType.ts

@@ -83,4 +83,4 @@ type DataTypeBaseFromRequestType<R extends RequestBase, ID> = R extends { _meta?
   : never
 export type DataTypeFromRequest<Req extends RequestBase, R extends RequestBase> = ValidateDataTypeExtraFileds<
   DataTypeFromQuery<DataTypeBaseFromRequestType<Req, R['id']>, R['query']>
->
+>

data/src/core/hooks.ts

@@ -4,18 +4,21 @@ import ArSyncModel from './ArSyncModel'
 let useState: <T>(t: T | (() => T)) => [T, (t: T | ((t: T) => T)) => void]
 let useEffect: (f: (() => void) | (() => (() => void)), deps: any[]) => void
 let useMemo: <T>(f: () => T, deps: any[]) => T
+let useRef: <T>(value: T) => { current: T }
 type InitializeHooksParams = {
   useState: typeof useState
   useEffect: typeof useEffect
   useMemo: typeof useMemo
+  useRef: typeof useRef
 }
 export function initializeHooks(hooks: InitializeHooksParams) {
   useState = hooks.useState
   useEffect = hooks.useEffect
   useMemo = hooks.useMemo
+  useRef = hooks.useRef
 }
 function checkHooks() {
-  if (!useState) throw 'uninitialized. needs `initializeHooks({ useState, useEffect, useMemo })`'
+  if (!useState) throw 'uninitialized. needs `initializeHooks({ useState, useEffect, useMemo, useRef })`'
 }
 
 interface ModelStatus { complete: boolean; notfound?: boolean; connected: boolean }
@@ -27,7 +30,9 @@ export function useArSyncModel<T>(request: Request | null): DataAndStatus<T> {
   checkHooks()
   const [result, setResult] = useState<DataAndStatus<T>>(initialResult)
   const requestString = JSON.stringify(request && request.params)
+  const prevRequestStringRef = useRef(requestString)
   useEffect(() => {
+    prevRequestStringRef.current = requestString
     if (!request) {
       setResult(initialResult)
       return () => {}
@@ -36,8 +41,9 @@ export function useArSyncModel<T>(request: Request | null): DataAndStatus<T> {
     function update() {
       const { complete, notfound, connected, data } = model
       setResult(resultWas => {
-        const [, statusWas] = resultWas
+        const [dataWas, statusWas] = resultWas
         const statusPersisted = statusWas.complete === complete && statusWas.notfound === notfound && statusWas.connected === connected
+        if (dataWas === data && statusPersisted) return resultWas
         const status = statusPersisted ? statusWas : { complete, notfound, connected }
         return [data, status]
       })
@@ -47,21 +53,37 @@ export function useArSyncModel<T>(request: Request | null): DataAndStatus<T> {
     } else {
       setResult(initialResult)
     }
+    model.subscribe('load', update)
     model.subscribe('change', update)
     model.subscribe('connection', update)
     return () => model.release()
   }, [requestString])
-  return result
+  return prevRequestStringRef.current === requestString ? result : initialResult
 }
 
 interface FetchStatus { complete: boolean; notfound?: boolean }
 type DataStatusUpdate<T> = [T | null, FetchStatus, () => void]
 type FetchState<T> = { data: T | null; status: FetchStatus }
 const initialFetchState: FetchState<any> = { data: null, status: { complete: false, notfound: undefined } }
+
+function extractParams(query: unknown, output: any[] = []): any[] {
+  if (typeof(query) !== 'object' || query == null || Array.isArray(query)) return output
+  if ('params' in query) output.push((query as { params: any }).params)
+  for (const key in query) {
+    extractParams(query[key], output)
+  }
+  return output
+}
+
 export function useArSyncFetch<T>(request: Request | null): DataStatusUpdate<T> {
   checkHooks()
   const [state, setState] = useState<FetchState<T>>(initialFetchState)
-  const requestString = JSON.stringify(request && request.params)
+  const query = request && request.query
+  const params = request && request.params
+  const requestString = useMemo(() => {
+    return JSON.stringify(extractParams(query, [params]))
+  }, [query, params])
+  const prevRequestStringRef = useRef(requestString)
   const loader = useMemo(() => {
     let lastLoadId = 0
     let timer: null | number = null
@@ -100,9 +122,11 @@ export function useArSyncFetch<T>(request: Request | null): DataStatusUpdate<T>
     return { update, cancel }
   }, [requestString])
   useEffect(() => {
+    prevRequestStringRef.current = requestString
     setState(initialFetchState)
     loader.update()
     return () => loader.cancel()
   }, [requestString])
-  return [state.data, state.status, loader.update]
+  const responseState = prevRequestStringRef.current === requestString ? state : initialFetchState
+  return [responseState.data, responseState.status, loader.update]
 }

data/tsconfig.json

@@ -1,10 +1,10 @@
 {
   "compilerOptions": {
-    "incremental": true,
     "outDir": ".",
     "rootDir": "./src",
     "module": "commonjs",
-    "target": "es2017",
+    "target": "es5",
+    "lib": ["es2017", "dom"],
     "strictNullChecks": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,